async def negapool(cmd): # Add persisted negative slime. market_data = EwMarket(id_server=cmd.guild.id) negaslime = market_data.negaslime await fe_utils.send_message( cmd.client, cmd.message.channel, fe_utils.formatMessage( cmd.message.author, "The dead have a total of {:,} negative slime at their disposal for summoning." .format(negaslime)))
def brickeat(item_obj): id_item = item_obj.id_item market = EwMarket(id_server=item_obj.id_server) pushedclock = ((market.clock + random.randint(6, 12)) % 24) + 1 item_obj.item_props['furniture_name'] = 'brick{:02d}'.format(pushedclock) digestion = '{}brickshit'.format(item_obj.id_owner) print(digestion) item_obj.persist() bknd_item.give_item(id_item=id_item, id_user=digestion, id_server=item_obj.id_server)
async def flutter(cmd): user_data = EwUser(member=cmd.message.author) if user_data.race == ewcfg.race_avian: district_data = EwDistrict(district=user_data.poi, id_server=cmd.guild.id) market_data = EwMarket(id_server=cmd.guild.id) response = "You flap your wings in an attempt to fly, but " excuses = [] if market_data.weather == ewcfg.weather_lightning: excuses.append("the current weather would make that a bit dangerous, so you decide not to.") if ewcfg.mutation_id_bigbones in user_data.get_mutations(): excuses.append("your bones are too big for you to get off the ground.") if ewcfg.mutation_id_lightasafeather in user_data.get_mutations(): excuses.append("your wings are too skinny to generate enough lift.") if 6 <= market_data.clock >= 20: excuses.append("it's not safe to fly at night, so you decide not to.") else: excuses.append("flying in plain daylight might get you shot off the sky, so you decide not to.") if user_data.slimes > 1000000: excuses.append("you have too much slime on you, so you don't even get off the ground.") else: excuses.append("you're too weak for this right now, gonna need to get more slime.") if user_data.life_state == ewcfg.life_state_corpse: excuses.append("your incorporeal wings generate no lift.") elif user_data.life_state == ewcfg.life_state_juvenile: excuses.append("you lack the moral fiber to do so.") else: if user_data.faction == ewcfg.faction_rowdys: excuses.append("you end up thrashing with your wings in an unorganized fashion.") if user_data.faction == ewcfg.faction_killers: excuses.append("you end up doing rapid dabs instead.") if len(district_data.get_players_in_district()) > 1: excuses.append("it's embarassing to do so with other people around.") else: excuses.append("you can't be bothered if there's no one here to see you do it.") if user_data.hunger / user_data.get_hunger_max() < 0.5: excuses.append("you're too hungry, and end up looking for worms instead.") else: excuses.append("you're too full from your last meal for such vigorous exercise.") response += random.choice(excuses) else: response = "You people are not allowed to do that." return await fe_utils.send_response(response, cmd)
async def fursuit(cmd): user_data = EwUser(member=cmd.message.author) mutations = user_data.get_mutations() market_data = EwMarket(id_server=cmd.guild.id) if ewcfg.mutation_id_organicfursuit in mutations: days_until = -market_data.day % 31 if days_until == 0: response = "Hair is beginning to grow on the surface of your skin rapidly. Your canine instincts will take over soon!" else: response = "With a basic hairy palm reading, you determine that you'll be particularly powerful in {} day{}.".format(days_until, "s" if days_until != 1 else "") if ewutils.check_fursuit_active(market_data): response = "The full moon shines above! Now's your chance to strike!" else: response = "You're about as hairless as an egg, my friend." await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def stock_market_tick(stock_data, id_server): market_data = EwMarket(id_server=id_server) company_data = EwCompany(id_server=id_server, stock=stock_data.id_stock) crashstate = EwGamestate(id_server=id_server, id_state='stockcrashdive').bit # Nudge the value back to stability. market_rate = stock_data.market_rate if market_rate >= 1030: market_rate -= 10 elif market_rate <= 970: market_rate += 10 # Invest/Withdraw effects coin_rate = 0 #stock_at_last_tick = EwStock(id_server=id_server, stock=stock_data.id_stock, timestamp=market_data.time_lasttick) #latest_stock = EwStock(id_server=id_server, stock=stock_data.id_stock) if stock_data.previous_entry != 0: total_shares = [stock_data.total_shares, stock_data.previous_entry[4]] else: total_shares = [ stock_data.total_shares, EwStock(id_server=id_server, stock=stock_data.id_stock, timestamp=market_data.time_lasttick).total_shares ] # Add profit bonus. profits = company_data.recent_profits profit_bonus = profits / 100 # - 1 * ((latest_stock.exchange_rate / ewcfg.default_stock_exchange_rate) ** 0.2) profit_bonus = min(50, max(profit_bonus, -50)) market_rate += (profit_bonus / 2) if total_shares[0] != total_shares[1]: # Positive if net investment, negative if net withdrawal. coin_change = (total_shares[0] - total_shares[1]) coin_rate = ((coin_change * 1.0) / total_shares[1] if total_shares[1] != 0 else 1) if coin_rate > 1.0: coin_rate = 1.0 elif coin_rate < -0.5: coin_rate = -0.5 coin_rate = round((coin_rate * ewcfg.max_iw_swing) if coin_rate > 0 else ( coin_rate * 2 * ewcfg.max_iw_swing)) market_rate += coin_rate # Tick down the boombust cooldown. if stock_data.boombust < 0: stock_data.boombust += 1 elif stock_data.boombust > 0: stock_data.boombust -= 1 # Adjust the market rate. fluctuation = 0 # (random.randrange(5) - 2) * 100 noise = (random.randrange(19) - 9) * 2 subnoise = (random.randrange(13) - 6) # Some extra excitement! if noise == 0 and subnoise == 0: boombust = (random.randrange(3) - 1) * 200 if crashstate == 1 and boombust > 0: boombust = -boombust # If a boombust occurs shortly after a previous boombust, make sure it's the opposite effect. (Boom follows bust, bust follows boom.) if (stock_data.boombust > 0 and boombust > 0) or (stock_data.boombust < 0 and boombust < 0): boombust *= -1 if boombust != 0: stock_data.boombust = ewcfg.cd_boombust if boombust < 0: stock_data.boombust *= -1 else: boombust = 0 market_rate += fluctuation + noise + subnoise + boombust if market_rate > 500 and crashstate == 1: market_rate = round(market_rate / 1.25) if market_rate < 300: market_rate = (300 + noise + subnoise) # percentage = ((market_rate / 10) - 100) # percentage_abs = percentage * -1 exchange_rate_increase = round( (market_rate - ewcfg.default_stock_market_rate) * min(stock_data.exchange_rate, ewcfg.default_stock_exchange_rate) / ewcfg.default_stock_market_rate) percentage = exchange_rate_increase / stock_data.exchange_rate percentage_abs = percentage * -1 # negative exchange rate causes problems, duh # exchange_rate_increase = max(exchange_rate_increase, -stock_data.exchange_rate + 1000) points = abs(exchange_rate_increase / 1000.0) stock_data.exchange_rate += exchange_rate_increase stock_data.market_rate = market_rate # Give some indication of how the market is doing to the users. response = ewcfg.stock_emotes.get( stock_data.id_stock) + ' ' + ewcfg.stock_names.get( stock_data.id_stock) + ' ' if stock_data.exchange_rate < 1000: response += 'has gone bankrupt!' if stock_data.total_shares > 0: majority_shareholder = get_majority_shareholder( stock=stock_data.id_stock, id_server=id_server) player_data = EwPlayer(id_user=majority_shareholder) shares = getUserTotalShares(stock=stock_data.id_stock, id_user=majority_shareholder, id_server=stock_data.id_server) shares_lost = round(shares * 0.9) stock_data.total_shares -= shares_lost updateUserTotalShares(stock=stock_data.id_stock, id_user=majority_shareholder, id_server=stock_data.id_server, shares=shares - shares_lost) response += ' The majority shareholder {} is held responsible. SlimeCorp seizes 90% of their shares in the company to pay for the damages.'.format( player_data.display_name) stock_data.exchange_rate = 10000 else: response += ' SlimeCorp pumps several billion slimecoin into bailing the company out and a new image campaign.' stock_data.exchange_rate = ewcfg.default_stock_exchange_rate stock_data.market_rate = ewcfg.default_stock_market_rate else: # Market is up ... if market_rate > 1200: response += 'is skyrocketing!!! Slime stock is up {p:.3g} points!!!'.format( p=points) elif market_rate > 1100: response += 'is booming! Slime stock is up {p:.3g} points!'.format( p=points) elif market_rate > 1000: response += 'is doing well. Slime stock is up {p:.3g} points.'.format( p=points) # Market is down ... elif market_rate < 800: response += 'is plummeting!!! Slime stock is down {p:.3g} points!!!'.format( p=points) elif market_rate < 900: response += 'is stagnating! Slime stock is down {p:.3g} points!'.format( p=points) elif market_rate < 1000: response += 'is a bit sluggish. Slime stock is down {p:.3g} points.'.format( p=points) # Perfectly balanced else: response += 'is holding steady. No change in slime stock value.' response += ' ' + ewcfg.stock_emotes.get(stock_data.id_stock) stock_data.persist() company_data.total_profits += company_data.recent_profits company_data.recent_profits = 0 company_data.persist() # Send the announcement. return response
async def order(cmd): user_data = EwUser(member=cmd.message.author) mutations = user_data.get_mutations() if user_data.life_state == ewcfg.life_state_shambler and user_data.poi != ewcfg.poi_id_nuclear_beach_edge: 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)) market_data = EwMarket(id_server=cmd.guild.id) currency_used = 'slime' current_currency_amount = user_data.slimes # poi = ewmap.fetch_poi_if_coordless(cmd.message.channel.name) poi = poi_static.id_to_poi.get(user_data.poi) if poi is None or len(poi.vendors) == 0 or ewutils.channel_name_is_poi(cmd.message.channel.name) == False: # Only allowed in the food court. response = "There’s nothing to buy here. If you want to purchase some items, go to a sub-zone with a vendor in it, like the food court, the speakeasy, or the bazaar." else: poi = poi_static.id_to_poi.get(user_data.poi) district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) shambler_multiplier = 1 # for speakeasy during shambler times if district_data.is_degraded(): if poi.id_poi == ewcfg.poi_id_speakeasy: shambler_multiplier = 4 else: 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)) # value = ewutils.flattenTokenListToString(cmd.tokens[1:2]) # if cmd.tokens_count > 1: # value = cmd.tokens[1] # value = value.lower() 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 # Finds the item if it's an EwGeneralItem. if value == "mylittleponyfigurine": value = random.choice(static_items.furniture_pony) item = static_items.item_map.get(value) item_type = ewcfg.it_item if item != None: item_id = item.id_item name = item.str_name # Finds the item if it's an EwFood item. if item == None: item = static_food.food_map.get(value) item_type = ewcfg.it_food if item != None: item_id = item.id_food name = item.str_name # Finds the item if it's an EwCosmeticItem. if item == None: item = static_cosmetics.cosmetic_map.get(value) item_type = ewcfg.it_cosmetic if item != None: item_id = item.id_cosmetic name = item.str_name if item == None: item = static_items.furniture_map.get(value) item_type = ewcfg.it_furniture if item != None: item_id = item.id_furniture name = item.str_name if item_id in static_items.furniture_pony: item.vendors = [ewcfg.vendor_bazaar] if item == None: item = static_weapons.weapon_map.get(value) item_type = ewcfg.it_weapon if item != None: item_id = item.id_weapon name = item.str_weapon if item == None: item = static_relic.relic_map.get(value) item_type = ewcfg.it_relic if item != None and relic_utils.canCreateRelic(item.id_relic, cmd.guild.id): item_id = item.id_relic name = item.str_name elif item != None: item = None if item != None: item_type = item.item_type # Gets a vendor that the item is available and the player currently located in try: current_vendor = (set(item.vendors).intersection(set(poi.vendors))).pop() except: current_vendor = None # Check if the item is available in the current bazaar item rotation if current_vendor == ewcfg.vendor_bazaar: if item_id not in market_data.bazaar_wares.values(): if item_id in static_items.furniture_pony and "mylittleponyfigurine" in market_data.bazaar_wares.values(): pass else: current_vendor = None if current_vendor is None or len(current_vendor) < 1: response = "Check the {} for a list of items you can {}.".format(ewcfg.cmd_menu, ewcfg.cmd_order) else: response = "" value = item.price premium_purchase = True if item_id in ewcfg.premium_items else False if premium_purchase: togo = True # Just in case they order a premium food item, don't make them eat it right then and there. if ewcfg.cd_premium_purchase > (int(time.time()) - user_data.time_lastpremiumpurchase): response = "That item is in very limited stock! The vendor asks that you refrain from purchasing it for a day or two." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) elif ewcfg.cd_new_player > (int(time.time()) - user_data.time_joined): response = "You've only been in the city for a few days. The vendor doesn't trust you with that item very much..." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) stock_data = None company_data = None # factor in the current stocks for vendor in item.vendors: if vendor in ewcfg.vendor_stock_map: stock = ewcfg.vendor_stock_map.get(vendor) company_data = EwCompany(id_server=user_data.id_server, stock=stock) stock_data = EwStock(id_server=user_data.id_server, stock=stock) if stock_data is not None: value *= (stock_data.exchange_rate / ewcfg.default_stock_exchange_rate) ** 0.2 controlling_faction = poi_utils.get_subzone_controlling_faction(user_data.poi, user_data.id_server) if controlling_faction != "": # prices are halved for the controlling gang if controlling_faction == user_data.faction: value /= 2 # and 4 times as much for enemy gangsters elif user_data.faction != "": value *= 4 # raise shambled speakeasy price 4 times value *= shambler_multiplier # Raise the price for togo ordering. This gets lowered back down later if someone does togo ordering on a non-food item by mistake. if togo: value *= 1.5 if current_vendor == ewcfg.vendor_breakroom and user_data.faction == ewcfg.faction_slimecorp: value = 0 value = int(value) food_ordered = False target_data = None # Kingpins eat free. if (user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe) and item_type == ewcfg.it_food: value = 0 if value > current_currency_amount: # Not enough money. response = "A {} costs {:,} {}, and you only have {:,}.".format(name, value, currency_used, current_currency_amount) else: mutations = user_data.get_mutations() if random.randrange(5) == 0 and ewcfg.mutation_id_stickyfingers in mutations: value = 0 user_data.change_crime(n=ewcfg.cr_larceny_points) inv_response = bknd_item.check_inv_capacity(user_data=user_data, item_type=item_type, return_strings=True, pronoun="You") if inv_response != "" and (item_type != ewcfg.it_food or togo): return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, inv_response)) if item_type == ewcfg.it_food: food_ordered = True target = None target_data = None if not togo: # cant order togo for someone else, you can just give it to them in person if cmd.mentions_count == 1: target = cmd.mentions[0] if target.id == cmd.message.author.id: target = None if target != None: target_data = EwUser(member=target) if target_data.life_state == ewcfg.life_state_corpse and target_data.get_possession(): response = "How are you planning to feed them while they're possessing you?" return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) elif target_data.poi != user_data.poi: response = "You can't order anything for them because they aren't here!" return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) elif item_type == ewcfg.it_weapon: if user_data.life_state == ewcfg.life_state_corpse: response = "Ghosts can't hold weapons." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) item_props = itm_utils.gen_item_props(item) # Only food should have the value multiplied. If someone togo orders a non-food item by mistake, lower it back down. if not food_ordered and togo: value = int(value / 1.5) if currency_used == 'slime': user_data.change_slimes(n=-value, source=ewcfg.source_spending) if company_data is not None: company_data.recent_profits += value company_data.persist() if item.str_name == "arcade cabinet": item_props['furniture_desc'] = random.choice(ewcfg.cabinets_list) elif item.item_type == ewcfg.it_furniture: if "custom" in item_props.get('id_furniture'): if cmd.tokens_count < 4 or cmd.tokens[2] == "" or cmd.tokens[3] == "": response = "You need to specify the customization text before buying a custom item. Come on, isn't that self-evident? (!order [custom item] \"custom name\" \"custom description\")" return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: customname = cmd.tokens[2] if len(customname) > 32: response = "That name is too long. ({:,}/32)".format(len(customname)) return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) customdesc = cmd.tokens[3] if len(customdesc) > 500: response = "That description is too long. ({:,}/500)".format(len(customdesc)) return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) name = item_props['furniture_name'] = item_props['furniture_name'].format(custom=customname) item_props['furniture_desc'] = customdesc item_props['furniture_look_desc'] = item_props['furniture_look_desc'].format(custom=customname) item_props['furniture_place_desc'] = item_props['furniture_place_desc'].format(custom=customname) id_item = bknd_item.item_create( item_type=item_type, id_user=cmd.message.author.id, id_server=cmd.guild.id, stack_max=-1, stack_size=0, item_props=item_props ) if value == 0: response = "You swipe a {} from the counter at {}.".format(name, current_vendor) else: response = "You slam {:,} {} down on the counter at {} for {}.".format(value, currency_used, current_vendor, name) if food_ordered and not togo: item_data = EwItem(id_item=id_item) # Eat food on the spot! if target_data != None: target_player_data = EwPlayer(id_user=target_data.id_user) if value == 0: response = "You swipe a {} from the counter at {} and give it to {}.".format(name, current_vendor, target_player_data.display_name) else: response = "You slam {:,} slime down on the counter at {} for {} and give it to {}.".format(value, current_vendor, name, target_player_data.display_name) response += "\n\n*{}*: ".format(target_player_data.display_name) + target_data.eat(item_data) target_data.persist() else: if value == 0: response = "You swipe a {} from the counter at {} and eat it right on the spot.".format(name, current_vendor) else: response = "You slam {:,} slime down on the counter at {} for {} and eat it right on the spot.".format(value, current_vendor, name) user_player_data = EwPlayer(id_user=user_data.id_user) response += "\n\n*{}*: ".format(user_player_data.display_name) + user_data.eat(item_data) user_data.persist() if premium_purchase: user_data.time_lastpremiumpurchase = int(time.time()) user_data.persist() else: response = "Check the {} for a list of items you can {}.".format(ewcfg.cmd_menu, ewcfg.cmd_order) # 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 withdraw(cmd): 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)) time_now = round(time.time()) market_data = EwMarket(id_server=cmd.message.author.guild.id) if market_data.clock < 6 or market_data.clock >= 20: response = ewcfg.str_exchange_closed return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if cmd.message.channel.name != ewcfg.channel_stockexchange: # or user_data.poi != ewcfg.poi_id_downtown: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="withdraw") return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) 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.life_state == ewcfg.life_state_corpse: # Disallow withdraws from ghosts. response = "Your slimebroker can't confirm your identity while you're dead." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: value = None stock = None if cmd.tokens_count > 1: value = ewutils.getIntToken(cmd.tokens[1:], allow_all=True) for token in cmd.tokens[1:]: if token.lower() in ewcfg.stocks: stock = token.lower() break if stock != None: stock = EwStock(id_server=cmd.guild.id, stock=stock) total_shares = market_utils.getUserTotalShares(id_server=user_data.id_server, stock=stock.id_stock, id_user=user_data.id_user) if value != None: if value < 0: value = total_shares if value <= 0: value = None if value != None: if value <= total_shares: exchange_rate = (stock.exchange_rate / 1000.0) shares = value slimecoin = round(value * exchange_rate) if user_data.time_lastinvest + ewcfg.cd_invest > time_now: # Limit frequency of withdrawals response = ewcfg.str_exchange_busy.format(action="withdraw") else: user_data.change_slimecoin(n=slimecoin, coinsource=ewcfg.coinsource_withdraw) total_shares -= shares user_data.time_lastinvest = time_now stock.total_shares -= shares response = "You exchange {shares:,} shares in {stock} for {coins:,} SlimeCoin.".format(coins=slimecoin, shares=shares, stock=ewcfg.stock_names.get(stock.id_stock)) user_data.persist() stock.timestamp = round(time.time()) stock.persist() market_utils.updateUserTotalShares(id_server=user_data.id_server, stock=stock.id_stock, id_user=user_data.id_user, shares=total_shares) else: response = "You don't have that many shares in {stock} to exchange.".format(stock=ewcfg.stock_names.get(stock.id_stock)) else: response = ewcfg.str_exchange_specify.format(currency="SlimeCoin", action="withdraw") else: response = "That's not a valid stock name, please use a proper one, you c**t: {}".format(ewutils.formatNiceList(names=ewcfg.stocks)) await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def xfer(cmd): time_now = round(time.time()) 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)) if cmd.message.channel.name != ewcfg.channel_stockexchange: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="transfer") return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) 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 cmd.mentions_count != 1: # Must have exactly one target to send to. response = "Mention the player you want to send SlimeCoin to." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.time_lastinvest + ewcfg.cd_invest > time_now: # Limit frequency of transfers response = ewcfg.str_exchange_busy.format(action="transfer slimecoin") return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.life_state == ewcfg.life_state_corpse: # Disallow transfers from ghosts. response = "Your slimebroker can't confirm your identity while you're dead." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) 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." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) market_data = EwMarket(id_server=cmd.message.author.guild.id) if cmd.message.author.id == member.id: slimes_total = user_data.slimes slimes_drained = int(slimes_total * 0.1) slimes_todistrict = slimes_total - slimes_drained sewer_data = EwDistrict(district=ewcfg.poi_id_thesewers, id_server=user_data.id_server) sewer_data.change_slimes(n=slimes_drained) sewer_data.persist() district_data = EwDistrict(district=user_data.poi, id_server=cmd.guild.id) district_data.change_slimes(n=slimes_todistrict, source=ewcfg.source_killing) district_data.persist() # Set the id_killer to the player himself, remove his slime and slime poudrins. user_data.id_killer = cmd.message.author.id user_data.visiting = ewcfg.location_id_empty user_data.trauma = ewcfg.trauma_id_environment user_data.die(cause=ewcfg.cause_suicide) user_data.persist() await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "Gaming the slimeconomy is punishable by death. SlimeCorp soldiers execute you immediately.")) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) return # Parse the slime value to send. value = None if cmd.tokens_count > 1: value = ewutils.getIntToken(tokens=cmd.tokens) if value != None: if value < 0: value = user_data.slimes if value <= 0: value = None if value != None: # Cost including the transfer fee. cost_total = round(value * 1.1) if user_data.slimecoin < cost_total: response = "You don't have enough SlimeCoin. ({:,}/{:,})".format(user_data.slimecoin, cost_total) else: # Do the transfer if the player can afford it. target_data.change_slimecoin(n=value, coinsource=ewcfg.coinsource_transfer) user_data.change_slimecoin(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)) target_data.persist() user_data.persist() else: response = ewcfg.str_exchange_specify.format(currency="SlimeCoin", action="transfer") # 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 redeem(cmd): 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)) time_now = round(time.time()) market_data = EwMarket(id_server=cmd.message.author.guild.id) if market_data.clock < 6 or market_data.clock >= 20: response = ewcfg.str_exchange_closed return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.time_lastinvest + ewcfg.cd_invest > time_now: response = ewcfg.str_exchange_busy.format(action="redeem") if cmd.message.channel.name != ewcfg.channel_stockexchange: # or user_data.poi != ewcfg.poi_id_downtown: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="redeem") return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) 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.life_state == ewcfg.life_state_corpse: # Disallow withdraws from ghosts. response = "Your slimebroker can't confirm your identity while you're dead." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: slimecoin_exchange_rate = 25000000000000 # 25 trillion slime redeem_value = round(user_data.slimecoin / slimecoin_exchange_rate) if redeem_value <= 0: response = "Sadly, you haven't made enough Slimecoin to reedeem any slime!" else: response = "" if user_data.life_state == ewcfg.life_state_enlisted: response = "After you dot all the i’s and cross all the t’s, you immediately send your Kingpin half of your earnings." role_boss = (ewcfg.role_copkiller if user_data.faction == ewcfg.faction_killers else ewcfg.role_rowdyfucker) kingpin = fe_utils.find_kingpin(id_server=cmd.guild.id, kingpin_role=role_boss) kingpin = EwUser(id_server=cmd.guild.id, id_user=kingpin.id_user) if kingpin: kingpin.change_slimes(n=int(redeem_value / 2)) kingpin.persist() else: response = "Your slimebroker pulls a fast one on you and gets you to sign a waiver that lets SlimeCorp keep half of your supposedly redeemed slime. Damn." response += "You walk out with {:,}.".format(int(redeem_value / 2)) user_data.slimes += int(redeem_value / 2) user_data.slimecoin = round(user_data.slimecoin % slimecoin_exchange_rate) user_data.persist() await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def scavenge(cmd): market_data = EwMarket(id_server=cmd.message.author.guild.id) user_data = EwUser(member=cmd.message.author) mutations = user_data.get_mutations() time_now = int(time.time()) response = "" time_since_last_scavenge = time_now - user_data.time_lastscavenge # Kingpins can't scavenge. if user_data.life_state == ewcfg.life_state_kingpin or user_data.life_state == ewcfg.life_state_grandfoe: return # ghosts cant scavenge if user_data.life_state == ewcfg.life_state_corpse: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "What would you want to do that for? You're a ghost, you have no need for such lowly materialistic possessions like slime. You only engage in intellectual pursuits now. {} if you want to give into your base human desire to see numbers go up.".format(ewcfg.cmd_revive))) # currently not active - no cooldown if time_since_last_scavenge < ewcfg.cd_scavenge: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "Slow down, you filthy hyena.")) if user_data.poi == ewcfg.poi_id_slimesea: if user_data.life_state == ewcfg.life_state_shambler: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "Are you trying to grab random trash instead of !searchingforbrainz? Pretty cringe bro...")) else: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You consider diving down to the bottom of the sea to grab some sick loot, but quickly change your mind when you {}.".format(random.choice(ewcfg.sea_scavenge_responses)))) # Scavenge only in location channels if ewutils.channel_name_is_poi(cmd.message.channel.name) == True: if user_data.hunger >= user_data.get_hunger_max(): return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You are too exhausted to scrounge up scraps of slime off the street! Go get some grub!")) else: if juviecmdutils.scavenge_combos.get(user_data.id_user) == None: juviecmdutils.scavenge_combos[user_data.id_user] = 0 combo = juviecmdutils.scavenge_combos.get(user_data.id_user) district_data = EwDistrict(district=user_data.poi, id_server=cmd.message.author.guild.id) user_initial_level = user_data.slimelevel # add scavenged slime to user if ewcfg.mutation_id_trashmouth in mutations: combo += 5 time_since_last_scavenge = min(max(1, time_since_last_scavenge), ewcfg.soft_cd_scavenge) # scavenge_mod = 0.003 * (time_since_last_scavenge ** 0.9) scavenge_mod = 0.005 * combo if (ewcfg.mutation_id_whitenationalist in mutations or ewcfg.mutation_id_airlock in mutations) and market_data.weather == "snow": scavenge_mod *= 1.5 if ewcfg.mutation_id_airlock in mutations and market_data.weather == "snow": scavenge_mod *= 1.5 if ewcfg.mutation_id_webbedfeet in mutations: district_slimelevel = len(str(district_data.slimes)) scavenge_mod *= max(1, min(district_slimelevel - 3, 4)) scavenge_yield = math.floor(scavenge_mod * district_data.slimes) levelup_response = user_data.change_slimes(n=scavenge_yield, source=ewcfg.source_scavenging) district_data.change_slimes(n=-1 * scavenge_yield, source=ewcfg.source_scavenging) district_data.persist() if levelup_response != "": response += levelup_response + "\n\n" # response += "You scrape together {} slime from the streets.\n\n".format(scavenge_yield) if cmd.tokens_count > 1: item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) has_comboed = False if juviecmdutils.scavenge_combos.get(user_data.id_user) > 0 and (time_now - user_data.time_lastscavenge) < 60: if juviecmdutils.scavenge_captchas.get(user_data.id_user).lower() == item_search.lower(): juviecmdutils.scavenge_combos[user_data.id_user] += 1 new_captcha = gen_scavenge_captcha(n=juviecmdutils.scavenge_combos.get(user_data.id_user), user_data=user_data) response += "New captcha: **" + ewutils.text_to_regional_indicator(new_captcha) + "**" if ewcfg.mutation_id_webbedfeet in mutations: response += "\nYour flippers pick up {:,} slime.".format(scavenge_yield) juviecmdutils.scavenge_captchas[user_data.id_user] = new_captcha has_comboed = True if ewcfg.mutation_id_dumpsterdiver in mutations: has_comboed = False item_search = item_search[random.randrange(len(item_search))] else: juviecmdutils.scavenge_combos[user_data.id_user] = 0 if not has_comboed: loot_resp = itm_utils.item_lootspecific( user_data=user_data, item_search=item_search ) if loot_resp != "": response = loot_resp + "\n\n" + response else: loot_multiplier = 1.0 + bknd_item.get_inventory_size(owner=user_data.poi, id_server=user_data.id_server) loot_chance = loot_multiplier / ewcfg.scavenge_item_rarity if ewcfg.mutation_id_dumpsterdiver in mutations: loot_chance *= 10 if random.random() < loot_chance: loot_resp = itm_utils.item_lootrandom( user_data ) if loot_resp != "": response += loot_resp + "\n\n" juviecmdutils.scavenge_combos[user_data.id_user] = 1 new_captcha = gen_scavenge_captcha(n=1, user_data=user_data) response += "New captcha: **" + ewutils.text_to_regional_indicator(new_captcha) + "**" if ewcfg.mutation_id_webbedfeet in mutations: response += "\nYour flippers pick up {:,} slime.".format(scavenge_yield) juviecmdutils.scavenge_captchas[user_data.id_user] = new_captcha # Fatigue the scavenger. hunger_cost_mod = ewutils.hunger_cost_mod(user_data.slimelevel) extra = hunger_cost_mod - int(hunger_cost_mod) # extra is the fractional part of hunger_cost_mod user_data.hunger += ewcfg.hunger_perscavenge * int(hunger_cost_mod) if extra > 0: # if hunger_cost_mod is not an integer # there's an x% chance that an extra stamina is deducted, where x is the fractional part of hunger_cost_mod in percent (times 100) if random.randint(1, 100) <= extra * 100: user_data.hunger += ewcfg.hunger_perscavenge user_data.time_lastscavenge = time_now user_data.persist() # 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) if not response == "": return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You'll find no slime here, this place has been picked clean. Head into the city to try and scavenge some slime."))
async def flag(cmd): market_data = EwMarket(id_server=cmd.message.author.guild.id) user_data = EwUser(member=cmd.message.author) mutations = user_data.get_mutations() 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() time_now = int(time.time()) 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) and ewcfg.mutation_id_lightminer not in mutations: 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) and ewcfg.mutation_id_lightminer not in mutations: 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 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 mining_type = ewcfg.mines_mining_type_map.get(user_data.poi) if mining_type != ewcfg.mining_type_minesweeper: response = "What do you think you can flag here?" return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) 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 row = -1 col = -1 if cmd.tokens_count < 2: response = "Please specify which Minesweeper vein to flag." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) for token in cmd.tokens[1:]: coords = token.lower() if col < 1: for char in coords: if char in ewcfg.alphabet: col = ewcfg.alphabet.index(char) coords = coords.replace(char, "") if row < 1: try: row = int(coords) except: row = -1 row -= 1 if row not in range(len(grid)) or col not in range(len(grid[row])): response = "Invalid Minesweeper vein." elif grid[row][col] == ewcfg.cell_empty_marked: grid[row][col] = ewcfg.cell_empty elif grid[row][col] == ewcfg.cell_mine_marked: grid[row][col] = ewcfg.cell_mine elif grid[row][col] == ewcfg.cell_empty_open: response = "This vein has already been mined dry." elif grid[row][col] == ewcfg.cell_mine: grid[row][col] = ewcfg.cell_mine_marked elif grid[row][col] == ewcfg.cell_empty: grid[row][col] = ewcfg.cell_empty_marked if printgrid: await print_grid(cmd) else: 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 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 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 adorn(cmd): user_data = EwUser(member=cmd.message.author) market_data = EwMarket(id_server=user_data.id_server) # Check to see if you even have the item you want to repair item_id = ewutils.flattenTokenListToString(cmd.tokens[1:]) try: item_id_int = int(item_id) except: item_id_int = None if item_id is not None and len(item_id) > 0: response = "You don't have one." cosmetic_items = bknd_item.inventory( id_user=cmd.message.author.id, id_server=cmd.guild.id, item_type_filter=ewcfg.it_cosmetic) item_sought = None item_from_slimeoid = None already_adorned = False space_adorned = 0 for item in cosmetic_items: i = EwItem(item.get('id_item')) # Get space used adorned cosmetics if i.item_props['adorned'] == 'true': space_adorned += int(i.item_props['size']) # Check all cosmetics found for item in cosmetic_items: i = EwItem(item.get('id_item')) # Search for desired cosmetic if item.get( 'id_item' ) == item_id_int or item_id in ewutils.flattenTokenListToString( item.get('name')): if item_from_slimeoid == None and i.item_props.get( "slimeoid") == 'true': item_from_slimeoid = i continue if i.item_props.get("adorned") == 'true': already_adorned = True elif i.item_props.get( "context") == 'costume' and not ewcfg.dh_active: if not ewcfg.dh_active and not ewutils.check_fursuit_active( market_data): response = "You can't adorn your costume right now." else: item_sought = i break if item_sought == None: item_sought = item_from_slimeoid # If the cosmetic you want to adorn is found if item_sought != None: # Calculate how much space you'll have after adorning... if int(item_sought.item_props['size']) > 0: space_adorned += int(item_sought.item_props['size']) # If you don't have enough space, abort if space_adorned > ewutils.max_adornspace_bylevel( user_data.slimelevel): response = "Oh yeah? And, pray tell, just how do you expect to do that? You’re out of space, you can’t adorn any more garments!" # If you have enough space, adorn else: item_sought.item_props['adorned'] = 'true' # Take the hat from your slimeoid if necessary if item_sought.item_props.get('slimeoid') == 'true': item_sought.item_props['slimeoid'] = 'false' response = "You take your {} from your slimeoid and successfully adorn it.".format( item_sought.item_props.get('cosmetic_name')) else: onadorn_response = item_sought.item_props['str_onadorn'] response = onadorn_response.format( item_sought.item_props['cosmetic_name']) item_sought.persist() user_data.persist() elif already_adorned: response = "You already have that garment adorned!" await fe_utils.send_message( cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: await fe_utils.send_message( cmd.client, cmd.message.channel, fe_utils.formatMessage( cmd.message.author, 'Adorn which cosmetic? Check your **!inventory**.'))
async def mill(cmd): 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)) market_data = EwMarket(id_server=user_data.id_server) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = bknd_item.find_item( item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None, item_type_filter=ewcfg.it_food) # Checking availability of milling if user_data.life_state != ewcfg.life_state_juvenile: response = "Only Juveniles of pure heart and with nothing better to do can mill their vegetables." elif cmd.message.channel.name not in [ ewcfg.channel_jr_farms, ewcfg.channel_og_farms, ewcfg.channel_ab_farms ]: response = "Alas, there doesn’t seem to be an official SlimeCorp milling station anywhere around here. Probably because you’re in the middle of the f*****g city. Try looking where you reaped your vegetable in the first place, dumbass." # elif user_data.slimes < ewcfg.slimes_permill: # response = "It costs {} to !mill, and you only have {}.".format(ewcfg.slimes_permill, user_data.slimes) elif item_sought: 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)) items = [] vegetable = EwItem(id_item=item_sought.get('id_item')) for result in vendors.mill_results: if type(result.ingredients) == str: if vegetable.item_props.get('id_food') != result.ingredients: pass else: items.append(result) elif type(result.ingredients) == list: if vegetable.item_props.get( 'id_food') not in result.ingredients: pass else: items.append(result) if len(items) > 0: item = random.choice(items) item_props = itm_utils.gen_item_props(item) bknd_item.item_create(item_type=item.item_type, id_user=cmd.message.author.id, id_server=cmd.guild.id, item_props=item_props) response = "You walk up to the official ~~SlimeCorp~~ Garden Gankers Milling Station and shove your irradiated produce into the hand-crank. You begin slowly churning them into a glorious, pastry goo. As the goo tosses and turns inside the machine, it solidifies, and after a few moments a {} pops out!".format( item.str_name) # market_data.donated_slimes += ewcfg.slimes_permill market_data.persist() bknd_item.item_delete(id_item=item_sought.get('id_item')) # user_data.change_slimes(n = -ewcfg.slimes_permill, source = ewcfg.source_spending) # user_data.slime_donations += ewcfg.slimes_permill user_data.persist() else: response = "You can only mill fresh vegetables! SlimeCorp obviously wants you to support local farmers." else: if item_search: # if they didn't forget to specify an item and it just wasn't found response = "You don't have one." else: response = "Mill which item? (check **!inventory**)" await fe_utils.send_message( cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def cast(cmd): time_now = round(time.time()) has_reeled = False user_data = EwUser(member=cmd.message.author) mutations = user_data.get_mutations() if ewutils.channel_name_is_poi(cmd.message.channel.name) == False: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0]))) market_data = EwMarket(id_server=cmd.message.author.guild.id) statuses = user_data.getStatusEffects() if cmd.message.author.id not in fishutils.fishers.keys(): fishutils.fishers[cmd.message.author.id] = EwFisher() fisher = fishutils.fishers[cmd.message.author.id] # Ghosts cannot fish. if user_data.life_state == ewcfg.life_state_corpse: response = "You can't fish while you're dead. Try {}.".format(ewcfg.cmd_revive) # Players who are already cast a line cannot cast another one. elif fisher.fishing == True: response = "You've already cast a line." # Only fish at The Pier elif user_data.poi in poi_static.piers: poi = poi_static.id_to_poi.get(user_data.poi) district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) rod_possession = user_data.get_possession('rod') if rod_possession: fisher.inhabitant_id = rod_possession[0] elif user_data.hunger >= user_data.get_hunger_max(): response = "You're too hungry to fish right now." elif (not fisher.inhabitant_id) and (poi.id_poi == ewcfg.poi_id_blackpond): response = "You cast your fishing line into the pond, but your hook bounces off its black waters like hard concrete." else: has_fishingrod = 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 == "fishingrod": has_fishingrod = True if ewcfg.status_high_id in statuses: fisher.high = True fisher.fishing = True fisher.bait = False fisher.bait_id = 0 fisher.pier = poi fisher.current_fish = gen_fish(market_data, fisher, has_fishingrod) high_value_bait_used = False # global fishing_counter fishutils.fishing_counter += 1 current_fishing_id = fisher.fishing_id = fishutils.fishing_counter item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) author = cmd.message.author server = cmd.guild item_sought = bknd_item.find_item(item_search=item_search, id_user=author.id, id_server=server.id) if item_sought: item = EwItem(id_item=item_sought.get('id_item')) if item.item_type == ewcfg.it_food: str_name = item.item_props['food_name'] id_food = item.item_props.get('id_food') fisher.bait = True if id_food in static_food.plebe_bait: fisher.current_fish = "plebefish" elif id_food == "doublestuffedcrust": if random.randrange(5) == 3: fisher.current_fish = "doublestuffedflounder" elif id_food in ["chickenbucket", "familymeal"]: if random.randrange(5) == 3: fisher.current_fish = "seacolonel" elif id_food in ["steakvolcanoquesomachorito", "nachosupreme"]: if random.randrange(5) == 3: fisher.current_fish = "marlinsupreme" elif id_food in "blacklimesour": if random.randrange(2) == 1: fisher.current_fish = "blacklimesalmon" elif id_food in "pinkrowdatouille": if random.randrange(2) == 1: fisher.current_fish = "thrash" elif id_food in "purplekilliflowercrustpizza": if random.randrange(2) == 1: fisher.current_fish = "dab" elif id_food == "kingpincrab": if random.randrange(5) == 1: fisher.current_fish = "uncookedkingpincrab" elif id_food == "masterbait": high_value_bait_used = True elif id_food == "ferroslimeoid": fisher.current_fish = "seaitem" elif float(item.time_expir if item.time_expir is not None else 0) < time.time(): if random.randrange(2) == 1: fisher.current_fish = "plebefish" fisher.bait_id = item_sought.get('id_item') if fisher.current_fish == "item": fisher.current_size = "item" else: mastery_bonus = 0 # Git gud. if has_fishingrod: mastery_bonus += user_data.weaponskill - 4 # else: mastery_bonus += -4 if rod_possession: mastery_bonus += 1 mastery_bonus = max(0, mastery_bonus) fisher.length = gen_fish_size(mastery_bonus) fisher.current_size = length_to_size(fisher.length) if fisher.bait == False: response = "You cast your fishing line into the " else: response = "You attach your {} to the hook as bait and then cast your fishing line into the ".format(str_name) if fisher.pier.pier_type == ewcfg.fish_slime_saltwater: response += "vast Slime Sea." elif fisher.pier.pier_type == ewcfg.fish_slime_freshwater: response += "glowing Slime Lake." elif fisher.pier.pier_type == ewcfg.fish_slime_void: response += "pond's black waters." user_data.hunger += ewcfg.hunger_perfish * ewutils.hunger_cost_mod(user_data.slimelevel) user_data.persist() await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) bite_text = gen_bite_text(fisher.current_size) # User has a 1/10 chance to get a bite fun = 100 if fisher.bait == True: # Bait attatched, chance to get a bite increases from 1/10 to 1/7 fun -= 30 if fisher.pier == ewcfg.poi_id_ferry: # Fisher is on the ferry, chance to get a bite increases from 1/10 to 1/9 fun -= 10 if ewcfg.mutation_id_lucky in mutations: fun -= 20 if fisher.inhabitant_id: # Having your rod possessed increases your chance to get a bite by 50% fun = int(fun // 2) if high_value_bait_used: fun = 5 bun = 0 while not ewutils.TERMINATE: if fun <= 0: fun = 1 else: damp = random.randrange(fun) if fisher.high: await asyncio.sleep(30) elif high_value_bait_used: await asyncio.sleep(5) else: await asyncio.sleep(60) # Cancel if fishing was interrupted if current_fishing_id != fisher.fishing_id: return if fisher.fishing == False: return user_data = EwUser(member=cmd.message.author) if fisher.pier == "" or user_data.poi != fisher.pier.id_poi: fisher.stop() return if user_data.life_state == ewcfg.life_state_corpse: fisher.stop() return if damp > 10: await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, random.choice(comm_cfg.void_fishing_text if fisher.pier.pier_type == ewcfg.fish_slime_void else comm_cfg.normal_fishing_text))) fun -= 2 bun += 1 if bun >= 5: fun -= 1 if bun >= 15: fun -= 1 continue else: break fisher.bite = True await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, bite_text)) await asyncio.sleep(8) if fisher.bite != False: response = "The fish got away..." response += cancel_rod_possession(fisher, user_data) fisher.stop() return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: has_reeled = True else: response = "You can't fish here. Go to a pier." # Don't send out a response if the user actually reeled in a fish, since that gets sent by the reel command instead. if has_reeled == False: await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def donate(cmd): 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)) market_data = EwMarket(id_server=user_data.id_server) time_now = round(time.time()) if user_data.poi == ewcfg.poi_id_slimecorphq: 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)) 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 and value < ewcfg.slimecoin_exchangerate: response = "You must volunteer to donate at least %d slime to receive compensation." % ewcfg.slimecoin_exchangerate elif value != None: # Amount of slime invested. cost_total = round(value) coin_total = round(value / ewcfg.slimecoin_exchangerate) if user_data.slimes < cost_total: response = "Acid-green flashes of light and bloodcurdling screams emanate from small window of SlimeCorp HQ. Unfortunately, you did not survive the procedure. Your body is dumped down a disposal chute to the sewers." market_data.donated_slimes += user_data.slimes market_data.persist() user_data.trauma = ewcfg.trauma_id_environment die_resp = user_data.die(cause=ewcfg.cause_donation) user_data.persist() # Assign the corpse role to the player. He dead. await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) await die_resp.post() else: # Do the transfer if the player can afford it. market_data.donated_slimes += cost_total market_data.persist() user_data.change_slimes(n=-cost_total, source=ewcfg.source_spending) user_data.change_slimecoin(n=coin_total, coinsource=ewcfg.coinsource_donation) user_data.slime_donations += cost_total # Persist changes user_data.persist() response = "You stumble out of a Slimecorp HQ vault room in a stupor. You don't remember what happened in there, but your body hurts and you've got {slimecoin:,} shiny new SlimeCoin in your pocket.".format(slimecoin=coin_total) else: response = ewcfg.str_exchange_specify.format(currency="slime", action="donate") elif user_data.poi == ewcfg.poi_id_slimeoidlab: 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)) poudrins = bknd_item.find_item(item_search="slimepoudrin", id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None, item_type_filter=ewcfg.it_item) if poudrins == None: response = "You have to own a poudrin in order to donate a poudrin. Duh." else: bknd_item.item_delete(id_item=poudrins.get('id_item')) # Remove Poudrins market_data.donated_poudrins += 1 market_data.persist() user_data.poudrin_donations += 1 user_data.persist() response = "You hand off one of your hard-earned poudrins to the front desk receptionist, who is all too happy to collect it. Pretty uneventful, but at the very least you’re glad donating isn’t physically painful anymore." else: response = "To donate slime, go to the SlimeCorp HQ in Downtown. To donate poudrins, go to the N.L.A.C.U. Lab in Brawlden." # 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 appraise(cmd): user_data = EwUser(member=cmd.message.author) if ewutils.channel_name_is_poi(cmd.message.channel.name) == False: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0]))) market_data = EwMarket(id_server=user_data.id_server) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = bknd_item.find_item(item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None) payment = bknd_item.find_item(item_search="manhattanproject", id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None, item_type_filter=ewcfg.it_food) # Checking availability of appraisal # if market_data.clock < 8 or market_data.clock > 17: # response = "You ask the bartender if he knows someone who would want to trade you something for your recently caught fish. Apparently, at night, an old commodore by the name of Captain Albert Alexander comes to drown his sorrows at this very tavern. You guess you’ll just have to sit here and wait for him, then." if cmd.message.channel.name != ewcfg.channel_speakeasy: if user_data.poi in poi_static.piers: response = 'You ask a nearby fisherman if he could appraise this fish you just caught. He tells you to f**k off, but also helpfully informs you that there’s an old sea captain that frequents the Speakeasy that might be able to help you. What an inexplicably helpful/grouchy fisherman!' else: response = 'What random passerby is going to give two shits about your fish? You’ll have to consult a fellow fisherman… perhaps you’ll find some on a pier?' return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) elif item_sought: name = item_sought.get('name') fish = EwItem(id_item=item_sought.get('id_item')) item_props = fish.item_props # str_fish = fish.item_props.get('str_name') # id_fish = item_props['id_food'] acquisition = item_props.get('acquisition') response = "You approach a man of particularly swashbuckling appearance, adorned in an old sea captain's uniform and bicorne cap, and surrounded by empty glass steins. You ask him if he is Captain Albert Alexander and he replies that he hasn’t heard that name in a long time. You submit your {} for appraisal".format(name) if acquisition != ewcfg.acquisition_fishing: response += '. \n"Have you lost yer mind, laddy? That’s not a fish!! Just what’re you trying to pull??"'.format(name) else: if payment == None: response += ", but he says he won’t provide his services for free... but, if you bring him a Manhattan Project, you might be able to get an appraisal." else: item_props = fish.item_props rarity = item_props['rarity'] size = item_props['size'] value = int(item_props['value']) response += ' and offer him a Manhattan Project as payment. \n"Hm, alright, let’s see here...' if rarity == ewcfg.fish_rarity_common: response += "Ah, a {}, that’s a pretty common fish... ".format(name) if rarity == ewcfg.fish_rarity_uncommon: response += "Interesting, a {}, that’s a pretty uncommon fish you’ve got there... ".format(name) if rarity == ewcfg.fish_rarity_rare: response += "Amazing, it’s a {}! Consider yourself lucky, that’s a pretty rare fish! ".format(name) if rarity == ewcfg.fish_rarity_promo: response += "Shiver me timbers, is that a {}?? Unbelievable, that’s an extremely rare fish!! It was only ever released as a promotional item in Japan during the late ‘90s. ".format(name) if size == ewcfg.fish_size_miniscule: response += "Or, is it just a speck of dust? Seriously, that {} is downright miniscule! ".format(name) if size == ewcfg.fish_size_small: response += "Hmmm, it’s a little small, don’t you think? " if size == ewcfg.fish_size_average: response += "It’s an average size for the species. " if size == ewcfg.fish_size_big: response += "Whoa, that’s a big one, too! " if size == ewcfg.fish_size_huge: response += "Look at the size of that thing, it’s huge! " if size == ewcfg.fish_size_colossal: response += "By Neptune’s beard, what a sight to behold, this {name} is absolutely colossal!! In all my years in the Navy, I don’t think I’ve ever seen a {name} as big as yours!! ".format(name=name) response += "So, I’d say this fish " if value <= 20: response += 'is absolutely worthless."' if value <= 40 and value >= 21: response += 'isn’t worth very much."' if value <= 60 and value >= 41: response += 'is somewhat valuable."' if value <= 80 and value >= 61: response += 'is highly valuable!"' if value <= 99 and value >= 81: response += 'is worth a fortune!!"' if value >= 100: response += 'is the most magnificent specimen I’ve ever seen!"' bknd_item.item_delete(id_item=payment.get('id_item')) user_data.persist() else: if item_search: # If they didn't forget to specify an item and it just wasn't found. response = "You don't have one." else: response = "Ask Captain Albert Alexander to appraise which fish? (check **!inventory**)" await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def invest(cmd): 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)) time_now = round(time.time()) market_data = EwMarket(id_server=cmd.message.author.guild.id) if cmd.message.channel.name != ewcfg.channel_stockexchange: # or user_data.poi != ewcfg.poi_id_downtown: # Only allowed in the stock exchange. response = ewcfg.str_exchange_channelreq.format(currency="SlimeCoin", action="invest") return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) 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 market_data.clock < 6 or market_data.clock >= 20: response = ewcfg.str_exchange_closed return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.time_lastinvest + ewcfg.cd_invest > time_now: # Limit frequency of investments. response = ewcfg.str_exchange_busy.format(action="invest") return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.life_state == ewcfg.life_state_corpse: # Disallow invests from ghosts. response = "Your slimebroker can't confirm your identity while you're dead." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.life_state == ewcfg.life_state_kingpin: # Disallow investments by RF and CK kingpins. response = "You need that money to buy more videogames." return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: value = None stock = None if cmd.tokens_count > 1: value = ewutils.getIntToken(cmd.tokens, allow_all=True) for token in cmd.tokens[1:]: if token.lower() in ewcfg.stocks: stock = token.lower() break if value != None: if value < 0: value = user_data.slimecoin if value <= 0: value = None if value != None: if stock != None: stock = EwStock(id_server=cmd.guild.id, stock=stock) # basic exchange rate / 1000 = 1 share exchange_rate = (stock.exchange_rate / 1000.0) cost_total = round(value * 1.05) # gets the highest value possible where the player can still pay the fee if value == user_data.slimecoin: while cost_total > user_data.slimecoin: value -= cost_total - value cost_total = round(value * 1.05) # The user can only buy a whole number of shares, so adjust their cost based on the actual number of shares purchased. net_shares = round(value / exchange_rate) if user_data.slimecoin < cost_total: response = "You don't have enough SlimeCoin. ({:,}/{:,})".format(user_data.slimecoin, cost_total) elif value > user_data.slimecoin: response = "You don't have that much SlimeCoin to invest." elif net_shares == 0: response = "You don't have enough SlimeCoin to buy a share in {stock}".format(stock=ewcfg.stock_names.get(stock.id_stock)) else: user_data.change_slimecoin(n=-cost_total, coinsource=ewcfg.coinsource_invest) shares = market_utils.getUserTotalShares(id_server=user_data.id_server, stock=stock.id_stock, id_user=user_data.id_user) shares += net_shares market_utils.updateUserTotalShares(id_server=user_data.id_server, stock=stock.id_stock, id_user=user_data.id_user, shares=shares) user_data.time_lastinvest = time_now stock.total_shares += net_shares response = "You invest {coin:,} SlimeCoin and receive {shares:,} shares in {stock}. Your slimebroker takes his nominal fee of {fee:,} SlimeCoin.".format(coin=value, shares=net_shares, stock=ewcfg.stock_names.get(stock.id_stock), fee=(cost_total - value)) user_data.persist() stock.timestamp = round(time.time()) stock.persist() else: response = "That's not a valid stock name, please use a proper one, you c**t: {}".format(ewutils.formatNiceList(names=ewcfg.stocks)) else: response = ewcfg.str_exchange_specify.format(currency="SlimeCoin", action="invest") # 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 barter(cmd): user_data = EwUser(member=cmd.message.author) mutations = user_data.get_mutations() if ewutils.channel_name_is_poi(cmd.message.channel.name) == False: return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, "You must {} in a zone's channel.".format(cmd.tokens[0]))) market_data = EwMarket(id_server=user_data.id_server) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = bknd_item.find_item(item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None) # Checking availability of appraisal # if market_data.clock < 8 or market_data.clock > 17: # response = "You ask the bartender if he knows someone who would want to trade you something for your recently caught fish. Apparently, at night, an old commodore by the name of Captain Albert Alexander comes to drown his sorrows at this very tavern. You guess you’ll just have to sit here and wait for him, then." if cmd.message.channel.name != ewcfg.channel_speakeasy: if user_data.poi in poi_static.piers: response = 'You ask a nearby fisherman if he wants to trade you anything for this fish you just caught. He tells you to f**k off, but also helpfully informs you that there’s an old sea captain that frequents the Speakeasy that might be able to help you. What an inexplicably helpful/grouchy fisherman!' else: response = 'What random passerby is going to give two shits about your fish? You’ll have to consult a fellow fisherman… perhaps you’ll find some on a pier?' return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) if user_data.life_state == ewcfg.life_state_corpse: response = 'Captain Albert Alexander hits the table with his glass and shouts "Nay laddy, you can fool me once but not twice! I dont do deals with spirits, get out of my sight!"' return await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) elif item_sought: name = item_sought.get('name') fish = EwItem(id_item=item_sought.get('id_item')) id_fish = fish.id_item # str_fish = fish.item_props.get('str_name') item_props = fish.item_props acquisition = item_props.get('acquisition') response = "You approach a man of particularly swashbuckling appearance, adorned in an old sea captain's uniform and bicorne cap, and surrounded by empty glass steins. You ask him if he is Captain Albert Alexander and he replies that he hasn’t heard that name in a long time. You submit your {} for bartering".format(name) if acquisition != ewcfg.acquisition_fishing: response += '. \n"Have you lost yer mind, laddy? That’s not a fish!! Just what’re you trying to pull??"' else: value = int(item_props['value']) items = [] # Filters out all non-generic items without the current fish as an ingredient. for result in vendors.appraise_results: if result.ingredients == fish.item_props.get('id_item') or result.ingredients == "generic" and result.acquisition == ewcfg.acquisition_bartering: # Generic means that it can be made with any fish. items.append(result) else: pass # Filters out items of greater value than your fish. for value_filter in items: if value < value_filter.context: items.remove(value_filter) else: pass else: offer = EwOffer( id_server=cmd.guild.id, id_user=cmd.message.author.id, offer_give=id_fish ) cur_time_min = time.time() / 60 time_offered = cur_time_min - offer.time_sinceoffer if offer.time_sinceoffer > 0 and time_offered < ewcfg.fish_offer_timeout: offer_receive = str(offer.offer_receive) if offer_receive.isdigit() == True and ewcfg.mutation_id_onemansjunk in mutations: item = random.choice(items) if hasattr(item, 'id_item'): offer.offer_receive = item.id_item if hasattr(item, 'id_food'): offer.offer_receive = item.id_food if hasattr(item, 'id_cosmetic'): offer.offer_receive = item.id_cosmetic response = '\n"Well, back again I see! That fish certainly looked better the last time I saw it. Best I’ll do is trade ya a {} for your {}."'.format(item.str_name, name) elif offer_receive.isdigit() == True: slime_gain = int(offer.offer_receive) response = '\n"Well, back again I see! My offer still stands, I’ll trade ya {} slime for your {}"'.format(slime_gain, name) elif ewcfg.mutation_id_davyjoneskeister in mutations and item_props.get('noslime') != "true": max_value = value * 6000 # 600,000 slime for a colossal promo fish, 120,000 for a miniscule common fish. min_value = max_value / 10 # 60,000 slime for a colossal promo fish, 12,000 for a miniscule common fish. slime_gain = round(random.triangular(min_value, max_value, min_value * 2)) offer.offer_receive = slime_gain offer.persist() response = '\n"You know what, laddy? I like the cut of your jib. I\'ll change my offer. How about {} slime for your {}?"'.format(slime_gain, name) else: for result in vendors.appraise_results: if hasattr(result, 'id_item'): if result.id_item != offer.offer_receive: pass else: item = result if hasattr(result, 'id_food'): if result.id_food != offer.offer_receive: pass else: item = result if hasattr(result, 'id_cosmetic'): if result.id_cosmetic != offer.offer_receive: pass else: item = result response = '\n"Well, back again I see! My offer still stands, I’ll trade ya a {} for your {}"'.format(item.str_name, name) response += "\n**!accept** or **!refuse** Captain Albert Alexander's deal." await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) else: # Random choice between 0, 1, and 2 offer_decision = random.randint(0, 2) if (offer_decision != 2 or ewcfg.mutation_id_davyjoneskeister in mutations) and item_props.get('noslime') != "true" and ewcfg.mutation_id_onemansjunk not in mutations: # If Captain Albert Alexander wants to offer you slime for your fish. 66% chance. max_value = value * 6000 # 600,000 slime for a colossal promo fish, 120,000 for a miniscule common fish. min_value = max_value / 10 # 60,000 slime for a colossal promo fish, 12,000 for a miniscule common fish. slime_gain = round(random.triangular(min_value, max_value, min_value * 2)) offer.offer_receive = slime_gain response = '"Hm, alright… for this {}... I’ll offer you {} slime! Trust me, you’re not going to get a better deal anywhere else, laddy."'.format(name, slime_gain) else: # If Captain Albert Alexander wants to offer you an item for your fish. 33% chance. Once there are more unique items, we'll make this 50%. item = random.choice(items) if hasattr(item, 'id_item'): offer.offer_receive = item.id_item if hasattr(item, 'id_food'): offer.offer_receive = item.id_food if hasattr(item, 'id_cosmetic'): offer.offer_receive = item.id_cosmetic response = '"Hm, alright… for this {}... I’ll offer you a {}! Trust me, you’re not going to get a better deal anywhere else, laddy."'.format(name, item.str_name) offer.time_sinceoffer = int(time.time() / 60) offer.persist() response += "\n**!accept** or **!refuse** Captain Albert Alexander's deal." await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) # Wait for an answer accepted = False try: message = await cmd.client.wait_for('message', timeout=20, 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: accepted = False offer = EwOffer( id_server=cmd.guild.id, id_user=cmd.message.author.id, offer_give=id_fish ) user_data = EwUser(member=cmd.message.author) fish = EwItem(id_item=id_fish) # cancel deal if fish is no longer in user's inventory if fish.id_owner != str(user_data.id_user): accepted = False # cancel deal if the user has left Vagrant's Corner if user_data.poi != ewcfg.poi_id_speakeasy: accepted = False # cancel deal if the offer has been deleted if offer.time_sinceoffer == 0: accepted = False if accepted == True: offer_receive = str(offer.offer_receive) response = "" if offer_receive.isdigit() == True: slime_gain = int(offer_receive) user_initial_level = user_data.slimelevel levelup_response = user_data.change_slimes(n=slime_gain, source=ewcfg.source_fishing) was_levelup = True if user_initial_level < user_data.slimelevel else False # Tell the player their slime level increased. if was_levelup: response += levelup_response response += "\n\n" else: item_props = itm_utils.gen_item_props(item) bknd_item.item_create( item_type=item.item_type, id_user=cmd.message.author.id, id_server=cmd.guild.id, item_props=item_props ) bknd_item.item_delete(id_item=item_sought.get('id_item')) user_data.persist() offer.deal() response += '"Pleasure doing business with you, laddy!"' else: response = '"Ah, what a shame. Maybe you’ll change your mind in the future…?"' else: if item_search: # If they didn't forget to specify an item and it just wasn't found. response = "You don't have one." else: response = "Offer Captain Albert Alexander which fish? (check **!inventory**)" await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def haunt(cmd): time_now = int(time.time()) response = "" resp_cont = EwResponseContainer(id_server=cmd.guild.id) if cmd.mentions_count > 1: response = "You can only spook one person at a time. Who do you think you are, the Lord of Ghosts?" else: haunted_data = None member = None if cmd.mentions_count == 0 and cmd.tokens_count > 1: server = cmd.guild member = server.get_member(ewutils.getIntToken(cmd.tokens)) haunted_data = EwUser(member=member) elif cmd.mentions_count == 1: member = cmd.mentions[0] haunted_data = EwUser(member=member) if member: # Get the user and target data from the database. user_data = EwUser(member=cmd.message.author) market_data = EwMarket(id_server=cmd.guild.id) target_mutations = haunted_data.get_mutations() target_poi = poi_static.id_to_poi.get(haunted_data.poi) target_is_shambler = haunted_data.life_state == ewcfg.life_state_shambler target_is_inhabitted = haunted_data.id_user == user_data.get_inhabitee( ) if user_data.life_state != ewcfg.life_state_corpse: # Only dead players can haunt. response = "You can't haunt now. Try {}.".format( ewcfg.cmd_suicide) elif haunted_data.life_state == ewcfg.life_state_kingpin: # Disallow haunting of generals. response = "He is too far from the sewers in his ivory tower, and thus cannot be haunted." elif (time_now - user_data.time_lasthaunt) < ewcfg.cd_haunt: # Disallow haunting if the user has haunted too recently. response = "You're being a little TOO spooky lately, don't you think? Try again in {} seconds.".format( int(ewcfg.cd_haunt - (time_now - user_data.time_lasthaunt))) elif ewutils.channel_name_is_poi( cmd.message.channel.name) == False: response = "You can't commit violence from here." elif target_poi.pvp == False: # Require the target to be in a PvP area, and flagged if it's a remote haunt response = "{} is not mired in the ENDLESS WAR right now.".format( member.display_name) elif haunted_data.life_state == ewcfg.life_state_corpse: # Dead players can't be haunted. response = "{} is already dead.".format(member.display_name) elif haunted_data.life_state == ewcfg.life_state_grandfoe: # Grand foes can't be haunted. response = "{} is invulnerable to ghosts.".format( member.display_name) elif haunted_data.life_state == ewcfg.life_state_enlisted or haunted_data.life_state == ewcfg.life_state_juvenile or haunted_data.life_state == ewcfg.life_state_shambler: haunt_power_multiplier = 1 # power to the ancients ghost_age = time_now - user_data.time_lastdeath if ghost_age > 60 * 60 * 24 * 7: # dead for longer than if ghost_age > 60 * 60 * 24 * 365: # one friggin year haunt_power_multiplier *= 2.5 if ghost_age > 60 * 60 * 24 * 90: # three months haunt_power_multiplier *= 2 elif ghost_age > 60 * 60 * 24 * 30: # one month haunt_power_multiplier *= 1.5 else: # one week haunt_power_multiplier *= 1.25 # vitriol as virtue list_ids = [] for quadrant in ewcfg.quadrant_ids: quadrant_data = EwQuadrant(id_server=cmd.guild.id, id_user=cmd.message.author.id, quadrant=quadrant) if quadrant_data.id_target != -1 and quadrant_data.check_if_onesided( ) is False: list_ids.append(quadrant_data.id_target) if quadrant_data.id_target2 != -1 and quadrant_data.check_if_onesided( ) is False: list_ids.append(quadrant_data.id_target2) if haunted_data.id_user in list_ids: # any mutual quadrants haunt_power_multiplier *= 1.2 if haunted_data.faction and ( (not user_data.faction) or (user_data.faction != haunted_data.faction) ): # opposite faction (or no faction at all) haunt_power_multiplier *= 1.2 if user_data.id_killer == haunted_data.id_user: # haunting your murderer/buster haunt_power_multiplier *= 1.2 # places of power. if haunted_data.poi in [ ewcfg.poi_id_thevoid, ewcfg.poi_id_wafflehouse, ewcfg.poi_id_blackpond ]: haunt_power_multiplier *= 2 elif haunted_data.poi in get_void_connection_pois( cmd.guild.id): haunt_power_multiplier *= 1.25 # glory to the vanquished target_kills = ewstats.get_stat(user=haunted_data, metric=ewcfg.stat_kills) if target_kills > 5: haunt_power_multiplier *= 1.25 + ( (target_kills - 5) / 100) # 1% per kill after 5 else: haunt_power_multiplier *= 1 + (target_kills * 5 / 100 ) # 5% per kill if time_now - haunted_data.time_lastkill < (60 * 15): haunt_power_multiplier *= 1.5 # wet hands # misc if weather_static.weather_map.get( market_data.weather) == ewcfg.weather_foggy: haunt_power_multiplier *= 1.1 if not haunted_data.has_soul: haunt_power_multiplier *= 1.2 # uncomment this after moon mechanics update # if (market_data.day % 31 == 15 and market_data.clock >= 20) or (market_data.day % 31 == 16 and market_data.clock <= 6): # haunt_power_multiplier *= 2 # divide haunt power by 2 if not in same area if user_data.poi != haunted_data.poi: haunt_power_multiplier /= 2 # Double Halloween if ewcfg.dh_active: haunt_power_multiplier *= 4 haunted_slimes = int( (haunted_data.slimes / ewcfg.slimes_hauntratio) * haunt_power_multiplier) slimes_lost = int( haunted_slimes / 5 ) # hauntee only loses 1/5th of what the ghost gets as antislime if ewcfg.mutation_id_coleblooded in target_mutations: haunted_slimes = -10000 if user_data.slimes > haunted_slimes: haunted_slimes = user_data.slimes haunted_data.change_slimes(n=-slimes_lost, source=ewcfg.source_haunted) user_data.change_slimes(n=-haunted_slimes, source=ewcfg.source_haunter) market_data.negaslime -= haunted_slimes user_data.time_lasthaunt = time_now user_data.clear_status(id_status=ewcfg.status_busted_id) resp_cont.add_member_to_update(cmd.message.author) # Persist changes to the database. user_data.persist() haunted_data.persist() market_data.persist() response = "{} has been haunted by the ghost of {}! Slime has been lost! {} antislime congeals within you.".format( member.display_name, cmd.message.author.display_name, haunted_slimes) if ewcfg.mutation_id_coleblooded in target_mutations: response = "{} has been haunted by the ghost of {}! Their exorcising coleslaw blood purges {} antislime from your being! Better not do that again.".format( member.display_name, cmd.message.author.display_name, -haunted_slimes) haunted_channel = poi_static.id_to_poi.get( haunted_data.poi).channel haunt_message = "You feel a cold shiver run down your spine" if cmd.tokens_count > 2: haunt_message_content = re.sub( "<.+>" if cmd.mentions_count == 1 else "\d{17,}", "", cmd.message.content[(len(cmd.tokens[0])):]).strip() # Cut down really big messages so discord doesn't crash if len(haunt_message_content) > 500: haunt_message_content = haunt_message_content[:-500] haunt_message += " and faintly hear the words \"{}\"".format( haunt_message_content) haunt_message += ". {} slime evaporates from your body.".format( slimes_lost) if ewcfg.mutation_id_coleblooded in target_mutations: haunt_message += " The ghost that did it wails in agony as their ectoplasm boils in your coleslaw blood!" haunt_message = fe_utils.formatMessage(member, haunt_message) resp_cont.add_channel_response(haunted_channel, haunt_message) else: # No mentions, or mentions we didn't understand. response = "Your spookiness is appreciated, but ENDLESS WAR didn\'t understand that name." # Send the response to the player. resp_cont.add_channel_response(cmd.message.channel.name, response) await resp_cont.post()
async def embiggen(cmd): user_data = EwUser(member=cmd.message.author) market_data = EwMarket(id_server=user_data.id_server) item_search = ewutils.flattenTokenListToString(cmd.tokens[1:]) item_sought = bknd_item.find_item(item_search=item_search, id_user=cmd.message.author.id, id_server=cmd.guild.id if cmd.guild is not None else None) if cmd.message.channel.name != ewcfg.channel_slimeoidlab: response = "How are you going to embiggen your fish on the side of the street? You’ve got to see a professional for this, man. Head to the SlimeCorp Laboratory, they’ve got dozens of modern day magic potions ‘n shit over there." elif item_sought: name = item_sought.get('name') fish = EwItem(id_item=item_sought.get('id_item')) acquisition = fish.item_props.get('acquisition') if fish.item_props.get('id_furniture') == "singingfishplaque": poudrins_owned = itm_utils.find_item_all(item_search="slimepoudrin", id_user=user_data.id_user, id_server=user_data.id_server, item_type_filter=ewcfg.it_item) poudrin_amount = len(poudrins_owned) if poudrin_amount < 2: response = "You don't have the poudrins for it." else: for delete in range(2): poudrin = poudrins_owned.pop() bknd_item.item_delete(id_item=poudrin.get("id_item")) fish.item_props['id_furniture'] = "colossalsingingfishplaque" fish.item_props['furniture_look_desc'] = "There's a fake fish mounted on the wall. Hoo boy, it's a whopper." fish.item_props['furniture_place_desc'] = "You take a nail gun to the wall to force it to hold this fish. Christ, this thing is your f*****g Ishmael. Er, Moby Dick. Whatever." fish.item_props['furniture_name'] = "colossal singing fish plaque" fish.item_props['furniture_desc'] = "You press the button on your gigantic plaque.\n***" + fish.item_props.get('furniture_desc')[38:-87].upper().replace(":NOTES:", ":notes:") + "***\nYou abruptly turn the fish off before you rupture an eardrum." fish.persist() response = "The elevator ride down to the embiggening ward feels like an eterninty. Are they going to find out the fish you're embiggening is fake? God, you hope not. But eventually, you make it down, and place the plaque in the usual reclined surgeon's chair. A stray spark from one of the defibrilators nearly gives you a heart attack. But even so, the embiggening process begins like usual. You sign the contract, and they take a butterfly needle to your beloved wall prop. And sure enough, it begins to grow. You hear the sounds of cracked plastic and grinding electronics, and catch a whiff of burnt wires. It's growing. It's 6 feet, no, 10 feet long. Good god. You were hoping for growth, but science has gone too far. Eventually, it stops. Although you raise a few eyebrows with ths anomaly, you still get back the colossal fish plaque without a hitch." elif acquisition != ewcfg.acquisition_fishing: response = "You can only embiggen fishes, dummy. Otherwise everyone would be walking around with colossal nunchucks and huge chicken buckets. Actually, that gives me an idea..." elif fish.item_props.get('embiggened') is not None: response = "After several minutes long elevator descents, in the depths of some basement level far below the laboratory's lobby, you lay down your {} on a reclined medical chair. An NLACU med student finishes the novel length terms of service they were reciting and asks you if you have any questions. You weren’t listening so you just tell them to get on with it so you can go back to haggling prices with Captain Albert Alexander. They oblige.\nThey grab a butterfly needle and carefully stab your fish with it, avoiding the rumbling tumors it's grown from its previous embiggening. All of a sudden, before the surgeon can inject, the {}'s heart rate monitor starts going f*****g nuts. The nurses begin to panic and duck behind equipment as the syringe flies out of the fish and sprays caustic rainbow goop over all the expensive machinery. Some of it lands on your pinky, and it expands into a second thumb. You are escorted out of the basement with a combination of fury and embarrassment.\n\nWelp, guess you can't embiggen the same fish twice. Too many...surgical complications.".format( name, name) else: size = fish.item_props.get('size') poudrin_cost = 0 if size == ewcfg.fish_size_miniscule: poudrin_cost = 2 if size == ewcfg.fish_size_small: poudrin_cost = 4 if size == ewcfg.fish_size_average: poudrin_cost = 8 if size == ewcfg.fish_size_big: poudrin_cost = 16 if size == ewcfg.fish_size_huge: poudrin_cost = 32 if size == ewcfg.fish_size_colossal: poudrin_cost = 32 poudrins_owned = itm_utils.find_item_all(item_search="slimepoudrin", id_user=user_data.id_user, id_server=user_data.id_server, item_type_filter=ewcfg.it_item) poudrin_amount = len(poudrins_owned) if poudrin_cost == 0: response = "Your {} is already as colossal as a fish can get!".format(name) elif poudrin_amount < poudrin_cost: response = "You need {} poudrins to embiggen your {}, but you only have {}!!".format(poudrin_cost, name, poudrin_amount) else: if fish.item_props.get('length') is None: fish.item_props['length'] = float((ewcfg.fish_size_range.get(fish.item_props.get('size'))[0] + ewcfg.fish_size_range.get(fish.item_props.get('size'))[1])/2) fish.item_props['length'] = float(fish.item_props['length']) + random.randint(5 + poudrin_cost, 15 + poudrin_cost) fish.item_props['size'] = fishutils.length_to_size(size_number=float(fish.item_props['length'])) fish.item_props['embiggened'] = 'illegal' fish.persist() for delete in range(poudrin_cost): poudrin = poudrins_owned.pop() bknd_item.item_delete(id_item=poudrin.get("id_item")) market_data.donated_poudrins += poudrin_cost market_data.persist() response = "After several minutes long elevator descents, in the depths of some basement level far below the laboratory's lobby, you lay down your {} on a reclined medical chair. An NLACU med student finishes the novel length terms of service they were reciting and asks you if you have any questions. You weren’t listening so you just tell them to get on with it so you can go back to haggling prices with Captain Albert Alexander. They oblige.\nThey grab a butterfly needle and carefully stab your fish with it, injecting filled with some bizarre, multi-colored serum you’ve never seen before. Sick, it’s bigger now!!".format( name) else: if item_search: # If they didn't forget to specify an item and it just wasn't found. response = "You don't have one." else: response = "Embiggen which fish? (check **!inventory**)" await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def revive(cmd, player_auto=None): time_now = int(time.time()) response = "" if cmd.message.channel.name != ewcfg.channel_endlesswar and cmd.message.channel.name != ewcfg.channel_sewers and player_auto is None: response = "Come to me. I hunger. #{}.".format(ewcfg.channel_sewers) else: if player_auto: player_data = EwUser(id_server=cmd.guild.id, id_user=player_auto) else: player_data = EwUser(member=cmd.message.author) # time_until_revive = (player_data.time_lastdeath + 600) - time_now time_until_revive = (player_data.time_lastdeath) - time_now if time_until_revive > 0 and player_auto is None: response = "ENDLESS WAR is not ready to {} you yet ({}s).".format( cmd.tokens[0], time_until_revive) return await fe_utils.send_message( cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) slimeoid = EwSlimeoid(member=cmd.message.author) if player_data.life_state == ewcfg.life_state_corpse: market_data = EwMarket(id_server=cmd.guild.id) # Endless War collects his fee. # fee = (player_data.slimecoin / 10) # player_data.change_slimecoin(n = -fee, coinsource = ewcfg.coinsource_revival) # market_data.slimes_revivefee += fee # player_data.busted = False # Preserve negaslime if player_data.slimes < 0: # market_data.negaslime += player_data.slimes player_data.change_slimes(n=-player_data.slimes) # set to 0 # reset slimelevel to zero player_data.slimelevel = 0 # Set time of last revive. This used to provied spawn protection, but currently isn't used. player_data.time_lastrevive = time_now if False: #player_data.degradation >= 100: player_data.life_state = ewcfg.life_state_shambler player_data.change_slimes(n=0.5 * ewcfg.slimes_shambler) player_data.trauma = "" poi_death = poi_static.id_to_poi.get(player_data.poi_death) if move_utils.inaccessible(poi=poi_death, user_data=player_data): player_data.poi = ewcfg.poi_id_endlesswar else: player_data.poi = poi_death.id_poi else: # Set life state. This is what determines whether the player is actually alive. player_data.life_state = ewcfg.life_state_juvenile # Give player some initial slimes. player_data.change_slimes(n=ewcfg.slimes_onrevive) # Get the player out of the sewers. player_data.poi = ewcfg.poi_id_endlesswar # Give newly spawned juvies a foul odour player_data.applyStatus(ewcfg.status_repelled_id) player_data.persist() market_data.persist() # Shower every district in the city with slime from the sewers. sewer_data = EwDistrict(district=ewcfg.poi_id_thesewers, id_server=cmd.guild.id) # the amount of slime showered is divided equally amongst the districts districts_amount = len(poi_static.capturable_districts) geyser_amount = int(0.5 * sewer_data.slimes / districts_amount) # Get a list of all the districts for poi in poi_static.capturable_districts: district_data = EwDistrict(district=poi, id_server=cmd.guild.id) district_data.change_slimes(n=geyser_amount) sewer_data.change_slimes(n=-1 * geyser_amount) district_data.persist() sewer_data.persist() sewer_inv = bknd_item.inventory(id_user=sewer_data.name, id_server=sewer_data.id_server) for item in sewer_inv: district = ewcfg.poi_id_slimesea if random.random() < 0.5: district = random.choice(poi_static.capturable_districts) bknd_item.give_item(id_item=item.get("id_item"), id_user=district, id_server=sewer_data.id_server) await ewrolemgr.updateRoles(client=cmd.client, member=cmd.message.author) response = '{slime4} Geysers of fresh slime erupt from every manhole in the city, showering their surrounding districts. {slime4} {name} has been reborn in slime. {slime4}'.format( slime4=ewcfg.emote_slime4, name=cmd.message.author.display_name) else: response = 'You\'re not dead just yet.' # deathreport = "You were {} by {}. {}".format(kill_descriptor, cmd.message.author.display_name, ewcfg.emote_slimeskull) # deathreport = "{} ".format(ewcfg.emote_slimeskull) + fe_utils.formatMessage(member, deathreport) if slimeoid.life_state == ewcfg.slimeoid_state_active: reunite = "" brain = sl_static.brain_map.get(slimeoid.ai) reunite += brain.str_revive.format(slimeoid_name=slimeoid.name) new_poi = poi_static.id_to_poi.get(player_data.poi) revivechannel = fe_utils.get_channel(cmd.guild, new_poi.channel) reunite = fe_utils.formatMessage(cmd.message.author, reunite) await fe_utils.send_message(cmd.client, revivechannel, reunite) # Send the response to the player. await fe_utils.send_message( cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))
async def refresh_bazaar(id_server=None): if id_server: # Update the list of available bazaar items by clearing the current list and adding the new items market_data = EwMarket(id_server) market_data.bazaar_wares.clear() bazaar_foods = [] bazaar_cosmetics = [] bazaar_general_items = [] bazaar_furniture = [] bazaar_relics = [] for item in vendors.vendor_inv.get(ewcfg.vendor_bazaar): if item in static_items.item_names: bazaar_general_items.append(item) elif item in static_food.food_names: bazaar_foods.append(item) elif item in cosmetics.cosmetic_names: bazaar_cosmetics.append(item) elif item in static_items.furniture_names: bazaar_furniture.append(item) elif item in static_relic.relic_names and relic_utils.canCreateRelic( item=item, id_server=id_server) is not None: bazaar_relics.append(item) if (ewdebug.bazaarTurnout() == 1) and (len(bazaar_relics) > 0): market_data.bazaar_wares['relic1'] = random.choice(bazaar_relics) market_data.bazaar_wares['slimecorp1'] = ewcfg.weapon_id_umbrella market_data.bazaar_wares['slimecorp2'] = ewcfg.cosmetic_id_raincoat market_data.bazaar_wares['generalitem'] = random.choice( bazaar_general_items) market_data.bazaar_wares['food1'] = random.choice(bazaar_foods) # Don't add repeated foods bw_food2 = None while bw_food2 is None or bw_food2 in market_data.bazaar_wares.values( ): bw_food2 = random.choice(bazaar_foods) market_data.bazaar_wares['food2'] = bw_food2 market_data.bazaar_wares['cosmetic1'] = random.choice(bazaar_cosmetics) # Don't add repeated cosmetics bw_cosmetic2 = None while bw_cosmetic2 is None or bw_cosmetic2 in market_data.bazaar_wares.values( ): bw_cosmetic2 = random.choice(bazaar_cosmetics) market_data.bazaar_wares['cosmetic2'] = bw_cosmetic2 bw_cosmetic3 = None while bw_cosmetic3 is None or bw_cosmetic3 in market_data.bazaar_wares.values( ): bw_cosmetic3 = random.choice(bazaar_cosmetics) market_data.bazaar_wares['cosmetic3'] = bw_cosmetic3 market_data.bazaar_wares['furniture1'] = random.choice( bazaar_furniture) bw_furniture2 = None while bw_furniture2 is None or bw_furniture2 in market_data.bazaar_wares.values( ): bw_furniture2 = random.choice(bazaar_furniture) market_data.bazaar_wares['furniture2'] = bw_furniture2 bw_furniture3 = None while bw_furniture3 is None or bw_furniture3 in market_data.bazaar_wares.values( ): bw_furniture3 = random.choice(bazaar_furniture) market_data.bazaar_wares['furniture3'] = bw_furniture3 if random.random() < 0.05: # 1 / 20 market_data.bazaar_wares['minigun'] = ewcfg.weapon_id_minigun if random.random() < 0.05: # 1 / 20 market_data.bazaar_wares['bustedrifle'] = ewcfg.item_id_bustedrifle market_data.persist()
async def menu(cmd): user_data = EwUser(member=cmd.message.author, data_level=2) if user_data.life_state == ewcfg.life_state_shambler and user_data.poi != ewcfg.poi_id_nuclear_beach_edge: 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)) market_data = EwMarket(id_server=cmd.guild.id) # poi = ewmap.fetch_poi_if_coordless(cmd.message.channel.name) poi = poi_static.id_to_poi.get(user_data.poi) if user_data.poi == ewcfg.poi_id_clinicofslimoplasty: response = "Try {}browse. The menu is in the zines.".format(ewcfg.cmd_prefix) elif poi is None or len(poi.vendors) == 0 or ewutils.channel_name_is_poi(cmd.message.channel.name) == False: # Only allowed in the food court. response = "There’s nothing to buy here. If you want to purchase some items, go to a sub-zone with a vendor in it, like the food court, the speakeasy, or the bazaar." else: poi = poi_static.id_to_poi.get(user_data.poi) mother_district_data = None for mother_poi in poi.mother_districts: mother_poi_data = poi_static.id_to_poi.get(mother_poi) if mother_poi_data.is_district: # One of the mother pois was a district, get its controlling faction mother_district_data = EwDistrict(district=mother_poi, id_server=user_data.id_server) break else: # One of the mother pois was a street, get the father district of that street and its controlling faction father_poi = mother_poi_data.father_district mother_district_data = EwDistrict(district=father_poi, id_server=user_data.id_server) break district_data = EwDistrict(district=poi.id_poi, id_server=user_data.id_server) # mother_district_data = EwDistrict(district = destination_poi.id_poi, id_server = user_data.id_server) shambler_multiplier = 1 # for speakeasy during shambler times if district_data.is_degraded() and poi.id_poi != ewcfg.poi_id_nuclear_beach_edge: if poi.id_poi == ewcfg.poi_id_speakeasy: shambler_multiplier = 4 else: 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)) controlling_faction = poi_utils.get_subzone_controlling_faction(user_data.poi, user_data.id_server) response = "{} Menu:\n\n".format(poi.str_name) vendors_list = poi.vendors for vendor in vendors_list: if vendor == ewcfg.vendor_secretbodega: if user_data.freshness < ewcfg.freshnesslevel_4: continue else: response += '\nThe hipster behind the counter nearly falls out of his chair after laying eyes on the sheer, unadulterated freshness before him.\n"S-Sir! Your outfit... i-it is positively ***on fleek!!*** As I see you are a fashion enthusiast like myself, let me show you the good stuff…"\n' items = [] # If the vendor is the bazaar get the current rotation of items from the market_data vendor_inv = vendors.vendor_inv[vendor] if vendor != ewcfg.vendor_bazaar else market_data.bazaar_wares.values() for item_name in vendor_inv: item_item = static_items.item_map.get(item_name) food_item = static_food.food_map.get(item_name) cosmetic_item = static_cosmetics.cosmetic_map.get(item_name) furniture_item = static_items.furniture_map.get(item_name) weapon_item = static_weapons.weapon_map.get(item_name) relic_item = static_relic.relic_map.get(item_name) if relic_item is not None: if relic_utils.canCreateRelic(item_name, cmd.guild.id) == None: continue # increase profits for the stock market stock_data = None if vendor in ewcfg.vendor_stock_map: stock = ewcfg.vendor_stock_map.get(vendor) stock_data = EwStock(id_server=user_data.id_server, stock=stock) value = 0 if item_item: value = item_item.price if food_item: value = food_item.price if cosmetic_item: value = cosmetic_item.price if furniture_item: value = furniture_item.price if weapon_item: value = weapon_item.price if relic_item: value = relic_item.price if stock_data != None: value *= (stock_data.exchange_rate / ewcfg.default_stock_exchange_rate) ** 0.2 # multiply by 4 is speakeasy is shambled value *= shambler_multiplier if mother_district_data != None: if controlling_faction != "": # prices are halved for the controlling gang if controlling_faction == user_data.faction: value /= 2 # and 4 times as much for enemy gangsters elif user_data.faction != "": value *= 4 if vendor == ewcfg.vendor_breakroom and user_data.faction == ewcfg.faction_slimecorp: value = 0 value = int(value) if value != 0: items.append('{} ({:,})'.format(item_name, value)) else: items.append(item_name) response += "**{}**: *{}*\n".format(vendor, ewutils.formatNiceList(names=items)) if vendor == ewcfg.vendor_bodega: if user_data.freshness < ewcfg.freshnesslevel_1: response += "\nThe hipster behind the counter is utterly repulsed by the fashion disaster in front of him. Looks like you just aren’t fresh enough for him." if user_data.has_soul == 0: if vendor == ewcfg.vendor_dojo: response += "\n\nThe Dojo master looks at your soulless form with pity." elif vendor == ewcfg.vendor_bar: response += "\n\nThe bartender, sensing your misery, asks if you're okay." elif vendor == ewcfg.vendor_diner: response += "\n\nThe cook gives you a concerned look as he throws down another helping of flapjacks." elif vendor == ewcfg.vendor_seafood: response += "\n\nThe waiter sneers at how soulless and unkempt you look. You try to ignore him." elif vendor == ewcfg.vendor_bazaar: response += "\n\nAll the shops seem so lively. You wish you had a soul so you could be like them." elif vendor == ewcfg.vendor_beachresort or vendor == ewcfg.vendor_countryclub: response += "\n\nEverything looks so fancy here, but it doesn't really appeal to you since you don't have a soul." elif vendor == ewcfg.vendor_bodega: if user_data.freshness < ewcfg.freshnesslevel_1: response += ".. and you probably never will be." elif vendor == ewcfg.vendor_glocksburycomics: response += "\n\nThe cashier here tries to start up a conversation about life being worth living. You're having none of it." elif vendor == ewcfg.vendor_basedhardware: response += "\n\nSo many industrial metals here... You contemplate which you could use to kill yourself..." elif vendor == ewcfg.vendor_wafflehouse: response += "\n\nNot even waffles could hope to make your emptiness go away." elif vendor == ewcfg.vendor_greencakecafe: response += "\n\nThe barista behind the counter pauses to look at your soulless misery for a second, but decides you're not worth it and gets back to work." elif vendor == ewcfg.vendor_slimypersuits: response += "\n\nYour mere presence in here ruins the cheery atmosphere." # 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 publish_manuscript(cmd): 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)) market_data = EwMarket(id_server=user_data.id_server) poi = poi_static.id_to_poi.get(user_data.poi) if not poi.write_manuscript: response = "You'd love to work on your zine, however your current location doesn't strike you as a particularly good place to write. Try heading over the the Cafe, the Comic Shop, or one of the colleges (NLACU/NMS)." elif user_data.manuscript == -1: response = "You have yet to create a manuscript. Try !createmanuscript" else: book = EwBook(member=cmd.message.author, book_state=0) # check if zine is unreasonably short length = 0 for page in book.book_pages.keys(): length += len(book.book_pages[page]) if book.genre == -1: response = "Before you publish your zine, you must first set a genre with !setgenre. The genre choices are {}.".format(ewutils.formatNiceList(ewcfg.book_genres)) elif len(book.book_pages.keys()) < 3 or length < 10: response = "Who are you trying to fool? This zine is obviously too short!" else: accepted = False response = "Are you sure you want to publish your manuscript? This cannot be undone. **!accept** or **!refuse**" await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response)) try: message = await cmd.client.wait_for('message', timeout=20, 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: accepted = False if not accepted: response = "The manuscript was not published." else: book.book_state = 1 book.date_published = market_data.day length = 0 for page in range(1, book.pages + 1): length += len(book.book_pages.get(page, "")) book.length = length user_data.manuscript = -1 user_data.persist() book.persist() bknd_item.item_create( item_type=ewcfg.it_book, id_user=user_data.id_user, id_server=book.id_server, item_props={ "title": book.title, "author": book.author, "date_published": book.date_published, "id_book": book.id_book, "book_desc": "A zine by {}, published on {}. It's the author's copy.".format(book.author, book.date_published) }) book_sale = EwBookSale(id_book=book.id_book, member=cmd.message.author) book_sale.bought = 1 book_sale.persist() response = "You've published your manuscript! Anybody can now buy your creation and you'll get royalties!" await fe_utils.send_message(cmd.client, cmd.message.channel, fe_utils.formatMessage(cmd.message.author, response))