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))
