341 lines
9.8 KiB
Go
341 lines
9.8 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"math/rand"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
|
|
"github.com/bwmarrin/discordgo"
|
|
|
|
"github.com/vartanbeno/go-reddit/v2/reddit"
|
|
)
|
|
|
|
var config Config
|
|
|
|
func init() {
|
|
loadedConfig, err := Load()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
config = *loadedConfig
|
|
}
|
|
|
|
func GetPostsFromReddit(subreddit string) (string, error) {
|
|
if subreddit == "" {
|
|
return "", fmt.Errorf("subreddit cannot be empty")
|
|
}
|
|
|
|
client, err := reddit.NewReadonlyClient()
|
|
if err != nil {
|
|
log.Println("Failed to create Reddit client:", err)
|
|
return "", err
|
|
}
|
|
|
|
posts, _, err := client.Subreddit.TopPosts(context.Background(), subreddit, &reddit.ListPostOptions{
|
|
ListOptions: reddit.ListOptions{
|
|
Limit: 100,
|
|
},
|
|
Time: "all",
|
|
})
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to get posts from Reddit: %v", err)
|
|
}
|
|
|
|
// Check if the subreddit exists
|
|
if len(posts) == 0 {
|
|
return "", fmt.Errorf("subreddit '%v' does not exist", subreddit)
|
|
}
|
|
|
|
// [Title](<https://old.reddit.com{Permalink}>)\n{URL}
|
|
randInt := rand.Intn(len(posts))
|
|
discordMessage := fmt.Sprintf("[%v](<https://old.reddit.com%v>)\n%v", posts[randInt].Title, posts[randInt].Permalink, posts[randInt].URL)
|
|
|
|
return discordMessage, nil
|
|
|
|
}
|
|
|
|
func handleRedditCommand(s *discordgo.Session, i *discordgo.InteractionCreate, subreddit string) {
|
|
post, err := GetPostsFromReddit(subreddit)
|
|
if err != nil {
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: fmt.Sprintf("Cannot get a random post: %v", err),
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
return
|
|
}
|
|
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: post,
|
|
},
|
|
})
|
|
}
|
|
|
|
var (
|
|
commands = []*discordgo.ApplicationCommand{
|
|
{
|
|
Name: "dank_memes",
|
|
Description: "Sends dank meme from /r/GoodAnimemes",
|
|
},
|
|
{
|
|
Name: "waifus",
|
|
Description: "Sends waifu from /r/WatchItForThePlot",
|
|
},
|
|
{
|
|
Name: "milkers",
|
|
Description: "Sends milkers from /r/RetrousseTits",
|
|
},
|
|
{
|
|
Name: "thighs",
|
|
Description: "Sends thighs from /r/ZettaiRyouiki",
|
|
},
|
|
{
|
|
Name: "help",
|
|
Description: "Sends help message",
|
|
},
|
|
{
|
|
Name: "echo",
|
|
Description: "Echoes your message",
|
|
Options: []*discordgo.ApplicationCommandOption{
|
|
{
|
|
Type: discordgo.ApplicationCommandOptionString,
|
|
Name: "message",
|
|
Description: "The message to echo",
|
|
Required: true,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
commandHandlers = map[string]func(s *discordgo.Session, i *discordgo.InteractionCreate){
|
|
// Dank memes command
|
|
"dank_memes": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "GoodAnimemes")
|
|
},
|
|
|
|
// Waifus command
|
|
"waifus": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "WatchItForThePlot")
|
|
},
|
|
|
|
// Milkers command
|
|
"milkers": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "RetrousseTits")
|
|
},
|
|
|
|
// Thighs command
|
|
"thighs": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
handleRedditCommand(s, i, "ZettaiRyouiki")
|
|
},
|
|
// Help command
|
|
"help": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
// Send the help message to the channel where the command was used
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "**Commands**\n\n/dank_memes - Sends dank meme from /r/GoodAnimemes\n/waifus - Sends waifu from /r/WatchItForThePlot\n/milkers - Sends milkers from /r/RetrousseTits\n/thighs - Sends thighs from /r/ZettaiRyouiki\n/help - Sends help message\n/echo - Echoes your message",
|
|
},
|
|
})
|
|
},
|
|
// Echo command
|
|
"echo": func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
// Check if the user provided a message
|
|
if len(i.ApplicationCommandData().Options) == 0 {
|
|
// If not, send an ephemeral message to the user
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "You need to provide a message!",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
return
|
|
}
|
|
|
|
// Check that the option contains text
|
|
if i.ApplicationCommandData().Options[0].Type != discordgo.ApplicationCommandOptionString {
|
|
// If not, send an ephemeral message to the user
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "The message needs to be text!",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
return
|
|
}
|
|
|
|
// Check that the option is not empty
|
|
if i.ApplicationCommandData().Options[0].StringValue() == "" {
|
|
// If not, send an ephemeral message to the user
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "The message cannot be empty!",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
return
|
|
}
|
|
|
|
// Respond to the original message so we don't get "This interaction failed" error
|
|
s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
|
|
Type: discordgo.InteractionResponseChannelMessageWithSource,
|
|
Data: &discordgo.InteractionResponseData{
|
|
Content: "love u",
|
|
Flags: discordgo.MessageFlagsEphemeral,
|
|
},
|
|
})
|
|
|
|
// Send the message to the channel where the command was used
|
|
s.ChannelMessageSend(i.ChannelID, i.ApplicationCommandData().Options[0].StringValue())
|
|
},
|
|
}
|
|
)
|
|
|
|
func onMessageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
|
|
if m.Author.ID == s.State.User.ID {
|
|
return
|
|
}
|
|
|
|
allowedUsers := []string{
|
|
"thelovinator",
|
|
"killyoy",
|
|
"forgefilip",
|
|
"plubplub",
|
|
"nobot",
|
|
"kao172",
|
|
}
|
|
|
|
// Have a 1/10 chance of replying to a message if written by a user in allowedUsers
|
|
randInt := rand.Intn(10)
|
|
log.Println("Random number:", randInt)
|
|
log.Println("Mentions:", m.Mentions)
|
|
if len(m.Mentions) == 0 && randInt == 4 {
|
|
for _, user := range allowedUsers {
|
|
log.Println("User:", user)
|
|
if m.Author.Username == user {
|
|
log.Println("User is in allowedUsers")
|
|
r, err := GetGPT3Response(m.Content, m.Author.Username)
|
|
if err != nil {
|
|
log.Println("Failed to get GPT-3 response:", err)
|
|
return
|
|
}
|
|
log.Println("GPT-3 response:", r)
|
|
log.Println("Channel ID:", m.ChannelID)
|
|
s.ChannelMessageSend(m.ChannelID, r)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if m.Mentions != nil {
|
|
for _, mention := range m.Mentions {
|
|
if mention.ID == s.State.User.ID {
|
|
r, err := GetGPT3Response(m.Content, m.Author.Username)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "prompt is too long") {
|
|
s.ChannelMessageSend(m.ChannelID, "Message is too long!")
|
|
return
|
|
}
|
|
|
|
if strings.Contains(err.Error(), "prompt is too short") {
|
|
s.ChannelMessageSend(m.ChannelID, "Message is too short!")
|
|
return
|
|
}
|
|
|
|
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("Brain broke :flushed: %v", err))
|
|
return
|
|
}
|
|
s.ChannelMessageSend(m.ChannelID, r)
|
|
}
|
|
}
|
|
}
|
|
|
|
if strings.HasPrefix(strings.ToLower(m.Content), "lovibot") {
|
|
r, err := GetGPT3Response(m.Content, m.Author.Username)
|
|
if err != nil {
|
|
if strings.Contains(err.Error(), "prompt is too long") {
|
|
s.ChannelMessageSend(m.ChannelID, "Message is too long!")
|
|
return
|
|
}
|
|
|
|
if strings.Contains(err.Error(), "prompt is too short") {
|
|
s.ChannelMessageSend(m.ChannelID, "Message is too short!")
|
|
return
|
|
}
|
|
|
|
s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("Brain broke :flushed: %v", err))
|
|
return
|
|
}
|
|
s.ChannelMessageSend(m.ChannelID, r)
|
|
}
|
|
|
|
}
|
|
|
|
func main() {
|
|
// Print the token for debugging purposes.
|
|
discordToken := config.DiscordToken
|
|
fmt.Println("Discord Token:", discordToken)
|
|
|
|
// Create a new Discord session using the provided bot token.
|
|
session, err := discordgo.New("Bot " + discordToken)
|
|
if err != nil {
|
|
log.Fatalf("Cannot create a new Discord session: %v", err)
|
|
}
|
|
|
|
// Add a handler function to the discordgo.Session that is triggered when a slash command is received.
|
|
session.AddHandler(func(s *discordgo.Session, i *discordgo.InteractionCreate) {
|
|
if h, ok := commandHandlers[i.ApplicationCommandData().Name]; ok {
|
|
log.Printf("Handling '%v' command.", i.ApplicationCommandData().Name)
|
|
h(s, i)
|
|
}
|
|
})
|
|
|
|
// Add a handler function to the discordgo.Session that is triggered when a message is received.
|
|
session.AddHandler(onMessageCreate)
|
|
|
|
// Print the user we are logging in as.
|
|
session.AddHandler(func(s *discordgo.Session, _ *discordgo.Ready) {
|
|
log.Printf("Logged in as: %v#%v", s.State.User.Username, s.State.User.Discriminator)
|
|
})
|
|
|
|
// Open a websocket connection to Discord and begin listening.
|
|
err = session.Open()
|
|
if err != nil {
|
|
log.Fatalf("Cannot open the session: %v", err)
|
|
}
|
|
|
|
// Register the commands.
|
|
log.Println("Adding commands...")
|
|
registeredCommands := make([]*discordgo.ApplicationCommand, len(commands))
|
|
for i, v := range commands {
|
|
cmd, err := session.ApplicationCommandCreate(session.State.User.ID, "", v)
|
|
if err != nil {
|
|
log.Panicf("Cannot create '%v' command: %v", v.Name, err)
|
|
}
|
|
registeredCommands[i] = cmd
|
|
log.Printf("Registered '%v' command.", cmd.Name)
|
|
}
|
|
|
|
// Run s.Close() when the program exits.
|
|
defer session.Close()
|
|
|
|
// Wait here until CTRL-C or other term signal is received.
|
|
stop := make(chan os.Signal, 1)
|
|
signal.Notify(stop, os.Interrupt)
|
|
log.Println("Press Ctrl+C to exit")
|
|
<-stop
|
|
|
|
// Bye bye!
|
|
log.Println("Gracefully shutting down.")
|
|
}
|