From 289684b0f117181c03e4e5ef6616d574da9a1981 Mon Sep 17 00:00:00 2001 From: alex Date: Sat, 20 Oct 2018 00:40:15 +0100 Subject: [PATCH] =?UTF-8?q?sorry=20for=20rehosting=20ur=20stuff=20(?= =?UTF-8?q?=EF=BD=A1=E2=97=95=20=E2=80=BF=20=E2=97=95=EF=BD=A1)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Added original source Fixed readme typo (I fat fingered your username again whoops) Fiddling with golang config --- .gitignore | 2 + README.md | 2 +- main.go | 18 ++ osrc/watbot.py | 15 ++ osrc/watbot_cli.py | 19 ++ osrc/watbot_config.py.example | 13 + osrc/watbot_db.py | 143 +++++++++++ osrc/watbot_game.py | 440 ++++++++++++++++++++++++++++++++++ osrc/watbot_irc.py | 102 ++++++++ osrc/watbot_player.py | 46 ++++ 10 files changed, 799 insertions(+), 1 deletion(-) create mode 100644 main.go create mode 100644 osrc/watbot.py create mode 100644 osrc/watbot_cli.py create mode 100644 osrc/watbot_config.py.example create mode 100644 osrc/watbot_db.py create mode 100644 osrc/watbot_game.py create mode 100644 osrc/watbot_irc.py create mode 100644 osrc/watbot_player.py diff --git a/.gitignore b/.gitignore index 7560965..942fa54 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +# personal reasons (｡◕ ‿ ◕｡) +*.tgz # ---> Go # Binaries for programs and plugins *.exe diff --git a/README.md b/README.md index ea11351..bf95212 100644 --- a/README.md +++ b/README.md @@ -2,4 +2,4 @@ watbot -ported watbot from wuzelfuz \ No newline at end of file +ported watbot from wuselfuzz diff --git a/main.go b/main.go new file mode 100644 index 0000000..54ddf3c --- /dev/null +++ b/main.go @@ -0,0 +1,18 @@ +package main + +import "fmt" +import "github.com/go-irc/irc" +import "github.com/namsral/flag" + +func main() { + var pass string + flag.String(pass) + config := irc.ClientConfig { + Nick: "wat", + Pass: pass, + User: "wat", + Name: "wat", + Handler: testHandler + } + fmt.Println("Hello world") +} diff --git a/osrc/watbot.py b/osrc/watbot.py new file mode 100644 index 0000000..44253fc --- /dev/null +++ b/osrc/watbot.py @@ -0,0 +1,15 @@ +#!/usr/bin/python + +# LICENSE: DO WAT YOU WANT WITH THIS! + + +from watbot_config import WatbotConfig +from watbot_db import WatbotDB +from watbot_game import WatbotGame +from watbot_irc import WatbotIRC + +db = WatbotDB(WatbotConfig) +game = WatbotGame(WatbotConfig, db) +irc = WatbotIRC(WatbotConfig, game) + +irc.main_loop() diff --git a/osrc/watbot_cli.py b/osrc/watbot_cli.py new file mode 100644 index 0000000..1dbadf6 --- /dev/null +++ b/osrc/watbot_cli.py @@ -0,0 +1,19 @@ +#!/usr/bin/python + +from watbot_config import WatbotConfig +from watbot_db import WatbotDB +from watbot_game import WatbotGame +from watbot_console import WatbotConsole + +import sys + +if len(sys.argv) > 1: + + db = WatbotDB(WatbotConfig) + game = WatbotGame(WatbotConfig, db) + con = WatbotConsole(WatbotConfig, game, sys.argv[1]) + + con.main_loop() +else: + print "usage: " + sys.argv[0] + " " + \ No newline at end of file diff --git a/osrc/watbot_config.py.example b/osrc/watbot_config.py.example new file mode 100644 index 0000000..7845a71 --- /dev/null +++ b/osrc/watbot_config.py.example @@ -0,0 +1,13 @@ +#!/usr/bin/python + +config = { + "prefix": "abc", + "currency": "abccoin", + "bot_nick": "abcbot", + "channel": "#abc", + "server": "irc.abc.example.com", + "port": 6667, + "ssl": False, + "nickserv": False, + "password": "" +} diff --git a/osrc/watbot_db.py b/osrc/watbot_db.py new file mode 100644 index 0000000..6759c3b --- /dev/null +++ b/osrc/watbot_db.py @@ -0,0 +1,143 @@ +#!/usr/bin/python + +import sqlite3 +import time + + +class WatbotDB: + """watbot database abstraction""" + + def __init__(self, config): + self.config = config + self.currency = config["currency"] + self.conn = sqlite3.connect(self.currency + ".db") + self.c = self.conn.cursor() + + self.c.execute("create table if not exists players (" + " nickname varchar(256)," + " watting integer," + " anarchy integer, " + " trickery integer, " + " coins integer, " + " health integer, " + " last_mine integer, " + " last_rest integer, " + " primary key(nickname)" + ")" + ) + + self.c.execute("create table if not exists ledger (" + " nickname varchar(256)," + " timestamp integer," + " balance integer," + " log text," + " foreign key(nickname) references coins(nickname)" + ")" + ) + + self.c.execute("create table if not exists items (" + " itemname varchar(256)," + " nickname varchar(256)," + " price integer," + " primary key(itemname)," + " foreign key(nickname) references players(nickname)" + ")" + ) + + self.c.execute("create table if not exists inventory (" + " nickname varchar(256)," + " itemname varchar(256)," + " count integer," + " foreign key(nickname) references players(nickname)," + " foreign key(itemname) references items(itemname)" + ")" + ) + + self.conn.commit() + + def get_account(self,nick): + self.c.execute("select watting, anarchy, trickery, coins, last_mine, health, last_rest from players where nickname=?", (nick.lower(),)) + data = self.c.fetchone() + + if data is None: + earlier = time.time() - ( 24 * 3600 + 1) + self.c.execute("insert into players(nickname, watting, anarchy, trickery, coins, last_mine, health, last_rest) values(?, 0, 0, 0, 0, ?, 100, ?)", (nick.lower(), earlier, earlier)) + self.c.execute("insert into ledger(nickname, timestamp, balance, log) values(?, ?, ?, ?)", (nick.lower(), earlier, 0, "created")) + self.conn.commit() + data = (0, 0, 0, 0, earlier, 100, earlier) + + return data + + def update_account(self, nick, watting, anarchy, trickery, coins, last_mine, health, last_rest, log): + now = time.time() + self.c.execute("update players set watting=?, anarchy=?, trickery=?, coins=?, last_mine=?, health=?, last_rest=? where nickname=?", (watting, anarchy, trickery, coins, last_mine, health, last_rest, nick.lower())) + self.c.execute("insert into ledger(nickname, timestamp, balance, log) values(?, ?, ?, ?)", (nick.lower(), now, coins, log)) + if not log is None: + print "log: " + log + self.conn.commit() + + def close(self): + self.conn.close() + + def topten(self): + out = "" + self.c.execute("select nickname, coins from players order by coins desc limit 10") + while True: + d = self.c.fetchone() + if d == None: + break + out += d[0] + "(" + str(d[1]) + ") " + + return out + + def items(self): + out = "" + self.c.execute("select itemname, nickname, price from items order by itemname") + while True: + d = self.c.fetchone() + if d == None: + break + out += d[0] + "(" + d[1] + ", " + str(d[2]) + ") " + + return out + + def invent_item(self, itemname, nickname, price): + try: + self.c.execute("insert into items(itemname, nickname, price) values(?, ?, ?)", (itemname.lower(), nickname.lower(), price)) + self.conn.commit() + return True + except: + return False + + def inventory(self, nickname): + out = "" + self.c.execute("select itemname, count from inventory where nickname = ? order by itemname", (nickname.lower(),)) + while True: + d = self.c.fetchone() + if d == None: + break + out += d[0] + "(" + str(d[1]) + ") " + + return out + + def get_item(self, itemname): + self.c.execute("select itemname, nickname, price from items where itemname = ?", (itemname.lower(),)) + return self.c.fetchone() + + def get_item_count(self, nickname, itemname): + self.c.execute("select count from inventory where nickname = ? and itemname = ?", (nickname.lower(), itemname.lower())) + d = self.c.fetchone() + if d == None: + return 0 + else: + return d[0] + + def set_item_count(self, nickname, itemname, count): + if count == 0: + self.c.execute("delete from inventory where nickname = ? and itemname = ?", (nickname.lower(), itemname.lower())) + else: + if self.get_item_count(nickname, itemname) != 0: + self.c.execute("update inventory set count=? where nickname = ? and itemname = ?", (count, nickname.lower(), itemname.lower())) + else: + self.c.execute("insert into inventory(nickname, itemname, count) values(?, ?, ?)", (nickname.lower(), itemname.lower(), count)) + self.conn.commit() diff --git a/osrc/watbot_game.py b/osrc/watbot_game.py new file mode 100644 index 0000000..71c8c7b --- /dev/null +++ b/osrc/watbot_game.py @@ -0,0 +1,440 @@ +#!/usr/bin/python + +import time +import random +import math + +from watbot_player import WatbotPlayer + +class WatbotGame: + """Class containing the game logic""" + + def __init__(self, config, db): + random.seed() + + self.config = config + self.db = db + + self.bot_nick = config["bot_nick"] + self.bot_player = WatbotPlayer(self.db, self.bot_nick) + + self.quiet = False + + self.help_text = ( + "balance [], " + "watch [], " + "inventory [], " + "topten, " + "items, " + "mine, " + "transfer , " + "roll , " + "steal , " + "frame , " + "punch , " + "give , " + "invent , " + "create , " + + ) + + self.rules_text = ("A new account is created with 5 hours time credit. " + "Mining exchanges time credit for coins: " + "1h - 10h: 1 coin/h; >10h: 10 coin; >1 day: 50 coin; >1 month: 1000 coin.") + + def do_command(self, nick, command, args): + try: + player = WatbotPlayer(self.db, nick) + self.now = time.time() + + if command == "wat": + out = self.mega_wat(player) + + elif command == "speak" and (player.nick == "Burrito" or player.nick == "wuselfuzz"): + self.quiet = False + out = "wat!" + + elif command == "shutup" and (player.nick == "Burrito" or player.nick == "wuselfuzz"): + self.quiet = True + out = "wat." + + elif self.quiet: + out = None + + elif command == "help": + out = self.help_text + + elif command == "rules": + out = self.rules_text + + elif command == "topten": + out = self.db.topten() + + elif command == "items": + out = "temporarily disabled, because bug!" + #out = self.db.items() + + elif command == "inventory": + if len(args) > 0: + out = self.db.inventory(args[0]) + else: + out = self.db.inventory(player.nick) + + elif command == "watch": + if len(args) > 0: + out = self.watch(self.get_target_player(player, args[0])) + else: + out = self.watch(player) + + elif command == "balance": + if len(args) > 0: + out = self.balance(self.get_target_player(player, args[0])) + else: + out = self.balance(player) + + elif command == "mine": + out = self.mine(player) + + elif command == "transfer": + if len(args) < 2: + out = "transfer " + else: + out = self.transfer(player, self.get_target_player(player, args[0]), int(args[1])) + + elif player.health <= 0: + out = "You cannot do that while unconscious!" + +# ----- commands that require consciousness below ----- + + elif command == "steal": + if len(args) < 2: + out = "steal - rolls a d6. If <3, you steal coins. Otherwise, you pay a * 2 fine to "+ self.bot_nick + "." + else: + out = self.steal(player, self.get_target_player(player, args[0]), int(args[1])) + + elif command == "frame": + if len(args) < 2: + out = "frame - rolls a d6. If <3, you make pay a fine of coins to " + self.bot_nick + ". Otherwise, you pay a ceil(/2) to /2) to " + self.bot_nick + " as fines." + else: + out = self.frame(player, self.get_target_player(player, args[0]), int(args[1])) + + elif command == "punch": + if len(args) < 1: + out = "punch " + else: + out = self.punch(player, self.get_target_player(player, args[0])) + + elif command == "roll": + if len(args) < 1: + out = "roll - rolls a d100 against watcoinbot. result<50 wins , result >=50 loses " + else: + out = self.roll(player, int(args[0])) + + elif command == "invent": + if len(args) < 2: + out = "invent - invent an item called which can be bought for . An invention costs 100 coins." + else: + out = self.invent(player, args[0], int(args[1])) + + elif command == "create": + if len(args) < 2: + out = "create - create s. You have to pay the price and must be the inventor of the item!" + else: + out = self.create(player, args[0], int(args[1])) + + elif command == "give": + if len(args) < 3: + out = "give " + else: + out = self.give(player, args[0], int(args[1]), args[2]) + + else: + out = None + + return out + + except: + return "wat?" + + def get_target_player(self, player, target_nick): + if target_nick == player.nick: + return player + elif target_nick == self.bot_nick: + return self.bot_player + else: + return WatbotPlayer(self.db, target_nick) + + def watch(self, player): + out = ( + "Watting: " + str(player.watting) + "(" + str(player.watting_exp) + ") / " + + "Anarchy: " + str(player.anarchy) + "(" + str(player.anarchy_exp) + ") / " + + "Trickery: " + str(player.trickery) + "(" + str(player.trickery_exp) + ") " + + "Coins: " + str(player.coins) + " " + + "Health: " + str(player.health) + ) + return out + + def balance(self, player): + out = player.nick + "'s watcoin balance is " + str(player.coins) + ". Mining time credit: " + self.dhms(int(self.now - player.last_mine)) + " seconds." + return out + + def mine(self, player): + delta = self.now - player.last_mine + + if delta < 3600: + return "wat? not so soon again!" + + if delta < 36000: + mined_coins = int(delta / 3600) + elif delta < 86400: + mined_coins = 10 + elif delta < 2592000: + mined_coins = 50 + else: + mined_coins = 1000 + + player.coins += mined_coins + player.last_mine = self.now + + out = player.nick + " mined " + str(mined_coins) + " coins for " + self.dhms(int(delta)) + " seconds and now has " + str(player.coins) + " watcoins." + + player.update(out) + return out + + + def transfer(self, player, target_player, amount): + if amount < 0: + return "wat? you thief!" + + if player.coins < amount: + return "wat? you poor fuck don't have enough!" + + player.coins -= amount + target_player.coins += amount + + if amount != 1: + out = player.nick + " sent " + target_player.nick + " " +str(amount) + " watcoins." + else: + out = player.nick + " sent " + target_player.nick + " a watcoin." + + player.update(out) + target_player.update(out) + + return out + + def mega_wat(self, player): + + mega_number = random.randint(1,1000000) + kilo_number = random.randint(1,1000) + + print "mega_wat(" + player.nick + ") mega_number == " + str(mega_number) + ", kilo_number == " + str(kilo_number) + + out = None + + if mega_number == 23: + player.coins += 1000000 + out = "OMGWATWATWAT!!!! " + player.nick + " has won the MegaWat lottery and gains 1000000 watcoins!" + + if kilo_number == 5: + player.coins += 1000 + out = "OMGWAT! " + player.nick + " has won the KiloWat lottery and gains 1000 watcoins!" + + player.watting_exp += 1 + player.update(out) + + return out + + def roll(self, player, amount): + if amount < 0: + return "wat? nonono!" + + if player.coins < amount: + return "wat? you broke, go away!" + + if self.bot_player.coins < amount: + bot_mining_delta = self.now - self.bot_player.last_mine + if bot_mining_delta > 86400: + return self.bot_nick + " doesn't have enough coins for this, but " + self.bot_nick + " can mine! " + self.mine(self.bot_player) + self.roll(player, amount) + else: + return "wat? " + self.bot_nick + " only has " + str(bot_player.coins) + " wtc left. Try again later or beg someone to fund the bot. " + self.bot_nick + " will mine in " + str(self.dhms(int(86400 - bot_mining_delta))) + "." + + number = random.randint(1, 100) + + if number < 50: + player.coins += amount + player.trickery_exp += 1 + self.bot_player.coins -= amount + out = player.nick + " rolls a d100 (<50 wins): " + str(number) + ". You win! Your new balance is " + str(player.coins) + "." + else: + player.coins -= amount + self.bot_player.coins += amount + out = player.nick + " rolls a d100 (<50 wins): " + str(number) + ". You lose. Your new balance is " + str(player.coins) + "." + + player.update(out) + self.bot_player.update(out) + return out + + def invent(self, player, itemname, price): + if price <= 0: + return "wat? nonono!" + + invent_cost = 100 - player.watting + + if player.coins < invent_cost: + return "wat? inventions cost you " + str(invent_cost) + " coins, but you're poor!" + + if self.db.invent_item(itemname, player.nick, price): + player.coins -= invent_cost + self.bot_player.coins += invent_cost + out = player.nick + " invented " + itemname + " (" + str(price) + ")." + player.update(out) + self.bot_player.update(out) + else: + out = "wat?" + itemname + " already invented!" + + return out + + def create(self, player, itemname, count): + if count <= 0: + return "wat? nonono!" + + (itemname, inventor_nick, price) = self.db.get_item(itemname) + + if player.nick.lower() != inventor_nick: + return "wat? that's not your invention!" + + if count * price > player.coins: + return "wat? you need more money for that!" + + player.coins -= count * price + original_count = self.db.get_item_count(player.nick, itemname) + self.db.set_item_count(player.nick, itemname, original_count + count) + + out = player.nick + " created " + str(count) + " " + itemname + "." + player.update(out) + return out + + def give(self, player, target_nick, count, itemname): + player_item_count = self.db.get_item_count(player.nick, itemname) + if player_item_count < count: + return "wat? you don't have that many!" + + self.db.set_item_count(player.nick, itemname, player_item_count - count) + + target_item_count = self.db.get_item_count(target_nick, itemname) + self.db.set_item_count(target_nick, itemname, target_item_count + count) + + return player.nick + " gave " + target_nick + " " + str(count) + " " + itemname + + def steal(self, player, target_player, amount): + if amount < 0: + return "wat? nonono!" + + if player.coins < amount * 2: + return "wat? you don't have enough to pay the possible fine!" + + if target_player.coins < amount: + return "wat? " + target_player.nick + " is a poor fuck and doesn't have " + str(amount) + " coins." + + number = random.randint(1,6) + + if number <3: + out = player.nick + " rolls a d6 to steal " + str(amount) + " watcoins from " + target_player.nick + ": " + str(number) + " (<3 wins). You win! Sneaky bastard!" + player.coins += amount + player.anarchy_exp += 1 + target_player.coins -= amount + player.update(out) + target_player.update(out) + else: + out = player.nick + " rolls a d6 to steal " + str(amount) + " watcoins from " + target_player.nick + ": " + str(number) + " (<3 wins). You were caught and pay " + str(2 * amount) + " coins to " + self.bot_nick + "." + player.coins -= 2 * amount + self.bot_player.coins += 2 * amount + player.update(out) + self.bot_player.update(out) + + return out + + def frame(self, player, target_player, amount): + if amount < 0: + return "wat? nonono!" + + if player.coins < amount: + return "wat? you don't have enough to pay the possible fine!" + + if target_player.coins < amount: + return "wat? " + target_player.nick + " is a poor fuck and doesn't have " + str(amount) + " coins." + + number = random.randint(1,6) + + if number <3: + out = player.nick + " rolls a d6 to frame " + str(amount) + " watcoins from " + target_player.nick + ": " + str(number) + " (<3 wins). You win! " + target_player.nick + " pays " + str(amount) + " to " + self.bot_nick + "." + + player.anarchy_exp += 1 + target_player.coins -= amount + self.bot_player.coins += amount + player.update(out) + target_player.update(out) + self.bot_player.update(out) + else: + target_amount = int(math.ceil(float(amount)/2)) + bot_amount = int(math.floor(float(amount)/2)) + out = player.nick + " rolls a d6 to frame " + str(amount) + " watcoins from " + target_player.nick + ": " + str(number) + " (<3 wins). You were caught and pay " + str(target_amount) + " coins to " + target_player.nick + " and " + str(bot_amount) + " coins to " + self.bot_nick + "." + + player.coins -= amount + target_player.coins += target_amount + self.bot_player.coins += bot_amount + + player.update(out) + target_player.update(out) + self.bot_player.update(out) + + return out + + def punch(self, player, target_player): + + number = random.randint(1, 6) + dmg = random.randint(1, 6) + + if number <3: + dmg += player.anarchy + out = player.nick + " rolls a d6 to punch " + target_player.nick + ": " + str(number) +". " + player.nick + " hits for " + str(dmg) + " points of damage." + target_player.health -= dmg + if target_player.health <= 0: + out += " " + target_player.nick + " falls unconscious." + target_player.update(out) + else: + dmg += target_player.anarchy + out = player.nick + " rolls a d6 to punch " + target_player.nick + ": " + str(number) +". " + player.nick + " misses. " + target_player.nick + " punches back for " + str(dmg) + " points of damage." + player.health -= dmg + if player.health <= 0: + out += " " + player.nick + " falls unconscious." + player.update(out) + + return out + + def dhms(self, seconds): + days = int(seconds / 86400) + seconds -= days * 86400 + hours = int(seconds / 3600) + seconds -= hours * 3600 + minutes = int(seconds / 60) + seconds -= minutes * 60 + + out = "" + show = False + + if days > 0: + out += str(days) + "d " + show = True + + if hours > 0 or show: + out += str(hours) + "h " + show = True + + if minutes > 0 or show: + out += str(minutes) + "m " + show = True + + out += str(seconds) + "s" + return out + diff --git a/osrc/watbot_irc.py b/osrc/watbot_irc.py new file mode 100644 index 0000000..4360745 --- /dev/null +++ b/osrc/watbot_irc.py @@ -0,0 +1,102 @@ +#!/usr/bin/python + +import irc.client +import ssl + +class WatbotIRC: + """irc frontend class""" + + def __init__(self, config, game): + + self.config = config + self.game = game + + self.client = irc.client.IRC() + server = self.client.server() + + if not config["ssl"]: + server.connect( + config["server"], + config["port"], + config["bot_nick"], + username = config["bot_nick"], + ircname = (config["prefix"] + " help"), + ) + else: + ssl_factory = irc.connection.Factory(wrapper=ssl.wrap_socket) + server.connect( + config["server"], + config["port"], + config["bot_nick"], + username = config["bot_nick"], + ircname = (config["prefix"] + " help"), + connect_factory = ssl_factory + ) + + + self.client.add_global_handler("welcome", self.on_connect) + self.client.add_global_handler("privmsg", self.on_msg) + self.client.add_global_handler("pubmsg", self.on_msg) + self.client.add_global_handler("disconnect", self.on_disconnect) + + + def main_loop(self): + self.client.process_forever() + + def on_connect(self, connection, event): + if self.config["nickserv"]: + connection.privmsg("nickserv", "identify " + self.config["password"]) + + connection.join(self.config["channel"]) + + def on_msg(self, connection, event): + for a in event.arguments: + self.do_command(connection, event.source, event.target, a) + + def do_command(self, connection, source, target, commandline): + + cl_list = commandline.strip().split(" ", 2) + + if len(cl_list) > 0: + if cl_list[0].lower() == "wat": + cl_list = [ self.config["prefix"], "wat" ] + + if len(cl_list) < 2: + return + + if cl_list[0].lower() != self.config["prefix"]: + return + + command = cl_list[1].lower() + if len(cl_list) > 2: + args_list = cl_list[2].split(" ") + else: + args_list = [] + + if self.config["nickserv"]: + # The @ must be there, irc standard + host = source.split("@")[1] + host_split = host.split("/") + if len(host_split) < 3: + return + + # Only allow nickserved users + if host_split[0] != "tripsit": + return + + #nick = host_split[2] + nick = source.split("!", 1)[0] + + output = self.game.do_command(nick, command, args_list) + + + if target == self.config["bot_nick"]: + target = nick + + if not output is None: + connection.privmsg(target, output) + + def on_disconnect(self, connection, event): + raise SystemExit() + + diff --git a/osrc/watbot_player.py b/osrc/watbot_player.py new file mode 100644 index 0000000..5c4267b --- /dev/null +++ b/osrc/watbot_player.py @@ -0,0 +1,46 @@ +#!/usr/bin/python + +import time + +class WatbotPlayer: + """class representing a player account""" + + def __init__(self, db, nick): + self.nick = nick + self.db = db + + ( + self.watting_exp, + self.anarchy_exp, + self.trickery_exp, + self.coins, + self.last_mine, + self.health, + self.last_rest + ) = db.get_account(nick) + + self.watting = self.get_level(self.watting_exp) + self.anarchy = self.get_level(self.anarchy_exp) + self.trickery = self.get_level(self.trickery_exp) + + now = time.time() + delta = now - self.last_rest + if delta > 60: + self.health += int(delta/60) + if self.health > 10: + self.health = 10 + + self.last_rest += int(delta/60) * 60 + + def get_level(self, exp): + if exp < 100: + level = int(exp/10) + elif exp < 900: + level = 10 + int(exp/100) + else: + level = 99 + + return level + + def update(self, log): + self.db.update_account(self.nick, self.watting_exp, self.anarchy_exp, self.trickery_exp, self.coins, self.last_mine, self.health, self.last_rest, log)