async def mill(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state == ewcfg.life_state_shambler: response = "You lack the higher brain functions required to {}.".format( cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) market_data = EwMarket(id_server=user_data.id_server) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = ewitem.find_item( item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None, item_type_filter=ewcfg.it_food) # Checking availability of milling if user_data.life_state != ewcfg.life_state_juvenile: response = "Only Juveniles of pure heart and with nothing better to do can mill their vegetables." elif cmd.message.channel.name not in [ ewcfg.channel_jr_farms, ewcfg.channel_og_farms, ewcfg.channel_ab_farms ]: response = "Alas, there doesn’t seem to be an official SlimeCorp milling station anywhere around here. Probably because you’re in the middle of the f*****g city. Try looking where you reaped your vegetable in the first place, dumbass." # elif user_data.slimes < ewcfg.slimes_permill: # response = "It costs {} to !mill, and you only have {}.".format(ewcfg.slimes_permill, user_data.slimes) elif item_sought: poi = ewcfg.id_to_poi.get(user_data.poi) district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) if district_data.is_degraded(): response = "{} has been degraded by shamblers. You can't {} here anymore.".format( poi.str_name, cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) items = [] vegetable = EwItem(id_item=item_sought.get('id_item')) for result in ewcfg.mill_results: if type(result.ingredients) == str: if vegetable.item_props.get('id_food') != result.ingredients: pass else: items.append(result) elif type(result.ingredients) == list: if vegetable.item_props.get( 'id_food') not in result.ingredients: pass else: items.append(result) if len(items) > 0: item = random.choice(items) item_props = ewitem.gen_item_props(item) ewitem.item_create(item_type=item.item_type, id_user=cmd.message.author.id, id_server=cmd.guild.id, item_props=item_props) response = "You walk up to the official ~~SlimeCorp~~ Garden Gankers Milling Station and shove your irradiated produce into the hand-crank. You begin slowly churning them into a glorious, pastry goo. As the goo tosses and turns inside the machine, it solidifies, and after a few moments a {} pops out!".format( item.str_name) #market_data.donated_slimes += ewcfg.slimes_permill market_data.persist() ewitem.item_delete(id_item=item_sought.get('id_item')) #user_data.change_slimes(n = -ewcfg.slimes_permill, source = ewcfg.source_spending) #user_data.slime_donations += ewcfg.slimes_permill user_data.persist() else: response = "You can only mill fresh vegetables! SlimeCorp obviously wants you to support local farmers." else: if item_search: # if they didn't forget to specify an item and it just wasn't found response = "You don't have one." else: response = "Mill which item? (check **!inventory**)" await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def burnSlimes(id_server = None): if id_server != None: time_now = int(time.time()) client = get_client() server = client.get_server(id_server) results = {} # Get users with burning effect data = execute_sql_query("SELECT {id_user}, {value}, {source} from status_effects WHERE {id_status} = %s and {id_server} = %s".format( id_user = ewcfg.col_id_user, value = ewcfg.col_value, id_status = ewcfg.col_id_status, id_server = ewcfg.col_id_server, source = ewcfg.col_source ), ( ewcfg.status_burning_id, id_server )) deathreport = "" resp_cont = EwResponseContainer(id_server = id_server) for result in data: user_data = EwUser(id_user = result[0], id_server = id_server) slimes_dropped = user_data.totaldamage + user_data.slimes # Deal 10% of total slime to burn every second slimes_to_burn = math.ceil(int(float(result[1])) * ewcfg.burn_tick_length / ewcfg.time_expire_burn) killer_data = EwUser(id_server = id_server, id_user=result[2]) # Damage stats ewstats.change_stat(user = killer_data, metric = ewcfg.stat_lifetime_damagedealt, n = slimes_to_burn) # Player died if user_data.slimes - slimes_to_burn < 0: weapon = ewcfg.weapon_map.get(ewcfg.weapon_id_molotov) player_data = EwPlayer(id_server = user_data.id_server, id_user = user_data.id_user) killer = EwPlayer(id_server = id_server, id_user=killer_data.id_user) # Kill stats ewstats.increment_stat(user = killer_data, metric = ewcfg.stat_kills) ewstats.track_maximum(user = killer_data, metric = ewcfg.stat_biggest_kill, value = int(slimes_dropped)) if killer_data.slimelevel > user_data.slimelevel: ewstats.increment_stat(user = killer_data, metric = ewcfg.stat_lifetime_ganks) elif killer_data.slimelevel < user_data.slimelevel: ewstats.increment_stat(user = killer_data, metric = ewcfg.stat_lifetime_takedowns) # Collect bounty coinbounty = int(user_data.bounty / ewcfg.slimecoin_exchangerate) # 100 slime per coin if user_data.slimes >= 0: killer_data.change_slimecoin(n = coinbounty, coinsource = ewcfg.coinsource_bounty) # Kill player user_data.id_killer = killer_data.id_user user_data.die(cause = ewcfg.cause_burning) #user_data.change_slimes(n = -slimes_dropped / 10, source = ewcfg.source_ghostification) deathreport = "You were {} by {}. {}".format(weapon.str_killdescriptor, killer.display_name, ewcfg.emote_slimeskull) deathreport = "{} ".format(ewcfg.emote_slimeskull) + formatMessage(server.get_member(user_data.id_user), deathreport) resp_cont.add_channel_response(ewcfg.channel_sewers, deathreport) user_data.trauma = weapon.id_weapon user_data.persist() await ewrolemgr.updateRoles(client = client, member = server.get_member(user_data.id_user)) else: user_data.change_slimes(n = -slimes_to_burn, source = ewcfg.source_damage) user_data.persist() await resp_cont.post()
async def pardon(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state != ewcfg.life_state_kingpin: response = "Only the Rowdy F****r {} and the Cop Killer {} can do that.".format( ewcfg.emote_rowdyfucker, ewcfg.emote_copkiller) else: member = None if cmd.mentions_count == 1: member = cmd.mentions[0] if member.id == cmd.message.author.id: member = None if member == None: response = "Who?" else: member_data = EwUser(member=member) member_data.unban(faction=user_data.faction) if member_data.faction == "": response = "{} has been allowed to join the {} again.".format( member.display_name, user_data.faction) else: faction_old = member_data.faction member_data.faction = "" if member_data.life_state == ewcfg.life_state_enlisted: member_data.life_state = ewcfg.life_state_juvenile member_data.weapon = -1 response = "{} has been released from their association with the {}.".format( member.display_name, faction_old) member_poi = ewcfg.id_to_poi.get(member_data.poi) if ewmap.inaccessible(user_data=member_data, poi=member_poi): member_data.poi = ewcfg.poi_id_downtown member_data.persist() await ewrolemgr.updateRoles(client=cmd.client, member=member) await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def summon_negaslimeoid(cmd): response = "" user_data = EwUser(member=cmd.message.author) if user_data.life_state != ewcfg.life_state_corpse: response = "Only the dead have the occult knowledge required to summon a cosmic horror." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if user_data.poi not in ewcfg.capturable_districts: response = "You can't conduct the ritual here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) name = None if cmd.tokens_count > 1: #value = ewutils.getIntToken(tokens = cmd.tokens, allow_all = True, negate = True) slimeoid = EwSlimeoid(member=cmd.message.author, sltype=ewcfg.sltype_nega) if slimeoid.life_state != ewcfg.slimeoid_state_none: response = "You already have an active negaslimeoid." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) negaslimeoid_name = cmd.message.content[(len(cmd.tokens[0])):].strip() if len(negaslimeoid_name) > 32: response = "That name is too long. ({:,}/32)".format( len(negaslimeoid_name)) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) market_data = EwMarket(id_server=cmd.message.author.server.id) if market_data.negaslime >= 0: response = "The dead haven't amassed any negaslime yet." else: max_level = min( len(str(user_data.slimes)) - 1, len(str(market_data.negaslime)) - 1) level = random.randint(1, max_level) value = 10**(level - 1) #user_data.change_slimes(n = int(value/10)) market_data.negaslime += value slimeoid.sltype = ewcfg.sltype_nega slimeoid.life_state = ewcfg.slimeoid_state_active slimeoid.level = level slimeoid.id_user = user_data.id_user slimeoid.id_server = user_data.id_server slimeoid.poi = user_data.poi slimeoid.name = negaslimeoid_name slimeoid.body = random.choice(ewcfg.body_names) slimeoid.head = random.choice(ewcfg.head_names) slimeoid.legs = random.choice(ewcfg.mobility_names) slimeoid.armor = random.choice(ewcfg.defense_names) slimeoid.weapon = random.choice(ewcfg.offense_names) slimeoid.special = random.choice(ewcfg.special_names) slimeoid.ai = random.choice(ewcfg.brain_names) for i in range(level): rand = random.randrange(3) if rand == 0: slimeoid.atk += 1 elif rand == 1: slimeoid.defense += 1 else: slimeoid.intel += 1 user_data.persist() slimeoid.persist() market_data.persist() response = "You have summoned **{}**, a {}-foot-tall Negaslimeoid.".format( slimeoid.name, slimeoid.level) desc = ewslimeoid.slimeoid_describe(slimeoid) response += desc else: response = "To summon a negaslimeoid you must first know its name." await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
def explode(damage = 0, district_data = None, market_data = None): id_server = district_data.id_server poi = district_data.name if market_data == None: market_data = EwMarket(id_server = district_data.id_server) client = get_client() server = client.get_server(id_server) resp_cont = EwResponseContainer(id_server = id_server) response = "" channel = ewcfg.id_to_poi.get(poi).channel life_states = [ewcfg.life_state_juvenile, ewcfg.life_state_enlisted, ewcfg.life_state_executive] users = district_data.get_players_in_district(life_states = life_states) enemies = district_data.get_enemies_in_district() # damage players for user in users: user_data = EwUser(id_user = user, id_server = id_server) mutations = user_data.get_mutations() user_weapon = None user_weapon_item = None if user_data.weapon >= 0: user_weapon_item = EwItem(id_item = user_data.weapon) user_weapon = ewcfg.weapon_map.get(user_weapon_item.item_props.get("weapon_type")) # apply defensive mods slimes_damage_target = damage * ewwep.damage_mod_defend( shootee_data = user_data, shootee_mutations = mutations, shootee_weapon = user_weapon, market_data = market_data ) # apply sap armor sap_armor = ewwep.get_sap_armor(shootee_data = user_data, sap_ignored = 0) slimes_damage_target *= sap_armor slimes_damage_target = int(max(0, slimes_damage_target)) player_data = EwPlayer(id_user = user_data.id_user) response = "{} is blown back by the explosion’s sheer force! They lose {:,} slime!!".format(player_data.display_name, slimes_damage_target) resp_cont.add_channel_response(channel, response) slimes_damage = slimes_damage_target if user_data.slimes < slimes_damage + user_data.bleed_storage: # die in the explosion district_data.change_slimes(n = user_data.slimes, source = ewcfg.source_killing) district_data.persist() slimes_dropped = user_data.totaldamage + user_data.slimes explode_damage = slime_bylevel(user_data.slimelevel) user_data.die(cause = ewcfg.cause_killing) #user_data.change_slimes(n = -slimes_dropped / 10, source = ewcfg.source_ghostification) user_data.persist() response = "Alas, {} was caught too close to the blast. They are consumed by the flames, and die in the explosion.".format(player_data.display_name) resp_cont.add_channel_response(channel, response) if ewcfg.mutation_id_spontaneouscombustion in mutations: sub_explosion = explode(explode_damage, district_data) resp_cont.add_response_container(sub_explosion) resp_cont.add_member_to_update(server.get_member(user_data.id_user)) else: # survive slime_splatter = 0.5 * slimes_damage district_data.change_slimes(n = slime_splatter, source = ewcfg.source_killing) district_data.persist() slimes_damage -= slime_splatter user_data.bleed_storage += slimes_damage user_data.change_slimes(n = -slime_splatter, source = ewcfg.source_killing) user_data.persist() # damage enemies for enemy in enemies: enemy_data = EwEnemy(id_enemy = enemy, id_server = id_server) response = "{} is blown back by the explosion’s sheer force! They lose {:,} slime!!".format(enemy_data.display_name, damage) resp_cont.add_channel_response(channel, response) slimes_damage_target = damage # apply sap armor sap_armor = ewwep.get_sap_armor(shootee_data = enemy_data, sap_ignored = 0) slimes_damage_target *= sap_armor slimes_damage_target = int(max(0, slimes_damage_target)) slimes_damage = slimes_damage_target if enemy_data.slimes < slimes_damage + enemy_data.bleed_storage: # die in the explosion district_data.change_slimes(n = enemy_data.slimes, source = ewcfg.source_killing) district_data.persist() # slimes_dropped = enemy_data.totaldamage + enemy_data.slimes # explode_damage = ewutils.slime_bylevel(enemy_data.level) response = "Alas, {} was caught too close to the blast. They are consumed by the flames, and die in the explosion.".format(enemy_data.display_name) resp_cont.add_response_container(ewhunting.drop_enemy_loot(enemy_data, district_data)) resp_cont.add_channel_response(channel, response) enemy_data.life_state = ewcfg.enemy_lifestate_dead enemy_data.persist() else: # survive slime_splatter = 0.5 * slimes_damage district_data.change_slimes(n = slime_splatter, source = ewcfg.source_killing) district_data.persist() slimes_damage -= slime_splatter enemy_data.bleed_storage += slimes_damage enemy_data.change_slimes(n = -slime_splatter, source = ewcfg.source_killing) enemy_data.persist() return resp_cont
async def updateRoles(client=None, member=None, server_default=None, refresh_perms=True, remove_or_apply_flag=None): time_now = int(time.time()) if server_default != None: user_data = EwUser(id_user=member.id, id_server=server_default) else: user_data = EwUser(member=member) id_server = user_data.id_server if member == None: return ewutils.logMsg("error: member was not supplied for updateRoles") #roles_map = ewutils.getRoleMap(member.guild.roles) roles_map_user = ewutils.getRoleIdMap(member.roles) if user_data.life_state != ewcfg.life_state_kingpin and ewcfg.role_kingpin in roles_map_user: # Fix the life_state of kingpins, if somehow it wasn't set. user_data.life_state = ewcfg.life_state_kingpin user_data.persist() elif user_data.life_state != ewcfg.life_state_grandfoe and ewcfg.role_grandfoe in roles_map_user: # Fix the life_state of a grand foe. user_data.life_state = ewcfg.life_state_grandfoe user_data.persist() faction_roles_remove = [ ewcfg.role_juvenile, ewcfg.role_juvenile_active, ewcfg.role_juvenile_pvp, ewcfg.role_rowdyfuckers, ewcfg.role_rowdyfuckers_pvp, ewcfg.role_rowdyfuckers_active, ewcfg.role_slimecorp, ewcfg.role_slimecorp_pvp, ewcfg.role_slimecorp_active, ewcfg.role_copkillers, ewcfg.role_copkillers_pvp, ewcfg.role_copkillers_active, ewcfg.role_corpse, ewcfg.role_corpse_pvp, ewcfg.role_corpse_active, ewcfg.role_kingpin, ewcfg.role_grandfoe, ewcfg.role_executive, ewcfg.role_tutorial, ewcfg.role_shambler, ] # Manage faction roles. faction_role = ewutils.get_faction(user_data=user_data) faction_roles_remove.remove(faction_role) pvp_role = None active_role = None if faction_role in ewcfg.role_to_pvp_role: if user_data.time_expirpvp >= time_now: pvp_role = ewcfg.role_to_pvp_role.get(faction_role) faction_roles_remove.remove(pvp_role) # if ewutils.is_otp(user_data): # active_role = ewcfg.role_to_active_role.get(faction_role) # faction_roles_remove.remove(active_role) tutorial_role = None if user_data.poi in ewcfg.tutorial_pois: tutorial_role = ewcfg.role_tutorial faction_roles_remove.remove(tutorial_role) # Manage location roles. user_poi = ewcfg.id_to_poi.get(user_data.poi) #print(user_poi.id_poi) if user_poi != None: # poi_role = user_poi.role poi_major_role = user_poi.major_role poi_minor_role = user_poi.minor_role poi_permissions = user_poi.permissions else: # poi_role = None poi_major_role = None poi_minor_role = None poi_permissions = None poi_permissions_remove = [] for poi in ewcfg.poi_list: if poi.permissions != None and poi.permissions != poi_permissions: poi_permissions_remove.append(poi.id_poi) poi_roles_remove = [] for poi in ewcfg.poi_list: if poi.major_role != None and poi.major_role != poi_major_role: poi_roles_remove.append(poi.major_role) #if poi.minor_role != None and poi.minor_role != poi_minor_role: poi_roles_remove.append(poi.minor_role) misc_roles_remove = [ewcfg.role_gellphone, ewcfg.role_slimernalia] # Remove user's gellphone role if they don't have a phone role_gellphone = None gellphones = ewitem.find_item_all(item_search=ewcfg.item_id_gellphone, id_user=user_data.id_user, id_server=user_data.id_server, item_type_filter=ewcfg.it_item) gellphone_active = False for phone in gellphones: phone_data = ewitem.EwItem(id_item=phone.get('id_item')) if phone_data.item_props.get('active') == 'true': gellphone_active = True break if gellphone_active == True: role_gellphone = ewcfg.role_gellphone misc_roles_remove.remove(ewcfg.role_gellphone) role_slimernalia = None #if user_data.slimernalia_kingpin == True: # role_slimernalia = ewcfg.role_slimernalia # misc_roles_remove.remove(ewcfg.role_slimernalia) role_ids = [] for role_id in roles_map_user: try: role_data = EwRole(id_server=id_server, id_role=role_id) roleName = role_data.name if roleName != None and roleName not in faction_roles_remove and roleName not in misc_roles_remove and roleName not in poi_roles_remove and role_data.id_role != '': role_ids.append(int(role_data.id_role)) except: ewutils.logMsg( 'error: couldn\'t find role with id {}'.format(role_id)) try: role_data = EwRole(id_server=id_server, name=faction_role) if not role_data.id_role in role_ids and role_data.id_role != '': role_ids.append(int(role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg( 'error: couldn\'t find faction role {}'.format(faction_role)) try: role_data = EwRole(id_server=id_server, name=pvp_role) if not role_data.id_role in role_ids and role_data.id_role != '': role_ids.append(int(role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg('error: couldn\'t find pvp role {}'.format(pvp_role)) try: role_data = EwRole(id_server=id_server, name=active_role) if not role_data.id_role in role_ids and role_data.id_role != '': role_ids.append(int(role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg( 'error: couldn\'t find active role {}'.format(active_role)) try: role_data = EwRole(id_server=id_server, name=tutorial_role) if not role_data.id_role in role_ids and role_data.id_role != '': role_ids.append(int(role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg( 'error: couldn\'t find tutorial role {}'.format(tutorial_role)) # poi roles are disabled try: major_role_data = EwRole(id_server=id_server, name=poi_major_role) if not major_role_data.id_role in role_ids and major_role_data.id_role != '': role_ids.append(int(major_role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg( 'error: couldn\'t find major role {}'.format(poi_major_role)) #try: # minor_role_data = EwRole(id_server = id_server, name = poi_minor_role) # if not minor_role_data.id_role in role_ids and minor_role_data.id_role != '': # role_ids.append(int(minor_role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) #except: # ewutils.logMsg('error: couldn\'t find minor role {}'.format(poi_minor_role)) try: role_data = EwRole(id_server=id_server, name=role_gellphone) if not role_data.id_role in role_ids and role_data.id_role != '': role_ids.append(int(role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg( 'error: couldn\'t find gellphone role {}'.format(role_gellphone)) try: role_data = EwRole(id_server=id_server, name=role_slimernalia) if not role_data.id_role in role_ids and role_data.id_role != '': role_ids.append(int(role_data.id_role)) #ewutils.logMsg('found role {} with id {}'.format(role_data.name, role_data.id_role)) except: ewutils.logMsg('error: couldn\'t find slimernalia role {}'.format( role_slimernalia)) # if faction_role not in role_names: # role_names.append(faction_role) # if poi_role != None and poi_role not in role_names: # role_names.append(poi_role) #replacement_roles = [] #for name in role_names: # role = roles_map.get(name) # if role != None: # replacement_roles.append(role) # else: # ewutils.logMsg("error: role missing \"{}\"".format(name)) #ewutils.logMsg('looking for {} roles to replace'.format(len(role_ids))) replacement_roles = [] for role in member.guild.roles: if role.id in role_ids: # ewutils.logMsg('found role {} with id {}'.format(role.name, role.id)) replacement_roles.append(role) #ewutils.logMsg('found {} roles to replace'.format(len(replacement_roles))) try: time_now = int(time.time()) was_pvp = user_data.time_expirpvp > time_now user_is_pvp = False role_ids = [] for pvp_role in ewcfg.role_to_pvp_role.values(): role = EwRole(id_server=member.guild.id, name=pvp_role) role_ids.append(role.id_role) for role in member.roles: if role.id in role_ids: user_is_pvp = True break if remove_or_apply_flag != None: if was_pvp: if remove_or_apply_flag == 'apply': if not user_is_pvp: # ewutils.logMsg('applying flag...') await member.edit(roles=replacement_roles) elif not was_pvp: if remove_or_apply_flag == 'remove': # ewutils.logMsg('removing flag...') await member.edit(roles=replacement_roles) else: await member.edit(roles=replacement_roles) except: ewutils.logMsg('error: failed to replace roles for {}'.format( member.display_name)) if refresh_perms: await refresh_user_perms(client=client, id_server=id_server, used_member=member)
async def haunt(cmd): time_now = int(time.time()) response = "" resp_cont = ewutils.EwResponseContainer(id_server=cmd.message.server.id) if cmd.mentions_count > 1: response = "You can only spook one person at a time. Who do you think you are, the Lord of Ghosts?" elif cmd.mentions_count == 1: # Get the user and target data from the database. user_data = EwUser(member=cmd.message.author) member = cmd.mentions[0] haunted_data = EwUser(member=member) market_data = EwMarket(id_server=cmd.message.server.id) if user_data.life_state != ewcfg.life_state_corpse: # Only dead players can haunt. response = "You can't haunt now. Try {}.".format(ewcfg.cmd_suicide) elif haunted_data.life_state == ewcfg.life_state_kingpin: # Disallow haunting of generals. response = "He is too far from the sewers in his ivory tower, and thus cannot be haunted." elif (time_now - user_data.time_lasthaunt) < ewcfg.cd_haunt: # Disallow haunting if the user has haunted too recently. response = "You're being a little TOO spooky lately, don't you think? Try again in {} seconds.".format( int(ewcfg.cd_haunt - (time_now - user_data.time_lasthaunt))) elif ewmap.channel_name_is_poi(cmd.message.channel.name) == False: response = "You can't commit violence from here." elif not ewutils.is_otp(haunted_data): # Require the target to be flagged for PvP response = "{} is not mired in the ENDLESS WAR right now.".format( member.display_name) elif haunted_data.life_state == ewcfg.life_state_corpse: # Dead players can't be haunted. response = "{} is already dead.".format(member.display_name) elif haunted_data.life_state == ewcfg.life_state_grandfoe: # Grand foes can't be haunted. response = "{} is invulnerable to ghosts.".format( member.display_name) elif haunted_data.life_state == ewcfg.life_state_enlisted or haunted_data.life_state == ewcfg.life_state_juvenile: # Target can be haunted by the player. haunted_slimes = int(haunted_data.slimes / ewcfg.slimes_hauntratio) # if user_data.poi == haunted_data.poi: # when haunting someone face to face, there is no cap and you get double the amount # haunted_slimes *= 2 if haunted_slimes > ewcfg.slimes_hauntmax: haunted_slimes = ewcfg.slimes_hauntmax #if -user_data.slimes < haunted_slimes: # cap on for how much you can haunt # haunted_slimes = -user_data.slimes haunted_data.change_slimes(n=-haunted_slimes, source=ewcfg.source_haunted) user_data.change_slimes(n=-haunted_slimes, source=ewcfg.source_haunter) market_data.negaslime -= haunted_slimes user_data.time_lasthaunt = time_now user_data.busted = False # Persist changes to the database. user_data.persist() haunted_data.persist() market_data.persist() response = "{} has been haunted by the ghost of {}! Slime has been lost!".format( member.display_name, cmd.message.author.display_name) haunted_channel = ewcfg.id_to_poi.get(haunted_data.poi).channel haunt_message = "You feel a cold shiver run down your spine" if cmd.tokens_count > 2: haunt_message_content = re.sub( "<.+>", "", cmd.message.content[(len(cmd.tokens[0])):]).strip() # Cut down really big messages so discord doesn't crash if len(haunt_message_content) > 500: haunt_message_content = haunt_message_content[:-500] haunt_message += " and faintly hear the words \"{}\"".format( haunt_message_content) haunt_message += "." haunt_message = ewutils.formatMessage(member, haunt_message) resp_cont.add_channel_response(haunted_channel, haunt_message) else: # Some condition we didn't think of. response = "You cannot haunt {}.".format(member.display_name) else: # No mentions, or mentions we didn't understand. response = "Your spookiness is appreciated, but ENDLESS WAR didn\'t understand that name." # Send the response to the player. resp_cont.add_channel_response(cmd.message.channel.name, response) await resp_cont.post()
async def store(cmd): user_data = EwUser(member=cmd.message.author) response = "" poi = ewcfg.id_to_poi.get(user_data.poi) if poi.community_chest == None: response = "There is no community chest here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = ewitem.find_item(item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.message.server.id if cmd.message.server is not None else None) if item_sought: item = EwItem(id_item=item_sought.get("id_item")) if not item.soulbound: if item.item_type == ewcfg.it_weapon and user_data.weapon >= 0 and item.id_item == user_data.weapon: if user_data.weaponmarried: weapon = ewcfg.weapon_map.get( item.item_props.get("weapon_type")) response = "Your cuckoldry is appreciated, but your {} will always remain faithful to you.".format( item_sought.get('name')) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) else: user_data.weapon = -1 user_data.persist() if item.item_type == ewcfg.it_cosmetic: if "adorned" in item.item_props: item.item_props["adorned"] = "false" if "slimeoid" in item.item_props: item.item_props["slimeoid"] = "false" item.persist() ewitem.give_item(id_item=item.id_item, id_server=item.id_server, id_user=poi.community_chest) response = "You store your {} in the community chest.".format( item_sought.get("name")) else: response = "You can't {} soulbound items.".format(cmd.tokens[0]) else: if item_search: response = "You don't have one" else: response = "{} which item? (check **!inventory**)".format( cmd.tokens[0]) await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def shambleball(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state != ewcfg.life_state_shambler: response = "You have too many higher brain functions left to play Shambleball." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if not ewutils.channel_name_is_poi(cmd.message.channel.name): response = "You have to go into the city to play Shambleball." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) poi_data = ewcfg.chname_to_poi.get(cmd.message.channel.name) if poi_data.is_subzone or poi_data.is_transport: response = "This place is too cramped for playing Shambleball. Go outside!" return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) district_data = EwDistrict(district=poi_data.id_poi, id_server=cmd.message.server.id) if not district_data.is_degraded: response = "This place is too functional and full of people to play Shambleball. You'll have to {} it first.".format( ewcfg.cmd_shamble) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) global sb_userid_to_player shamble_player = sb_userid_to_player.get(cmd.message.author.id) game_data = None if shamble_player != None: global sb_games game_data = sb_games.get(shamble_player.id_game) if game_data != None and game_data.poi != poi_data.id_poi: game_data.players.remove(shamble_player) game_data = None if game_data == None: global sb_idserver_to_gamemap gamemap = sb_idserver_to_gamemap.get(cmd.message.server.id) if gamemap != None: game_data = gamemap.get(poi_data.id_poi) team = ewutils.flattenTokenListToString(cmd.tokens[1:]) if team not in ["purple", "pink"]: response = "Please choose if you want to play on the pink team or the purple team." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if game_data == None: game_data = EwShambleBallGame(poi_data.id_poi, cmd.message.server.id) response = "You put your severed head on the floor and start a new game of Shambleball as a {team} team player." else: response = "You join the Shambleball game on the {team} team." shamble_player = EwShambleBallPlayer(cmd.message.author.id, cmd.message.server.id, game_data.id_game, team) else: response = "You are playing Shambleball on the {team} team. You are currently at {player_coords} going in direction {player_vel}. The ball is currently at {ball_coords} going in direction {ball_vel}. The score is purple {score_purple} : {score_pink} pink." response = response.format(team=shamble_player.team, player_coords=shamble_player.coords, ball_coords=game_data.ball_coords, player_vel=shamble_player.velocity, ball_vel=game_data.ball_velocity, score_purple=game_data.score_purple, score_pink=game_data.score_pink) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def disembark(cmd): # can only use movement commands in location channels if ewmap.channel_name_is_poi(cmd.message.channel.name) == False: return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0]))) user_data = EwUser(member=cmd.message.author) response = "" resp_cont = ewutils.EwResponseContainer(client=cmd.client, id_server=user_data.id_server) # can only disembark when you're on a transport vehicle if user_data.poi in ewcfg.transports: transport_data = EwTransport(id_server=user_data.id_server, poi=user_data.poi) response = "{}ing.".format(cmd.tokens[0][1:].lower()).capitalize() stop_poi = ewcfg.id_to_poi.get(transport_data.current_stop) if stop_poi.is_subzone: stop_poi = ewcfg.id_to_poi.get(stop_poi.mother_district) if ewmap.inaccessible(user_data=user_data, poi=stop_poi): return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You're not allowed to go there (bitch).")) # schedule tasks for concurrent execution message_task = asyncio.ensure_future( ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))) wait_task = asyncio.ensure_future(asyncio.sleep(5)) # Take control of the move for this player. ewmap.move_counter += 1 move_current = ewutils.moves_active[ cmd.message.author.id] = ewmap.move_counter await message_task await wait_task # check if the user entered another movement command while waiting for the current one to be completed if move_current != ewutils.moves_active[cmd.message.author.id]: return user_data = EwUser(member=cmd.message.author) transport_data = EwTransport(id_server=user_data.id_server, poi=transport_data.poi) # cancel move, if the user has left the transport while waiting for movement to be completed (e.g. by dying) if user_data.poi != transport_data.poi: return stop_poi = ewcfg.id_to_poi.get(transport_data.current_stop) # juvies can't swim if transport_data.current_stop == ewcfg.poi_id_slimesea and user_data.life_state != ewcfg.life_state_corpse: if user_data.life_state == ewcfg.life_state_kingpin: response = "You try to heave yourself over the railing as you're hit by a sudden case of sea sickness. You puke into the sea and sink back on deck." response = ewutils.formatMessage(cmd.message.author, response) return await ewutils.send_message(cmd.client, cmd.message.channel, response) user_data.poi = ewcfg.poi_id_slimesea user_data.trauma = ewcfg.trauma_id_environment die_resp = user_data.die(cause=ewcfg.cause_drowning) user_data.persist() resp_cont.add_response_container(die_resp) response = "{} jumps over the railing of the ferry and promptly drowns in the slime sea.".format( cmd.message.author.display_name) resp_cont.add_channel_response(channel=ewcfg.channel_slimesea, response=response) resp_cont.add_channel_response(channel=ewcfg.channel_ferry, response=response) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) # they also can't fly elif transport_data.transport_type == ewcfg.transport_type_blimp and not stop_poi.is_transport_stop and user_data.life_state != ewcfg.life_state_corpse: user_mutations = user_data.get_mutations() if user_data.life_state == ewcfg.life_state_kingpin: response = "Your life flashes before your eyes, as you plummet towards your certain death. A lifetime spent being a piece of shit and playing videogames all day. You close your eyes and... BOING! You open your eyes again to see a crew of workers transporting the trampoline that broke your fall. You get up and dust yourself off, sighing heavily." response = ewutils.formatMessage(cmd.message.author, response) resp_cont.add_channel_response(channel=stop_poi.channel, response=response) user_data.poi = stop_poi.id_poi user_data.persist() await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) return await resp_cont.post() elif ewcfg.mutation_id_lightasafeather in user_mutations: response = "With a running jump you launch yourself out of the blimp and begin falling to your soon-to-be demise... but then a strong updraft breaks your fall and you land unscathed. " response = ewutils.formatMessage(cmd.message.author, response) resp_cont.add_channel_response(channel=stop_poi.channel, response=response) user_data.poi = stop_poi.id_poi user_data.persist() await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) return await resp_cont.post() district_data = EwDistrict(id_server=user_data.id_server, district=stop_poi.id_poi) district_data.change_slimes(n=user_data.slimes) district_data.persist() user_data.poi = stop_poi.id_poi user_data.trauma = ewcfg.trauma_id_environment die_resp = user_data.die(cause=ewcfg.cause_falling) user_data.persist() resp_cont.add_response_container(die_resp) response = "SPLAT! A body collides with the asphalt with such force, that it is utterly annihilated, covering bystanders in blood and slime and guts." resp_cont.add_channel_response(channel=stop_poi.channel, response=response) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) # update user location, if move successful else: if stop_poi.is_subzone: stop_poi = ewcfg.id_to_poi.get(stop_poi.mother_district) if ewmap.inaccessible(user_data=user_data, poi=stop_poi): return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You're not allowed to go there (bitch).")) user_data.poi = stop_poi.id_poi user_data.persist() response = "You enter {}".format(stop_poi.str_name) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) return await ewutils.send_message( cmd.client, ewutils.get_channel(cmd.message.server, stop_poi.channel), ewutils.formatMessage(cmd.message.author, response)) return await resp_cont.post() else: response = "You are not currently riding any transport." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def take(cmd): user_data = EwUser(member=cmd.message.author) response = "" poi = ewcfg.id_to_poi.get(user_data.poi) if poi.community_chest == None: response = "There is no community chest here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = ewitem.find_item(item_search=item_search, id_user=poi.community_chest, id_server=cmd.message.server.id if cmd.message.server is not None else None) if item_sought: if item_sought.get('item_type') == ewcfg.it_food: food_items = ewitem.inventory(id_user=cmd.message.author.id, id_server=cmd.message.server.id, item_type_filter=ewcfg.it_food) if len(food_items) >= user_data.get_food_capacity(): response = "You can't carry any more food items." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if item_sought.get('item_type') == ewcfg.it_weapon: weapons_held = ewitem.inventory(id_user=cmd.message.author.id, id_server=cmd.message.server.id, item_type_filter=ewcfg.it_weapon) if user_data.life_state == ewcfg.life_state_corpse: response = "Ghosts can't hold weapons." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) elif len(weapons_held) >= user_data.get_weapon_capacity(): response = "You can't carry any more weapons." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) ewitem.give_item(id_item=item_sought.get('id_item'), id_server=user_data.id_server, id_user=user_data.id_user) response = "You retrieve a {} from the community chest.".format( item_sought.get("name")) else: if item_search: response = "There isn't one here." else: response = "{} which item? (check **{}**)".format( cmd.tokens[0], ewcfg.cmd_communitychest) await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def embark(cmd): # can only use movement commands in location channels if ewmap.channel_name_is_poi(cmd.message.channel.name) == False: return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0]))) poi = ewcfg.chname_to_poi.get(cmd.message.channel.name) district_data = EwDistrict(district=poi.id_poi, id_server=cmd.message.server.id) if district_data.is_degraded(): response = "{} has been degraded by shamblers. You can't {} here anymore.".format( poi.str_name, cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) user_data = EwUser(member=cmd.message.author) response = "" if ewutils.active_restrictions.get( user_data.id_user) != None and ewutils.active_restrictions.get( user_data.id_user) > 0: response = "You can't do that right now." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) poi = ewmap.fetch_poi_if_coordless(cmd.message.channel.name) # must be at a transport stop to enter a transport if poi != None and poi.id_poi in ewcfg.transport_stops: transport_ids = get_transports_at_stop(id_server=user_data.id_server, stop=poi.id_poi) # can't embark, when there's no vehicles to embark on if len(transport_ids) == 0: response = "There are currently no transport vehicles to embark on here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) # automatically embark on the only transport at the station, if no arguments were provided elif len(transport_ids) == 1 and cmd.tokens_count < 2: transport_data = EwTransport(id_server=user_data.id_server, poi=transport_ids[0]) target_name = transport_data.current_line # get target name from command arguments else: target_name = ewutils.flattenTokenListToString(cmd.tokens[1:]) # report failure, if the vehicle to be boarded couldn't be ascertained if target_name == None or len(target_name) == 0: return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "Which transport line?")) transport_line = ewcfg.id_to_transport_line.get(target_name) # report failure, if an invalid argument was given if transport_line == None: return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "Never heard of it.")) for transport_id in transport_ids: transport_data = EwTransport(id_server=user_data.id_server, poi=transport_id) # check if one of the vehicles at the stop matches up with the line, the user wants to board if transport_data.current_line == transport_line.id_line: last_stop_poi = ewcfg.id_to_poi.get(transport_line.last_stop) response = "Embarking on {}.".format(transport_line.str_name) # schedule tasks for concurrent execution message_task = asyncio.ensure_future( ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))) wait_task = asyncio.ensure_future(asyncio.sleep(5)) # Take control of the move for this player. ewmap.move_counter += 1 move_current = ewutils.moves_active[ cmd.message.author.id] = ewmap.move_counter await message_task await wait_task # check if the user entered another movement command while waiting for the current one to be completed if move_current == ewutils.moves_active[cmd.message.author.id]: user_data = EwUser(member=cmd.message.author) transport_data = EwTransport(id_server=user_data.id_server, poi=transport_id) # check if the transport is still at the same stop if transport_data.current_stop == poi.id_poi: user_data.poi = transport_data.poi user_data.persist() transport_poi = ewcfg.id_to_poi.get(transport_data.poi) response = "You enter the {}.".format( transport_data.transport_type) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) return await ewutils.send_message( cmd.client, ewutils.get_channel(cmd.message.server, transport_poi.channel), ewutils.formatMessage(cmd.message.author, response)) else: response = "The {} starts moving just as you try to get on.".format( transport_data.transport_type) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) response = "There is currently no vehicle following that line here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) else: response = "No transport vehicles stop here. Try going to a subway station or a ferry port." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def cultivate(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state == ewcfg.life_state_shambler: response = "You lack the higher brain functions required to {}.".format( cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) response = "" levelup_response = "" mutations = user_data.get_mutations() # Checking availability of irrigate action if user_data.life_state != ewcfg.life_state_juvenile: response = "Only Juveniles of pure heart and with nothing better to do can tend to their crops." elif cmd.message.channel.name not in [ ewcfg.channel_jr_farms, ewcfg.channel_og_farms, ewcfg.channel_ab_farms ]: response = "Do you remember planting anything here in this barren wasteland? No, you don’t. Idiot." else: poi = ewcfg.id_to_poi.get(user_data.poi) district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) if district_data.is_degraded(): response = "{} has been degraded by shamblers. You can't {} here anymore.".format( poi.str_name, cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if user_data.poi == ewcfg.poi_id_jr_farms: farm_id = ewcfg.poi_id_jr_farms elif user_data.poi == ewcfg.poi_id_og_farms: farm_id = ewcfg.poi_id_og_farms else: # if it's the farm in arsonbrook farm_id = ewcfg.poi_id_ab_farms farm = EwFarm(id_server=cmd.guild.id, id_user=cmd.message.author.id, farm=farm_id) farm_action = ewcfg.cmd_to_farm_action.get(cmd.tokens[0].lower()) if farm.time_lastsow == 0: response = "You missed a step, you haven’t planted anything here yet." elif farm.action_required != farm_action.id_action: response = farm_action.str_execute_fail farm.slimes_onreap -= ewcfg.farm_slimes_peraction farm.slimes_onreap = max(farm.slimes_onreap, 0) farm.persist() else: response = farm_action.str_execute # gvs - farm actions award more slime farm.slimes_onreap += ewcfg.farm_slimes_peraction * 2 farm.action_required = ewcfg.farm_action_none farm.persist() await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def check_farm(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state == ewcfg.life_state_shambler: response = "You lack the higher brain functions required to {}.".format( cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) response = "" levelup_response = "" mutations = user_data.get_mutations() # Checking availability of check farm action if user_data.life_state != ewcfg.life_state_juvenile: response = "Only Juveniles of pure heart and with nothing better to do can farm." elif cmd.message.channel.name not in [ ewcfg.channel_jr_farms, ewcfg.channel_og_farms, ewcfg.channel_ab_farms ]: response = "Do you remember planting anything here in this barren wasteland? No, you don’t. Idiot." else: poi = ewcfg.id_to_poi.get(user_data.poi) district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) if district_data.is_degraded(): response = "{} has been degraded by shamblers. You can't {} here anymore.".format( poi.str_name, cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if user_data.poi == ewcfg.poi_id_jr_farms: farm_id = ewcfg.poi_id_jr_farms elif user_data.poi == ewcfg.poi_id_og_farms: farm_id = ewcfg.poi_id_og_farms else: # if it's the farm in arsonbrook farm_id = ewcfg.poi_id_ab_farms farm = EwFarm(id_server=cmd.guild.id, id_user=cmd.message.author.id, farm=farm_id) if farm.time_lastsow == 0: response = "You missed a step, you haven’t planted anything here yet." elif farm.action_required == ewcfg.farm_action_none: if farm.phase == ewcfg.farm_phase_reap: response = "Your crop is ready for the harvest." elif farm.phase == ewcfg.farm_phase_sow: response = "You only just planted the seeds. Check back later." else: if farm.slimes_onreap < ewcfg.reap_gain: response = "Your crop looks frail and weak." elif farm.slimes_onreap < ewcfg.reap_gain + 3 * ewcfg.farm_slimes_peraction: response = "Your crop looks small and generally unremarkable." elif farm.slimes_onreap < ewcfg.reap_gain + 6 * ewcfg.farm_slimes_peraction: response = "Your crop seems to be growing well." else: response = "Your crop looks powerful and bursting with nutrients." else: farm_action = ewcfg.id_to_farm_action.get(farm.action_required) response = farm_action.str_check await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def prank_item_effect_response(cmd, item): item_action = "" mentions_user = False use_mention_displayname = False side_effect = "" if cmd.mentions_count == 1: mentions_user = True if mentions_user: member = cmd.mentions[0] pranker_data = EwUser(member=cmd.message.author) pranked_data = EwUser(member=member) if pranker_data.id_user == pranked_data.id_user: response = "A bit masochistic, don't you think?" return item_action, response, use_mention_displayname, side_effect if pranked_data.time_last_action < (int(time.time()) - afk_timer): response = "Whoa whoa WHOA! Slow down there, big guy, this person's practically asleep! Where's the fun in pranking them right now, when you won't even be able to get a reaction out of them?\n**(Hint: {} is AFK! Try pranking someone else.)**".format( member.display_name) return item_action, response, use_mention_displayname, side_effect if pranker_data.poi != pranked_data.poi: response = "You need to be in the same place as your target to prank them with that item." return item_action, response, use_mention_displayname, side_effect # if pranker_data.credence == 0 or pranked_data.credence == 0: # if pranker_data.credence == 0: # # response = "You can't prank that person right now, you don't have any credence!" # else: # response = "You can't prank that person right now, they don't have any credence!" # # return item_action, response, use_mention_displayname, side_effect if (ewutils.active_restrictions.get(pranker_data.id_user) != None and ewutils.active_restrictions.get(pranker_data.id_user) == 2 ) or (ewutils.active_restrictions.get(pranked_data.id_user) != None and ewutils.active_restrictions.get( pranked_data.id_user) == 2): response = "You can't prank that person right now." return item_action, response, use_mention_displayname, side_effect prank_item_data = item response = prank_item_data.item_props.get('prank_desc') extra_response_1 = prank_item_data.item_props.get('response_desc_1') extra_response_2 = prank_item_data.item_props.get('response_desc_2') extra_response_3 = prank_item_data.item_props.get('response_desc_3') extra_response_4 = prank_item_data.item_props.get('response_desc_4') possible_responses_list = [ response, extra_response_1, extra_response_2, extra_response_3, extra_response_4, ] # response = response.format(cmd.message.author.display_name) # Apply restrictions, stop both users in their tracks # Restriction level 2 -- No one else can prank you at this time. ewutils.active_target_map[pranker_data.id_user] = pranked_data.id_user ewutils.active_target_map[pranked_data.id_user] = pranker_data.id_user ewutils.moves_active[pranker_data.id_user] = 0 ewutils.moves_active[pranked_data.id_user] = 0 ewutils.active_restrictions[pranker_data.id_user] = 2 ewutils.active_restrictions[pranked_data.id_user] = 2 # The command needed to remove the response item response_command = prank_item_data.item_props.get('response_command') use_mention_displayname = True # The pranked person has 5 chances to type in the proper command before more and more gambit builds up limit = 0 accepted = 0 has_escaped = False has_escaped_fast = False while limit < 6: limit += 1 if limit != 6: chosen_response = possible_responses_list[limit - 1] # Some response item messages wont have formatting in them. try: chosen_response = chosen_response.format( cmd.message.author.display_name) except: pass await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage( (cmd.message.author if use_mention_displayname == False else cmd.mentions[0]), chosen_response)) #prank_feed_channel = ewutils.get_channel(cmd.guild, 'prank-feed') #await ewutils.send_message(cmd.client, prank_feed_channel, ewutils.formatMessage((cmd.message.author if use_mention_displayname == False else cmd.mentions[0]), (chosen_response+"\n`-------------------------`"))) # The longer time goes on without the pranked person typing in the command, the more gambit they lose pranker_data = EwUser(member=cmd.message.author) pranked_data = EwUser(member=member) #calculate_gambit_exchange(pranker_data, pranked_data, prank_item_data, limit) accepted = 0 try: msg = await cmd.client.wait_for( 'message', timeout=response_timer, check=lambda message: message.author == member) if msg != None: if msg.content.lower() == "!" + response_command: accepted = 1 if limit != 5: has_escaped = True # if limit == 1: # has_escaped_fast = True limit = 6 except: accepted = 0 if accepted == 1 and has_escaped: response = "You manage to resist {}'s prank efforts for now.".format( cmd.message.author.display_name) # if has_escaped_fast: # response = "You swiftly dodge {}'s prank attempt!".format(cmd.message.author.display_name) # limit = 7 else: response = "It's over. The damage {} has done to you will stay with you until your death. Or at least for the rest of the week, whichever comes first.".format( cmd.message.author.display_name) pranker_data = EwUser(member=cmd.message.author) pranked_data = EwUser(member=member) #calculate_gambit_exchange(pranker_data, pranked_data, prank_item_data, limit) # Remove restrictions ewutils.active_target_map[pranker_data.id_user] = "" ewutils.active_target_map[pranked_data.id_user] = "" ewutils.active_restrictions[pranker_data.id_user] = 0 ewutils.active_restrictions[pranked_data.id_user] = 0 item_action = "delete" else: response = "You gotta find someone to prank someone with that item, first!\n**(Hint: !use item @player)**" return item_action, response, use_mention_displayname, side_effect
async def giveslime(cmd): resp = await ewcmd.start(cmd = cmd) response = "" roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) if (ewcfg.role_copkiller not in roles_map_user) and (ewcfg.role_rowdyfucker not in roles_map_user): response = "Only the Rowdy F****r {} and the Cop Killer {} can do that.".format(ewcfg.emote_rowdyfucker, ewcfg.emote_copkiller) else: if cmd.mentions_count == 0: response = "Give slimes to who?" else: if cmd.tokens_count > 1: value = None for token in cmd.tokens[1:]: try: value = int(token) break except: value = None if value != None: user_slimes = 0 member_slimes = [] try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) # determine slime count for every member mentioned for member in cmd.mentions: member_slimes.append(EwUser(member=member, conn=conn, cursor=cursor)) finally: cursor.close() conn.close() if (value * cmd.mentions_count) > user_data.slimes: response = "You don't have that much slime to give ({:,}/{:,}).".format(user_data.slimes, (value * cmd.mentions_count)) else: user_data.slimes -= (value * cmd.mentions_count) try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data.persist(conn=conn, cursor=cursor) # give value slimes to mentioned players for obj in member_slimes: obj.slimes += value obj.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() response = "Slime scores altered! {}".format(ewcfg.emote_slime1) else: response = "Give how much slime?" # Send the response to the player. await cmd.client.edit_message(resp, ewutils.formatMessage(cmd.message.author, response))
async def writhe(cmd): resp = await ewcmd.start(cmd=cmd) response = "" user_data = EwUser(member=cmd.message.author) if user_data.life_state != ewcfg.life_state_grandfoe: response = "Only the NEGASLIME {} can do that.".format( ewcfg.emote_negaslime) await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) else: # play animation he = ewcfg.emote_he s_ = ewcfg.emote_s_ ve = ewcfg.emote_ve vt = ewcfg.emote_vt v_ = ewcfg.emote_v_ h_ = ewcfg.emote_h_ va = ewcfg.emote_va ht = ewcfg.emote_ht hs = ewcfg.emote_hs blank = ewcfg.emote_blank writhing1 = he writhing2 = s_ + he + "\n" + ve writhing3 = s_ + h_ + he + "\n" + vt + he writhing4 = s_ + h_ + ht + "\n" + vt + he + ve writhing5 = s_ + h_ + ht + "\n" + va + he + vt + he + "\n" + ve writhing6 = s_ + h_ + ht + "\n" + va + ht + va + ht + "\n" + v_ + ve + ve + ve + "\n" + ve writhing7 = s_ + h_ + ht + "\n" + va + ht + va + hs + he + "\n" + v_ + ve + v_ + vt + he + "\n" + ve + blank + ve writhing8 = s_ + h_ + ht + "\n" + va + ht + va + hs + he + "\n" + v_ + ve + v_ + vt + h_ + he + "\n" + vt + he + vt + he writhing9 = s_ + h_ + ht + "\n" + va + ht + va + hs + h_ + he + "\n" + v_ + ve + v_ + vt + h_ + ht + "\n" + vt + ht + vt + ht + blank + ve + "\n" + blank + ve + blank + ve writhing10 = s_ + h_ + ht + "\n" + va + ht + va + hs + h_ + he + "\n" + v_ + ve + v_ + vt + h_ + ht + "\n" + vt + ht + vt + ht + blank + vt + he + "\n" + blank + ve + blank + vt + he writhings = [ writhing1, writhing2, writhing3, writhing4, writhing5, writhing6, writhing7, writhing8, writhing9, writhing10 ] for writhing in writhings: cur_time = time.time() await ewutils.edit_message(cmd.client, resp, writhing) elapsed = time.time() - cur_time await asyncio.sleep(2.0 - elapsed) id_server = cmd.guild.id targets = [] # search for players in the negaslime's location in database and put them in a list if id_server != None: try: conn_info = ewutils.databaseConnect() conn = conn_info.get('conn') cursor = conn.cursor() cursor.execute( "SELECT id_user FROM users WHERE id_server = %s AND poi = '{}' AND life_state IN (1, 2);" .format(user_data.poi), (id_server, )) # convert pulled IDs into member objects target_ids = cursor.fetchall() for target_id in target_ids: target = cmd.guild.get_member(target_id[0]) targets.append(target) conn.commit() finally: # Clean up the database handles. cursor.close() ewutils.databaseClose(conn_info) victim_list = [] # kill everyone in the negaslime's poi and remember their names for target in targets: if target != None: user_data_target = EwUser(member=target) user_data_target.id_killer = cmd.message.author.id user_data_target.die(cause=ewcfg.cause_grandfoe) user_data_target.persist() await ewrolemgr.updateRoles(client=cmd.client, member=target) sewerchannel = ewutils.get_channel(cmd.guild, ewcfg.channel_sewers) await ewutils.send_message( cmd.client, sewerchannel, "{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage( target, "You have been crushed by tendrils. {}".format( ewcfg.emote_slimeskull))) victim_list.append(target) # display result of the writhing if len(victim_list) > 0: victims_string = ewutils.userListToNameString(victim_list) response = "Your tendrils have successfully killed {}.".format( victims_string) else: response = "Your tendrils didn't kill anyone :(" await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def devour(cmd): resp = await ewcmd.start(cmd = cmd) response = "" roles_map_user = ewutils.getRoleMap(cmd.message.author.roles) is_copkiller = ewcfg.role_copkiller in roles_map_user is_rowdyfucker = ewcfg.role_rowdyfucker in roles_map_user if is_copkiller == False and is_rowdyfucker == False: response = "Know your place." else: if cmd.mentions_count == 0: response = "Devour who?" else: members_devoured = [] members_na = [] try: conn = ewutils.databaseConnect() cursor = conn.cursor() user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor) # determine slime count for every member mentioned for member in cmd.mentions: roles_map_member = ewutils.getRoleMap(member.roles) if is_copkiller == True and ewcfg.role_copkillers in roles_map_member or is_rowdyfucker == True and ewcfg.role_rowdyfuckers in roles_map_member: # get slimes from the player member_data = EwUser(member=member, conn=conn, cursor=cursor) user_data.slimes += member_data.slimes # set player slimes to 0 member_data.slimes = 0 member_data.persist(conn=conn, cursor=cursor) members_devoured.append(member) else: members_na.append(member) # add slime to rf/ck user_data.persist(conn=conn, cursor=cursor) conn.commit() finally: cursor.close() conn.close() role_corpse = cmd.roles_map[ewcfg.role_corpse] for member in members_devoured: # update slime counts try: # set roles to corpse for mentioned players await cmd.client.replace_roles(member, role_corpse) except: pass if len(members_devoured) > 0: names = ewutils.userListToNameString(members_devoured) if len(members_na) > 0: response = '{} has been devoured. ({} was not devoured.)'.format(names, ewutils.userListToNameString(members_na)) else: response = '{} has been devoured.'.format(names) elif len(members_na) > 0: response = '{} was not devoured.'.format(ewutils.userListToNameString(members_na)) else: response = 'No one was devoured.' # Send the response to the player. await cmd.client.edit_message(resp, ewutils.formatMessage(cmd.message.author, response))
async def refresh_user_perms(client, id_server, used_member=None, startup=False): server = client.get_guild(id_server) has_overrides = False user_data = EwUser(member=used_member) if not startup: for poi in ewcfg.poi_list: channel = ewutils.get_channel(server, poi.channel) if channel == None: #ewutils.logMsg('Error: In refresh_user_perms, could not get channel for {}'.format(poi.channel)) # Second try channel = ewutils.get_channel(server, poi.channel) if channel == None: continue #print('{} overwrites: {}'.format(poi.id_poi, channel.overwrites)) if used_member in channel.overwrites and user_data.poi != poi.id_poi: # Incorrect overwrite found for user #time_now_start = int(time.time()) for i in range(ewcfg.permissions_tries): await channel.set_permissions(used_member, overwrite=None) # Handle mine walls if poi.id_poi in ewcfg.mines_wall_map: wall_channel = ewutils.get_channel( server, ewcfg.mines_wall_map[poi.id_poi]) if wall_channel is not None: for i in range(ewcfg.permissions_tries): await wall_channel.set_permissions(used_member, overwrite=None) #time_now_end = int(time.time()) #print('took {} seconds to delete channel permissions'.format(time_now_end - time_now_start)) #print('\ndeleted overwrite in {} for {}\n'.format(channel, member)) elif used_member not in channel.overwrites and user_data.poi == poi.id_poi: correct_poi = ewcfg.id_to_poi.get(user_data.poi) if correct_poi == None: print('User {} has invalid POI of {}'.format( user_data.id_user, user_data.poi)) correct_poi = ewcfg.id_to_poi.get(ewcfg.poi_id_downtown) correct_channel = ewutils.get_channel(server, correct_poi.channel) #correct_lan_channel = "{}-LAN-connection".format(correct_channel) if correct_channel == None: ewutils.logMsg("Channel {} not found".format( correct_poi.channel)) return permissions_dict = correct_poi.permissions overwrite = discord.PermissionOverwrite() overwrite.read_messages = True if ewcfg.permission_read_messages in permissions_dict[ user_data.poi] else False overwrite.send_messages = True if ewcfg.permission_send_messages in permissions_dict[ user_data.poi] else False #print(permissions_dict[user_data.poi]) #time_now_start = int(time.time()) for i in range(ewcfg.permissions_tries): await correct_channel.set_permissions(used_member, overwrite=overwrite) # Handle mine walls if correct_poi.id_poi in ewcfg.mines_wall_map: wall_channel = ewutils.get_channel( server, ewcfg.mines_wall_map[correct_poi.id_poi]) if wall_channel is not None: overwrite = discord.PermissionOverwrite() overwrite.read_messages = True for i in range(ewcfg.permissions_tries): await wall_channel.set_permissions( used_member, overwrite=overwrite) #time_now_end = int(time.time()) #print('took {} seconds to update channel permissions'.format(time_now_end - time_now_start)) #print('updated permissions for {} in {}'.format(member, user_data.poi)) has_overrides = True if not has_overrides: # Member has no overwrites -- fix this: user_data = EwUser(member=used_member) # User might not have their poi set to downtown when they join the server. if user_data.poi == None: correct_poi = ewcfg.id_to_poi.get(ewcfg.poi_id_downtown) else: correct_poi = ewcfg.id_to_poi.get(user_data.poi) if correct_poi == None: print('User {} has invalid POI of {}'.format( user_data.id_user, user_data.poi)) correct_poi = ewcfg.id_to_poi.get(ewcfg.poi_id_downtown) #print(user_data.poi) correct_channel = ewutils.get_channel(server, correct_poi.channel) if correct_channel == None: ewutils.logMsg("Channel {} not found".format( correct_poi.channel)) return permissions_dict = correct_poi.permissions overwrite = discord.PermissionOverwrite() overwrite.read_messages = True if ewcfg.permission_read_messages in permissions_dict[ user_data.poi] else False overwrite.send_messages = True if ewcfg.permission_send_messages in permissions_dict[ user_data.poi] else False #time_now_start = int(time.time()) for i in range(ewcfg.permissions_tries): await correct_channel.set_permissions(used_member, overwrite=overwrite)
async def weather_tick(id_server = None): if id_server != None: try: market_data = EwMarket(id_server = id_server) if market_data.weather != ewcfg.weather_bicarbonaterain: return exposed_pois = [] exposed_pois.extend(ewcfg.capturable_districts) exposed_pois.extend(ewcfg.outskirts) exposed_pois = tuple(exposed_pois) client = ewutils.get_client() server = client.get_server(id_server) users = ewutils.execute_sql_query("SELECT id_user FROM users WHERE id_server = %s AND {poi} IN %s AND {life_state} > 0".format( poi = ewcfg.col_poi, life_state = ewcfg.col_life_state ), ( id_server, exposed_pois )) deathreport = "" resp_cont = ewutils.EwResponseContainer(id_server = id_server) for user in users: user_data = EwUser(id_user = user[0], id_server = id_server) if user_data.life_state == ewcfg.life_state_kingpin: continue user_poi = ewcfg.id_to_poi.get(user_data.poi) player_data = EwPlayer(id_server = user_data.id_server, id_user = user_data.id_user) protected = False slimeoid_protected = False if user_data.weapon >= 0: weapon_item = EwItem(id_item = user_data.weapon) if weapon_item.item_props.get('weapon_type') in ewcfg.rain_protection: protected = True cosmetics = ewitem.inventory(id_user = user_data.id_user, id_server = id_server, item_type_filter = ewcfg.it_cosmetic) for cosmetic in cosmetics: cosmetic_data = EwItem(id_item = cosmetic.get('id_item')) if cosmetic_data.item_props.get('id_cosmetic') in ewcfg.rain_protection: if cosmetic_data.item_props.get('adorned') == 'true': protected = True elif cosmetic_data.item_props.get('slimeoid') == 'true': slimeoid_protected = True if not protected: if user_data.life_state == ewcfg.life_state_shambler: slime_gain = (ewcfg.slimes_shambler - user_data.slimes) / 10 slime_gain = max(0, int(slime_gain)) user_data.change_slimes(n = slime_gain, source = ewcfg.source_weather) else: if random.random() < 0.01: user_data.degradation += 1 user_data.persist() if not slimeoid_protected: slimeoid_data = EwSlimeoid(id_user = user_data.id_user, id_server = id_server) if slimeoid_data.life_state != ewcfg.slimeoid_state_active: continue slimeoid_response = "" if random.randrange(10) < slimeoid_data.level: slimeoid_response = "*{uname}*: {slname} cries out in pain, as it's hit by the bicarbonate rain.".format(uname = player_data.display_name, slname = slimeoid_data.name) else: item_props = { 'context': ewcfg.context_slimeoidheart, 'subcontext': slimeoid_data.id_slimeoid, 'item_name': "Heart of {}".format(slimeoid_data.name), 'item_desc': "A poudrin-like crystal. If you listen carefully you can hear something that sounds like a faint heartbeat." } ewitem.item_create( id_user = user_data.id_user, id_server = id_server, item_type = ewcfg.it_item, item_props = item_props ) slimeoid_data.die() slimeoid_data.persist() slimeoid_response = "*{uname}*: {slname} lets out a final whimper as it's dissolved by the bicarbonate rain. {skull} You quickly pocket its heart.".format(uname = player_data.display_name, slname = slimeoid_data.name, skull = ewcfg.emote_slimeskull) resp_cont.add_channel_response(user_poi.channel, slimeoid_response) for poi in exposed_pois: district_data = EwDistrict(district = poi, id_server = id_server) slimes_to_erase = district_data.slimes * 0.01 * ewcfg.weather_tick_length slimes_to_erase = max(slimes_to_erase, ewcfg.weather_tick_length * 1000) slimes_to_erase = min(district_data.slimes, slimes_to_erase) #round up or down, randomly weighted remainder = slimes_to_erase - int(slimes_to_erase) if random.random() < remainder: slimes_to_erase += 1 slimes_to_erase = int(slimes_to_erase) district_data.change_slimes(n = - slimes_to_erase, source = ewcfg.source_weather) district_data.persist() enemies = ewutils.execute_sql_query("SELECT id_enemy FROM enemies WHERE id_server = %s AND {poi} IN %s AND {life_state} = %s AND {weathertype} != %s".format( poi = ewcfg.col_enemy_poi, life_state = ewcfg.col_enemy_life_state, weathertype = ewcfg.col_enemy_weathertype ), ( id_server, exposed_pois, ewcfg.enemy_lifestate_alive, ewcfg.enemy_weathertype_rainresist )) for enemy in enemies: enemy_data = EwEnemy(id_enemy = enemy[0]) enemy_poi = ewcfg.id_to_poi.get(enemy_data.poi) slimes_to_erase = enemy_data.slimes * 0.01 * ewcfg.weather_tick_length slimes_to_erase = max(slimes_to_erase, ewcfg.weather_tick_length * 1000) slimes_to_erase = min(enemy_data.slimes, slimes_to_erase) #round up or down, randomly weighted remainder = slimes_to_erase - int(slimes_to_erase) if random.random() < remainder: slimes_to_erase += 1 slimes_to_erase = int(slimes_to_erase) enemy_data.change_slimes(n = - slimes_to_erase, source = ewcfg.source_weather) enemy_data.persist() response = "{name} takes {slimeloss:,} damage from the bicarbonate rain.".format(name = enemy_data.display_name, slimeloss = slimes_to_erase) resp_cont.add_channel_response(enemy_poi.channel, response) if enemy_data.slimes <= 0: ewhunting.delete_enemy(enemy_data) deathreport = "{skull} {name} is dissolved by the bicarbonate rain. {skull}".format(skull = ewcfg.emote_slimeskull, name = enemy_data.display_name) resp_cont.add_channel_response(enemy_poi.channel, deathreport) await resp_cont.post() except: ewutils.logMsg("Error occurred in weather tick for server {}".format(id_server))
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.slimecoin / 10) #player_data.change_slimecoin(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. player_data.poi = ewcfg.poi_id_endlesswar player_data.persist() market_data.persist() # Shower every district in the city with slime from the sewers. sewer_data = EwDistrict(district=ewcfg.poi_id_thesewers, id_server=cmd.message.server.id) # the amount of slime showered is divided equally amongst the districts districts_amount = len(ewcfg.capturable_districts) geyser_amount = int(0.5 * sewer_data.slimes / districts_amount) # Get a list of all the districts for poi in ewcfg.capturable_districts: district_data = EwDistrict(district=poi, id_server=cmd.message.server.id) district_data.change_slimes(n=geyser_amount) sewer_data.change_slimes(n=-1 * geyser_amount) district_data.persist() sewer_data.persist() sewer_inv = ewitem.inventory(id_user=sewer_data.name, id_server=sewer_data.id_server) for item in sewer_inv: district = ewcfg.poi_id_slimesea if random.random() < 0.5: district = random.choice(ewcfg.capturable_districts) ewitem.give_item(id_item=item.get("id_item"), id_user=district, id_server=sewer_data.id_server) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) response = '{slime4} Geysers of fresh slime erupt from every manhole in the city, showering their surrounding districts. {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) new_poi = ewcfg.id_to_poi.get(player_data.poi) revivechannel = ewutils.get_channel(cmd.message.server, new_poi.channel) reunite = ewutils.formatMessage(cmd.message.author, reunite) await ewutils.send_message(cmd.client, revivechannel, reunite) # Send the response to the player. await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def smelt(cmd): user_data = EwUser(member=cmd.message.author) # Find sought recipe. if cmd.tokens_count > 1: sought_result = ewutils.flattenTokenListToString(cmd.tokens[1:]) found_recipe = ewcfg.smelting_recipe_map.get(sought_result) if found_recipe != None: # Checks what ingredients are needed to smelt the recipe. necessary_ingredients = found_recipe.ingredients necessary_ingredients_list = [] owned_ingredients = [] # Seeks out the necessary ingredients in your inventory. missing_ingredients = [] for matched_item in necessary_ingredients: necessary_items = necessary_ingredients.get(matched_item) necessary_str = "{} {}".format(necessary_items, matched_item) if necessary_items > 1: necessary_str += "s" necessary_ingredients_list.append(necessary_str) sought_items = ewitem.find_item_all( item_search=matched_item, id_user=user_data.id_user, id_server=user_data.id_server) missing_items = necessary_items - len(sought_items) if missing_items > 0: missing_str = "{} {}".format(missing_items, matched_item) if missing_items > 1: missing_str += "s" missing_ingredients.append(missing_str) else: for i in range(necessary_ingredients.get(matched_item)): sought_item = sought_items.pop() owned_ingredients.append(sought_item.get('id_item')) # If you don't have all the necessary ingredients. if len(missing_ingredients) > 0: response = "You’ve never done this before, have you? To smelt {}, you’ll need to combine *{}*.".format( found_recipe.str_name, ewutils.formatNiceList(names=necessary_ingredients_list, conjunction="and")) response += " You are missing *{}*.".format( ewutils.formatNiceList(names=missing_ingredients, conjunction="and")) else: # If you try to smelt a random cosmetic, use old smelting code to calculate what your result will be. if found_recipe.id_recipe == "cosmetic": patrician_rarity = 20 patrician_smelted = random.randint(1, patrician_rarity) patrician = False if patrician_smelted == 1: patrician = True cosmetics_list = [] for result in ewcfg.cosmetic_items_list: if result.acquisition == ewcfg.acquisition_smelting: cosmetics_list.append(result) else: pass items = [] for cosmetic in cosmetics_list: if patrician and cosmetic.rarity == ewcfg.rarity_patrician: items.append(cosmetic) elif not patrician and cosmetic.rarity == ewcfg.rarity_plebeian: items.append(cosmetic) item = items[random.randint(0, len(items) - 1)] ewitem.item_create(item_type=ewcfg.it_cosmetic, id_user=cmd.message.author.id, id_server=cmd.message.server.id, item_props={ 'id_cosmetic': item.id_cosmetic, 'cosmetic_name': item.str_name, 'cosmetic_desc': item.str_desc, 'rarity': item.rarity, 'adorned': 'false' }) # If you're trying to smelt a specific item. else: possible_results = [] # Matches the recipe's listed products to actual items. for result in ewcfg.smelt_results: if hasattr(result, 'id_item'): if result.id_item not in found_recipe.products: pass else: possible_results.append(result) if hasattr(result, 'id_food'): if result.id_food not in found_recipe.products: pass else: possible_results.append(result) if hasattr(result, 'id_cosmetic'): if result.id_cosmetic not in found_recipe.products: pass else: possible_results.append(result) if hasattr(result, 'id_weapon'): if result.id_weapon not in found_recipe.products: pass else: possible_results.append(result) # If there are multiple possible products, randomly select one. item = random.choice(possible_results) item_props = ewitem.gen_item_props(item) ewitem.item_create(item_type=item.item_type, id_user=cmd.message.author.id, id_server=cmd.message.server.id, item_props=item_props) for id_item in owned_ingredients: ewitem.item_delete(id_item=id_item) name = "" if hasattr(item, 'str_name'): name = item.str_name elif hasattr(item, 'id_weapon'): name = item.id_weapon response = "You sacrifice your {} to smelt a {}!!".format( ewutils.formatNiceList(names=necessary_ingredients_list, conjunction="and"), name) user_data.persist() else: response = "There is no recipe by the name." else: response = "Please specify a desired smelt result." # Send response await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def manifest(cmd): user_data = EwUser(member=cmd.message.author) response = "" if user_data.life_state == ewcfg.life_state_corpse and user_data.busted: if user_data.poi == ewcfg.poi_id_thesewers: return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage( cmd.message.author, "You're busted, bitch. You can't leave the sewers until your restore your power by !haunting one of the living." )) else: # sometimes busted ghosts get stuck outside the sewers user_data.poi = ewcfg.poi_id_thesewers user_data.persist() await ewrolemgr.updateRoles(cmd.client, cmd.message.author) return if user_data.life_state != ewcfg.life_state_corpse: response = "You don't even know what that MEANS." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if user_data.poi != ewcfg.poi_id_thesewers: response = "You've already manifested in the city." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if user_data.slimes > ewcfg.slimes_tomanifest: response = "You are too weak to manifest. You need to gather more negative slime." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) poi = ewcfg.id_to_poi.get(user_data.poi_death) response = "{}ing in {}.".format(cmd.tokens[0][1:].capitalize(), poi.str_name) # schedule tasks for concurrent execution message_task = asyncio.ensure_future( ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))) wait_task = asyncio.ensure_future(asyncio.sleep(5)) # Take control of the move for this player. ewmap.move_counter += 1 move_current = ewutils.moves_active[ cmd.message.author.id] = ewmap.move_counter await message_task await wait_task # check if the user entered another movement command while waiting for the current one to be completed if move_current != ewutils.moves_active[cmd.message.author.id]: return user_data = EwUser(member=cmd.message.author) user_data.poi = poi.id_poi user_data.persist() await ewrolemgr.updateRoles(cmd.client, cmd.message.author)
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))
def decaySlimes(id_server = None): if id_server != None: try: conn_info = databaseConnect() conn = conn_info.get('conn') cursor = conn.cursor(); cursor.execute("SELECT id_user FROM users WHERE id_server = %s AND {slimes} > 1".format( slimes = ewcfg.col_slimes ), ( id_server, )) users = cursor.fetchall() total_decayed = 0 for user in users: user_data = EwUser(id_user = user[0], id_server = id_server) slimes_to_decay = user_data.slimes - (user_data.slimes * (.5 ** (ewcfg.update_market / ewcfg.slime_half_life))) #round up or down, randomly weighted remainder = slimes_to_decay - int(slimes_to_decay) if random.random() < remainder: slimes_to_decay += 1 slimes_to_decay = int(slimes_to_decay) if slimes_to_decay >= 1: user_data.change_slimes(n = -slimes_to_decay, source = ewcfg.source_decay) user_data.persist() total_decayed += slimes_to_decay cursor.execute("SELECT district FROM districts WHERE id_server = %s AND {slimes} > 1".format( slimes = ewcfg.col_district_slimes ), ( id_server, )) districts = cursor.fetchall() for district in districts: district_data = EwDistrict(district = district[0], id_server = id_server) slimes_to_decay = district_data.slimes - (district_data.slimes * (.5 ** (ewcfg.update_market / ewcfg.slime_half_life))) #round up or down, randomly weighted remainder = slimes_to_decay - int(slimes_to_decay) if random.random() < remainder: slimes_to_decay += 1 slimes_to_decay = int(slimes_to_decay) if slimes_to_decay >= 1: district_data.change_slimes(n = -slimes_to_decay, source = ewcfg.source_decay) district_data.persist() total_decayed += slimes_to_decay cursor.execute("UPDATE markets SET {decayed} = ({decayed} + %s) WHERE {server} = %s".format( decayed = ewcfg.col_decayed_slimes, server = ewcfg.col_id_server ), ( total_decayed, id_server )) conn.commit() finally: # Clean up the database handles. cursor.close() databaseClose(conn_info)
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))
elif life_state == 0: return url.format("ghost") return "" if len(sys.argv) >= 3: id_server = sys.argv[1] id_user = sys.argv[2] else: print("<p><i>Nothing but dust...</i></p>") sys.exit(0) print("<article class=story>") user_data = EwUser(id_user=id_user, id_server=id_server) player = EwPlayer(id_user=id_user) # Floating profile section print( "<div class=profile_float><img src=\"{avatar_url}\" class=profile_avatar>". format(avatar_url=player.avatar)) print("<table>") print("<tr><td>Faction</td><td>{icon}{faction}</td></tr>".format( icon=faction(user_data.faction, user_data.life_state), faction=user_data.faction)) print( "<tr><td>Slime</td><td>{slime:,}</td></tr>".format(slime=user_data.slimes)) print("<tr><td>SlimeCoin</td><td>{slimecoin:,}</td></tr>".format( slimecoin=user_data.slimecoin))
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 banish(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state != ewcfg.life_state_kingpin: response = "Only the Rowdy F****r {} and the Cop Killer {} can do that.".format( ewcfg.emote_rowdyfucker, ewcfg.emote_copkiller) else: member = None if cmd.mentions_count == 1: member = cmd.mentions[0] if member.id == cmd.message.author.id: member = None if member == None: response = "Who?" else: member_data = EwUser(member=member) member_data.ban(faction=user_data.faction) member_data.unvouch(faction=user_data.faction) if member_data.faction == user_data.faction: member_data.faction = "" if member_data.life_state == ewcfg.life_state_enlisted: member_data.life_state = ewcfg.life_state_juvenile member_poi = ewcfg.id_to_poi.get(member_data.poi) if ewmap.inaccessible(user_data=member_data, poi=member_poi): member_data.poi = ewcfg.poi_id_downtown member_data.persist() response = "{} has been banned from enlisting in the {}".format( member.display_name, user_data.faction) await ewrolemgr.updateRoles(client=cmd.client, member=member) await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def sow(cmd): user_data = EwUser(member=cmd.message.author) if user_data.life_state == ewcfg.life_state_shambler: response = "You lack the higher brain functions required to {}.".format( cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) # check if the user has a farming tool equipped weapon_item = EwItem(id_item=user_data.weapon) weapon = ewcfg.weapon_map.get(weapon_item.item_props.get("weapon_type")) has_tool = False if weapon is not None: if ewcfg.weapon_class_farming in weapon.classes: has_tool = True # Checking availability of sow action if user_data.life_state != ewcfg.life_state_juvenile and not has_tool: response = "Only Juveniles of pure heart and with nothing better to do can farm." elif cmd.message.channel.name not in [ ewcfg.channel_jr_farms, ewcfg.channel_og_farms, ewcfg.channel_ab_farms ]: response = "The cracked, filthy concrete streets around you would be a pretty terrible place for a farm. Try again on more arable land." else: poi = ewcfg.id_to_poi.get(user_data.poi) district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) if district_data.is_degraded(): response = "{} has been degraded by shamblers. You can't {} here anymore.".format( poi.str_name, cmd.tokens[0]) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) if user_data.poi == ewcfg.poi_id_jr_farms: farm_id = ewcfg.poi_id_jr_farms elif user_data.poi == ewcfg.poi_id_og_farms: farm_id = ewcfg.poi_id_og_farms else: # if it's the farm in arsonbrook farm_id = ewcfg.poi_id_ab_farms farm = EwFarm(id_server=cmd.guild.id, id_user=cmd.message.author.id, farm=farm_id) if farm.time_lastsow > 0: response = "You’ve already sown something here. Try planting in another farming location. If you’ve planted in all three farming locations, you’re shit out of luck. Just wait, asshole." else: it_type_filter = None # gangsters can only plant poudrins if cmd.tokens_count > 1 and user_data.life_state == ewcfg.life_state_juvenile: item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) # if the item selected was a vegetable, use a food only filter in find_item for v in ewcfg.vegetable_list: if item_search in v.id_food or item_search in v.str_name: it_type_filter = ewcfg.it_food break else: item_search = "slimepoudrin" item_sought = ewitem.find_item( item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None, item_type_filter=it_type_filter) if item_sought == None: response = "You don't have anything to plant! Try collecting a poudrin." else: slimes_onreap = ewcfg.reap_gain item_data = EwItem(id_item=item_sought.get("id_item")) if item_data.item_type == ewcfg.it_item: if item_data.item_props.get( "id_item") == ewcfg.item_id_slimepoudrin: vegetable = random.choice(ewcfg.vegetable_list) slimes_onreap *= 2 elif item_data.item_props.get( "context") == ewcfg.context_slimeoidheart: vegetable = random.choice(ewcfg.vegetable_list) slimes_onreap *= 2 slimeoid_data = EwSlimeoid( id_slimeoid=item_data.item_props.get("subcontext")) slimeoid_data.delete() else: response = "The soil has enough toxins without you burying your trash here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) elif item_data.item_type == ewcfg.it_food: food_id = item_data.item_props.get("id_food") vegetable = ewcfg.food_map.get(food_id) if ewcfg.vendor_farm not in vegetable.vendors: response = "It sure would be nice if {}s grew on trees, but alas they do not. Idiot.".format( item_sought.get("name")) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) elif user_data.life_state != ewcfg.life_state_juvenile: response = "You lack the knowledge required to grow {}.".format( item_sought.get("name")) return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) else: response = "The soil has enough toxins without you burying your trash here." return await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)) mutations = user_data.get_mutations() growth_time = ewcfg.crops_time_to_grow if user_data.life_state == ewcfg.life_state_juvenile: growth_time /= 2 if ewcfg.mutation_id_greenfingers in mutations: growth_time /= 1.5 hours = int(growth_time / 60) minutes = int(growth_time % 60) str_growth_time = "{} hour{}{}".format( hours, "s" if hours > 1 else "", " and {} minutes".format(minutes) if minutes > 0 else "") # Sowing response = "You sow a {} into the fertile soil beneath you. It will grow in about {}.".format( item_sought.get("name"), str_growth_time) farm.time_lastsow = int(time.time() / 60) # Grow time is stored in minutes. farm.time_lastphase = int(time.time()) farm.slimes_onreap = slimes_onreap farm.crop = vegetable.id_food farm.phase = ewcfg.farm_phase_sow farm.action_required = ewcfg.farm_action_none farm.sow_life_state = user_data.life_state if ewcfg.mutation_id_greenfingers in mutations: if user_data.life_state == ewcfg.life_state_juvenile: farm.sow_life_state = ewcfg.farm_life_state_juviethumb else: farm.sow_life_state = ewcfg.farm_life_state_thumb ewitem.item_delete( id_item=item_sought.get('id_item')) # Remove Poudrins farm.persist() await ewutils.send_message( cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))