func (t *triviaChannel) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if strings.ToLower(message.Message()) == t.Answer { t.Lock() defer t.Unlock() if !t.Active { return } ts := t.Scores[message.UserID()] if ts == nil { ts = &triviaScore{} t.Scores[message.UserID()] = ts } ts.Name = message.UserName() ts.Score++ service.SendMessage(message.Channel(), fmt.Sprintf("%s got it! The answer was %s.", message.UserName(), t.Answer)) service.SendMessage(message.Channel(), fmt.Sprintf("%s answered in %d seconds and their score is now %d.", message.UserName(), int(time.Now().Sub(t.Asked).Seconds()), ts.Score)) t.Unanswered = 0 if t.hintChan != nil { close(t.hintChan) t.hintChan = nil } } }
func makeScriptFromMessages(service bruxism.Service, message bruxism.Message, messages []bruxism.Message) *comicgen.Script { speakers := make(map[string]int) avatars := make(map[int]string) script := []*comicgen.Message{} for _, message := range messages { speaker, ok := speakers[message.UserName()] if !ok { speaker = len(speakers) speakers[message.UserName()] = speaker avatars[speaker] = message.UserAvatar() } script = append(script, &comicgen.Message{ Speaker: speaker, Text: message.Message(), Author: message.UserName(), }) } return &comicgen.Script{ Messages: script, Author: fmt.Sprintf(service.UserName()), Avatars: avatars, Type: comicgen.ComicTypeChat, } }
// Message handler. func (p *YouTubeJoinPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if (service.IsBotOwner(message) || service.IsChannelOwner(message)) && bruxism.MatchesCommand(service, "leave", message) { video, ok := p.youtube.VideoIDForChatID(message.Channel()) if ok { channel, ok := p.youtube.ChannelIDForVideoID(video) if ok { p.Unmonitor(channel) } } } }
func (p *topStreamersPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if !service.IsMe(message) { if bruxism.MatchesCommand(service, "topstreamers", message) { n := time.Now() if !n.After(p.lastUpdate.Add(1 * time.Minute)) { if p.lastMessage != "" { service.SendMessage(message.Channel(), fmt.Sprintf("%s *Last updated %s.*", p.lastMessage, humanize.Time(p.lastUpdate))) } return } service.Typing(message.Channel()) p.lastUpdate = n m, err := p.topStreamers(5) if err != nil { service.SendMessage(message.Channel(), "There was an error while requesting the top streamers, please try again later.") return } service.SendMessage(message.Channel(), m) p.lastMessage = m } } }
// MTGCommand is a command for getting information about MTG cards.. func MTGCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) { cardNames := fuzzy.RankFindFold(command, MTGCardNames) if len(cardNames) == 0 { service.SendMessage(message.Channel(), "Could not find a card with that name, sorry.") return } sort.Sort(cardNames) card := MTGCardMap[cardNames[0].Target] rest := "" if card.Text != "" { rest += "\n" } if card.Power != nil { rest += MTGRestReplacer.Replace(fmt.Sprintf("%s/%s", *card.Power, *card.Toughness)) } if card.Loyalty != nil { rest += MTGRestReplacer.Replace(fmt.Sprintf("%d", *card.Loyalty)) } if card.ID != nil { if rest != "" && rest != "\n" { rest += "\n" } rest += fmt.Sprintf("(http://gatherer.wizards.com/Handlers/Image.ashx?multiverseid=%d&type=card)", *card.ID) } if service.Name() == bruxism.DiscordServiceName { service.SendMessage(message.Channel(), fmt.Sprintf("**%s** %s\n*%s*\n%s%s", card.Name, card.ManaCost, card.Type, MTGTextReplacer.Replace(card.Text), rest)) } else { service.SendMessage(message.Channel(), strings.Replace(fmt.Sprintf("%s. %s. %s. %s%s", card.Name, card.Type, card.ManaCost, card.Text, rest), "\n", " ", -1)) } }
// InviteCommand is a command for accepting an invite to a channel. func InviteCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) { if service.Name() == bruxism.DiscordServiceName { discord := service.(*bruxism.Discord) if discord.ApplicationClientID != "" { service.SendMessage(message.Channel(), fmt.Sprintf("Please visit https://discordapp.com/oauth2/authorize?client_id=%s&scope=bot to add %s to your server.", discord.ApplicationClientID, service.UserName())) return } } if len(parts) == 1 { join := parts[0] if service.Name() == bruxism.DiscordServiceName { join = discordInviteID(join) } if err := service.Join(join); err != nil { if service.Name() == bruxism.DiscordServiceName && err == bruxism.ErrAlreadyJoined { service.PrivateMessage(message.UserID(), "I have already joined that server.") return } log.Println("Error joining %s %v", service.Name(), err) } else if service.Name() == bruxism.DiscordServiceName { service.PrivateMessage(message.UserID(), "I have joined that server.") } } }
func emojiMessageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if service.Name() == bruxism.DiscordServiceName && !service.IsMe(message) { if bruxism.MatchesCommand(service, "emoji", message) || bruxism.MatchesCommand(service, "hugemoji", message) { base := "emoji/twitter" if bruxism.MatchesCommand(service, "hugemoji", message) { base = "emoji/twitterhuge" } _, parts := bruxism.ParseCommand(service, message) if len(parts) == 1 { submatches := discordRegex.FindStringSubmatch(parts[0]) if len(submatches) != 0 { h, err := http.Get("https://cdn.discordapp.com/emojis/" + submatches[1] + ".png") if err != nil { return } service.SendFile(message.Channel(), "emoji.png", h.Body) h.Body.Close() return } s := strings.TrimSpace(parts[0]) for i := range s { filename := emojiFile(base, s[i:]) if filename != "" { if f, err := os.Open(fmt.Sprintf("%s/%s.png", base, filename)); err == nil { defer f.Close() service.SendFile(message.Channel(), "emoji.png", f) return } } } } } } }
// Help returns a list of help strings that are printed when the user requests them. func (p *MusicPlugin) Help(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, detailed bool) []string { // Only show help messages for guilds where we have a voice connection c, err := p.discord.Channel(message.Channel()) if err != nil { log.Println("musicplugin: fetching channel err:", err.Error()) return nil } _, ok := p.VoiceConnections[c.GuildID] if !ok { return nil } help := []string{ bruxism.CommandHelp(service, "music", "<command>", "Music Plugin, see `help music`")[0], } if detailed { help = append(help, []string{ "Examples:", bruxism.CommandHelp(service, "music", "join [channelid]", "Join your voice channel or the provided voice channel.")[0], bruxism.CommandHelp(service, "music", "leave", "Leave current voice channel.")[0], bruxism.CommandHelp(service, "music", "play [url]", "Start playing music and optionally enqueue provided url.")[0], bruxism.CommandHelp(service, "music", "info", "Information about this plugin and the currently playing song.")[0], bruxism.CommandHelp(service, "music", "pause", "Pause playback of current song.")[0], bruxism.CommandHelp(service, "music", "resume", "Resume playback of current song.")[0], bruxism.CommandHelp(service, "music", "skip", "Skip current song.")[0], bruxism.CommandHelp(service, "music", "stop", "Stop playing music.")[0], bruxism.CommandHelp(service, "music", "list", "List contents of queue.")[0], bruxism.CommandHelp(service, "music", "clear", "Clear all items from queue.")[0], }...) } return help }
func messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if service.IsMe(message) || !bruxism.MatchesCommand(service, "myson", message) || service.Name() != bruxism.DiscordServiceName { return } discord := service.(*bruxism.Discord) discord.Session.ChannelMessageSendEmbed(message.Channel(), &discordgo.MessageEmbed{ Color: discord.UserColor(service.UserID(), message.Channel()), Description: "Don't ever talk to me or my son ever again.", Author: &discordgo.MessageEmbedAuthor{ Name: discord.NicknameForID(service.UserID(), service.UserName(), message.Channel()), IconURL: discordgo.EndpointUserAvatar(service.UserID(), discord.Session.State.User.Avatar), }, }) }
func (p *streamerPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if !service.IsMe(message) { if bruxism.MatchesCommand(service, "streamer", message) { query, parts := bruxism.ParseCommand(service, message) if len(parts) == 0 { return } r, _ := p.requests[query] if r == nil { r = &streamerPluginRequest{} p.requests[query] = r } n := time.Now() if !n.After(r.lastUpdate.Add(60 * time.Minute)) { if r.lastMessage != "" { service.SendMessage(message.Channel(), fmt.Sprintf("%s *Last updated %s.*", r.lastMessage, humanize.Time(r.lastUpdate))) } return } service.Typing(message.Channel()) r.lastUpdate = n m, err := p.streamer(query, service.Name() == bruxism.DiscordServiceName) if err != nil { service.SendMessage(message.Channel(), "There was an error while requesting the streamer, please try again later.") return } service.SendMessage(message.Channel(), m) r.lastMessage = m } } }
// NumberTriviaCommand is a command for getting number trivial. func NumberTriviaCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) { notfound := true num := rand.Intn(1000) if len(parts) == 1 { if i, err := strconv.Atoi(parts[0]); err == nil { num = i notfound = false } } service.Typing(message.Channel()) str, err := numberTrivia(bot, num, notfound) if err != nil { service.SendMessage(message.Channel(), "There was an error requesting trivia, sorry!") return } service.SendMessage(message.Channel(), str) }
func avatarMessageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if !service.IsMe(message) { if bruxism.MatchesCommand(service, "avatar", message) { query := strings.Join(strings.Split(message.RawMessage(), " ")[1:], " ") id := message.UserID() match := userIDRegex.FindStringSubmatch(query) if match != nil { id = match[1] } discord := service.(*bruxism.Discord) u, err := discord.Session.User(id) if err != nil { return } service.SendMessage(message.Channel(), discordgo.EndpointUserAvatar(u.ID, u.Avatar)) } } }
func (p *playedPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { defer bruxism.MessageRecover() if service.Name() == bruxism.DiscordServiceName && !service.IsMe(message) { if bruxism.MatchesCommand(service, "played", message) { query := strings.Join(strings.Split(message.RawMessage(), " ")[1:], " ") id := message.UserID() match := userIDRegex.FindStringSubmatch(query) if match != nil { id = match[1] } p.Lock() defer p.Unlock() u := p.Users[id] if u == nil { service.SendMessage(message.Channel(), "I haven't seen that user.") return } if len(u.Entries) == 0 { service.SendMessage(message.Channel(), "I haven't seen anything played by that user.") return } lc := humanize.Time(u.LastChanged) u.Update(u.Current, time.Now()) pes := make(byDuration, len(u.Entries)) i := 0 for _, pe := range u.Entries { pes[i] = pe i++ } sort.Sort(pes) messageText := fmt.Sprintf("*First seen %s, last update %s*\n", humanize.Time(u.FirstSeen), lc) for i = 0; i < len(pes) && i < 5; i++ { pe := pes[i] du := pe.Duration ds := "" hours := int(du / time.Hour) if hours > 0 { ds += fmt.Sprintf("%dh ", hours) du -= time.Duration(hours) * time.Hour } minutes := int(du / time.Minute) if minutes > 0 || len(ds) > 0 { ds += fmt.Sprintf("%dm ", minutes) du -= time.Duration(minutes) * time.Minute } seconds := int(du / time.Second) ds += fmt.Sprintf("%ds", seconds) messageText += fmt.Sprintf("**%s**: %s\n", pe.Name, ds) } service.SendMessage(message.Channel(), messageText) } } }
// Message handler. func (p *triviaPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { defer bruxism.MessageRecover() if !service.IsMe(message) && !service.IsPrivate(message) { messageChannel := message.Channel() isCommand := bruxism.MatchesCommand(service, "trivia", message) if isCommand && (service.IsModerator(message) || service.IsBotOwner(message)) { p.Lock() tc := p.Channels[messageChannel] if tc == nil { tc = &triviaChannel{ Channel: messageChannel, Scores: map[string]*triviaScore{}, } p.Channels[messageChannel] = tc } p.Unlock() _, parts := bruxism.ParseCommand(service, message) if len(parts) == 0 { return } switch parts[0] { case "start": theme := "" if len(parts) >= 2 { theme = parts[1] } tc.Start(bot, service, theme) case "stop": tc.Stop(bot, service) } } else { if isCommand { _, parts := bruxism.ParseCommand(service, message) if len(parts) == 0 { return } if parts[0] == "score" { p.RLock() tc := p.Channels[messageChannel] if tc != nil { ts := tc.Scores[message.UserID()] if ts != nil { service.SendMessage(message.Channel(), fmt.Sprintf("%s's score is %d.", message.UserName(), ts.Score)) } else { service.SendMessage(message.Channel(), fmt.Sprintf("%s's score is 0.", message.UserName())) } } p.RUnlock() } return } p.RLock() tc := p.Channels[messageChannel] p.RUnlock() if tc != nil { tc.Message(bot, service, message) } } } }
// Message handler. func (p *livePlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { defer bruxism.MessageRecover() if !service.IsMe(message) { messageChannel := message.Channel() if bruxism.MatchesCommand(service, "live", message) { ticks := "" if service.Name() == bruxism.DiscordServiceName { ticks = "`" } _, parts := bruxism.ParseCommand(service, message) if len(parts) == 0 { service.SendMessage(messageChannel, fmt.Sprintf("Incorrect command. eg: %s%slive [add|remove|list] <%s>%s", ticks, service.CommandPrefix(), "UCGmC0A8mEAPdlELQdP9xJbw", ticks)) } switch parts[0] { case "list": if !service.IsModerator(message) { service.SendMessage(messageChannel, "I'm sorry, you must be the channel owner to list live announcements.") return } list := []string{} p.Lock() for ytChannel := range p.ChannelToYouTubeChannels[messageChannel] { list = append(list, fmt.Sprintf("%s (%s)", p.ytLiveChannel.ChannelName(ytChannel), ytChannel)) } p.Unlock() if len(list) == 0 { service.SendMessage(messageChannel, "No Channels are being announced.") } else { service.SendMessage(messageChannel, fmt.Sprintf("Currently announcing: %s", strings.Join(list, ","))) } case "add": if !service.IsModerator(message) { service.SendMessage(messageChannel, "I'm sorry, you must be the channel owner to add live announcements.") return } if len(parts) != 2 || len(parts[1]) != 24 { service.SendMessage(messageChannel, fmt.Sprintf("Incorrect Channel ID. eg: %s%slive %s %s%s", ticks, service.CommandPrefix(), parts[0], "UCGmC0A8mEAPdlELQdP9xJbw", ticks)) return } err := p.monitor(messageChannel, parts[1]) if err != nil { service.SendMessage(messageChannel, fmt.Sprintf("Could not add Channel ID. %s", err)) return } service.SendMessage(messageChannel, fmt.Sprintf("Messages will be sent here when %s goes live.", p.ytLiveChannel.ChannelName(parts[1]))) case "remove": if !service.IsModerator(message) { service.SendMessage(messageChannel, "I'm sorry, you must be the channel owner to remove live announcements.") return } if len(parts) != 2 || len(parts[1]) != 24 { service.SendMessage(messageChannel, fmt.Sprintf("Incorrect Channel ID. eg: %s%slive %s %s%s", ticks, service.CommandPrefix(), parts[0], "UCGmC0A8mEAPdlELQdP9xJbw", ticks)) return } p.Lock() delete(p.ChannelToYouTubeChannels[messageChannel], parts[1]) delete(p.youTubeChannelToChannels[parts[1]], messageChannel) p.Unlock() service.SendMessage(messageChannel, fmt.Sprintf("Messages will no longer be sent here when %s goes live.", p.ytLiveChannel.ChannelName(parts[1]))) } } } }
func (p *chartPlugin) messageFunc(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if service.IsMe(message) { return } if bruxism.MatchesCommand(service, "chart", message) { query, parts := bruxism.ParseCommand(service, message) if len(parts) == 0 { service.SendMessage(message.Channel(), fmt.Sprintf("Invalid chart eg: %s", p.randomChart(service))) return } start, end := 0.5, 0.5 switch parts[0] { case "up": start, end = 0, 1 case "down": start, end = 1, 0 case "flat": case "straight": default: service.SendMessage(message.Channel(), fmt.Sprintf("Invalid chart direction. eg: %s", p.randomChart(service))) return } axes := strings.Split(query[len(parts[0]):], ",") if len(axes) != 2 { service.SendMessage(message.Channel(), fmt.Sprintf("Invalid chart axis labels eg: %s", p.randomChart(service))) return } pl, err := plot.New() if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Error making chart, sorry! eg: %s", p.randomChart(service))) return } service.Typing(message.Channel()) pl.Y.Label.Text = axes[0] pl.X.Label.Text = axes[1] num := 5 + rand.Intn(15) start *= float64(num) end *= float64(num) pts := make(plotter.XYs, num) for i := range pts { pts[i].X = float64(i) + rand.Float64()*0.5 - 0.2 pts[i].Y = start + float64(end-start)/float64(num-1)*float64(i) + rand.Float64()*0.5 - 0.25 } pl.X.Tick.Label.Color = color.Transparent pl.Y.Tick.Label.Color = color.Transparent pl.X.Min = -0.5 pl.X.Max = float64(num) + 0.5 pl.Y.Min = -0.5 pl.Y.Max = float64(num) + 0.5 lpLine, lpPoints, err := plotter.NewLinePoints(pts) if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your chart.", message.UserName())) } lpLine.Color = plotutil.Color(rand.Int()) lpLine.Width = vg.Points(1 + 0.5*rand.Float64()) lpLine.Dashes = plotutil.Dashes(rand.Int()) lpPoints.Shape = plotutil.Shape(rand.Int()) lpPoints.Color = lpLine.Color pl.Add(lpLine, lpPoints) w, err := pl.WriterTo(320, 240, "png") if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your chart.", message.UserName())) return } b := &bytes.Buffer{} w.WriteTo(b) go func() { if service.Name() == bruxism.DiscordServiceName { discord := service.(*bruxism.Discord) p, err := discord.UserChannelPermissions(message.UserID(), message.Channel()) if err == nil && p&discordgo.PermissionAttachFiles != 0 { service.SendFile(message.Channel(), "chart.png", b) return } } url, err := bot.UploadToImgur(b, "chart.png") if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem uploading the chart to imgur.", message.UserName())) log.Println("Error uploading chart: ", err) return } if service.Name() == bruxism.DiscordServiceName { service.SendMessage(message.Channel(), fmt.Sprintf("Here's your chart <@%s>: %s", message.UserID(), url)) } else { service.SendMessage(message.Channel(), fmt.Sprintf("Here's your chart %s: %s", message.UserName(), url)) } }() } }
func (p *ReminderPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if !service.IsMe(message) { if bruxism.MatchesCommand(service, "remind", message) || bruxism.MatchesCommand(service, "reminder", message) { _, parts := bruxism.ParseCommand(service, message) if len(parts) < 2 { service.SendMessage(message.Channel(), fmt.Sprintf("Invalid reminder, no time or message. eg: %s", p.randomReminder(service))) return } t, r, err := p.parseReminder(parts) now := time.Now() if err != nil || t.Before(now) || t.After(now.Add(time.Hour*24*365+time.Hour)) { service.SendMessage(message.Channel(), fmt.Sprintf("Invalid time. eg: %s", strings.Join(randomTimes, ", "))) return } if r == "" { service.SendMessage(message.Channel(), fmt.Sprintf("Invalid reminder, no message. eg: %s", p.randomReminder(service))) return } requester := message.UserName() if service.Name() == bruxism.DiscordServiceName { requester = fmt.Sprintf("<@%s>", message.UserID()) } err = p.AddReminder(&Reminder{ StartTime: now, Time: t, Requester: requester, Target: message.Channel(), Message: r, IsPrivate: service.IsPrivate(message), }) if err != nil { service.SendMessage(message.Channel(), err.Error()) return } service.SendMessage(message.Channel(), fmt.Sprintf("Reminder set for %s.", humanize.Time(t))) } } }
// Message handler. func (p *MusicPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { defer bruxism.MessageRecover() if service.IsMe(message) { return } if !bruxism.MatchesCommand(service, "music", message) && !bruxism.MatchesCommand(service, "mu", message) { return } _, parts := bruxism.ParseCommand(service, message) if len(parts) == 0 { service.SendMessage(message.Channel(), strings.Join(p.Help(bot, service, message, true), "\n")) return } // Get the Channel (and GuildID) for this channel because it's needed in // a few locations below channel, err := p.discord.Channel(message.Channel()) if err != nil { log.Println("musicplugin: fetching channel err:", err.Error()) return } // grab pointer to this channels voice connection, if exists. vc, vcok := p.VoiceConnections[channel.GuildID] switch parts[0] { case "help": // display extended help information service.SendMessage(message.Channel(), strings.Join(p.Help(bot, service, message, true), "\n")) case "stats": // TODO: maybe provide plugin stats, total channels, total song queues, etc case "join": if !service.IsBotOwner(message) { service.SendMessage(message.Channel(), "Sorry, only bot owner can join, please ask him to run this command.") return } // join the voice channel of the caller or the provided channel ID channelID := "" if len(parts) > 1 { channelID = parts[1] } if channelID == "" { messageUserID := message.UserID() for _, g := range p.discord.Guilds() { for _, v := range g.VoiceStates { if v.UserID == messageUserID { channelID = v.ChannelID } } } if channelID == "" { service.SendMessage(message.Channel(), "I couldn't find you in any voice channels, please join one.") return } } _, err := p.join(channelID) if err != nil { service.SendMessage(message.Channel(), err.Error()) break } service.SendMessage(message.Channel(), "Now, let's play some music!") case "leave": // leave voice channel for this Guild if !service.IsBotOwner(message) { service.SendMessage(message.Channel(), "Sorry, only bot owner can leave, please ask him to run this command.") return } if !vcok { service.SendMessage(message.Channel(), "There is no voice connection for this Guild.") } vc.conn.Close() delete(p.VoiceConnections, channel.GuildID) service.SendMessage(message.Channel(), "Closed voice connection.") case "debug": // enable or disable debug if !vcok { service.SendMessage(message.Channel(), fmt.Sprintf("There is no voice connection for this Guild.")) } vc.Lock() vc.debug = !vc.debug service.SendMessage(message.Channel(), fmt.Sprintf("debug mode set to %v", vc.debug)) vc.Unlock() case "play": // Start queue player and optionally enqueue provided songs p.gostart(vc) for _, v := range parts[1:] { url, err := url.Parse(v) // doesn't check much.. if err != nil { continue } err = p.enqueue(vc, url.String(), service, message) if err != nil { // TODO: Might need improving. service.SendMessage(message.Channel(), err.Error()) } } case "stop": // stop the queue player if vc.close != nil { close(vc.close) vc.close = nil } if vc.control != nil { close(vc.control) vc.control = nil } case "skip": // skip current song if vc.control == nil { return } vc.control <- Skip case "pause": // pause the queue player if vc.control == nil { return } vc.control <- Pause case "resume": // resume the queue player if vc.control == nil { return } vc.control <- Resume case "info": // report player settings, queue info, and current song msg := fmt.Sprintf("`Bruxism MusicPlugin:`\n") msg += fmt.Sprintf("`Voice Channel:` %s\n", vc.ChannelID) msg += fmt.Sprintf("`Queue Size:` %d\n", len(vc.Queue)) if vc.playing == nil { service.SendMessage(message.Channel(), msg) break } msg += fmt.Sprintf("`Now Playing:`\n") msg += fmt.Sprintf("`ID:` %s\n", vc.playing.ID) msg += fmt.Sprintf("`Title:` %s\n", vc.playing.Title) msg += fmt.Sprintf("`Duration:` %ds\n", vc.playing.Duration) msg += fmt.Sprintf("`Remaining:` %ds\n", vc.playing.Remaining) msg += fmt.Sprintf("`Source URL:` <%s>\n", vc.playing.URL) msg += fmt.Sprintf("`Thumbnail:` %s\n", vc.playing.Thumbnail) service.SendMessage(message.Channel(), msg) case "list": // list top items in the queue if len(vc.Queue) == 0 { service.SendMessage(message.Channel(), "The music queue is empty.") return } var msg string i := 1 i2 := 0 for k, v := range vc.Queue { np := "" if vc.playing != nil && *vc.playing == v { np = "**(Now Playing)**" } d := time.Duration(v.Duration) * time.Second msg += fmt.Sprintf("`%.3d:%.15s` **%s** [%s] - *%s* %s\n", k, v.ID, v.Title, d.String(), v.AddedBy, np) if i >= 15 { service.SendMessage(message.Channel(), msg) msg = "" i = 0 i2++ if i2 >= 8 { // limit response to 8 messages (120 songs) return } } i++ } service.SendMessage(message.Channel(), msg) case "clear": // clear all items from the queue vc.Lock() vc.Queue = []song{} vc.Unlock() default: service.SendMessage(message.Channel(), "Unknown music command, try `help music`") } }
// enqueue a song/playlest to a VoiceConnections Queue func (p *MusicPlugin) enqueue(vc *voiceConnection, url string, service bruxism.Service, message bruxism.Message) (err error) { if vc == nil { return fmt.Errorf("Cannot enqueue to nil voice connection.") } if url == "" { return fmt.Errorf("Cannot enqueue an empty string.") } // TODO ////////////////////////////////////////////////////////////////// // need to parse the url and have a way to know what we're doing // 1) option to queue local files // 2) option to queue saved playlists // 3) option to queue URL that can be passed directly to ffmpeg without youtube-dl // 4) option to queue youtube-dl playlist // 5) option to queue youtube-dl song // 6) option to queue youtube-dl search result // right now option 4 and 5 work, only. ////////////////////////////////////////////////////////////////////////// cmd := exec.Command("./youtube-dl", "-i", "-j", "--youtube-skip-dash-manifest", url) if vc.debug { cmd.Stderr = os.Stderr } output, err := cmd.StdoutPipe() if err != nil { log.Println(err) service.SendMessage(message.Channel(), fmt.Sprintf("Error adding song to playlist.")) return } err = cmd.Start() if err != nil { log.Println(err) service.SendMessage(message.Channel(), fmt.Sprintf("Error adding song to playlist.")) return } defer func() { go cmd.Wait() }() scanner := bufio.NewScanner(output) for scanner.Scan() { s := song{} err = json.Unmarshal(scanner.Bytes(), &s) if err != nil { log.Println(err) continue } s.AddedBy = message.UserName() vc.Lock() vc.Queue = append(vc.Queue, s) vc.Unlock() } return }
func (p *comicPlugin) makeComic(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, script *comicgen.Script) { p.Comics++ comic := comicgen.NewComicGen("arial", service.Name() != bruxism.DiscordServiceName) image, err := comic.MakeComic(script) if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was an error creating the comic. %s", message.UserName(), err)) } else { go func() { if service.Name() == bruxism.DiscordServiceName { discord := service.(*bruxism.Discord) p, err := discord.UserChannelPermissions(message.UserID(), message.Channel()) if err == nil && p&discordgo.PermissionAttachFiles != 0 { b := &bytes.Buffer{} err = png.Encode(b, image) if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your comic.", message.UserName())) return } if err := service.SendFile(message.Channel(), "comic.png", b); err == nil { return } } } b := &bytes.Buffer{} err = png.Encode(b, image) if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem creating your comic.", message.UserName())) return } url, err := bot.UploadToImgur(b, "comic.png") if err != nil { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, there was a problem uploading the comic to imgur.", message.UserName())) log.Println("Error uploading comic: ", err) return } if service.Name() == bruxism.DiscordServiceName { service.SendMessage(message.Channel(), fmt.Sprintf("Here's your comic <@%s>: %s", message.UserID(), url)) } else { service.SendMessage(message.Channel(), fmt.Sprintf("Here's your comic %s: %s", message.UserName(), url)) } runtime.GC() }() } }
// StatsCommand returns bot statistics. func StatsCommand(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message, command string, parts []string) { stats := runtime.MemStats{} runtime.ReadMemStats(&stats) w := &tabwriter.Writer{} buf := &bytes.Buffer{} w.Init(buf, 0, 4, 0, ' ', 0) if service.Name() == bruxism.DiscordServiceName { fmt.Fprintf(w, "```\n") } fmt.Fprintf(w, "Bruxism: \t%s\n", bruxism.VersionString) if service.Name() == bruxism.DiscordServiceName { fmt.Fprintf(w, "Discordgo: \t%s\n", discordgo.VERSION) } fmt.Fprintf(w, "Go: \t%s\n", runtime.Version()) fmt.Fprintf(w, "Uptime: \t%s\n", getDurationString(time.Now().Sub(statsStartTime))) fmt.Fprintf(w, "Memory used: \t%s / %s (%s garbage collected)\n", humanize.Bytes(stats.Alloc), humanize.Bytes(stats.Sys), humanize.Bytes(stats.TotalAlloc)) fmt.Fprintf(w, "Concurrent tasks: \t%d\n", runtime.NumGoroutine()) if service.Name() == bruxism.DiscordServiceName { discord := service.(*bruxism.Discord) fmt.Fprintf(w, "Connected servers: \t%d\n", service.ChannelCount()) if len(discord.Sessions) > 1 { shards := 0 for _, s := range discord.Sessions { if s.DataReady { shards++ } } if shards == len(discord.Sessions) { fmt.Fprintf(w, "Shards: \t%d\n", shards) } else { fmt.Fprintf(w, "Shards: \t%d (%d connected)\n", len(discord.Sessions), shards) } guild, err := discord.Channel(message.Channel()) if err == nil { id, err := strconv.Atoi(guild.ID) if err == nil { fmt.Fprintf(w, "Current shard: \t%d\n", ((id>>22)%len(discord.Sessions) + 1)) } } } } else { fmt.Fprintf(w, "Connected channels: \t%d\n", service.ChannelCount()) } plugins := bot.Services[service.Name()].Plugins names := []string{} for _, plugin := range plugins { names = append(names, plugin.Name()) sort.Strings(names) } for _, name := range names { stats := plugins[name].Stats(bot, service, message) for _, stat := range stats { fmt.Fprint(w, stat) } } if service.Name() == bruxism.DiscordServiceName { fmt.Fprintf(w, "\n```") } w.Flush() out := buf.String() end := "" if IsSeptapus { end += "Septapus community: <https://discord.gg/HWN9pwj>\nPatreon: <https://www.patreon.com/iopred>\nBuilt with love by iopred." } if service.SupportsMultiline() { if end != "" { out += "\n" + end } service.SendMessage(message.Channel(), out) } else { service.SendMessage(message.Channel(), strings.Join(strings.Split(out, "\n"), " ")) service.SendMessage(message.Channel(), strings.Join(strings.Split(end, "\n"), " ")) } }
// Message handler. func (p *comicPlugin) Message(bot *bruxism.Bot, service bruxism.Service, message bruxism.Message) { if service.IsMe(message) { return } p.Lock() defer p.Unlock() log, ok := p.log[message.Channel()] if !ok { log = []bruxism.Message{} } if bruxism.MatchesCommand(service, "customcomic", message) || bruxism.MatchesCommand(service, "customcomicsimple", message) { ty := comicgen.ComicTypeChat if bruxism.MatchesCommand(service, "customcomicsimple", message) { ty = comicgen.ComicTypeSimple } service.Typing(message.Channel()) str, _ := bruxism.ParseCommand(service, message) messages := []*comicgen.Message{} splits := strings.Split(str, "|") for _, line := range splits { line := strings.Trim(line, " ") text := "" speaker := 0 author := "" if strings.Index(line, ":") != -1 { lineSplit := strings.Split(line, ":") author = strings.ToLower(strings.Trim(lineSplit[0], " ")) var err error speaker, err = strconv.Atoi(author) if err != nil { speaker = -1 } text = strings.Trim(lineSplit[1], " ") } else { text = line } messages = append(messages, &comicgen.Message{ Speaker: speaker, Text: text, Author: author, }) } if len(messages) == 0 { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, you didn't add any text.", message.UserName())) return } p.makeComic(bot, service, message, &comicgen.Script{ Messages: messages, Author: fmt.Sprintf(service.UserName()), Type: ty, }) } else if bruxism.MatchesCommand(service, "comic", message) { if len(log) == 0 { service.SendMessage(message.Channel(), fmt.Sprintf("Sorry %s, I don't have enough messages to make a comic yet.", message.UserName())) return } service.Typing(message.Channel()) lines := 0 linesString, parts := bruxism.ParseCommand(service, message) if len(parts) > 0 { lines, _ = strconv.Atoi(linesString) } if lines <= 0 { lines = 1 + int(math.Floor((math.Pow(2*rand.Float64()-1, 3)/2+0.5)*float64(5))) } if lines > len(log) { lines = len(log) } p.makeComic(bot, service, message, makeScriptFromMessages(service, message, log[len(log)-lines:])) } else { // Don't append commands. if bruxism.MatchesCommand(service, "", message) { return } switch message.Type() { case bruxism.MessageTypeCreate: if len(log) < 10 { log = append(log, message) } else { log = append(log[1:], message) } case bruxism.MessageTypeUpdate: for i, m := range log { if m.MessageID() == message.MessageID() { log[i] = message break } } case bruxism.MessageTypeDelete: for i, m := range log { if m.MessageID() == message.MessageID() { log = append(log[:i], log[i+1:]...) break } } } p.log[message.Channel()] = log } }