import datetime, decimal, functools, math, random, re, secrets, time from src import ModuleManager, utils SIDES = {"heads": 0, "tails": 1} DEFAULT_REDEEM_DELAY = 600 # 600 seconds, 10 minutes DEFAULT_REDEEM_AMOUNT = "100.0" DEFAULT_INTEREST_RATE = "0.01" INTEREST_INTERVAL = 60*60 # 1 hour REGEX_FLOAT = re.compile("(?:\d+(?:\.\d{1,2}|$)|\.\d{1,2})") DEFAULT_MARKET_CAP = str(1_000_000_000) DECIMAL_ZERO = decimal.Decimal("0") DECIMAL_BET_MINIMUM = decimal.Decimal("0.01") HOUR_SECONDS = (1*60)*60 LOTTERY_INTERVAL = (60*60)*6 # 6 hours LOTTERY_BUYIN = "100.00" RED = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36] BLACK = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35] SMALL = range(1, 19) BIG = range(19, 37) FIRST_DOZEN = list(range(1, 13)) SECOND_DOZEN = list(range(13, 25)) THIRD_DOZEN = list(range(25, 37)) FIRST_COLUMN = list(range(1, 37))[0::3] SECOND_COLUMN = list(range(1, 37))[1::3] THIRD_COLUMN = list(range(1, 37))[2::3] REGEX_STREET = re.compile("street([1-9]|1[0-2])$") REGEX_DOUBLESTREET = re.compile("2street([1-9]|1[0-1])$") REGEX_CORNER = re.compile("([lr])corner([1-9]|1[0-1])$") WALLET_DEFAULT_NAME = "default" WALLET_DEFAULTS = {"in": WALLET_DEFAULT_NAME, "out": WALLET_DEFAULT_NAME, "interest": WALLET_DEFAULT_NAME, "lottery": WALLET_DEFAULT_NAME} class CoinParseException(Exception): pass class Module(ModuleManager.BaseModule): def on_load(self): self.timers.add("coin-interest", INTEREST_INTERVAL, time.time()+self._until_next_hour()) self.timers.add("coin-lottery", LOTTERY_INTERVAL, time.time()+self._until_next_6_hour()) def _until_next_hour(self, now=None): now = now or datetime.datetime.utcnow() until_next_hour = 60-now.second return until_next_hour+((60-(now.minute+1))*60) def _until_next_6_hour(self): now = datetime.datetime.utcnow() until_next_hour = self._until_next_hour(now) until_next_6_hour = (6-(now.hour%6))-1 until_next_6_hour = until_next_6_hour*HOUR_SECONDS return until_next_hour+until_next_6_hour def _get_pool(self, server): return decimal.Decimal(server.get_setting("coins", DEFAULT_MARKET_CAP)) def _set_pool(self, server, amount): server.set_setting("coins", self._coin_str(amount)) def _take_from_pool(self, server, amount): coins = self._get_pool(server) self._set_pool(server, coins-amount) def _give_to_pool(self, server, amount): coins = self._get_pool(server) self._set_pool(server, coins+amount) def _get_user_wallets(self, user): return user.get_setting("wallets", {WALLET_DEFAULT_NAME: "0.0"}) def _set_user_wallets(self, user, wallets): user.set_setting("wallets", wallets) def _reset_user_wallets(self, user): user.del_setting("wallets") def _user_has_wallet(self, user, wallet): return wallet.lower() in self._get_user_wallets(user) def _get_user_coins(self, user, wallet=WALLET_DEFAULT_NAME): wallets = self._get_user_wallets(user) return decimal.Decimal(wallets.get(wallet.lower(), "0.0")) def _get_all_user_coins(self, user): wallets = self._get_user_wallets(user) return sum(decimal.Decimal(amount) for amount in wallets.values()) def _set_user_coins(self, user, coins, wallet=WALLET_DEFAULT_NAME): wallets = self._get_user_wallets(user) wallets[wallet.lower()] = self._coin_str(coins) self._set_user_wallets(user, wallets) def _add_user_wallet(self, user, wallet): wallets = self._get_user_wallets(user) wallets[wallet.lower()] = "0.0" self._set_user_wallets(user, wallets) def _remove_user_wallet(self, user, wallet): wallets = self._get_user_wallets(user) del wallets[wallet.lower()] self._set_user_wallets(user, wallets) def _all_coins(self, server): coins = server.get_all_user_settings("wallets", []) for i, (nickname, wallet) in enumerate(coins): user_coins = sum(decimal.Decimal(v) for v in wallet.values()) coins[i] = (nickname, user_coins) return dict(filter(lambda coin: coin[1], coins)) def _redeem_amount(self, server): return decimal.Decimal(server.get_setting("redeem-amount", DEFAULT_REDEEM_AMOUNT)) def _redeem_delay(self, server): return server.get_setting("redeem-delay", DEFAULT_REDEEM_DELAY) def _give(self, server, user, amount, wallet=WALLET_DEFAULT_NAME): user_coins = self._get_user_coins(user, wallet) self._take_from_pool(server, amount) self._set_user_coins(user, user_coins+amount, wallet) return user_coins+amount def _take(self, server, user, amount, wallet=WALLET_DEFAULT_NAME): user_coins = self._get_user_coins(user, wallet) self._give_to_pool(server, amount) self._set_user_coins(user, user_coins-amount, wallet) return user_coins-amount def _move(self, user1, user2, amount, from_wallet=WALLET_DEFAULT_NAME, to_wallet=WALLET_DEFAULT_NAME): user1_coins = self._get_user_coins(user1, from_wallet) self._set_user_coins(user1, user1_coins-amount, from_wallet) user2_coins = self._get_user_coins(user2, to_wallet) self._set_user_coins(user2, user2_coins+amount, to_wallet) def _coin_str(self, coins): return "{0:.2f}".format(coins) def _coin_str_human(self, coins): return "{0:,.2f}".format(coins) def _parse_coins(self, s, minimum=None): try: s = utils.parse_number(s) except ValueError: pass match = REGEX_FLOAT.match(s) if match: coins = decimal.Decimal(match.group(0)) if minimum == None or coins >= minimum: return coins else: raise CoinParseException( "Coin amount provided is lower than %s" % minimum) else: raise CoinParseException( "Please provide a valid positive coin amount") def _get_default_wallets(self, user): return user.get_setting("default-wallets", WALLET_DEFAULTS.copy()) def _set_default_wallet(self, user, type, wallet): default_wallets = self._get_default_wallets(user) default_wallets[type.lower()] = wallet.lower() user.set_setting("default-wallets", default_wallets) def _default_wallet(self, user, type): default_wallets = self._get_default_wallets(user) return default_wallets.get(type.lower(), None) def _default_wallets(self, user): default_wallet_in = self._default_wallet(user, "in") default_wallet_out = self._default_wallet(user, "out") return default_wallet_in, default_wallet_out def _default_wallet_for(self, user, wallet): default_wallets = self._get_default_wallets(user) for key, value in default_wallets.items(): if value.lower() == wallet.lower(): return key def _parse_wallets(self, user, s): if not s: return self._default_wallets(user) if not ":" in s: return s, s wallet_in_default, wallet_out_default = self._default_wallets(user) wallet_1, _, wallet_2 = s.partition(":") wallet_1 = wallet_1.lower() or wallet_in_Default wallet_2 = wallet_2.lower() or wallet_out_default wallets = self._get_user_wallets(user) if not wallet_1 in wallets or not wallet_2 in wallets: raise utils.EventError("Unknown wallet") return wallet_1, wallet_2 @utils.hook("received.command.bank") def bank(self, event): """ :help: Show how many coins The Bank currently has """ event["stdout"].write("The Bank has %s coins" % self._coin_str(self._get_pool(event["server"]))) def _total_coins(self, server): all_coins = sum(self._all_coins(server).values()) return self._get_pool(server)+all_coins @utils.hook("received.command.totalcoins") def total_coins(self, event): """ :help: Show how many coins are currently in circulation """ event["stdout"].write("Total coins: %s" % self._coin_str( self._total_coins(event["server"]))) @utils.hook("received.command.coins") def coins(self, event): """ :help: Show how many coins you have """ if event["args_split"]: target = event["server"].get_user(event["args_split"][0]) else: target = event["user"] coins = self._get_all_user_coins(target) event["stdout"].write("%s has %s coin%s" % (target.nickname, self._coin_str_human(coins), "" if coins == 1 else "s")) @utils.hook("received.command.wallet") def wallet(self, event): """ :help: Show your wallets and their balances :usage: [wallet] """ if not event["args_split"]: wallets = self._get_user_wallets(event["user"]).keys() event["stdout"].write("%s: your available wallets are: %s" % (event["user"].nickname, ", ".join(wallets))) else: wallet = event["args"] if not self._user_has_wallet(event["user"], wallet): raise utils.EventError("%s: you don't have a '%s' wallet" % (event["user"].nickname, wallet)) coins = self._get_user_coins(event["user"], wallet) event["stdout"].write("%s: you have %s coins in your '%s' wallet" % (event["user"].nickname, self._coin_str_human(coins), wallet)) @utils.hook("received.command.addwallet", authenticated=True, min_args=1) def add_wallet(self, event): """ :help: Add a wallet to your account :usage: """ wallet = event["args_split"][0] if self._user_has_wallet(event["user"], wallet): raise utils.EventError("%s: you already have a '%s' wallet" % (event["user"].nickname, wallet)) self._add_user_wallet(event["user"], wallet) event["stdout"].write("%s: added a '%s' wallet" % ( event["user"].nickname, wallet)) @utils.hook("received.command.removewallet", authenticated=True, min_args=1) def remove_wallet(self, event): """ :help: Remove a wallet from your account :usage: """ wallet = event["args_split"][0] if not self._user_has_wallet(event["user"], wallet): raise utils.EventError("%s: you don't have a '%s' wallet" % (event["user"].nickname, wallet)) default_type = self._default_wallet_for(event["user"], wallet) if default_type: raise utils.EventError("%s: you cannot delete a default wallet " "('%s' is the default wallet for '%s')" % (event["user"].nickname, wallet, default_type)) coins = self._get_user_coins(event["user"], wallet) in_wallet = self._default_wallet(event["user"], "in") self._give(event["server"], event["user"], coins, in_wallet) self._remove_user_wallet(event["user"], wallet) event["stdout"].write("%s: removed wallet '%s' and shifted any funds " "to your default 'in' wallet" % (event["user"].nickname, wallet)) @utils.hook("received.command.defaultwallet", authenticated=True, min_args=1) def default_wallet(self, event): """ :help: Set a default wallet for a given wallet type :usage: [wallet] """ type = event["args_split"][0] if len(event["args_split"]) > 1: wallet = event["args_split"][1] if not self._user_has_wallet(event["user"], wallet): raise utils.EventError("%s: Unknown wallet" % event["user"].nickname) self._set_default_wallet(event["user"], type, wallet) event["stdout"].write("%s: Set default wallet for '%s' to '%s'" % (event["user"].nickname, type, wallet)) else: wallet = self._default_wallet(event["user"], type) event["stdout"].write("%s: Your default wallet for '%s' is '%s'" % (event["user"].nickname, type, wallet)) @utils.hook("received.command.resetcoins", min_args=1) def reset_coins(self, event): """ :help: Reset a user's coins to 0 :usage: :permission: resetcoins """ target = event["server"].get_user(event["args_split"][0]) coins = self._get_all_user_coins(target) self._take(event["server"], target, coins) self._reset_user_wallets(target) event["stdout"].write("Reset coins for %s" % target.nickname) @utils.hook("received.command.givecoins", min_args=1) def give_coins(self, event): """ :help: Give coins to a user :usage: [wallet] :permission: givecoins """ _, wallet_out = self._default_wallets(event["user"]) if len(event["args_split"]) > 2: _, wallet_out = self._parse_wallets(event["user"], event["args_split"][2]) target = event["server"].get_user(event["args_split"][0]) try: coins = self._parse_coins(event["args_split"][1], DECIMAL_ZERO) except CoinParseException as e: raise utils.EventError("%s: %s" % (event["user"].nickname, str(e))) self._give(event["server"], target, coins, wallet_out) event["stdout"].write("Gave '%s' %s coins" % (target.nickname, self._coin_str(coins))) @utils.hook("received.command.richest") def richest(self, event): """ :help: Show the top 10 richest users """ top_10 = utils.top_10(self._all_coins(event["server"]), convert_key=lambda nickname: utils.prevent_highlight( event["server"].get_user(nickname).nickname), value_format=lambda value: self._coin_str_human(value)) event["stdout"].write("Richest users: %s" % ", ".join(top_10)) def _redeem_cache(self, server, user): return "redeem|%s|%s@%s" % (server.id, user.username, user.hostname) @utils.hook("received.command.redeemcoins") def redeem_coins(self, event): """ :help: Redeem your free coins """ user_coins = self._get_all_user_coins(event["user"]) if user_coins == DECIMAL_ZERO: cache = self._redeem_cache(event["server"], event["user"]) if not self.bot.cache.has_item(cache): _, wallet_out = self._default_wallets(event["user"]) if len(event["args_split"]) > 0: _, wallet_out = self._parse_wallets(event["user"], event["args_split"][0]) redeem_amount = self._redeem_amount(event["server"]) self._give(event["server"], event["user"], redeem_amount, wallet_out) event["stdout"].write("Redeemed %s coins" % self._coin_str( redeem_amount)) redeem_delay = self._redeem_delay(event["server"]) self.bot.cache.temporary_cache(cache, redeem_delay) else: time_left = self.bot.cache.until_expiration(cache) event["stderr"].write("%s: Please wait %s before redeeming" % ( event["user"].nickname, utils.to_pretty_time(math.ceil(time_left)))) else: event["stderr"].write( "%s: You can only redeem coins when you have none" % event["user"].nickname) @utils.hook("received.command.flip", min_args=2, authenticated=True) def flip(self, event): """ :help: Bet on a coin flip :usage: heads|tails [wallet_in:wallet_out] """ wallet_in, wallet_out = self._default_wallets(event["user"]) if len(event["args_split"]) > 2: wallet_in, wallet_out = self._parse_wallets(event["user"], event["args_split"][2]) side_name = event["args_split"][0].lower() coin_bet = event["args_split"][1].lower() if coin_bet == "all": coin_bet = self._get_user_coins(event["user"], wallet_in) if coin_bet <= DECIMAL_ZERO: raise utils.EventError("%s: You have no coins to bet" % event["user"].nickname) else: try: coin_bet = self._parse_coins(coin_bet, DECIMAL_BET_MINIMUM) except CoinParseException as e: raise utils.EventError("%s: %s" % (event["user"].nickname, str(e))) if not side_name in SIDES: raise utils.EventError("%s: Please provide 'heads' or 'tails'" % event["user"].nickname) user_coins = self._get_user_coins(event["user"], wallet_in) if coin_bet > user_coins: raise utils.EventError("%s: You don't have enough coins to bet" % event["user"].nickname) chosen_side = secrets.choice(list(SIDES.keys())) win = side_name == chosen_side coin_bet_str = self._coin_str(coin_bet) if win: new_total = self._give(event["server"], event["user"], coin_bet, wallet_out) event["stdout"].write( "%s flips %s and wins %s coin%s! (new total: %s)" % ( event["user"].nickname, side_name, coin_bet_str, "" if coin_bet == 1 else "s", self._coin_str(new_total) ) ) else: self._take(event["server"], event["user"], coin_bet, wallet_in) event["stdout"].write( "%s flips %s and loses %s coin%s! (new total: %s)" % ( event["user"].nickname, side_name, coin_bet_str, "" if coin_bet == 1 else "s", self._coin_str(user_coins-coin_bet) ) ) @utils.hook("received.command.movecoins", authenticated=True, min_args=3) def move_coins(self, event): """ :help: Move coins between your wallets :usage: """ wallet_1 = event["args_split"][0] wallet_2 = event["args_split"][1] amount = self._parse_coins(event["args_split"][2], DECIMAL_ZERO) for wallet in [wallet_1, wallet_2]: if not self._user_has_wallet(event["user"], wallet): raise utils.EventError("%s: Unknown wallet '%s'" % (event["user"].nickname, wallet)) self._move(event["user"], event["user"], amount, wallet_1, wallet_2) event["stdout"].write("%s: Moved %s coins from wallet '%s' to " "wallet '%s'" % (event["user"].nickname, self._coin_str(amount), wallet_1, wallet_2)) @utils.hook("received.command.sendcoins", min_args=2, authenticated=True) def send(self, event): """ :help: Send coins to another user :usage: [wallet_in:wallet_out] """ target_user = event["server"].get_user(event["args_split"][0]) wallet_in, _ = self._default_wallets(event["user"]) _, wallet_out = self._default_wallets(target_user) if len(event["args_split"]) > 2: wallet_in, _ = self._parse_wallets(event["user"], event["args_split"][2]) _, wallet_out = self._parse_wallets(target_user, event["args_split"][2]) if event["user"].get_id() == target_user.get_id(): raise utils.EventError("%s: You can't send coins to yourself" % event["user"].nickname) send_amount = event["args_split"][1] try: send_amount = self._parse_coins(send_amount, DECIMAL_ZERO) except CoinParseException as e: raise utils.EventError("%s: %s" % (event["user"].nickname, str(e))) user_coins = self._get_user_coins(event["user"], wallet_in) redeem_amount = self._redeem_amount(event["server"]) new_total_coins = self._get_all_user_coins(event["user"])-send_amount if user_coins == DECIMAL_ZERO: raise utils.EventError("%s: You have no coins" % event["user"].nickname) elif new_total_coins < redeem_amount: raise utils.EventError( "%s: You cannot send an amount of money that puts" " you below %s coins" % ( event["user"].nickname, self._coin_str(redeem_amount))) target_user_coins = self._get_user_coins(target_user, wallet_out) if target_user_coins == None: raise utils.EventError("%s: You can only send coins to users that " "have had coins before" % event["user"].nickname) self._move(event["user"], target_user, send_amount, wallet_in, wallet_out) event["stdout"].write("%s sent %s coins to %s" % ( event["user"].nickname, self._coin_str(send_amount), target_user.nickname)) def _double_street(self, i): return (i*3)-2, (i*3)+3 @utils.hook("received.command.roulette", min_args=2, authenticated=True) def roulette(self, event): """ :help: Spin a roulette wheel :usage: [wallet_in:wallet_out] """ expected_args = 1 expected_args += len(event["args_split"][0].split(",")) wallet_in, wallet_out = self._default_wallets(event["user"]) if len(event["args_split"]) > expected_args: wallet_in, wallet_out = self._parse_wallets(event["user"], event["args_split"][expected_args]) bets = event["args_split"][0].lower().split(",") if "0" in bets: raise utils.EventError("%s: You can't bet on 0" % event["user"].nickname) bet_amounts = [amount.lower() for amount in event["args_split"][ 1:expected_args]] if len(bet_amounts) < len(bets): raise utils.EventError("%s: Please provide an amount for each bet" % event["user"].nickname) if len(bet_amounts) == 1 and bet_amounts[0] == "all": bet_amounts[0] = self._get_user_coins(event["user"], wallet_in) if bet_amounts[0] <= DECIMAL_ZERO: raise utils.EventError("%s: You have no coins to bet" % event["user"].nickname) bet_amounts[0] = self._coin_str(bet_amounts[0]) for i, bet_amount in enumerate(bet_amounts): try: bet_amounts[i] = self._parse_coins(bet_amount, DECIMAL_BET_MINIMUM) except CoinParseException as e: raise utils.EventError("%s: %s" % (event["user"].nickname, str(e))) bet_amount_total = sum(bet_amounts) user_coins = self._get_user_coins(event["user"], wallet_in) if bet_amount_total > user_coins: raise utils.EventError("%s: You don't have enough coins to bet" % event["user"].nickname) self._take(event["server"], event["user"], bet_amount_total, wallet_in) # black, red, odds, evens, low (1-18), high (19-36) # 1dozen (1-12), 2dozen (13-24), 3dozen (25-36) # 1column (1,4..34), 2column (2,5..35), 3column (3,6..36) choice = secrets.randbelow(37) winnings = {} losses = {} if choice == 0: event["stdout"].write("Roulette spin lands on 0, " "the house wins, %s loses %s" % ( event["user"].nickname, bet_amount_total)) return colour = "red" if choice in RED else "black" for i, bet in enumerate(bets): street_match = REGEX_STREET.match(bet) doublestreet_match = REGEX_DOUBLESTREET.match(bet) corner_match = REGEX_CORNER.match(bet) odds = 0 if bet == "even": odds = 1*((choice % 2) == 0) elif bet == "odd": odds = 1*((choice % 2) == 1) elif bet == "red": odds = 1*(choice in RED) elif bet == "black": odds = 1*(choice in BLACK) elif bet == "small" or bet == "low": odds = 1*(choice in SMALL) elif bet == "big" or bet == "high": odds = 1*(choice in BIG) elif bet == "dozen1": odds = 2*(choice in FIRST_DOZEN) elif bet == "dozen2": odds = 2*(choice in SECOND_DOZEN) elif bet == "dozen3": odds = 2*(choice in THIRD_DOZEN) elif bet == "column1": odds = 2*(choice in FIRST_COLUMN) elif bet == "column2": odds = 2*(choice in SECOND_COLUMN) elif bet == "column3": odds = 2*(choice in THIRD_COLUMN) elif street_match: row = int(street_match.group(1)) odds = 11*(((row*3)-2) <= choice <= (row*3)) elif doublestreet_match: row = int(doublestreet_match.group(1)) min_num, max_num = self._double_street(row) odds = 5*(min_num <= choice <= max_num) elif corner_match: row = int(corner_match.group(2)) min_num, max_num = self._double_street(row) numbers = list(range(min_num, max_num+1)) if corner_match.group(1) == "l": numbers = numbers[:2] + numbers[3:5] else: numbers = numbers[1:3] + numbers[-2:] odds = 8*(choice in numbers) elif bet.isdigit() and (1 <= int(bet) <= 36): odds = 35*(choice == int(bet)) else: raise utils.EventError("%s: Unknown bet" % event["user"].nickname) if odds == 0: losses[bet] = bet_amounts[i] else: winnings[bet] = [odds, bet_amounts[i]] winnings_str = ["%s for %s (%d to 1)" % ( winnings[bet][1]*winnings[bet][0], bet, winnings[bet][0]) for bet in winnings.keys()] coin_winnings = DECIMAL_ZERO for odds, amount in winnings.values(): coin_winnings += amount # give back bet coin_winnings += amount*odds # give winnings coin_losses = sum(loss for loss in losses.values()) if coin_winnings: self._give(event["server"], event["user"], coin_winnings, wallet_out) total_winnings_str = " (%s total)" % coin_winnings if len( winnings.keys()) > 1 else "" choice = "%d %s" % (choice, colour) if not losses and winnings: event["stdout"].write("Roulette spin lands on %s, " "%s wins %s%s" % (choice, event["user"].nickname, ", ".join(winnings_str), total_winnings_str)) elif losses and winnings: event["stdout"].write("Roulette spin lands on %s, " "%s wins %s%s; loses %s" % (choice, event["user"].nickname, ", ".join(winnings_str), str(total_winnings_str), str(coin_losses))) else: event["stdout"].write("Roulette spin lands on %s, " "%s loses %s" % (choice, event["user"].nickname, str(coin_losses))) @utils.hook("timer.coin-interest") def interest(self, event): for server in self.bot.servers.values(): all_coins = self._all_coins(server) interest_rate = decimal.Decimal(server.get_setting( "interest-rate", DEFAULT_INTEREST_RATE)) redeem_amount = self._redeem_amount(server) for nickname, coins in all_coins.items(): if coins > redeem_amount: interest = round(coins*interest_rate, 2) self._take_from_pool(server, interest) wallets = server.get_user_setting(nickname, "wallets", {}) default_wallet = self._default_wallet( server.get_user(nickname), "interest") default_coins = wallets.get(default_wallet, "0.0") default_coins = decimal.Decimal(default_coins) wallets[default_wallet] = self._coin_str( default_coins+interest) server.set_user_setting(nickname, "wallets", wallets) event["timer"].redo() @utils.hook("received.command.lotterybuy", authenticated=True) def lottery_buy(self, event): """ :help: Buy ticket(s) for the lottery :usage: [amount] [wallet] """ wallet_in, _ = self._default_wallets(event["user"]) if len(event["args_split"]) > 0: wallet_in, _ = self._parse_wallets(event["user"], event["args_split"][0]) amount = 1 if event["args_split"]: amount = event["args_split"][0] if not amount.isdigit(): raise utils.EventError("%s: Please provide a positive number " "of tickets to buy" % event["user"].nickname) amount = int(amount) user_coins = self._get_user_coins(event["user"], wallet_in) coin_amount = decimal.Decimal(LOTTERY_BUYIN)*amount if coin_amount > user_coins: raise utils.EventError("%s: You don't have enough coins" % event["user"].nickname) self._take(event["server"], event["user"], coin_amount, wallet_in) lottery = event["server"].get_setting("lottery", {}) nickname = event["user"].nickname_lower if not nickname in lottery: lottery[nickname] = 0 lottery[nickname] += amount event["server"].set_setting("lottery", lottery) event["stdout"].write("%s: You bought %d lottery ticket%s for %s" % ( event["user"].nickname, amount, "" if amount == 1 else "s", self._coin_str(coin_amount))) @utils.hook("received.command.mylottery") def my_lottery(self, event): """ :help: Show how many lottery tickets you currently have """ lottery = event["server"].get_setting("lottery", {}) count = lottery.get(event["user"].nickname_lower, 0) event["stdout"].write("%s: You have %d lottery ticket%s" % ( event["user"].nickname, count, "" if count == 1 else "s")) @utils.hook("received.command.jackpot") def jackpot(self, event): """ :help: Show the current lottery jackpot """ lottery = event["server"].get_setting("lottery", {}) count = sum(value for nickname, value in lottery.items()) event["stdout"].write("%s: The current jackpot is %s" % ( event["user"].nickname, decimal.Decimal(LOTTERY_BUYIN)*count)) @utils.hook("received.command.nextlottery") def next_lottery(self, event): """ :help: Show time until the next lottery draw """ until = self._until_next_6_hour() event["stdout"].write("Next lottery is in: %s" % utils.to_pretty_time(until)) @utils.hook("received.command.lotterywinner") def lottery_winner(self, event): """ :help: Show who last won the lottery """ winner = event["server"].get_setting("lottery-winner", None) if winner: event["stdout"].write("Last lottery winner: %s" % winner) else: event["stderr"].write("There have been no lottery winners!") @utils.hook("timer.coin-lottery") def lottery(self, event): for server in self.bot.servers.values(): lottery = server.get_setting("lottery", {}) if lottery: server.del_setting("lottery") else: continue users = [(nickname,)*value for nickname, value in lottery.items()] users = functools.reduce(lambda x, y: x+y, users) winner = random.choice(users) user = server.get_user(winner) coins = self._get_user_coins(user) winnings = decimal.Decimal(LOTTERY_BUYIN)*len(users) new_coins = coins+winnings wallet = self._default_wallet(user, "lottery") self._give(server, user, winnings, wallet) server.set_setting("lottery-winner", user.nickname) user.send_notice("You won %s in the lottery! you now have %s coins" % (self._coin_str(winnings), self._coin_str(new_coins))) event["timer"].redo()