async def check_schedule(cmd):
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)
poi = ewcfg.chname_to_poi.get(cmd.message.channel.name)
response = ""
if poi.is_transport_stop:
response = "The following public transit lines stop here:"
for line in poi.transport_lines:
line_data = ewcfg.id_to_transport_line.get(line)
response += "\n-" + line_data.str_name
elif poi.is_transport:
transport_data = EwTransport(id_server=user_data.id_server,
poi=poi.id_poi)
transport_line = ewcfg.id_to_transport_line.get(
transport_data.current_line)
response = "This {} is following {}.".format(
transport_data.transport_type,
transport_line.str_name.replace("The", "the"))
else:
response = "There is no schedule to check here."
return await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
async def help(cmd):
response = ""
topic = None
user_data = EwUser(member=cmd.message.author)
# help only checks for districts while in game channels
if ewmap.channel_name_is_poi(cmd.message.channel.name) == False:
response = 'Check out the guide for help: https://ew.krakissi.net/guide/' + ' \n' + 'The guide might be a bit outdated though, so you can also visit N.L.A.C.U. (!goto uni) or Neo Milwaukee State (!goto nms) to get more in-depth descriptions about how various game mechanics work.'
else:
# checks if user is in a college
if user_data.poi == ewcfg.poi_id_neomilwaukeestate or user_data.poi == ewcfg.poi_id_nlacu:
if not len(cmd.tokens) > 1:
topic_counter = 0
topic_total = 0
# list off help topics to player at college
response = 'What would you like to learn about? Topics include: \n'
topics = ewcfg.help_responses.keys()
for topic in topics:
topic_counter += 1
topic_total += 1
response += "**{}**".format(topic)
if topic_total != len(topics):
response += ", "
if topic_counter == 4:
topic_counter = 0
response += "\n"
else:
topic = ewutils.flattenTokenListToString(cmd.tokens[1:])
if topic in ewcfg.help_responses:
response = ewcfg.help_responses[topic]
else:
response = 'ENDLESS WAR questions your belief in the existence of such a topic. Try referring to the topics list again by using just !help.'
else:
# user not in college, check what help message would apply to the subzone they are in
# poi variable assignment used for checking if player is in a vendor subzone or not
poi = ewcfg.id_to_poi.get(user_data.poi)
if user_data.poi in [
ewcfg.poi_id_mine, ewcfg.poi_id_cv_mines,
ewcfg.poi_id_tt_mines
]:
# mine help
response = ewcfg.help_responses['mining']
elif (len(poi.vendors) >=
1) and not user_data.poi in ewcfg.poi_id_dojo:
# food help
response = ewcfg.help_responses['food']
elif user_data.poi in ewcfg.poi_id_dojo and not len(
cmd.tokens) > 1:
# dojo help
response = "For general dojo information, do **'!help dojo'**. For information about the sparring and weapon rank systems, do **'!help sparring.'**"
elif user_data.poi in ewcfg.poi_id_dojo and len(cmd.tokens) > 1:
topic = ewutils.flattenTokenListToString(cmd.tokens[1:])
if topic == 'dojo':
response = ewcfg.help_responses['dojo']
elif topic == 'sparring':
response = ewcfg.help_responses['sparring']
else:
response = 'ENDLESS WAR questions your belief in the existence of such information regarding the dojo. Try referring to the topics list again by using just !help.'
elif user_data.poi in [
ewcfg.poi_id_jr_farms, ewcfg.poi_id_og_farms,
ewcfg.poi_id_ab_farms
]:
# farming help
response = ewcfg.help_responses['farming']
elif user_data.poi in ewcfg.poi_id_slimeoidlab:
# slimeoid help (somewhat redundant, but may help by pointing player towards !instructions)
response = ewcfg.help_responses['slimeoids']
elif user_data.poi in ewcfg.transport_stops:
# transportation help
response = ewcfg.help_responses['transportation']
elif user_data.poi in ewcfg.poi_id_stockexchange:
# stock exchange help
response = ewcfg.help_responses['stocks']
elif user_data.poi in ewcfg.poi_id_thecasino:
# casino help
response = ewcfg.help_responses['casino']
elif user_data.poi in ewcfg.poi_id_thesewers:
# death help
response = ewcfg.help_responses['death']
elif user_data.poi in ewcfg.poi_id_realestate:
#real estate help
response = ewcfg.help_responses['realestate']
elif user_data.poi in [
ewcfg.poi_id_toxington_pier,
ewcfg.poi_id_assaultflatsbeach_pier,
ewcfg.poi_id_vagrantscorner_pier,
ewcfg.poi_id_crookline_pier, ewcfg.poi_id_slimesend_pier,
ewcfg.poi_id_jaywalkerplain_pier, ewcfg.poi_id_ferry
]:
# fishing help
response = ewcfg.help_responses['fishing']
elif user_data.poi in ewcfg.outskirts_districts:
# hunting help
response = ewcfg.help_responses['hunting']
else:
# catch-all response for when user isn't in a sub-zone with a help response
response = 'Check out the guide for help: https://ew.krakissi.net/guide/' + ' \n' + 'The guide might be a bit outdated though, so you can also visit N.L.A.C.U. (!goto uni) or Neo Milwaukee State (!goto nms) to get more in-depth descriptions about how various game mechanics work.'
# Send the response to the player.
await ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
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 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 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 haunt(cmd):
time_now = int(time.time())
response = ""
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)
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 user_data.busted:
response = "You can't haunt while you're busted."
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?"
elif ewmap.channel_name_is_poi(cmd.message.channel.name) == False:
response = "You can't commit violence from here."
elif ewmap.poi_is_pvp(haunted_data.poi) == False:
# Require the target to be flagged for PvP
response = "{} is not mired in the ENDLESS WAR right now.".format(member.display_name)
elif haunted_data.life_state == ewcfg.life_state_corpse:
# Dead players can't be haunted.
response = "{} is already dead.".format(member.display_name)
elif haunted_data.life_state == ewcfg.life_state_grandfoe:
# Grand foes can't be haunted.
response = "{} is invulnerable to ghosts.".format(member.display_name)
elif haunted_data.life_state == ewcfg.life_state_enlisted or haunted_data.life_state == ewcfg.life_state_juvenile:
# Target can be haunted by the player.
haunted_slimes = int(haunted_data.slimes / ewcfg.slimes_hauntratio)
if user_data.poi == haunted_data.poi: # when haunting someone face to face, there is no cap and you get double the amount
haunted_slimes *= 2
elif 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)
user_data.time_lasthaunt = time_now
# Persist changes to the database.
user_data.persist()
haunted_data.persist()
response = "{} has been haunted by the ghost of {}! Slime has been lost!".format(member.display_name, cmd.message.author.display_name)
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.
await cmd.client.send_message(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))
async def embark(cmd):
# can only use movement commands in location channels
if ewmap.channel_name_is_poi(cmd.message.channel.name) == False:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0])))
user_data = EwUser(member = cmd.message.author)
response = ""
# must be at a transport stop to enter a transport
if user_data.poi in ewcfg.transport_stops:
transport_ids = get_transports_at_stop(id_server = user_data.id_server, stop = user_data.poi)
# can't embark, when there's no vehicles to embark on
if len(transport_ids) == 0:
response = "There are currently no transport vehicles to embark on here."
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
# automatically embark on the only transport at the station, if no arguments were provided
elif len(transport_ids) == 1 and cmd.tokens_count < 2:
transport_data = EwTransport(id_server = user_data.id_server, poi = transport_ids[0])
target_name = transport_data.current_line
# get target name from command arguments
else:
target_name = ewutils.flattenTokenListToString(cmd.tokens[1:])
# report failure, if the vehicle to be boarded couldn't be ascertained
if target_name == None or len(target_name) == 0:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "Which transport line?"))
transport_line = ewcfg.id_to_transport_line.get(target_name)
# report failure, if an invalid argument was given
if transport_line == None:
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, "Never heard of it."))
for transport_id in transport_ids:
transport_data = EwTransport(id_server = user_data.id_server, poi = transport_id)
# check if one of the vehicles at the stop matches up with the line, the user wants to board
if transport_data.current_line == transport_line.id_line:
last_stop_poi = ewcfg.id_to_poi.get(transport_line.last_stop)
response = "Embarking on {}.".format(transport_line.str_name)
# schedule tasks for concurrent execution
message_task = asyncio.ensure_future(ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response)))
wait_task = asyncio.ensure_future(asyncio.sleep(5))
# Take control of the move for this player.
ewmap.move_counter += 1
move_current = ewutils.moves_active[cmd.message.author.id] = ewmap.move_counter
await message_task
await wait_task
# check if the user entered another movement command while waiting for the current one to be completed
if move_current == ewutils.moves_active[cmd.message.author.id]:
user_data = EwUser(member = cmd.message.author)
transport_data = EwTransport(id_server = user_data.id_server, poi = transport_id)
# check if the transport is still at the same stop
if transport_data.current_stop == user_data.poi:
user_data.poi = transport_data.poi
user_data.persist()
transport_poi = ewcfg.id_to_poi.get(transport_data.poi)
response = "You enter the {}.".format(transport_data.transport_type)
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
return await ewutils.send_message(cmd.client, ewutils.get_channel(cmd.message.server, transport_poi.channel), ewutils.formatMessage(cmd.message.author, response))
else:
response = "The {} starts moving just as you try to get on.".format(transport_data.transport_type)
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
response = "There is currently no vehicle following that line here."
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
else:
response = "No transport vehicles stop here. Try going to a subway station or a ferry port."
return await ewutils.send_message(cmd.client, cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))