async def revive(cmd):
time_now = int(time.time())
response = ""
if cmd.message.channel.name != ewcfg.channel_endlesswar and cmd.message.channel.name != ewcfg.channel_sewers:
response = "Come to me. I hunger. #{}.".format(ewcfg.channel_sewers)
else:
player_data = EwUser(member = cmd.message.author)
slimeoid = EwSlimeoid(member = cmd.message.author)
if player_data.life_state == ewcfg.life_state_corpse:
market_data = EwMarket(id_server = cmd.message.server.id)
# Endless War collects his fee.
fee = (player_data.slimecredit / 10)
player_data.change_slimecredit(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
# Give player some initial slimes.
player_data.slimelevel = 0
player_data.change_slimes(n = ewcfg.slimes_onrevive)
# Set time of last revive. This used to provied spawn protection, but currently isn't used.
player_data.time_lastrevive = time_now
# Set life state. This is what determines whether the player is actually alive.
player_data.life_state = ewcfg.life_state_juvenile
# Get the player out of the sewers. Will be endless-war eventually.
player_data.poi = ewcfg.poi_id_downtown
player_data.persist()
market_data.persist()
# Give some slimes to every living player (currently online)
for member in cmd.message.server.members:
if member.id != cmd.message.author.id and member.id != cmd.client.user.id:
member_data = EwUser(member = member)
if member_data.life_state != ewcfg.life_state_corpse and member_data.life_state != ewcfg.life_state_grandfoe:
member_data.change_slimes(n = ewcfg.slimes_onrevive_everyone)
member_data.persist()
await ewrolemgr.updateRoles(client = cmd.client, member = cmd.message.author)
response = '{slime4} A geyser of fresh slime erupts, showering Rowdy, Killer, and Juvenile alike. {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) + ewutils.formatMessage(member, deathreport)
if slimeoid.life_state == ewcfg.slimeoid_state_active:
reunite = ""
brain = ewcfg.brain_map.get(slimeoid.ai)
reunite += brain.str_revive.format(
slimeoid_name = slimeoid.name
)
downtownchannel = ewutils.get_channel(cmd.message.server, ewcfg.channel_downtown)
reunite = ewutils.formatMessage(cmd.message.author, reunite)
await cmd.client.send_message(downtownchannel, reunite)
# Send the response to the player.
await cmd.client.send_message(cmd.message.channel, ewutils.formatMessage(cmd.message.author, response))
async def order(cmd):
user_data = EwUser(member=cmd.message.author)
poi = ewcfg.id_to_poi.get(user_data.poi)
if (poi == None) or (len(poi.vendors) == 0):
# Only allowed in the food court.
response = ewcfg.str_food_channelreq.format(action="order")
else:
value = None
togo = False
if cmd.tokens_count > 1:
for token in cmd.tokens[1:]:
if token.startswith('<@') == False and token.lower(
) not in "togo": # togo can be spelled together or separate
value = token
break
for token in cmd.tokens[1:]:
if token.lower(
) in "togo": # lets people get away with just typing only to or only go (or only t etc.) but whatever
togo = True
break
food = ewcfg.food_map.get(value.lower() if value != None else value)
if food != None and food.vendor == ewcfg.vendor_vendingmachine:
togo = True
member = None
if not togo: # cant order togo for someone else, you can just give it to them in person
if cmd.mentions_count == 1:
member = cmd.mentions[0]
if member.id == cmd.message.author.id:
member = None
member_data = EwUser(member=member)
if food == None or food.vendor not in poi.vendors:
response = "Check the {} for a list of items you can {}.".format(
ewcfg.cmd_menu, ewcfg.cmd_order)
elif member is not None and member_data.poi != user_data.poi:
response = "The delivery service has become unavailable due to unforeseen circumstances."
else:
market_data = EwMarket(id_server=cmd.message.server.id)
target_data = None
if member != None:
target_data = EwUser(member=member)
value = food.price if not togo else food.price * ewcfg.togo_price_increase
# Kingpins eat free.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
value = 0
if value > user_data.slimecredit:
# Not enough money.
response = "A {food} is {cost:,} SlimeCoin (and you only have {credits:,}).".format(
food=food.str_name,
cost=value,
credits=user_data.slimecredit)
else:
user_data.change_slimecredit(
n=-value, coinsource=ewcfg.coinsource_spending)
if not togo:
if target_data != None:
target_data.hunger -= food.recover_hunger
if target_data.hunger < 0:
target_data.hunger = 0
target_data.inebriation += food.inebriation
if target_data.inebriation > ewcfg.inebriation_max:
target_data.inebriation = ewcfg.inebriation_max
if food.id_food == "coleslaw":
target_data.ghostbust = True
else:
user_data.hunger -= food.recover_hunger
if user_data.hunger < 0:
user_data.hunger = 0
user_data.inebriation += food.inebriation
if user_data.inebriation > ewcfg.inebriation_max:
user_data.inebriation = ewcfg.inebriation_max
if food.id_food == "coleslaw":
user_data.ghostbust = True
else: # if it's togo
inv = ewitem.inventory(id_user=cmd.message.author.id,
id_server=cmd.message.server.id)
food_in_inv = 0
for item in inv:
if item.get('item_type') == ewcfg.it_food:
food_in_inv += 1
if food_in_inv >= math.ceil(
user_data.slimelevel / ewcfg.max_food_in_inv_mod):
# user_data never got persisted so the player won't lose money unnecessarily
response = "You can't carry any more food than that."
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
response))
item_props = {
'food_name':
food.str_name,
'food_desc':
food.str_desc,
'recover_hunger':
food.recover_hunger,
'price':
food.price,
'inebriation':
food.inebriation,
'vendor':
food.vendor,
'str_eat':
food.str_eat,
'time_expir':
time.time() + (food.time_expir if food.time_expir
is not None else ewcfg.std_food_expir)
}
ewitem.item_create(item_type=ewcfg.it_food,
id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
item_props=item_props)
response = "You slam {cost:,} SlimeCoin down at the {vendor} for a {food}{togo}{sharetext}{flavor}".format(
cost=value,
vendor=food.vendor,
food=food.str_name,
togo=" to go" if togo else "",
sharetext=(". " if member == None else
" and give it to {}.\n\n{}".format(
member.display_name,
ewutils.formatMessage(member, ""))),
flavor=food.str_eat if not togo else "")
if member == None and user_data.hunger <= 0 and not togo:
response += "\n\nYou're stuffed!"
user_data.persist()
market_data.persist()
if target_data != None:
target_data.persist()
# Send the response to the player.
await cmd.client.send_message(
cmd.message.channel, ewutils.formatMessage(cmd.message.author,
response))
async def xfer(cmd):
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_stockexchange:
# Only allowed in the stock exchange.
response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin",
action="transfer")
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
return
if cmd.mentions_count != 1:
# Must have exactly one target to send to.
response = "Mention the player you want to send SlimeCoin to."
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
return
member = cmd.mentions[0]
target_data = EwUser(member=member)
if target_data.life_state == ewcfg.life_state_kingpin:
# Disallow transfers to RF and CK kingpins.
response = "You can't transfer SlimeCoin to a known criminal warlord."
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
return
user_data = EwUser(member=cmd.message.author)
market_data = EwMarket(id_server=cmd.message.author.server.id)
# Parse the slime value to send.
value = None
if cmd.tokens_count > 1:
value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True)
if value != None:
if value < 0:
value = user_data.slimes
if value <= 0:
value = None
if value != None:
# Cost including the 5% transfer fee.
cost_total = int(value * 1.05)
if user_data.slimecredit < cost_total:
response = "You don't have enough SlimeCoin. ({:,}/{:,})".format(
user_data.slimecredit, cost_total)
else:
# Do the transfer if the player can afford it.
target_data.change_slimecredit(
n=value, coinsource=ewcfg.coinsource_transfer)
user_data.change_slimecredit(n=-cost_total,
coinsource=ewcfg.coinsource_transfer)
user_data.time_lastinvest = time_now
# Persist changes
response = "You transfer {slime:,} SlimeCoin to {target_name}. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format(
slime=value,
target_name=member.display_name,
fee=(cost_total - value))
user_data.persist()
target_data.persist()
else:
response = ewcfg.str_exchange_specify.format(currency="SlimeCoin",
action="transfer")
# Send the response to the player.
await cmd.client.send_message(
cmd.message.channel, ewutils.formatMessage(cmd.message.author,
response))
async def data(cmd):
resp = await start(cmd = cmd)
response = ""
user_data = None
roles_map_user = {}
if cmd.mentions_count == 0:
roles_map_user = ewutils.getRoleMap(cmd.message.author.roles)
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member = cmd.message.author, conn = conn, cursor = cursor)
market_data = EwMarket(id_server = cmd.message.server.id, conn = conn, cursor = cursor)
new_level = 0
# Ghosts don't have a slime level.
if ewcfg.role_corpse not in roles_map_user:
new_level = len(str(int(user_data.slimes)))
# Update the user's slime level.
if new_level > user_data.slimelevel:
user_data.slimelevel = new_level
user_data.persist(conn = conn, cursor = cursor)
conn.commit()
finally:
cursor.close()
conn.close()
# return my data
if ewcfg.role_corpse in roles_map_user:
response = "You are a level {} deadboi.".format(user_data.slimelevel)
else:
response = "You are a level {} slimeboi.".format(user_data.slimelevel)
coinbounty = int(user_data.bounty / (market_data.rate_exchange / 1000000.0))
weapon = ewcfg.weapon_map.get(user_data.weapon)
if weapon != None:
response += " {} {}{}.".format(ewcfg.str_weapon_wielding_self, ("" if len(user_data.weaponname) == 0 else "{}, ".format(user_data.weaponname)), weapon.str_weapon)
if user_data.weaponskill >= 5:
response += " {}".format(weapon.str_weaponmaster_self.format(rank = (user_data.weaponskill - 4)))
trauma = ewcfg.weapon_map.get(user_data.trauma)
if trauma != None:
response += " {}".format(trauma.str_trauma_self)
if user_data.kills > 0:
response += " You have {:,} confirmed kills.".format(user_data.kills)
if coinbounty != 0:
response += " SlimeCorp offers a bounty of {:,} SlimeCoin for your death.".format(coinbounty)
if user_data.stamina > 0:
response += " You are {}% hungry.".format(user_data.stamina * 100.0 / ewcfg.stamina_max)
else:
member = cmd.mentions[0]
roles_map_user = ewutils.getRoleMap(member.roles)
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member = member, conn = conn, cursor = cursor)
market_data = EwMarket(id_server = cmd.message.server.id, conn = conn, cursor = cursor)
new_level = 0
if ewcfg.role_corpse not in roles_map_target:
new_level = len(str(int(user_data.slimes)))
if new_level > user_data.slimelevel:
user_data.slimelevel = new_level
user_data.persist(conn = conn, cursor = cursor)
conn.commit()
finally:
cursor.close()
conn.close()
# return somebody's score
if ewcfg.role_corpse in roles_map_target:
response = "{} is a level {} deadboi.".format(member.display_name, user_data.slimelevel)
else:
response = "{} is a level {} slimeboi.".format(member.display_name, user_data.slimelevel)
coinbounty = int(user_data.bounty / (market_data.rate_exchange / 1000000.0))
weapon = ewcfg.weapon_map.get(user_data.weapon)
if weapon != None:
response += " {} {}{}.".format(ewcfg.str_weapon_wielding, ("" if len(user_data.weaponname) == 0 else "{}, ".format(user_data.weaponname)), weapon.str_weapon)
if user_data.weaponskill >= 5:
response += " {}".format(weapon.str_weaponmaster.format(rank = (user_data.weaponskill - 4)))
trauma = ewcfg.weapon_map.get(user_data.trauma)
if trauma != None:
response += " {}".format(trauma.str_trauma)
if user_data.kills > 0:
response += " They have {:,} confirmed kills.".format(user_data.kills)
if coinbounty != 0:
response += " SlimeCorp offers a bounty of {:,} SlimeCoin for their death.".format(coinbounty)
# Update the user's slime level if they're alive.
if user_data != None:
new_level = 0
if ewcfg.role_corpse not in roles_map_user:
new_level = len(str(int(user_data.slimes)))
if new_level > user_data.slimelevel:
user_data.slimelevel = new_level
user_data.persist()
# Send the response to the player.
await cmd.client.edit_message(resp, ewutils.formatMessage(cmd.message.author, response))
async def on_ready():
ewutils.logMsg('Logged in as {} ({}).'.format(client.user.name,
client.user.id))
ewutils.logMsg("Loaded NLACakaNM world map. ({}x{})".format(
ewmap.map_width, ewmap.map_height))
ewmap.map_draw()
# Flatten role names to all lowercase, no spaces.
for poi in ewcfg.poi_list:
if poi.role != None:
poi.role = ewutils.mapRoleName(poi.role)
await client.change_presence(game=discord.Game(name=("dev. by @krak " +
ewcfg.version)))
# Look for a Twitch client_id on disk.
# FIXME debug - temporarily disable Twitch integration
if False:
twitch_client_id = ewutils.getTwitchClientId()
# If no twitch client ID is available, twitch integration will be disabled.
# FIXME debug - temporarily disable Twitch integration.
if True:
twich_client_id = None
ewutils.logMsg('Twitch integration disabled.')
elif twitch_client_id == None or len(twitch_client_id) == 0:
ewutils.logMsg(
'No twitch_client_id file found. Twitch integration disabled.')
else:
ewutils.logMsg("Enabled Twitch integration.")
# Channels in the connected discord servers to announce to.
channels_announcement = []
# Channels in the connected discord servers to send stock market updates to. Map of server ID to channel.
channels_stockmarket = {}
for server in client.servers:
# Update server data in the database
ewserver.server_update(server=server)
# store the list of channels in an ewutils field
ewcfg.update_server_list(server=server)
# Grep around for channels
ewutils.logMsg("connected to server: {}".format(server.name))
for channel in server.channels:
if (channel.type == discord.ChannelType.text):
if (channel.name == ewcfg.channel_twitch_announcement):
channels_announcement.append(channel)
ewutils.logMsg(
"• found channel for announcements: {}".format(
channel.name))
elif (channel.name == ewcfg.channel_stockexchange):
channels_stockmarket[server.id] = channel
ewutils.logMsg(
"• found channel for stock exchange: {}".format(
channel.name))
# create all the districts in the database
for poi in ewcfg.capturable_districts:
# call the constructor to create an entry if it doesnt exist yet
dist = EwDistrict(id_server=server.id, district=poi)
# change the ownership to the faction that's already in control to initialize topic names
try:
await dist.change_ownership(new_owner=dist.controlling_faction,
actor="init",
client=client)
except:
ewutils.logMsg(
'Could not change ownership for {} to "{}".'.format(
poi, dist.controlling_faction))
asyncio.ensure_future(
ewdistrict.capture_tick_loop(id_server=server.id))
try:
ewutils.logMsg('Creating message queue directory.')
os.mkdir(ewcfg.dir_msgqueue)
except FileExistsError:
ewutils.logMsg('Message queue directory already exists.')
ewutils.logMsg('Ready.')
ewcfg.set_client(client)
"""
Set up for infinite loop to perform periodic tasks.
"""
time_now = int(time.time())
time_last_twitch = time_now
time_twitch_downed = 0
# Every three hours we log a message saying the periodic task hook is still active. On startup, we want this to happen within about 60 seconds, and then on the normal 3 hour interval.
time_last_logged = time_now - ewcfg.update_hookstillactive + 60
stream_live = None
ewutils.logMsg('Beginning periodic hook loop.')
while True:
time_now = int(time.time())
# Periodic message to log that this stuff is still running.
if (time_now - time_last_logged) >= ewcfg.update_hookstillactive:
time_last_logged = time_now
ewutils.logMsg("Periodic hook still active.")
# Check to see if a stream is live via the Twitch API.
# FIXME disabled
if False:
#if twitch_client_id != None and (time_now - time_last_twitch) >= ewcfg.update_twitch:
time_last_twitch = time_now
try:
# Twitch API call to see if there are any active streams.
json_string = ""
p = subprocess.Popen(
"curl -H 'Client-ID: {}' -X GET 'https://api.twitch.tv/helix/streams?user_login = rowdyfrickerscopkillers' 2>/dev/null"
.format(twitch_client_id),
shell=True,
stdout=subprocess.PIPE)
for line in p.stdout.readlines():
json_string += line.decode('utf-8')
json_parsed = json.loads(json_string)
# When a stream is up, data is an array of stream information objects.
data = json_parsed.get('data')
if data != None:
data_count = len(data)
stream_was_live = stream_live
stream_live = True if data_count > 0 else False
if stream_was_live == True and stream_live == False:
time_twitch_downed = time_now
if stream_was_live == False and stream_live == True and (
time_now - time_twitch_downed) > 600:
ewutils.logMsg("The stream is now live.")
# The stream has transitioned from offline to online. Make an announcement!
for channel in channels_announcement:
await client.send_message(
channel,
"ATTENTION CITIZENS. THE **ROWDY F****R** AND THE **COP KILLER** ARE **STREAMING**. BEWARE OF INCREASED KILLER AND ROWDY ACTIVITY.\n\n@everyone\n{}"
.format(
"https://www.twitch.tv/rowdyfrickerscopkillers"
))
except:
ewutils.logMsg(
'Twitch handler hit an exception (continuing): {}'.format(
json_string))
traceback.print_exc(file=sys.stdout)
# Adjust the exchange rate of slime for the market.
try:
for server in client.servers:
# Load market data from the database.
market_data = EwMarket(id_server=server.id)
if market_data.time_lasttick + ewcfg.update_market <= time_now:
market_data.time_lasttick = time_now
# Advance the time and potentially change weather.
market_data.clock += 1
if market_data.clock >= 24 or market_data.clock < 0:
market_data.clock = 0
market_data.day += 1
if random.randrange(30) == 0:
pattern_count = len(ewcfg.weather_list)
if pattern_count > 1:
weather_old = market_data.weather
# Randomly select a new weather pattern. Try again if we get the same one we currently have.
while market_data.weather == weather_old:
pick = random.randrange(len(
ewcfg.weather_list))
market_data.weather = ewcfg.weather_list[
pick].name
# Log message for statistics tracking.
ewutils.logMsg(
"The weather changed. It's now {}.".format(
market_data.weather))
# Persist new data.
market_data.persist()
# Decay slime totals
ewutils.decaySlimes(id_server=server.id)
# Increase hunger for all players below the max.
ewutils.pushupServerHunger(id_server=server.id)
# Decrease inebriation for all players above min (0).
ewutils.pushdownServerInebriation(id_server=server.id)
await ewdistrict.give_kingpins_slime_and_decay_capture_points(
id_server=server.id)
# Post leaderboards at 6am NLACakaNM time.
if market_data.clock == 6:
await ewleaderboard.post_leaderboards(client=client,
server=server)
except:
ewutils.logMsg(
'An error occurred in the scheduled slime market update task:')
traceback.print_exc(file=sys.stdout)
# Parse files dumped into the msgqueue directory and send messages as needed.
try:
for msg_file in os.listdir(ewcfg.dir_msgqueue):
fname = "{}/{}".format(ewcfg.dir_msgqueue, msg_file)
msg = ewutils.readMessage(fname)
os.remove(fname)
msg_channel_names = []
msg_channel_names_reverb = []
if msg.channel != None:
msg_channel_names.append(msg.channel)
if msg.poi != None:
poi = ewcfg.id_to_poi.get(msg.poi)
if poi != None:
if poi.channel != None and len(poi.channel) > 0:
msg_channel_names.append(poi.channel)
if msg.reverb == True:
pois_adjacent = ewmap.path_to(poi_start=msg.poi)
for poi_adjacent in pois_adjacent:
if poi_adjacent.channel != None and len(
poi_adjacent.channel) > 0:
msg_channel_names_reverb.append(
poi_adjacent.channel)
if len(msg_channel_names) == 0:
ewutils.logMsg(
'in file {} message for channel {} (reverb {})\n{}'.
format(msg_file, msg.channel, msg.reverb, msg.message))
else:
# Send messages to every connected server.
for server in client.servers:
for channel in server.channels:
if channel.name in msg_channel_names:
await client.send_message(
channel, "**{}**".format(msg.message))
elif channel.name in msg_channel_names_reverb:
await client.send_message(
channel,
"**Something is happening nearby...\n\n{}**"
.format(msg.message))
except:
ewutils.logMsg(
'An error occurred while trying to process the message queue:')
traceback.print_exc(file=sys.stdout)
# Wait a while before running periodic tasks.
await asyncio.sleep(15)
async def order(cmd):
resp = await ewcmd.start(cmd=cmd)
if cmd.message.channel.name != ewcfg.channel_foodcourt:
# Only allowed in the food court.
response = ewcfg.str_food_channelreq.format(action="order")
else:
value = None
if cmd.tokens_count > 1:
for token in cmd.tokens[1:]:
if token.startswith('<@') == False:
value = token
break
food = ewcfg.food_map.get(value)
member = None
if cmd.mentions_count == 1:
member = cmd.mentions[0]
if member.id == cmd.message.author.id:
member = None
if food == None:
response = "Check the {} for a list of items you can {}.".format(
ewcfg.cmd_menu, ewcfg.cmd_order)
else:
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
market_data = EwMarket(id_server=cmd.message.server.id,
conn=conn,
cursor=cursor)
target_data = None
if member != None:
target_data = EwUser(member=member,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
value = int(food.price / (market_data.rate_exchange / 1000000.0))
if value <= 0:
value = 1
# Kingpins eat free.
roles_map_user = ewutils.getRoleMap(cmd.message.author.roles)
if ewcfg.role_rowdyfucker in roles_map_user or ewcfg.role_copkiller in roles_map_user:
value = 0
if value > user_data.slimecredit:
# Not enough money.
response = "A {food} is {cost:,} SlimeCoin (and you only have {credits:,}).".format(
food=food.str_name,
cost=value,
credits=user_data.slimecredit)
else:
user_data.slimecredit -= value
if target_data != None:
target_data.stamina -= food.recover_stamina
if target_data.stamina < 0:
target_data.stamina = 0
target_data.inebriation += food.inebriation
if target_data.inebriation > 20:
target_data.inebriation = 20
else:
user_data.stamina -= food.recover_stamina
if user_data.stamina < 0:
user_data.stamina = 0
user_data.inebriation += food.inebriation
if user_data.inebriation > 20:
user_data.inebriation = 20
market_data.slimes_casino += food.price
response = "You slam {cost:,} SlimeCoin down at the {vendor} for a {food}{sharetext}{flavor}".format(
cost=value,
vendor=food.vendor,
food=food.str_name,
sharetext=(". " if member == None else
" and give it to {}.\n\n{}".format(
member.display_name,
ewutils.formatMessage(member, ""))),
flavor=food.str_eat)
if member == None and user_data.stamina <= 0:
response += "\n\nYou're stuffed!"
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data.persist(conn=conn, cursor=cursor)
market_data.persist(conn=conn, cursor=cursor)
if target_data != None:
target_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def mine(cmd):
market_data = EwMarket(id_server=cmd.message.author.server.id)
user_data = EwUser(member=cmd.message.author)
time_now = int(time.time())
# Kingpins can't mine.
if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe:
return
# ghosts cant mine (anymore)
if user_data.life_state == ewcfg.life_state_corpse:
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You can't mine while you're dead. Try {}.".format(
ewcfg.cmd_revive)))
# Enlisted players only mine at certain times.
if user_data.life_state == ewcfg.life_state_enlisted:
if user_data.faction == ewcfg.faction_rowdys and (
market_data.clock < 8 or market_data.clock > 17):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Rowdies only mine in the daytime. Wait for full daylight at 8am."
.format(ewcfg.cmd_revive)))
if user_data.faction == ewcfg.faction_killers and (
market_data.clock < 20 and market_data.clock > 5):
return await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"Killers only mine under cover of darkness. Wait for nightfall at 8pm."
.format(ewcfg.cmd_revive)))
# Mine only in the mines.
if cmd.message.channel.name in [
ewcfg.channel_mines, ewcfg.channel_cv_mines, ewcfg.channel_tt_mines
]:
if user_data.hunger >= ewutils.hunger_max_bylevel(
user_data.slimelevel):
global last_mismined_times
mismined = last_mismined_times.get(cmd.message.author.id)
if mismined == None:
mismined = {'time': time_now, 'count': 0}
if time_now - mismined['time'] < 5:
mismined['count'] += 1
else:
# Reset counter.
mismined['time'] = time_now
mismined['count'] = 1
last_mismined_times[cmd.message.author.id] = mismined
if mismined[
'count'] >= 7: # up to 6 messages can be buffered by discord and people have been dying unfairly because of that
# Death
last_mismined_times[cmd.message.author.id] = None
user_data.die(cause=ewcfg.cause_mining)
user_data.persist()
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You have died in a mining accident."))
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await cmd.client.send_message(
sewerchannel, "{} ".format(ewcfg.emote_slimeskull) +
ewutils.formatMessage(
cmd.message.author,
"You have died in a mining accident. {}".format(
ewcfg.emote_slimeskull)))
else:
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(
cmd.message.author,
"You've exhausted yourself from mining. You'll need some refreshment before getting back to work."
))
else:
# Determine if a poudrin is found.
poudrin = False
poudrinamount = 0
# juvies get poudrins 4 times as often as enlisted players
poudrin_rarity = ewcfg.poudrin_rarity / (
2 if user_data.life_state == ewcfg.life_state_juvenile else 1)
poudrin_mined = random.randint(1, poudrin_rarity)
if poudrin_mined == 1:
poudrin = True
poudrinamount = 1 if random.randint(
1, 3) != 1 else 2 # 33% chance of extra drop
user_initial_level = user_data.slimelevel
# Add mined slime to the user.
slime_bylevel = ewutils.slime_bylevel(user_data.slimelevel)
mining_yield = math.floor((slime_bylevel / 10) + 1)
alternate_yield = math.floor(200 + slime_bylevel**(1 / math.e))
mining_yield = min(mining_yield, alternate_yield)
user_data.change_slimes(n=mining_yield, source=ewcfg.source_mining)
was_levelup = True if user_initial_level < user_data.slimelevel else False
# Create and give slime poudrins
for pdx in range(poudrinamount):
item_id = ewitem.item_create(
item_type=ewcfg.it_slimepoudrin,
id_user=cmd.message.author.id,
id_server=cmd.message.server.id,
)
ewutils.logMsg(
'Created poudrin (item {}) for user (id {})'.format(
item_id, cmd.message.author.id))
# Fatigue the miner.
hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel)
extra = hunger_cost_mod - int(
hunger_cost_mod
) # extra is the fractional part of hunger_cost_mod
user_data.hunger += ewcfg.hunger_permine * int(hunger_cost_mod)
if extra > 0: # if hunger_cost_mod is not an integer
# there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100)
if random.randint(1, 100) <= extra * 100:
user_data.hunger += ewcfg.hunger_permine
user_data.persist()
# Tell the player their slime level increased and/or a poudrin was found.
if was_levelup or poudrin:
response = ""
if poudrin:
if poudrinamount == 1:
response += "You unearthed a slime poudrin! "
elif poudrinamount == 2:
response += "You unearthed two slime poudrins! "
ewstats.change_stat(user=user_data,
metric=ewcfg.stat_lifetime_poudrins,
n=poudrinamount)
ewutils.logMsg('{} has found {} poudrin(s)!'.format(
cmd.message.author.display_name, poudrinamount))
if was_levelup:
response += "You have been empowered by slime and are now a level {} slimeboi!".format(
user_data.slimelevel)
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author, response))
else:
# Mismined. Potentially kill the player for spamming the wrong channel.
mismined = last_mismined_times.get(cmd.message.author.id)
if mismined == None:
mismined = {'time': time_now, 'count': 0}
if time_now - mismined['time'] < 5:
mismined['count'] += 1
else:
# Reset counter.
mismined['time'] = time_now
mismined['count'] = 1
last_mismined_times[cmd.message.author.id] = mismined
if mismined['count'] >= 5:
# Death
last_mismined_times[cmd.message.author.id] = None
user_data.die(cause=ewcfg.cause_mining)
user_data.persist()
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
"You have died in a mining accident."))
await ewrolemgr.updateRoles(client=cmd.client,
member=cmd.message.author)
sewerchannel = ewutils.get_channel(cmd.message.server,
ewcfg.channel_sewers)
await cmd.client.send_message(
sewerchannel,
"{} ".format(ewcfg.emote_slimeskull) + ewutils.formatMessage(
cmd.message.author,
"You have died in a mining accident. {}".format(
ewcfg.emote_slimeskull)))
else:
await cmd.client.send_message(
cmd.message.channel,
ewutils.formatMessage(cmd.message.author,
"You can't mine here. Go to the mines."))
async def pachinko(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
global last_pachinkoed_times
last_used = last_pachinkoed_times.get(cmd.message.author.id)
if last_used == None:
last_used = 0
response = ""
if last_used + 10 > time_now:
response = "**ENOUGH**"
elif cmd.message.channel.name != ewcfg.channel_casino:
# Only allowed in the slime casino.
response = "You must go to the #{} to gamble your SlimeCoin.".format(
ewcfg.channel_casino)
else:
last_pachinkoed_times[cmd.message.author.id] = time_now
value = ewcfg.slimes_perpachinko
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
market_data = EwMarket(id_server=cmd.message.server.id,
conn=conn,
cursor=cursor)
user_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
if ewcmd.is_casino_open(market_data.clock) == False:
response = ewcfg.str_casino_closed
elif value > user_data.slimecredit:
response = "You don't have enough SlimeCoin to play."
else:
#subtract slimecoin from player
user_data.slimecredit -= value
user_data.persist()
await cmd.client.edit_message(
resp,
ewutils.formatMessage(
cmd.message.author,
"You insert {:,} SlimeCoin. Balls begin to drop!".format(
ewcfg.slimes_perpachinko)))
await asyncio.sleep(3)
ball_count = 10
response = ""
winballs = 0
# Drop ball_count balls
while ball_count > 0:
ball_count -= 1
roll = random.randint(1, 5)
response += "\n*plink*"
# Add a varying number of plinks to make it feel more random.
plinks = random.randint(1, 4)
while plinks > 0:
plinks -= 1
response += " *plink*"
response += " PLUNK"
# 1/5 chance to win.
if roll == 5:
response += " ... **ding!**"
winballs += 1
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
await asyncio.sleep(1)
winnings = winballs * 250
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
# Significant time has passed since the user issued this command. We can't trust that their data hasn't changed.
user_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
# add winnings
user_data.slimecredit += winnings
user_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
if winnings > 0:
response += "\n\n**You won {:,} SlimeCoin!**".format(winnings)
else:
response += "\n\nYou lost your SlimeCoin."
# Allow the player to pachinko again now that we're done.
last_pachinkoed_times[cmd.message.author.id] = 0
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def attack(cmd):
resp = await ewcmd.start(cmd)
time_now = int(time.time())
response = ""
user_data = EwUser(member=cmd.message.author)
if cmd.message.channel.name != ewcfg.channel_combatzone:
response = "You must go to the #{} to commit gang violence.".format(
ewcfg.channel_combatzone)
elif cmd.mentions_count > 1:
response = "One shot at a time!"
elif cmd.mentions_count <= 0:
response = "Your bloodlust is appreciated, but ENDLESS WAR didn\'t understand that name."
elif user_data.stamina >= ewcfg.stamina_max:
response = "You are too exhausted for gang violence right now. Go get some grub!"
elif cmd.mentions_count == 1:
# The roles assigned to the author of this message.
roles_map_user = ewutils.getRoleMap(cmd.message.author.roles)
# Get shooting player's info
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
if user_data.slimelevel <= 0:
user_data.slimelevel = 1
# Flag the shooter for PvP no matter what happens next.
user_data.time_expirpvp = ewutils.calculatePvpTimer(
user_data.time_expirpvp, (time_now + ewcfg.time_pvp_kill))
user_data.persist(conn=conn, cursor=cursor)
# Get target's info.
member = cmd.mentions[0]
shootee_data = EwUser(member=member, conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
miss = False
crit = False
strikes = 0
# Shot player's assigned Discord roles.
roles_map_target = ewutils.getRoleMap(member.roles)
# Slime level data. Levels are in powers of 10.
slimes_bylevel = int((10**user_data.slimelevel) / 10)
slimes_spent = int(slimes_bylevel / 10)
slimes_damage = int((slimes_bylevel / 5.0) *
(100 + (user_data.weaponskill * 5)) / 100.0)
slimes_dropped = shootee_data.totaldamage
fumble_chance = (random.randrange(10) - 4)
if fumble_chance > user_data.weaponskill:
miss = True
user_iskillers = ewcfg.role_copkillers in roles_map_user or ewcfg.role_copkillers in roles_map_user
user_isrowdys = ewcfg.role_rowdyfuckers in roles_map_user or ewcfg.role_rowdyfucker in roles_map_user
# Add the PvP flag role.
await ewutils.add_pvp_role(cmd=cmd)
if ewcfg.role_copkiller in roles_map_target or ewcfg.role_rowdyfucker in roles_map_target:
# Disallow killing generals.
response = "He is hiding in his ivory tower and playing video games like a retard."
elif (slimes_spent > user_data.slimes):
# Not enough slime to shoot.
response = "You don't have enough slime to attack. ({:,}/{:,})".format(
user_data.slimes, slimes_spent)
elif (time_now - user_data.time_lastkill) < ewcfg.cd_kill:
# disallow kill if the player has killed recently
response = "Take a moment to appreciate your last slaughter."
elif shootee_data.id_killer == user_data.id_user:
# Don't allow the shootee to be shot by the same player twice.
response = "You have already proven your superiority over {}.".format(
member.display_name)
elif time_now > shootee_data.time_expirpvp:
# Target is not flagged for PvP.
response = "{} is not mired in the ENDLESS WAR right now.".format(
member.display_name)
elif user_iskillers == False and user_isrowdys == False:
# Only killers, rowdys, the cop killer, and rowdy f****r can shoot people.
if ewcfg.role_juvenile in roles_map_user:
response = "Juveniles lack the moral fiber necessary for violence."
else:
response = "You lack the moral fiber necessary for violence."
elif ewcfg.role_corpse in roles_map_target:
# Target is already dead.
response = "{} is already dead.".format(member.display_name)
elif (time_now - shootee_data.time_lastrevive) < ewcfg.invuln_onrevive:
# User is currently invulnerable.
response = "{} has died too recently and is immune.".format(
member.display_name)
else:
# Slimes from this shot might be awarded to the boss.
role_boss = (ewcfg.role_copkiller
if user_iskillers else ewcfg.role_rowdyfucker)
boss_slimes = 0
role_corpse = cmd.roles_map[ewcfg.role_corpse]
was_juvenile = False
was_killed = False
was_shot = False
if (user_iskillers and
(ewcfg.role_rowdyfuckers in roles_map_target)) or (
user_isrowdys and
(ewcfg.role_copkillers in roles_map_target)) or (
ewcfg.role_juvenile in roles_map_target):
# User can be shot.
if ewcfg.role_juvenile in roles_map_target:
was_juvenile = True
was_shot = True
if was_shot:
#stamina drain
user_data.stamina += ewcfg.stamina_pershot
# Weaponized flavor text.
weapon = ewcfg.weapon_map.get(user_data.weapon)
randombodypart = ewcfg.hitzone_list[random.randrange(
len(ewcfg.hitzone_list))]
# Weapon-specific adjustments
if weapon != None and weapon.fn_effect != None:
# Build effect container
ctn = EwEffectContainer(miss=miss,
crit=crit,
slimes_damage=slimes_damage,
slimes_spent=slimes_spent,
user_data=user_data,
shootee_data=shootee_data)
# Make adjustments
weapon.fn_effect(ctn)
# Apply effects for non-reference values
miss = ctn.miss
crit = ctn.crit
slimes_damage = ctn.slimes_damage
slimes_spent = ctn.slimes_spent
strikes = ctn.strikes
# user_data and shootee_data should be passed by reference, so there's no need to assign them back from the effect container.
if miss:
slimes_damage = 0
# Remove !revive invulnerability.
user_data.time_lastrevive = 0
user_data.slimes -= slimes_spent
# Remove repeat killing protection if.
if user_data.id_killer == shootee_data.id_user:
user_data.id_killer = ""
# Don't allow attacking to cause you to go negative.
if user_data.slimes < 0:
user_data.slimes = 0
if slimes_damage >= shootee_data.slimes:
was_killed = True
if was_killed:
# Move around slime as a result of the shot.
if shootee_data.slimes > 0:
if was_juvenile:
user_data.slimes += (slimes_dropped +
shootee_data.slimes)
user_data.slimepoudrins += shootee_data.slimepoudrins
else:
market_data = EwMarket(
id_server=cmd.message.server.id)
coinbounty = int(
shootee_data.bounty /
(market_data.rate_exchange / 1000000.0))
user_data.slimecredit += coinbounty
user_data.slimes += int(slimes_dropped / 2)
user_data.slimepoudrins += shootee_data.slimepoudrins
boss_slimes += int(slimes_dropped / 2)
# Player was killed.
shootee_data.totaldamage += shootee_data.slimes
shootee_data.slimes = 0
shootee_data.slimepoudrins = 0
shootee_data.id_killer = user_data.id_user
shootee_data.bounty = 0
if weapon != None:
response = weapon.str_damage.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name,
hitzone=randombodypart,
strikes=strikes)
if crit:
response += " {}".format(
weapon.str_crit.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name))
response += "\n\n{}".format(
weapon.str_kill.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name,
emote_skull=ewcfg.emote_slimeskull))
shootee_data.trauma = weapon.id_weapon
else:
response = "{name_target} is hit!!\n\n{name_target} has died.".format(
name_target=member.display_name)
shootee_data.trauma = ""
#adjust kills bounty
user_data.kills += 1
user_data.bounty += int((shootee_data.bounty / 2) +
(shootee_data.totaldamage / 4))
# Give a bonus to the player's weapon skill for killing a stronger player.
if shootee_data.slimelevel > user_data.slimelevel:
user_data.weaponskill += 1
else:
# A non-lethal blow!
shootee_data.slimes -= slimes_damage
shootee_data.totaldamage += slimes_damage
if weapon != None:
if miss:
response = "{}".format(
weapon.str_miss.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name))
else:
response = weapon.str_damage.format(
name_player=cmd.message.author.display_name,
name_target=member.display_name,
hitzone=randombodypart,
strikes=strikes)
if crit:
response += " {}".format(
weapon.str_crit.format(
name_player=cmd.message.author.
display_name,
name_target=member.display_name))
else:
if miss:
response = "{} is unharmed.".format(
member.display_name)
else:
response = "{} is hit!!".format(
member.display_name)
else:
response = 'ENDLESS WAR finds this betrayal stinky. He will not allow you to slaughter {}.'.format(
member.display_name)
# Level up the player if appropriate.
new_level = len(str(int(user_data.slimes)))
if new_level > user_data.slimelevel:
response += "\n\n{} has been empowered by slime and is now a level {} slimeboi!".format(
cmd.message.author.display_name, new_level)
user_data.slimelevel = new_level
# Give slimes to the boss if possible.
boss_member = None
if boss_slimes > 0:
for member_search in cmd.message.server.members:
if role_boss in ewutils.getRoleMap(member_search.roles):
boss_member = member_search
break
# Persist every users' data.
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data.persist(conn=conn, cursor=cursor)
shootee_data.persist(conn=conn, cursor=cursor)
if boss_member != None:
boss_data = EwUser(member=boss_member,
conn=conn,
cursor=cursor)
boss_data.slimes += boss_slimes
boss_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
# Assign the corpse role to the newly dead player.
if was_killed:
await cmd.client.replace_roles(member, role_corpse)
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def craps(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
global last_crapsed_times
last_used = last_crapsed_times.get(cmd.message.author.id)
if last_used == None:
last_used = 0
if last_used + 2 > time_now:
response = "**ENOUGH**"
elif cmd.message.channel.name != ewcfg.channel_casino:
# Only allowed in the slime casino.
response = "You must go to the #{} to gamble your SlimeCoin.".format(
ewcfg.channel_casino)
else:
last_crapsed_times[cmd.message.author.id] = time_now
value = None
if cmd.tokens_count > 1:
value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True)
if value != None:
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
market_data = EwMarket(id_server=cmd.message.author.server.id,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
if ewcmd.is_casino_open(market_data.clock) == False:
response = ewcfg.str_casino_closed
elif value > user_data.slimecredit:
response = "You don't have that much SlimeCoin to bet with."
else:
user_data.slimecredit -= value
roll1 = random.randint(1, 6)
roll2 = random.randint(1, 6)
emotes_dice = [
ewcfg.emote_dice1, ewcfg.emote_dice2, ewcfg.emote_dice3,
ewcfg.emote_dice4, ewcfg.emote_dice5, ewcfg.emote_dice6
]
response = " {} {}".format(emotes_dice[roll1 - 1],
emotes_dice[roll2 - 1])
if (roll1 + roll2) == 7:
winnings = 5 * value
response += "\n\n**You rolled a 7! It's your lucky day. You won {:,} SlimeCoin.**".format(
winnings)
user_data.slimecredit += winnings
else:
response += "\n\nYou didn't roll 7. You lost your SlimeCoins."
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data.persist(conn=conn, cursor=cursor)
market_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
else:
response = "Specify how much SlimeCoin you will wager."
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def slots(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
global last_slotsed_times
last_used = last_slotsed_times.get(cmd.message.author.id)
if last_used == None:
last_used = 0
if last_used + 30 > time_now:
# Rate limit slot machine action.
response = "**ENOUGH**"
elif cmd.message.channel.name != ewcfg.channel_casino:
# Only allowed in the slime casino.
response = "You must go to the #{} to gamble your SlimeCoin.".format(
ewcfg.channel_casino)
else:
value = ewcfg.slimes_perslot
last_slotsed_times[cmd.message.author.id] = time_now
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
market_data = EwMarket(id_server=cmd.message.author.server.id,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
if ewcmd.is_casino_open(market_data.clock) == False:
response = ewcfg.str_casino_closed
elif value > user_data.slimecredit:
response = "You don't have enough SlimeCoin."
else:
#subtract slimecoin from player
user_data.slimecredit -= value
user_data.persist()
# Add some suspense...
await cmd.client.edit_message(
resp,
ewutils.formatMessage(
cmd.message.author,
"You insert {:,} SlimeCoin and pull the handle...".format(
ewcfg.slimes_perslot)))
await asyncio.sleep(3)
slots = [
ewcfg.emote_tacobell, ewcfg.emote_pizzahut, ewcfg.emote_kfc,
ewcfg.emote_moon, ewcfg.emote_111, ewcfg.emote_copkiller,
ewcfg.emote_rowdyfucker, ewcfg.emote_theeye
]
slots_len = len(slots)
# Roll those tumblers!
spins = 3
while spins > 0:
await cmd.client.edit_message(
resp,
ewutils.formatMessage(
cmd.message.author, "{} {} {}".format(
slots[random.randrange(0, slots_len)],
slots[random.randrange(0, slots_len)],
slots[random.randrange(0, slots_len)])))
await asyncio.sleep(1)
spins -= 1
# Determine the final state.
roll1 = slots[random.randrange(0, slots_len)]
roll2 = slots[random.randrange(0, slots_len)]
roll3 = slots[random.randrange(0, slots_len)]
response = "{} {} {}".format(roll1, roll2, roll3)
winnings = 0
# Determine winnings.
if roll1 == ewcfg.emote_tacobell and roll2 == ewcfg.emote_tacobell and roll3 == ewcfg.emote_tacobell:
winnings = 5 * value
response += "\n\n**¡Ándale! ¡Arriba! The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_pizzahut and roll2 == ewcfg.emote_pizzahut and roll3 == ewcfg.emote_pizzahut:
winnings = 5 * value
response += "\n\n**Oven-fired goodness! The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_kfc and roll2 == ewcfg.emote_kfc and roll3 == ewcfg.emote_kfc:
winnings = 5 * value
response += "\n\n**The Colonel's dead eyes unnerve you deeply. The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif (roll1 == ewcfg.emote_tacobell or roll1 == ewcfg.emote_kfc
or roll1 == ewcfg.emote_pizzahut) and (
roll2 == ewcfg.emote_tacobell or roll2 == ewcfg.emote_kfc
or roll2 == ewcfg.emote_pizzahut) and (
roll3 == ewcfg.emote_tacobell or roll3
== ewcfg.emote_kfc or roll3 == ewcfg.emote_pizzahut):
winnings = value
response += "\n\n**You dine on fast food. The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_moon and roll2 == ewcfg.emote_moon and roll3 == ewcfg.emote_moon:
winnings = 5 * value
response += "\n\n**Tonight seems like a good night for VIOLENCE. The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_111 and roll2 == ewcfg.emote_111 and roll3 == ewcfg.emote_111:
winnings = 1111
response += "\n\n**111111111111111111111111111111111111111111111111**\n\n**The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_copkiller and roll2 == ewcfg.emote_copkiller and roll3 == ewcfg.emote_copkiller:
winnings = 40 * value
response += "\n\n**How handsome!! The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_rowdyfucker and roll2 == ewcfg.emote_rowdyfucker and roll3 == ewcfg.emote_rowdyfucker:
winnings = 40 * value
response += "\n\n**So powerful!! The machine spits out {:,} SlimeCoin.**".format(
winnings)
elif roll1 == ewcfg.emote_theeye and roll2 == ewcfg.emote_theeye and roll3 == ewcfg.emote_theeye:
winnings = 350 * value
response += "\n\n**JACKPOT!! The machine spews forth {:,} SlimeCoin!**".format(
winnings)
else:
response += "\n\n*Nothing happens...*"
# Add winnings (if there were any) and save the user data.
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
# Significant time has passed since the user issued this command. We can't trust that their data hasn't changed.
user_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
# add winnings
user_data.slimecredit += winnings
user_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
last_slotsed_times[cmd.message.author.id] = 0
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def data(cmd):
response = ""
user_data = None
member = None
if cmd.mentions_count == 0:
user_data = EwUser(member=cmd.message.author)
market_data = EwMarket(id_server=cmd.message.server.id)
poi = ewcfg.id_to_poi.get(user_data.poi)
if poi != None:
response = "You find yourself {} {}. ".format(
poi.str_in, poi.str_name)
# return my data
if user_data.life_state == ewcfg.life_state_corpse:
response += "You are a level {} deadboi.".format(
user_data.slimelevel)
else:
response += "You are a level {} slimeboi.".format(
user_data.slimelevel)
coinbounty = int(user_data.bounty / ewcfg.slimecoin_exchangerate)
weapon = ewcfg.weapon_map.get(user_data.weapon)
if weapon != None:
response += " {} {}{}.".format(
ewcfg.str_weapon_wielding_self,
("" if len(user_data.weaponname) == 0 else "{}, ".format(
user_data.weaponname)), weapon.str_weapon)
if user_data.weaponskill >= 5:
response += " {}".format(
weapon.str_weaponmaster_self.format(
rank=(user_data.weaponskill - 4)))
trauma = ewcfg.weapon_map.get(user_data.trauma)
if trauma != None:
response += " {}".format(trauma.str_trauma_self)
user_kills = ewstats.get_stat(user=user_data, metric=ewcfg.stat_kills)
if user_kills > 0:
response += " You have {:,} confirmed kills.".format(user_kills)
if coinbounty != 0:
response += " SlimeCorp offers a bounty of {:,} SlimeCoin for your death.".format(
coinbounty)
if user_data.hunger > 0:
response += " You are {}% hungry.".format(
round(
user_data.hunger * 100.0 /
ewutils.hunger_max_bylevel(user_data.slimelevel), 1))
if user_data.ghostbust:
response += " The coleslaw in your stomach enables you to bust ghosts."
if user_data.busted and user_data.life_state == ewcfg.life_state_corpse:
response += " You are busted and therefore cannot leave the sewers without reviving."
else:
member = cmd.mentions[0]
user_data = EwUser(member=member)
market_data = EwMarket(id_server=cmd.message.server.id)
if user_data.life_state == ewcfg.life_state_grandfoe:
poi = ewcfg.id_to_poi.get(user_data.poi)
if poi != None:
response = "{} is {} {}.".format(member.display_name,
poi.str_in, poi.str_name)
else:
response = "You can't discern anything useful about {}.".format(
member.display_name)
else:
# return somebody's score
if user_data.life_state == ewcfg.life_state_corpse:
response = "{} is a level {} deadboi.".format(
member.display_name, user_data.slimelevel)
else:
response = "{} is a level {} slimeboi.".format(
member.display_name, user_data.slimelevel)
coinbounty = int(user_data.bounty / ewcfg.slimecoin_exchangerate)
weapon = ewcfg.weapon_map.get(user_data.weapon)
if weapon != None:
response += " {} {}{}.".format(
ewcfg.str_weapon_wielding,
("" if len(user_data.weaponname) == 0 else "{}, ".format(
user_data.weaponname)), weapon.str_weapon)
if user_data.weaponskill >= 5:
response += " {}".format(
weapon.str_weaponmaster.format(
rank=(user_data.weaponskill - 4)))
trauma = ewcfg.weapon_map.get(user_data.trauma)
if trauma != None:
response += " {}".format(trauma.str_trauma)
user_kills = ewstats.get_stat(user=user_data,
metric=ewcfg.stat_kills)
if user_kills > 0:
response += " They have {:,} confirmed kills.".format(
user_kills)
if coinbounty != 0:
response += " SlimeCorp offers a bounty of {:,} SlimeCoin for their death.".format(
coinbounty)
# Send the response to the player.
await cmd.client.send_message(
cmd.message.channel, ewutils.formatMessage(cmd.message.author,
response))
await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author)
if member != None:
await ewrolemgr.updateRoles(client=cmd.client, member=member)
async def invest(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_stockexchange:
# Only allowed in the stock exchange.
response = ewcfg.str_exchange_channelreq.format(currency="slime",
action="invest")
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
return
roles_map_user = ewutils.getRoleMap(cmd.message.author.roles)
if ewcfg.role_rowdyfucker in roles_map_user or ewcfg.role_copkiller in roles_map_user:
# Disallow investments by RF and CK kingpins.
response = "You're too powerful to be playing the market."
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
return
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor)
market_data = EwMarket(id_server=cmd.message.author.server.id,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
if market_data.clock >= 18 or market_data.clock < 6:
response = ewcfg.str_exchange_closed
else:
value = None
if cmd.tokens_count > 1:
value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True)
if value != None:
if value < 0:
value = user_data.slimes
if value <= 0:
value = None
if value != None:
# Apply a brokerage fee of ~5% (rate * 1.05)
rate_exchange = (market_data.rate_exchange / 1000000.0)
feerate = 1.05
# The user can only buy a whole number of credits, so adjust their cost based on the actual number of credits purchased.
gross_credits = int(value / rate_exchange)
fee = int((gross_credits * feerate) - gross_credits)
net_credits = gross_credits - fee
if value > user_data.slimes:
response = "You don't have that much slime to invest."
elif user_data.time_lastinvest + ewcfg.cd_invest > time_now:
# Limit frequency of investments.
response = ewcfg.str_exchange_busy.format(action="invest")
else:
user_data.slimes -= value
user_data.slimecredit += net_credits
user_data.time_lastinvest = time_now
market_data.slimes_casino += value
response = "You invest {slime:,} slime and receive {credit:,} SlimeCoin. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format(
slime=value, credit=net_credits, fee=fee)
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data.persist(conn=conn, cursor=cursor)
market_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
else:
response = ewcfg.str_exchange_specify.format(currency="slime",
action="invest")
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def xfer(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_stockexchange:
# Only allowed in the stock exchange.
response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin",
action="transfer")
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
return
if cmd.mentions_count != 1:
# Must have exactly one target to send to.
response = "Mention the player you want to send SlimeCoin to."
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
return
member = cmd.mentions[0]
roles_map_target = ewutils.getRoleMap(member.roles)
if ewcfg.role_rowdyfucker in roles_map_target or ewcfg.role_copkiller in roles_map_target:
# Disallow transfers to RF and CK kingpins.
response = "You can't transfer SlimeCoin to a known criminal warlord."
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
return
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
target_data = EwUser(member=member, conn=conn, cursor=cursor)
user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor)
market_data = EwMarket(id_server=cmd.message.author.server.id,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
if market_data.clock >= 18 or market_data.clock < 6:
response = ewcfg.str_exchange_closed
else:
# Parse the slime value to send.
value = None
if cmd.tokens_count > 1:
value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True)
if value != None:
if value < 0:
value = user_data.slimes
if value <= 0:
value = None
if value != None:
# Cost including the 5% transfer fee.
cost_total = int(value * 1.05)
if user_data.slimecredit < cost_total:
response = "You don't have enough SlimeCoin. ({:,}/{:,})".format(
user_data.slimecredit, cost_total)
elif user_data.time_lastinvest + ewcfg.cd_invest > time_now:
# Limit frequency of investments.
response = ewcfg.str_exchange_busy.format(action="transfer")
else:
# Do the transfer if the player can afford it.
target_data.slimecredit += value
user_data.slimecredit -= cost_total
user_data.time_lastinvest = time_now
# Persist changes
response = "You transfer {slime:,} SlimeCoin to {target_name}. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format(
slime=value,
target_name=member.display_name,
fee=(cost_total - value))
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data.persist(conn=conn, cursor=cursor)
target_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
else:
response = ewcfg.str_exchange_specify.format(currency="SlimeCoin",
action="transfer")
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def withdraw(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
if cmd.message.channel.name != ewcfg.channel_stockexchange:
# Only allowed in the stock exchange.
response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin",
action="withdraw")
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
return
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data = EwUser(member=cmd.message.author, conn=conn, cursor=cursor)
market_data = EwMarket(id_server=cmd.message.author.server.id,
conn=conn,
cursor=cursor)
finally:
cursor.close()
conn.close()
if market_data.clock >= 18 or market_data.clock < 6:
response = ewcfg.str_exchange_closed
else:
value = None
if cmd.tokens_count > 1:
value = ewutils.getIntToken(tokens=cmd.tokens, allow_all=True)
if value != None:
if value < 0:
value = user_data.slimecredit
if value <= 0:
value = None
if value != None:
rate_exchange = (market_data.rate_exchange / 1000000.0)
credits = value
slimes = int(value * rate_exchange)
if value > user_data.slimecredit:
response = "You don't have that many SlimeCoin to exchange."
elif user_data.time_lastinvest + ewcfg.cd_invest > time_now:
# Limit frequency of withdrawals
response = ewcfg.str_exchange_busy.format(action="withdraw")
else:
user_data.slimes += slimes
user_data.slimecredit -= credits
user_data.time_lastinvest = time_now
market_data.slimes_casino -= slimes
# Flag the user for PvP
user_data.time_expirpvp = ewutils.calculatePvpTimer(
user_data.time_expirpvp,
(int(time.time()) + ewcfg.time_pvp_invest_withdraw))
response = "You exchange {credits:,} SlimeCoin for {slimes:,} slime.".format(
credits=credits, slimes=slimes)
# Level up the player if appropriate.
new_level = len(str(int(user_data.slimes)))
if new_level > user_data.slimelevel:
response += "\n\n{} has been empowered by slime and is now a level {} slimeboi!".format(
cmd.message.author.display_name, new_level)
user_data.slimelevel = new_level
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
user_data.persist(conn=conn, cursor=cursor)
market_data.persist(conn=conn, cursor=cursor)
conn.commit()
finally:
cursor.close()
conn.close()
# Add the visible PvP flag role.
await ewutils.add_pvp_role(cmd=cmd)
else:
response = ewcfg.str_exchange_specify.format(currency="SlimeCoin",
action="withdraw")
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
async def revive(cmd):
resp = await ewcmd.start(cmd=cmd)
time_now = int(time.time())
response = ""
if cmd.message.channel.name != ewcfg.channel_endlesswar and cmd.message.channel.name != ewcfg.channel_sewers:
response = "Come to me. I hunger. #{}.".format(ewcfg.channel_sewers)
else:
roles_map_user = ewutils.getRoleMap(cmd.message.author.roles)
if ewcfg.role_corpse in roles_map_user:
player_is_pvp = False
try:
conn = ewutils.databaseConnect()
cursor = conn.cursor()
player_data = EwUser(member=cmd.message.author,
conn=conn,
cursor=cursor)
market_data = EwMarket(id_server=cmd.message.server.id,
conn=conn,
cursor=cursor)
# Endless War collects his fee.
fee = (player_data.slimecredit / 10)
player_data.slimecredit -= fee
market_data.slimes_revivefee += fee
# Preserve negaslime
if player_data.slimes < 0:
market_data.negaslime += player_data.slimes
# Give player some initial slimes.
player_data.slimes = ewcfg.slimes_onrevive
# Clear fatigue, totaldamage, bounty, killcount.
player_data.stamina = 0
player_data.totaldamage = 0
player_data.bounty = 0
player_data.kills = 0
# Clear PvP flag.
player_data.time_expirpvp = time_now - 1
# Clear weapon and weaponskill.
player_data.weapon = ""
player_data.weaponskill = 0
ewutils.weaponskills_clear(member=cmd.message.author,
conn=conn,
cursor=cursor)
# Set time of last revive. This used to provied spawn protection, but currently isn't used.
player_data.time_lastrevive = time_now
if (player_data.time_expirpvp > time_now):
player_is_pvp = True
# Set initial slime level. It's probably 2.
player_data.slimelevel = len(str(player_data.slimes))
player_data.persist(conn=conn, cursor=cursor)
market_data.persist(conn=conn, cursor=cursor)
# Give some slimes to every living player (currently online)
for member in cmd.message.server.members:
if member.id != cmd.message.author.id and member.id != cmd.client.user.id:
if ewcfg.role_corpse not in ewutils.getRoleMap(
member.roles):
member_data = EwUser(member=member,
conn=conn,
cursor=cursor)
member_data.slimes += ewcfg.slimes_onrevive_everyone
member_data.persist(conn=conn, cursor=cursor)
# Commit all transactions at once.
conn.commit()
finally:
cursor.close()
conn.close()
if player_is_pvp:
await cmd.client.replace_roles(
cmd.message.author, cmd.roles_map[ewcfg.role_juvenile],
cmd.roles_map[ewcfg.role_juvenile_pvp])
else:
await cmd.client.replace_roles(
cmd.message.author, cmd.roles_map[ewcfg.role_juvenile])
response = '{slime4} A geyser of fresh slime erupts, showering Rowdy, Killer, and Juvenile alike. {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.'
# Send the response to the player.
await cmd.client.edit_message(
resp, ewutils.formatMessage(cmd.message.author, response))
