db4c1257b9
fixed imp with imps but should go back to privmsg detection give the bot money when people lose lel
415 lines
12 KiB
Go
415 lines
12 KiB
Go
package wat
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
"strings"
|
|
"strconv"
|
|
"crypto/rand"
|
|
"math/big"
|
|
"github.com/go-irc/irc"
|
|
)
|
|
|
|
type WatGame struct {
|
|
bot *WatBot
|
|
db *WatDb
|
|
me Player
|
|
commands map[string](func(*Player,[]string)(string))
|
|
lifeCommands map[string](func(*Player, []string)(string))
|
|
}
|
|
|
|
func NewWatGame(bot *WatBot, db *WatDb) *WatGame {
|
|
g := WatGame{bot, db, Player{}, nil, nil}
|
|
g.me = g.db.User(bot.Nick, "tripsit/user/"+bot.Nick, true)
|
|
g.commands = map[string](func(*Player,[]string)(string)) {
|
|
"wat": g.megaWat,
|
|
"watch": g.Watch,
|
|
"coins": g.Balance,
|
|
"send": g.Send,
|
|
"rest": g.Rest,
|
|
"leech": g.Leech,
|
|
"roll": g.Roll,
|
|
"dice": g.Dice,
|
|
"mine": g.Mine,
|
|
}
|
|
g.lifeCommands = map[string](func(*Player, []string)(string)) {
|
|
"steal": g.Steal,
|
|
"frame": g.Frame,
|
|
"punch": g.Punch,
|
|
"quest": g.QuestStart,
|
|
}
|
|
return &g
|
|
}
|
|
|
|
var currency = "watcoin"
|
|
var currencys = "watcoins"
|
|
var unconscious = "wat, your hands fumble and fail you. try resting, weakling."
|
|
var helpText = fmt.Sprintf("coins <nick>, watch <nick>, topten, mine, send <nick> <%s>, roll <%s>, steal <nick> <%s>, frame <nick> <%s>, punch <nick>", currency, currency, currency, currency)
|
|
var rules = "A new account is created with 5 hours time credit. Mining exchanges time credit for %s: 1-10h: 1 p/h; >10h: 10 p/h; >1 day: 50 p/h; >1 month: 1000 p/h."
|
|
|
|
// missing
|
|
// invent, create, give inventory
|
|
|
|
func (g *WatGame) Msg(m *irc.Message, player *Player, fields []string) {
|
|
reply := ""
|
|
if g.commands[fields[0]] != nil {
|
|
reply = g.commands[fields[0]](player, fields)
|
|
} else {
|
|
// one liners
|
|
switch strings.ToLower(fields[0]) {
|
|
case "rules":
|
|
reply = rules
|
|
case "help":
|
|
reply = helpText
|
|
case "topten":
|
|
reply = fmt.Sprintf("%s holders: %s", currency, g.TopTen())
|
|
}
|
|
}
|
|
if g.lifeCommands[fields[0]] != nil {
|
|
if !player.Conscious() {
|
|
reply = unconscious
|
|
} else {
|
|
reply = g.lifeCommands[fields[0]](player, fields)
|
|
}
|
|
}
|
|
g.bot.reply(m, reply)
|
|
}
|
|
|
|
func (g *WatGame) RandInt(max int64) int64 {
|
|
i, _ := rand.Int(rand.Reader, big.NewInt(max))
|
|
return i.Int64()
|
|
}
|
|
|
|
func (g *WatGame) Dice(player *Player, fields []string) string {
|
|
roll := int64(6)
|
|
if len(fields) > 1 {
|
|
i, e := g.Int(fields[1])
|
|
if e == nil {
|
|
roll = i
|
|
}
|
|
}
|
|
answer := g.RandInt(roll)+1
|
|
return fmt.Sprintf("1d%d - %d", roll, answer)
|
|
}
|
|
|
|
type PositiveError struct {}
|
|
func (e PositiveError) Error() string {return ""}
|
|
|
|
func (g *WatGame) Int(str string) (int64, error) {
|
|
i, e := strconv.ParseInt(str, 10, 64)
|
|
if i < 0 {
|
|
return 0, PositiveError{}
|
|
}
|
|
return i, e
|
|
}
|
|
|
|
func (g *WatGame) Roll(player *Player, fields []string) string {
|
|
if len(fields) < 2 {
|
|
return fmt.Sprintf("roll <%s> pls - u must score < 50 if u want 2 win", currency)
|
|
}
|
|
amount, e := g.Int(fields[1])
|
|
if e != nil {
|
|
return "wat kinda number is that"
|
|
}
|
|
if amount > player.Coins {
|
|
return "wat? brokeass"
|
|
}
|
|
n := g.RandInt(100)+1
|
|
ret := fmt.Sprintf("%s rolls a 1d100... %d! ", player.Nick, n)
|
|
if n < 50 {
|
|
player.Coins += amount
|
|
ret += fmt.Sprintf("You win! total: %d %s", player.Coins, currency)
|
|
} else {
|
|
player.LoseCoins(amount)
|
|
g.me.Coins += amount
|
|
g.db.Update(g.me)
|
|
ret += fmt.Sprintf("You lose! %d %s left...", player.Coins, currency)
|
|
}
|
|
g.db.Update(player)
|
|
return ret
|
|
}
|
|
|
|
func (g *WatGame) Punch(player *Player, fields []string) string {
|
|
if len(fields) < 2 {
|
|
return "punch <target> pls"
|
|
}
|
|
target, err := g.GetTarget(player.Nick, fields[1])
|
|
if err != "" {
|
|
return err
|
|
}
|
|
chance := g.RandInt(6)+1
|
|
dmg := g.RandInt(6)+1
|
|
ret := fmt.Sprintf("%s rolls a d6... %s ", player.Nick, player.Nick)
|
|
if chance > 3 {
|
|
dmg += player.Level(player.Anarchy)
|
|
ret += fmt.Sprintf("hits %s for %d points of damage!", target.Nick, dmg)
|
|
target.Health -= dmg
|
|
g.db.Update(target)
|
|
if target.Health <= 0 {
|
|
ret += target.Nick + " has fallen unconscious."
|
|
}
|
|
} else {
|
|
ret += fmt.Sprintf("fumbles, and punches themselves in confusion! %d self-damage. ", dmg)
|
|
player.Health -= dmg
|
|
if player.Health <= 0 {
|
|
ret += player.Nick + " has fallen unconscious."
|
|
}
|
|
g.db.Update(player)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (g *WatGame) Frame(player *Player, fields []string) string {
|
|
if len(fields) < 3 {
|
|
return fmt.Sprintf("frame <nick> <%s> - d6 roll. Sneaky? You force the target to pay me. Clumsy? You pay a fine to the target and myself.", currency)
|
|
}
|
|
amount, e := g.Int(fields[2])
|
|
if amount <= 0 || e != nil {
|
|
return "wat kinda number is "+fields[2]+"?"
|
|
}
|
|
if player.Coins < amount {
|
|
return "wat? you too poor for that."
|
|
}
|
|
target, err := g.GetTarget(player.Nick, fields[1])
|
|
if err != "" {
|
|
return err
|
|
}
|
|
if target.Coins < amount {
|
|
return fmt.Sprintf("wat? %s is too poor for this.", target.Nick)
|
|
}
|
|
n := g.RandInt(6)+1
|
|
ret := fmt.Sprintf("%s rolls a d6 to frame %s with %d %s: It's a %d! (<3 wins). ", player.Nick, target.Nick, amount, currency, n)
|
|
if n < 3 {
|
|
ret += fmt.Sprintf("You frame %s for a minor crime. They pay me %d.", target.Nick, amount)
|
|
player.Anarchy += 1
|
|
target.Coins -= amount
|
|
} else {
|
|
ret += fmt.Sprintf("You were caught and pay them %d. %s gets the rest.", (amount/2), g.bot.Nick)
|
|
player.LoseCoins(amount)
|
|
target.Coins += amount/2
|
|
g.me.Coins += amount/2
|
|
g.db.Update(g.me)
|
|
}
|
|
g.db.Update(player)
|
|
g.db.Update(target)
|
|
return ret
|
|
}
|
|
|
|
func (g *WatGame) Steal(player *Player, fields []string) string {
|
|
if len(fields) < 3 {
|
|
return fmt.Sprintf("steal <nick> <%s> - d6 roll. If you fail, you pay double the %s to %s", currency, currency, g.bot.Nick)
|
|
}
|
|
amount, e := g.Int(fields[2])
|
|
if amount <= 0 || e != nil {
|
|
return "wat kinda number is "+fields[2]+"?"
|
|
}
|
|
if player.Coins < amount*2 {
|
|
return "wat? You'd go bankrupt if they steal back..."
|
|
}
|
|
target, err := g.GetTarget(player.Nick, fields[1])
|
|
if target == nil {
|
|
return err
|
|
}
|
|
if target.Coins < amount {
|
|
return fmt.Sprintf("wat? %s is poor and doesn't have that much to steal. (%d %s)", target.Nick, target.Coins, currency)
|
|
}
|
|
n := g.RandInt(6)+1
|
|
ret := fmt.Sprintf("%s is trying to steal %d %s from %s... ", player.Nick, amount, currency, target.Nick)
|
|
if n < 3 {
|
|
ret += "You did it! Sneaky bastard!"
|
|
player.Coins += amount
|
|
player.Anarchy += 1
|
|
target.Coins -= amount
|
|
g.db.Update(target)
|
|
} else {
|
|
ret += fmt.Sprintf("You were caught and I took %d %s from your pocket.", (amount*2), currency)
|
|
player.LoseCoins(amount*2)
|
|
g.me.Coins += amount*2
|
|
g.db.Update(g.me)
|
|
}
|
|
g.db.Update(player)
|
|
return ret
|
|
}
|
|
|
|
func (g *WatGame) GetTarget(player, target string) (*Player, string) {
|
|
t := g.db.User(strings.ToLower(target), "", false)
|
|
if t.Nick == "" {
|
|
return nil, "Who? wat?"
|
|
}
|
|
if t.Nick == player {
|
|
return nil, "You can't do that to yourself, silly."
|
|
}
|
|
return &t, ""
|
|
}
|
|
|
|
func (g *WatGame) Leech(player *Player, fields []string) string {
|
|
divisor := int64(10)
|
|
if len(fields) < 3 {
|
|
return fmt.Sprintf("leech <nick> <%s> - using your wealth, you steal the life force of another player", currency)
|
|
}
|
|
amount, er := g.Int(fields[2])
|
|
if amount < divisor {
|
|
return fmt.Sprintf("wat? its %d %s for 1 hp", divisor, currency)
|
|
}
|
|
if player.Coins < amount || er != nil {
|
|
return "wat great fortune do you think you have? poor wats shouldn't be doing this, wat a waste..."
|
|
}
|
|
target, err := g.GetTarget(player.Nick, fields[1])
|
|
if err != "" {
|
|
return err
|
|
}
|
|
r := g.RandInt(10)+1
|
|
reply := fmt.Sprintf("You muster your wealth and feed it to %s. ", g.bot.Nick)
|
|
hpDown := amount/divisor
|
|
player.Coins -= amount
|
|
if r < 5 {
|
|
target.Health -= hpDown
|
|
player.Health += hpDown
|
|
player.Anarchy += 1
|
|
reply += fmt.Sprintf("The deal is done, you took %d HP from %s. They now have %d HP, you have %d.", hpDown, target.Nick, target.Health, player.Health)
|
|
} else {
|
|
reply += "The gods do not smile upon you this waturday. Your money vanishes and nothing happens."
|
|
}
|
|
return reply
|
|
}
|
|
|
|
func (g *WatGame) Rest(player *Player, fields []string) string {
|
|
minRest := int64(43200)
|
|
delta := time.Now().Unix() - player.LastRested
|
|
ret := ""
|
|
if player.LastRested == 0 {
|
|
ret = "you've never slept before - you sleep so well, your injuries are cured and your health is restored to 10"
|
|
player.Health = 10
|
|
player.LastRested = time.Now().Unix()
|
|
g.db.Update(player)
|
|
} else if delta < minRest {
|
|
ret = fmt.Sprintf("wat were you thinking, sleeping at a time like this (%d until next rest)", minRest-delta)
|
|
} else {
|
|
value := g.RandInt(10)+1
|
|
ret = fmt.Sprintf("wat a nap - have back a random amount of hitpoints (this time it's %d)", value)
|
|
player.LastRested = time.Now().Unix()
|
|
player.Health += value
|
|
g.db.Update(player)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func (g *WatGame) QuestStart(player *Player, fields []string) string {
|
|
// Begin a quest with some people. It will involve multiple dice rolls.
|
|
return ""
|
|
}
|
|
|
|
func (g *WatGame) Send(player *Player, fields []string) string {
|
|
if len(fields) < 3 {
|
|
return fmt.Sprintf("You forgot somethin'. send <nick> <%s>", currency)
|
|
}
|
|
amount, err := strconv.Atoi(fields[2])
|
|
if err != nil {
|
|
return fields[2] + " is not an integer, wat?"
|
|
}
|
|
if int64(amount) > player.Coins {
|
|
return "wat? you're too poor!"
|
|
}
|
|
target, str := g.GetTarget(player.Nick, fields[1])
|
|
if target == nil {
|
|
return str
|
|
}
|
|
player.Coins -= int64(amount)
|
|
target.Coins += int64(amount)
|
|
g.db.Update(player)
|
|
g.db.Update(target)
|
|
return fmt.Sprintf("%s sent %s %d %s. %s has %d %s, %s has %d %s", player.Nick, target.Nick, amount, currency, player.Nick, player.Coins, currency, target.Nick, target.Coins, currency)
|
|
}
|
|
|
|
func (g *WatGame) Mine(player *Player, _ []string) string {
|
|
delta := time.Now().Unix() - player.LastMined
|
|
if delta < 1800 {
|
|
return fmt.Sprintf("wat? 2 soon. u earn more when u wait long (%d)", delta)
|
|
}
|
|
value := int64(0)
|
|
if delta < 36000 {
|
|
value = delta/1800
|
|
} else if delta < 86400 {
|
|
value = 10
|
|
} else if delta < 2592000 {
|
|
value = 50
|
|
} else {
|
|
value = 1000
|
|
}
|
|
msg := ""
|
|
if player.LastMined == 0 {
|
|
msg = "with wat? you go to get a pickaxe"
|
|
value = 0
|
|
} else {
|
|
player.Coins += value
|
|
msg = fmt.Sprintf("%s mined %d %s for %d and has %d %s", player.Nick, value, currency, delta, player.Coins, currency)
|
|
}
|
|
player.LastMined = time.Now().Unix()
|
|
g.db.Update(player)
|
|
return msg
|
|
}
|
|
|
|
func (g *WatGame) Watch(player *Player, fields []string) string {
|
|
if len(fields) > 1 {
|
|
maybePlayer, err := g.GetTarget("", fields[1])
|
|
if err != "" {
|
|
return err
|
|
}
|
|
player = maybePlayer
|
|
}
|
|
return fmt.Sprintf("%s's Watting: %d (%d) / Anarchy: %d (%d) / Trickery: %d (%d) / Coins: %d / Health: %d", player.Nick, player.Level(player.Watting), player.Watting, player.Level(player.Anarchy), player.Anarchy, player.Trickery, player.Trickery, player.Coins, player.Health)
|
|
}
|
|
|
|
func (g *WatGame) Balance(player *Player, fields []string) string {
|
|
balStr := "%s's %s balance: %d. Mining time credit: %d. Total lost: %d."
|
|
balPlayer := player
|
|
if len(fields) > 1 {
|
|
var err string
|
|
balPlayer, err = g.GetTarget("", fields[1])
|
|
if err != "" {
|
|
return err
|
|
}
|
|
}
|
|
if balPlayer.Nick == "hibs" {
|
|
ptwo, _ := g.GetTarget("", "vlk")
|
|
//balPlayer.Coins = ptwo.Coins
|
|
balPlayer.Coins = -1*ptwo.Coins
|
|
}
|
|
return fmt.Sprintf(balStr, balPlayer.Nick, currency, balPlayer.Coins, time.Now().Unix()-balPlayer.LastMined, balPlayer.CoinsLost)
|
|
}
|
|
|
|
func (g *WatGame) TopTen() string {
|
|
players := g.db.TopTen()
|
|
ret := ""
|
|
for _, p := range players {
|
|
ret += PrintTwo(p.Nick, p.Coins)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func PrintTwo(nick string, value int64) string {
|
|
return fmt.Sprintf("%s (%d) ", CleanNick(nick), value)
|
|
}
|
|
|
|
func (g *WatGame) megaWat(player *Player, _ []string) string {
|
|
mega := g.RandInt(1000000)+1
|
|
kilo := g.RandInt(1000)+1
|
|
ten := g.RandInt(100)+1
|
|
reply := ""
|
|
if mega == 23 {
|
|
player.Coins += 1000000
|
|
reply = fmt.Sprintf("OMGWATWATWAT!!!! %s has won the MegaWat lottery and gains 1000000 %s!", player.Nick, currency)
|
|
}
|
|
if kilo == 5 {
|
|
player.Coins += 1000
|
|
reply = fmt.Sprintf("OMGWAT! %s has won the KiloWat lottery and gains 1000 %s!", player.Nick, currency)
|
|
}
|
|
if ten == 10 {
|
|
player.Coins += 10
|
|
reply = fmt.Sprintf("%s won the regular wattery. This one only pays 10 %s.", player.Nick, currency)
|
|
}
|
|
player.Watting += 1
|
|
g.db.Update(player)
|
|
return reply
|
|
}
|