async def crystalize_negapoudrin(cmd):
user_data = EwUser(member=cmd.message.author)
response = ""
if user_data.life_state != ewcfg.life_state_corpse:
response = "What the f**k do you think you're doing, you corporeal bitch?"
elif user_data.slimes >= (ewcfg.slimes_tomanifest +
ewcfg.slimes_to_crystalize_negapoudrin):
# prevent ghosts from using so much antislime they can't manifest afterwards
response = "Crystalizing a negapoudrin requires a lot of negaslime, and you're not quite there yet."
else:
negapoudrin_data = next(i for i in ewcfg.item_list
if i.id_item == ewcfg.item_id_negapoudrin)
ewitem.item_create(item_type=ewcfg.it_item,
id_user=user_data.id_user,
id_server=cmd.guild.id,
item_props={
'id_item': negapoudrin_data.id_item,
'item_name': negapoudrin_data.str_name,
'item_desc': negapoudrin_data.str_desc,
})
user_data.change_slimes(n=-ewcfg.slimes_to_crystalize_negapoudrin,
source=ewcfg.source_spending)
user_data.persist()
response = "The cathedral's bells toll in the distance, and a rumbling {} can be heard echoing from deep within the sewers. A negapoudrin has formed.".format(
ewcfg.cmd_boo)
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def bleedout(cmd):
user_data = EwUser(member=cmd.message.author)
mutations = user_data.get_mutations()
if ewcfg.mutation_id_bleedingheart not in mutations:
response = "You don't have an open enough wound to just gush your blood everywhere."
elif user_data.bleed_storage == 0:
response = "There's nothing to bleed. Sounds like someone has a persecution complex..."
elif user_data.bleed_storage > user_data.slimes: #don't think this is possible, but just in case
response = "Wait, wouldn't that kill you? Better not."
else:
response = "You clutch your malformed heart and squeeze as hard as you can. The intense pain makes you fall to your knees, and your slime drops in spurts to the floor under you as you gasp desperately for relief. You have been bled dry."
poi = ewcfg.id_to_poi.get(user_data.poi)
district_data = EwDistrict(id_server=cmd.message.guild.id,
district=poi.id_poi)
user_data.change_slimes(n=-user_data.bleed_storage,
source=ewcfg.source_bleeding)
district_data.change_slimes(n=user_data.bleed_storage,
source=ewcfg.source_bleeding)
user_data.bleed_storage = 0
user_data.persist()
district_data.persist()
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def renounce(cmd):
user_data = EwUser(member=cmd.message.author)
if user_data.life_state == ewcfg.life_state_corpse:
response = "You're dead, bitch."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif user_data.life_state != ewcfg.life_state_enlisted:
response = "What exactly are you renouncing? Your lackadaisical, idyllic life free of vice and violence? You aren't actually currently enlisted in any gang, retard."
elif user_data.poi not in [
ewcfg.poi_id_rowdyroughhouse, ewcfg.poi_id_copkilltown
]:
response = "To turn in your badge, you must return to your soon-to-be former gang base."
else:
renounce_fee = int(user_data.slimes) / 2
user_data.change_slimes(n=-renounce_fee)
faction = user_data.faction
user_data.life_state = ewcfg.life_state_juvenile
user_data.weapon = -1
user_data.persist()
response = "You are no longer enlisted in the {}, but you are not free of association with them. Your former teammates immediately begin to beat the shit out of you, knocking {} slime out of you before you're able to get away.".format(
faction, renounce_fee)
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def bleedSlimes(id_server = None):
if id_server != None:
try:
client = get_client()
server = client.get_server(id_server)
conn_info = databaseConnect()
conn = conn_info.get('conn')
cursor = conn.cursor();
cursor.execute("SELECT id_user FROM users WHERE id_server = %s AND {bleed_storage} > 1".format(
bleed_storage = ewcfg.col_bleed_storage
), (
id_server,
))
users = cursor.fetchall()
total_bled = 0
deathreport = ""
resp_cont = EwResponseContainer(id_server = id_server)
for user in users:
user_data = EwUser(id_user = user[0], id_server = id_server)
slimes_to_bleed = user_data.bleed_storage * (1 - .5 ** (ewcfg.bleed_tick_length / ewcfg.bleed_half_life))
slimes_to_bleed = max(slimes_to_bleed, ewcfg.bleed_tick_length * 1000)
slimes_to_bleed = min(slimes_to_bleed, user_data.bleed_storage)
slimes_dropped = user_data.totaldamage + user_data.slimes
district_data = EwDistrict(id_server = id_server, district = user_data.poi)
#round up or down, randomly weighted
remainder = slimes_to_bleed - int(slimes_to_bleed)
if random.random() < remainder:
slimes_to_bleed += 1
slimes_to_bleed = int(slimes_to_bleed)
if slimes_to_bleed >= 1:
user_data.bleed_storage -= slimes_to_bleed
user_data.change_slimes(n = - slimes_to_bleed, source = ewcfg.source_bleeding)
if user_data.slimes < 0:
user_data.die(cause = ewcfg.cause_bleeding)
#user_data.change_slimes(n = -slimes_dropped / 10, source = ewcfg.source_ghostification)
player_data = EwPlayer(id_server = user_data.id_server, id_user = user_data.id_user)
deathreport = "{skull} *{uname}*: You have succumbed to your wounds. {skull}".format(skull = ewcfg.emote_slimeskull, uname = player_data.display_name)
resp_cont.add_channel_response(ewcfg.channel_sewers, deathreport)
user_data.persist()
district_data.change_slimes(n = slimes_to_bleed, source = ewcfg.source_bleeding)
district_data.persist()
total_bled += slimes_to_bleed
await ewrolemgr.updateRoles(client = client, member = server.get_member(user_data.id_user))
await resp_cont.post()
conn.commit()
finally:
# Clean up the database handles.
cursor.close()
databaseClose(conn_info)
async def possess_weapon(cmd):
user_data = EwUser(member = cmd.message.author)
response = ""
if user_data.life_state != ewcfg.life_state_corpse:
response = "You have no idea what you're doing."
elif not user_data.get_inhabitee():
response = "You're not **{}**ing anyone right now.".format(ewcfg.cmd_inhabit)
elif user_data.slimes >= ewcfg.slimes_to_possess_weapon:
response = "You'll have to become stronger before you can perform occult arts of this level."
else:
server = cmd.guild
inhabitee_id = user_data.get_inhabitee()
inhabitee_data = EwUser(id_user = inhabitee_id, id_server = user_data.id_server)
inhabitee_member = server.get_member(inhabitee_id)
inhabitee_name = inhabitee_member.display_name
if inhabitee_data.weapon < 0:
response = "{} is not wielding a weapon right now.".format(inhabitee_name)
elif inhabitee_data.get_possession():
response = "{} is already being possessed.".format(inhabitee_name)
else:
proposal_response = "You propose a trade to {}.\n" \
"You will possess their weapon to empower it, and in return they'll sacrifice a fifth of their slime to your name upon their next kill.\n" \
"Will they **{}** this exchange, or **{}** it?".format(inhabitee_name, ewcfg.cmd_accept, ewcfg.cmd_refuse)
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, proposal_response))
accepted = False
try:
msg = await cmd.client.wait_for('message', timeout = 30, check=lambda message: message.author == inhabitee_member and
message.content.lower() in [ewcfg.cmd_accept, ewcfg.cmd_refuse])
if msg != None:
if msg.content.lower() == ewcfg.cmd_accept:
accepted = True
elif msg.content.lower() == ewcfg.cmd_refuse:
accepted = False
except:
accepted = False
if accepted:
ewutils.execute_sql_query(
"UPDATE inhabitations SET {empowered} = %s WHERE {id_fleshling} = %s AND {id_ghost} = %s".format(
empowered = ewcfg.col_empowered,
id_fleshling = ewcfg.col_id_fleshling,
id_ghost = ewcfg.col_id_ghost,
), (
'weapon',
inhabitee_id,
user_data.id_user,
))
user_data.change_slimes(n = -ewcfg.slimes_to_possess_weapon, source = ewcfg.source_ghost_contract)
user_data.persist()
accepted_response = "You feel a metallic taste in your mouth as you sign {}'s spectral contract. You see them bind themselves to your weapon, which now bears their mark. It feels cold to the touch.".format(cmd.message.author.display_name)
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(inhabitee_member, accepted_response))
else:
response = "You should've known better, why would anyone ever trust you?"
if response:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def possess_fishing_rod(cmd):
user_data = EwUser(member = cmd.message.author)
response = ""
if user_data.life_state != ewcfg.life_state_corpse:
response = "You have no idea what you're doing."
elif not user_data.get_inhabitee():
response = "You're not **{}**ing anyone right now.".format(ewcfg.cmd_inhabit)
elif user_data.slimes >= ewcfg.slimes_to_possess_fishing_rod:
response = "You'll have to become stronger before you can perform occult arts of this level."
else:
server = cmd.guild
inhabitee_id = user_data.get_inhabitee()
inhabitee_data = EwUser(id_user = inhabitee_id, id_server = user_data.id_server)
inhabitee_member = server.get_member(inhabitee_id)
inhabitee_name = inhabitee_member.display_name
if inhabitee_data.get_possession():
response = "{} is already being possessed.".format(inhabitee_name)
else:
proposal_response = "You propose a trade to {}.\n" \
"You will possess their fishing rod to enhance it, making it more attractive to fish. In exchange, you will corrupt away all of the fish's slime, and absorb it as antislime.\n" \
"Both of you will need to reel the fish in together, and failing to do so will nullify this contract.\nWill they **{}** this exchange, or **{}** it?".format(inhabitee_name, ewcfg.cmd_accept, ewcfg.cmd_refuse)
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, proposal_response))
accepted = False
try:
msg = await cmd.client.wait_for('message', timeout = 30, check=lambda message: message.author == inhabitee_member and
message.content.lower() in [ewcfg.cmd_accept, ewcfg.cmd_refuse])
if msg != None:
if msg.content.lower() == ewcfg.cmd_accept:
accepted = True
elif msg.content.lower() == ewcfg.cmd_refuse:
accepted = False
except:
accepted = False
if accepted:
ewutils.execute_sql_query(
"UPDATE inhabitations SET {empowered} = %s WHERE {id_fleshling} = %s AND {id_ghost} = %s".format(
empowered = ewcfg.col_empowered,
id_fleshling = ewcfg.col_id_fleshling,
id_ghost = ewcfg.col_id_ghost,
), (
'rod',
inhabitee_id,
user_data.id_user,
))
user_data.change_slimes(n = -ewcfg.slimes_to_possess_fishing_rod, source = ewcfg.source_ghost_contract)
user_data.persist()
accepted_response = "You feel a metallic taste in your mouth as you sign {}'s spectral contract. Their ghastly arms superpose yours, enhancing your grip and causing shadowy tendrils to appear near your rod's hook.".format(cmd.message.author.display_name)
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(inhabitee_member, accepted_response))
else:
response = "You should've known better, why would anyone ever trust you?"
if response:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def event_tick(id_server):
time_now = int(time.time())
resp_cont = ewutils.EwResponseContainer(id_server=id_server)
if True:
data = ewutils.execute_sql_query(
"SELECT {id_event} FROM world_events WHERE {time_expir} <= %s AND {time_expir} > 0 AND id_server = %s"
.format(
id_event=ewcfg.col_id_event,
time_expir=ewcfg.col_time_expir,
), (
time_now,
id_server,
))
for row in data:
event_data = EwWorldEvent(id_event=row[0])
event_def = ewcfg.event_type_to_def.get(event_data.event_type)
response = event_def.str_event_end
if event_data.event_type == ewcfg.event_type_minecollapse:
user_data = EwUser(
id_user=event_data.event_props.get('id_user'),
id_server=id_server)
if user_data.poi == event_data.event_props.get('poi'):
user_data.change_slimes(n=-(user_data.slimes * 0.5))
user_data.persist()
player_data = EwPlayer(id_user=user_data.id_user)
response = "*{}*: You have lost an arm and a leg in a mining accident. Tis but a scratch.".format(
player_data.display_name)
if len(response) > 0:
poi = event_data.event_props.get('poi')
channel = event_data.event_props.get('channel')
if channel != None:
resp_cont.add_channel_response(channel, response)
elif poi != None:
poi_def = ewcfg.id_to_poi.get(poi)
if poi_def != None:
resp_cont.add_channel_response(poi_def.channel,
response)
else:
for ch in ewcfg.hideout_channels:
resp_cont.add_channel_response(ch, response)
delete_world_event(event_data.id_event)
await resp_cont.post()
else:
ewutils.logMsg("Error in event tick for server {}".format(id_server))
async def donate(cmd):
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_slimecorphq:
# Only allowed in SlimeCorp HQ.
response = "You must go to SlimeCorp HQ to donate slime."
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
return
user_data = EwUser(member = cmd.message.author)
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 and value < ewcfg.slimecoin_exchangerate:
response = "You must volunteer to donate at least %d slime to receive compensation." % ewcfg.slimecoin_exchangerate
elif value != None:
# Amount of slime invested.
cost_total = int(value)
coin_total = int(value / ewcfg.slimecoin_exchangerate)
if user_data.slimes < cost_total:
response = "Acid-green flashes of light and bloodcurdling screams emanate from small window of SlimeCorp HQ. Unfortunately, you did not survive the procedure. Your body is dumped down a disposal chute to the sewers."
user_data.die(cause = ewcfg.cause_donation)
user_data.persist()
# Assign the corpse role to the player. He dead.
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
sewerchannel = ewutils.get_channel(cmd.message.server, ewcfg.channel_sewers)
await cmd.client.send_message(sewerchannel, "{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage(cmd.message.author, "You have died in a medical mishap. {}".format(ewcfg.emote_slimeskull)))
else:
# Do the transfer if the player can afford it.
user_data.change_slimes(n = -cost_total, source = ewcfg.source_spending)
user_data.change_slimecredit(n = coin_total, coinsource = ewcfg.coinsource_donation)
user_data.time_lastinvest = time_now
# Persist changes
user_data.persist()
response = "You stumble out of a Slimecorp HQ vault room in a stupor. You don't remember what happened in there, but your body hurts and you've got {slimecoin:,} shiny new SlimeCoin in your pocket.".format(slimecoin = coin_total)
else:
response = ewcfg.str_exchange_specify.format(currency = "slime", action = "donate")
# Send the response to the player.
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def annoint(cmd):
response = ""
if cmd.tokens_count < 2:
response = "Specify a name for your weapon!"
else:
annoint_name = cmd.message.content[(len(ewcfg.cmd_annoint)):].strip()
if len(annoint_name) > 32:
response = "That name is too long. ({:,}/32)".format(
len(annoint_name))
else:
user_data = EwUser(member=cmd.message.author)
poudrins = ewitem.inventory(id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
item_type_filter=ewcfg.it_slimepoudrin)
poudrins_count = len(poudrins)
if poudrins_count < 1:
response = "You need a slime poudrin."
elif user_data.slimes < 100:
response = "You need more slime."
elif user_data.weapon == "":
response = "Equip a weapon first."
else:
# Perform the ceremony.
user_data.change_slimes(n=-100, source=ewcfg.source_spending)
user_data.weaponname = annoint_name
skillup = 0
if user_data.weaponskill < 10:
skillup = 1
user_data.add_weaponskill(n=skillup)
# delete a slime poudrin from the player's inventory
ewitem.item_delete(id_item=poudrins[0].get('id_item'))
user_data.persist()
response = "You place your weapon atop the poudrin and annoint it with slime. It is now known as {}!\n\nThe name draws you closer to your weapon. The poudrin was destroyed in the process.".format(
annoint_name)
# Send the response to the player.
await cmd.client.send_message(
cmd.message.channel, ewutils.formatMessage(cmd.message.author,
response))
async def autocannibalize(cmd): user_data = EwUser(member = cmd.message.author) response = "" if user_data.race == ewcfg.races["food"]: time_now = int(time.time()) if time_now > user_data.time_racialability: response = "You give in to the the existential desire all foods have, and take a small bite out of yourself. It hurts like a bitch, but God **DAMN** you're tasty." user_data.time_racialability = time_now + ewcfg.cd_autocannibalize user_data.hunger = max(user_data.hunger - (user_data.get_hunger_max() * 0.01), 0) user_data.change_slimes(n = -user_data.slimes * 0.001) user_data.persist() else: response = "You're too full of yourself right now, try again later." else: response = "You people are not allowed to do that." return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def begin_manuscript(cmd = None, dm = False):
user_data = EwUser(member = cmd.message.author)
title = cmd.message.content[(len(cmd.tokens[0])):].strip()
cost = 20000
if not dm:
poi = ewcfg.chname_to_poi.get(cmd.message.channel.name)
else:
poi = ewcfg.id_to_poi.get(user_data.poi)
if not poi.write_manuscript and not dm:
response = "You'd love to work on your zine, however your current location doesn't strike you as a particularly good place to write. Try heading over the the Cafe, the Comic Shop, or one of the colleges (NLACU/NMS)."
elif poi not in ewcfg.zine_mother_districts and dm:
response = "You'd love to work on your zine, however your current location doesn't strike you as a particularly good place to write. Try heading over the the Cafe, the Comic Shop, or one of the colleges (NLACU/NMS). Keep in mind, once you're there you can work on your manuscript in DMs."
elif user_data.slimes < cost:
response = "You don't have enough slime to create a manuscript. ({:,}/{:,})".format(user_data.slimes, cost)
elif user_data.hunger >= user_data.get_hunger_max() and user_data.life_state != ewcfg.life_state_corpse:
response = "You are just too hungry to begin your masterpiece!"
elif title == "":
response = "Specify a title."
elif len(title) > 50:
response = "Alright buddy, reel it in. That title is just too long. ({:,}/50)".format(len(title))
else:
if user_data.manuscript != -1:
response = "You already have a manuscript deployed you eager beaver!"
else:
book = EwBook(member = cmd.message.author, book_state = 0)
book.author = cmd.message.author.display_name
book.title = title
user_data.manuscript = book.id_book
user_data.change_slimes(n=-cost, source=ewcfg.source_spending)
book.persist()
user_data.persist()
response = "You exchange 20,000 slime for a shoddily-bound manuscript. You scrawl the name \"{} by {}\" into the cover.".format(book.title, book.author)
await ewutils.send_message(cmd.client, cmd.message.channel, 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("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 deadmega(cmd):
response = ""
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:
value = 1000000
user_slimes = 0
if value > user_data.slimes:
response = "You don't have that much slime to lose ({:,}/{:,}).".format(user_data.slimes, value)
else:
user_data.change_slimes(n = -value)
user_data.persist()
response = "Alas, poor megaslime. You have {:,} slime remaining.".format(user_data.slimes)
# Send the response to the player.
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def arrest(cmd):
author = cmd.message.author
if not author.server_permissions.administrator:
return
if cmd.mentions_count == 1:
member = cmd.mentions[0]
user_data = EwUser(member=member)
user_data.arrested = True
user_data.poi = ewcfg.poi_id_juviesrow
user_data.change_slimes(n=-user_data.slimes)
user_data.persist()
response = "{} is thrown into one of the Juvenile Detention Center's high security solitary confinement cells.".format(
member.display_name)
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 reap(cmd):
user_data = EwUser(member=cmd.message.author)
response = ""
levelup_response = ""
mutations = user_data.get_mutations()
poi = ewcfg.id_to_poi.get(user_data.poi)
# Checking availability of reap 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 user_data.poi not in [
ewcfg.poi_id_jr_farms, ewcfg.poi_id_og_farms, ewcfg.poi_id_ab_farms
]:
response = "Do you remember planting anything here in this barren wasteland? No, you don’t. Idiot."
else:
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.message.server.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."
else:
cur_time_min = time.time() / 60
time_grown = cur_time_min - farm.time_lastsow
if farm.phase != ewcfg.farm_phase_reap:
response = "Patience is a virtue and you are morally bankrupt. Just wait, asshole."
else: # Reaping
if time_grown > ewcfg.crops_time_to_grow * 16: # about 2 days
response = "You eagerly cultivate your crop, but what’s this? It’s dead and wilted! It seems as though you’ve let it lay fallow for far too long. Pay better attention to your farm next time. You gain no slime."
else:
user_initial_level = user_data.slimelevel
slime_gain = farm.slimes_onreap
if poi.is_subzone:
district_data = EwDistrict(
district=poi.mother_district,
id_server=cmd.message.server.id)
else:
district_data = EwDistrict(
district=poi.id_poi,
id_server=cmd.message.server.id)
if district_data.controlling_faction != "" and district_data.controlling_faction == user_data.faction:
slime_gain *= 2
response = "You reap what you’ve sown. Your investment has yielded {} slime, ".format(
slime_gain)
# Determine if an item is found.
unearthed_item = False
unearthed_item_amount = 0
unearthed_item_chance = 50 / ewcfg.unearthed_item_rarity # 1 in 30 chance
if ewcfg.mutation_id_lucky in mutations:
unearthed_item_chance *= 1.33
if random.random() < unearthed_item_chance:
unearthed_item = True
unearthed_item_amount = 1 if random.randint(
1, 3) != 1 else 2 # 33% chance of extra drop
if unearthed_item == True:
# If there are multiple possible products, randomly select one.
item = random.choice(ewcfg.mine_results)
item_props = ewitem.gen_item_props(item)
if item is not None:
for creation in range(unearthed_item_amount):
ewitem.item_create(
item_type=item.item_type,
id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
item_props=item_props)
if unearthed_item_amount == 1:
response += "a {}, ".format(item.str_name)
elif unearthed_item_amount == 2:
response += "two {}s, ".format(item.str_name)
# Determine what crop is grown.
vegetable = ewcfg.food_map.get(farm.crop)
if vegetable is None:
vegetable = random.choice(ewcfg.vegetable_list)
item_props = ewitem.gen_item_props(vegetable)
# Create and give a bushel of whatever crop was grown.
for vcreate in range(3):
ewitem.item_create(id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
item_type=vegetable.item_type,
item_props=item_props)
response += "and a bushel of {}!".format(
vegetable.str_name)
levelup_response = user_data.change_slimes(
n=slime_gain, source=ewcfg.source_farming)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Tell the player their slime level increased.
if was_levelup:
response += "\n\n" + levelup_response
user_data.hunger += ewcfg.hunger_perfarm
user_data.persist()
farm.time_lastsow = 0 # 0 means no seeds are currently planted
farm.persist()
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def graft(cmd):
user_data = EwUser(member=cmd.message.author)
if cmd.message.channel.name != ewcfg.channel_clinicofslimoplasty:
response = "Chemotherapy doesn't just grow on trees. You'll need to go to the clinic in Crookline to get some."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif user_data.life_state == ewcfg.life_state_shambler:
response = '"Oh goodness me, it seems like another one of these decaying subhumans has wandered into my office. Go on, shoo!"\n\nTough luck, seems shamblers aren\'t welcome here.'.format(
cmd.tokens[0])
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)
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))
elif user_data.life_state == ewcfg.life_state_corpse:
response = '"You get out of here, dirty nega. We don\'t serve your kind." \n\n Auntie Dusttrap threatingly flails a jar of cole slaw at you. Looks like you need a body to mutate a body.'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif len(cmd.tokens) <= 1:
response = '"What, just anything? I love a good improv surgery! I had to leave town the last one I did though, so you\'ll have to pick an actual surgical procedure. Sorry, sonny."'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
target_name = ewutils.flattenTokenListToString(cmd.tokens[1:])
target = ewutils.get_mutation_alias(target_name)
mutations = user_data.get_mutations()
if target == 0:
response = '"What? My ears aren\'t what they used to be. I thought you suggested I give you {}. Only braindead squicks would say that."'.format(
' '.join(cmd.tokens[1:]))
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif target in mutations:
response = '"Nope, you already have that mutation. Hey, I thought I was supposed to be the senile one here!"'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif user_data.get_mutation_level(
) + ewcfg.mutations_map[target].tier > min([user_data.slimelevel, 50]):
response = '"Your body\'s already full of mutations. Your sentient tumors will probably start bitin\' once I take out my scalpel."\n\nLevel:{}/50\nMutation Levels Added:{}/{}'.format(
user_data.slimelevel, user_data.get_mutation_level(),
min(user_data.slimelevel, 50))
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif ewcfg.mutations_map.get(target).tier * 10000 > user_data.slimes:
response = '"We\'re not selling gumballs here. It\'s cosmetic surgery. It\'ll cost at least {} slime, ya idjit!"'.format(
ewcfg.mutations_map.get(target).tier * 10000)
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
price = ewcfg.mutations_map.get(target).tier * 10000
user_data.change_slimes(n=-price, source=ewcfg.source_spending)
user_data.persist()
user_data.add_mutation(id_mutation=target, is_artificial=1)
response = ewcfg.mutations_map[
target].str_transplant + "\n\nMutation Levels Added:{}/{}".format(
user_data.get_mutation_level(), min(user_data.slimelevel, 50))
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def chemo(cmd):
user_data = EwUser(member=cmd.message.author)
if cmd.message.channel.name != ewcfg.channel_clinicofslimoplasty:
response = "Chemotherapy doesn't just grow on trees. You'll need to go to the clinic in Crookline to get some."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif user_data.life_state == ewcfg.life_state_shambler:
response = '"Oh goodness me, it seems like another one of these decaying subhumans has wandered into my office. Go on, shoo!"\n\nTough luck, seems shamblers aren\'t welcome here.'.format(
cmd.tokens[0])
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)
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))
elif user_data.life_state == ewcfg.life_state_corpse:
response = '"You get out of here. We don\'t serve your kind." \n\n Auntie Dusttrap threatingly flails a jar of cole slaw at you. Looks like you need a body to operate on one.'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
mutations = user_data.get_mutations()
if len(mutations) == 0:
response = '"I can chemo you all day long, sonny. You\'re not getting any cleaner than you are."'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif len(cmd.tokens) <= 1:
response = '"Are you into chemo for the thrill, boy? You have to tell me what you want taken out."'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif cmd.tokens[1] == "all":
finalprice = 0
for mutation in mutations:
finalprice += ewcfg.mutations_map.get(mutation).tier * 5000
if finalprice > user_data.slimes:
response = '"We\'re not selling gumballs here. It\'s chemotherapy. It\'ll cost at least {:,} slime, ya idjit!"'.format(
finalprice)
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
response = "\"Sure you got the slime for that, whelp? It's {:,}.\"\n**Accept** or **refuse?**".format(
finalprice)
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
try:
accepted = False
message = await cmd.client.wait_for(
'message',
timeout=30,
check=lambda message: message.author == cmd.message.author
and message.content.lower(
) in [ewcfg.cmd_accept, ewcfg.cmd_refuse])
if message != None:
if message.content.lower() == ewcfg.cmd_accept:
accepted = True
if message.content.lower() == ewcfg.cmd_refuse:
accepted = False
except Exception as e:
print(e)
accepted = False
if not accepted:
response = "\"Tch. Knew you weren't good for it.\""
else:
for mutation in mutations:
price = ewcfg.mutations_map.get(mutation).tier * 5000
user_data.change_slimes(n=-price,
source=ewcfg.source_spending)
mutation_obj = EwMutation(id_mutation=mutation,
id_user=user_data.id_user,
id_server=cmd.message.guild.id)
if mutation_obj.artificial == 0:
try:
ewutils.execute_sql_query(
"DELETE FROM mutations WHERE {id_server} = %s AND {id_user} = %s AND {mutation} = %s"
.format(id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user,
mutation=ewcfg.col_id_mutation), (
user_data.id_server,
user_data.id_user,
mutation,
))
except:
ewutils.logMsg(
"Failed to clear mutations for user {}.".
format(user_data.id_user))
user_data.persist()
response = '"Everything, eh? All right then. This might hurt a lottle!" Auntie Dusttrap takes a specialized shop vac and sucks the slime out of you. While you\'re reeling in slimeless existential dread, she runs it through a filtration process that gets rid of the carcinogens that cause mutation. She grabs the now purified canister and haphazardly dumps it back into you. You feel pure, energized, and ready to dirty up your slime some more!'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
target_name = ewutils.flattenTokenListToString(cmd.tokens[1:])
target = ewutils.get_mutation_alias(target_name)
mutation_obj = EwMutation(id_mutation=target,
id_user=user_data.id_user,
id_server=cmd.message.guild.id)
if target == 0:
response = '"I don\'t know what kind of gold-rush era disease that is, but I have no idea how to take it out of you."'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif target not in mutations:
response = '"Oy vey, another hypochondriac. You don\'t have that mutation, so I can\'t remove it."'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif ewcfg.mutations_map.get(target).tier * 5000 > user_data.slimes:
response = '"We\'re not selling gumballs here. It\'s chemotherapy. It\'ll cost at least {} slime, ya idjit!"'.format(
ewcfg.mutations_map.get(target).tier * 5000)
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif mutation_obj.artificial == 1:
response = '"Hey, didn\'t I do that to ya? Well no refunds!"\n\nGuess you can\'t get rid of artificial mutations with chemo.'
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
price = ewcfg.mutations_map.get(target).tier * 5000
user_data.change_slimes(n=-price, source=ewcfg.source_spending)
user_data.persist()
try:
ewutils.execute_sql_query(
"DELETE FROM mutations WHERE {id_server} = %s AND {id_user} = %s AND {mutation} = %s"
.format(id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user,
mutation=ewcfg.col_id_mutation), (
user_data.id_server,
user_data.id_user,
target,
))
except:
ewutils.logMsg("Failed to clear mutations for user {}.".format(
user_data.id_user))
response = '"Alright, dearie, let\'s get you purged." You enter a dingy looking operating room, with slime strewn all over the floor. Dr. Dusttrap pulls out a needle the size of your bicep and injects into odd places on your body. After a few minutes of this, you get fatigued and go under.\n\n You wake up and {} is gone. Nice! \nMutation Levels Added:{}/{}'.format(
ewcfg.mutations_map.get(target).str_name,
user_data.get_mutation_level(), min(user_data.slimelevel, 50))
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def order(cmd):
user_data = EwUser(member=cmd.message.author)
if user_data.life_state == ewcfg.life_state_shambler and user_data.poi != ewcfg.poi_id_nuclear_beach_edge:
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=cmd.guild.id)
currency_used = 'slime'
current_currency_amount = user_data.slimes
#poi = ewmap.fetch_poi_if_coordless(cmd.message.channel.name)
poi = ewcfg.id_to_poi.get(user_data.poi)
if poi is None or len(poi.vendors) == 0 or ewutils.channel_name_is_poi(
cmd.message.channel.name) == False:
# Only allowed in the food court.
response = "There’s nothing to buy here. If you want to purchase some items, go to a sub-zone with a vendor in it, like the food court, the speakeasy, or the bazaar."
else:
poi = ewcfg.id_to_poi.get(user_data.poi)
district_data = EwDistrict(district=poi.id_poi,
id_server=user_data.id_server)
shambler_multiplier = 1 #for speakeasy during shambler times
if district_data.is_degraded(
) and poi.id_poi != ewcfg.poi_id_nuclear_beach_edge:
if poi.id_poi == ewcfg.poi_id_speakeasy:
shambler_multiplier = 4
else:
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))
#value = ewutils.flattenTokenListToString(cmd.tokens[1:2])
#if cmd.tokens_count > 1:
# value = cmd.tokens[1]
# value = value.lower()
value = None
togo = False
if cmd.tokens_count > 1:
for token in cmd.tokens[1:]:
if token.startswith('<@') == False and token.lower(
) not in "togo": # togo can be spelled together or separate
value = token
break
for token in cmd.tokens[1:]:
if token.lower(
) in "togo": # lets people get away with just typing only to or only go (or only t etc.) but whatever
togo = True
break
# Finds the item if it's an EwGeneralItem.
if value == "mylittleponyfigurine":
value = random.choice(ewcfg.furniture_pony)
item = ewcfg.item_map.get(value)
item_type = ewcfg.it_item
if item != None:
item_id = item.id_item
name = item.str_name
# Finds the item if it's an EwFood item.
if item == None:
item = ewcfg.food_map.get(value)
item_type = ewcfg.it_food
if item != None:
item_id = item.id_food
name = item.str_name
# Finds the item if it's an EwCosmeticItem.
if item == None:
item = ewcfg.cosmetic_map.get(value)
item_type = ewcfg.it_cosmetic
if item != None:
item_id = item.id_cosmetic
name = item.str_name
if item == None:
item = ewcfg.furniture_map.get(value)
item_type = ewcfg.it_furniture
if item != None:
item_id = item.id_furniture
name = item.str_name
if item_id in ewcfg.furniture_pony:
item.vendors = [ewcfg.vendor_bazaar]
if item == None:
item = ewcfg.weapon_map.get(value)
item_type = ewcfg.it_weapon
if item != None:
item_id = item.id_weapon
name = item.str_weapon
if item != None:
item_type = item.item_type
# Gets a vendor that the item is available and the player currently located in
try:
current_vendor = (set(item.vendors).intersection(
set(poi.vendors))).pop()
except:
current_vendor = None
# Check if the item is available in the current bazaar item rotation
if current_vendor == ewcfg.vendor_bazaar:
if item_id not in market_data.bazaar_wares.values():
if item_id in ewcfg.furniture_pony and "mylittleponyfigurine" in market_data.bazaar_wares.values(
):
pass
else:
current_vendor = None
if current_vendor == ewcfg.vendor_downpourlaboratory:
currency_used = 'brainz'
current_currency_amount = user_data.gvs_currency
if current_vendor is None or len(current_vendor) < 1:
response = "Check the {} for a list of items you can {}.".format(
ewcfg.cmd_menu, ewcfg.cmd_order)
else:
response = ""
value = item.price
premium_purchase = True if item_id in ewcfg.premium_items else False
if premium_purchase:
togo = True # Just in case they order a premium food item, don't make them eat it right then and there.
if ewcfg.cd_premium_purchase > (int(
time.time()) - user_data.time_lastpremiumpurchase):
response = "That item is in very limited stock! The vendor asks that you refrain from purchasing it for a day or two."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
response))
elif ewcfg.cd_new_player > (int(time.time()) -
user_data.time_joined):
response = "You've only been in the city for a few days. The vendor doesn't trust you with that item very much..."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
response))
stock_data = None
company_data = None
# factor in the current stocks
for vendor in item.vendors:
if vendor in ewcfg.vendor_stock_map:
stock = ewcfg.vendor_stock_map.get(vendor)
company_data = EwCompany(id_server=user_data.id_server,
stock=stock)
stock_data = EwStock(id_server=user_data.id_server,
stock=stock)
if stock_data is not None:
value *= (stock_data.exchange_rate /
ewcfg.default_stock_exchange_rate)**0.2
controlling_faction = ewutils.get_subzone_controlling_faction(
user_data.poi, user_data.id_server)
if controlling_faction != "" and poi.id_poi != ewcfg.poi_id_nuclear_beach_edge:
# prices are halved for the controlling gang
if controlling_faction == user_data.faction:
value /= 2
# and 4 times as much for enemy gangsters
elif user_data.faction != "":
value *= 4
# raise shambled speakeasy price 4 times
value *= shambler_multiplier
# Raise the price for togo ordering. This gets lowered back down later if someone does togo ordering on a non-food item by mistake.
if togo:
value *= 1.5
if current_vendor == ewcfg.vendor_breakroom and user_data.faction == ewcfg.faction_slimecorp:
value = 0
value = int(value)
food_ordered = False
target_data = None
# Kingpins eat free.
if (user_data.life_state == ewcfg.life_state_kingpin
or user_data.life_state == ewcfg.life_state_grandfoe
) and item_type == ewcfg.it_food:
value = 0
if value > current_currency_amount:
# Not enough money.
response = "A {} costs {:,} {}, and you only have {:,}.".format(
name, value, currency_used, current_currency_amount)
else:
if item_type == ewcfg.it_food:
food_ordered = True
food_items = ewitem.inventory(
id_user=cmd.message.author.id,
id_server=cmd.guild.id,
item_type_filter=ewcfg.it_food)
target = None
target_data = None
if not togo: # cant order togo for someone else, you can just give it to them in person
if cmd.mentions_count == 1:
target = cmd.mentions[0]
if target.id == cmd.message.author.id:
target = None
if target != None:
target_data = EwUser(member=target)
if target_data.life_state == ewcfg.life_state_corpse and target_data.get_possession(
):
response = "How are you planning to feed them while they're possessing you?"
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author, response))
elif target_data.poi != user_data.poi:
response = "You can't order anything for them because they aren't here!"
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author, response))
if len(food_items) >= user_data.get_food_capacity(
) and target_data == None and togo:
# user_data never got persisted so the player won't lose money unnecessarily
response = "You can't carry any more food than that."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
response))
elif item_type == ewcfg.it_weapon:
weapons_held = ewitem.inventory(
id_user=user_data.id_user,
id_server=cmd.guild.id,
item_type_filter=ewcfg.it_weapon)
has_weapon = False
# Thrown weapons are stackable
if ewcfg.weapon_class_thrown in item.classes:
# Check the player's inventory for the weapon and add amount to stack size. Create a new item the max stack size has been reached
for wep in weapons_held:
weapon = EwItem(id_item=wep.get("id_item"))
if weapon.item_props.get(
"weapon_type"
) == item.id_weapon and weapon.stack_size < weapon.stack_max:
has_weapon = True
weapon.stack_size += 1
weapon.persist()
if value == 0:
response = "You swipe a {} from the counter at {}.".format(
item.str_weapon, current_vendor)
else:
response = "You slam {:,} slime down on the counter at {} for {}.".format(
value, current_vendor,
item.str_weapon)
user_data.change_slimes(
n=-value, source=ewcfg.source_spending)
user_data.persist()
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author, response))
if has_weapon == False:
if 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))
elif 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))
item_props = ewitem.gen_item_props(item)
customtext = cmd.message.content[(len(cmd.tokens[0]) +
len(cmd.tokens[1]) + 2):]
if item.item_type == ewcfg.it_furniture and "custom" in item_props.get(
'id_furniture'):
if customtext == "":
response = "You need to specify the customization text before buying a custom item. Come on, isn't that self-evident?"
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
response))
# Only food should have the value multiplied. If someone togo orders a non-food item by mistake, lower it back down.
if not food_ordered and togo:
value = int(value / 1.5)
if currency_used == 'slime':
user_data.change_slimes(n=-value,
source=ewcfg.source_spending)
elif currency_used == 'brainz':
user_data.gvs_currency -= value
if company_data is not None:
company_data.recent_profits += value
company_data.persist()
if item.str_name == "arcade cabinet":
item_props['furniture_desc'] = random.choice(
ewcfg.cabinets_list)
elif item.item_type == ewcfg.it_furniture:
if "custom" in item_props.get('id_furniture'):
item_props['furniture_name'] = item_props[
'furniture_name'].format(custom=customtext)
item_props['furniture_desc'] = item_props[
'furniture_desc'].format(custom=customtext)
item_props['furniture_look_desc'] = item_props[
'furniture_look_desc'].format(
custom=customtext)
item_props['furniture_place_desc'] = item_props[
'furniture_place_desc'].format(
custom=customtext)
item.str_name = item.str_name.format(
custom=customtext)
id_item = ewitem.item_create(
item_type=item_type,
id_user=cmd.message.author.id,
id_server=cmd.guild.id,
stack_max=20 if item_type == ewcfg.it_weapon
and ewcfg.weapon_class_thrown in item.classes else -1,
stack_size=1 if item_type == ewcfg.it_weapon
and ewcfg.weapon_class_thrown in item.classes else 0,
item_props=item_props)
if value == 0:
response = "You swipe a {} from the counter at {}.".format(
item.str_name, current_vendor)
else:
response = "You slam {:,} {} down on the counter at {} for {}.".format(
value, currency_used, current_vendor,
item.str_name)
if food_ordered and not togo:
item_data = EwItem(id_item=id_item)
# Eat food on the spot!
if target_data != None:
target_player_data = EwPlayer(
id_user=target_data.id_user)
if value == 0:
response = "You swipe a {} from the counter at {} and give it to {}.".format(
item.str_name, current_vendor,
target_player_data.display_name)
else:
response = "You slam {:,} slime down on the counter at {} for {} and give it to {}.".format(
value, current_vendor, item.str_name,
target_player_data.display_name)
response += "\n\n*{}*: ".format(
target_player_data.display_name
) + target_data.eat(item_data)
target_data.persist()
asyncio.ensure_future(
ewutils.decrease_food_multiplier(
user_data.id_user))
else:
if value == 0:
response = "You swipe a {} from the counter at {} and eat it right on the spot.".format(
item.str_name, current_vendor)
else:
response = "You slam {:,} slime down on the counter at {} for {} and eat it right on the spot.".format(
value, current_vendor, item.str_name)
user_player_data = EwPlayer(
id_user=user_data.id_user)
response += "\n\n*{}*: ".format(
user_player_data.display_name) + user_data.eat(
item_data)
user_data.persist()
asyncio.ensure_future(
ewutils.decrease_food_multiplier(
user_data.id_user))
if premium_purchase:
user_data.time_lastpremiumpurchase = int(time.time())
user_data.persist()
else:
response = "Check the {} for a list of items you can {}.".format(
ewcfg.cmd_menu, ewcfg.cmd_order)
# Send the response to the player.
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def barter(cmd):
user_data = EwUser(member = cmd.message.author)
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.message.server.id if cmd.message.server is not None else None)
# Checking availability of appraisal
#if market_data.clock < 8 or market_data.clock > 17:
# response = "You ask the bartender if he knows someone who would want to trade you something for your recently caught fish. Apparently, at night, an old commodore by the name of Captain Albert Alexander comes to drown his sorrows at this very tavern. You guess you’ll just have to sit here and wait for him, then."
if cmd.message.channel.name != ewcfg.channel_speakeasy:
if cmd.message.channel.name in [ewcfg.channel_tt_pier, ewcfg.channel_jp_pier, ewcfg.channel_cl_pier, ewcfg.channel_afb_pier, ewcfg.channel_vc_pier, ewcfg.channel_se_pier, ewcfg.channel_ferry]:
response = 'You ask a nearby fisherman if he wants to trade you anything for this fish you just caught. He tells you to f**k off, but also helpfully informs you that there’s an old sea captain that frequents the Speakeasy that might be able to help you. What an inexplicably helpful/grouchy fisherman!'
else:
response = 'What random passerby is going to give two shits about your fish? You’ll have to consult a fellow fisherman… perhaps you’ll find some on a pier?'
elif item_sought:
name = item_sought.get('name')
fish = EwItem(id_item = item_sought.get('id_item'))
id_fish = fish.id_item
# str_fish = fish.item_props.get('str_name')
item_props = fish.item_props
acquisition = item_props.get('acquisition')
response = "You approach a man of particularly swashbuckling appearance, adorned in an old sea captain's uniform and bicorne cap, and surrounded by empty glass steins. You ask him if he is Captain Albert Alexander and he replies that he hasn’t heard that name in a long time. You submit your {} for bartering".format(name)
if acquisition != ewcfg.acquisition_fishing:
response += '. \n"Have you lost yer mind, laddy? That’s not a fish!! Just what’re you trying to pull??"'
else:
value = int(item_props['value'])
items = []
# Filters out all non-generic items without the current fish as an ingredient.
for result in ewcfg.appraise_results:
if result.ingredients == fish.item_props.get('id_item') or result.ingredients == "generic" and result.acquisition == ewcfg.acquisition_bartering: # Generic means that it can be made with any fish.
items.append(result)
else:
pass
# Filters out items of greater value than your fish.
for value_filter in items:
if value < value_filter.context:
items.remove(value_filter)
else:
pass
else:
offer = EwOffer(
id_server = cmd.message.server.id,
id_user = cmd.message.author.id,
offer_give = id_fish
)
cur_time_min = time.time() / 60
time_offered = cur_time_min - offer.time_sinceoffer
if offer.time_sinceoffer > 0 and time_offered < ewcfg.fish_offer_timeout:
offer_receive = str(offer.offer_receive)
if offer_receive.isdigit() == True:
slime_gain = int(offer.offer_receive)
response = '\n"Well, back again I see! My offer still stands, I’ll trade ya {} slime for your {}"'.format(slime_gain, name)
else:
for result in ewcfg.appraise_results:
if hasattr(result, 'id_item'):
if result.id_item != offer.offer_receive:
pass
else:
item = result
if hasattr(result, 'id_food'):
if result.id_food != offer.offer_receive:
pass
else:
item = result
if hasattr(result, 'id_cosmetic'):
if result.id_cosmetic != offer.offer_receive:
pass
else:
item = result
response = '\n"Well, back again I see! My offer still stands, I’ll trade ya a {} for your {}"'.format(item.str_name, name)
response += "\n**!accept** or **!refuse** Captain Albert Alexander's deal."
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
else:
# Random choice between 0, 1, and 2
offer_decision = random.randint(0, 2)
if offer_decision != 2: # If Captain Albert Alexander wants to offer you slime for your fish. 66% chance.
max_value = value * 6000 # 600,000 slime for a colossal promo fish, 120,000 for a miniscule common fish.
min_value = max_value / 10 # 60,000 slime for a colossal promo fish, 12,000 for a miniscule common fish.
slime_gain = round(random.triangular(min_value, max_value, min_value * 2))
offer.offer_receive = slime_gain
response = '"Hm, alright… for this {}... I’ll offer you {} slime! Trust me, you’re not going to get a better deal anywhere else, laddy."'.format(name, slime_gain)
else: # If Captain Albert Alexander wants to offer you an item for your fish. 33% chance. Once there are more unique items, we'll make this 50%.
item = random.choice(items)
if hasattr(item, 'id_item'):
offer.offer_receive = item.id_item
if hasattr(item, 'id_food'):
offer.offer_receive = item.id_food
if hasattr(item, 'id_cosmetic'):
offer.offer_receive = item.id_cosmetic
response = '"Hm, alright… for this {}... I’ll offer you a {}! Trust me, you’re not going to get a better deal anywhere else, laddy."'.format(name, item.str_name)
offer.time_sinceoffer = int(time.time() / 60)
offer.persist()
response += "\n**!accept** or **!refuse** Captain Albert Alexander's deal."
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
# Wait for an answer
accepted = False
try:
message = await cmd.client.wait_for_message(timeout = 20, author = cmd.message.author, check = ewutils.check_accept_or_refuse)
if message != None:
if message.content.lower() == "!accept":
accepted = True
if message.content.lower() == "!refuse":
accepted = False
except:
accepted = False
offer = EwOffer(
id_server = cmd.message.server.id,
id_user = cmd.message.author.id,
offer_give = id_fish
)
user_data = EwUser(member = cmd.message.author)
fish = EwItem(id_item = id_fish)
# cancel deal if fish is no longer in user's inventory
if fish.id_owner != user_data.id_user:
accepted = False
# cancel deal if the user has left the speakeasy
if user_data.poi != ewcfg.poi_id_speakeasy:
accepted = False
# cancel deal if the offer has been deleted
if offer.time_sinceoffer == 0:
accepted = False
if accepted == True:
offer_receive = str(offer.offer_receive)
response = ""
if offer_receive.isdigit() == True:
slime_gain = int(offer_receive)
user_initial_level = user_data.slimelevel
levelup_response = user_data.change_slimes(n = slime_gain, source = ewcfg.source_fishing)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Tell the player their slime level increased.
if was_levelup:
response += levelup_response
response += "\n\n"
else:
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
)
ewitem.item_delete(id_item = item_sought.get('id_item'))
user_data.persist()
offer.deal()
response += '"Pleasure doing business with you, laddy!"'
else:
response = '"Ah, what a shame. Maybe you’ll change your mind in the future…?"'
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 = "Offer Captain Albert Alexander which fish? (check **!inventory**)"
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def reel(cmd):
user_data = EwUser(member = cmd.message.author)
if cmd.message.author.id not in fishers.keys():
fishers[cmd.message.author.id] = EwFisher()
fisher = fishers[cmd.message.author.id]
poi = ewcfg.id_to_poi.get(user_data.poi)
# Ghosts cannot fish.
if user_data.life_state == ewcfg.life_state_corpse:
response = "You can't fish while you're dead. Try {}.".format(ewcfg.cmd_revive)
elif cmd.message.channel.name in [ewcfg.channel_tt_pier, ewcfg.channel_jp_pier, ewcfg.channel_cl_pier, ewcfg.channel_afb_pier, ewcfg.channel_vc_pier, ewcfg.channel_se_pier, ewcfg.channel_ferry]:
# Players who haven't cast a line cannot reel.
if fisher.fishing == False:
response = "You haven't cast your hook yet. Try !cast."
# If a fish isn't biting, then a player reels in nothing.
elif fisher.bite == False and fisher.fishing == True:
fisher.current_fish = ""
fisher.current_size = ""
fisher.fishing = False
fisher.pier = ""
response = "You reeled in too early! Nothing was caught."
# On successful reel.
else:
if fisher.current_fish == "item":
slimesea_inventory = ewitem.inventory(id_server = cmd.message.server.id, id_user = ewcfg.poi_id_slimesea)
pier_poi = ewcfg.id_to_poi.get(fisher.pier)
if pier_poi.pier_type != ewcfg.fish_slime_saltwater or len(slimesea_inventory) == 0 or random.random() < 0.5:
item = random.choice(ewcfg.mine_results)
unearthed_item_amount = (random.randrange(5) + 8) # anywhere from 8-12 drops
item_props = ewitem.gen_item_props(item)
for creation in range(unearthed_item_amount):
ewitem.item_create(
item_type = item.item_type,
id_user = cmd.message.author.id,
id_server = cmd.message.server.id,
item_props = item_props
)
response = "You reel in {} {}s! ".format(unearthed_item_amount, item.str_name)
else:
item = random.choice(slimesea_inventory)
ewitem.give_item(id_item = item.get('id_item'), member = cmd.message.author)
response = "You reel in a {}!".format(item.get('name'))
fisher.fishing = False
fisher.bite = False
fisher.current_fish = ""
fisher.current_size = ""
fisher.pier = ""
user_data.persist()
else:
user_initial_level = user_data.slimelevel
gang_bonus = False
has_fishingrod = False
if user_data.weapon >= 0:
weapon_item = EwItem(id_item = user_data.weapon)
weapon = ewcfg.weapon_map.get(weapon_item.item_props.get("weapon_type"))
if weapon.id_weapon == "fishingrod":
has_fishingrod = True
value = 0
if fisher.current_size == ewcfg.fish_size_miniscule:
slime_gain = ewcfg.fish_gain * 1
value += 10
elif fisher.current_size == ewcfg.fish_size_small:
slime_gain = ewcfg.fish_gain * 2
value += 20
elif fisher.current_size == ewcfg.fish_size_average:
slime_gain = ewcfg.fish_gain * 3
value += 30
elif fisher.current_size == ewcfg.fish_size_big:
slime_gain = ewcfg.fish_gain * 4
value += 40
elif fisher.current_size == ewcfg.fish_size_huge:
slime_gain = ewcfg.fish_gain * 5
value += 50
else:
slime_gain = ewcfg.fish_gain * 6
value += 60
if ewcfg.fish_map[fisher.current_fish].rarity == ewcfg.fish_rarity_common:
value += 10
if ewcfg.fish_map[fisher.current_fish].rarity == ewcfg.fish_rarity_uncommon:
value += 20
if ewcfg.fish_map[fisher.current_fish].rarity == ewcfg.fish_rarity_rare:
value += 30
if ewcfg.fish_map[fisher.current_fish].rarity == ewcfg.fish_rarity_promo:
value += 40
if user_data.life_state == 2:
if ewcfg.fish_map[fisher.current_fish].catch_time == ewcfg.fish_catchtime_day and user_data.faction == ewcfg.faction_rowdys:
gang_bonus = True
slime_gain = slime_gain * 1.5
value += 20
if ewcfg.fish_map[fisher.current_fish].catch_time == ewcfg.fish_catchtime_night and user_data.faction == ewcfg.faction_killers:
gang_bonus = True
slime_gain = slime_gain * 1.5
value += 20
if has_fishingrod == True:
slime_gain = slime_gain * 2
if fisher.current_fish == "plebefish":
slime_gain = ewcfg.fish_gain * .5
value = 10
if poi.is_subzone:
district_data = EwDistrict(district = poi.mother_district, id_server = cmd.message.server.id)
else:
district_data = EwDistrict(district = poi.id_poi, id_server = cmd.message.server.id)
if district_data.controlling_faction != "" and district_data.controlling_faction == user_data.faction:
slime_gain *= 2
ewitem.item_create(
id_user = cmd.message.author.id,
id_server = cmd.message.server.id,
item_type = ewcfg.it_food,
item_props = {
'id_food': ewcfg.fish_map[fisher.current_fish].id_fish,
'food_name': ewcfg.fish_map[fisher.current_fish].str_name,
'food_desc': ewcfg.fish_map[fisher.current_fish].str_desc,
'recover_hunger': 20,
'str_eat': ewcfg.str_eat_raw_material.format(ewcfg.fish_map[fisher.current_fish].str_name),
'rarity': ewcfg.fish_map[fisher.current_fish].rarity,
'size': fisher.current_size,
'time_expir': time.time() + ewcfg.std_food_expir,
'time_fridged': 0,
'acquisition': ewcfg.acquisition_fishing,
'value': value
}
)
response = "You reel in a {fish}! {flavor} You grab hold and wring {slime} slime from it. "\
.format(fish = ewcfg.fish_map[fisher.current_fish].str_name, flavor = ewcfg.fish_map[fisher.current_fish].str_desc, slime = str(slime_gain))
if gang_bonus == True:
if user_data.faction == ewcfg.faction_rowdys:
response += "The Rowdy-pride this fish is showing gave you more slime than usual. "
elif user_data.faction == ewcfg.faction_killers:
response += "The Killer-pride this fish is showing gave you more slime than usual. "
levelup_response = user_data.change_slimes(n = slime_gain, source = ewcfg.source_fishing)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Tell the player their slime level increased.
if was_levelup:
response += levelup_response
market_data = EwMarket(id_server=user_data.id_server)
if market_data.caught_fish == ewcfg.debugfish_goal and fisher.pier in ewcfg.debugpiers:
item = ewcfg.debugitem
ewitem.item_create(
item_type=ewcfg.it_item,
id_user=user_data.id_user,
id_server=user_data.id_server,
item_props={
'id_item': item.id_item,
'context': item.context,
'item_name': item.str_name,
'item_desc': item.str_desc,
}
),
ewutils.logMsg('Created item: {}'.format(item.id_item))
item = EwItem(id_item=item.id_item)
item.persist()
response += ewcfg.debugfish_response
market_data.caught_fish += 1
market_data.persist()
elif market_data.caught_fish < ewcfg.debugfish_goal and fisher.pier in ewcfg.debugpiers:
market_data.caught_fish += 1
market_data.persist()
fisher.fishing = False
fisher.bite = False
fisher.current_fish = ""
fisher.current_size = ""
fisher.pier = ""
user_data.persist()
else:
response = "You cast your fishing rod unto a sidewalk. That is to say, you've accomplished nothing. Go to a pier if you want to fish."
await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def mine(cmd):
market_data = EwMarket(id_server=cmd.message.author.server.id)
user_data = EwUser(member=cmd.message.author)
mutations = user_data.get_mutations()
time_now = int(time.time())
response = ""
# Kingpins can't mine.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
return
# ghosts cant mine (anymore)
if user_data.life_state == ewcfg.life_state_corpse:
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You can't mine while you're dead. Try {}.".format(
ewcfg.cmd_revive)))
# Enlisted players only mine at certain times.
if user_data.life_state == ewcfg.life_state_enlisted:
if user_data.faction == ewcfg.faction_rowdys and (
market_data.clock < 8 or market_data.clock > 17):
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Rowdies only mine in the daytime. Wait for full daylight at 8am."
.format(ewcfg.cmd_revive)))
if user_data.faction == ewcfg.faction_killers and (
market_data.clock < 20 and market_data.clock > 5):
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Killers only mine under cover of darkness. Wait for nightfall at 8pm."
.format(ewcfg.cmd_revive)))
# Mine only in the mines.
if cmd.message.channel.name in [
ewcfg.channel_mines, ewcfg.channel_cv_mines, ewcfg.channel_tt_mines
]:
if user_data.hunger >= user_data.get_hunger_max():
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You've exhausted yourself from mining. You'll need some refreshment before getting back to work."
))
else:
printgrid = False
hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel)
extra = hunger_cost_mod - int(
hunger_cost_mod
) # extra is the fractional part of hunger_cost_mod
if user_data.poi not in mines_map:
response = "You can't mine here! Go to the mines in Juvie's Row, Toxington, or Cratersville!"
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
elif user_data.id_server not in mines_map.get(user_data.poi):
init_grid(user_data.poi, user_data.id_server)
printgrid = True
grid_cont = mines_map.get(user_data.poi).get(user_data.id_server)
grid = grid_cont.grid
#minesweeper = False
if cmd.tokens_count < 2:
response = "Please specify which vein to mine."
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
return await print_grid(cmd)
else:
#minesweeper = True
#grid_multiplier = grid_cont.cells_mined ** 0.4
#flag = False
row = -1
col = -1
for token in cmd.tokens[1:]:
if token.lower() == "reset":
user_data.hunger += ewcfg.hunger_perminereset * int(
hunger_cost_mod)
if random.random() < extra:
user_data.hunger += ewcfg.hunger_perminereset
user_data.persist()
init_grid(user_data.poi, user_data.id_server)
return await print_grid(cmd)
if row < 1 or col < 1:
coords = token.lower()
for char in coords:
if char in ewcfg.alphabet:
col = ewcfg.alphabet.index(char)
coords = coords.replace(char, "")
try:
row = int(coords)
except:
row = -1
row -= 1
if row not in range(len(grid)) or col not in range(
len(grid[row])):
response = "Invalid vein."
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
return await print_grid(cmd)
mining_yield = 0
mining_accident = False
slimes_pertile = ewcfg.slimes_pertile
for current_row in range(max(0, row - 1),
min(row + 2, len(grid))):
for current_col in range(
max(0, col - 1),
min(col + 2, len(grid[current_row]))):
symbol_prev = get_cell_symbol(
grid[current_row][current_col])
slimes_fromtile = slimes_pertile
if current_row == row and current_col == col:
slimes_fromtile *= 2
mining_yield += max(
0,
min(slimes_fromtile,
grid[current_row][current_col]))
grid[current_row][current_col] -= slimes_fromtile
if grid[current_row][
current_col] < -60 * ewcfg.slimes_pertile:
mining_accident = True
if get_cell_symbol(
grid[current_row][current_col]) != symbol_prev:
printgrid = True
if mining_accident:
user_data.change_slimes(n=-(user_data.slimes * 0.5))
user_data.persist()
init_grid(user_data.poi, user_data.id_server)
response = "You have lost an arm and a leg in a mining accident. Tis but a scratch."
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
return await print_grid(cmd)
if mining_yield == 0:
user_data.hunger += ewcfg.hunger_permine * int(
hunger_cost_mod)
user_data.persist()
response = "This vein has already been mined dry."
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
if printgrid:
return await print_grid(cmd)
else:
return
has_pickaxe = False
if user_data.weapon >= 0:
weapon_item = EwItem(id_item=user_data.weapon)
weapon = ewcfg.weapon_map.get(
weapon_item.item_props.get("weapon_type"))
if weapon.id_weapon == ewcfg.weapon_id_pickaxe:
has_pickaxe = True
# Determine if an item is found.
unearthed_item = False
unearthed_item_amount = 0
# juvies get items 4 times as often as enlisted players
unearthed_item_chance = 1 / ewcfg.unearthed_item_rarity
if user_data.life_state == ewcfg.life_state_juvenile:
unearthed_item_chance *= 2
if has_pickaxe == True:
unearthed_item_chance *= 1.5
if ewcfg.mutation_id_lucky in mutations:
unearthed_item_chance *= 1.33
if random.random() < unearthed_item_chance:
unearthed_item = True
unearthed_item_amount = 1 if random.randint(
1, 3) != 1 else 2 # 33% chance of extra drop
if unearthed_item == True:
# If there are multiple possible products, randomly select one.
item = random.choice(ewcfg.mine_results)
item_props = ewitem.gen_item_props(item)
for creation in range(unearthed_item_amount):
ewitem.item_create(item_type=item.item_type,
id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
item_props=item_props)
if unearthed_item_amount == 1:
response = "You unearthed a {}! ".format(item.str_name)
elif unearthed_item_amount == 2:
response = "You unearthed two (2) {}! ".format(
item.str_name)
ewstats.change_stat(user=user_data,
metric=ewcfg.stat_lifetime_poudrins,
n=unearthed_item_amount)
ewutils.logMsg('{} has found {} {}(s)!'.format(
cmd.message.author.display_name, item.str_name,
unearthed_item_amount))
user_initial_level = user_data.slimelevel
# Add mined slime to the user.
slime_bylevel = ewutils.slime_bylevel(user_data.slimelevel)
#mining_yield = math.floor((slime_bylevel / 10) + 1)
#alternate_yield = math.floor(200 + slime_bylevel ** (1 / math.e))
#mining_yield = min(mining_yield, alternate_yield)
if has_pickaxe == True:
mining_yield *= 2
# Fatigue the miner.
user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod)
if extra > 0: # if hunger_cost_mod is not an integer
# there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100)
if random.randint(1, 100) <= extra * 100:
user_data.hunger += ewcfg.hunger_permine
levelup_response = user_data.change_slimes(
n=mining_yield, source=ewcfg.source_mining)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Tell the player their slime level increased and/or they unearthed an item.
if was_levelup:
response += levelup_response
user_data.persist()
if printgrid:
await print_grid(cmd)
else:
response = "You can't mine here! Go to the mines in Juvie's Row, Toxington, or Cratersville!"
if len(response) > 0:
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
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)
time_until_revive = (player_data.time_lastdeath +
player_data.degradation) - time_now
if time_until_revive > 0:
response = "ENDLESS WAR is not ready to {} you yet ({}s).".format(
cmd.tokens[0], time_until_revive)
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
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
# reset slimelevel to zero
player_data.slimelevel = 0
# Set time of last revive. This used to provied spawn protection, but currently isn't used.
player_data.time_lastrevive = time_now
if player_data.degradation >= 100:
player_data.life_state = ewcfg.life_state_shambler
player_data.change_slimes(n=0.5 * ewcfg.slimes_shambler)
player_data.trauma = ""
poi_death = ewcfg.id_to_poi.get(player_data.poi_death)
if ewmap.inaccessible(poi=poi_death, user_data=player_data):
player_data.poi = ewcfg.poi_id_downtown
else:
player_data.poi = poi_death.id_poi
else:
# Set life state. This is what determines whether the player is actually alive.
player_data.life_state = ewcfg.life_state_juvenile
# Give player some initial slimes.
player_data.change_slimes(n=ewcfg.slimes_onrevive)
# Get the player out of the sewers.
player_data.poi = ewcfg.poi_id_downtown
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 event_tick(id_server):
time_now = int(time.time())
resp_cont = ewutils.EwResponseContainer(id_server=id_server)
try:
data = ewutils.execute_sql_query(
"SELECT {id_event} FROM world_events WHERE {time_expir} <= %s AND {time_expir} > 0 AND id_server = %s"
.format(
id_event=ewcfg.col_id_event,
time_expir=ewcfg.col_time_expir,
), (
time_now,
id_server,
))
for row in data:
try:
event_data = EwWorldEvent(id_event=row[0])
event_def = ewcfg.event_type_to_def.get(event_data.event_type)
response = event_def.str_event_end if event_def else ""
if event_data.event_type == ewcfg.event_type_minecollapse:
user_data = EwUser(
id_user=event_data.event_props.get('id_user'),
id_server=id_server)
mutations = user_data.get_mutations()
if user_data.poi == event_data.event_props.get('poi'):
player_data = EwPlayer(id_user=user_data.id_user)
response = "*{}*: You have lost an arm and a leg in a mining accident. Tis but a scratch.".format(
player_data.display_name)
if random.randrange(4) == 0:
response = "*{}*: Big John arrives just in time to save you from your mining accident!\nhttps://cdn.discordapp.com/attachments/431275470902788107/743629505876197416/mine2.jpg".format(
player_data.display_name)
else:
if ewcfg.mutation_id_lightminer in mutations:
response = "*{}*: You instinctively jump out of the way of the collapsing shaft, not a scratch on you. Whew, really gets your blood pumping.".format(
player_data.display_name)
else:
user_data.change_slimes(
n=-(user_data.slimes * 0.5))
user_data.persist()
# check if any void connections have expired, if so pop it and create a new one
elif event_data.event_type == ewcfg.event_type_voidconnection:
void_poi = ewcfg.id_to_poi.get(ewcfg.poi_id_thevoid)
void_poi.neighbors.pop(event_data.event_props.get('poi'),
"")
create_void_connection(id_server)
if len(response) > 0:
poi = event_data.event_props.get('poi')
channel = event_data.event_props.get('channel')
if channel != None:
# in shambaquarium the event happens in the user's DMs
if event_data.event_type == ewcfg.event_type_shambaquarium:
client = ewutils.get_client()
channel = client.get_guild(id_server).get_member(
int(channel))
resp_cont.add_channel_response(channel, response)
elif poi != None:
poi_def = ewcfg.id_to_poi.get(poi)
if poi_def != None:
resp_cont.add_channel_response(
poi_def.channel, response)
else:
for ch in ewcfg.hideout_channels:
resp_cont.add_channel_response(ch, response)
delete_world_event(event_data.id_event)
except:
ewutils.logMsg(
"Error in event tick for server {}".format(id_server))
await resp_cont.post()
except:
ewutils.logMsg("Error in event tick for server {}".format(id_server))
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)
target_isshambler = haunted_data.life_state == ewcfg.life_state_shambler
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 time_now > haunted_data.time_expirpvp and not target_isshambler:
# 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 or haunted_data.life_state == ewcfg.life_state_shambler:
# 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
user_data.time_expirpvp = ewutils.calculatePvpTimer(
user_data.time_expirpvp,
(int(time.time()) + ewcfg.time_pvp_attack))
resp_cont.add_member_to_update(cmd.message.author)
# 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 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 scavenge(cmd):
market_data = EwMarket(id_server=cmd.message.author.server.id)
user_data = EwUser(member=cmd.message.author)
mutations = user_data.get_mutations()
time_now = int(time.time())
response = ""
time_since_last_scavenge = time_now - user_data.time_lastscavenge
# Kingpins can't scavenge.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
return
# ghosts cant scavenge
if user_data.life_state == ewcfg.life_state_corpse:
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"What would you want to do that for? You're a ghost, you have no need for such lowly materialistic possessions like slime. You only engage in intellectual pursuits now. {} if you want to give into your base human desire to see numbers go up."
.format(ewcfg.cmd_revive)))
# currently not active - no cooldown
if time_since_last_scavenge < ewcfg.cd_scavenge:
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
"Slow down, you filthy hyena."))
# Scavenge only in location channels
if ewmap.channel_name_is_poi(cmd.message.channel.name) == True:
if user_data.hunger >= user_data.get_hunger_max():
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You are too exhausted to scrounge up scraps of slime off the street! Go get some grub!"
))
else:
district_data = EwDistrict(district=user_data.poi,
id_server=cmd.message.author.server.id)
user_initial_level = user_data.slimelevel
# add scavenged slime to user
if ewcfg.mutation_id_trashmouth in mutations:
time_since_last_scavenge *= 3
time_since_last_scavenge = min(max(1, time_since_last_scavenge),
30)
scavenge_mod = 0.003 * (time_since_last_scavenge**0.9)
if ewcfg.mutation_id_whitenationalist in mutations and market_data.weather == "snow":
scavenge_mod *= 1.5
if ewcfg.mutation_id_webbedfeet in mutations:
district_slimelevel = len(str(district_data.slimes))
scavenge_mod *= max(1, min(district_slimelevel - 3, 4))
scavenge_yield = math.floor(scavenge_mod * district_data.slimes)
levelup_response = user_data.change_slimes(
n=scavenge_yield, source=ewcfg.source_scavenging)
district_data.change_slimes(n=-1 * scavenge_yield,
source=ewcfg.source_scavenging)
district_data.persist()
if levelup_response != "":
response += levelup_response + "\n\n"
#response += "You scrape together {} slime from the streets.\n\n".format(scavenge_yield)
if cmd.tokens_count > 1:
item_search = ewutils.flattenTokenListToString(cmd.tokens[1:])
loot_resp = ewitem.item_lootspecific(
id_server=user_data.id_server,
id_user=user_data.id_user,
item_search=item_search)
response += loot_resp
else:
loot_multiplier = 1.0 + ewitem.get_inventory_size(
owner=user_data.poi, id_server=user_data.id_server)
loot_chance = loot_multiplier / ewcfg.scavenge_item_rarity
if ewcfg.mutation_id_dumpsterdiver in mutations:
loot_chance *= 10
if random.random() < loot_chance:
loot_resp = ewitem.item_lootrandom(
id_server=user_data.id_server,
id_user=user_data.id_user)
response += loot_resp
# Fatigue the scavenger.
hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel)
extra = hunger_cost_mod - int(
hunger_cost_mod
) # extra is the fractional part of hunger_cost_mod
user_data.hunger += ewcfg.hunger_perscavenge * int(hunger_cost_mod)
if extra > 0: # if hunger_cost_mod is not an integer
# there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100)
if random.randint(1, 100) <= extra * 100:
user_data.hunger += ewcfg.hunger_perscavenge
user_data.time_lastscavenge = time_now
user_data.persist()
if not response == "":
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You'll find no slime here, this place has been picked clean. Head into the city to try and scavenge some slime."
))
async def explode(damage = 0, district_data = None):
id_server = district_data.id_server
poi = district_data.name
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()
if True:
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, damage)
resp_cont.add_channel_response(channel, response)
slimes_damage = damage
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 = await explode(explode_damage, district_data)
resp_cont.add_response_container(sub_explosion)
await ewrolemgr.updateRoles(client = client, member = 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)
if True:
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 = damage
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)
response += "\n\n" + 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 mine(cmd):
market_data = EwMarket(id_server=cmd.message.author.server.id)
user_data = EwUser(member=cmd.message.author)
# Kingpins can't mine.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
return
# ghosts cant mine (anymore)
if user_data.life_state == ewcfg.life_state_corpse:
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You can't mine while you're dead. Try {}.".format(
ewcfg.cmd_revive)))
# Enlisted players only mine at certain times.
if user_data.life_state == ewcfg.life_state_enlisted:
if user_data.faction == ewcfg.faction_rowdys and (
market_data.clock < 8 or market_data.clock > 17):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Rowdies only mine in the daytime. Wait for full daylight at 8am."
.format(ewcfg.cmd_revive)))
if user_data.faction == ewcfg.faction_killers and (
market_data.clock < 20 and market_data.clock > 5):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Killers only mine under cover of darkness. Wait for nightfall at 8pm."
.format(ewcfg.cmd_revive)))
# Mine only in the mines.
if cmd.message.channel.name in [
ewcfg.channel_mines, ewcfg.channel_cv_mines, ewcfg.channel_tt_mines
]:
if user_data.hunger >= ewutils.hunger_max_bylevel(
user_data.slimelevel):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You've exhausted yourself from mining. You'll need some refreshment before getting back to work."
))
else:
# Determine if a poudrin is found.
poudrin = False
poudrinamount = 0
# juvies get poudrins 4 times as often as enlisted players
poudrin_rarity = ewcfg.poudrin_rarity / (
2 if user_data.life_state == ewcfg.life_state_juvenile else 1)
poudrin_mined = random.randint(1, poudrin_rarity)
if poudrin_mined == 1:
poudrin = True
poudrinamount = 1 if random.randint(
1, 3) != 1 else 2 # 33% chance of extra drop
user_initial_level = user_data.slimelevel
# Add mined slime to the user.
slime_bylevel = ewutils.slime_bylevel(user_data.slimelevel)
mining_yield = math.floor((slime_bylevel / 10) + 1)
alternate_yield = math.floor(200 + slime_bylevel**(1 / math.e))
mining_yield = min(mining_yield, alternate_yield)
user_data.change_slimes(n=mining_yield, source=ewcfg.source_mining)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Create and give slime poudrins
for pdx in range(poudrinamount):
item_id = ewitem.item_create(
item_type=ewcfg.it_slimepoudrin,
id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
)
ewutils.logMsg(
'Created poudrin (item {}) for user (id {})'.format(
item_id, cmd.message.author.id))
# Fatigue the miner.
hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel)
extra = hunger_cost_mod - int(
hunger_cost_mod
) # extra is the fractional part of hunger_cost_mod
user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod)
if extra > 0: # if hunger_cost_mod is not an integer
# there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100)
if random.randint(1, 100) <= extra * 100:
user_data.hunger += ewcfg.hunger_permine
user_data.persist()
# Tell the player their slime level increased and/or a poudrin was found.
if was_levelup or poudrin:
response = ""
if poudrin:
if poudrinamount == 1:
response += "You unearthed a slime poudrin! "
elif poudrinamount == 2:
response += "You unearthed two slime poudrins! "
ewstats.change_stat(user=user_data,
metric=ewcfg.stat_lifetime_poudrins,
n=poudrinamount)
ewutils.logMsg('{} has found {} poudrin(s)!'.format(
cmd.message.author.display_name, poudrinamount))
if was_levelup:
response += "You have been empowered by slime and are now a level {} slimeboi!".format(
user_data.slimelevel)
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
"You can't mine here. Go to the mines."))
async def russian_roulette(cmd):
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_casino:
#Only at the casino
response = "You can only play russian roulette at the casino."
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
if cmd.mentions_count != 1:
#Must mention only one player
response = "Mention the player you want to challenge."
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
author = cmd.message.author
member = cmd.mentions[0]
global last_russianrouletted_times
last_used_author = last_russianrouletted_times.get(author.id)
last_used_member = last_russianrouletted_times.get(member.id)
if last_used_author == None:
last_used_author = 0
if last_used_member == None:
last_used_member = 0
if last_used_author + ewcfg.cd_rr > time_now or last_used_member + ewcfg.cd_rr > time_now:
response = "**ENOUGH**"
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
if author.id == member.id:
response = "You might be looking for !suicide."
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
challenger = EwUser(member = author)
challengee = EwUser(member = member)
#Players have been challenged
if challenger.rr_challenger != "":
response = "You are already in the middle of a challenge."
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
if challengee.rr_challenger != "":
response = "{} is already in the middle of a challenge.".format(member.display_name).replace("@", "\{at\}")
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
if challenger.poi != challengee.poi:
#Challangee must be in the casino
response = "Both players must be in the casino."
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
#Players have to be enlisted
if challenger.life_state != ewcfg.life_state_enlisted or challengee.life_state != ewcfg.life_state_enlisted:
if challenger.life_state == ewcfg.life_state_corpse:
response = "You try to grab the gun, but it falls through your hands. Ghosts can't hold weapons.".format(author.display_name).replace("@", "\{at\}")
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
elif challengee.life_state == ewcfg.life_state_corpse:
response = "{} tries to grab the gun, but it falls through their hands. Ghosts can't hold weapons.".format(member.display_name).replace("@", "\{at\}")
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
else:
response = "Juveniles are too cowardly to gamble their lives."
return await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
#Assign a challenger so players can't be challenged
challenger.rr_challenger = challenger.id_user
challengee.rr_challenger = challenger.id_user
challenger.persist()
challengee.persist()
response = "You have been challenged by {} to a game of russian roulette. Do you !accept or !refuse?".format(author.display_name).replace("@", "\{at\}")
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(member, response))
#Wait for an answer
accepted = 0
msg = await cmd.client.wait_for_message(timeout = 10, author = member, check = check)
if msg != None:
if msg.content == "!accept":
accepted = 1
#Start game
if accepted == 1:
for spin in range(1, 7):
challenger = EwUser(member = author)
challengee = EwUser(member = member)
#In case any of the players suicide mid-game
if challenger.life_state == ewcfg.life_state_corpse:
response = "{} couldn't handle the pressure and killed themselves.".format(author.display_name).replace("@", "\{at\}")
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(member, response))
break
if challengee.life_state == ewcfg.life_state_corpse:
response = "{} couldn't handle the pressure and killed themselves.".format(member.display_name).replace("@", "\{at\}")
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
break
#Challenger goes second
if spin % 2 == 0:
player = author
else:
player = member
response = "You put the gun to your head and pull the trigger..."
res = await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(player, response))
await asyncio.sleep(1)
#Player dies
if random.randint(1, (7 - spin)) == 1:
await cmd.client.edit_message(res, ewutils.formatMessage(player, (response + " **BANG**")))
response = "You return to the Casino with {}'s slime.".format(player.display_name).replace("@", "\{at\}")
was_suicide = False
#Challenger dies
if spin % 2 == 0:
winner = member
challenger = EwUser(member = author)
challengee = EwUser(member = member)
if challengee.life_state != ewcfg.life_state_corpse:
challengee.change_slimes(n = challenger.slimes, source = ewcfg.source_killing)
ewitem.item_loot(member = author, id_user_target = member.id)
challenger.id_killer = challenger.id_user
challenger.die(cause = ewcfg.cause_suicide)
#In case the other player killed themselves
else:
was_suicide = True
winner = author
response = "You shoot {}'s corpse, adding insult to injury.".format(member.display_name).replace("@", "\{at\}")
#Challangee dies
else:
winner = author
challenger = EwUser(member = author)
challengee = EwUser(member = member)
if challenger.life_state != ewcfg.life_state_corpse:
challenger.change_slimes(n = challengee.slimes, source = ewcfg.source_killing)
ewitem.item_loot(member = member, id_user_target = author.id)
challengee.id_killer = challengee.id_user
challengee.die(cause = ewcfg.cause_suicide)
#In case the other player killed themselves
else:
was_suicide = True
winner = member
response = "You shoot {}'s corpse, adding insult to injury.".format(author.display_name).replace("@", "\{at\}")
challenger.rr_challenger = ""
challengee.rr_challenger = ""
challenger.persist()
challengee.persist()
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(winner, response))
await ewrolemgr.updateRoles(client = cmd.client, member = author)
await ewrolemgr.updateRoles(client = cmd.client, member = member)
if was_suicide == False:
deathreport = "You arrive among the dead by your own volition. {}".format(ewcfg.emote_slimeskull)
deathreport = "{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage(player, deathreport)
sewerchannel = ewutils.get_channel(cmd.message.server, ewcfg.channel_sewers)
await cmd.client.send_message(sewerchannel, deathreport)
break
#Or survives
else:
await cmd.client.edit_message(res, ewutils.formatMessage(player, (response + " but it's empty")))
await asyncio.sleep(1)
#track spins?
#Or cancel the challenge
else:
response = "{} was too cowardly to accept your challenge.".format(member.display_name).replace("@", "\{at\}")
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(author, response))
last_russianrouletted_times[author.id] = time_now - 540
last_russianrouletted_times[member.id] = time_now - 540
challenger = EwUser(member = author)
challengee = EwUser(member = member)
challenger.rr_challenger = ""
challengee.rr_challenger = ""
challenger.persist()
challengee.persist()
return
async def mill(cmd):
user_data = EwUser(member=cmd.message.author)
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.message.server.id
if cmd.message.server is not None else None)
# 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 user_data.poi not in [
ewcfg.poi_id_jr_farms, ewcfg.poi_id_og_farms, ewcfg.poi_id_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:
items = []
vegetable = EwItem(id_item=item_sought.get('id_item'))
for result in ewcfg.mill_results:
if result.ingredients != vegetable.item_props.get('id_food'):
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.message.server.id,
item_props=item_props)
response = "You walk up to the official SlimeCorp Milling Station and shove your irradiated produce into the hand-crank. You painfully grip the needle-covered crank handle, dripping {} slime into a small compartment on the device’s side which supposedly fuels it. 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(
ewcfg.slimes_permill, 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))
