trucknyl.go

// Wew lad
package main

import (
	"flag"
	"fmt"
	"github.com/bwmarrin/discordgo"
	"math"
	"strings"
	"sync"
	"time"

	"github.com/Philipp15b/go-steam"
	"github.com/Philipp15b/go-steam/gsbot"
	"github.com/Philipp15b/go-steam/protocol/steamlang"
	"github.com/Philipp15b/go-steamapi"
)

const (
	AppID = 397950
)

var (
	flagSteamUser    string
	flagSteamPW      string
	flagSteamAPIKey  string
	flagDiscordToken string

	client         *steam.Client
	auth           *gsbot.Auth
	debug          *gsbot.Debug
	serverList     *gsbot.ServerList
	discordSession *discordgo.Session
)

func init() {
	flag.StringVar(&flagSteamUser, "su", "", "Steam username")
	flag.StringVar(&flagSteamPW, "sp", "", "Steam password")
	flag.StringVar(&flagSteamAPIKey, "sa", "", "Steam apikey")
	flag.StringVar(&flagDiscordToken, "dt", "", "discord token")

	flag.Parse()
}

var (
	leaderboardQueue = make([]string, 0)
	leaderboardLock  sync.Mutex
)

func main() {
	launchSteam(flagSteamUser, flagSteamPW)
	launchDiscord(flagDiscordToken)

	fmt.Scanln()
}

func launchDiscord(token string) {
	s, err := discordgo.New(token)
	if err != nil {
		panic(err)
	}

	s.AddHandler(onMessageCreate)
	err = s.Open()
	if err != nil {
		panic(err)
	}
	discordSession = s
}

func launchSteam(user, pw string) {

	bot := gsbot.Default()
	client = bot.Client
	auth = gsbot.NewAuth(bot, &gsbot.LogOnDetails{
		user,
		pw,
		"",
	}, "sentry.bin")

	var err error
	debug, err = gsbot.NewDebug(bot, "debug")
	if err != nil {
		panic(err)
	}

	client.RegisterPacketHandler(debug)
	serverList = gsbot.NewServerList(bot, "serverlist.json")
	serverList.Connect()

	go handleSteamEvents()
}

var currentLevel = 1

func handleSteamEvents() {
	for event := range client.Events() {
		auth.HandleEvent(event)
		debug.HandleEvent(event)
		serverList.HandleEvent(event)

		switch e := event.(type) {
		case error:
			fmt.Printf("Error: %v", e)
		case *steam.LoggedOnEvent:
			client.Social.SetPersonaState(steamlang.EPersonaState_Online)
			go onLoggedOn()
		case *steam.LeaderboardFoundEvent:
			//fmt.Printf("Found leaderboard\n%#v\n", e)

			client.UserStats.GetLeaderboardEntries(AppID, e.ID, 0, 15, steamlang.ELeaderboardDataRequest_Global, nil)
		case *steam.LeaderboardScoresEvent:
			//fmt.Println("Received entries")
			go onLeaderboardScores(e)
		}
	}
}

func onLeaderboardScores(evt *steam.LeaderboardScoresEvent) {
	leaderboardLock.Lock()

	if len(leaderboardQueue) < 1 {
		leaderboardLock.Unlock()
		fmt.Println("No queue")
		return
	}

	channel := leaderboardQueue[0]
	leaderboardQueue = leaderboardQueue[1:]
	leaderboardLock.Unlock()

	ids := make([]uint64, len(evt.Entries))
	for k, v := range evt.Entries {
		ids[k] = v.GetSteamIdUser()
	}

	// Retrieve summaries such as persona names and whatnot
	summaries, err := steamapi.GetPlayerSummaries(ids, flagSteamAPIKey)
	if err != nil {
		fmt.Println("Steam web api err", err)
		return
	}
	fmt.Println(channel)

	out := "Leaderboard```\n"

	for _, v := range evt.Entries {
		name := fmt.Sprint(v.GetSteamIdUser())
		for _, sum := range summaries {
			if sum.SteamID == v.GetSteamIdUser() {
				name = sum.PersonaName
				break
			}
		}

		score := v.GetScore()

		secondsMilliseconds := score % 60000
		seconds := float64(secondsMilliseconds) / 1000
		minutes := int(math.Floor(float64(score/1000) / 60))

		out += fmt.Sprintf("#%02d %25s: %2d:%.3f\n", v.GetGlobalRank(), name, minutes, seconds)
	}

	out += "```"
	_, err = discordSession.ChannelMessageSend(channel, out)
	if err != nil {
		fmt.Println("Channel send err", err)
	}
}

func onMessageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
	split := strings.SplitN(m.ContentWithMentionsReplaced(), " ", 2)
	if len(split) < 2 || split[0] != "!ct" {
		return
	}

	leaderboardName := split[1]

	leaderboardLock.Lock()
	leaderboardQueue = append(leaderboardQueue, m.ChannelID)
	client.UserStats.FindLeaderboard(AppID, leaderboardName)
	leaderboardLock.Unlock()

	fmt.Println("Fetching", leaderboardName)
}