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 on_member_remove(member):
# Kill players who leave the server.
try:
user_data = EwUser(member = member)
user_data.die(cause = ewcfg.cause_leftserver)
user_data.persist()
ewutils.logMsg('Player killed for leaving the server.')
except:
ewutils.logMsg('Failed to kill member who left the 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 on_member_remove(member):
# Kill players who leave the server.
try:
user_data = EwUser(member = member)
# don't kill players who haven't cleared the tutorial yet
if user_data.poi in ewcfg.tutorial_pois:
return
user_data.die(cause = ewcfg.cause_leftserver)
user_data.persist()
ewutils.logMsg('Player killed for leaving the server.')
except:
ewutils.logMsg('Failed to kill member who left the server.')
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 suicide(cmd):
response = ""
deathreport = ""
# Only allowed in the combat zone.
if ewmap.channel_name_is_poi(cmd.message.channel.name) == False:
response = "You must go into the city to commit suicide."
else:
# Get the user data.
user_data = EwUser(member=cmd.message.author)
user_iskillers = user_data.life_state == ewcfg.life_state_enlisted and user_data.faction == ewcfg.faction_killers
user_isrowdys = user_data.life_state == ewcfg.life_state_enlisted and user_data.faction == ewcfg.faction_rowdys
user_isgeneral = user_data.life_state == ewcfg.life_state_kingpin
user_isjuvenile = user_data.life_state == ewcfg.life_state_juvenile
user_isdead = user_data.life_state == ewcfg.life_state_corpse
if user_isdead:
response = "Too late for that."
elif user_isjuvenile:
response = "Juveniles are too cowardly for suicide."
elif user_isgeneral:
response = "\*click* Alas, your gun has jammed."
elif user_iskillers or user_isrowdys:
#Give slime to challenger if player suicides mid russian roulette
if user_data.rr_challenger != "":
challenger = EwUser(id_user=user_data.rr_challenger,
id_server=user_data.id_server)
challenger.change_slimes(n=user_data.slimes,
source=ewcfg.source_killing)
ewitem.item_loot(member=cmd.message.author,
id_user_target=user_data.rr_challenger)
challenger.persist()
# Set the id_killer to the player himself, remove his slime and slime poudrins.
user_data.id_killer = cmd.message.author.id
user_data.die(cause=ewcfg.cause_suicide)
user_data.persist()
# Assign the corpse role to the player. He dead.
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
response = '{} has willingly returned to the slime. {}'.format(
cmd.message.author.display_name, ewcfg.emote_slimeskull)
deathreport = "You arrive among the dead by your own volition. {}".format(
ewcfg.emote_slimeskull)
deathreport = "{} ".format(
ewcfg.emote_slimeskull) + ewutils.formatMessage(
cmd.message.author, deathreport)
else:
# This should never happen. We handled all the role cases. Just in case.
response = "\*click* Alas, your gun has jammed."
# Send the response to the player.
await cmd.client.send_message(
cmd.message.channel, ewutils.formatMessage(cmd.message.author,
response))
if deathreport != "":
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await cmd.client.send_message(sewerchannel, deathreport)
async def attack(cmd):
time_now = int(time.time())
response = ""
deathreport = ""
coinbounty = 0
user_data = EwUser(member=cmd.message.author)
slimeoid = EwSlimeoid(member=cmd.message.author)
weapon = ewcfg.weapon_map.get(user_data.weapon)
if ewmap.channel_name_is_poi(cmd.message.channel.name) == False:
response = "You can't commit violence from here."
elif ewmap.poi_is_pvp(user_data.poi) == False:
response = "You must go elsewhere to commit gang violence."
elif cmd.mentions_count > 1:
response = "One shot at a time!"
elif cmd.mentions_count <= 0:
response = "Your bloodlust is appreciated, but ENDLESS WAR didn't understand that name."
elif user_data.hunger >= ewutils.hunger_max_bylevel(user_data.slimelevel):
response = "You are too exhausted for gang violence right now. Go get some grub!"
elif cmd.mentions_count == 1:
# Get shooting player's info
if user_data.slimelevel <= 0:
user_data.slimelevel = 1
user_data.persist()
# Get target's info.
member = cmd.mentions[0]
shootee_data = EwUser(member=member)
shootee_slimeoid = EwSlimeoid(member=member)
miss = False
crit = False
strikes = 0
slimes_spent = int(ewutils.slime_bylevel(user_data.slimelevel) / 20)
slimes_damage = int(
(slimes_spent * 4) * (100 + (user_data.weaponskill * 10)) / 100.0)
if weapon is None:
slimes_damage /= 2 # penalty for not using a weapon, otherwise fists would be on par with other weapons
slimes_dropped = shootee_data.totaldamage + shootee_data.slimes
#fumble_chance = (random.randrange(10) - 4)
#if fumble_chance > user_data.weaponskill:
#miss = True
user_iskillers = user_data.life_state == ewcfg.life_state_enlisted and user_data.faction == ewcfg.faction_killers
user_isrowdys = user_data.life_state == ewcfg.life_state_enlisted and user_data.faction == ewcfg.faction_rowdys
if shootee_data.life_state == ewcfg.life_state_kingpin:
# Disallow killing generals.
response = "He is hiding in his ivory tower and playing video games like a retard."
elif (slimes_spent > user_data.slimes):
# Not enough slime to shoot.
response = "You don't have enough slime to attack. ({:,}/{:,})".format(
user_data.slimes, slimes_spent)
elif (time_now - user_data.time_lastkill) < ewcfg.cd_kill:
# disallow kill if the player has killed recently
response = "Take a moment to appreciate your last slaughter."
elif shootee_data.poi != user_data.poi:
response = "You can't reach them from where you are."
elif ewmap.poi_is_pvp(shootee_data.poi) == False:
response = "{} is not mired in the ENDLESS WAR right now.".format(
member.display_name)
elif user_iskillers == False and user_isrowdys == False:
# Only killers, rowdys, the cop killer, and rowdy f****r can shoot people.
if user_data.life_state == ewcfg.life_state_juvenile:
response = "Juveniles lack the moral fiber necessary for violence."
else:
response = "You lack the moral fiber necessary for violence."
elif (time_now - shootee_data.time_lastrevive) < ewcfg.invuln_onrevive:
# User is currently invulnerable.
response = "{} has died too recently and is immune.".format(
member.display_name)
elif shootee_data.life_state == ewcfg.life_state_corpse and user_data.ghostbust == True:
# Attack a ghostly target
was_busted = False
#hunger drain
user_data.hunger += ewcfg.hunger_pershot * ewutils.hunger_cost_mod(
user_data.slimelevel)
# Weaponized flavor text.
randombodypart = ewcfg.hitzone_list[random.randrange(
len(ewcfg.hitzone_list))]
# Weapon-specific adjustments
if weapon != None and weapon.fn_effect != None:
# Build effect container
ctn = EwEffectContainer(miss=miss,
crit=crit,
slimes_damage=slimes_damage,
slimes_spent=slimes_spent,
user_data=user_data,
shootee_data=shootee_data)
# Make adjustments
weapon.fn_effect(ctn)
# Apply effects for non-reference values
miss = ctn.miss
crit = ctn.crit
slimes_damage = ctn.slimes_damage
slimes_spent = ctn.slimes_spent
strikes = ctn.strikes
# user_data and shootee_data should be passed by reference, so there's no need to assign them back from the effect container.
if miss:
slimes_damage = 0
# Remove !revive invulnerability.
user_data.time_lastrevive = 0
# Spend slimes, to a minimum of zero
user_data.change_slimes(
n=(-user_data.slimes
if slimes_spent >= user_data.slimes else -slimes_spent),
source=ewcfg.source_spending)
# Damage stats
ewstats.track_maximum(user=user_data,
metric=ewcfg.stat_max_hitdealt,
value=slimes_damage)
ewstats.change_stat(user=user_data,
metric=ewcfg.stat_lifetime_damagedealt,
n=slimes_damage)
# Remove repeat killing protection if.
if user_data.id_killer == shootee_data.id_user:
user_data.id_killer = ""
if slimes_damage >= -shootee_data.slimes:
was_busted = True
if was_busted:
# Move around slime as a result of the shot.
user_data.change_slimes(n=ewutils.slime_bylevel(
shootee_data.slimelevel),
source=ewcfg.source_busting)
coinbounty = int(shootee_data.bounty /
ewcfg.slimecoin_exchangerate)
user_data.change_slimecredit(
n=coinbounty, coinsource=ewcfg.coinsource_bounty)
ewstats.track_maximum(user=user_data,
metric=ewcfg.stat_biggest_bust_level,
value=shootee_data.slimelevel)
# Player was busted.
shootee_data.die(cause=ewcfg.cause_busted)
response = "{name_target}\'s ghost has been **BUSTED**!!".format(
name_target=member.display_name)
deathreport = "Your ghost has been busted by {}. {}".format(
cmd.message.author.display_name, ewcfg.emote_bustin)
deathreport = "{} ".format(
ewcfg.emote_bustin) + ewutils.formatMessage(
member, deathreport)
if coinbounty > 0:
response += "\n\n SlimeCorp transfers {} SlimeCoin to {}\'s account.".format(
str(coinbounty), cmd.message.author.display_name)
#adjust busts
ewstats.increment_stat(user=user_data,
metric=ewcfg.stat_ghostbusts)
else:
# A non-lethal blow!
shootee_data.change_slimes(n=slimes_damage,
source=ewcfg.source_busting)
damage = str(slimes_damage)
if weapon != None:
if miss:
response = "{}".format(
weapon.str_miss.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name + "\'s ghost"))
else:
response = weapon.str_damage.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name + "\'s ghost",
hitzone=randombodypart,
strikes=strikes)
if crit:
response += " {}".format(
weapon.str_crit.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name +
"\'s ghost"))
response += " {target_name} loses {damage} antislime!".format(
target_name=(member.display_name + "\'s ghost"),
damage=damage)
else:
if miss:
response = "{}\'s ghost is unharmed.".format(
member.display_name)
else:
response = "{target_name} is hit!! {target_name} loses {damage} antislime!".format(
target_name=(member.display_name + "\'s ghost"),
damage=damage)
# Persist every users' data.
user_data.persist()
shootee_data.persist()
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.server.get_member(
shootee_data.id_user))
elif shootee_data.life_state == ewcfg.life_state_corpse and shootee_data.busted == True:
# Target is already dead and not a ghost.
response = "{} is already dead.".format(member.display_name)
elif shootee_data.life_state == ewcfg.life_state_corpse and user_data.ghostbust == False:
# Target is a ghost but user is not able to bust
response = "You don't know how to fight a ghost."
else:
# Slimes from this shot might be awarded to the boss.
role_boss = (ewcfg.role_copkiller
if user_iskillers else ewcfg.role_rowdyfucker)
boss_slimes = 0
user_inital_level = user_data.slimelevel
was_juvenile = False
was_killed = False
was_shot = False
if (shootee_data.life_state == ewcfg.life_state_enlisted) or (
shootee_data.life_state == ewcfg.life_state_juvenile):
# User can be shot.
if shootee_data.life_state == ewcfg.life_state_juvenile:
was_juvenile = True
was_shot = True
if was_shot:
#hunger drain
user_data.hunger += ewcfg.hunger_pershot * ewutils.hunger_cost_mod(
user_data.slimelevel)
# Weaponized flavor text.
randombodypart = ewcfg.hitzone_list[random.randrange(
len(ewcfg.hitzone_list))]
# Weapon-specific adjustments
if weapon != None and weapon.fn_effect != None:
# Build effect container
ctn = EwEffectContainer(miss=miss,
crit=crit,
slimes_damage=slimes_damage,
slimes_spent=slimes_spent,
user_data=user_data,
shootee_data=shootee_data)
# Make adjustments
weapon.fn_effect(ctn)
# Apply effects for non-reference values
miss = ctn.miss
crit = ctn.crit
slimes_damage = ctn.slimes_damage
slimes_spent = ctn.slimes_spent
strikes = ctn.strikes
# user_data and shootee_data should be passed by reference, so there's no need to assign them back from the effect container.
if miss:
slimes_damage = 0
# Remove !revive invulnerability.
user_data.time_lastrevive = 0
# Spend slimes, to a minimum of zero
user_data.change_slimes(
n=(-user_data.slimes
if slimes_spent >= user_data.slimes else -slimes_spent),
source=ewcfg.source_spending)
# Damage stats
ewstats.track_maximum(user=user_data,
metric=ewcfg.stat_max_hitdealt,
value=slimes_damage)
ewstats.change_stat(user=user_data,
metric=ewcfg.stat_lifetime_damagedealt,
n=slimes_damage)
# Remove repeat killing protection if.
if user_data.id_killer == shootee_data.id_user:
user_data.id_killer = ""
if slimes_damage >= shootee_data.slimes:
was_killed = True
if was_killed:
#adjust statistics
ewstats.increment_stat(user=user_data,
metric=ewcfg.stat_kills)
ewstats.track_maximum(user=user_data,
metric=ewcfg.stat_biggest_kill,
value=int(slimes_dropped))
if user_data.slimelevel > shootee_data.slimelevel:
ewstats.increment_stat(
user=user_data, metric=ewcfg.stat_lifetime_ganks)
elif user_data.slimelevel < shootee_data.slimelevel:
ewstats.increment_stat(
user=user_data,
metric=ewcfg.stat_lifetime_takedowns)
# Collect bounty
coinbounty = int(
shootee_data.bounty /
ewcfg.slimecoin_exchangerate) # 100 slime per coin
# Move around slime as a result of the shot.
if shootee_data.slimes >= 0:
if was_juvenile:
user_data.change_slimes(
n=slimes_dropped, source=ewcfg.source_killing)
else:
user_data.change_slimecredit(
n=coinbounty,
coinsource=ewcfg.coinsource_bounty)
user_data.change_slimes(
n=slimes_dropped / 2,
source=ewcfg.source_killing)
boss_slimes += int(slimes_dropped / 2)
# Steal items
ewitem.item_loot(member=member,
id_user_target=cmd.message.author.id)
#add bounty
user_data.add_bounty(n=(shootee_data.bounty / 2) +
(slimes_dropped / 4))
# Give a bonus to the player's weapon skill for killing a stronger player.
if shootee_data.slimelevel >= user_data.slimelevel:
user_data.add_weaponskill(n=1)
# Player was killed.
shootee_data.id_killer = user_data.id_user
shootee_data.die(cause=ewcfg.cause_killing)
shootee_data.change_slimes(
n=-slimes_dropped / 10,
source=ewcfg.source_ghostification)
kill_descriptor = "beaten to death"
if weapon != None:
response = weapon.str_damage.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name,
hitzone=randombodypart,
strikes=strikes)
kill_descriptor = weapon.str_killdescriptor
if crit:
response += " {}".format(
weapon.str_crit.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name))
response += "\n\n{}".format(
weapon.str_kill.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name,
emote_skull=ewcfg.emote_slimeskull))
shootee_data.trauma = weapon.id_weapon
if slimeoid.level == ewcfg.slimeoid_state_active:
brain = ewcfg.brain_map.get(slimeoid.ai)
response += "\n\n{}" + brain.str_kill.format(
slimeoid_name=shootee_slimeoid.name)
if shootee_slimeoid.level == ewcfg.slimeoid_state_active:
brain = ewcfg.brain_map.get(shootee_slimeoid.ai)
response += "\n\n{}" + brain.str_death.format(
slimeoid_name=shootee_slimeoid.name)
else:
response = "{name_target} is hit!!\n\n{name_target} has died.".format(
name_target=member.display_name)
shootee_data.trauma = ""
if slimeoid.life_state == ewcfg.slimeoid_state_active:
brain = ewcfg.brain_map.get(slimeoid.ai)
response += "\n\n" + brain.str_kill.format(
slimeoid_name=shootee_slimeoid.name)
if shootee_slimeoid.life_state == ewcfg.slimeoid_state_active:
brain = ewcfg.brain_map.get(shootee_slimeoid.ai)
response += "\n\n" + brain.str_death.format(
slimeoid_name=shootee_slimeoid.name)
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 coinbounty > 0:
response += "\n\n SlimeCorp transfers {} SlimeCoin to {}\'s account.".format(
str(coinbounty), cmd.message.author.display_name)
else:
# A non-lethal blow!
shootee_data.change_slimes(n=-slimes_damage,
source=ewcfg.source_damage)
damage = str(slimes_damage)
if weapon != None:
if miss:
response = "{}".format(
weapon.str_miss.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name))
else:
response = weapon.str_damage.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name,
hitzone=randombodypart,
strikes=strikes)
if crit:
response += " {}".format(
weapon.str_crit.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name))
response += " {target_name} loses {damage} slime!".format(
target_name=member.display_name, damage=damage)
else:
# unarmed attacks have no miss or crit chance
response = "{target_name} is hit!! {target_name} loses {damage} slime!".format(
target_name=member.display_name, damage=damage)
else:
response = 'You are unable to attack {}.'.format(
member.display_name)
# Add level up text to response if appropriate
if user_inital_level < user_data.slimelevel:
response += "\n\n{} has been empowered by slime and is now a level {} slimeboi!".format(
cmd.message.author.display_name, user_data.slimelevel)
# # Give slimes to the boss if possible.
# boss_member = None
# if boss_slimes > 0:
# for member_search in cmd.message.server.members:
# if role_boss in ewutils.getRoleMap(member_search.roles):
# boss_member = member_search
# break
# if boss_member != None:
# boss_data = EwUser(member = boss_member)
# boss_data.change_slimes(n = boss_slimes)
# boss_data.persist()
kingpin = ewutils.find_kingpin(id_server=cmd.message.server.id,
kingpin_role=role_boss)
if kingpin:
kingpin.change_slimes(n=boss_slimes)
kingpin.persist()
# Persist every users' data.
user_data.persist()
shootee_data.persist()
# Assign the corpse role to the newly dead player.
if was_killed:
await ewrolemgr.updateRoles(client=cmd.client, member=member)
# Send the response to the player.
await cmd.client.send_message(
cmd.message.channel, ewutils.formatMessage(cmd.message.author,
response))
if deathreport != "":
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await cmd.client.send_message(sewerchannel, deathreport)
async def disembark(cmd):
# can only use movement commands in location channels
if ewutils.channel_name_is_poi(cmd.message.channel.name) == False:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0])))
user_data = EwUser(member = cmd.message.author)
response = ""
resp_cont = ewutils.EwResponseContainer(client = cmd.client, id_server = user_data.id_server)
# prevent ghosts currently inhabiting other players from moving on their own
if user_data.get_inhabitee():
response = "You might want to **{}** of the poor soul you've been tormenting first.".format(ewcfg.cmd_letgo)
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
# can only disembark when you're on a transport vehicle
elif user_data.poi in ewcfg.transports:
transport_data = EwTransport(id_server = user_data.id_server, poi = user_data.poi)
response = "{}ing.".format(cmd.tokens[0][1:].lower()).capitalize()
stop_poi = ewcfg.id_to_poi.get(transport_data.current_stop)
# if stop_poi.is_subzone:
# stop_poi = ewcfg.id_to_poi.get(stop_poi.mother_district)
if ewmap.inaccessible(user_data = user_data, poi = stop_poi):
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You're not allowed to go there (bitch)."))
# schedule tasks for concurrent execution
message_task = asyncio.ensure_future(ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)))
wait_task = asyncio.ensure_future(asyncio.sleep(5))
# Take control of the move for this player.
ewmap.move_counter += 1
move_current = ewutils.moves_active[cmd.message.author.id] = ewmap.move_counter
await message_task
await wait_task
# check if the user entered another movement command while waiting for the current one to be completed
if move_current != ewutils.moves_active[cmd.message.author.id]:
return
user_data = EwUser(member = cmd.message.author)
transport_data = EwTransport(id_server = user_data.id_server, poi = transport_data.poi)
# cancel move, if the user has left the transport while waiting for movement to be completed (e.g. by dying)
if user_data.poi != transport_data.poi:
return
stop_poi = ewcfg.id_to_poi.get(transport_data.current_stop)
# juvies can't swim
if transport_data.current_stop == ewcfg.poi_id_slimesea and user_data.life_state != ewcfg.life_state_corpse:
if user_data.life_state == ewcfg.life_state_kingpin:
response = "You try to heave yourself over the railing as you're hit by a sudden case of sea sickness. You puke into the sea and sink back on deck."
response = ewutils.formatMessage(cmd.message.author, response)
return await ewutils.send_message(cmd.client, cmd.message.channel, response)
user_data.poi = ewcfg.poi_id_slimesea
user_data.trauma = ewcfg.trauma_id_environment
die_resp = user_data.die(cause = ewcfg.cause_drowning)
user_data.persist()
resp_cont.add_response_container(die_resp)
response = "{} jumps over the railing of the ferry and promptly drowns in the slime sea.".format(cmd.message.author.display_name)
resp_cont.add_channel_response(channel = ewcfg.channel_slimesea, response = response)
resp_cont.add_channel_response(channel = ewcfg.channel_ferry, response = response)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
# they also can't fly
elif transport_data.transport_type == ewcfg.transport_type_blimp and not stop_poi.is_transport_stop and user_data.life_state != ewcfg.life_state_corpse:
user_mutations = user_data.get_mutations()
if user_data.life_state == ewcfg.life_state_kingpin:
response = "Your life flashes before your eyes, as you plummet towards your certain death. A lifetime spent being a piece of shit and playing videogames all day. You close your eyes and... BOING! You open your eyes again to see a crew of workers transporting the trampoline that broke your fall. You get up and dust yourself off, sighing heavily."
response = ewutils.formatMessage(cmd.message.author, response)
resp_cont.add_channel_response(channel = stop_poi.channel, response = response)
user_data.poi = stop_poi.id_poi
user_data.persist()
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
return await resp_cont.post()
elif ewcfg.mutation_id_lightasafeather in user_mutations:
response = "With a running jump you launch yourself out of the blimp and begin falling to your soon-to-be demise... but then a strong updraft breaks your fall and you land unscathed. "
response = ewutils.formatMessage(cmd.message.author, response)
resp_cont.add_channel_response(channel = stop_poi.channel, response = response)
user_data.poi = stop_poi.id_poi
user_data.persist()
await user_data.move_inhabitants(id_poi = stop_poi.id_poi)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
return await resp_cont.post()
district_data = EwDistrict(id_server = user_data.id_server, district = stop_poi.id_poi)
district_data.change_slimes(n = user_data.slimes)
district_data.persist()
user_data.poi = stop_poi.id_poi
user_data.trauma = ewcfg.trauma_id_environment
die_resp = user_data.die(cause = ewcfg.cause_falling)
user_data.persist()
resp_cont.add_response_container(die_resp)
response = "SPLAT! A body collides with the asphalt with such force, that it is utterly annihilated, covering bystanders in blood and slime and guts."
resp_cont.add_channel_response(channel = stop_poi.channel, response = response)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
# update user location, if move successful
else:
# if stop_poi.is_subzone:
# stop_poi = ewcfg.id_to_poi.get(stop_poi.mother_district)
if ewmap.inaccessible(user_data = user_data, poi = stop_poi):
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You're not allowed to go there (bitch)."))
user_data.poi = stop_poi.id_poi
user_data.persist()
await user_data.move_inhabitants(id_poi = stop_poi.id_poi)
response = "You enter {}".format(stop_poi.str_name)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
await ewutils.send_message(cmd.client, ewutils.get_channel(cmd.guild, stop_poi.channel), ewutils.formatMessage(cmd.message.author, response))
# SWILLDERMUK
await ewutils.activate_trap_items(stop_poi.id_poi, user_data.id_server, user_data.id_user)
return
return await resp_cont.post()
else:
response = "You are not currently riding any transport."
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def disembark(cmd):
# can only use movement commands in location channels
if ewmap.channel_name_is_poi(cmd.message.channel.name) == False:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0])))
user_data = EwUser(member = cmd.message.author)
response = ""
resp_cont = ewutils.EwResponseContainer(client = cmd.client, id_server = user_data.id_server)
# can only disembark when you're on a transport vehicle
if user_data.poi in ewcfg.transports:
transport_data = EwTransport(id_server = user_data.id_server, poi = user_data.poi)
response = "{}ing.".format(cmd.tokens[0][1:].lower()).capitalize()
# schedule tasks for concurrent execution
message_task = asyncio.ensure_future(ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)))
wait_task = asyncio.ensure_future(asyncio.sleep(5))
# Take control of the move for this player.
ewmap.move_counter += 1
move_current = ewutils.moves_active[cmd.message.author.id] = ewmap.move_counter
await message_task
await wait_task
# check if the user entered another movement command while waiting for the current one to be completed
if move_current != ewutils.moves_active[cmd.message.author.id]:
return
user_data = EwUser(member = cmd.message.author)
transport_data = EwTransport(id_server = user_data.id_server, poi = transport_data.poi)
# cancel move, if the user has left the transport while waiting for movement to be completed (e.g. by dying)
if user_data.poi != transport_data.poi:
return
stop_poi = ewcfg.id_to_poi.get(transport_data.current_stop)
# juvies can't swim
if transport_data.current_stop == ewcfg.poi_id_slimesea and user_data.life_state != ewcfg.life_state_corpse:
if user_data.life_state == ewcfg.life_state_kingpin:
response = "You try to heave yourself over the railing as you're hit by a sudden case of sea sickness. You puke into the sea and sink back on deck."
response = ewutils.formatMessage(cmd.message.author, response)
return await ewutils.send_message(cmd.client, cmd.message.channel, response)
user_data.poi = ewcfg.poi_id_slimesea
die_resp = user_data.die(cause = ewcfg.cause_drowning)
user_data.persist()
resp_cont.add_response_container(die_resp)
response = "{} jumps over the railing of the ferry and promptly drowns in the slime sea.".format(cmd.message.author.display_name)
resp_cont.add_channel_response(channel = ewcfg.channel_slimesea, response = response)
resp_cont.add_channel_response(channel = ewcfg.channel_ferry, response = response)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
# they also can't fly
elif transport_data.transport_type == ewcfg.transport_type_blimp and not stop_poi.is_transport_stop and user_data.life_state != ewcfg.life_state_corpse:
if user_data.life_state == ewcfg.life_state_kingpin:
response = "Your life flashes before your eyes, as you plummet towards your certain death. A lifetime spent being a piece of shit and playing videogames all day. You close your eyes and... BOING! You open your eyes again to see a crew of workers transporting the trampoline that broke your fall. You get up and dust yourself off, sighing heavily."
response = ewutils.formatMessage(cmd.message.author, response)
resp_cont.add_channel_response(channel = stop_poi.channel, response = response)
user_data.poi = stop_poi.id_poi
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
return await resp_cont.post()
district_data = EwDistrict(id_server = user_data.id_server, district = stop_poi.id_poi)
district_data.change_slimes(n = user_data.slimes)
district_data.persist()
user_data.poi = stop_poi.id_poi
die_resp = user_data.die(cause = ewcfg.cause_falling)
user_data.persist()
resp_cont.add_response_container(die_resp)
response = "SPLAT! A body collides with the asphalt with such force, that it is utterly annihilated, covering bystanders in blood and slime and guts."
resp_cont.add_channel_response(channel = stop_poi.channel, response = response)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
# update user location, if move successful
else:
user_data.poi = transport_data.current_stop
user_data.persist()
response = "You enter {}".format(stop_poi.str_name)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
return await ewutils.send_message(cmd.client, ewutils.get_channel(cmd.message.server, stop_poi.channel), ewutils.formatMessage(cmd.message.author, response))
return await resp_cont.post()
else:
response = "You are not currently riding any transport."
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
def explode(damage = 0, district_data = None, market_data = None):
id_server = district_data.id_server
poi = district_data.name
if market_data == None:
market_data = EwMarket(id_server = district_data.id_server)
client = get_client()
server = client.get_server(id_server)
resp_cont = EwResponseContainer(id_server = id_server)
response = ""
channel = ewcfg.id_to_poi.get(poi).channel
life_states = [ewcfg.life_state_juvenile, ewcfg.life_state_enlisted, ewcfg.life_state_executive]
users = district_data.get_players_in_district(life_states = life_states)
enemies = district_data.get_enemies_in_district()
# damage players
for user in users:
user_data = EwUser(id_user = user, id_server = id_server)
mutations = user_data.get_mutations()
user_weapon = None
user_weapon_item = None
if user_data.weapon >= 0:
user_weapon_item = EwItem(id_item = user_data.weapon)
user_weapon = ewcfg.weapon_map.get(user_weapon_item.item_props.get("weapon_type"))
# apply defensive mods
slimes_damage_target = damage * ewwep.damage_mod_defend(
shootee_data = user_data,
shootee_mutations = mutations,
shootee_weapon = user_weapon,
market_data = market_data
)
# apply sap armor
sap_armor = ewwep.get_sap_armor(shootee_data = user_data, sap_ignored = 0)
slimes_damage_target *= sap_armor
slimes_damage_target = int(max(0, slimes_damage_target))
player_data = EwPlayer(id_user = user_data.id_user)
response = "{} is blown back by the explosion’s sheer force! They lose {:,} slime!!".format(player_data.display_name, slimes_damage_target)
resp_cont.add_channel_response(channel, response)
slimes_damage = slimes_damage_target
if user_data.slimes < slimes_damage + user_data.bleed_storage:
# die in the explosion
district_data.change_slimes(n = user_data.slimes, source = ewcfg.source_killing)
district_data.persist()
slimes_dropped = user_data.totaldamage + user_data.slimes
explode_damage = slime_bylevel(user_data.slimelevel)
user_data.die(cause = ewcfg.cause_killing)
#user_data.change_slimes(n = -slimes_dropped / 10, source = ewcfg.source_ghostification)
user_data.persist()
response = "Alas, {} was caught too close to the blast. They are consumed by the flames, and die in the explosion.".format(player_data.display_name)
resp_cont.add_channel_response(channel, response)
if ewcfg.mutation_id_spontaneouscombustion in mutations:
sub_explosion = explode(explode_damage, district_data)
resp_cont.add_response_container(sub_explosion)
resp_cont.add_member_to_update(server.get_member(user_data.id_user))
else:
# survive
slime_splatter = 0.5 * slimes_damage
district_data.change_slimes(n = slime_splatter, source = ewcfg.source_killing)
district_data.persist()
slimes_damage -= slime_splatter
user_data.bleed_storage += slimes_damage
user_data.change_slimes(n = -slime_splatter, source = ewcfg.source_killing)
user_data.persist()
# damage enemies
for enemy in enemies:
enemy_data = EwEnemy(id_enemy = enemy, id_server = id_server)
response = "{} is blown back by the explosion’s sheer force! They lose {:,} slime!!".format(enemy_data.display_name, damage)
resp_cont.add_channel_response(channel, response)
slimes_damage_target = damage
# apply sap armor
sap_armor = ewwep.get_sap_armor(shootee_data = enemy_data, sap_ignored = 0)
slimes_damage_target *= sap_armor
slimes_damage_target = int(max(0, slimes_damage_target))
slimes_damage = slimes_damage_target
if enemy_data.slimes < slimes_damage + enemy_data.bleed_storage:
# die in the explosion
district_data.change_slimes(n = enemy_data.slimes, source = ewcfg.source_killing)
district_data.persist()
# slimes_dropped = enemy_data.totaldamage + enemy_data.slimes
# explode_damage = ewutils.slime_bylevel(enemy_data.level)
response = "Alas, {} was caught too close to the blast. They are consumed by the flames, and die in the explosion.".format(enemy_data.display_name)
resp_cont.add_response_container(ewhunting.drop_enemy_loot(enemy_data, district_data))
resp_cont.add_channel_response(channel, response)
enemy_data.life_state = ewcfg.enemy_lifestate_dead
enemy_data.persist()
else:
# survive
slime_splatter = 0.5 * slimes_damage
district_data.change_slimes(n = slime_splatter, source = ewcfg.source_killing)
district_data.persist()
slimes_damage -= slime_splatter
enemy_data.bleed_storage += slimes_damage
enemy_data.change_slimes(n = -slime_splatter, source = ewcfg.source_killing)
enemy_data.persist()
return resp_cont
async def weather_tick(id_server=None):
if id_server != None:
try:
market_data = EwMarket(id_server=id_server)
if market_data.weather != ewcfg.weather_bicarbonaterain:
return
exposed_pois = []
exposed_pois.extend(ewcfg.capturable_districts)
exposed_pois.extend(ewcfg.outskirts)
exposed_pois = tuple(exposed_pois)
client = ewutils.get_client()
server = client.get_server(id_server)
users = ewutils.execute_sql_query(
"SELECT id_user FROM users WHERE id_server = %s AND {poi} IN %s AND {life_state} > 0"
.format(poi=ewcfg.col_poi, life_state=ewcfg.col_life_state),
(id_server, exposed_pois))
deathreport = ""
resp_cont = ewutils.EwResponseContainer(id_server=id_server)
users_to_update = []
for user in users:
user_data = EwUser(id_user=user[0], id_server=id_server)
if user_data.life_state == ewcfg.life_state_kingpin:
continue
user_poi = ewcfg.id_to_poi.get(user_data.poi)
player_data = EwPlayer(id_server=user_data.id_server,
id_user=user_data.id_user)
protected = False
slimeoid_protected = False
if user_data.weapon >= 0:
weapon_item = EwItem(id_item=user_data.weapon)
if weapon_item.item_props.get(
'weapon_type') in ewcfg.rain_protection:
protected = True
cosmetics = ewitem.inventory(
id_user=user_data.id_user,
id_server=id_server,
item_type_filter=ewcfg.it_cosmetic)
for cosmetic in cosmetics:
cosmetic_data = EwItem(id_item=cosmetic.get('id_item'))
if cosmetic_data.item_props.get(
'id_cosmetic') in ewcfg.rain_protection:
if cosmetic_data.item_props.get('adorned') == 'true':
protected = True
elif cosmetic_data.item_props.get(
'slimeoid') == 'true':
slimeoid_protected = True
if not protected:
slimes_to_erase = user_data.slimes * 0.01 * ewcfg.weather_tick_length
slimes_to_erase = max(slimes_to_erase,
ewcfg.weather_tick_length * 1000)
slimes_to_erase = min(user_data.slimes, slimes_to_erase)
#round up or down, randomly weighted
remainder = slimes_to_erase - int(slimes_to_erase)
if random.random() < remainder:
slimes_to_erase += 1
slimes_to_erase = int(slimes_to_erase)
user_data.change_slimes(n=-slimes_to_erase,
source=ewcfg.source_weather)
response = "*{uname}*: The bicarbonate rain dissolves {slimeloss:,} of your slime.".format(
uname=player_data.display_name,
slimeloss=slimes_to_erase)
resp_cont.add_channel_response(user_poi.channel, response)
if user_data.slimes <= 0:
user_data.die(cause=ewcfg.cause_weather)
#user_data.change_slimes(n = -slimes_dropped / 10, source = ewcfg.source_ghostification)
deathreport = "{skull} *{uname}*: You have been cleansed by the bicarbonate rain. {skull}".format(
skull=ewcfg.emote_slimeskull,
uname=player_data.display_name)
resp_cont.add_channel_response(ewcfg.channel_sewers,
deathreport)
resp_cont.add_channel_response(user_poi.channel,
deathreport)
users_to_update.append(user[0])
user_data.persist()
if not slimeoid_protected:
slimeoid_data = EwSlimeoid(id_user=user_data.id_user,
id_server=id_server)
if slimeoid_data.life_state != ewcfg.slimeoid_state_active:
continue
slimeoid_response = ""
if random.randrange(10) < slimeoid_data.level:
slimeoid_response = "*{uname}*: {slname} cries out in pain, as it's hit by the bicarbonate rain.".format(
uname=player_data.display_name,
slname=slimeoid_data.name)
else:
item_props = {
'context':
ewcfg.context_slimeoidheart,
'subcontext':
slimeoid_data.id_slimeoid,
'item_name':
"Heart of {}".format(slimeoid_data.name),
'item_desc':
"A poudrin-like crystal. If you listen carefully you can hear something that sounds like a faint heartbeat."
}
ewitem.item_create(id_user=user_data.id_user,
id_server=id_server,
item_type=ewcfg.it_item,
item_props=item_props)
slimeoid_data.die()
slimeoid_data.persist()
slimeoid_response = "*{uname}*: {slname} lets out a final whimper as it's dissolved by the bicarbonate rain. {skull} You quickly pocket its heart.".format(
uname=player_data.display_name,
slname=slimeoid_data.name,
skull=ewcfg.emote_slimeskull)
resp_cont.add_channel_response(user_poi.channel,
slimeoid_response)
for poi in exposed_pois:
district_data = EwDistrict(district=poi, id_server=id_server)
slimes_to_erase = district_data.slimes * 0.01 * ewcfg.weather_tick_length
slimes_to_erase = max(slimes_to_erase,
ewcfg.weather_tick_length * 1000)
slimes_to_erase = min(district_data.slimes, slimes_to_erase)
#round up or down, randomly weighted
remainder = slimes_to_erase - int(slimes_to_erase)
if random.random() < remainder:
slimes_to_erase += 1
slimes_to_erase = int(slimes_to_erase)
district_data.change_slimes(n=-slimes_to_erase,
source=ewcfg.source_weather)
district_data.persist()
enemies = ewutils.execute_sql_query(
"SELECT id_enemy FROM enemies WHERE id_server = %s AND {poi} IN %s AND {life_state} = %s AND {weathertype} != %s"
.format(poi=ewcfg.col_enemy_poi,
life_state=ewcfg.col_enemy_life_state,
weathertype=ewcfg.col_enemy_weathertype),
(id_server, exposed_pois, ewcfg.enemy_lifestate_alive,
ewcfg.enemy_weathertype_rainresist))
for enemy in enemies:
enemy_data = EwEnemy(id_enemy=enemy[0])
enemy_poi = ewcfg.id_to_poi.get(enemy_data.poi)
slimes_to_erase = enemy_data.slimes * 0.01 * ewcfg.weather_tick_length
slimes_to_erase = max(slimes_to_erase,
ewcfg.weather_tick_length * 1000)
slimes_to_erase = min(enemy_data.slimes, slimes_to_erase)
#round up or down, randomly weighted
remainder = slimes_to_erase - int(slimes_to_erase)
if random.random() < remainder:
slimes_to_erase += 1
slimes_to_erase = int(slimes_to_erase)
enemy_data.change_slimes(n=-slimes_to_erase,
source=ewcfg.source_weather)
enemy_data.persist()
response = "{name} takes {slimeloss:,} damage from the bicarbonate rain.".format(
name=enemy_data.display_name, slimeloss=slimes_to_erase)
resp_cont.add_channel_response(enemy_poi.channel, response)
if enemy_data.slimes <= 0:
ewhunting.delete_enemy(enemy_data)
deathreport = "{skull} {name} is dissolved by the bicarbonate rain. {skull}".format(
skull=ewcfg.emote_slimeskull,
name=enemy_data.display_name)
resp_cont.add_channel_response(enemy_poi.channel,
deathreport)
for user in users_to_update:
await ewrolemgr.updateRoles(client=client,
member=server.get_member(user))
await resp_cont.post()
except:
ewutils.logMsg(
"Error occurred in weather tick for server {}".format(
id_server))
async def xfer(cmd):
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_stockexchange:
# Only allowed in the stock exchange.
response = ewcfg.str_exchange_channelreq.format(currency = "SlimeCoin", action = "transfer")
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
return
if cmd.mentions_count != 1:
# Must have exactly one target to send to.
response = "Mention the player you want to send SlimeCoin to."
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
return
member = cmd.mentions[0]
target_data = EwUser(member = member)
if target_data.life_state == ewcfg.life_state_kingpin:
# Disallow transfers to RF and CK kingpins.
response = "You can't transfer SlimeCoin to a known criminal warlord."
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
return
user_data = EwUser(member = cmd.message.author)
market_data = EwMarket(id_server = cmd.message.author.server.id)
if cmd.message.author.id == member.id:
user_data.id_killer = cmd.message.author.id
user_data.die(cause = ewcfg.cause_suicide)
user_data.persist()
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, "Gaming the slimeconomy is punishable by death. SlimeCorp soldiers execute you immediately."))
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
return
# Parse the slime value to send.
value = None
if cmd.tokens_count > 1:
value = ewutils.getIntToken(tokens = cmd.tokens, allow_all = True)
if value != None:
if value < 0:
value = user_data.slimes
if value <= 0:
value = None
if value != None:
# Cost including the 5% transfer fee.
cost_total = int(value * 1.05)
if user_data.slimecredit < cost_total:
response = "You don't have enough SlimeCoin. ({:,}/{:,})".format(user_data.slimecredit, cost_total)
else:
# Do the transfer if the player can afford it.
target_data.change_slimecredit(n = value, coinsource = ewcfg.coinsource_transfer)
user_data.change_slimecredit(n = -cost_total, coinsource = ewcfg.coinsource_transfer)
user_data.time_lastinvest = time_now
# Persist changes
response = "You transfer {slime:,} SlimeCoin to {target_name}. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format(slime = value, target_name = member.display_name, fee = (cost_total - value))
target_data.persist()
user_data.persist()
else:
response = ewcfg.str_exchange_specify.format(currency = "SlimeCoin", action = "transfer")
# Send the response to the player.
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def mine(cmd):
market_data = EwMarket(id_server=cmd.message.author.server.id)
user_data = EwUser(member=cmd.message.author)
time_now = int(time.time())
# Kingpins can't mine.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
return
# ghosts cant mine (anymore)
if user_data.life_state == ewcfg.life_state_corpse:
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You can't mine while you're dead. Try {}.".format(
ewcfg.cmd_revive)))
# Enlisted players only mine at certain times.
if user_data.life_state == ewcfg.life_state_enlisted:
if user_data.faction == ewcfg.faction_rowdys and (
market_data.clock < 8 or market_data.clock > 17):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Rowdies only mine in the daytime. Wait for full daylight at 8am."
.format(ewcfg.cmd_revive)))
if user_data.faction == ewcfg.faction_killers and (
market_data.clock < 20 and market_data.clock > 5):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Killers only mine under cover of darkness. Wait for nightfall at 8pm."
.format(ewcfg.cmd_revive)))
# Mine only in the mines.
if cmd.message.channel.name in [
ewcfg.channel_mines, ewcfg.channel_cv_mines, ewcfg.channel_tt_mines
]:
if user_data.hunger >= ewutils.hunger_max_bylevel(
user_data.slimelevel):
global last_mismined_times
mismined = last_mismined_times.get(cmd.message.author.id)
if mismined == None:
mismined = {'time': time_now, 'count': 0}
if time_now - mismined['time'] < 5:
mismined['count'] += 1
else:
# Reset counter.
mismined['time'] = time_now
mismined['count'] = 1
last_mismined_times[cmd.message.author.id] = mismined
if mismined[
'count'] >= 7: # up to 6 messages can be buffered by discord and people have been dying unfairly because of that
# Death
last_mismined_times[cmd.message.author.id] = None
user_data.die(cause=ewcfg.cause_mining)
user_data.persist()
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You have died in a mining accident."))
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await cmd.client.send_message(
sewerchannel, "{} ".format(ewcfg.emote_slimeskull) +
ewutils.formatMessage(
cmd.message.author,
"You have died in a mining accident. {}".format(
ewcfg.emote_slimeskull)))
else:
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You've exhausted yourself from mining. You'll need some refreshment before getting back to work."
))
else:
# Determine if a poudrin is found.
poudrin = False
poudrinamount = 0
# juvies get poudrins 4 times as often as enlisted players
poudrin_rarity = ewcfg.poudrin_rarity / (
2 if user_data.life_state == ewcfg.life_state_juvenile else 1)
poudrin_mined = random.randint(1, poudrin_rarity)
if poudrin_mined == 1:
poudrin = True
poudrinamount = 1 if random.randint(
1, 3) != 1 else 2 # 33% chance of extra drop
user_initial_level = user_data.slimelevel
# Add mined slime to the user.
slime_bylevel = ewutils.slime_bylevel(user_data.slimelevel)
mining_yield = math.floor((slime_bylevel / 10) + 1)
alternate_yield = math.floor(200 + slime_bylevel**(1 / math.e))
mining_yield = min(mining_yield, alternate_yield)
user_data.change_slimes(n=mining_yield, source=ewcfg.source_mining)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Create and give slime poudrins
for pdx in range(poudrinamount):
item_id = ewitem.item_create(
item_type=ewcfg.it_slimepoudrin,
id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
)
ewutils.logMsg(
'Created poudrin (item {}) for user (id {})'.format(
item_id, cmd.message.author.id))
# Fatigue the miner.
hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel)
extra = hunger_cost_mod - int(
hunger_cost_mod
) # extra is the fractional part of hunger_cost_mod
user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod)
if extra > 0: # if hunger_cost_mod is not an integer
# there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100)
if random.randint(1, 100) <= extra * 100:
user_data.hunger += ewcfg.hunger_permine
user_data.persist()
# Tell the player their slime level increased and/or a poudrin was found.
if was_levelup or poudrin:
response = ""
if poudrin:
if poudrinamount == 1:
response += "You unearthed a slime poudrin! "
elif poudrinamount == 2:
response += "You unearthed two slime poudrins! "
ewstats.change_stat(user=user_data,
metric=ewcfg.stat_lifetime_poudrins,
n=poudrinamount)
ewutils.logMsg('{} has found {} poudrin(s)!'.format(
cmd.message.author.display_name, poudrinamount))
if was_levelup:
response += "You have been empowered by slime and are now a level {} slimeboi!".format(
user_data.slimelevel)
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
# Mismined. Potentially kill the player for spamming the wrong channel.
mismined = last_mismined_times.get(cmd.message.author.id)
if mismined == None:
mismined = {'time': time_now, 'count': 0}
if time_now - mismined['time'] < 5:
mismined['count'] += 1
else:
# Reset counter.
mismined['time'] = time_now
mismined['count'] = 1
last_mismined_times[cmd.message.author.id] = mismined
if mismined['count'] >= 5:
# Death
last_mismined_times[cmd.message.author.id] = None
user_data.die(cause=ewcfg.cause_mining)
user_data.persist()
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
"You have died in a mining accident."))
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await cmd.client.send_message(
sewerchannel,
"{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage(
cmd.message.author,
"You have died in a mining accident. {}".format(
ewcfg.emote_slimeskull)))
else:
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
"You can't mine here. Go to the mines."))
async def 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 writhe(cmd):
resp = await ewcmd.start(cmd=cmd)
response = ""
user_data = EwUser(member=cmd.message.author)
if user_data.life_state != ewcfg.life_state_grandfoe:
response = "Only the NEGASLIME {} can do that.".format(
ewcfg.emote_negaslime)
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
# play animation
he = ewcfg.emote_he
s_ = ewcfg.emote_s_
ve = ewcfg.emote_ve
vt = ewcfg.emote_vt
v_ = ewcfg.emote_v_
h_ = ewcfg.emote_h_
va = ewcfg.emote_va
ht = ewcfg.emote_ht
hs = ewcfg.emote_hs
blank = ewcfg.emote_blank
writhing1 = he
writhing2 = s_ + he + "\n" + ve
writhing3 = s_ + h_ + he + "\n" + vt + he
writhing4 = s_ + h_ + ht + "\n" + vt + he + ve
writhing5 = s_ + h_ + ht + "\n" + va + he + vt + he + "\n" + ve
writhing6 = s_ + h_ + ht + "\n" + va + ht + va + ht + "\n" + v_ + ve + ve + ve + "\n" + ve
writhing7 = s_ + h_ + ht + "\n" + va + ht + va + hs + he + "\n" + v_ + ve + v_ + vt + he + "\n" + ve + blank + ve
writhing8 = s_ + h_ + ht + "\n" + va + ht + va + hs + he + "\n" + v_ + ve + v_ + vt + h_ + he + "\n" + vt + he + vt + he
writhing9 = s_ + h_ + ht + "\n" + va + ht + va + hs + h_ + he + "\n" + v_ + ve + v_ + vt + h_ + ht + "\n" + vt + ht + vt + ht + blank + ve + "\n" + blank + ve + blank + ve
writhing10 = s_ + h_ + ht + "\n" + va + ht + va + hs + h_ + he + "\n" + v_ + ve + v_ + vt + h_ + ht + "\n" + vt + ht + vt + ht + blank + vt + he + "\n" + blank + ve + blank + vt + he
writhings = [
writhing1, writhing2, writhing3, writhing4, writhing5, writhing6,
writhing7, writhing8, writhing9, writhing10
]
for writhing in writhings:
cur_time = time.time()
await ewutils.edit_message(cmd.client, resp, writhing)
elapsed = time.time() - cur_time
await asyncio.sleep(2.0 - elapsed)
id_server = cmd.message.server.id
targets = []
# search for players in the negaslime's location in database and put them in a list
if id_server != None:
try:
conn_info = ewutils.databaseConnect()
conn = conn_info.get('conn')
cursor = conn.cursor()
cursor.execute(
"SELECT id_user FROM users WHERE id_server = %s AND poi = '{}' AND life_state IN (1, 2);"
.format(user_data.poi), (id_server, ))
# convert pulled IDs into member objects
target_ids = cursor.fetchall()
for target_id in target_ids:
target = cmd.message.server.get_member(target_id[0])
targets.append(target)
conn.commit()
finally:
# Clean up the database handles.
cursor.close()
ewutils.databaseClose(conn_info)
victim_list = []
# kill everyone in the negaslime's poi and remember their names
for target in targets:
if target != None:
user_data_target = EwUser(member=target)
user_data_target.id_killer = cmd.message.author.id
user_data_target.die(cause=ewcfg.cause_grandfoe)
user_data_target.persist()
await ewrolemgr.updateRoles(client=cmd.client, member=target)
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await ewutils.send_message(
cmd.client, sewerchannel,
"{} ".format(ewcfg.emote_slimeskull) +
ewutils.formatMessage(
target, "You have been crushed by tendrils. {}".format(
ewcfg.emote_slimeskull)))
victim_list.append(target)
# display result of the writhing
if len(victim_list) > 0:
victims_string = ewutils.userListToNameString(victim_list)
response = "Your tendrils have successfully killed {}.".format(
victims_string)
else:
response = "Your tendrils didn't kill anyone :("
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def 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 donate(cmd):
user_data = EwUser(member=cmd.message.author)
market_data = EwMarket(id_server=user_data.id_server)
time_now = round(time.time())
if user_data.poi == ewcfg.poi_id_slimecorphq:
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 = round(value)
coin_total = round(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."
market_data.donated_slimes += user_data.slimes
market_data.persist()
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 ewutils.send_message(
cmd.client, 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.
market_data.donated_slimes += cost_total
market_data.persist()
user_data.change_slimes(n=-cost_total,
source=ewcfg.source_spending)
user_data.change_slimecoin(
n=coin_total, coinsource=ewcfg.coinsource_donation)
user_data.slime_donations += cost_total
# 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")
elif user_data.poi == ewcfg.poi_id_slimeoidlab:
poudrins = ewitem.find_item(item_search="slimepoudrin",
id_user=cmd.message.author.id,
id_server=cmd.message.server.id if
cmd.message.server is not None else None)
if poudrins == None:
response = "You have to own a poudrin in order to donate a poudrin. Duh."
else:
ewitem.item_delete(
id_item=poudrins.get('id_item')) # Remove Poudrins
market_data.donated_poudrins += 1
market_data.persist()
user_data.poudrin_donations += 1
user_data.persist()
response = "You hand off one of your hard-earned poudrins to the front desk receptionist, who is all too happy to collect it. Pretty uneventful, but at the very least you’re glad donating isn’t physically painful anymore."
else:
response = "To donate slime, go to the SlimeCorp HQ in Downtown. To donate poudrins, go to the SlimeCorp Lab in Brawlden."
# Send the response to the player.
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
