async def rejuvenate(cmd):
user_data = EwUser(member=cmd.message.author)
if user_data.life_state == ewcfg.life_state_shambler and user_data.poi != ewcfg.poi_id_oozegardens:
response = "You lack the higher brain functions required to {}.".format(cmd.tokens[0])
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif user_data.life_state == ewcfg.life_state_shambler and user_data.poi == ewcfg.poi_id_oozegardens:
response = "You decide to change your ways and become one of the Garden Gankers in order to overthrow your old master."
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
await asyncio.sleep(5)
user_data = EwUser(member=cmd.message.author)
user_data.life_state = ewcfg.life_state_juvenile
#user_data.degradation = 0
# user_data.gvs_currency = 0
ewutils.moves_active[user_data.id_user] = 0
user_data.poi = ewcfg.poi_id_og_farms
user_data.persist()
client = ewutils.get_client()
server = client.get_guild(user_data.id_server)
member = server.get_member(user_data.id_user)
base_poi_channel = fe_utils.get_channel(cmd.message.guild, ewcfg.channel_og_farms)
response = "You enter into Atomic Forest inside the farms of Ooze Gardens and are sterilized of the Modelovirus. Hortisolis gives you a big hug and says he's glad you've overcome your desire for vengeance in pursuit of deposing Downpour."
await ewrolemgr.updateRoles(client=cmd.client, member=member)
return await fe_utils.send_message(cmd.client, base_poi_channel, fe_utils.formatMessage(cmd.message.author, response))
else:
pass
async def hailcab(cmd):
user_data = EwUser(member = cmd.message.author)
blockstate = EwGamestate(id_server=cmd.guild.id, id_state='blockparty')
poi = ''.join([i for i in blockstate.value if not i.isdigit()])
if poi == 'outsidethe':
poi = ewcfg.poi_id_711
if poi != user_data.poi:
response = "You can't hail a cab right now. All the cabbies are hiding for cover thanks to all the violence. Good job on that, by the way."
else:
if user_data.life_state in [ewcfg.life_state_enlisted, ewcfg.life_state_juvenile]:
if user_data.faction == ewcfg.faction_rowdys and user_data.life_state == ewcfg.life_state_enlisted:
dest = ewcfg.poi_id_rowdyroughhouse
elif user_data.faction == ewcfg.faction_killers and user_data.life_state == ewcfg.life_state_enlisted:
dest = ewcfg.poi_id_copkilltown
else:
dest = ewcfg.poi_id_juviesrow
await asyncio.sleep(5)
response = "**TAXI!** You shout into the crowd for a ride home. The drivers don't notice you're a miscreant, and pick you up without a second thought. They got nervous when you asked to return to your gang base, and forgot to ask for any fare. Nice!"
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
ewutils.moves_active[cmd.message.author.id] = 0
user_data.poi = dest
user_data.persist()
await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author)
return await user_data.move_inhabitants(id_poi=dest, visitor=user_data.id_user)
elif user_data.life_state == ewcfg.life_state_corpse:
response = "You're already dead. The cabbies unfortunately tend to avoid black people, so you should probably just float back to the sewers."
else:
response = "The cabbie looks confused. Why would a person like you need a cab?"
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def shamble(cmd):
user_data = EwUser(member=cmd.message.author)
if user_data.life_state != ewcfg.life_state_shambler and user_data.poi != ewcfg.poi_id_assaultflatsbeach:
response = "You have too many higher brain functions left to {}.".format(cmd.tokens[0])
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif user_data.life_state in [ewcfg.life_state_juvenile, ewcfg.life_state_enlisted] and user_data.poi == ewcfg.poi_id_assaultflatsbeach:
response = "You feel an overwhelming sympathy for the plight of the Shamblers and decide to join their ranks."
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
await asyncio.sleep(5)
user_data = EwUser(member=cmd.message.author)
user_data.life_state = ewcfg.life_state_shambler
#user_data.degradation = 100
ewutils.moves_active[user_data.id_user] = 0
user_data.poi = ewcfg.poi_id_nuclear_beach_edge
user_data.persist()
member = cmd.message.author
base_poi_channel = fe_utils.get_channel(cmd.message.guild, 'nuclear-beach-edge')
response = 'You arrive inside the facility and are injected with a unique strain of the Modelovirus. Not long after, a voice on the intercom chimes in.\n**"Welcome, {}. Welcome to Downpour Laboratories. It\'s safer here. Please treat all machines and facilities with respect, they are precious to our cause."**'.format(member.display_name)
await ewrolemgr.updateRoles(client=cmd.client, member=member)
return await fe_utils.send_message(cmd.client, base_poi_channel, fe_utils.formatMessage(cmd.message.author, response))
else:
pass
async def kick(id_server):
# Gets data for all living players from the database
all_living_players = bknd_core.execute_sql_query("SELECT {poi}, {id_user} FROM users WHERE id_server = %s AND {life_state} > 0 AND {time_last_action} < %s".format(
poi=ewcfg.col_poi,
id_user=ewcfg.col_id_user,
time_last_action=ewcfg.col_time_last_action,
life_state=ewcfg.col_life_state
), (
id_server,
(int(time.time()) - ewcfg.time_kickout)
))
client = ewutils.get_client()
for player in all_living_players:
try:
poi = poi_static.id_to_poi[player[0]]
id_user = player[1]
# checks if the player should be kicked from the subzone and kicks them if they should.
if poi.is_subzone and poi.id_poi not in [ewcfg.poi_id_thesphere, ewcfg.poi_id_thebreakroom]:
# Don't load the user until we know that we need to
user_data = EwUser(id_user=id_user, id_server=id_server)
# Some subzones could potentially have multiple mother districts.
# Make sure to get one that's accessible before attempting a proper kickout.
mother_district_chosen = random.choice(poi.mother_districts)
if inaccessible(user_data=user_data, poi=poi_static.id_to_poi.get(mother_district_chosen)):
# If the randomly chosen mother district is inaccessible, make one more attempt.
mother_district_chosen = random.choice(poi.mother_districts)
else:
pass
if not inaccessible(user_data=user_data, poi=poi_static.id_to_poi.get(mother_district_chosen)):
if user_data.life_state not in [ewcfg.life_state_kingpin, ewcfg.life_state_lucky, ewcfg.life_state_executive] and user_data.id_user != 799933061080416266:
server = ewcfg.server_list[id_server]
member_object = server.get_member(id_user)
user_data.poi = mother_district_chosen
user_data.time_lastenter = int(time.time())
user_data.persist()
await ewrolemgr.updateRoles(client=client, member=member_object)
await user_data.move_inhabitants(id_poi=mother_district_chosen)
mother_district_channel = fe_utils.get_channel(server, poi_static.id_to_poi[mother_district_chosen].channel)
response = "You have been kicked out for loitering! You can only stay in a sub-zone and twiddle your thumbs for 1 hour at a time."
await fe_utils.send_message(client, mother_district_channel, fe_utils.formatMessage(member_object, response))
except:
ewutils.logMsg('failed to move inactive player out of subzone with poi {}: {}'.format(player[0], player[1]))
async def toss_squatters(user_id=None, server_id=None, keepKeys=False):
player_info = EwPlayer(id_user=user_id)
apt_info = EwApartment(id_user=user_id, id_server=server_id)
client = ewutils.get_client()
server = client.get_guild(server_id)
member_data = server.get_member(player_info.id_user)
if player_info.id_server != None and member_data != None:
try:
conn_info = bknd_core.databaseConnect()
conn = conn_info.get('conn')
cursor = conn.cursor()
client = ewutils.get_client()
# get all players visiting an evicted apartment and kick them out
cursor.execute(
"SELECT {} FROM users WHERE {} = %s AND {} = %s".format(
ewcfg.col_id_user,
ewcfg.col_visiting,
ewcfg.col_id_server,
), (
member_data.id,
server_id,
))
squatters = cursor.fetchall()
key_1 = EwItem(id_item=apt_info.key_1).id_owner
key_2 = EwItem(id_item=apt_info.key_2).id_owner
for squatter in squatters:
sqt_data = EwUser(id_user=squatter[0],
id_server=player_info.id_server)
if keepKeys and (sqt_data.id_user == key_1
or sqt_data.id_user == key_2):
pass
else:
server = ewcfg.server_list[sqt_data.id_server]
member_object = server.get_member(squatter[0])
sqt_data.poi = sqt_data.poi[3:] if sqt_data.poi[
3:] in poi_static.id_to_poi.keys() else sqt_data.poi
sqt_data.visiting = ewcfg.location_id_empty
sqt_data.persist()
await ewrolemgr.updateRoles(client=client,
member=member_object)
finally:
# Clean up the database handles.
cursor.close()
bknd_core.databaseClose(conn_info)
async def beam_me_up(cmd):
user_data = EwUser(member=cmd.message.author)
protected = False
cosmetics = bknd_item.inventory(id_user=user_data.id_user,
id_server=cmd.guild.id,
item_type_filter=ewcfg.it_cosmetic)
for cosmetic in cosmetics:
cosmetic_data = EwItem(id_item=cosmetic.get('id_item'))
print(cosmetic_data.item_props)
if cosmetic_data.item_props.get('id_cosmetic') == 'skinsuit':
if cosmetic_data.item_props.get('adorned') == 'true':
protected = True
poi_sought = poi_static.id_to_poi.get(user_data.poi)
shipstate = EwGamestate(id_server=user_data.id_server,
id_state='shipstate')
if not protected:
response = "Why would aliens abduct you? What makes you so special?"
elif poi_sought.id_poi == 'ufoufo':
response = 'You\'re already in here.'
elif poi_sought.id_poi != ewcfg.poi_id_west_outskirts:
response = "Hey, get a bit closer. The ship's in the West Outskirts. Beam up power doesn't grow on trees, you know."
elif shipstate.bit == 1:
response = 'The ship\'s on the ground right now, it can\'t beam shit.'
else:
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(
cmd.message.author,
"You are being abducted by aliens. The ship is 20 seconds away."
))
ewutils.active_restrictions[user_data.id_user] = 2
await asyncio.sleep(20)
ewutils.active_restrictions[user_data.id_user] = 0
ewutils.moves_active[cmd.message.author.id] = 0
user_data.poi = 'ufoufo'
user_data.persist()
await ewrolemgr.updateRoles(client=ewutils.get_client(),
member=cmd.message.author)
await user_data.move_inhabitants(id_poi='ufoufo')
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
async def clowncar(cmd): #shoves everyone not there into JR or the sewers
if not cmd.message.author.guild_permissions.administrator:
return
id_server = cmd.guild.id
server = ewcfg.server_list[cmd.guild.id]
gellphones = itm_utils.find_item_all(item_search=ewcfg.item_id_gellphone,
id_server=id_server,
item_type_filter=ewcfg.it_item)
for phone in gellphones:
phone_data = EwItem(id_item=phone.get('id_item'))
phone_data.item_props['gellphoneactive'] = 'false'
phone_data.persist()
if phone_data.id_owner.isnumeric() and int(phone_data.id_owner) > 0:
print(phone_data.id_owner)
member_object = server.get_member(int(phone_data.id_owner))
if member_object is None:
continue
user_data = EwUser(member=member_object)
print('{}{}'.format('clowning:', user_data.id_user))
user_data.poi = 'juviesrow'
user_data.persist()
await ewrolemgr.updateRoles(client=cmd.client,
member=member_object)
if id_server != None:
try:
selection = bknd_core.execute_sql_query(
"SELECT {id_user} FROM users WHERE id_server = %s AND {poi} NOT IN('juviesrow', 'thesewers', 'rowdyroughhouse', 'copkilltown')"
.format(id_user=ewcfg.col_id_user,
poi=ewcfg.col_poi), ([str(id_server)]))
bknd_core.execute_sql_query(
"UPDATE users SET {poi} = %s WHERE id_server = %s AND {poi} NOT IN('juviesrow', 'thesewers', 'rowdyroughhouse', 'copkilltown')"
.format(poi=ewcfg.col_poi), ('juviesrow', [str(id_server)]))
iterator = 0
for member in selection:
iterator += 1
if iterator % 20 == 0:
await asyncio.sleep(5)
member_object = server.get_member(member[0])
await ewrolemgr.updateRoles(client=cmd.client,
member=member_object)
except:
ewutils.logMsg('server {}: failed to clowncar.'.format(
cmd.message.guild.id, cmd.message.author.id))
async def pardon(cmd):
user_data = EwUser(member=cmd.message.author)
if user_data.life_state != ewcfg.life_state_kingpin and user_data.life_state != ewcfg.life_state_executive and not cmd.message.author.guild_permissions.administrator:
response = "Only the Rowdy F****r {} and the Cop Killer {} can do that.".format(
ewcfg.emote_rowdyfucker, ewcfg.emote_copkiller,
ewcfg.emote_slimecorp)
else:
member = None
if cmd.mentions_count == 1:
member = cmd.mentions[0]
if member.id == cmd.message.author.id:
member = None
if member == None:
response = "Who?"
else:
member_data = EwUser(member=member)
member_data.unban(faction=user_data.faction)
if member_data.faction == "":
response = "{} has been allowed to join the {} again.".format(
member.display_name, user_data.faction)
else:
faction_old = member_data.faction
member_data.faction = ""
if member_data.life_state == ewcfg.life_state_enlisted:
member_data.life_state = ewcfg.life_state_juvenile
member_data.weapon = -1
member_data.sidearm = -1
response = "{} has been released from their association with the {}.".format(
member.display_name, faction_old)
member_poi = poi_static.id_to_poi.get(member_data.poi)
if move_utils.inaccessible(user_data=member_data, poi=member_poi):
member_data.poi = ewcfg.poi_id_downtown
member_data.persist()
await ewrolemgr.updateRoles(client=cmd.client, member=member)
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
async def begin_tutorial(member):
user_data = EwUser(member=member)
dungeonutils.user_to_tutorial_state[user_data.id_user] = 0
scene = poi_static.dungeon_tutorial[0]
if scene.poi != None:
user_data.poi = scene.poi
if scene.life_state != None:
user_data.life_state = scene.life_state
user_data.persist()
await ewrolemgr.updateRoles(client=ewutils.get_client(), member=member)
response = format_tutorial_response(scene)
poi_def = poi_static.id_to_poi.get(user_data.poi)
channels = [poi_def.channel]
return await fe_utils.post_in_channels(
member.guild.id, fe_utils.formatMessage(member, response), channels)
async def banish(cmd):
user_data = EwUser(member=cmd.message.author)
if user_data.life_state != ewcfg.life_state_kingpin and user_data.life_state != ewcfg.life_state_executive and not cmd.message.author.guild_permissions.administrator:
response = "Only the Rowdy F****r {} and the Cop Killer {} can do that.".format(
ewcfg.emote_rowdyfucker, ewcfg.emote_copkiller)
else:
member = None
if cmd.mentions_count == 1:
member = cmd.mentions[0]
# >:]
# if member.id == cmd.message.author.id:
# member = None
if member == None:
response = "Who?"
else:
member_data = EwUser(member=member)
member_data.ban(faction=user_data.faction)
member_data.unvouch(faction=user_data.faction)
if member_data.faction == user_data.faction:
member_data.faction = ""
if member_data.life_state == ewcfg.life_state_enlisted:
member_data.life_state = ewcfg.life_state_juvenile
member_poi = poi_static.id_to_poi.get(member_data.poi)
if move_utils.inaccessible(user_data=member_data, poi=member_poi):
member_data.poi = ewcfg.poi_id_downtown
member_data.persist()
response = "{} has been banned from enlisting in the {}".format(
member.display_name, user_data.faction)
await ewrolemgr.updateRoles(client=cmd.client, member=member)
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
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 fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.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 = 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 fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
# can only disembark when you're on a transport vehicle
elif user_data.poi in poi_static.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 = poi_static.id_to_poi.get(transport_data.current_stop)
# if stop_poi.is_subzone:
# stop_poi = poi_static.id_to_poi.get(stop_poi.mother_district)
if move_utils.inaccessible(user_data=user_data, poi=stop_poi):
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You're not allowed to go there (bitch)."))
# schedule tasks for concurrent execution
message_task = asyncio.ensure_future(fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)))
wait_task = asyncio.ensure_future(asyncio.sleep(ewcfg.time_embark))
# Take control of the move for this player.
move_utils.move_counter += 1
move_current = ewutils.moves_active[cmd.message.author.id] = move_utils.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 = poi_static.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 = fe_utils.formatMessage(cmd.message.author, response)
return await fe_utils.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 = fe_utils.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 or ewcfg.mutation_id_airlock 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 = fe_utils.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 = poi_static.id_to_poi.get(stop_poi.mother_district)
if move_utils.inaccessible(user_data=user_data, poi=stop_poi):
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.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 fe_utils.send_message(cmd.client, fe_utils.get_channel(cmd.guild, stop_poi.channel), fe_utils.formatMessage(cmd.message.author, response))
# SWILLDERMUK
await prank_utils.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 fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def abduct(cmd):
user_data = EwUser(member=cmd.message.author)
item_sought = bknd_item.find_item(item_search='batterypack', id_user=cmd.message.author.id, id_server=cmd.guild.id)
protected = False
cosmetics = bknd_item.inventory(id_user=user_data.id_user, id_server=cmd.guild.id,
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') == 'skinsuit':
if cosmetic_data.item_props.get('adorned') == 'true':
protected = True
shipstate = EwGamestate(id_server=user_data.id_server, id_state='shipstate')
if user_data.poi != 'ufoufo':
response = "Abduct what, dumbass? My patience?"
elif not protected:
response = "The aliens aren't gonna let you start the ship. You're basically their captive now."
elif not ewcfg.dh_active or ewcfg.dh_stage != 3:
response = "Wait, your alien espionage is waaaay out of season."
elif cmd.mentions_count == 0:
response = "Abduct who?"
elif cmd.mentions_count > 1:
response = "One victim at a time, please."
elif shipstate.bit == 1:
response = 'The ship\'s on the ground right now, it can\'t reach you.'
else:
if item_sought:
target_data = EwUser(member = cmd.mentions[0])
target_poi = poi_static.id_to_poi.get(target_data.poi)
target_channel = fe_utils.get_channel(cmd.message.guild, target_poi.channel)
if target_poi.id_poi == 'blackpond' or (
not target_poi.is_district and not target_poi.is_outskirts and not target_poi.is_pier and target_poi.id_poi not in [
ewcfg.poi_id_slimesendcliffs, ewcfg.poi_id_ferry, ewcfg.poi_id_sodafountain,
ewcfg.poi_id_stockexchange, ewcfg.poi_id_ab_farms, ewcfg.poi_id_og_farms, ewcfg.poi_id_jr_farms]):
response = "The tractor beam on this ship sucks. You can't really see indoors."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif target_poi.id_poi in [ewcfg.poi_id_rowdyroughhouse, ewcfg.poi_id_copkilltown]:
response = "Don't do that."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
bknd_item.item_delete(id_item=item_sought.get('id_item'))
ewutils.moves_active[target_data.id_user] = 0
response = 'You plug in your battery pack and begin to abduct {} They\'re 20 seconds away.'.format(cmd.mentions[0].display_name)
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
await fe_utils.send_message(cmd.client, target_channel, fe_utils.formatMessage(cmd.mentions[0], "You are being abducted by aliens. The ship is 20 seconds away."))
ewutils.active_restrictions[target_data.id_user] = 2
await asyncio.sleep(20)
ewutils.active_restrictions[target_data.id_user] = 0
ewutils.moves_active[cmd.message.author.id] = 0
target_data.poi = 'ufoufo'
user_data.persist()
target_data.persist()
await ewrolemgr.updateRoles(client=ewutils.get_client(), member=cmd.mentions[0])
await target_data.move_inhabitants(id_poi='ufoufo')
else:
response = "The going energy cost for abduction is pretty expensive these days. You better have a battery pack before you do something like that."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def slap(cmd):
if ewutils.channel_name_is_poi(cmd.message.channel.name) == False:
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0])))
time_now = int(time.time())
user_data = EwUser(member=cmd.message.author)
user_poi = poi_static.id_to_poi.get(user_data.poi)
target_data = -1
mutations = user_data.get_mutations()
resp_cont = EwResponseContainer(id_server=cmd.guild.id)
if cmd.tokens_count < 3:
response = "You'll need to specify who and where you're slapping. Try !slap <target> <location>."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
dest_poi = cmd.tokens[2].lower()
dest_poi_obj = poi_static.id_to_poi.get(dest_poi)
response = ""
if cmd.mentions_count == 0:
response = "Who are you slapping?"
elif cmd.mentions_count > 1:
response = "Nobody's that good at slapping. Do it to one person at a time."
else:
target_data = EwUser(member=cmd.mentions[0])
if response != "":
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
if target_data.poi != user_data.poi:
response = "Not right now. You can't slap what you can't see."
elif user_data.id_user == target_data.id_user:
response = "Stop hitting yourself."
elif ewutils.active_restrictions.get(target_data.id_user) != None and ewutils.active_restrictions.get(target_data.id_user) > 0:
response = "They're in the middle of something, be patient."
elif target_data.life_state == ewcfg.life_state_corpse:
response = "You give {} a good whack. They're a ghost though, so your hand passes straight through.".format(cmd.mentions[0].display_name)
elif ewcfg.mutation_id_ditchslap not in mutations:
response = "You wind up your good arm and tacoom {} hard in the {}. The air gets knocked out of them but they stay firmly in place.".format(cmd.mentions[0].display_name, random.choice(['face', 'face', 'face', 'ass']))
else:
mutation_data = EwMutation(id_mutation=ewcfg.mutation_id_ditchslap, id_user=cmd.message.author.id, id_server=cmd.message.guild.id)
if len(mutation_data.data) > 0:
time_lastuse = int(mutation_data.data)
else:
time_lastuse = 0
if dest_poi_obj.id_poi not in user_poi.neighbors.keys():
response = "You can't hit them that far."
elif move_utils.inaccessible(user_data=target_data, poi=dest_poi_obj):
response = "That place is locked up good. You can't get a good launch angle to send them there."
# elif time_lastuse + 180 * 60 > time_now:
# response = "Your arm is spent from the last time you obliterated someone. Try again in {} minutes.".format(math.ceil((time_lastuse + 180*60 - time_now)/60))
elif user_data.faction != target_data.faction:
response = "You try to slap {}, but they realize what you're doing and jump back. Welp, back to the drawing board.".format(cmd.mentions[0].display_name)
elif user_poi.id_poi in [ewcfg.poi_id_rowdyroughhouse, ewcfg.poi_id_copkilltown] or user_poi.is_apartment:
response = "They're currently in their room. You'd have to carry {} out of it to slap them, which would be gay.".format(cmd.mentions[0].display_name)
elif ewcfg.status_slapped_id in target_data.getStatusEffects():
response = "Don't turn this into domestic abuse now. Can't you see they're still reeling from the last time?"
elif (ewutils.clenched.get(target_data.id_user) == None or ewutils.clenched.get(target_data.id_user) == 0) and (user_poi.is_subzone or user_poi.is_district):
response = "You wind up your slappin' hand and take a swing, but {} is all relaxed and you can't get a good angle. They end up flying into the wall. Better not touch people who aren't prepared to get hit...".format(cmd.mentions[0].display_name)
else:
response = "You wind up your slap. This one's gonna hurt. Steady as she goes...WHAM! {} is sent flying helplessly into {}!".format(cmd.mentions[0].display_name, dest_poi_obj.str_name)
target_data.applyStatus(id_status=ewcfg.status_slapped_id)
dm_response = "WHAP! {} smacked you into {}!".format(cmd.message.author.display_name, dest_poi_obj.str_name)
target_response = "**CRAAAAAAAAAAAASH!** You arrive in {}!".format(dest_poi_obj.str_name)
ewutils.moves_active[cmd.message.author.id] = 0
target_data.poi = dest_poi_obj.id_poi
user_data.time_lastenter = int(time.time())
mutation_data.data = str(time_now)
mutation_data.persist()
if target_data.poi == ewcfg.poi_id_thesewers:
target_data.die(cause=ewcfg.cause_suicide)
target_response += " But you hit your head really hard! Your precious little dome explodes into bits and pieces and you die!"
user_data.persist()
await ewrolemgr.updateRoles(client=ewutils.get_client(), member=cmd.mentions[0], new_poi=target_data.poi)
target_data.persist()
await user_data.move_inhabitants(id_poi=dest_poi_obj.id_poi)
await prank_utils.activate_trap_items(dest_poi_obj.id_poi, user_data.id_server, target_data.id_user)
await fe_utils.send_message(cmd.client, cmd.mentions[0], fe_utils.formatMessage(cmd.mentions[0], dm_response))
await fe_utils.send_message(cmd.client, fe_utils.get_channel(server=cmd.mentions[0].guild, channel_name=dest_poi_obj.channel), fe_utils.formatMessage(cmd.mentions[0], target_response))
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def revive(cmd, player_auto=None):
time_now = int(time.time())
response = ""
if cmd.message.channel.name != ewcfg.channel_endlesswar and cmd.message.channel.name != ewcfg.channel_sewers and player_auto is None:
response = "Come to me. I hunger. #{}.".format(ewcfg.channel_sewers)
else:
if player_auto:
player_data = EwUser(id_server=cmd.guild.id, id_user=player_auto)
else:
player_data = EwUser(member=cmd.message.author)
# time_until_revive = (player_data.time_lastdeath + 600) - time_now
time_until_revive = (player_data.time_lastdeath) - time_now
if time_until_revive > 0 and player_auto is None:
response = "ENDLESS WAR is not ready to {} you yet ({}s).".format(
cmd.tokens[0], time_until_revive)
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
slimeoid = EwSlimeoid(member=cmd.message.author)
if player_data.life_state == ewcfg.life_state_corpse:
market_data = EwMarket(id_server=cmd.guild.id)
# Endless War collects his fee.
# fee = (player_data.slimecoin / 10)
# player_data.change_slimecoin(n = -fee, coinsource = ewcfg.coinsource_revival)
# market_data.slimes_revivefee += fee
# player_data.busted = False
# Preserve negaslime
if player_data.slimes < 0:
# market_data.negaslime += player_data.slimes
player_data.change_slimes(n=-player_data.slimes) # set to 0
# reset slimelevel to zero
player_data.slimelevel = 0
# Set time of last revive. This used to provied spawn protection, but currently isn't used.
player_data.time_lastrevive = time_now
if False: #player_data.degradation >= 100:
player_data.life_state = ewcfg.life_state_shambler
player_data.change_slimes(n=0.5 * ewcfg.slimes_shambler)
player_data.trauma = ""
poi_death = poi_static.id_to_poi.get(player_data.poi_death)
if move_utils.inaccessible(poi=poi_death,
user_data=player_data):
player_data.poi = ewcfg.poi_id_endlesswar
else:
player_data.poi = poi_death.id_poi
else:
# Set life state. This is what determines whether the player is actually alive.
player_data.life_state = ewcfg.life_state_juvenile
# Give player some initial slimes.
player_data.change_slimes(n=ewcfg.slimes_onrevive)
# Get the player out of the sewers.
player_data.poi = ewcfg.poi_id_endlesswar
# Give newly spawned juvies a foul odour
player_data.applyStatus(ewcfg.status_repelled_id)
player_data.persist()
market_data.persist()
# Shower every district in the city with slime from the sewers.
sewer_data = EwDistrict(district=ewcfg.poi_id_thesewers,
id_server=cmd.guild.id)
# the amount of slime showered is divided equally amongst the districts
districts_amount = len(poi_static.capturable_districts)
geyser_amount = int(0.5 * sewer_data.slimes / districts_amount)
# Get a list of all the districts
for poi in poi_static.capturable_districts:
district_data = EwDistrict(district=poi,
id_server=cmd.guild.id)
district_data.change_slimes(n=geyser_amount)
sewer_data.change_slimes(n=-1 * geyser_amount)
district_data.persist()
sewer_data.persist()
sewer_inv = bknd_item.inventory(id_user=sewer_data.name,
id_server=sewer_data.id_server)
for item in sewer_inv:
district = ewcfg.poi_id_slimesea
if random.random() < 0.5:
district = random.choice(poi_static.capturable_districts)
bknd_item.give_item(id_item=item.get("id_item"),
id_user=district,
id_server=sewer_data.id_server)
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
response = '{slime4} Geysers of fresh slime erupt from every manhole in the city, showering their surrounding districts. {slime4} {name} has been reborn in slime. {slime4}'.format(
slime4=ewcfg.emote_slime4,
name=cmd.message.author.display_name)
else:
response = 'You\'re not dead just yet.'
# deathreport = "You were {} by {}. {}".format(kill_descriptor, cmd.message.author.display_name, ewcfg.emote_slimeskull)
# deathreport = "{} ".format(ewcfg.emote_slimeskull) + fe_utils.formatMessage(member, deathreport)
if slimeoid.life_state == ewcfg.slimeoid_state_active:
reunite = ""
brain = sl_static.brain_map.get(slimeoid.ai)
reunite += brain.str_revive.format(slimeoid_name=slimeoid.name)
new_poi = poi_static.id_to_poi.get(player_data.poi)
revivechannel = fe_utils.get_channel(cmd.guild, new_poi.channel)
reunite = fe_utils.formatMessage(cmd.message.author, reunite)
await fe_utils.send_message(cmd.client, revivechannel, reunite)
# Send the response to the player.
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
async def rent_time(id_server=None):
try:
conn_info = bknd_core.databaseConnect()
conn = conn_info.get('conn')
cursor = conn.cursor()
client = ewutils.get_client()
if id_server != None:
# get all players with apartments. If a player is evicted, thir rent is 0, so this will not affect any bystanders.
cursor.execute(
"SELECT apartment.rent, users.id_user FROM users INNER JOIN apartment ON users.id_user=apartment.id_user WHERE users.id_server = %s AND apartment.id_server = %s AND apartment.rent > 0"
.format(), (
id_server,
id_server,
))
landowners = cursor.fetchall()
for landowner in landowners:
owner_id_user = int(landowner[1])
owner_rent_price = landowner[0]
user_data = EwUser(id_user=owner_id_user, id_server=id_server)
user_poi = poi_static.id_to_poi.get(user_data.poi)
poi = poi_static.id_to_poi.get(user_data.apt_zone)
if owner_rent_price > user_data.slimecoin:
if (user_poi.is_apartment
and user_data.visiting == ewcfg.location_id_empty):
user_data.poi = user_data.apt_zone # toss out player
user_data.persist()
server = ewcfg.server_list[user_data.id_server]
member_object = server.get_member(owner_id_user)
await ewrolemgr.updateRoles(client=client,
member=member_object)
player = EwPlayer(id_user=owner_id_user)
response = "{} just got evicted. Point and laugh, everyone.".format(
player.display_name)
await fe_utils.send_message(
client, fe_utils.get_channel(server, poi.channel),
response)
user_data = EwUser(id_user=owner_id_user,
id_server=id_server)
user_apt = EwApartment(id_user=owner_id_user,
id_server=id_server)
poi = poi_static.id_to_poi.get(user_data.apt_zone)
toss_items(id_user=str(user_data.id_user) + 'closet',
id_server=user_data.id_server,
poi=poi)
toss_items(id_user=str(user_data.id_user) + 'fridge',
id_server=user_data.id_server,
poi=poi)
toss_items(id_user=str(user_data.id_user) + 'decorate',
id_server=user_data.id_server,
poi=poi)
user_data.apt_zone = ewcfg.location_id_empty
user_data.persist()
user_apt.rent = 0
user_apt.poi = " "
user_apt.persist()
await toss_squatters(user_id=user_data.id_user,
server_id=id_server)
else:
user_data.change_slimecoin(
n=-owner_rent_price,
coinsource=ewcfg.coinsource_spending)
user_data.persist()
finally:
cursor.close()
bknd_core.databaseClose(conn_info)
async def defect(cmd):
accepted = False
member = cmd.message.author
modauth = 0
response = "You feel...traitor-ish today. Hey mods, any takers? Let them free, !yes or !no?"
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
try:
message = await cmd.client.wait_for(
'message',
timeout=30,
check=lambda message: 0 < ewrolemgr.checkClearance(
member=message.author) <= 4 and message.content.lower(
) in [ewcfg.cmd_yes, ewcfg.cmd_no])
if message != None:
if message.content.lower() == ewcfg.cmd_yes:
accepted = True
modauth = message.author
if message.content.lower() == ewcfg.cmd_no:
accepted = False
except Exception as e:
print(e)
accepted = False
if not accepted:
response = "Well if it isn't the boy who cried backstab. Guess you won't be going anywhere."
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
else:
member_data = EwUser(member=cmd.message.author)
mod_data = EwUser(member=modauth)
member_data.unban(faction=mod_data.faction)
if member_data.faction == "":
response = "{} has been allowed to join the {} again.".format(
member.display_name, mod_data.faction)
else:
faction_old = member_data.faction
member_data.faction = ""
if member_data.life_state == ewcfg.life_state_enlisted:
member_data.life_state = ewcfg.life_state_juvenile
member_data.weapon = -1
member_data.sidearm = -1
response = "{} has been released from their association with the {}.".format(
member.display_name, faction_old)
member_poi = poi_static.id_to_poi.get(member_data.poi)
if move_utils.inaccessible(user_data=member_data, poi=member_poi):
member_data.poi = ewcfg.poi_id_downtown
member_data.persist()
await ewrolemgr.updateRoles(client=cmd.client, member=member)
leak_channel = fe_utils.get_channel(server=cmd.guild,
channel_name='squickyleaks')
await fe_utils.send_message(
cmd.client, leak_channel,
"{}: Let {} defect.".format(modauth.display_name,
member.display_name))
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
async def usekey(cmd, owner_user):
owner_apartment = EwApartment(id_user=owner_user.id_user,
id_server=cmd.guild.id)
user_data = EwUser(member=cmd.message.author)
poi = poi_static.id_to_poi.get(user_data.poi)
poi_dest = poi_static.id_to_poi.get(
ewcfg.poi_id_apt + owner_apartment.poi
) # there isn't an easy way to change this, apologies for being a little hacky
inv = bknd_item.inventory(id_user=cmd.message.author.id,
id_server=cmd.guild.id)
key = None
for item_inv in inv:
if "key to" in item_inv.get('name'):
item_key_check = EwItem(id_item=item_inv.get('id_item'))
if item_key_check.item_props.get("houseID") == str(
owner_user.id_user):
key = item_key_check
if ewutils.channel_name_is_poi(cmd.message.channel.name) == False:
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(
cmd.message.author,
"You must enter an apartment in a zone's channel.".format(
cmd.tokens[0])))
elif key == None:
response = "You don't have a key for their apartment."
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
elif owner_apartment.apt_class == ewcfg.property_class_c or (
owner_apartment.apt_class
in [ewcfg.property_class_a, ewcfg.property_class_b]
and key.id_item == owner_apartment.key_2):
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(
cmd.message.author,
"Your key's not working at this new flat. Your roomates must've forgotten to upgrade apartments. Congratulations on the homelessness by the way."
.format(cmd.tokens[0])))
elif owner_apartment.poi != poi.id_poi:
response = "Your key doesn't match an apartment here."
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, response))
else:
move_utils.move_counter += 1
move_current = ewutils.moves_active[
cmd.message.author.id] = move_utils.move_counter
await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author,
"You start walking toward the apartment."))
await asyncio.sleep(20)
if move_current == ewutils.moves_active[cmd.message.author.id]:
user_data = EwUser(member=cmd.message.author)
user_data.poi = poi_dest.id_poi
user_data.visiting = owner_user.id_user
user_data.persist()
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
response = "You're in the apartment."
try:
await fe_utils.send_message(cmd.client, cmd.message.author,
response)
except:
await fe_utils.send_message(
cmd.client,
fe_utils.get_channel(cmd.guild, poi_dest.channel),
fe_utils.formatMessage(cmd.message.author, response))
async def tutorial_cmd(cmd):
user_data = EwUser(member=cmd.message.author)
client = cmd.client
if user_data.poi not in poi_static.tutorial_pois:
return
if user_data.id_user not in dungeonutils.user_to_tutorial_state:
return await dungeon_utils.begin_tutorial(cmd.message.author)
tutorial_state = dungeonutils.user_to_tutorial_state.get(user_data.id_user)
tutorial_scene = poi_static.dungeon_tutorial[tutorial_state]
cmd_content = cmd.message.content[1:].lower()
# Administrators can skip the tutorial
if cmd_content == "skiptutorial" and cmd.message.author.guild_permissions.administrator:
new_state = 20
dungeonutils.user_to_tutorial_state[user_data.id_user] = new_state
scene = poi_static.dungeon_tutorial[new_state]
if scene.poi != None:
user_data.poi = scene.poi
if scene.life_state != None:
user_data.life_state = scene.life_state
user_data.persist()
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
response = dungeon_utils.format_tutorial_response(scene)
poi_def = poi_static.id_to_poi.get(user_data.poi)
channels = [poi_def.channel]
return await fe_utils.post_in_channels(
cmd.guild.id, fe_utils.formatMessage(cmd.message.author, response),
channels)
if cmd_content in tutorial_scene.options:
new_state = tutorial_scene.options.get(cmd_content)
dungeonutils.user_to_tutorial_state[user_data.id_user] = new_state
scene = poi_static.dungeon_tutorial[new_state]
if scene.poi != None:
user_data.poi = scene.poi
if scene.life_state != None:
user_data.life_state = scene.life_state
user_data.persist()
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
response = dungeon_utils.format_tutorial_response(scene)
poi_def = poi_static.id_to_poi.get(user_data.poi)
channels = [poi_def.channel]
return await fe_utils.post_in_channels(
cmd.guild.id, fe_utils.formatMessage(cmd.message.author, response),
channels)
else:
""" couldn't process the command. bail out!! """
""" bot rule 0: be cute """
randint = random.randint(1, 3)
msg_mistake = "ENDLESS WAR is growing frustrated."
if randint == 2:
msg_mistake = "ENDLESS WAR denies you his favor."
elif randint == 3:
msg_mistake = "ENDLESS WAR pays you no mind."
msg = await fe_utils.send_message(client, cmd.message.channel,
msg_mistake)
await asyncio.sleep(2)
try:
await msg.delete()
pass
except:
pass
# response = dungeon_utils.format_tutorial_response(tutorial_scene)
# return await fe_utils.send_message(client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
return
async def embark(cmd):
# can only use movement commands in location channels
if ewutils.channel_name_is_poi(cmd.message.channel.name) == False:
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0])))
user_data = EwUser(member=cmd.message.author)
poi = poi_static.id_to_poi.get(user_data.poi)
district_data = EwDistrict(district=poi.id_poi, id_server=cmd.guild.id)
if district_data.is_degraded():
response = "{} has been degraded by shamblers. You can't {} here anymore.".format(poi.str_name, cmd.tokens[0])
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
response = ""
if ewutils.active_restrictions.get(user_data.id_user) != None and ewutils.active_restrictions.get(user_data.id_user) > 0:
response = "You can't do that right now."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
if user_data.get_inhabitee():
# prevent ghosts currently inhabiting other players from moving on their own
response = "You might want to **{}** of the poor soul you've been tormenting first.".format(ewcfg.cmd_letgo)
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
# poi = ewmap.fetch_poi_if_coordless(cmd.message.channel.name)
# must be at a transport stop to enter a transport
if poi != None and poi.id_poi in poi_static.transport_stops:
transport_ids = get_transports_at_stop(id_server=user_data.id_server, stop=poi.id_poi)
# can't embark, when there's no vehicles to embark on
if len(transport_ids) == 0:
response = "There are currently no transport vehicles to embark on here."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.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 fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "Which transport line?"))
transport_line = poi_static.id_to_transport_line.get(target_name)
# report failure, if an invalid argument was given
if transport_line == None:
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.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:
ticket = None
# TODO remove after double halloween
# user_data = EwUser(member = cmd.message.author)
# if user_data.poi in [ewcfg.poi_id_dt_subway_station, ewcfg.poi_id_rr_subway_station, ewcfg.poi_id_jr_subway_station]:
# if transport_line.id_line in [ewcfg.transport_line_subway_white_eastbound, ewcfg.transport_line_subway_white_westbound]:
# ticket = bknd_item.find_item(item_search=ewcfg.item_id_whitelineticket, id_user=cmd.message.author.id, id_server=cmd.message.guild.id)
# if ticket is None:
# response = "You need a ticket to embark on the White Line."
# return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
last_stop_poi = poi_static.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(fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)))
wait_task = asyncio.ensure_future(asyncio.sleep(ewcfg.time_embark))
# Take control of the move for this player.
move_utils.move_counter += 1
move_current = ewutils.moves_active[cmd.message.author.id] = move_utils.move_counter
await message_task
await wait_task
# check if the user entered another movement command while waiting for the current one to be completed
if move_current == ewutils.moves_active[cmd.message.author.id]:
user_data = EwUser(member=cmd.message.author)
transport_data = EwTransport(id_server=user_data.id_server, poi=transport_id)
# check if the transport is still at the same stop
if transport_data.current_stop == poi.id_poi:
user_data.poi = transport_data.poi
user_data.persist()
transport_poi = poi_static.id_to_poi.get(transport_data.poi)
response = "You enter the {}.".format(transport_data.transport_type)
if ticket is not None:
bknd_item.item_delete(ticket.get("id_item"))
await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author)
await user_data.move_inhabitants(id_poi=transport_data.poi)
return await fe_utils.send_message(cmd.client, fe_utils.get_channel(cmd.guild, transport_poi.channel), fe_utils.formatMessage(cmd.message.author, response))
else:
response = "The {} starts moving just as you try to get on.".format(transport_data.transport_type)
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
response = "There is currently no vehicle following that line here."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
else:
response = "No transport vehicles stop here. Try going to a subway station or a ferry port."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
