async def give_kingpins_slime_and_decay_capture_points(id_server):
for kingpin_role in [ewcfg.role_rowdyfucker, ewcfg.role_copkiller]:
kingpin = ewutils.find_kingpin(id_server=id_server,
kingpin_role=kingpin_role)
if kingpin is not None:
slimegain = 0
for id_district in ewcfg.capturable_districts:
district = EwDistrict(id_server=id_server,
district=id_district)
# if the kingpin is controlling this district
if district.controlling_faction == (
ewcfg.faction_killers if kingpin.faction
== ewcfg.faction_killers else ewcfg.faction_rowdys):
# give the kingpin slime based on the district's property class
slimegain += ewcfg.district_control_slime_yields[
district.property_class]
await district.decay_capture_points()
kingpin.change_slimes(n=slimegain)
kingpin.persist()
ewutils.logMsg(kingpin_role + " just received %d" % slimegain +
" slime for their captured districts.")
def persist(self):
try:
# Save the object.
ewutils.execute_sql_query(
"REPLACE INTO world_events({}, {}, {}, {}, {}) VALUES(%s, %s, %s, %s, %s)"
.format(
ewcfg.col_id_event,
ewcfg.col_id_server,
ewcfg.col_event_type,
ewcfg.col_time_activate,
ewcfg.col_time_expir,
), (
self.id_event,
self.id_server,
self.event_type,
self.time_activate,
self.time_expir,
))
# Remove all existing property rows.
ewutils.execute_sql_query(
"DELETE FROM world_events_prop WHERE {} = %s".format(
ewcfg.col_id_event), (self.id_event, ))
# Write out all current property rows.
for name in self.event_props:
ewutils.execute_sql_query(
"INSERT INTO world_events_prop({}, {}, {}) VALUES(%s, %s, %s)"
.format(ewcfg.col_id_event, ewcfg.col_name,
ewcfg.col_value),
(self.id_event, name, self.event_props[name]))
except:
ewutils.logMsg("Error while persisting world event {}".format(
self.id_event))
def player_update(member=None, server=None):
id_server_old = ""
try:
conn_info = ewutils.databaseConnect()
conn = conn_info.get('conn')
cursor = conn.cursor()
# Get existing player info (or create a record if it's a new player)
player = EwPlayer(id_user=member.id, id_server=server.id)
# Update values with Member data.
id_server_old = player.id_server
player.id_server = server.id
player.avatar = member.avatar_url
player.display_name = member.display_name
# Save the updated data.
player.persist()
conn.commit()
finally:
cursor.close()
ewutils.databaseClose(conn_info)
# Log server changes
if (server.id != id_server_old):
ewutils.logMsg('active server for {} changed from "{}" to "{}"'.format(
member.display_name, id_server_old, server.id))
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:
ewutils.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 ewutils.send_message(
cmd.client, cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
def __init__(self, id_server = None, poi = None):
if id_server is not None and poi is not None:
self.id_server = id_server
self.poi = poi
try:
data = ewutils.execute_sql_query("SELECT {transport_type}, {current_line}, {current_stop} FROM transports WHERE {id_server} = %s AND {poi} = %s".format(
transport_type = ewcfg.col_transport_type,
current_line = ewcfg.col_current_line,
current_stop = ewcfg.col_current_stop,
id_server = ewcfg.col_id_server,
poi = ewcfg.col_poi
),(
self.id_server,
self.poi
))
# Retrieve data if the object was found
if len(data) > 0:
self.transport_type = data[0][0]
self.current_line = data[0][1]
self.current_stop = data[0][2]
# initialize it per the Poi default otherwise
else:
poi_data = ewcfg.id_to_poi.get(self.poi)
if poi_data is not None:
self.transport_type = poi_data.transport_type
self.current_line = poi_data.default_line
self.current_stop = poi_data.default_stop
self.persist()
except:
ewutils.logMsg("Failed to retrieve transport {} from database.".format(self.poi))
def get_players_in_district(self,
min_level=0,
max_level=math.inf,
life_states=[],
factions=[],
min_slimes=-math.inf,
max_slimes=math.inf):
client = ewutils.get_client()
server = client.get_server(self.id_server)
if server == None:
ewutils.logMsg("error: couldn't find server with id {}".format(
self.id_server))
return []
players = ewutils.execute_sql_query(
"SELECT {id_user} FROM users WHERE id_server = %s AND {poi} = %s".
format(id_user=ewcfg.col_id_user,
poi=ewcfg.col_poi), (self.id_server, self.name))
filtered_players = []
for player in players:
if server.get_member(player[0]) != None:
user_data = EwUser(id_user=player[0], id_server=self.id_server)
if max_level >= user_data.slimelevel >= min_level \
and max_slimes >= user_data.slimes >= min_slimes \
and (len(life_states) == 0 or user_data.life_state in life_states) \
and (len(factions) == 0 or user_data.faction in factions):
filtered_players.append(user_data.id_user)
return filtered_players
def delete_world_event(id_event):
try:
ewutils.execute_sql_query(
"DELETE FROM world_events WHERE {id_event} = %s".format(
id_event=ewcfg.col_id_event, ), (id_event, ))
except:
ewutils.logMsg("Error while deleting world event {}".format(id_event))
def __init__(self, id_server=None, stock=None):
if id_server is not None and stock is not None:
self.id_server = id_server
self.id_stock = stock
try:
# Retrieve object
result = ewutils.execute_sql_query(
"SELECT {recent_profits}, {total_profits} FROM companies WHERE {id_server} = %s AND {stock} = %s"
.format(recent_profits=ewcfg.col_recent_profits,
total_profits=ewcfg.col_total_profits,
id_server=ewcfg.col_id_server,
stock=ewcfg.col_stock),
(self.id_server, self.id_stock))
if len(result) > 0:
# Record found: apply the data to this object.
self.recent_profits = result[0][0]
self.total_profits = result[0][1]
else:
# Create a new database entry if the object is missing.
self.persist()
except:
ewutils.logMsg(
"Failed to retrieve company {} from database.".format(
self.id_stock))
async def on_member_join(member):
ewutils.logMsg("New member \"{}\" joined. Configuring default roles now.".format(member.display_name))
await ewrolemgr.updateRoles(client = client, member = member)
ewplayer.player_update(
member = member,
server = member.server
)
def item_create(item_type=None,
id_user=None,
id_server=None,
item_props=None,
conn=None,
cursor=None):
our_cursor = False
our_conn = False
item_def = ewcfg.item_def_map.get(item_type)
if item_def == None:
ewutils.logMsg(
'Tried to create invalid item_type: {}'.format(item_type))
return
try:
# Get database handles if they weren't passed.
if (cursor == None):
if (conn == None):
conn = ewutils.databaseConnect()
our_conn = True
cursor = conn.cursor()
our_cursor = True
# Create the item in the database.
cursor.execute(
"INSERT INTO items({}, {}, {}, {}, {}, {}) VALUES(%s, %s, %s, %s, %s, %s)"
.format(ewcfg.col_item_type, ewcfg.col_id_user,
ewcfg.col_id_server, ewcfg.col_soulbound,
ewcfg.col_stack_max, ewcfg.col_stack_size),
(item_type, id_user, id_server, (1 if item_def.soulbound else 0),
item_def.stack_max, item_def.stack_size))
item_id = cursor.lastrowid
conn.commit()
if item_id > 0:
# If additional properties are specified in the item definition or in this create call, create and persist them.
if item_props != None or item_def.item_props != None:
item_inst = EwItem(id_item=item_id)
if item_def.item_props != None:
item_inst.item_props.update(item_def.item_props)
if item_props != None:
item_inst.item_props.update(item_props)
item_inst.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
# Clean up the database handles.
if (our_cursor):
cursor.close()
if (our_conn):
conn.close()
return item_id
def dedorn_all_costumes():
costumes = ewutils.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)
usermodel = EwUser(id_user=costume_item.id_owner,
id_server=costume_item.id_server)
costume_item.item_props['adorned'] = 'false'
if costume_item.item_props['slimeoid'] == 'false':
usermodel.persist()
costume_item.item_props['slimeoid'] = 'false'
costume_item.persist()
costume_count += 1
ewutils.logMsg(
"Dedorned {} costumes after full moon ended.".format(costume_count))
def __init__(
self,
id_state = None,
id_server = None
):
if id_server is not None and id_state is not None:
self.id_server = id_server
self.id_state = id_state
try:
data = ewutils.execute_sql_query("SELECT {col_bit}, {col_value} FROM gamestates WHERE {id_server} = %s AND {id_state} = %s".format(
id_state = ewcfg.col_id_state,
id_server = ewcfg.col_id_server,
col_bit = ewcfg.col_bit,
col_value = ewcfg.col_value
),(
self.id_server,
self.id_state
))
# Retrieve data if the object was found
if len(data) > 0:
self.id_state = id_state
self.bit = data[0][0]
self.value = data[0][1]
else:
self.bit = None
except:
ewutils.logMsg("Failed to retrieve gamestate {} from database.".format(self.id_state))
async def give_kingpins_slime_and_decay_capture_points(id_server): resp_cont_decay_loop = ewutils.EwResponseContainer(client = ewutils.get_client(), id_server = id_server) for kingpin_role in [ewcfg.role_rowdyfucker, ewcfg.role_copkiller]: kingpin = ewutils.find_kingpin(id_server = id_server, kingpin_role = kingpin_role) if kingpin is not None: total_slimegain = 0 for id_district in ewcfg.capturable_districts: district = EwDistrict(id_server = id_server, district = id_district) # if the kingpin is controlling this district give the kingpin slime based on the district's property class if district.controlling_faction == (ewcfg.faction_killers if kingpin.faction == ewcfg.faction_killers else ewcfg.faction_rowdys): poi = ewcfg.id_to_poi.get(id_district) slimegain = ewcfg.district_control_slime_yields[poi.property_class] # increase slimeyields by 10 percent per friendly neighbor friendly_mod = 1 + 0.1 * district.get_number_of_friendly_neighbors() total_slimegain += slimegain * friendly_mod kingpin.change_slimes(n = total_slimegain) kingpin.persist() ewutils.logMsg(kingpin_role + " just received %d" % total_slimegain + " slime for their captured districts.") # Decay capture points. for id_district in ewcfg.capturable_districts: district = EwDistrict(id_server = id_server, district = id_district) responses = district.decay_capture_points() resp_cont_decay_loop.add_response_container(responses) district.persist()
async def hideRoleNames(cmd):
id_server = cmd.guild.id
client = ewutils.get_client()
server = client.get_guild(id_server)
roles_map = ewutils.getRoleMap(server.roles)
role_counter = 0
ewutils.logMsg('Attempting to hide all role names...')
for poi in ewcfg.poi_list:
if poi.is_street:
pass
elif poi.is_district:
pass
elif poi.id_poi in [
ewcfg.poi_id_mine, ewcfg.poi_id_cv_mines, ewcfg.poi_id_tt_mines
]:
pass
else:
continue
# Slow down just a bit every 20 Role change attempts
if role_counter >= 20:
role_counter = 0
await asyncio.sleep(5)
try:
if poi.role in roles_map:
role = roles_map[poi.role]
if role.name != ewcfg.generic_role_name:
role_counter += 1
await role.edit(name=ewcfg.generic_role_name)
except:
ewutils.logMsg('Failed to hide role name for {}'.format(poi.role))
try:
if poi.major_role in roles_map:
major_role = roles_map[poi.major_role]
if major_role.name != ewcfg.generic_role_name:
role_counter += 1
await major_role.edit(name=ewcfg.generic_role_name)
except:
ewutils.logMsg('Failed to hide role name for {}'.format(
poi.major_role))
try:
if poi.minor_role in roles_map:
minor_role = roles_map[poi.minor_role]
if minor_role.name != ewcfg.generic_role_name:
role_counter += 1
await minor_role.edit(name=ewcfg.generic_role_name)
except:
ewutils.logMsg('Failed to hide role name for {}'.format(
poi.minor_role))
ewutils.logMsg('Finished hiding roles!')
async def updateRoles(client=None, member=None):
user_data = EwUser(member=member)
roles_map = ewutils.getRoleMap(member.server.roles)
roles_map_user = ewutils.getRoleMap(member.roles)
if user_data.life_state != ewcfg.life_state_kingpin and ewcfg.role_kingpin in roles_map_user:
# Fix the life_state of kingpins, if somehow it wasn't set.
user_data.life_state = ewcfg.life_state_kingpin
user_data.persist()
elif user_data.life_state != ewcfg.life_state_grandfoe and ewcfg.role_grandfoe in roles_map_user:
# Fix the life_state of a grand foe.
user_data.life_state = ewcfg.life_state_grandfoe
user_data.persist()
faction_roles_remove = [
ewcfg.role_juvenile, ewcfg.role_juvenile_pvp, ewcfg.role_rowdyfuckers,
ewcfg.role_rowdyfuckers_pvp, ewcfg.role_copkillers,
ewcfg.role_copkillers_pvp, ewcfg.role_corpse, ewcfg.role_corpse_pvp,
ewcfg.role_kingpin, ewcfg.role_grandfoe
]
# Manage faction roles.
faction_role = ewutils.get_faction(user_data=user_data)
faction_roles_remove.remove(faction_role)
# Manage location roles.
poi_role = None
poi = ewcfg.id_to_poi.get(user_data.poi)
if poi != None:
poi_role = poi.role
poi_roles_remove = []
for poi in ewcfg.poi_list:
if poi.role != None and poi.role != poi_role:
poi_roles_remove.append(poi.role)
role_names = []
for roleName in roles_map_user:
if roleName not in faction_roles_remove and roleName not in poi_roles_remove:
role_names.append(roleName)
if faction_role not in role_names:
role_names.append(faction_role)
if poi_role != None and poi_role not in role_names:
role_names.append(poi_role)
replacement_roles = []
for name in role_names:
role = roles_map.get(name)
if role != None:
replacement_roles.append(role)
else:
ewutils.logMsg("error: role missing \"{}\"".format(name))
await client.replace_roles(member, *replacement_roles)
async def on_member_join(member):
roles_map = ewutils.getRoleMap(member.server.roles)
role_juvenile = roles_map[ewcfg.role_juvenile]
ewutils.logMsg("New member \"{}\" joined. Assigned Juveniles role.".format(
member.display_name))
await client.replace_roles(member, role_juvenile)
async def on_message_delete(message):
if message != None and message.server != None and message.author.id != client.user.id and message.content.startswith(
ewcfg.cmd_prefix):
ewutils.logMsg("deleted message from {}: {}".format(
message.author.display_name, message.content))
await client.send_message(
message.channel,
ewutils.formatMessage(message.author, '**I SAW THAT.**'))
def clear(self):
try:
ewutils.execute_sql_query(
"DELETE FROM mutations WHERE {mutation_counter} = %s".format(
mutation_counter=ewcfg.col_mutation_counter),
(self.mutation_counter))
except:
ewutils.logMsg("Failed to clear mutation {} for user {}.".format(
self.id_mutation, self.id_user))
async def on_member_remove(member):
# Kill players who leave the server.
try:
user_data = EwUser(member = member)
user_data.die(cause = ewcfg.cause_leftserver)
user_data.persist()
ewutils.logMsg('Player killed for leaving the server.')
except:
ewutils.logMsg('Failed to kill member who left the server.')
async def on_member_update(before, after):
# update last offline time if they went from offline to online
try:
if before.status == discord.Status.offline and after.status != discord.Status.offline:
user_data = EwUser(member = after)
user_data.time_lastoffline = int(time.time())
user_data.persist()
except:
ewutils.logMsg('Failed to update member\'s last offline time.')
def clear_mutations(self):
try:
ewutils.execute_sql_query(
"DELETE FROM mutations WHERE {id_server} = %s AND {id_user} = %s"
.format(id_server=ewcfg.col_id_server,
id_user=ewcfg.col_id_user),
(self.id_server, self.id_user))
except:
ewutils.logMsg("Failed to clear mutations for user {}.".format(
self.id_user))
def clear_allstatuses(self):
try:
ewutils.execute_sql_query("DELETE FROM status_effects WHERE {id_server} = %s AND {id_user} = %s".format(
id_server = ewcfg.col_id_server,
id_user = ewcfg.col_id_user
),(
self.id_server,
self.id_user
))
except:
ewutils.logMsg("Failed to clear status effects for user {}.".format(self.id_user))
async def on_member_join(member):
ewutils.logMsg("New member \"{}\" joined. Configuring default roles now.".format(member.display_name))
await ewrolemgr.updateRoles(client = client, member = member)
ewplayer.player_update(
member = member,
server = member.server
)
user_data = EwUser(member = member)
if user_data.poi in ewcfg.tutorial_pois:
await ewdungeons.begin_tutorial(member)
async def event_tick(id_server):
time_now = int(time.time())
resp_cont = ewutils.EwResponseContainer(id_server=id_server)
if True:
data = ewutils.execute_sql_query(
"SELECT {id_event} FROM world_events WHERE {time_expir} <= %s AND {time_expir} > 0 AND id_server = %s"
.format(
id_event=ewcfg.col_id_event,
time_expir=ewcfg.col_time_expir,
), (
time_now,
id_server,
))
for row in data:
event_data = EwWorldEvent(id_event=row[0])
event_def = ewcfg.event_type_to_def.get(event_data.event_type)
response = event_def.str_event_end
if event_data.event_type == ewcfg.event_type_minecollapse:
user_data = EwUser(
id_user=event_data.event_props.get('id_user'),
id_server=id_server)
if user_data.poi == event_data.event_props.get('poi'):
user_data.change_slimes(n=-(user_data.slimes * 0.5))
user_data.persist()
player_data = EwPlayer(id_user=user_data.id_user)
response = "*{}*: You have lost an arm and a leg in a mining accident. Tis but a scratch.".format(
player_data.display_name)
if len(response) > 0:
poi = event_data.event_props.get('poi')
channel = event_data.event_props.get('channel')
if channel != None:
resp_cont.add_channel_response(channel, response)
elif poi != None:
poi_def = ewcfg.id_to_poi.get(poi)
if poi_def != None:
resp_cont.add_channel_response(poi_def.channel,
response)
else:
for ch in ewcfg.hideout_channels:
resp_cont.add_channel_response(ch, response)
delete_world_event(event_data.id_event)
await resp_cont.post()
else:
ewutils.logMsg("Error in event tick for server {}".format(id_server))
def __init__(self, id_item=None):
if (id_item != None):
self.id_item = id_item
# the item props don't reset themselves automatically which is why the items_prop table had tons of extraneous rows (like food items having medal_names)
self.item_props.clear()
try:
conn_info = ewutils.databaseConnect()
conn = conn_info.get('conn')
cursor = conn.cursor()
# Retrieve object
cursor.execute(
"SELECT {}, {}, {}, {}, {}, {}, {} FROM items WHERE id_item = %s"
.format(ewcfg.col_id_server, ewcfg.col_id_user,
ewcfg.col_item_type, ewcfg.col_time_expir,
ewcfg.col_stack_max, ewcfg.col_stack_size,
ewcfg.col_soulbound), (self.id_item, ))
result = cursor.fetchone()
if result != None:
# Record found: apply the data to this object.
self.id_server = result[0]
self.id_user = result[1]
self.item_type = result[2]
self.time_expir = result[3]
self.stack_max = result[4]
self.stack_size = result[5]
self.soulbound = (result[6] != 0)
# Retrieve additional properties
cursor.execute(
"SELECT {}, {} FROM items_prop WHERE id_item = %s".
format(ewcfg.col_name,
ewcfg.col_value), (self.id_item, ))
for row in cursor:
# this try catch is only necessary as long as extraneous props exist in the table
try:
self.item_props[row[0]] = row[1]
except:
ewutils.logMsg(
"extraneous item_prop row detected.")
else:
# Item not found.
self.id_item = -1
finally:
# Clean up the database handles.
cursor.close()
ewutils.databaseClose(conn_info)
async def restoreRoleNames(cmd):
member = cmd.message.author
if not member.guild_permissions.administrator:
return
client = cmd.client
server = member.guild
role_counter = 0
ewutils.logMsg('Attempting to restore all role names...')
for poi in ewcfg.poi_list:
# Slow down just a bit every 20 Role change attempts
if role_counter >= 20:
role_counter = 0
await asyncio.sleep(5)
try:
role_data = EwRole(id_server=server.id, name=poi.role)
for role in server.roles:
if role.id == int(role_data.id_role):
role_counter += 1
await role.edit(name=role_data.name)
except:
ewutils.logMsg('Failed to restore role name for {}'.format(
poi.role))
try:
major_role_data = EwRole(id_server=server.id, name=poi.major_role)
for role in server.roles:
if role.id == int(major_role_data.id_role):
role_counter += 1
await role.edit(name=major_role_data.name)
except:
ewutils.logMsg('Failed to restore role name for {}'.format(
poi.major_role))
try:
minor_role_data = EwRole(id_server=server.id, name=poi.minor_role)
for role in server.roles:
if role.id == int(minor_role_data.id_role):
role_counter += 1
await role.edit(name=minor_role_data.name)
except:
ewutils.logMsg('Failed to restore role name for {}'.format(
poi.minor_role))
ewutils.logMsg('Finished restoring roles!')
def persist(self):
try:
ewutils.execute_sql_query(
"REPLACE INTO companies({recent_profits}, {total_profits}, {id_server}, {stock}) VALUES(%s,%s,%s,%s)"
.format(recent_profits=ewcfg.col_recent_profits,
total_profits=ewcfg.col_total_profits,
id_server=ewcfg.col_id_server,
stock=ewcfg.col_stock),
(self.recent_profits, self.total_profits, self.id_server,
self.id_stock))
except:
ewutils.logMsg("Failed to save company {} to the database.".format(
self.id_stock))
async def hideRoleNames(client=None, id_server=""):
server = client.get_server(id_server)
roles_map = ewutils.getRoleMap(server.roles)
for poi in ewcfg.poi_list:
try:
if poi.role in roles_map:
role = roles_map[poi.role]
await client.edit_role(server=server,
role=role,
name=ewcfg.generic_role_name)
except:
ewutils.logMsg('Failed to hide role name for {}'.format(poi.role))
async def recreateRoles(cmd):
member = cmd.message.author
if not member.guild_permissions.administrator:
return
client = cmd.client
server = client.get_guild(cmd.guild.id)
server_role_names = []
for role in server.roles:
server_role_names.append(role.name)
# print(server_role_names)
roles_created = 0
for poi in ewcfg.poi_list:
# if poi.role != None:
#
# if poi.role not in server_role_names:
# await server.create_role(name=poi.role)
# ewutils.logMsg('created role {} for poi {}'.format(poi.role, poi.id_poi))
#
# roles_created += 1
if poi.major_role != None and poi.major_role != ewcfg.role_null_major_role:
if poi.major_role not in server_role_names:
if poi.is_district:
#print(poi.major_role)
await server.create_role(name=poi.major_role)
ewutils.logMsg('created major role {} for poi {}'.format(
poi.major_role, poi.id_poi))
roles_created += 1
if poi.minor_role != None and poi.minor_role != ewcfg.role_null_minor_role:
if poi.minor_role not in server_role_names:
if poi.is_district or poi.is_street:
await server.create_role(name=poi.minor_role)
ewutils.logMsg('created minor role {} for poi {}'.format(
poi.minor_role, poi.id_poi))
roles_created += 1
print('{} roles were created in recreateRoles.'.format(roles_created))
def get_enemies_in_district(self,
min_level = 0,
max_level = math.inf,
min_slimes = -math.inf,
max_slimes = math.inf,
scout_used = False,
classes = None,
):
client = ewutils.get_client()
server = client.get_guild(self.id_server)
if server == None:
ewutils.logMsg("error: couldn't find server with id {}".format(self.id_server))
return []
enemies = ewutils.execute_sql_query("SELECT {id_enemy}, {slimes}, {level}, {enemytype}, {enemyclass} FROM enemies WHERE id_server = %s AND {poi} = %s AND {life_state} = 1".format(
id_enemy = ewcfg.col_id_enemy,
slimes = ewcfg.col_enemy_slimes,
level = ewcfg.col_enemy_level,
enemytype = ewcfg.col_enemy_type,
enemyclass = ewcfg.col_enemy_class,
poi = ewcfg.col_enemy_poi,
life_state = ewcfg.col_enemy_life_state
),(
self.id_server,
self.name
))
filtered_enemies = []
for enemy_data_column in enemies:
fetched_id_enemy = enemy_data_column[0] # data from id_enemy column in enemies table
fetched_slimes = enemy_data_column[1] # data from slimes column in enemies table
fetched_level = enemy_data_column[2] # data from level column in enemies table
fetched_type = enemy_data_column[3] # data from enemytype column in enemies table
fetched_class = enemy_data_column[4] # data from enemyclass column in enemies table
# Append the enemy to the list if it meets the requirements
if max_level >= fetched_level >= min_level \
and max_slimes >= fetched_slimes >= min_slimes:
if classes != None:
if fetched_class in classes:
filtered_enemies.append(fetched_id_enemy)
else:
filtered_enemies.append(fetched_id_enemy)
# Don't show sandbags on !scout
if scout_used and fetched_type == ewcfg.enemy_type_sandbag:
filtered_enemies.remove(fetched_id_enemy)
return filtered_enemies
