Refactored handlers and command handlers

command/coin.go

@@ -0,0 +1,29 @@
+package command
+
+import (
+	"git.kill0.net/chill9/beepboop/lib"
+	"github.com/bwmarrin/discordgo"
+)
+
+type Coin bool
+
+func (c *Coin) Flip() bool {
+	*c = Coin(lib.Itob(lib.RandInt(0, 1)))
+	return bool(*c)
+}
+
+func (h *Handlers) Coin(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	var (
+		c   Coin
+		msg string
+	)
+
+	if c.Flip() {
+		msg = "heads"
+	} else {
+		msg = "tails"
+	}
+
+	s.ChannelMessageSend(m.ChannelID, msg)
+	return nil
+}

command/commands.go

@@ -0,0 +1,11 @@
+package command
+
+import "git.kill0.net/chill9/beepboop/config"
+
+type Handlers struct {
+	config *config.Config
+}
+
+func NewHandlers(config *config.Config) *Handlers {
+	return &Handlers{config: config}
+}

command/deal.go

@@ -0,0 +1,83 @@
+package command
+
+import (
+	"errors"
+	"fmt"
+	"math/rand"
+	"strconv"
+	"strings"
+
+	"github.com/bwmarrin/discordgo"
+	log "github.com/sirupsen/logrus"
+)
+
+type (
+	Card string
+
+	Deck [52]Card
+)
+
+var deck Deck = Deck{
+	"2♣", "3♣", "4♣", "5♣", "6♣", "7♣", "8♣", "9♣", "10♣", "J♣", "Q♣", "K♣", "A♣",
+	"2♦", "3♦", "4♦", "5♦", "6♦", "7♦", "8♦", "9♦", "10♦", "J♦", "Q♦", "K♦", "A♦",
+	"2♥", "3♥", "4♥", "5♥", "6♥", "7♥", "8♥", "9♥", "10♥", "J♥", "Q♥", "K♥", "A♥",
+	"2♠", "3♠", "4♠", "5♠", "6♠", "7♠", "8♠", "9♠", "10♠", "J♠", "Q♠", "K♠", "A♠",
+}
+
+func (d *Deck) Deal(n int) ([]Card, error) {
+	var (
+		hand []Card
+		err  error
+	)
+
+	if n < 1 {
+		err = errors.New("number cannot be less than 1")
+		return hand, err
+	}
+
+	if n > len(d) {
+		err = errors.New("number is greater than cards in the deck")
+		return hand, err
+	}
+
+	hand = deck[0:n]
+
+	return hand, err
+}
+
+func (h *Handlers) Deal(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	rand.Shuffle(len(deck), func(i, j int) {
+		deck[i], deck[j] = deck[j], deck[i]
+	})
+
+	log.Debugf("%+v", deck)
+
+	if len(args) != 1 {
+		s.ChannelMessageSend(m.ChannelID, "help: `!deal <n>`")
+		return nil
+	}
+
+	n, err := strconv.Atoi(args[0])
+	if err != nil {
+		log.Errorf("failed to convert string to int: %s", err)
+	}
+
+	hand, err := deck.Deal(n)
+	if err != nil {
+		s.ChannelMessageSend(m.ChannelID, fmt.Sprintf("error: %s\n", err))
+		return nil
+	}
+
+	s.ChannelMessageSend(m.ChannelID, JoinCards(hand, " "))
+	return nil
+}
+
+func JoinCards(h []Card, sep string) string {
+	b := make([]string, len(h))
+
+	for i, v := range h {
+		b[i] = string(v)
+	}
+
+	return strings.Join(b, sep)
+}

command/dice.go

@@ -0,0 +1,103 @@
+package command
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"git.kill0.net/chill9/beepboop/lib"
+
+	"github.com/bwmarrin/discordgo"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	MaxDice  = 100
+	MaxSides = 100
+)
+
+type (
+	Roll struct {
+		N, D, Sum int
+		Rolls     []int
+		S         string
+	}
+)
+
+func NewRoll(n, d int) *Roll {
+	r := new(Roll)
+	r.N = n
+	r.D = d
+	r.S = fmt.Sprintf("%dd%d", r.N, r.D)
+	return r
+}
+
+func ParseRoll(roll string) (*Roll, error) {
+	var (
+		dice []string
+		err  error
+		n, d int
+	)
+
+	match, _ := regexp.MatchString(`^(?:\d+)?d\d+$`, roll)
+
+	if !match {
+		return nil, errors.New("invalid roll, use `<n>d<sides>` e.g. `4d6`")
+	}
+
+	dice = strings.Split(roll, "d")
+
+	if dice[0] == "" {
+		n = 1
+	} else {
+		n, err = strconv.Atoi(dice[0])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	d, err = strconv.Atoi(dice[1])
+	if err != nil {
+		return nil, err
+	}
+
+	if n > MaxDice || d > MaxSides {
+		return nil, fmt.Errorf("invalid roll, n must be <= %d and sides must be <= %d", MaxDice, MaxSides)
+	}
+
+	return NewRoll(n, d), nil
+}
+
+func (r *Roll) RollDice() {
+	for i := 1; i <= r.N; i++ {
+		roll := lib.RandInt(1, r.D)
+		r.Rolls = append(r.Rolls, roll)
+		r.Sum += roll
+	}
+}
+
+func (h *Handlers) Roll(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	var (
+		err       error
+		msg, roll string
+		r         *Roll
+	)
+
+	roll = args[0]
+
+	r, err = ParseRoll(roll)
+	if err != nil {
+		s.ChannelMessageSend(m.ChannelID, err.Error())
+		return nil
+	}
+
+	r.RollDice()
+	log.Debugf("rolled dice: %+v", r)
+
+	msg = fmt.Sprintf("🎲 %s = %d", lib.JoinInt(r.Rolls, " + "), r.Sum)
+
+	s.ChannelMessageSend(m.ChannelID, msg)
+	return nil
+}

command/ping.go

@@ -0,0 +1,10 @@
+package command
+
+import (
+	"github.com/bwmarrin/discordgo"
+)
+
+func (h *Handlers) Ping(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	s.ChannelMessageSend(m.ChannelID, "pong")
+	return nil
+}

command/roulette.go

@@ -0,0 +1,82 @@
+package command
+
+import (
+	"git.kill0.net/chill9/beepboop/lib"
+
+	"github.com/bwmarrin/discordgo"
+	log "github.com/sirupsen/logrus"
+)
+
+const (
+	Bullets         = 1
+	GunFireMessage  = "💀🔫"
+	GunClickMessage = "😌🔫"
+)
+
+type (
+	Gun struct {
+		C [6]bool
+		N int
+	}
+)
+
+var (
+	gun *Gun
+)
+
+func init() {
+	gun = NewGun()
+}
+
+func NewGun() *Gun {
+	return new(Gun)
+}
+
+func (g *Gun) Load(n int) {
+	g.N = 0
+	for i := 1; i <= n; {
+		x := lib.RandInt(0, len(g.C)-1)
+		if !g.C[x] {
+			g.C[x] = true
+			i++
+		} else {
+			continue
+		}
+	}
+}
+
+func (g *Gun) Fire() bool {
+	if g.C[g.N] {
+		g.C[g.N] = false
+		g.N++
+		return true
+	}
+
+	g.N++
+	return false
+}
+
+func (g *Gun) IsEmpty() bool {
+	for _, v := range g.C {
+		if v {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (h *Handlers) Roulette(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	if gun.IsEmpty() {
+		gun.Load(Bullets)
+		log.Debugf("reloading gun: %+v\n", gun)
+	}
+
+	log.Debugf("firing gun: %+v\n", gun)
+	if gun.Fire() {
+		s.ChannelMessageSend(m.ChannelID, GunFireMessage)
+	} else {
+		s.ChannelMessageSend(m.ChannelID, GunClickMessage)
+	}
+	return nil
+}

command/rps.go

@@ -0,0 +1,34 @@
+package command
+
+import (
+	"strings"
+
+	"git.kill0.net/chill9/beepboop/lib/rps"
+	"github.com/bwmarrin/discordgo"
+)
+
+func (h *Handlers) Rps(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	if len(args) != 1 {
+		s.ChannelMessageSend(
+			m.ChannelID, "help: `!rps (rock | paper | scissors)`",
+		)
+		return nil
+	}
+
+	pc := strings.ToLower(args[0]) // player's choice
+
+	g := rps.NewGame(rps.RulesRps, rps.EmojiMapRps)
+
+	bc := g.Rand() // bot's choice
+
+	out, err := g.Play(bc, pc)
+	if _, ok := err.(rps.InvalidChoiceError); ok {
+		s.ChannelMessageSend(
+			m.ChannelID, "help: `!rps (rock | paper | scissors)`",
+		)
+	}
+
+	s.ChannelMessageSend(m.ChannelID, out)
+
+	return nil
+}

command/rpsls.go

@@ -0,0 +1,34 @@
+package command
+
+import (
+	"strings"
+
+	"git.kill0.net/chill9/beepboop/lib/rps"
+	"github.com/bwmarrin/discordgo"
+)
+
+func (h *Handlers) Rpsls(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	if len(args) != 1 {
+		s.ChannelMessageSend(
+			m.ChannelID, "help: `!rps (rock | paper | scissors | lizard | spock)`",
+		)
+		return nil
+	}
+
+	pc := strings.ToLower(args[0]) // player's choice
+
+	g := rps.NewGame(rps.RulesRpsls, rps.EmojiMapRpsls)
+
+	bc := g.Rand() // bot's choice
+
+	out, err := g.Play(bc, pc)
+	if _, ok := err.(rps.InvalidChoiceError); ok {
+		s.ChannelMessageSend(
+			m.ChannelID, "help: `!rps (rock | paper | scissors | lizard | spock)`",
+		)
+	}
+
+	s.ChannelMessageSend(m.ChannelID, out)
+
+	return nil
+}

command/time.go

@@ -0,0 +1,34 @@
+package command
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/bwmarrin/discordgo"
+	log "github.com/sirupsen/logrus"
+)
+
+func (h *Handlers) Time(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	var (
+		t  time.Time
+		tz string
+	)
+
+	now := time.Now()
+
+	if len(args) == 1 {
+		tz = args[0]
+		loc, err := time.LoadLocation(tz)
+		if err != nil {
+			log.Warnf("failed to load location: %s", err)
+			s.ChannelMessageSend(m.ChannelID, err.Error())
+			return nil
+		}
+		t = now.In(loc)
+	} else {
+		t = now
+	}
+
+	s.ChannelMessageSend(m.ChannelID, fmt.Sprint(t))
+	return nil
+}

command/version.go

@@ -0,0 +1,23 @@
+package command
+
+import (
+	"fmt"
+	"runtime"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+const (
+	SourceURI = "https://git.kill0.net/chill9/bb"
+)
+
+func (h *Handlers) Version(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	s.ChannelMessageSend(m.ChannelID, fmt.Sprintf(
+		"go version: %s\nplatform: %s\nos: %s\nsource: %s\n",
+		runtime.Version(),
+		runtime.GOARCH,
+		runtime.GOOS,
+		SourceURI,
+	))
+	return nil
+}

command/weather.go

@@ -0,0 +1,54 @@
+package command
+
+import (
+	"fmt"
+
+	"git.kill0.net/chill9/beepboop/lib/weather"
+
+	"github.com/bwmarrin/discordgo"
+	log "github.com/sirupsen/logrus"
+)
+
+func (h *Handlers) Weather(args []string, s *discordgo.Session, m *discordgo.MessageCreate) error {
+	var (
+		err error
+		loc string
+		w   weather.Weather
+	)
+
+	if len(args) != 1 {
+		s.ChannelMessageSend(m.ChannelID, "help: `!weather <CITY>,<STATE>,<COUNTRY>`")
+		return nil
+	}
+
+	loc = args[0]
+
+	if h.config.OpenWeatherMapToken == "" {
+		log.Error("OpenWeather token is not set")
+		return nil
+	}
+
+	wc := weather.NewClient(h.config.OpenWeatherMapToken)
+
+	log.Debugf("weather requested for '%s'", loc)
+
+	w, err = wc.Get(loc)
+	if err != nil {
+		log.Errorf("weather client error: %v", err)
+		return nil
+	}
+
+	log.Debugf("weather returned for '%s': %+v", loc, w)
+
+	s.ChannelMessageSend(m.ChannelID, fmt.Sprintf(
+		"%s (%.1f, %.1f) — C:%.1f F:%.1f K:%.1f",
+		loc,
+		w.Coord.Lat,
+		w.Coord.Lon,
+		w.Main.Temp.Celcius(),
+		w.Main.Temp.Fahrenheit(),
+		w.Main.Temp.Kelvin(),
+	))
+
+	return nil
+}