fun

Documentation

Index

• Constants
• Variables
• func NukeGuild(s *discordgo.Session, guildID string) error

Constants

const SpacesMax = 32

Variables

var AwardsCommand = &framework.Command{
	Name:               "awards",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "Displays info for awards given out",
	Exec: func(ctx *framework.Context) error {
		arg := ctx.GetArgIndexDefault(0, "get")

		switch arg {
		case "get":
			{
				akv, err := db.QueryAwardCounts(ctx.Hanamaru.Db, ctx.GuildID, ctx.Author.ID)
				if err != nil {
					return err
				}
				ctx.Reply(formatAwardKV(akv))
			}
		case "leaderboard":
			{
				lbString, err := generateLeaderboard(ctx.Hanamaru, ctx.GuildID)
				if err != nil {
					return err
				}
				ctx.Reply(lbString)
			}
		}

		return nil

	},
	Setup: nil,
}

var Dance = &framework.Command{
	Name:               "dance",
	PermissionRequired: 0,
	Exec: func(ctx *framework.Context) error {
		input, err := ctx.GetArgIndex(0)
		if err != nil {
			return fmt.Errorf("please type something in (if it has spaces use quotes)")
		}

		input = strings.ToUpper(input)

		targetSlice := strings.Split(input, "")
		for _, char := range targetSlice {
			ctx.Reply(dmappings[char])
		}
		return nil
	},
	Setup: func() error {
		json.NewDecoder(bytes.NewReader(danceBytes)).Decode(&dmappings)
		return nil
	},
}

var Emoji = &framework.Command{
	Name: "emoji",
	Exec: func(ctx *framework.Context) error {
		name, err := ctx.GetArgIndex(0)
		id, err := ctx.GetArgIndex(1)
		if err != nil {
			return err
		}
		ctx.Reply(fmt.Sprintf("<:%s:%s>", name, id))
		return nil
	},
}

var ErrGenerateLeaderboard = errors.New("failed to generate leaderboard")

var FlagDec = &framework.Command{
	Name:               "flagdec",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "Extracts the data from a flag...thats it <https://en.wikipedia.org/wiki/Illegal_number>",
	Exec: func(ctx *framework.Context) error {
		flag, err := ctx.GetImage(0)
		if err != nil {
			return err
		}
		data, err := util.DecodeFlag(flag)
		if err != nil {
			return err
		}
		if string(data) == "" {
			ctx.Reply("This flag contains no data.")
			return nil
		}
		ctx.Reply(string(data))
		return nil
	},
	Setup: nil,
}

var FlagEnc = &framework.Command{
	Name:               "flagenc",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "Generates a flag...thats it <https://en.wikipedia.org/wiki/Illegal_number>",
	Exec: func(ctx *framework.Context) error {
		data := ctx.TakeRest()
		flag := util.EncodeFlag([]byte(data))
		ctx.ReplyPNGImg(flag, "flag")
		return nil
	},
	Setup: nil,
}

var Frick = &framework.Command{
	Name:               "frick",
	PermissionRequired: discordgo.PermissionManageChannels | discordgo.PermissionManageServer,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		tmpCh, err := ctx.Hanamaru.GuildChannelCreate(ctx.GuildID, "this is death", discordgo.ChannelTypeGuildVoice)
		if err != nil {
			return errors.New("failed to create temporary channel, check the permissions given to the bot")
		}
		fromVC, err := ctx.GetSenderVoiceChannel()
		if err != nil {
			return nil
		}
		guild, err := ctx.Hanamaru.Guild(ctx.GuildID)
		if err != nil {
			return nil
		}
		for _, s := range guild.VoiceStates {
			if s.ChannelID == fromVC.ID {
				ctx.Hanamaru.GuildMemberMove(ctx.GuildID, s.UserID, &tmpCh.ID)
			}
		}
		ctx.Hanamaru.ChannelDelete(tmpCh.ID)
		ctx.Reply("Done")
		return nil
	},
}

var Migrate = &framework.Command{
	Name:               "mgr",
	PermissionRequired: discordgo.PermissionManageChannels | discordgo.PermissionManageServer,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		toVC, err := ctx.GetArgIndex(0)
		if err != nil {
			return err
		}
		_, err = ctx.Hanamaru.Guild(toVC)
		if err != nil {
			return errors.New("please use a guild id that exists")
		}
		fromVC, err := ctx.GetSenderVoiceChannel()
		if err != nil {
			return nil
		}
		guild, err := ctx.Hanamaru.Guild(ctx.GuildID)
		if err != nil {
			return nil
		}
		for _, s := range guild.VoiceStates {
			if s.ChannelID == fromVC.ID {
				ctx.Hanamaru.GuildMemberMove(ctx.GuildID, s.UserID, &toVC)
			}
		}
		return nil
	},
}

var Nitro = &framework.Command{
	Name:               "nitro",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		channel, err := ctx.Hanamaru.Channel(ctx.ChannelID)
		if err != nil {
			return err
		}
		if channel.Type != discordgo.ChannelTypeDM {
			if channel.Type != discordgo.ChannelTypeGroupDM {
				ctx.Hanamaru.ChannelMessageDelete(ctx.ChannelID, ctx.Message.ID)
				ctx.ReplyEmbed(constructNitroEmbed())
			}
		} else {
			ctx.ReplyEmbed(constructNitroEmbed())
		}
		return nil
	},
}

var NoU = &framework.Command{
	Name:               "nou",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		ctx.Reply("https://i.imgur.com/3WDcYbV.png")
		return nil
	},
}

var Nuke = &framework.Command{
	Name:               "nuke",
	PermissionRequired: 0,
	OwnerOnly:          true,
	Help:               "NEVER RUN THIS UNLESS U WANT TO NUKE THE SERVER",
	Exec: func(ctx *framework.Context) error {
		var outerr error
		ctx.Reply("Are you 100% sure you want to do this: (y or n)")
		ctx.Hanamaru.AddEventListenerOnce(&framework.EventListener{
			Name: "Nuke confirmer",
			HandlerConstructor: func(h *framework.Hanamaru) interface{} {
				return func(session *discordgo.Session, m *discordgo.MessageCreate) {
					if ctx.GuildID == m.GuildID && strings.Contains(m.Content, "y") && ctx.Author == m.Author {
						err := NukeGuild(ctx.Hanamaru.Session, ctx.GuildID)
						if err != nil {
							outerr = err
						}
					} else {
						ctx.Reply("Canceled")
					}
				}
			}})
		if outerr != nil {
			return outerr
		}
		return nil
	},
}

var Padoru = &framework.Command{
	Name:               "padoru",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		imgFile, _ := padoruFS.Open("assets/padoru" + "/" + padoruList[util.IntnNoDup(len(padoruList), &prevPick)])
		defer imgFile.Close()
		img, _, _ := image.Decode(imgFile)
		fileInfo, _ := imgFile.Stat()
		ctx.ReplyJPGImg(img, fileInfo.Name())
		return nil
	},
	Setup: func() error {
		dir, err := padoruFS.ReadDir("assets/padoru")
		for _, f := range dir {
			padoruList = append(padoruList, f.Name())
		}
		return err
	},
}

var Patrick = &framework.Command{
	Name:               "patrick",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		length, _ := strconv.Atoi(ctx.GetArgIndexDefault(0, "0"))
		if length < 0 {
			ctx.ReplyFile("0r.jpg", getPatrickImage("0r.jpg"))
			for i := 0; i > length; i-- {
				ctx.ReplyFile("1r.jpg", getPatrickImage("1r.jpg"))
			}
			ctx.ReplyFile("2r.jpg", getPatrickImage("2r.jpg"))
		} else if length > 0 {
			ctx.ReplyFile("0.jpg", getPatrickImage("0.jpg"))
			for i := 0; i < length; i++ {
				ctx.ReplyFile("1.jpg", getPatrickImage("1.jpg"))
			}
			ctx.ReplyFile("2.jpg", getPatrickImage("2.jpg"))
		} else {
			ctx.ReplyFile("0.jpg", getPatrickImage("0.jpg"))
			ctx.ReplyFile("2.jpg", getPatrickImage("2.jpg"))
		}
		return nil
	},
}

var Roll = &framework.Command{
	Name:               "roll",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		rollStr := ctx.GetArgIndexDefault(0, "100")
		rollInt64, err := strconv.ParseInt(rollStr, 10, 64)
		if err != nil {
			rollInt64 = 100
		}
		if rollInt64 <= 0 {
			ctx.Reply(fmt.Sprintf("%v is how many friends you have %s", rollInt64, ctx.Message.Author.Mention()))
			return nil
		}
		ctx.Reply(fmt.Sprintf("%v rolls %v point(s)!", ctx.Author.Username, rand.Int63n(rollInt64)+1))
		return nil
	},
}

var SineCommand = &framework.Command{
	Name: "sine",
	Help: "WaVeS",
	Exec: func(ctx *framework.Context) error {
		var output = ""
		var text = ctx.TakeRest()

		for i := 0; i <= SpacesMax*2; i++ {
			output += fmt.Sprintf("%v%v\n", computeSpaces(i, SpacesMax), text)
		}
		_, err := ctx.Reply(output)
		return err
	},
}

var Spoonful = &framework.Command{
	Name:               "spoonful",
	PermissionRequired: 0,
	OwnerOnly:          false,
	Help:               "Prints the spoonful image except with minecraft hoe, similar to patrick command",
	Exec: func(ctx *framework.Context) error {
		length, _ := strconv.Atoi(ctx.GetArgIndexDefault(0, "0"))
		if length <= 0 {
			ctx.ReplyFile("0.jpg", getSpoonfulImage("0.jpg"))
			ctx.ReplyFile("2.jpg", getSpoonfulImage("2.jpg"))
		} else if length <= 3 {
			ctx.ReplyFile("0.jpg", getSpoonfulImage("0.jpg"))
			for i := 0; i < length; i++ {
				ctx.ReplyFile("1.jpg", getSpoonfulImage("1.jpg"))
			}
			ctx.ReplyFile("2.jpg", getSpoonfulImage("2.jpg"))
		} else {
			return errors.New("length too long")
		}
		return nil
	},
}

var Suntsu = &framework.Command{
	Name:               "suntsu",
	PermissionRequired: 0,
	Exec: func(ctx *framework.Context) error {
		buff := new(bytes.Buffer)
		quoteTempl.Execute(buff, quotes[rand.Intn(len(quotes))])
		ctx.Reply(buff.String())
		return nil
	},
	Setup: func() error {
		json.NewDecoder(bytes.NewReader(suntsuJSON)).Decode(&quotes)
		return nil
	},
}

var Talk = &framework.Command{
	Name:               "talk",
	PermissionRequired: 0,
	OwnerOnly:          true,
	Help:               "",
	Exec: func(ctx *framework.Context) error {
		chatId, err := ctx.GetArgIndex(0)
		if err != nil {
			return err
		}
		message, err := ctx.GetArgIndex(1)
		if err != nil {
			return err
		}
		_, err = ctx.Hanamaru.ChannelMessageSend(chatId, message)
		if err != nil {
			ctx.Reply("message failed to send, maybe the channel doesn't exist")
		}
		return nil
	},
}

Im bored lol

Functions

func NukeGuild

func NukeGuild(s *discordgo.Session, guildID string) error