async def revive(cmd): time_now = int(time.time()) response = "" if cmd.message.channel.name != ewcfg.channel_endlesswar and cmd.message.channel.name != ewcfg.channel_sewers: response = "Come to me. I hunger. #{}.".format(ewcfg.channel_sewers) else: player_data = EwUser(member = cmd.message.author) slimeoid = EwSlimeoid(member = cmd.message.author) if player_data.life_state == ewcfg.life_state_corpse: market_data = EwMarket(id_server = cmd.message.server.id) # Endless War collects his fee. fee = (player_data.slimecredit / 10) player_data.change_slimecredit(n = -fee, coinsource = ewcfg.coinsource_revival) market_data.slimes_revivefee += fee player_data.busted = False # Preserve negaslime if player_data.slimes < 0: market_data.negaslime += player_data.slimes player_data.change_slimes(n = -player_data.slimes) # set to 0 # Give player some initial slimes. player_data.slimelevel = 0 player_data.change_slimes(n = ewcfg.slimes_onrevive) # Set time of last revive. This used to provied spawn protection, but currently isn't used. player_data.time_lastrevive = time_now # Set life state. This is what determines whether the player is actually alive. player_data.life_state = ewcfg.life_state_juvenile # Get the player out of the sewers. Will be endless-war eventually. player_data.poi = ewcfg.poi_id_downtown player_data.persist() market_data.persist() # Give some slimes to every living player (currently online) for member in cmd.message.server.members: if member.id != cmd.message.author.id and member.id != cmd.client.user.id: member_data = EwUser(member = member) if member_data.life_state != ewcfg.life_state_corpse and member_data.life_state != ewcfg.life_state_grandfoe: member_data.change_slimes(n = ewcfg.slimes_onrevive_everyone) member_data.persist() await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author) response = '{slime4} A geyser of fresh slime erupts, showering Rowdy, Killer, and Juvenile alike. {slime4} {name} has been reborn in slime. {slime4}'.format(slime4 = ewcfg.emote_slime4, name = cmd.message.author.display_name) else: response = 'You\'re not dead just yet.' # deathreport = "You were {} by {}. {}".format(kill_descriptor, cmd.message.author.display_name, ewcfg.emote_slimeskull) # deathreport = "{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage(member, deathreport) if slimeoid.life_state == ewcfg.slimeoid_state_active: reunite = "" brain = ewcfg.brain_map.get(slimeoid.ai) reunite += brain.str_revive.format( slimeoid_name = slimeoid.name ) downtownchannel = ewutils.get_channel(cmd.message.server, ewcfg.channel_downtown) reunite = ewutils.formatMessage(cmd.message.author, reunite) await cmd.client.send_message(downtownchannel, reunite) # Send the response to the player. await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def order(cmd): user_data = EwUser(member=cmd.message.author) poi = ewcfg.id_to_poi.get(user_data.poi) if (poi == None) or (len(poi.vendors) == 0): # Only allowed in the food court. response = ewcfg.str_food_channelreq.format(action="order") else: value = None togo = False if cmd.tokens_count > 1: for token in cmd.tokens[1:]: if token.startswith('<@') == False and token.lower( ) not in "togo": # togo can be spelled together or separate value = token break for token in cmd.tokens[1:]: if token.lower( ) in "togo": # lets people get away with just typing only to or only go (or only t etc.) but whatever togo = True break food = ewcfg.food_map.get(value.lower() if value != None else value) if food != None and food.vendor == ewcfg.vendor_vendingmachine: togo = True member = None if not togo: # cant order togo for someone else, you can just give it to them in person if cmd.mentions_count == 1: member = cmd.mentions[0] if member.id == cmd.message.author.id: member = None member_data = EwUser(member=member) if food == None or food.vendor not in poi.vendors: response = "Check the {} for a list of items you can {}.".format( ewcfg.cmd_menu, ewcfg.cmd_order) elif member is not None and member_data.poi != user_data.poi: response = "The delivery service has become unavailable due to unforeseen circumstances." else: market_data = EwMarket(id_server=cmd.message.server.id) target_data = None if member != None: target_data = EwUser(member=member) value = food.price if not togo else food.price * ewcfg.togo_price_increase # Kingpins eat free. if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe: value = 0 if value > user_data.slimecredit: # Not enough money. response = "A {food} is {cost:,} SlimeCoin (and you only have {credits:,}).".format( food=food.str_name, cost=value, credits=user_data.slimecredit) else: user_data.change_slimecredit( n=-value, coinsource=ewcfg.coinsource_spending) if not togo: if target_data != None: target_data.hunger -= food.recover_hunger if target_data.hunger < 0: target_data.hunger = 0 target_data.inebriation += food.inebriation if target_data.inebriation > ewcfg.inebriation_max: target_data.inebriation = ewcfg.inebriation_max if food.id_food == "coleslaw": target_data.ghostbust = True else: user_data.hunger -= food.recover_hunger if user_data.hunger < 0: user_data.hunger = 0 user_data.inebriation += food.inebriation if user_data.inebriation > ewcfg.inebriation_max: user_data.inebriation = ewcfg.inebriation_max if food.id_food == "coleslaw": user_data.ghostbust = True else: # if it's togo inv = ewitem.inventory(id_user=cmd.message.author.id, id_server=cmd.message.server.id) food_in_inv = 0 for item in inv: if item.get('item_type') == ewcfg.it_food: food_in_inv += 1 if food_in_inv >= math.ceil( user_data.slimelevel / ewcfg.max_food_in_inv_mod): # user_data never got persisted so the player won't lose money unnecessarily response = "You can't carry any more food than that." return await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) item_props = { 'food_name': food.str_name, 'food_desc': food.str_desc, 'recover_hunger': food.recover_hunger, 'price': food.price, 'inebriation': food.inebriation, 'vendor': food.vendor, 'str_eat': food.str_eat, 'time_expir': time.time() + (food.time_expir if food.time_expir is not None else ewcfg.std_food_expir) } ewitem.item_create(item_type=ewcfg.it_food, id_user=cmd.message.author.id, id_server=cmd.message.server.id, item_props=item_props) response = "You slam {cost:,} SlimeCoin down at the {vendor} for a {food}{togo}{sharetext}{flavor}".format( cost=value, vendor=food.vendor, food=food.str_name, togo=" to go" if togo else "", sharetext=(". " if member == None else " and give it to {}.\n\n{}".format( member.display_name, ewutils.formatMessage(member, ""))), flavor=food.str_eat if not togo else "") if member == None and user_data.hunger <= 0 and not togo: response += "\n\nYou're stuffed!" user_data.persist() market_data.persist() if target_data != None: target_data.persist() # Send the response to the player. await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def xfer(cmd): time_now = int(time.time()) if cmd.message.channel.name != ewcfg.channel_stockexchange: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="transfer") await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) return if cmd.mentions_count != 1: # Must have exactly one target to send to. response = "Mention the player you want to send SlimeCoin to." await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) return member = cmd.mentions[0] target_data = EwUser(member=member) if target_data.life_state == ewcfg.life_state_kingpin: # Disallow transfers to RF and CK kingpins. response = "You can't transfer SlimeCoin to a known criminal warlord." await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) return user_data = EwUser(member=cmd.message.author) market_data = EwMarket(id_server=cmd.message.author.server.id) # Parse the slime value to send. value = None if cmd.tokens_count > 1: value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True) if value != None: if value < 0: value = user_data.slimes if value <= 0: value = None if value != None: # Cost including the 5% transfer fee. cost_total = int(value * 1.05) if user_data.slimecredit < cost_total: response = "You don't have enough SlimeCoin. ({:,}/{:,})".format( user_data.slimecredit, cost_total) else: # Do the transfer if the player can afford it. target_data.change_slimecredit( n=value, coinsource=ewcfg.coinsource_transfer) user_data.change_slimecredit(n=-cost_total, coinsource=ewcfg.coinsource_transfer) user_data.time_lastinvest = time_now # Persist changes response = "You transfer {slime:,} SlimeCoin to {target_name}. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format( slime=value, target_name=member.display_name, fee=(cost_total - value)) user_data.persist() target_data.persist() else: response = ewcfg.str_exchange_specify.format(currency="SlimeCoin", action="transfer") # Send the response to the player. await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def data(cmd): resp = await start(cmd = cmd) response = "" user_data = None roles_map_user = {} if cmd.mentions_count == 0: roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member = cmd.message.author, conn = conn, cursor = cursor) market_data = EwMarket(id_server = cmd.message.server.id, conn = conn, cursor = cursor) new_level = 0 # Ghosts don't have a slime level. if ewcfg.role_corpse not in roles_map_user: new_level = len(str(int(user_data.slimes))) # Update the user's slime level. if new_level > user_data.slimelevel: user_data.slimelevel = new_level user_data.persist(conn = conn, cursor = cursor) conn.commit() finally: cursor.close() conn.close() # return my data if ewcfg.role_corpse in roles_map_user: response = "You are a level {} deadboi.".format(user_data.slimelevel) else: response = "You are a level {} slimeboi.".format(user_data.slimelevel) coinbounty = int(user_data.bounty / (market_data.rate_exchange / 1000000.0)) weapon = ewcfg.weapon_map.get(user_data.weapon) if weapon != None: response += " {} {}{}.".format(ewcfg.str_weapon_wielding_self, ("" if len(user_data.weaponname) == 0 else "{}, ".format(user_data.weaponname)), weapon.str_weapon) if user_data.weaponskill >= 5: response += " {}".format(weapon.str_weaponmaster_self.format(rank = (user_data.weaponskill - 4))) trauma = ewcfg.weapon_map.get(user_data.trauma) if trauma != None: response += " {}".format(trauma.str_trauma_self) if user_data.kills > 0: response += " You have {:,} confirmed kills.".format(user_data.kills) if coinbounty != 0: response += " SlimeCorp offers a bounty of {:,} SlimeCoin for your death.".format(coinbounty) if user_data.stamina > 0: response += " You are {}% hungry.".format(user_data.stamina * 100.0 / ewcfg.stamina_max) else: member = cmd.mentions[0] roles_map_user = ewutils.getRoleMap(member.roles) try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member = member, conn = conn, cursor = cursor) market_data = EwMarket(id_server = cmd.message.server.id, conn = conn, cursor = cursor) new_level = 0 if ewcfg.role_corpse not in roles_map_target: new_level = len(str(int(user_data.slimes))) if new_level > user_data.slimelevel: user_data.slimelevel = new_level user_data.persist(conn = conn, cursor = cursor) conn.commit() finally: cursor.close() conn.close() # return somebody's score if ewcfg.role_corpse in roles_map_target: response = "{} is a level {} deadboi.".format(member.display_name, user_data.slimelevel) else: response = "{} is a level {} slimeboi.".format(member.display_name, user_data.slimelevel) coinbounty = int(user_data.bounty / (market_data.rate_exchange / 1000000.0)) weapon = ewcfg.weapon_map.get(user_data.weapon) if weapon != None: response += " {} {}{}.".format(ewcfg.str_weapon_wielding, ("" if len(user_data.weaponname) == 0 else "{}, ".format(user_data.weaponname)), weapon.str_weapon) if user_data.weaponskill >= 5: response += " {}".format(weapon.str_weaponmaster.format(rank = (user_data.weaponskill - 4))) trauma = ewcfg.weapon_map.get(user_data.trauma) if trauma != None: response += " {}".format(trauma.str_trauma) if user_data.kills > 0: response += " They have {:,} confirmed kills.".format(user_data.kills) if coinbounty != 0: response += " SlimeCorp offers a bounty of {:,} SlimeCoin for their death.".format(coinbounty) # Update the user's slime level if they're alive. if user_data != None: new_level = 0 if ewcfg.role_corpse not in roles_map_user: new_level = len(str(int(user_data.slimes))) if new_level > user_data.slimelevel: user_data.slimelevel = new_level user_data.persist() # Send the response to the player. await cmd.client.edit_message(resp, ewutils.formatMessage(cmd.message.author, response))
async def on_ready(): ewutils.logMsg('Logged in as {} ({}).'.format(client.user.name, client.user.id)) ewutils.logMsg("Loaded NLACakaNM world map. ({}x{})".format( ewmap.map_width, ewmap.map_height)) ewmap.map_draw() # Flatten role names to all lowercase, no spaces. for poi in ewcfg.poi_list: if poi.role != None: poi.role = ewutils.mapRoleName(poi.role) await client.change_presence(game=discord.Game(name=("dev. by @krak " + ewcfg.version))) # Look for a Twitch client_id on disk. # FIXME debug - temporarily disable Twitch integration if False: twitch_client_id = ewutils.getTwitchClientId() # If no twitch client ID is available, twitch integration will be disabled. # FIXME debug - temporarily disable Twitch integration. if True: twich_client_id = None ewutils.logMsg('Twitch integration disabled.') elif twitch_client_id == None or len(twitch_client_id) == 0: ewutils.logMsg( 'No twitch_client_id file found. Twitch integration disabled.') else: ewutils.logMsg("Enabled Twitch integration.") # Channels in the connected discord servers to announce to. channels_announcement = [] # Channels in the connected discord servers to send stock market updates to. Map of server ID to channel. channels_stockmarket = {} for server in client.servers: # Update server data in the database ewserver.server_update(server=server) # store the list of channels in an ewutils field ewcfg.update_server_list(server=server) # Grep around for channels ewutils.logMsg("connected to server: {}".format(server.name)) for channel in server.channels: if (channel.type == discord.ChannelType.text): if (channel.name == ewcfg.channel_twitch_announcement): channels_announcement.append(channel) ewutils.logMsg( "• found channel for announcements: {}".format( channel.name)) elif (channel.name == ewcfg.channel_stockexchange): channels_stockmarket[server.id] = channel ewutils.logMsg( "• found channel for stock exchange: {}".format( channel.name)) # create all the districts in the database for poi in ewcfg.capturable_districts: # call the constructor to create an entry if it doesnt exist yet dist = EwDistrict(id_server=server.id, district=poi) # change the ownership to the faction that's already in control to initialize topic names try: await dist.change_ownership(new_owner=dist.controlling_faction, actor="init", client=client) except: ewutils.logMsg( 'Could not change ownership for {} to "{}".'.format( poi, dist.controlling_faction)) asyncio.ensure_future( ewdistrict.capture_tick_loop(id_server=server.id)) try: ewutils.logMsg('Creating message queue directory.') os.mkdir(ewcfg.dir_msgqueue) except FileExistsError: ewutils.logMsg('Message queue directory already exists.') ewutils.logMsg('Ready.') ewcfg.set_client(client) """ Set up for infinite loop to perform periodic tasks. """ time_now = int(time.time()) time_last_twitch = time_now time_twitch_downed = 0 # Every three hours we log a message saying the periodic task hook is still active. On startup, we want this to happen within about 60 seconds, and then on the normal 3 hour interval. time_last_logged = time_now - ewcfg.update_hookstillactive + 60 stream_live = None ewutils.logMsg('Beginning periodic hook loop.') while True: time_now = int(time.time()) # Periodic message to log that this stuff is still running. if (time_now - time_last_logged) >= ewcfg.update_hookstillactive: time_last_logged = time_now ewutils.logMsg("Periodic hook still active.") # Check to see if a stream is live via the Twitch API. # FIXME disabled if False: #if twitch_client_id != None and (time_now - time_last_twitch) >= ewcfg.update_twitch: time_last_twitch = time_now try: # Twitch API call to see if there are any active streams. json_string = "" p = subprocess.Popen( "curl -H 'Client-ID: {}' -X GET 'https://api.twitch.tv/helix/streams?user_login = rowdyfrickerscopkillers' 2>/dev/null" .format(twitch_client_id), shell=True, stdout=subprocess.PIPE) for line in p.stdout.readlines(): json_string += line.decode('utf-8') json_parsed = json.loads(json_string) # When a stream is up, data is an array of stream information objects. data = json_parsed.get('data') if data != None: data_count = len(data) stream_was_live = stream_live stream_live = True if data_count > 0 else False if stream_was_live == True and stream_live == False: time_twitch_downed = time_now if stream_was_live == False and stream_live == True and ( time_now - time_twitch_downed) > 600: ewutils.logMsg("The stream is now live.") # The stream has transitioned from offline to online. Make an announcement! for channel in channels_announcement: await client.send_message( channel, "ATTENTION CITIZENS. THE **ROWDY F****R** AND THE **COP KILLER** ARE **STREAMING**. BEWARE OF INCREASED KILLER AND ROWDY ACTIVITY.\n\n@everyone\n{}" .format( "https://www.twitch.tv/rowdyfrickerscopkillers" )) except: ewutils.logMsg( 'Twitch handler hit an exception (continuing): {}'.format( json_string)) traceback.print_exc(file=sys.stdout) # Adjust the exchange rate of slime for the market. try: for server in client.servers: # Load market data from the database. market_data = EwMarket(id_server=server.id) if market_data.time_lasttick + ewcfg.update_market <= time_now: market_data.time_lasttick = time_now # Advance the time and potentially change weather. market_data.clock += 1 if market_data.clock >= 24 or market_data.clock < 0: market_data.clock = 0 market_data.day += 1 if random.randrange(30) == 0: pattern_count = len(ewcfg.weather_list) if pattern_count > 1: weather_old = market_data.weather # Randomly select a new weather pattern. Try again if we get the same one we currently have. while market_data.weather == weather_old: pick = random.randrange(len( ewcfg.weather_list)) market_data.weather = ewcfg.weather_list[ pick].name # Log message for statistics tracking. ewutils.logMsg( "The weather changed. It's now {}.".format( market_data.weather)) # Persist new data. market_data.persist() # Decay slime totals ewutils.decaySlimes(id_server=server.id) # Increase hunger for all players below the max. ewutils.pushupServerHunger(id_server=server.id) # Decrease inebriation for all players above min (0). ewutils.pushdownServerInebriation(id_server=server.id) await ewdistrict.give_kingpins_slime_and_decay_capture_points( id_server=server.id) # Post leaderboards at 6am NLACakaNM time. if market_data.clock == 6: await ewleaderboard.post_leaderboards(client=client, server=server) except: ewutils.logMsg( 'An error occurred in the scheduled slime market update task:') traceback.print_exc(file=sys.stdout) # Parse files dumped into the msgqueue directory and send messages as needed. try: for msg_file in os.listdir(ewcfg.dir_msgqueue): fname = "{}/{}".format(ewcfg.dir_msgqueue, msg_file) msg = ewutils.readMessage(fname) os.remove(fname) msg_channel_names = [] msg_channel_names_reverb = [] if msg.channel != None: msg_channel_names.append(msg.channel) if msg.poi != None: poi = ewcfg.id_to_poi.get(msg.poi) if poi != None: if poi.channel != None and len(poi.channel) > 0: msg_channel_names.append(poi.channel) if msg.reverb == True: pois_adjacent = ewmap.path_to(poi_start=msg.poi) for poi_adjacent in pois_adjacent: if poi_adjacent.channel != None and len( poi_adjacent.channel) > 0: msg_channel_names_reverb.append( poi_adjacent.channel) if len(msg_channel_names) == 0: ewutils.logMsg( 'in file {} message for channel {} (reverb {})\n{}'. format(msg_file, msg.channel, msg.reverb, msg.message)) else: # Send messages to every connected server. for server in client.servers: for channel in server.channels: if channel.name in msg_channel_names: await client.send_message( channel, "**{}**".format(msg.message)) elif channel.name in msg_channel_names_reverb: await client.send_message( channel, "**Something is happening nearby...\n\n{}**" .format(msg.message)) except: ewutils.logMsg( 'An error occurred while trying to process the message queue:') traceback.print_exc(file=sys.stdout) # Wait a while before running periodic tasks. await asyncio.sleep(15)
async def order(cmd): resp = await ewcmd.start(cmd=cmd) if cmd.message.channel.name != ewcfg.channel_foodcourt: # Only allowed in the food court. response = ewcfg.str_food_channelreq.format(action="order") else: value = None if cmd.tokens_count > 1: for token in cmd.tokens[1:]: if token.startswith('<@') == False: value = token break food = ewcfg.food_map.get(value) member = None if cmd.mentions_count == 1: member = cmd.mentions[0] if member.id == cmd.message.author.id: member = None if food == None: response = "Check the {} for a list of items you can {}.".format( ewcfg.cmd_menu, ewcfg.cmd_order) else: try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.server.id, conn=conn, cursor=cursor) target_data = None if member != None: target_data = EwUser(member=member, conn=conn, cursor=cursor) finally: cursor.close() conn.close() value = int(food.price / (market_data.rate_exchange / 1000000.0)) if value <= 0: value = 1 # Kingpins eat free. roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) if ewcfg.role_rowdyfucker in roles_map_user or ewcfg.role_copkiller in roles_map_user: value = 0 if value > user_data.slimecredit: # Not enough money. response = "A {food} is {cost:,} SlimeCoin (and you only have {credits:,}).".format( food=food.str_name, cost=value, credits=user_data.slimecredit) else: user_data.slimecredit -= value if target_data != None: target_data.stamina -= food.recover_stamina if target_data.stamina < 0: target_data.stamina = 0 target_data.inebriation += food.inebriation if target_data.inebriation > 20: target_data.inebriation = 20 else: user_data.stamina -= food.recover_stamina if user_data.stamina < 0: user_data.stamina = 0 user_data.inebriation += food.inebriation if user_data.inebriation > 20: user_data.inebriation = 20 market_data.slimes_casino += food.price response = "You slam {cost:,} SlimeCoin down at the {vendor} for a {food}{sharetext}{flavor}".format( cost=value, vendor=food.vendor, food=food.str_name, sharetext=(". " if member == None else " and give it to {}.\n\n{}".format( member.display_name, ewutils.formatMessage(member, ""))), flavor=food.str_eat) if member == None and user_data.stamina <= 0: response += "\n\nYou're stuffed!" try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) market_data.persist(conn=conn, cursor=cursor) if target_data != None: target_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def mine(cmd): market_data = EwMarket(id_server=cmd.message.author.server.id) user_data = EwUser(member=cmd.message.author) time_now = int(time.time()) # Kingpins can't mine. if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe: return # ghosts cant mine (anymore) if user_data.life_state == ewcfg.life_state_corpse: return await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You can't mine while you're dead. Try {}.".format( ewcfg.cmd_revive))) # Enlisted players only mine at certain times. if user_data.life_state == ewcfg.life_state_enlisted: if user_data.faction == ewcfg.faction_rowdys and ( market_data.clock < 8 or market_data.clock > 17): return await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage( cmd.message.author, "Rowdies only mine in the daytime. Wait for full daylight at 8am." .format(ewcfg.cmd_revive))) if user_data.faction == ewcfg.faction_killers and ( market_data.clock < 20 and market_data.clock > 5): return await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage( cmd.message.author, "Killers only mine under cover of darkness. Wait for nightfall at 8pm." .format(ewcfg.cmd_revive))) # Mine only in the mines. if cmd.message.channel.name in [ ewcfg.channel_mines, ewcfg.channel_cv_mines, ewcfg.channel_tt_mines ]: if user_data.hunger >= ewutils.hunger_max_bylevel( user_data.slimelevel): global last_mismined_times mismined = last_mismined_times.get(cmd.message.author.id) if mismined == None: mismined = {'time': time_now, 'count': 0} if time_now - mismined['time'] < 5: mismined['count'] += 1 else: # Reset counter. mismined['time'] = time_now mismined['count'] = 1 last_mismined_times[cmd.message.author.id] = mismined if mismined[ 'count'] >= 7: # up to 6 messages can be buffered by discord and people have been dying unfairly because of that # Death last_mismined_times[cmd.message.author.id] = None user_data.die(cause=ewcfg.cause_mining) user_data.persist() await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You have died in a mining accident.")) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) sewerchannel = ewutils.get_channel(cmd.message.server, ewcfg.channel_sewers) await cmd.client.send_message( sewerchannel, "{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage( cmd.message.author, "You have died in a mining accident. {}".format( ewcfg.emote_slimeskull))) else: await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You've exhausted yourself from mining. You'll need some refreshment before getting back to work." )) else: # Determine if a poudrin is found. poudrin = False poudrinamount = 0 # juvies get poudrins 4 times as often as enlisted players poudrin_rarity = ewcfg.poudrin_rarity / ( 2 if user_data.life_state == ewcfg.life_state_juvenile else 1) poudrin_mined = random.randint(1, poudrin_rarity) if poudrin_mined == 1: poudrin = True poudrinamount = 1 if random.randint( 1, 3) != 1 else 2 # 33% chance of extra drop user_initial_level = user_data.slimelevel # Add mined slime to the user. slime_bylevel = ewutils.slime_bylevel(user_data.slimelevel) mining_yield = math.floor((slime_bylevel / 10) + 1) alternate_yield = math.floor(200 + slime_bylevel**(1 / math.e)) mining_yield = min(mining_yield, alternate_yield) user_data.change_slimes(n=mining_yield, source=ewcfg.source_mining) was_levelup = True if user_initial_level < user_data.slimelevel else False # Create and give slime poudrins for pdx in range(poudrinamount): item_id = ewitem.item_create( item_type=ewcfg.it_slimepoudrin, id_user=cmd.message.author.id, id_server=cmd.message.server.id, ) ewutils.logMsg( 'Created poudrin (item {}) for user (id {})'.format( item_id, cmd.message.author.id)) # Fatigue the miner. hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel) extra = hunger_cost_mod - int( hunger_cost_mod ) # extra is the fractional part of hunger_cost_mod user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod) if extra > 0: # if hunger_cost_mod is not an integer # there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100) if random.randint(1, 100) <= extra * 100: user_data.hunger += ewcfg.hunger_permine user_data.persist() # Tell the player their slime level increased and/or a poudrin was found. if was_levelup or poudrin: response = "" if poudrin: if poudrinamount == 1: response += "You unearthed a slime poudrin! " elif poudrinamount == 2: response += "You unearthed two slime poudrins! " ewstats.change_stat(user=user_data, metric=ewcfg.stat_lifetime_poudrins, n=poudrinamount) ewutils.logMsg('{} has found {} poudrin(s)!'.format( cmd.message.author.display_name, poudrinamount)) if was_levelup: response += "You have been empowered by slime and are now a level {} slimeboi!".format( user_data.slimelevel) await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) else: # Mismined. Potentially kill the player for spamming the wrong channel. mismined = last_mismined_times.get(cmd.message.author.id) if mismined == None: mismined = {'time': time_now, 'count': 0} if time_now - mismined['time'] < 5: mismined['count'] += 1 else: # Reset counter. mismined['time'] = time_now mismined['count'] = 1 last_mismined_times[cmd.message.author.id] = mismined if mismined['count'] >= 5: # Death last_mismined_times[cmd.message.author.id] = None user_data.die(cause=ewcfg.cause_mining) user_data.persist() await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You have died in a mining accident.")) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) sewerchannel = ewutils.get_channel(cmd.message.server, ewcfg.channel_sewers) await cmd.client.send_message( sewerchannel, "{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage( cmd.message.author, "You have died in a mining accident. {}".format( ewcfg.emote_slimeskull))) else: await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You can't mine here. Go to the mines."))
async def pachinko(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) global last_pachinkoed_times last_used = last_pachinkoed_times.get(cmd.message.author.id) if last_used == None: last_used = 0 response = "" if last_used + 10 > time_now: response = "**ENOUGH**" elif cmd.message.channel.name != ewcfg.channel_casino: # Only allowed in the slime casino. response = "You must go to the #{} to gamble your SlimeCoin.".format( ewcfg.channel_casino) else: last_pachinkoed_times[cmd.message.author.id] = time_now value = ewcfg.slimes_perpachinko try: conn = ewutils.databaseConnect() cursor = conn.cursor() market_data = EwMarket(id_server=cmd.message.server.id, conn=conn, cursor=cursor) user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) finally: cursor.close() conn.close() if ewcmd.is_casino_open(market_data.clock) == False: response = ewcfg.str_casino_closed elif value > user_data.slimecredit: response = "You don't have enough SlimeCoin to play." else: #subtract slimecoin from player user_data.slimecredit -= value user_data.persist() await cmd.client.edit_message( resp, ewutils.formatMessage( cmd.message.author, "You insert {:,} SlimeCoin. Balls begin to drop!".format( ewcfg.slimes_perpachinko))) await asyncio.sleep(3) ball_count = 10 response = "" winballs = 0 # Drop ball_count balls while ball_count > 0: ball_count -= 1 roll = random.randint(1, 5) response += "\n*plink*" # Add a varying number of plinks to make it feel more random. plinks = random.randint(1, 4) while plinks > 0: plinks -= 1 response += " *plink*" response += " PLUNK" # 1/5 chance to win. if roll == 5: response += " ... **ding!**" winballs += 1 await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) await asyncio.sleep(1) winnings = winballs * 250 try: conn = ewutils.databaseConnect() cursor = conn.cursor() # Significant time has passed since the user issued this command. We can't trust that their data hasn't changed. user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) # add winnings user_data.slimecredit += winnings user_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() if winnings > 0: response += "\n\n**You won {:,} SlimeCoin!**".format(winnings) else: response += "\n\nYou lost your SlimeCoin." # Allow the player to pachinko again now that we're done. last_pachinkoed_times[cmd.message.author.id] = 0 # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def attack(cmd): resp = await ewcmd.start(cmd) time_now = int(time.time()) response = "" user_data = EwUser(member=cmd.message.author) if cmd.message.channel.name != ewcfg.channel_combatzone: response = "You must go to the #{} to commit gang violence.".format( ewcfg.channel_combatzone) elif cmd.mentions_count > 1: response = "One shot at a time!" elif cmd.mentions_count <= 0: response = "Your bloodlust is appreciated, but ENDLESS WAR didn\'t understand that name." elif user_data.stamina >= ewcfg.stamina_max: response = "You are too exhausted for gang violence right now. Go get some grub!" elif cmd.mentions_count == 1: # The roles assigned to the author of this message. roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) # Get shooting player's info try: conn = ewutils.databaseConnect() cursor = conn.cursor() if user_data.slimelevel <= 0: user_data.slimelevel = 1 # Flag the shooter for PvP no matter what happens next. user_data.time_expirpvp = ewutils.calculatePvpTimer( user_data.time_expirpvp, (time_now + ewcfg.time_pvp_kill)) user_data.persist(conn=conn, cursor=cursor) # Get target's info. member = cmd.mentions[0] shootee_data = EwUser(member=member, conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() miss = False crit = False strikes = 0 # Shot player's assigned Discord roles. roles_map_target = ewutils.getRoleMap(member.roles) # Slime level data. Levels are in powers of 10. slimes_bylevel = int((10**user_data.slimelevel) / 10) slimes_spent = int(slimes_bylevel / 10) slimes_damage = int((slimes_bylevel / 5.0) * (100 + (user_data.weaponskill * 5)) / 100.0) slimes_dropped = shootee_data.totaldamage fumble_chance = (random.randrange(10) - 4) if fumble_chance > user_data.weaponskill: miss = True user_iskillers = ewcfg.role_copkillers in roles_map_user or ewcfg.role_copkillers in roles_map_user user_isrowdys = ewcfg.role_rowdyfuckers in roles_map_user or ewcfg.role_rowdyfucker in roles_map_user # Add the PvP flag role. await ewutils.add_pvp_role(cmd=cmd) if ewcfg.role_copkiller in roles_map_target or ewcfg.role_rowdyfucker in roles_map_target: # Disallow killing generals. response = "He is hiding in his ivory tower and playing video games like a retard." elif (slimes_spent > user_data.slimes): # Not enough slime to shoot. response = "You don't have enough slime to attack. ({:,}/{:,})".format( user_data.slimes, slimes_spent) elif (time_now - user_data.time_lastkill) < ewcfg.cd_kill: # disallow kill if the player has killed recently response = "Take a moment to appreciate your last slaughter." elif shootee_data.id_killer == user_data.id_user: # Don't allow the shootee to be shot by the same player twice. response = "You have already proven your superiority over {}.".format( member.display_name) elif time_now > shootee_data.time_expirpvp: # Target is not flagged for PvP. response = "{} is not mired in the ENDLESS WAR right now.".format( member.display_name) elif user_iskillers == False and user_isrowdys == False: # Only killers, rowdys, the cop killer, and rowdy f****r can shoot people. if ewcfg.role_juvenile in roles_map_user: response = "Juveniles lack the moral fiber necessary for violence." else: response = "You lack the moral fiber necessary for violence." elif ewcfg.role_corpse in roles_map_target: # Target is already dead. response = "{} is already dead.".format(member.display_name) elif (time_now - shootee_data.time_lastrevive) < ewcfg.invuln_onrevive: # User is currently invulnerable. response = "{} has died too recently and is immune.".format( member.display_name) else: # Slimes from this shot might be awarded to the boss. role_boss = (ewcfg.role_copkiller if user_iskillers else ewcfg.role_rowdyfucker) boss_slimes = 0 role_corpse = cmd.roles_map[ewcfg.role_corpse] was_juvenile = False was_killed = False was_shot = False if (user_iskillers and (ewcfg.role_rowdyfuckers in roles_map_target)) or ( user_isrowdys and (ewcfg.role_copkillers in roles_map_target)) or ( ewcfg.role_juvenile in roles_map_target): # User can be shot. if ewcfg.role_juvenile in roles_map_target: was_juvenile = True was_shot = True if was_shot: #stamina drain user_data.stamina += ewcfg.stamina_pershot # Weaponized flavor text. weapon = ewcfg.weapon_map.get(user_data.weapon) randombodypart = ewcfg.hitzone_list[random.randrange( len(ewcfg.hitzone_list))] # Weapon-specific adjustments if weapon != None and weapon.fn_effect != None: # Build effect container ctn = EwEffectContainer(miss=miss, crit=crit, slimes_damage=slimes_damage, slimes_spent=slimes_spent, user_data=user_data, shootee_data=shootee_data) # Make adjustments weapon.fn_effect(ctn) # Apply effects for non-reference values miss = ctn.miss crit = ctn.crit slimes_damage = ctn.slimes_damage slimes_spent = ctn.slimes_spent strikes = ctn.strikes # user_data and shootee_data should be passed by reference, so there's no need to assign them back from the effect container. if miss: slimes_damage = 0 # Remove !revive invulnerability. user_data.time_lastrevive = 0 user_data.slimes -= slimes_spent # Remove repeat killing protection if. if user_data.id_killer == shootee_data.id_user: user_data.id_killer = "" # Don't allow attacking to cause you to go negative. if user_data.slimes < 0: user_data.slimes = 0 if slimes_damage >= shootee_data.slimes: was_killed = True if was_killed: # Move around slime as a result of the shot. if shootee_data.slimes > 0: if was_juvenile: user_data.slimes += (slimes_dropped + shootee_data.slimes) user_data.slimepoudrins += shootee_data.slimepoudrins else: market_data = EwMarket( id_server=cmd.message.server.id) coinbounty = int( shootee_data.bounty / (market_data.rate_exchange / 1000000.0)) user_data.slimecredit += coinbounty user_data.slimes += int(slimes_dropped / 2) user_data.slimepoudrins += shootee_data.slimepoudrins boss_slimes += int(slimes_dropped / 2) # Player was killed. shootee_data.totaldamage += shootee_data.slimes shootee_data.slimes = 0 shootee_data.slimepoudrins = 0 shootee_data.id_killer = user_data.id_user shootee_data.bounty = 0 if weapon != None: response = weapon.str_damage.format( name_player=cmd.message.author.display_name, name_target=member.display_name, hitzone=randombodypart, strikes=strikes) if crit: response += " {}".format( weapon.str_crit.format( name_player=cmd.message.author. display_name, name_target=member.display_name)) response += "\n\n{}".format( weapon.str_kill.format( name_player=cmd.message.author.display_name, name_target=member.display_name, emote_skull=ewcfg.emote_slimeskull)) shootee_data.trauma = weapon.id_weapon else: response = "{name_target} is hit!!\n\n{name_target} has died.".format( name_target=member.display_name) shootee_data.trauma = "" #adjust kills bounty user_data.kills += 1 user_data.bounty += int((shootee_data.bounty / 2) + (shootee_data.totaldamage / 4)) # Give a bonus to the player's weapon skill for killing a stronger player. if shootee_data.slimelevel > user_data.slimelevel: user_data.weaponskill += 1 else: # A non-lethal blow! shootee_data.slimes -= slimes_damage shootee_data.totaldamage += slimes_damage if weapon != None: if miss: response = "{}".format( weapon.str_miss.format( name_player=cmd.message.author. display_name, name_target=member.display_name)) else: response = weapon.str_damage.format( name_player=cmd.message.author.display_name, name_target=member.display_name, hitzone=randombodypart, strikes=strikes) if crit: response += " {}".format( weapon.str_crit.format( name_player=cmd.message.author. display_name, name_target=member.display_name)) else: if miss: response = "{} is unharmed.".format( member.display_name) else: response = "{} is hit!!".format( member.display_name) else: response = 'ENDLESS WAR finds this betrayal stinky. He will not allow you to slaughter {}.'.format( member.display_name) # Level up the player if appropriate. new_level = len(str(int(user_data.slimes))) if new_level > user_data.slimelevel: response += "\n\n{} has been empowered by slime and is now a level {} slimeboi!".format( cmd.message.author.display_name, new_level) user_data.slimelevel = new_level # Give slimes to the boss if possible. boss_member = None if boss_slimes > 0: for member_search in cmd.message.server.members: if role_boss in ewutils.getRoleMap(member_search.roles): boss_member = member_search break # Persist every users' data. try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) shootee_data.persist(conn=conn, cursor=cursor) if boss_member != None: boss_data = EwUser(member=boss_member, conn=conn, cursor=cursor) boss_data.slimes += boss_slimes boss_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() # Assign the corpse role to the newly dead player. if was_killed: await cmd.client.replace_roles(member, role_corpse) # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def craps(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) global last_crapsed_times last_used = last_crapsed_times.get(cmd.message.author.id) if last_used == None: last_used = 0 if last_used + 2 > time_now: response = "**ENOUGH**" elif cmd.message.channel.name != ewcfg.channel_casino: # Only allowed in the slime casino. response = "You must go to the #{} to gamble your SlimeCoin.".format( ewcfg.channel_casino) else: last_crapsed_times[cmd.message.author.id] = time_now value = None if cmd.tokens_count > 1: value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True) if value != None: try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.author.server.id, conn=conn, cursor=cursor) finally: cursor.close() conn.close() if ewcmd.is_casino_open(market_data.clock) == False: response = ewcfg.str_casino_closed elif value > user_data.slimecredit: response = "You don't have that much SlimeCoin to bet with." else: user_data.slimecredit -= value roll1 = random.randint(1, 6) roll2 = random.randint(1, 6) emotes_dice = [ ewcfg.emote_dice1, ewcfg.emote_dice2, ewcfg.emote_dice3, ewcfg.emote_dice4, ewcfg.emote_dice5, ewcfg.emote_dice6 ] response = " {} {}".format(emotes_dice[roll1 - 1], emotes_dice[roll2 - 1]) if (roll1 + roll2) == 7: winnings = 5 * value response += "\n\n**You rolled a 7! It's your lucky day. You won {:,} SlimeCoin.**".format( winnings) user_data.slimecredit += winnings else: response += "\n\nYou didn't roll 7. You lost your SlimeCoins." try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) market_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() else: response = "Specify how much SlimeCoin you will wager." # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def slots(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) global last_slotsed_times last_used = last_slotsed_times.get(cmd.message.author.id) if last_used == None: last_used = 0 if last_used + 30 > time_now: # Rate limit slot machine action. response = "**ENOUGH**" elif cmd.message.channel.name != ewcfg.channel_casino: # Only allowed in the slime casino. response = "You must go to the #{} to gamble your SlimeCoin.".format( ewcfg.channel_casino) else: value = ewcfg.slimes_perslot last_slotsed_times[cmd.message.author.id] = time_now try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.author.server.id, conn=conn, cursor=cursor) finally: cursor.close() conn.close() if ewcmd.is_casino_open(market_data.clock) == False: response = ewcfg.str_casino_closed elif value > user_data.slimecredit: response = "You don't have enough SlimeCoin." else: #subtract slimecoin from player user_data.slimecredit -= value user_data.persist() # Add some suspense... await cmd.client.edit_message( resp, ewutils.formatMessage( cmd.message.author, "You insert {:,} SlimeCoin and pull the handle...".format( ewcfg.slimes_perslot))) await asyncio.sleep(3) slots = [ ewcfg.emote_tacobell, ewcfg.emote_pizzahut, ewcfg.emote_kfc, ewcfg.emote_moon, ewcfg.emote_111, ewcfg.emote_copkiller, ewcfg.emote_rowdyfucker, ewcfg.emote_theeye ] slots_len = len(slots) # Roll those tumblers! spins = 3 while spins > 0: await cmd.client.edit_message( resp, ewutils.formatMessage( cmd.message.author, "{} {} {}".format( slots[random.randrange(0, slots_len)], slots[random.randrange(0, slots_len)], slots[random.randrange(0, slots_len)]))) await asyncio.sleep(1) spins -= 1 # Determine the final state. roll1 = slots[random.randrange(0, slots_len)] roll2 = slots[random.randrange(0, slots_len)] roll3 = slots[random.randrange(0, slots_len)] response = "{} {} {}".format(roll1, roll2, roll3) winnings = 0 # Determine winnings. if roll1 == ewcfg.emote_tacobell and roll2 == ewcfg.emote_tacobell and roll3 == ewcfg.emote_tacobell: winnings = 5 * value response += "\n\n**¡Ándale! ¡Arriba! The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_pizzahut and roll2 == ewcfg.emote_pizzahut and roll3 == ewcfg.emote_pizzahut: winnings = 5 * value response += "\n\n**Oven-fired goodness! The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_kfc and roll2 == ewcfg.emote_kfc and roll3 == ewcfg.emote_kfc: winnings = 5 * value response += "\n\n**The Colonel's dead eyes unnerve you deeply. The machine spits out {:,} SlimeCoin.**".format( winnings) elif (roll1 == ewcfg.emote_tacobell or roll1 == ewcfg.emote_kfc or roll1 == ewcfg.emote_pizzahut) and ( roll2 == ewcfg.emote_tacobell or roll2 == ewcfg.emote_kfc or roll2 == ewcfg.emote_pizzahut) and ( roll3 == ewcfg.emote_tacobell or roll3 == ewcfg.emote_kfc or roll3 == ewcfg.emote_pizzahut): winnings = value response += "\n\n**You dine on fast food. The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_moon and roll2 == ewcfg.emote_moon and roll3 == ewcfg.emote_moon: winnings = 5 * value response += "\n\n**Tonight seems like a good night for VIOLENCE. The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_111 and roll2 == ewcfg.emote_111 and roll3 == ewcfg.emote_111: winnings = 1111 response += "\n\n**111111111111111111111111111111111111111111111111**\n\n**The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_copkiller and roll2 == ewcfg.emote_copkiller and roll3 == ewcfg.emote_copkiller: winnings = 40 * value response += "\n\n**How handsome!! The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_rowdyfucker and roll2 == ewcfg.emote_rowdyfucker and roll3 == ewcfg.emote_rowdyfucker: winnings = 40 * value response += "\n\n**So powerful!! The machine spits out {:,} SlimeCoin.**".format( winnings) elif roll1 == ewcfg.emote_theeye and roll2 == ewcfg.emote_theeye and roll3 == ewcfg.emote_theeye: winnings = 350 * value response += "\n\n**JACKPOT!! The machine spews forth {:,} SlimeCoin!**".format( winnings) else: response += "\n\n*Nothing happens...*" # Add winnings (if there were any) and save the user data. try: conn = ewutils.databaseConnect() cursor = conn.cursor() # Significant time has passed since the user issued this command. We can't trust that their data hasn't changed. user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) # add winnings user_data.slimecredit += winnings user_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() last_slotsed_times[cmd.message.author.id] = 0 # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def data(cmd): response = "" user_data = None member = None if cmd.mentions_count == 0: user_data = EwUser(member=cmd.message.author) market_data = EwMarket(id_server=cmd.message.server.id) poi = ewcfg.id_to_poi.get(user_data.poi) if poi != None: response = "You find yourself {} {}. ".format( poi.str_in, poi.str_name) # return my data if user_data.life_state == ewcfg.life_state_corpse: response += "You are a level {} deadboi.".format( user_data.slimelevel) else: response += "You are a level {} slimeboi.".format( user_data.slimelevel) coinbounty = int(user_data.bounty / ewcfg.slimecoin_exchangerate) weapon = ewcfg.weapon_map.get(user_data.weapon) if weapon != None: response += " {} {}{}.".format( ewcfg.str_weapon_wielding_self, ("" if len(user_data.weaponname) == 0 else "{}, ".format( user_data.weaponname)), weapon.str_weapon) if user_data.weaponskill >= 5: response += " {}".format( weapon.str_weaponmaster_self.format( rank=(user_data.weaponskill - 4))) trauma = ewcfg.weapon_map.get(user_data.trauma) if trauma != None: response += " {}".format(trauma.str_trauma_self) user_kills = ewstats.get_stat(user=user_data, metric=ewcfg.stat_kills) if user_kills > 0: response += " You have {:,} confirmed kills.".format(user_kills) if coinbounty != 0: response += " SlimeCorp offers a bounty of {:,} SlimeCoin for your death.".format( coinbounty) if user_data.hunger > 0: response += " You are {}% hungry.".format( round( user_data.hunger * 100.0 / ewutils.hunger_max_bylevel(user_data.slimelevel), 1)) if user_data.ghostbust: response += " The coleslaw in your stomach enables you to bust ghosts." if user_data.busted and user_data.life_state == ewcfg.life_state_corpse: response += " You are busted and therefore cannot leave the sewers without reviving." else: member = cmd.mentions[0] user_data = EwUser(member=member) market_data = EwMarket(id_server=cmd.message.server.id) if user_data.life_state == ewcfg.life_state_grandfoe: poi = ewcfg.id_to_poi.get(user_data.poi) if poi != None: response = "{} is {} {}.".format(member.display_name, poi.str_in, poi.str_name) else: response = "You can't discern anything useful about {}.".format( member.display_name) else: # return somebody's score if user_data.life_state == ewcfg.life_state_corpse: response = "{} is a level {} deadboi.".format( member.display_name, user_data.slimelevel) else: response = "{} is a level {} slimeboi.".format( member.display_name, user_data.slimelevel) coinbounty = int(user_data.bounty / ewcfg.slimecoin_exchangerate) weapon = ewcfg.weapon_map.get(user_data.weapon) if weapon != None: response += " {} {}{}.".format( ewcfg.str_weapon_wielding, ("" if len(user_data.weaponname) == 0 else "{}, ".format( user_data.weaponname)), weapon.str_weapon) if user_data.weaponskill >= 5: response += " {}".format( weapon.str_weaponmaster.format( rank=(user_data.weaponskill - 4))) trauma = ewcfg.weapon_map.get(user_data.trauma) if trauma != None: response += " {}".format(trauma.str_trauma) user_kills = ewstats.get_stat(user=user_data, metric=ewcfg.stat_kills) if user_kills > 0: response += " They have {:,} confirmed kills.".format( user_kills) if coinbounty != 0: response += " SlimeCorp offers a bounty of {:,} SlimeCoin for their death.".format( coinbounty) # Send the response to the player. await cmd.client.send_message( cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) if member != None: await ewrolemgr.updateRoles(client=cmd.client, member=member)
async def invest(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) if cmd.message.channel.name != ewcfg.channel_stockexchange: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="slime", action="invest") await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) return roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) if ewcfg.role_rowdyfucker in roles_map_user or ewcfg.role_copkiller in roles_map_user: # Disallow investments by RF and CK kingpins. response = "You're too powerful to be playing the market." await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) return try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.author.server.id, conn=conn, cursor=cursor) finally: cursor.close() conn.close() if market_data.clock >= 18 or market_data.clock < 6: response = ewcfg.str_exchange_closed else: value = None if cmd.tokens_count > 1: value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True) if value != None: if value < 0: value = user_data.slimes if value <= 0: value = None if value != None: # Apply a brokerage fee of ~5% (rate * 1.05) rate_exchange = (market_data.rate_exchange / 1000000.0) feerate = 1.05 # The user can only buy a whole number of credits, so adjust their cost based on the actual number of credits purchased. gross_credits = int(value / rate_exchange) fee = int((gross_credits * feerate) - gross_credits) net_credits = gross_credits - fee if value > user_data.slimes: response = "You don't have that much slime to invest." elif user_data.time_lastinvest + ewcfg.cd_invest > time_now: # Limit frequency of investments. response = ewcfg.str_exchange_busy.format(action="invest") else: user_data.slimes -= value user_data.slimecredit += net_credits user_data.time_lastinvest = time_now market_data.slimes_casino += value response = "You invest {slime:,} slime and receive {credit:,} SlimeCoin. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format( slime=value, credit=net_credits, fee=fee) try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) market_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() else: response = ewcfg.str_exchange_specify.format(currency="slime", action="invest") # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def xfer(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) if cmd.message.channel.name != ewcfg.channel_stockexchange: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="transfer") await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) return if cmd.mentions_count != 1: # Must have exactly one target to send to. response = "Mention the player you want to send SlimeCoin to." await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) return member = cmd.mentions[0] roles_map_target = ewutils.getRoleMap(member.roles) if ewcfg.role_rowdyfucker in roles_map_target or ewcfg.role_copkiller in roles_map_target: # Disallow transfers to RF and CK kingpins. response = "You can't transfer SlimeCoin to a known criminal warlord." await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) return try: conn = ewutils.databaseConnect() cursor = conn.cursor() target_data = EwUser(member=member, conn=conn, cursor=cursor) user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.author.server.id, conn=conn, cursor=cursor) finally: cursor.close() conn.close() if market_data.clock >= 18 or market_data.clock < 6: response = ewcfg.str_exchange_closed else: # Parse the slime value to send. value = None if cmd.tokens_count > 1: value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True) if value != None: if value < 0: value = user_data.slimes if value <= 0: value = None if value != None: # Cost including the 5% transfer fee. cost_total = int(value * 1.05) if user_data.slimecredit < cost_total: response = "You don't have enough SlimeCoin. ({:,}/{:,})".format( user_data.slimecredit, cost_total) elif user_data.time_lastinvest + ewcfg.cd_invest > time_now: # Limit frequency of investments. response = ewcfg.str_exchange_busy.format(action="transfer") else: # Do the transfer if the player can afford it. target_data.slimecredit += value user_data.slimecredit -= cost_total user_data.time_lastinvest = time_now # Persist changes response = "You transfer {slime:,} SlimeCoin to {target_name}. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format( slime=value, target_name=member.display_name, fee=(cost_total - value)) try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) target_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() else: response = ewcfg.str_exchange_specify.format(currency="SlimeCoin", action="transfer") # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def withdraw(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) if cmd.message.channel.name != ewcfg.channel_stockexchange: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="withdraw") await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response)) return try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.author.server.id, conn=conn, cursor=cursor) finally: cursor.close() conn.close() if market_data.clock >= 18 or market_data.clock < 6: response = ewcfg.str_exchange_closed else: value = None if cmd.tokens_count > 1: value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True) if value != None: if value < 0: value = user_data.slimecredit if value <= 0: value = None if value != None: rate_exchange = (market_data.rate_exchange / 1000000.0) credits = value slimes = int(value * rate_exchange) if value > user_data.slimecredit: response = "You don't have that many SlimeCoin to exchange." elif user_data.time_lastinvest + ewcfg.cd_invest > time_now: # Limit frequency of withdrawals response = ewcfg.str_exchange_busy.format(action="withdraw") else: user_data.slimes += slimes user_data.slimecredit -= credits user_data.time_lastinvest = time_now market_data.slimes_casino -= slimes # Flag the user for PvP user_data.time_expirpvp = ewutils.calculatePvpTimer( user_data.time_expirpvp, (int(time.time()) + ewcfg.time_pvp_invest_withdraw)) response = "You exchange {credits:,} SlimeCoin for {slimes:,} slime.".format( credits=credits, slimes=slimes) # Level up the player if appropriate. new_level = len(str(int(user_data.slimes))) if new_level > user_data.slimelevel: response += "\n\n{} has been empowered by slime and is now a level {} slimeboi!".format( cmd.message.author.display_name, new_level) user_data.slimelevel = new_level try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) market_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() # Add the visible PvP flag role. await ewutils.add_pvp_role(cmd=cmd) else: response = ewcfg.str_exchange_specify.format(currency="SlimeCoin", action="withdraw") # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))
async def revive(cmd): resp = await ewcmd.start(cmd=cmd) time_now = int(time.time()) response = "" if cmd.message.channel.name != ewcfg.channel_endlesswar and cmd.message.channel.name != ewcfg.channel_sewers: response = "Come to me. I hunger. #{}.".format(ewcfg.channel_sewers) else: roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) if ewcfg.role_corpse in roles_map_user: player_is_pvp = False try: conn = ewutils.databaseConnect() cursor = conn.cursor() player_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) market_data = EwMarket(id_server=cmd.message.server.id, conn=conn, cursor=cursor) # Endless War collects his fee. fee = (player_data.slimecredit / 10) player_data.slimecredit -= fee market_data.slimes_revivefee += fee # Preserve negaslime if player_data.slimes < 0: market_data.negaslime += player_data.slimes # Give player some initial slimes. player_data.slimes = ewcfg.slimes_onrevive # Clear fatigue, totaldamage, bounty, killcount. player_data.stamina = 0 player_data.totaldamage = 0 player_data.bounty = 0 player_data.kills = 0 # Clear PvP flag. player_data.time_expirpvp = time_now - 1 # Clear weapon and weaponskill. player_data.weapon = "" player_data.weaponskill = 0 ewutils.weaponskills_clear(member=cmd.message.author, conn=conn, cursor=cursor) # Set time of last revive. This used to provied spawn protection, but currently isn't used. player_data.time_lastrevive = time_now if (player_data.time_expirpvp > time_now): player_is_pvp = True # Set initial slime level. It's probably 2. player_data.slimelevel = len(str(player_data.slimes)) player_data.persist(conn=conn, cursor=cursor) market_data.persist(conn=conn, cursor=cursor) # Give some slimes to every living player (currently online) for member in cmd.message.server.members: if member.id != cmd.message.author.id and member.id != cmd.client.user.id: if ewcfg.role_corpse not in ewutils.getRoleMap( member.roles): member_data = EwUser(member=member, conn=conn, cursor=cursor) member_data.slimes += ewcfg.slimes_onrevive_everyone member_data.persist(conn=conn, cursor=cursor) # Commit all transactions at once. conn.commit() finally: cursor.close() conn.close() if player_is_pvp: await cmd.client.replace_roles( cmd.message.author, cmd.roles_map[ewcfg.role_juvenile], cmd.roles_map[ewcfg.role_juvenile_pvp]) else: await cmd.client.replace_roles( cmd.message.author, cmd.roles_map[ewcfg.role_juvenile]) response = '{slime4} A geyser of fresh slime erupts, showering Rowdy, Killer, and Juvenile alike. {slime4} {name} has been reborn in slime. {slime4}'.format( slime4=ewcfg.emote_slime4, name=cmd.message.author.display_name) else: response = 'You\'re not dead just yet.' # Send the response to the player. await cmd.client.edit_message( resp, ewutils.formatMessage(cmd.message.author, response))