async def shakeoff(cmd):
user_data = EwUser(member=cmd.message.author)
if cmd.mentions_count == 0:
response = "God knows there are like a million third eyes floating around. You'll have to specify whose you're looking for."
elif cmd.mentions_count > 1:
response = "You're not that good at finding private eyes. Look for one at a time."
else:
target_data = EwUser(member=cmd.mentions[0])
try:
bknd_core.execute_sql_query(
"UPDATE mutations SET {data} = %s WHERE {id_server} = %s AND {mutation} = %s and {id_user} = %s;".format(
data=ewcfg.col_mutation_data,
id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user,
mutation=ewcfg.col_id_mutation,
), (
"",
user_data.id_server,
ewcfg.mutation_id_oneeyeopen,
target_data.id_user
))
response = "You search high and low for {}'s third eye, shouting a bit to give it a good scare. If it was stalking you it certainly isn't now.".format(cmd.mentions[0].display_name)
except:
ewutils.logMsg("Failed to undo tracking for {}.".format(user_data.id_user))
response = ""
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def one_eye_dm(id_user = None, id_server = None, poi = None):
poi_obj = poi_static.id_to_poi.get(poi)
client = ewutils.get_client()
server = client.get_guild(id_server)
server = client.get_guild(str(id_server))
server = client.get_guild(int(id_server))
id_player = EwPlayer(id_user=id_user, id_server=id_server)
if poi_obj.pvp:
try:
recipients = bknd_core.execute_sql_query(
"SELECT {id_user} FROM mutations WHERE {id_server} = %s AND {mutation} = %s and {data} = %s".format(
data=ewcfg.col_mutation_data,
id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user,
mutation=ewcfg.col_id_mutation,
), (
id_server,
ewcfg.mutation_id_oneeyeopen,
str(id_user),
))
for recipient in recipients:
member = server.get_member(int(recipient[0]))
mutation = EwMutation(id_server=id_server, id_user=recipient[0], id_mutation=ewcfg.mutation_id_oneeyeopen)
mutation.data = ""
mutation.persist()
await fe_utils.send_message(client, member, fe_utils.formatMessage(member, "{} is stirring...".format(id_player.display_name)))
except:
ewutils.logMsg("Failed to do OEO notificaitons for {}.".format(id_user))
async def dedorn_all_costumes():
costume_count = 0
# Grab costumes from the cache if enabled
item_cache = bknd_core.get_cache(obj_type="EwItem")
if item_cache is not False:
# separate search criteria for adorned or slimeoided
p1 = {"context": "costume", "adorned": "true"}
p2 = {"context": "costume", "slimeoid": "true"}
# compile both results
costumes_data = item_cache.find_entries(criteria={"item_props": p1})
costumes_data += item_cache.find_entries(criteria={"item_props": p2})
# Build a list that'll be handled in the same way
costumes = list(map(lambda dat: dat.get("id_item"), costumes_data))
else:
costumes = bknd_core.execute_sql_query(
"SELECT id_item FROM items_prop WHERE name = 'context' AND value = 'costume' AND id_item IN (SELECT id_item FROM items_prop WHERE (name = 'adorned' OR name = 'slimeoid') AND value = 'true')"
)
for costume_id in costumes:
costume_item = EwItem(id_item=costume_id)
costume_item.item_props['adorned'] = 'false'
costume_item.item_props['slimeoid'] = 'false'
costume_item.persist()
costume_count += 1
ewutils.logMsg(
"Dedorned {} costumes after full moon ended.".format(costume_count))
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 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))
def get_transports_at_stop(id_server, stop):
result = []
try:
data = bknd_core.execute_sql_query(
"SELECT {poi} FROM transports WHERE {id_server} = %s AND {current_stop} = %s"
.format(poi=ewcfg.col_poi,
id_server=ewcfg.col_id_server,
current_stop=ewcfg.col_current_stop), (id_server, stop))
for row in data:
result.append(row[0])
except:
ewutils.logMsg(
"Failed to retrieve transports at stop {}.".format(stop))
finally:
return result
def item_drop(id_item=None, other_poi=None):
try:
item_data = EwItem(id_item=id_item)
user_data = EwUser(id_user=item_data.id_owner,
id_server=item_data.id_server)
if other_poi == None:
dest = user_data.poi
else:
dest = other_poi
if item_data.item_type == ewcfg.it_cosmetic:
item_data.item_props["adorned"] = "false"
item_data.persist()
bknd_item.give_item(id_user=dest,
id_server=item_data.id_server,
id_item=item_data.id_item)
except:
ewutils.logMsg("Failed to drop item {}.".format(id_item))
def dedorn_all_costumes():
costumes = bknd_core.execute_sql_query(
"SELECT id_item FROM items_prop WHERE name = 'context' AND value = 'costume' AND id_item IN (SELECT id_item FROM items_prop WHERE (name = 'adorned' OR name = 'slimeoid') AND value = 'true')"
)
costume_count = 0
for costume_id in costumes:
costume_item = EwItem(id_item=costume_id)
costume_item.item_props['adorned'] = 'false'
costume_item.item_props['slimeoid'] = 'false'
costume_item.persist()
costume_count += 1
ewutils.logMsg(
"Dedorned {} costumes after full moon ended.".format(costume_count))
def path_to(
poi_start = None,
poi_end = None,
user_data = None
):
# ewutils.logMsg("beginning pathfinding")
score_golf = math.inf
score_map = {}
for poi in poi_static.poi_list:
score_map[poi.id_poi] = math.inf
paths_finished = []
paths_walking = []
pois_adjacent = []
poi_start = poi_static.id_to_poi.get(poi_start)
poi_end = poi_static.id_to_poi.get(poi_end)
path_base = EwPath(
steps=[poi_start],
cost=0,
pois_visited={poi_start.id_poi},
)
path_id = 0
heapq.heappush(paths_walking, (path_base.cost + landmark_heuristic(path_base, poi_end), path_id, path_base))
path_id += 1
count_iter = 0
while len(paths_walking) > 0:
count_iter += 1
path_tuple = heapq.heappop(paths_walking)
path = path_tuple[-1]
if path is not None:
step_last = path.steps[-1]
score_current = score_map.get(step_last.id_poi)
if poi_end is not None and not poi_start.is_outskirts and not poi_end.is_outskirts and step_last.is_outskirts:
# do not go through outskirts if the start and destination aren't part of them
continue
if path.cost >= score_current:
continue
if user_data.life_state != ewcfg.life_state_corpse and (poi_end and poi_end.id_poi != step_last.id_poi == ewcfg.poi_id_thesewers):
# can't route through the sewers unless you're dead
continue
score_map[step_last.id_poi] = path.cost
# ewutils.logMsg("visiting " + str(step_last))
step_penult = path.steps[-2] if len(path.steps) >= 2 else None
if poi_end != None:
# Arrived at the actual destination?
if step_last.id_poi == poi_end.id_poi:
path_final = path
if path_final.cost < score_golf:
score_golf = path_final.cost
paths_finished = []
if path_final.cost <= score_golf:
paths_finished.append(path_final)
break
else:
# Looking for adjacent points of interest.
poi_adjacent = step_last
if poi_adjacent.id_poi != poi_start.id_poi:
pois_adjacent.append(poi_adjacent)
continue
path_base = path
neighs = list(step_last.neighbors.keys())
if step_penult != None and step_penult.id_poi in neighs:
neighs.remove(step_penult.id_poi)
num_neighbors = len(neighs)
i = 0
for i in range(num_neighbors):
neigh = poi_static.id_to_poi.get(neighs[i])
neigh_cost = step_last.neighbors.get(neigh.id_poi)
if neigh_cost == None:
continue
if i < num_neighbors - 1:
branch = path_branch(path_base, neigh, neigh_cost, user_data, poi_end)
if branch != None:
heapq.heappush(paths_walking, (branch.cost + landmark_heuristic(branch, poi_end), path_id, branch))
path_id += 1
else:
if path_step(path_base, neigh, neigh_cost, user_data, poi_end):
heapq.heappush(paths_walking, (path_base.cost + landmark_heuristic(path_base, poi_end), path_id, path_base))
path_id += 1
# ewutils.logMsg("finished pathfinding")
if poi_end != None:
path_true = None
if len(paths_finished) > 0:
path_true = paths_finished[0]
path_true.iters = count_iter
if path_true is None:
ewutils.logMsg("Could not find a path.")
return path_true
else:
return pois_adjacent
async def setOffAlarms(id_server=None):
ewutils.logMsg('Setting off alarms...')
if id_server != None:
client = ewutils.get_client()
server = client.get_guild(id_server)
time_current = EwMarket(id_server=id_server).clock
if time_current <= 12:
displaytime = str(time_current)
ampm = 'am'
if time_current > 12:
displaytime = str(time_current - 12)
ampm = 'pm'
if time_current == 24:
ampm = "am"
elif time_current == 12:
ampm = "pm"
item_search = "alarm clock set to {}{}".format(displaytime, ampm)
item_search_brick = "brick{:02d}".format(time_current)
clockinv = item_utils.find_item_all(
item_search="alarmclock",
id_server=id_server,
item_type_filter=ewcfg.it_furniture)
brickinv = item_utils.find_item_all(
item_search=item_search_brick,
id_server=id_server,
item_type_filter=ewcfg.it_furniture,
search_names=True)
for clock in clockinv:
isFurnished = False
clock_obj = EwItem(id_item=clock.get('id_item'))
if clock_obj.item_props.get('furniture_name') == item_search:
if "decorate" in clock_obj.id_owner:
isFurnished = True
clock_user = clock_obj.id_owner.replace("decorate", "")
clock_member = server.get_member(user_id=clock_user)
if clock_member != None:
clock_player = EwUser(member=clock_member)
if (isFurnished == False or
("apt" in clock_player.poi and clock_player.visiting
== "empty")) and clock_member:
try:
await fe_utils.send_message(
client, clock_member,
fe_utils.formatMessage(
clock_member,
"BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP"
))
except:
ewutils.logMsg(
"failed to send alarm to user {}".format(
clock_member.id))
for brick in brickinv:
brick_obj = EwItem(id_item=brick.get('id_item'))
id_user = brick_obj.id_owner.replace("brickshit", "")
print(id_user)
brick_user = EwUser(id_server=id_server, id_user=id_user)
brick_member = server.get_member(user_id=int(id_user))
poi = poi_static.id_to_poi.get(brick_user.poi)
channel_brick = fe_utils.get_channel(server, poi.channel)
print('pass1')
if brick_member != None:
print('pass2')
if brick_member:
print('pass3')
try:
await fe_utils.send_message(
client, channel_brick,
fe_utils.formatMessage(
brick_member,
"UUUUUUUUUUGGGGGGGGGGGGHHHHHHHHHHH... OOOOOOOOOOOOOOOOOAAAAAAAAAAAAAAAHHHHH th-tunk. You just shit a brick. Congratulations?"
))
brick_obj.id_owner = poi.id_poi
brick_obj.item_props['furniture_name'] = 'brick'
brick_obj.persist()
except:
ewutils.logMsg(
"failed to shit brick on user {}".format(
brick_member.id))
async def balance_cosmetics(cmd):
author = cmd.message.author
if not author.guild_permissions.administrator:
return
if cmd.tokens_count == 2:
id_cosmetic = cmd.tokens[1]
try:
# Pull info from the cache if items are being cached
item_cache = bknd_core.get_cache(obj_type="EwItem")
if item_cache is not False:
# find all cosmetics for the target server
server_cosmetic_data = item_cache.find_entries(
criteria={
"id_server": cmd.guild.id,
"item_type": ewcfg.it_cosmetic
})
# format the results the same way the sql query would
data = list(
map(
lambda dat: [
dat.get("id_item"),
dat.get("item_type"),
dat.get("soulbound"),
dat.get("stack_max"),
dat.get("stack_size")
], server_cosmetic_data))
if len(data) == 0:
data = None
else:
data = bknd_core.execute_sql_query(
"SELECT {id_item}, {item_type}, {col_soulbound}, {col_stack_max}, {col_stack_size} FROM items WHERE {id_server} = {server_id} AND {item_type} = '{type_item}'"
.format(id_item=ewcfg.col_id_item,
item_type=ewcfg.col_item_type,
col_soulbound=ewcfg.col_soulbound,
col_stack_max=ewcfg.col_stack_max,
col_stack_size=ewcfg.col_stack_size,
id_server=ewcfg.col_id_server,
server_id=cmd.guild.id,
type_item=ewcfg.it_cosmetic))
if data != None:
for row in data:
id_item = row[0]
item_data = EwItem(id_item=id_item)
item_type = ewcfg.it_cosmetic
item_data.item_type = item_type
if id_cosmetic == "soul":
if item_data.item_props['id_cosmetic'] == 'soul':
item_data.item_props = {
'id_cosmetic':
item_data.item_props['id_cosmetic'],
'cosmetic_name':
item_data.item_props['cosmetic_name'],
'cosmetic_desc':
item_data.item_props['cosmetic_desc'],
'str_onadorn':
ewcfg.str_soul_onadorn,
'str_unadorn':
ewcfg.str_soul_unadorn,
'str_onbreak':
ewcfg.str_soul_onbreak,
'rarity':
ewcfg.rarity_patrician,
'attack':
6,
'defense':
6,
'speed':
6,
'ability':
None,
'durability':
ewcfg.soul_durability,
'size':
1,
'fashion_style':
ewcfg.style_cool,
'freshness':
10,
'adorned':
'false',
'user_id':
item_data.item_props['user_id']
}
elif id_cosmetic == "scalp":
if item_data.item_props['id_cosmetic'] == 'scalp':
item_data.item_props = {
'id_cosmetic':
item_data.item_props['id_cosmetic'],
'cosmetic_name':
item_data.item_props['cosmetic_name'],
'cosmetic_desc':
item_data.item_props['cosmetic_desc'],
'str_onadorn':
ewcfg.str_generic_onadorn,
'str_unadorn':
ewcfg.str_generic_unadorn,
'str_onbreak':
ewcfg.str_generic_onbreak,
'rarity':
ewcfg.rarity_plebeian,
'attack':
0,
'defense':
0,
'speed':
0,
'ability':
None,
'durability':
ewcfg.generic_scalp_durability,
'size':
16,
'fashion_style':
ewcfg.style_cool,
'freshness':
0,
'adorned':
'false',
}
elif id_cosmetic == "costume":
if item_data.item_props.get('context') == 'costume':
item_data.item_props = {
'id_cosmetic':
'dhcostume',
'cosmetic_name':
item_data.item_props['cosmetic_name'],
'cosmetic_desc':
item_data.item_props['cosmetic_desc'],
'str_onadorn':
ewcfg.str_generic_onadorn,
'str_unadorn':
ewcfg.str_generic_unadorn,
'str_onbreak':
ewcfg.str_generic_onbreak,
'rarity':
ewcfg.rarity_plebeian,
'attack':
1,
'defense':
1,
'speed':
1,
'ability':
None,
'durability':
ewcfg.base_durability * 100,
'size':
1,
'fashion_style':
ewcfg.style_cute,
'freshness':
0,
'adorned':
'false',
}
elif id_cosmetic == 'cigarettebutt':
if item_data.item_props.get(
'id_cosmetic') == 'cigarettebutt':
item_data.item_props = {
'id_cosmetic':
'cigarettebutt',
'cosmetic_name':
item_data.item_props['cosmetic_name'],
'cosmetic_desc':
item_data.item_props['cosmetic_desc'],
'str_onadorn':
ewcfg.str_generic_onadorn,
'str_unadorn':
ewcfg.str_generic_unadorn,
'str_onbreak':
ewcfg.str_generic_onbreak,
'rarity':
ewcfg.rarity_plebeian,
'attack':
2,
'defense':
0,
'speed':
0,
'ability':
None,
'durability':
ewcfg.base_durability / 2,
'size':
1,
'fashion_style':
ewcfg.style_cool,
'freshness':
5,
'adorned':
'false',
}
else:
if item_data.item_props.get(
'id_cosmetic') == id_cosmetic:
item = cosmetics.cosmetic_map.get(
item_data.item_props['id_cosmetic'])
item_data.item_props = {
'id_cosmetic':
item.id_cosmetic,
'cosmetic_name':
item.str_name,
'cosmetic_desc':
item.str_desc,
'str_onadorn':
item.str_onadorn if item.str_onadorn else
ewcfg.str_generic_onadorn,
'str_unadorn':
item.str_unadorn if item.str_unadorn else
ewcfg.str_generic_unadorn,
'str_onbreak':
item.str_onbreak if item.str_onbreak else
ewcfg.str_generic_onbreak,
'rarity':
item.rarity
if item.rarity else ewcfg.rarity_plebeian,
'attack':
item.stats[ewcfg.stat_attack] if
ewcfg.stat_attack in item.stats.keys() else 0,
'defense':
item.stats[ewcfg.stat_defense] if
ewcfg.stat_defense in item.stats.keys() else 0,
'speed':
item.stats[ewcfg.stat_speed] if
ewcfg.stat_speed in item.stats.keys() else 0,
'ability':
item.ability if item.ability else None,
'durability':
item.durability
if item.durability else ewcfg.base_durability,
'size':
item.size if item.size else 1,
'fashion_style':
item.style if item.style else ewcfg.style_cool,
'freshness':
item.freshness if item.freshness else 0,
'adorned':
'false',
}
item_data.persist()
ewutils.logMsg('Balanced cosmetic: {}'.format(id_item))
except KeyError as k:
ewutils.logMsg("Key error: " + k)
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, "Failure."))
except Exception as e:
ewutils.logMsg(e)
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, "Failure."))
return await fe_utils.send_message(
cmd.client, cmd.message.channel,
fe_utils.formatMessage(cmd.message.author, "Success!"))
async def crush(cmd):
member = cmd.message.author
user_data = EwUser(member=member)
response = "" # if it's not overwritten
crush_slimes = ewcfg.crush_slimes
command = "crush"
if cmd.tokens[0] == (ewcfg.cmd_prefix + 'crunch'):
command = "crunch"
if user_data.life_state == ewcfg.life_state_corpse:
response = "Alas, your ghostly form cannot {} anything. Lame.".format(command)
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
item_search = ewutils.flattenTokenListToString(cmd.tokens[1:])
item_sought = bknd_item.find_item(item_search=item_search, id_user=user_data.id_user, id_server=user_data.id_server)
if item_sought:
sought_id = item_sought.get('id_item')
item_data = EwItem(id_item=sought_id)
response = "The item doesn't have !{} functionality".format(command) # if it's not overwritten
if item_data.item_props.get("id_item") == ewcfg.item_id_slimepoudrin:
# delete a slime poudrin from the player's inventory
bknd_item.item_delete(id_item=sought_id)
levelup_response = user_data.change_slimes(n=crush_slimes, source=ewcfg.source_crush)
user_data.persist()
response = "You {} the hardened slime crystal with your bare teeth.\nYou gain {} slime. Sick, dude!!".format(command, crush_slimes)
if len(levelup_response) > 0:
response += "\n\n" + levelup_response
elif item_data.item_props.get("id_item") == ewcfg.item_id_royaltypoudrin:
# delete a royalty poudrin from the player's inventory
bknd_item.item_delete(id_item=sought_id)
crush_slimes = 5000
levelup_response = user_data.change_slimes(n=crush_slimes, source=ewcfg.source_crush)
user_data.persist()
response = "You {} your hard-earned slime crystal with your bare teeth.\nYou gain {} slime. Ah, the joy of writing!".format(command, crush_slimes)
if len(levelup_response) > 0:
response += "\n\n" + levelup_response
elif item_data.item_props.get("id_food") in static_food.vegetable_to_cosmetic_material.keys():
bknd_item.item_delete(id_item=sought_id)
crop_name = item_data.item_props.get('food_name')
# Turn the crop into its proper cosmetic material item.
cosmetic_material_id = static_food.vegetable_to_cosmetic_material[item_data.item_props.get("id_food")]
new_item = static_items.item_map.get(cosmetic_material_id)
new_item_type = ewcfg.it_item
if new_item != None:
new_name = new_item.str_name
new_item_props = itm_utils.gen_item_props(new_item)
else:
ewutils.logMsg("ERROR: !crunch failed to retrieve proper cosmetic material for crop {}.".format(item_data.item_props.get("id_food")))
new_name = None
new_item_props = None
generated_item_id = bknd_item.item_create(
item_type=new_item_type,
id_user=cmd.message.author.id,
id_server=cmd.guild.id,
item_props=new_item_props
)
response = "You {} your {} in your mouth and spit it out to create some {}!!".format(command, crop_name, new_name)
elif item_data.item_props.get("id_food") in static_food.candy_ids_list:
bknd_item.item_delete(id_item=sought_id)
item_name = item_data.item_props.get('food_name')
if float(getattr(item_data, "time_expir", 0)) < time.time():
response = "The {} melts disappointingly in your hand...".format(item_name)
else:
gristnum = random.randrange(2) + 1
gristcount = 0
response = "You crush the {} with an iron grip. You gain {} piece(s) of Double Halloween Grist!".format(item_name, gristnum)
while gristcount < gristnum:
grist = static_items.item_map.get(ewcfg.item_id_doublehalloweengrist)
grist_props = itm_utils.gen_item_props(grist)
bknd_item.item_create(
item_type=grist.item_type,
id_user=cmd.message.author.id,
id_server=cmd.message.guild.id,
item_props=grist_props
)
gristcount += 1
elif item_data.item_props.get("id_item") == ewcfg.item_id_negapoudrin:
# delete a negapoudrin from the player's inventory
bknd_item.item_delete(id_item=sought_id)
crush_slimes = -1000000
# kill player if they have less than 1 million slime
if user_data.slimes < 1000000:
user_data.die(cause=ewcfg.cause_suicide)
# remove 1 million slime from the player
else:
levelup_response = user_data.change_slimes(n = crush_slimes, source = ewcfg.source_crush)
user_data.persist()
response = "You {} your hard-earned slime crystal with your bare teeth.\nAs the nerve endings in your teeth explode, you realize you bit into a negapoudrin! You writhe on the ground as slime gushes from all of your orifices.".format(command)
if len(levelup_response) > 0:
response += "\n\n" + levelup_response
else:
if item_search: # if they didnt forget to specify an item and it just wasn't found
response = "You don't have one."
else:
response = "{} which item? (check **!inventory**)".format(command)
# 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 mine(cmd):
market_data = EwMarket(id_server=cmd.message.author.guild.id)
user_data = EwUser(member=cmd.message.author)
if user_data.life_state == ewcfg.life_state_shambler:
response = "You lack the higher brain functions required to {}.".format(cmd.tokens[0])
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
mutations = user_data.get_mutations()
cosmetic_abilites = itm_utils.get_cosmetic_abilities(id_user=cmd.message.author.id, id_server=cmd.guild.id)
time_now = int(time.time())
poi = poi_static.id_to_poi.get(user_data.poi)
response = ""
# Kingpins can't mine.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
return
# ghosts cant mine (anymore)
if user_data.life_state == ewcfg.life_state_corpse:
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You can't mine while you're dead. Try {}.".format(ewcfg.cmd_revive)))
# Enlisted players only mine at certain times.
if user_data.life_state == ewcfg.life_state_enlisted:
if user_data.faction == ewcfg.faction_rowdys and (market_data.clock < 8 or market_data.clock > 17):
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "Rowdies only mine in the daytime. Wait for full daylight at 8am.".format(ewcfg.cmd_revive)))
if user_data.faction == ewcfg.faction_killers and (market_data.clock < 20 and market_data.clock > 5):
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "Killers only mine under cover of darkness. Wait for nightfall at 8pm.".format(ewcfg.cmd_revive)))
# Mine only in the mines.
if cmd.message.channel.name in ewcfg.mining_channels:
poi = poi_static.id_to_poi.get(user_data.poi)
district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server)
if district_data.is_degraded():
response = "{} has been degraded by shamblers. You can't {} here anymore.".format(poi.str_name, cmd.tokens[0])
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
if user_data.hunger >= user_data.get_hunger_max():
return await mismine(cmd, user_data, "exhaustion")
# return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You've exhausted yourself from mining. You'll need some refreshment before getting back to work."))
else:
printgrid = True
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
world_events = bknd_worldevent.get_world_events(id_server=cmd.guild.id)
mining_type = ewcfg.mines_mining_type_map.get(user_data.poi)
for id_event in world_events:
if world_events.get(id_event) == ewcfg.event_type_minecollapse:
event_data = EwWorldEvent(id_event=id_event)
if int(event_data.event_props.get('id_user')) == user_data.id_user and event_data.event_props.get('poi') == user_data.poi:
captcha = event_data.event_props.get('captcha').lower()
tokens_lower = []
for token in cmd.tokens[1:]:
tokens_lower.append(token.lower())
if captcha in tokens_lower:
bknd_worldevent.delete_world_event(id_event=id_event)
response = "You escape from the collapsing mineshaft."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif ewcfg.mutation_id_lightminer in mutations:
bknd_worldevent.delete_world_event(id_event=id_event)
response = "You nimbly step outside the collapse without even thinking about it."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
else:
return await mismine(cmd, user_data, ewcfg.event_type_minecollapse)
if user_data.poi not in juviecmdutils.mines_map:
response = "You can't mine here! Go to the mines in Juvie's Row, Toxington, or Cratersville!"
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif user_data.id_server not in juviecmdutils.mines_map.get(user_data.poi):
init_grid(user_data.poi, user_data.id_server)
printgrid = True
grid_cont = juviecmdutils.mines_map.get(user_data.poi).get(user_data.id_server)
grid = grid_cont.grid
grid_type = ewcfg.grid_type_by_mining_type.get(mining_type)
if grid_type != grid_cont.grid_type:
init_grid(user_data.poi, user_data.id_server)
printgrid = True
grid_cont = juviecmdutils.mines_map.get(user_data.poi).get(user_data.id_server)
grid = grid_cont.grid
# minesweeper = True
# grid_multiplier = grid_cont.cells_mined ** 0.4
# flag = False
mining_yield = get_mining_yield_by_grid_type(cmd, grid_cont)
if type(mining_yield) == type(""):
response = mining_yield
if len(response) > 0:
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
if time_now > grid_cont.time_last_posted + 10:
await print_grid(cmd)
return
if mining_yield == 0:
user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod)
user_data.persist()
# response = "This vein has already been mined dry."
# await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
if printgrid:
return await print_grid(cmd)
else:
return
has_pickaxe = False
if user_data.weapon >= 0:
weapon_item = EwItem(id_item=user_data.weapon)
weapon = static_weapons.weapon_map.get(weapon_item.item_props.get("weapon_type"))
if (weapon.id_weapon == ewcfg.weapon_id_pickaxe or weapon.id_weapon == ewcfg.weapon_id_diamondpickaxe) and user_data.life_state != ewcfg.life_state_juvenile:
has_pickaxe = True
# if user_data.sidearm >= 0:
# sidearm_item = EwItem(id_item=user_data.sidearm)
# sidearm = static_weapons.weapon_map.get(sidearm_item.item_props.get("weapon_type"))
# if sidearm.id_weapon == ewcfg.weapon_id_pickaxe:
# has_pickaxe = True
# Determine if an item is found.
unearthed_item = False
unearthed_item_amount = (random.randrange(3) + 5) # anywhere from 5-7 drops
# juvies get items 4 times as often as enlisted players
unearthed_item_chance = 1 / ewcfg.unearthed_item_rarity
if user_data.life_state == ewcfg.life_state_juvenile:
unearthed_item_chance *= 2
if has_pickaxe == True:
unearthed_item_chance *= 1.5
if ewcfg.mutation_id_lucky in mutations:
unearthed_item_chance *= 1.33
if ewcfg.cosmeticAbility_id_lucky in cosmetic_abilites:
unearthed_item_chance *= 1.33
# event bonus
for id_event in world_events:
if world_events.get(id_event) == ewcfg.event_type_slimefrenzy:
event_data = EwWorldEvent(id_event=id_event)
if event_data.event_props.get('poi') == user_data.poi and int(event_data.event_props.get('id_user')) == user_data.id_user:
mining_yield *= 2
if world_events.get(id_event) == ewcfg.event_type_poudrinfrenzy:
event_data = EwWorldEvent(id_event=id_event)
if event_data.event_props.get('poi') == user_data.poi and int(event_data.event_props.get('id_user')) == user_data.id_user:
unearthed_item_chance = 1
unearthed_item_amount = 1
if random.random() < 0.05:
id_event = create_mining_event(cmd)
event_data = EwWorldEvent(id_event=id_event)
if event_data.id_event == -1:
return ewutils.logMsg("Error couldn't find world event with id {}".format(id_event))
if event_data.event_type == ewcfg.event_type_slimeglob:
mining_yield *= 4
bknd_worldevent.delete_world_event(id_event=id_event)
if event_data.time_activate <= time.time():
event_def = poi_static.event_type_to_def.get(event_data.event_type)
if event_def == None:
return ewutils.logMsg("Error, couldn't find event def for event type {}".format(event_data.event_type))
str_event_start = event_def.str_event_start
if event_data.event_type == ewcfg.event_type_minecollapse:
str_event_start = str_event_start.format(cmd=ewcfg.cmd_mine, captcha=ewutils.text_to_regional_indicator(event_data.event_props.get('captcha')))
await fe_utils.send_response(str_event_start, cmd)
event_data.time_expir = time_now + 60
event_data.persist()
str_event_start = ""
if str_event_start != "":
response += str_event_start + "\n"
if random.random() < unearthed_item_chance:
unearthed_item = True
if unearthed_item == True:
# If there are multiple possible products, randomly select one.
item = random.choice(vendors.mine_results)
if bknd_item.check_inv_capacity(user_data=user_data, item_type=item.item_type):
item_props = itm_utils.gen_item_props(item)
for creation in range(unearthed_item_amount):
bknd_item.item_create(
item_type=item.item_type,
id_user=cmd.message.author.id,
id_server=cmd.guild.id,
item_props=item_props
)
if unearthed_item_amount == 1:
response += "You unearthed a {}! ".format(item.str_name)
else:
response += "You unearthed {} {}s! ".format(unearthed_item_amount, item.str_name)
ewstats.change_stat(user=user_data, metric=ewcfg.stat_lifetime_poudrins, n=unearthed_item_amount)
# ewutils.logMsg('{} has found {} {}(s)!'.format(cmd.message.author.display_name, item.str_name, unearthed_item_amount))
user_initial_level = user_data.slimelevel
# Add mined slime to the user.
slime_bylevel = ewutils.slime_bylevel(user_data.slimelevel)
# mining_yield = math.floor((slime_bylevel / 10) + 1)
# alternate_yield = math.floor(200 + slime_bylevel ** (1 / math.e))
# mining_yield = min(mining_yield, alternate_yield)
controlling_faction = poi_utils.get_subzone_controlling_faction(user_data.poi, user_data.id_server)
if controlling_faction != "" and controlling_faction == user_data.faction:
mining_yield *= 2
if has_pickaxe == True:
mining_yield *= 2
if user_data.life_state == ewcfg.life_state_juvenile:
mining_yield *= 2
# trauma = se_static.trauma_map.get(user_data.trauma)
# if trauma != None and trauma.trauma_class == ewcfg.trauma_class_slimegain:
# mining_yield *= (1 - 0.5 * user_data.degradation / 100)
mining_yield = max(0, round(mining_yield))
# Fatigue the miner.
user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod)
if extra > 0: # if hunger_cost_mod is not an integer
# there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100)
if random.randint(1, 100) <= extra * 100:
user_data.hunger += ewcfg.hunger_permine
levelup_response = user_data.change_slimes(n=mining_yield, source=ewcfg.source_mining)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Tell the player their slime level increased and/or they unearthed an item.
if was_levelup:
response += levelup_response
user_data.persist()
if printgrid:
await print_grid(cmd)
# gangsters don't need their roles updated
if user_data.life_state == ewcfg.life_state_juvenile:
await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author)
else:
return await mismine(cmd, user_data, "channel")
# response = "You can't mine here! Go to the mines in Juvie's Row, Toxington, or Cratersville!"
if len(response) > 0:
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def handle_hourly_events(id_server=None):
if id_server != None:
client = ewutils.get_client()
server = client.get_guild(id_server)
time_current = EwMarket(id_server=id_server).clock
events = bknd_event.get_world_events(id_server, True)
for we_id, we_type in events.items():
if we_type in ewcfg.hourly_events:
we = EwWorldEvent(id_event=we_id)
if we.event_props.get("time") == str(time_current):
# Handle brickshitting code
if we_type == ewcfg.event_type_brickshit:
brick_obj = EwItem(
id_item=we.event_props.get("brick_id"))
id_user = brick_obj.id_owner.replace("stomach", "")
brick_user = EwUser(id_server=id_server,
id_user=id_user)
brick_member = server.get_member(user_id=int(id_user))
poi = poi_static.id_to_poi.get(brick_user.poi)
channel_brick = fe_utils.get_channel(
server, poi.channel)
if brick_member:
try:
await fe_utils.send_message(
client, channel_brick,
fe_utils.formatMessage(
brick_member,
"UUUUUUUUUUGGGGGGGGGGGGHHHHHHHHHHH... OOOOOOOOOOOOOOOOOAAAAAAAAAAAAAAAHHHHH th-tunk. You just shit a brick. Congratulations?"
))
brick_obj.id_owner = poi.id_poi
brick_obj.item_props[
'furniture_name'] = 'brick'
brick_obj.persist()
except:
ewutils.logMsg(
"failed to shit brick on user {}".format(
brick_member.id))
else:
bknd_event.delete_world_event(we_id)
# Handle alarm clock code
elif we_type == ewcfg.event_type_alarmclock:
clock_obj = EwItem(
id_item=we.event_props.get("clock_id"))
if "decorate" in clock_obj.id_owner:
isFurnished = True
clock_user = clock_obj.id_owner.replace("decorate", "")
clock_member = server.get_member(user_id=clock_user)
if clock_member != None:
clock_player = EwUser(member=clock_member)
if (isFurnished == False or
("apt" in clock_player.poi
and clock_player.visiting
== "empty")) and clock_member:
try:
await fe_utils.send_message(
client, clock_member,
fe_utils.formatMessage(
clock_member,
"BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP BLAAAP"
))
except:
ewutils.logMsg(
"failed to send alarm to user {}".
format(clock_member.id))
async def chemo(cmd):
user_data = EwUser(member=cmd.message.author)
if cmd.message.channel.name != ewcfg.channel_clinicofslimoplasty:
response = "Chemotherapy doesn't just grow on trees. You'll need to go to the clinic in Crookline to get some."
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif user_data.life_state == ewcfg.life_state_corpse:
response = '"You get out of here. We don\'t serve your kind." \n\n Auntie Dusttrap threatingly flails a jar of cole slaw at you. Looks like you need a body to operate on one.'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
mutations = user_data.get_mutations()
if len(mutations) == 0:
response = '"I can chemo you all day long, sonny. You\'re not getting any cleaner than you are."'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif len(cmd.tokens) <= 1:
response = '"Are you into chemo for the thrill, boy? You have to tell me what you want taken out."'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif cmd.tokens[1] == "all":
finalprice = 0
for mutation in mutations:
finalprice += static_mutations.mutations_map.get(mutation).tier * 5000
if finalprice > user_data.slimes:
response = '"We\'re not selling gumballs here. It\'s chemotherapy. It\'ll cost at least {:,} slime, ya idjit!"'.format(finalprice)
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
else:
response = "\"Sure you got the slime for that, whelp? It's {:,}.\"\n**Accept** or **refuse?**".format(finalprice)
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
try:
accepted = False
message = await cmd.client.wait_for('message', timeout=30, check=lambda message: message.author == cmd.message.author and message.content.lower() in [ewcfg.cmd_accept, ewcfg.cmd_refuse])
if message != None:
if message.content.lower() == ewcfg.cmd_accept:
accepted = True
if message.content.lower() == ewcfg.cmd_refuse:
accepted = False
except Exception as e:
print(e)
accepted = False
if not accepted:
response = "\"Tch. Knew you weren't good for it.\""
else:
for mutation in mutations:
price = static_mutations.mutations_map.get(mutation).tier * 5000
user_data.change_slimes(n=-price, source=ewcfg.source_spending)
mutation_obj = EwMutation(id_mutation=mutation, id_user=user_data.id_user, id_server=cmd.message.guild.id)
if mutation_obj.artificial == 0:
try:
bknd_core.execute_sql_query(
"DELETE FROM mutations WHERE {id_server} = %s AND {id_user} = %s AND {mutation} = %s".format(
id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user,
mutation=ewcfg.col_id_mutation
), (
user_data.id_server,
user_data.id_user,
mutation,
))
except:
ewutils.logMsg("Failed to clear mutations for user {}.".format(user_data.id_user))
user_data.persist()
response = '"Everything, eh? All right then. This might hurt a lottle!" Auntie Dusttrap takes a specialized shop vac and sucks the slime out of you. While you\'re reeling in slimeless existential dread, she runs it through a filtration process that gets rid of the carcinogens that cause mutation. She grabs the now purified canister and haphazardly dumps it back into you. You feel pure, energized, and ready to dirty up your slime some more!'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
else:
target_name = ewutils.flattenTokenListToString(cmd.tokens[1:])
target = ewutils.get_mutation_alias(target_name)
mutation_obj = EwMutation(id_mutation=target, id_user=user_data.id_user, id_server=cmd.message.guild.id)
if target == 0:
response = '"I don\'t know what kind of gold-rush era disease that is, but I have no idea how to take it out of you."'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif target not in mutations:
response = '"Oy vey, another hypochondriac. You don\'t have that mutation, so I can\'t remove it."'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif static_mutations.mutations_map.get(target).tier * 5000 > user_data.slimes:
response = '"We\'re not selling gumballs here. It\'s chemotherapy. It\'ll cost at least {} slime, ya idjit!"'.format(static_mutations.mutations_map.get(target).tier * 5000)
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
elif mutation_obj.artificial == 1:
response = '"Hey, didn\'t I do that to ya? Well no refunds!"\n\nGuess you can\'t get rid of artificial mutations with chemo.'
return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
else:
price = static_mutations.mutations_map.get(target).tier * 5000
user_data.change_slimes(n=-price, source=ewcfg.source_spending)
user_data.persist()
try:
bknd_core.execute_sql_query("DELETE FROM mutations WHERE {id_server} = %s AND {id_user} = %s AND {mutation} = %s".format(
id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user,
mutation=ewcfg.col_id_mutation
), (
user_data.id_server,
user_data.id_user,
target,
))
except:
ewutils.logMsg("Failed to clear mutations for user {}.".format(user_data.id_user))
response = '"Alright, dearie, let\'s get you purged." You enter a dingy looking operating room, with slime strewn all over the floor. Dr. Dusttrap pulls out a needle the size of your bicep and injects into odd places on your body. After a few minutes of this, you get fatigued and go under.\n\n You wake up and {} is gone. Nice! \nMutation Levels Added:{}/{}'.format(
static_mutations.mutations_map.get(target).str_name, user_data.get_mutation_level(), min(user_data.slimelevel, 50))
await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
