From 52801b4de1d63cd01191acf7fcee137977140ec0 Mon Sep 17 00:00:00 2001 From: lexicade Date: Fri, 27 Jan 2023 21:06:30 +0000 Subject: Project init --- cogs/adv_inc/AdventurersInc.py | 107 ++++++++++++++++++ cogs/adv_inc/Calculate.py | 52 +++++++++ cogs/adv_inc/Combat.py | 167 ++++++++++++++++++++++++++++ cogs/adv_inc/Enemy.py | 82 ++++++++++++++ cogs/adv_inc/Items.py | 245 +++++++++++++++++++++++++++++++++++++++++ cogs/adv_inc/LevelUp.py | 41 +++++++ cogs/adv_inc/PlayerCreate.py | 65 +++++++++++ cogs/adv_inc/PlayerDeath.py | 41 +++++++ cogs/adv_inc/PlayerStats.py | 79 +++++++++++++ cogs/adv_inc/Resting.py | 204 ++++++++++++++++++++++++++++++++++ cogs/adv_inc/__init__.py | 0 11 files changed, 1083 insertions(+) create mode 100644 cogs/adv_inc/AdventurersInc.py create mode 100644 cogs/adv_inc/Calculate.py create mode 100644 cogs/adv_inc/Combat.py create mode 100644 cogs/adv_inc/Enemy.py create mode 100644 cogs/adv_inc/Items.py create mode 100644 cogs/adv_inc/LevelUp.py create mode 100644 cogs/adv_inc/PlayerCreate.py create mode 100644 cogs/adv_inc/PlayerDeath.py create mode 100644 cogs/adv_inc/PlayerStats.py create mode 100644 cogs/adv_inc/Resting.py create mode 100644 cogs/adv_inc/__init__.py (limited to 'cogs/adv_inc') diff --git a/cogs/adv_inc/AdventurersInc.py b/cogs/adv_inc/AdventurersInc.py new file mode 100644 index 0000000..f47bd5e --- /dev/null +++ b/cogs/adv_inc/AdventurersInc.py @@ -0,0 +1,107 @@ +import configparser +import pymysql +from discord.ext import commands +import discord +import importlib +import utils + +from cogs.adv_inc import PlayerStats +from cogs.adv_inc import PlayerCreate +from cogs.adv_inc import LevelUp +from cogs.adv_inc import Resting +from cogs.adv_inc import Combat + +importlib.reload(utils) +importlib.reload(PlayerStats) +importlib.reload(PlayerCreate) +importlib.reload(LevelUp) +importlib.reload(Resting) +importlib.reload(Combat) + + +class AdventurersInc(commands.Cog): + def __init__(self, bot): + self.bot = bot + + @commands.command() + async def a(self, ctx, *arg): + if "adventurers-inc" in str(ctx.channel): + # Variables + str_input_group = ctx.message.content.split(" ") + try: + str_cmd1 = ctx.message.content.split(" ")[1] + except: + str_cmd1 = "" + try: + str_cmd2 = ctx.message.content.split(" ")[2] + except: + str_cmd2 = "" + + # config = configparser.ConfigParser() + # config.read(r'config.ini') + # pgloader mysql://adventure:egg@lexicade.uk:3306/AdventurersInc postgresql://Lexicade:LetMeIn123@localhost:5432/AdventurersInc + # str_player_state = "debug" + # params = {'LiveDB': 'AdventurersInc', + # 'LiveVersion': '1.0', + # 'GameVersion': '1.3.1', + # 'Nick': ctx.author.id, + # "db": '5.135.189.226', + # 'dbuser': 'adventure', + # 'dbpass': 'egg', + # 'cmd1': str_cmd1, + # 'cmd2': str_cmd2, + # 'msg': ctx.message.content[3:]} + params = {'game_version': '1.4', + 'nick': ctx.author.id, + 'ctx': ctx, + 'cmd1': str_cmd1, + 'cmd2': str_cmd2, + 'msg': ctx.message.content[3:]} + + player_stats = await PlayerStats.refresh_stats(params) + # print(player_stats) + + str_output = 'Oh hi there... \\_(:o怍āˆ )\\_' + # Global Commands + if str_cmd1 == "git": + str_output = "Adventurers Inc - git: http://www.blatech.co.uk/JasonFS/Artifact-v2" + elif str_cmd1 == "version": + str_output = "Adventurers Inc - alpha 0.1" + else: + # Actions based on player state + if player_stats is None: + print("OH GOD NO") + str_output = await PlayerCreate.pick_character_clan(params) + + elif player_stats["player_state"] == "creation_name": + str_output = await PlayerCreate.pick_character_name(params, player_stats) + + elif player_stats["player_state"] == "creation_race": + str_output = await PlayerCreate.pick_character_race(params, player_stats) + + elif player_stats["player_state"] == "rest" and player_stats['attribute_points'] > 0: + str_output = await LevelUp.level_up_attributes(params) + + elif player_stats["player_state"] == "rest" and player_stats['attribute_points'] == 0: + str_output = await Resting.player_resting(params, player_stats) + + elif player_stats["player_state"] == "combat": + str_output = await Combat.player_in_combat(params) + + if str_output is not None: + if type(str_output) == str or type(str_output) == dict: + await ctx.send(content=f"{ctx.author.mention}: {str_output}") + else: + await ctx.send(content=f"{ctx.author.mention}", embed=str_output) + else: + await ctx.send(content=f"Wrong channel {ctx.channel}") + + +def setup(bot): + print("INFO: Loading [Adventurers Inc]... ", end="") + bot.add_cog(AdventurersInc(bot)) + print("Done!") + + +def teardown(bot): + print("INFO: Unloading [Adventurers Inc]") diff --git a/cogs/adv_inc/Calculate.py b/cogs/adv_inc/Calculate.py new file mode 100644 index 0000000..b6861ca --- /dev/null +++ b/cogs/adv_inc/Calculate.py @@ -0,0 +1,52 @@ +import math +import random + + +async def get_dodge_chance(dexterity, dodge, coefficient=110): + system_percentage = (dodge + (dexterity / 3)) / ((dodge+(dexterity / 3)) + coefficient) + return system_percentage + + +async def get_block_chance(strength, block, coefficient=30): + strength_bonus = 0 if strength < 17 else math.floor((strength-17) / 3) + system_percentage = (block + (strength_bonus / 3)) / ((block + (strength_bonus / 3)) + coefficient) + return system_percentage + + +async def get_luck_chance(luck, coefficient=50): + luck_rolls = round((luck / (luck + coefficient)) * 15, 0) + return int(luck_rolls) + + +async def get_attack_power(strength, dexterity): + str_bonus = strength * 1 + dex_bonus = math.floor(dexterity / 2) + attack_power = random.uniform((str_bonus + dex_bonus) * 1.1, (str_bonus + dex_bonus) * 0.9) + return math.floor(attack_power) + + +async def get_hit_chance(dexterity, accuracy, coefficient=50): + system_percentage = (accuracy + (dexterity / 3)) / ((accuracy + (dexterity / 3)) + coefficient) + return system_percentage + + +async def get_max_life(strength, constitution): + str_bonus = math.floor(strength / 3) + con_bonus = constitution * 2 + max_life = con_bonus + str_bonus + return math.floor(max_life) + + +async def get_armour_percentage(armour, strength, constitution, coefficient=80): + strength_bonus = 0 if strength < 20 else math.floor((strength-16) / 4) + constitution_bonus = 0 if constitution < 20 else math.floor((constitution-16) / 4) + armour_bonus = armour * 3 + armour_perc = (strength_bonus + constitution_bonus + armour_bonus / 3) / ((strength_bonus + constitution_bonus + armour_bonus / 3) + coefficient) + return round(armour_perc, 2) + + +async def get_crit_percentage(dexterity, critical, coefficient=100): + critical = critical * 2 + dexterity_bonus = math.floor(dexterity / 3) + critical_chance = (critical + dexterity_bonus / 3) / ((critical + dexterity_bonus / 3) + coefficient) + return round(critical_chance, 2) diff --git a/cogs/adv_inc/Combat.py b/cogs/adv_inc/Combat.py new file mode 100644 index 0000000..578ff31 --- /dev/null +++ b/cogs/adv_inc/Combat.py @@ -0,0 +1,167 @@ +import pymysql +import math +import re +import sys +import random +import os +import importlib +import utils + +from cogs.adv_inc import PlayerStats +from cogs.adv_inc import Items +from cogs.adv_inc import Enemy +from cogs.adv_inc import PlayerDeath +from cogs.adv_inc import Calculate + +importlib.reload(utils) +importlib.reload(PlayerStats) +importlib.reload(Items) +importlib.reload(Enemy) +importlib.reload(PlayerDeath) +importlib.reload(Calculate) + + +async def player_in_combat(params): + player_stats = await PlayerStats.refresh_stats(params) + enemy_stats = await Enemy.get_enemy_stats(params) + if enemy_stats is None: + str_output = "Combat error, returning to camp." + await utils.sql_postgres('CALL adventurersinc.del_player_enemies(%s)', (params['nick'],), False) + await utils.sql_postgres('CALL adventurersinc.set_player_state(%s, %s)', (params['nick'], 'rest',), False) + return str_output + + str_attack_log = '' + + # Attack + if params['cmd1'] == 'a' or params['cmd1'] == 'attack': + # Players attack + str_attack_log = str_attack_log + await perform_attack(player_stats, enemy_stats, params) + + if enemy_stats['hp'] <= 0: + str_attack_log = str_attack_log + f"The {enemy_stats['enemy_name']} falls to the floor. " + + # Generate equipment item + if random.randint(1, 2) == 1 and enemy_stats['enemy_class'] == 'normal': + + # Generate Shard of Chaos on Chaos kill + if enemy_stats['unlock'] == 'chaos': + await utils.sql_postgres(f"CALL adventurersinc.add_shard_of_chaos(%s)", (params["nick"],), False) + return "You acquire a Shard of Chaos from the remains of the enemy." + + # Generate normal equipment drop + elif enemy_stats['unlock'] == 'default': + # Equipment Drop Rarity:Element:Item:Enchantment:Fabled + item_gen = await Items.generate_equipment(params, '0:0:0:0:0') + str_attack_log = str_attack_log + f"You obtained a {item_gen['equipment_colour']} {item_gen['equipment_name']}. " + await Items.add_to_inventory(params, item_gen) + + # Generate gold drop + if random.randint(1, 1) == 1: + await utils.sql_postgres("CALL adventurersinc.set_player_exit_combat(%s, %s)", (enemy_stats['gold_carried'], params["nick"],), False) + str_attack_log = str_attack_log + f"You found {enemy_stats['gold_carried']} gold. " + + await utils.sql_postgres("CALL adventurersinc.del_player_enemies(%s)", (params["nick"],), False) + + # Attempt to restock shop + if random.randint(1, 2) == 1: + str_attack_log = str_attack_log + "A new travelling merchant has arrived. " + await utils.sql_postgres("CALL adventurersinc.del_player_shop(%s)", (params["nick"],), False) + + for i in range(1, (random.randint(3, 5) + 1)): + await Items.add_to_shop(params, await Items.generate_equipment(params, '0:0:0:0:1')) + + # # Unlock boss items + # if enemy_stats['unlock'] is not 'default' and enemy_stats['enemy_class'] is 'boss': + # await utils.sql_postgres("", (params['nick'], enemy_stats['Unlock'],), True) + # sql_unlock_check = c.fetchone() + # if str(sql_unlock_check['requirement']) == '0': + # Items.unlock_items(params, str(enemy_stats['unlock'])) + # return "Additional items will now begin appearing" + + player_stats = await PlayerStats.refresh_stats(params) + if float(player_stats['challenge_rating']).is_integer(): + int_attribute_points = 2 + int(player_stats["challenge_rating"]) + await utils.sql_postgres("CALL adventurersinc.set_player_attribute_points(%s, %s)", (int_attribute_points, params["nick"],), False) + str_attack_log = str_attack_log + f"You have gained {int_attribute_points} attribute points. " + else: + # Enemy attack + str_attack_log = str_attack_log + await perform_attack(enemy_stats, player_stats, params) + + if player_stats['hp'] <= 0: + str_attack_log = f"{str_attack_log}. You died. (http://adventurersinc.lelong.uk/graveyard/)" + await PlayerDeath.character_death(player_stats, params) + + return "" + str_attack_log + + # flee + elif params['cmd1'].lower() == 'f' or params['cmd1'].lower() == 'flee': + if random.randint(1, 2) == 1: + return await flee_combat(params) + else: + str_output = f"You failed to escape. {await perform_attack(enemy_stats, player_stats, params)}" + if player_stats['hp'] <= 0: + str_output = f"{str_output}. You were struck down as you attempted to flee. You died. (http://adventurersinc.lelong.uk/graveyard/)" + await PlayerDeath.character_death(player_stats, params) + return str_output + + # Admin commands + elif params['cmd1'].lower() == 'admin' and input.admin: + return perform_attack(player_stats, enemy_stats, params["nick"]) + else: + return "Available commands: (a)ttack, (f)lee" + + +async def perform_attack(attacker_stats, defender_stats, params): + # Check if the defender dodges + dodge_perc = await Calculate.get_dodge_chance(int(defender_stats['dexterity']), int(defender_stats['dodge'])) + if random.randint(0, 100) < math.floor(dodge_perc * 100): + if attacker_stats['unit_type'] == 'player': + return "You miss. " + elif attacker_stats['unit_type'] == 'enemy': + return f"You dodge the {attacker_stats['enemy_name']}'s attack. " + + # Check if the defender blocks + block_perc = await Calculate.get_block_chance(defender_stats['strength'], defender_stats['block']) + if random.randint(0, 100) < math.floor(block_perc * 100): + if attacker_stats['unit_type'] == 'player': + return "The enemy blocks your attack. " + elif attacker_stats['unit_type'] == 'enemy': + return f"You block the {attacker_stats['enemy_name']}'s attack. " + + # Generate combat values + int_attack_damage = await Calculate.get_attack_power(attacker_stats['strength'], attacker_stats['dexterity']) + int_armour_perc = await Calculate.get_armour_percentage(attacker_stats['armour'], attacker_stats['strength'], attacker_stats['constitution']) + int_crit_chance = await Calculate.get_crit_percentage(attacker_stats['crit'], attacker_stats['dexterity']) + int_final_damage = int_attack_damage - (int_attack_damage * int_armour_perc) + + # Determine if the attacker is going to crit + if random.randint(0, 100) < (int_crit_chance * 100): + int_final_damage = int_final_damage * 2 + str_crit = '**CRIT**' + else: + str_crit = 'did' + + # Round this up to avoid decimals + int_final_damage = math.ceil(int_final_damage) + + # Update defender health + defender_stats['hp'] = defender_stats['hp'] - int_final_damage + + # Update HP of the appropriate unit_type + await utils.sql_postgres(f"CALL adventurersinc.set_{str(defender_stats['unit_type'])}_health(%s, %s);", (int(defender_stats['hp']), int(params['nick']),), False) + + # Assemble hit message + if attacker_stats['unit_type'] == 'player': + return f"You {str_crit} {int_final_damage} damage. " + elif attacker_stats['unit_type'] == 'enemy': + return f"The {attacker_stats['enemy_name']} {str_crit} {int_final_damage} damage. " + + +async def flee_combat(params): + # Delete players opponent + await utils.sql_postgres("CALL adventurersinc.del_player_enemies(%s);", (params['nick'],), False) + + # Update player record for player + await utils.sql_postgres("CALL adventurersinc.set_player_state(%s,%s)", (params['nick'], 'rest',), False) + + return "You flee your enemy." diff --git a/cogs/adv_inc/Enemy.py b/cogs/adv_inc/Enemy.py new file mode 100644 index 0000000..f5f76e6 --- /dev/null +++ b/cogs/adv_inc/Enemy.py @@ -0,0 +1,82 @@ +import pymysql +import math +import random +import importlib +import utils + +importlib.reload(utils) + + +async def create_enemy(enemy_stats, player_stats, params): + # Update player state for combat + await utils.sql_postgres("CALL adventurersinc.set_playerstate_combat(%s)", (params['nick'],), False) + + # If challenge_rating is an INT we'll swap for a boss + if player_stats['challenge_rating'] == int(math.ceil(player_stats['challenge_rating'] / 4) * 4): + str_class = "boss" + else: + str_class = "normal" + + # Get enemy weighting list + all_enemies = await utils.sql_postgres(f"SELECT adventurersinc.get_all_enemies(%s)", (str_class,), True) + int_total_weight = random.randint(1, all_enemies[0][0]['total_weight']) + + # Apply challenge rating modifier to enemy + int_challenge_modifier = player_stats['challenge_rating'] / 2 + + for enemy in all_enemies: + int_total_weight = int_total_weight - enemy[0]['enemy_weight'] + if int_total_weight <= 0: + # Set stats + enemy[0]['enemy_colour'] = enemy[0]['enemy_colour'] + enemy[0]['enemy_name'] = str(enemy[0]['enemy_name']) + enemy[0]['enemy_class'] = str(enemy[0]['enemy_class']) + enemy[0]['unlock'] = str(enemy[0]['unlock']) + enemy[0]['hp'] = math.floor(enemy[0]['hp'] * int_challenge_modifier) + enemy[0]['enemy_weight'] = math.floor(enemy[0]['enemy_weight'] * int_challenge_modifier) + enemy[0]['challenge_rating'] = math.floor(enemy[0]['challenge_rating'] * int_challenge_modifier) + enemy[0]['gold_carried'] = math.floor(enemy[0]['gold_carried'] * int_challenge_modifier) + enemy[0]['strength'] = math.floor(enemy[0]['strength'] * int_challenge_modifier) + enemy[0]['dexterity'] = math.floor(enemy[0]['dexterity'] * int_challenge_modifier) + enemy[0]['constitution'] = math.floor(enemy[0]['constitution'] * int_challenge_modifier) + enemy[0]['intelligence'] = math.floor(enemy[0]['intelligence'] * int_challenge_modifier) + enemy[0]['dodge'] = math.floor(enemy[0]['dodge'] * int_challenge_modifier) + enemy[0]['crit'] = math.floor(enemy[0]['crit'] * int_challenge_modifier) + enemy[0]['accuracy'] = math.floor(enemy[0]['accuracy'] * int_challenge_modifier) + enemy[0]['resistance'] = math.floor(enemy[0]['resistance'] * int_challenge_modifier) + enemy[0]['luck'] = math.floor(enemy[0]['luck'] * int_challenge_modifier) + enemy[0]['block'] = math.floor(enemy[0]['block'] * int_challenge_modifier) + break + + await utils.sql_postgres("CALL adventurersinc.add_player_enemy(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)", + (params['nick'], enemy[0]['enemy_colour'], enemy[0]['enemy_name'], enemy[0]['enemy_class'], enemy[0]['unlock'], enemy[0]['hp'], enemy[0]['enemy_weight'],enemy[0]['challenge_rating'], enemy[0]['gold_carried'], + enemy[0]['strength'], enemy[0]['dexterity'], enemy[0]['constitution'], enemy[0]['intelligence'], enemy[0]['dodge'], enemy[0]['crit'], enemy[0]['accuracy'], enemy[0]['resistance'], enemy[0]['luck'], enemy[0]['block'],), False) + + return enemy[0] + + +async def get_enemy_stats(params): + enemy = await utils.sql_postgres("SELECT adventurersinc.get_player_enemy(%s)", (params['nick'],), True) + if enemy[0][0] is None: + return None + + enemy[0][0]['enemy_colour'] = enemy[0][0]['enemy_colour'] + enemy[0][0]['enemy_name'] = enemy[0][0]['enemy_name'] + enemy[0][0]['enemy_class'] = enemy[0][0]['enemy_class'] + enemy[0][0]['unlock'] = enemy[0][0]['unlock'] + enemy[0][0]['hp'] = enemy[0][0]['hp'] + enemy[0][0]['gold_carried'] = enemy[0][0]['gold_carried'] + enemy[0][0]['strength'] = enemy[0][0]['strength'] + enemy[0][0]['dexterity'] = enemy[0][0]['dexterity'] + enemy[0][0]['constitution'] = enemy[0][0]['constitution'] + enemy[0][0]['intelligence'] = enemy[0][0]['intelligence'] + enemy[0][0]['dodge'] = enemy[0][0]['dodge'] + enemy[0][0]['crit'] = enemy[0][0]['crit'] + enemy[0][0]['accuracy'] = enemy[0][0]['accuracy'] + enemy[0][0]['resistance'] = enemy[0][0]['resistance'] + enemy[0][0]['luck'] = enemy[0][0]['luck'] + enemy[0][0]['block'] = enemy[0][0]['block'] + enemy[0][0]['armour'] = 0 + enemy[0][0]['unit_type'] = 'enemy' + + return enemy[0][0] diff --git a/cogs/adv_inc/Items.py b/cogs/adv_inc/Items.py new file mode 100644 index 0000000..52cc38f --- /dev/null +++ b/cogs/adv_inc/Items.py @@ -0,0 +1,245 @@ +import pymysql +import random +import math +import importlib +import utils + +import codecs +import unicodedata + +importlib.reload(utils) + + +async def generate_equipment(params, item_code): + # int_iteration = 0 + # item_name = str_rarity_spacing = '' + item_code = item_code.split(':') + + # for i in range(len(item_code)): + # if str(i).isdigit(): + # i = i + # else: + # i = random.choice(i.split(',')) + + # Generate Rarity + item_gen_rarity = await create_equipment_rarity(item_code[0]) + + # Generate Item + item_gen_equipment = await create_equipment_name(item_code[1]) + + # Generate Enchantment (Uncommon or greater) + item_gen_enchantment = await create_equipment_enchantment(item_code[2], item_gen_rarity['rarity_id']) + + # Generate Element (Rare or greater) + item_gen_element = await create_equipment_element(item_code[3], item_gen_rarity['rarity_id']) + + # Attempt creating an Artifact + item_gen_equipment = await create_equipment_artifact(params, item_code[4], item_gen_equipment) + + # print(type(item_gen_element), item_gen_equipment['permanent'], (("" if item_gen_equipment['permanent'] == 0 else "Fabled ") + + # f"{item_gen_rarity['rarity_name']}" + + # ("" if len(item_gen_rarity['rarity_name']) == 0 else " ") + + # ("" if item_gen_element is None else item_gen_element['element_name'] + " ") + + # f"{item_gen_equipment['equipment_name']} " + + # ("" if item_gen_enchantment is None else item_gen_enchantment['enchant_name'])).strip()) + + item_gen = {'equipment_colour': item_gen_rarity['rarity_colour'], + 'equipment_name': (("" if item_gen_equipment['permanent'] == 0 else "Fabled ") + + f"{item_gen_rarity['rarity_name']}" + + ("" if len(item_gen_rarity['rarity_name']) == 0 else " ") + + ("" if item_gen_element is None else item_gen_element['element_name'] + " ") + + f"{item_gen_equipment['equipment_name']} " + + ("" if item_gen_enchantment is None else item_gen_enchantment['enchant_name'])).strip(), + 'equipment_slot': item_gen_equipment['equipment_slot'], + 'equipment_type': item_gen_equipment['equipment_type'], + 'hands_req': item_gen_equipment['hands_req'], + 'strength': math.floor((item_gen_equipment['strength'] + (0 if item_gen_enchantment is None else item_gen_enchantment['strength']) + + (0 if item_gen_element is None else item_gen_element['strength'])) * item_gen_rarity['rarity_modifier']), + 'dexterity': math.floor((item_gen_equipment['dexterity'] + (0 if item_gen_enchantment is None else item_gen_enchantment['dexterity']) + + (0 if item_gen_element is None else item_gen_element['dexterity'])) * item_gen_rarity['rarity_modifier']), + 'constitution': math.floor((item_gen_equipment['constitution'] + (0 if item_gen_enchantment is None else item_gen_enchantment['constitution']) + + (0 if item_gen_element is None else item_gen_element['constitution'])) * item_gen_rarity['rarity_modifier']), + 'intelligence': math.floor((item_gen_equipment['intelligence'] + (0 if item_gen_enchantment is None else item_gen_enchantment['intelligence']) + + (0 if item_gen_element is None else item_gen_element['intelligence'])) * item_gen_rarity['rarity_modifier']), + 'dodge': math.floor((item_gen_equipment['dodge'] + (0 if item_gen_enchantment is None else item_gen_enchantment['dodge']) + + (0 if item_gen_element is None else item_gen_element['dodge'])) * item_gen_rarity['rarity_modifier']), + 'crit': math.floor((item_gen_equipment['crit'] + (0 if item_gen_enchantment is None else item_gen_enchantment['crit']) + + (0 if item_gen_element is None else item_gen_element['crit'])) * item_gen_rarity['rarity_modifier']), + 'armour': math.floor((item_gen_equipment['armour'] + (0 if item_gen_enchantment is None else item_gen_enchantment['armour']) + + (0 if item_gen_element is None else item_gen_element['armour'])) * item_gen_rarity['rarity_modifier']), + 'accuracy': math.floor((item_gen_equipment['accuracy'] + (0 if item_gen_enchantment is None else item_gen_enchantment['accuracy']) + + (0 if item_gen_element is None else item_gen_element['accuracy'])) * item_gen_rarity['rarity_modifier']), + 'resistance': math.floor((item_gen_equipment['resistance'] + (0 if item_gen_enchantment is None else item_gen_enchantment['resistance']) + + (0 if item_gen_element is None else item_gen_element['resistance'])) * item_gen_rarity['rarity_modifier']), + 'luck': math.floor((item_gen_equipment['luck'] + (0 if item_gen_enchantment is None else item_gen_enchantment['luck']) + + (0 if item_gen_element is None else item_gen_element['luck'])) * item_gen_rarity['rarity_modifier']), + 'block': math.floor((item_gen_equipment['block'] + (0 if item_gen_enchantment is None else item_gen_enchantment['block']) + + (0 if item_gen_element is None else item_gen_element['block'])) * item_gen_rarity['rarity_modifier']), + 'permanent': item_gen_equipment['permanent'], + 'cost': math.floor(item_gen_equipment['item_cost'] + (0 if item_gen_element is None else item_gen_element['element_cost']) + + (0 if item_gen_enchantment is None else item_gen_enchantment['enchant_cost']) + + (0 if item_gen_rarity is None else item_gen_rarity['rarity_cost']))} + + return item_gen + + +async def create_equipment_name(item_code): + # If item_code is specified, find the base item and return. + if int(item_code) != 0: + base_item = await utils.sql_postgres("SELECT AdventurersInc.get_item_equipment(%s)", (item_code,), True) + + # If item_code is 0, roll the standard random generation + else: + base_item = await utils.sql_postgres("SELECT AdventurersInc.get_item_equipment(%s)", ('%',), True) + + return base_item[0][0] + + +async def create_equipment_element(item_code, rarity_id): + # Get a random element from the given item_code + if int(item_code) != 0: + element = await utils.sql_postgres("SELECT AdventurersInc.get_item_elements(%s)", (item_code,), True) + return element[0][0] + + # Roll for a random enchant for any item Rare or greater + else: + if rarity_id >= 4 and random.randint(1, 3) == 1: + element = await utils.sql_postgres("SELECT AdventurersInc.get_item_elements(%s)", ('%',), True) + return element[0][0] + + +async def create_equipment_rarity(item_code): + # If item_code is specified, find the rarity and return. + if int(item_code) != 0: + # item_code = 1 if item_code <= 0 or item_code >= 7 else item_code + rarity = await utils.sql_postgres("SELECT AdventurersInc.get_item_rarities(%s)", (item_code,), True) + return rarity[0][0] + + # If item_code is 0, roll the standard random generation + elif int(item_code) == 0: + # Get all rarities + base_rarities = await utils.sql_postgres("SELECT AdventurersInc.get_item_rarities(%s)", ('%',), True) + + # Get the dice roll for this random generation cycle + rarity_dice_roll = random.randint(1, base_rarities[0][0]["total_weight"]) + + # Determine the rarity + for rarity in base_rarities: + rarity_dice_roll = rarity_dice_roll - rarity[0]["rarity_weight"] + if rarity_dice_roll <= 0: + return rarity[0] + + +async def create_equipment_enchantment(item_code, rarity_id): + # Get a random enchant from the given item_code + if int(item_code) != 0: + enchant = await utils.sql_postgres("SELECT adventurersinc.get_item_enchantment(%s)", (item_code,), True) + return enchant[0][0] + + # Roll for a random enchant for any item Uncommon or greater + else: + if rarity_id >= 3 and random.randint(1, 3) == 1: + enchant = await utils.sql_postgres("SELECT adventurersinc.get_item_enchantment(%s)", ('%',), True) + return enchant[0][0] + + +async def create_equipment_artifact(params, item_code, item_gen_equipment): + # Gen for Artifact item: + player_fabled = await utils.sql_postgres("SELECT adventurersinc.get_player_artifact_count(%s);", (params['nick'],), True) + + # 0 - Will attempt to add an artifact randomly and not exceed the standard limit + if player_fabled[0][0]['perm_can_drop']: + if random.randint(1, 100) == 1 and int(item_code) == 0: + item_gen_equipment['permanent'] = 1 + + # 1 - Will not generate item as an artifact + elif int(item_code) == 1: + item_gen_equipment['permanent'] = 0 + + else: + item_gen_equipment['permanent'] = 0 + + # 2 - Will force the item to become an artifact and exceed the limit of 2 artifacts + elif int(item_code) == 2: + item_gen_equipment['permanent'] = 1 + + return item_gen_equipment + + +# def create_item(enemy_stats, player_stats, params): +# # Get random element +# c.execute("SELECT loot_name,ItemType,Potency FROM GenLoot WHERE Locked=0 ORDER BY RAND() LIMIT 1") +# sql_rarity = c.fetchone() +# str_loot_name = sql_rarity['loot_name'] +# str_item_type = sql_rarity['ItemType'] +# int_potency = sql_rarity['Potency'] +# +# if str_item_type == 'Quantity': +# int_potency = enemy_stats['GoldCarried'] + int(random.uniform(float(enemy_stats['GoldCarried']) * -0.3, float(enemy_stats['GoldCarried']) * 0.3)) +# +# return str_loot_name, int_potency + + +async def add_to_shop(params, item): + sql = 'CALL adventurersinc.add_to_player_shop(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)' + params = (params['nick'], item['cost'], item['equipment_colour'], item['equipment_name'], item['equipment_slot'], + item['equipment_type'], bool(item['permanent']), item['hands_req'], item['strength'], item['dexterity'], + item['constitution'], item['intelligence'], item['dodge'], item['crit'], item['armour'], + item['accuracy'], item['resistance'], item['luck'], item['block'],) + await utils.sql_postgres(sql, params, False) + return + + +async def add_to_inventory(params, item): + sql = 'CALL adventurersinc.add_to_player_inventory(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)' + params = (item['equipment_colour'], item['equipment_name'], item['equipment_slot'], item['equipment_type'], bool(item['permanent']), item['hands_req'], + item['strength'], item['dexterity'], item['constitution'], item['intelligence'], item['dodge'], item['crit'], + item['armour'], item['accuracy'], item['resistance'], item['luck'], item['block'], params['nick']) + await utils.sql_postgres(sql, params, False) + return + + +def merge_item_codes(item_code1, item_code2): + str_output = "" + item_code1 = item_code1.split(':') + item_code2 = item_code2.split(':') + + for i in range(len(item_code1)): + if str(item_code1[i]) == "0" or str(item_code2[i]) == "0": + str_output = str_output + str(int(item_code1[i]) + int(item_code2[i])) + else: + str_output = str_output + random.choice([item_code1[i], item_code2[i]]) + + return str_output + + +# def unlock_items(params, unlocked_set): +# c_select.execute("SELECT equipment_name, equipment_slot, equipment_type, hands_req, Locked, strength, dexterity, constitution, intelligence, dodge, crit, armour, Requirement FROM base_items WHERE Requirement=%s", (unlocked_set,)) +# while sql_item is not None: +# c_insert.execute("INSERT INTO Items_PlayerPool(equipment_name,Nick) VALUES (%s,%s)",(sql_item['equipment_name'], params['Nick'],));db.commit(); +# return "Updated." + + +async def item_test(): + params = {'nick': 182588470135488512} + item_code = '0:0:0:0:0' + max_loops = 100 + totals = {'Ruined': 0, 'Normal': 0, 'Uncommon': 0, 'Rare': 0, 'Epic': 0, 'Legendary': 0 } + for loop in range(1, max_loops): + item = await generate_equipment(params, item_code) + if item['permanent'] == 1: + if item['equipment_colour'] == 'āš«': + rarity = 'Ruined' + elif item['equipment_colour'] == 'āšŖ': + rarity = 'Normal' + elif item['equipment_colour'] == 'šŸŸ¢': + rarity = 'Uncommon' + elif item['equipment_colour'] == 'šŸ”µ': + rarity = 'Rare' + elif item['equipment_colour'] == 'šŸŸ£': + rarity = 'Epic' + elif item['equipment_colour'] == 'šŸŸ ': + rarity = 'Legendary' + + totals[rarity] = totals[rarity] + 1 + return totals diff --git a/cogs/adv_inc/LevelUp.py b/cogs/adv_inc/LevelUp.py new file mode 100644 index 0000000..b6b73b6 --- /dev/null +++ b/cogs/adv_inc/LevelUp.py @@ -0,0 +1,41 @@ +import pymysql +import sys +import os +import importlib +import utils + +from cogs.adv_inc import PlayerStats + +importlib.reload(PlayerStats) + + +async def level_up_attributes(params): + # In the event no valid value is given, assume the points to assign will be 1 + try: + params['cmd2'] = int(params['cmd2']) + except ValueError: + params['cmd2'] = 1 + + # Get players attribute points + player_attribute_points = await utils.sql_postgres("SELECT adventurersinc.get_player_attribute_points(%s);", (params["nick"],), True) + + # Prevent over-allocation + if int(params['cmd2']) > player_attribute_points[0][0]['attribute_points']: + return "You cannot apply more points than you have." + + # Attribute allocation + else: + if params['cmd1'].lower() == 's': + await utils.sql_postgres("CALL adventurersinc.set_player_attribute_strength(%s, %s)", (params['cmd2'], params["nick"],), False) + elif params['cmd1'].lower() == 'd': + await utils.sql_postgres("CALL adventurersinc.set_player_attribute_dexterity(%s, %s)", (params['cmd2'], params["nick"],), False) + elif params['cmd1'].lower() == 'c': + await utils.sql_postgres("CALL adventurersinc.set_player_attribute_constitution(%s, %s)", (params['cmd2'], params["nick"],), False) + elif params['cmd1'].lower() == 'i': + await utils.sql_postgres("CALL adventurersinc.set_player_attribute_intelligence(%s, %s)", (params['cmd2'], params["nick"],), False) + + player_stats = await PlayerStats.refresh_stats(params) + + # await utils.sql_postgres("CALL adventurersinc.set_player_attribute_intelligence(%s, %s)", (int_attribute_points, params["nick"],), False) + # c.execute("UPDATE Players SET HP = %s WHERE Nick='%s';", (player_stats['MaxHP'], params["Nick"]));db.commit(); + return f"Attribute Points: {player_stats['attribute_points']} (S)tr:{player_stats['strength']} (D)ex:{player_stats['dexterity']} (C)on:{player_stats['constitution']} (I)nt:{player_stats['intelligence']}" diff --git a/cogs/adv_inc/PlayerCreate.py b/cogs/adv_inc/PlayerCreate.py new file mode 100644 index 0000000..17feae5 --- /dev/null +++ b/cogs/adv_inc/PlayerCreate.py @@ -0,0 +1,65 @@ +# Embedded file name: /home/bouncer/sassbot/modules/advinc/PlayerCreate.py +import pymysql +import importlib +import utils + +from cogs.adv_inc import PlayerStats +from cogs.adv_inc import Items + +importlib.reload(utils) +importlib.reload(PlayerStats) +importlib.reload(Items) + + +async def pick_character_clan(params): + if params['cmd1'] == '': + return 'Name your Clan.' + + elif len(params['cmd1']) < 3: + return 'Your Clan Name must be at least three characters.' + + else: + await utils.sql_postgres('CALL adventurersinc.set_player_character_new(%s,%s)', (params['nick'], params['msg'].strip(),), False) + return f"The adventure for the {params['msg'].strip()} clan begins." + + +async def pick_character_name(params, player_stats): + if params['cmd1'] == '': + return 'Give yourself a name.' + + elif len(params['cmd1']) < 3: + return 'Your name must be at least three characters.' + + else: + await utils.sql_postgres('CALL adventurersinc.set_player_character_name(%s, %s)', (params['cmd1'].strip(), params['nick'],), False) + return f"You are {params['cmd1'].strip()} {player_stats['clan_name']}. Pick a race: (H)uman, (O)rc, (E)lf, (D)warf, (L)izard" + + +async def pick_character_race(params, player_stats): + # Get chosen race + str_race_selected = None + if params['cmd1'].lower() == 'h': + str_race_selected = 'Human' + elif params['cmd1'].lower() == 'o': + str_race_selected = 'Orc' + elif params['cmd1'].lower() == 'e': + str_race_selected = 'Elf' + elif params['cmd1'].lower() == 'd': + str_race_selected = 'Dwarf' + elif params['cmd1'].lower() == 'l': + str_race_selected = 'Lizard' + else: + return 'Pick a race: (H)uman, (O)rc, (E)lf, (D)warf, (L)izard' + + if str_race_selected is not None: + race_stats = await utils.sql_postgres('SELECT adventurersinc.get_race_stats(%s)', (str_race_selected,), True) + await utils.sql_postgres('CALL adventurersinc.set_player_character_race(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)', (race_stats[0][0]['strength'], + race_stats[0][0]['dexterity'], race_stats[0][0]['constitution'], race_stats[0][0]['intelligence'], race_stats[0][0]['dodge'], race_stats[0][0]['crit'], race_stats[0][0]['armour'], + race_stats[0][0]['accuracy'], race_stats[0][0]['resistance'], race_stats[0][0]['luck'], race_stats[0][0]['block'], params['nick'], str_race_selected), False) + + player_stats = await PlayerStats.refresh_stats(params) + await utils.sql_postgres("CALL adventurersinc.set_player_health(%s,%s)", (player_stats['max_hp'], params['nick'],), False) + + return f"{player_stats['character_name']} {player_stats['clan_name']} the {str_race_selected} begins their adventure" + else: + return diff --git a/cogs/adv_inc/PlayerDeath.py b/cogs/adv_inc/PlayerDeath.py new file mode 100644 index 0000000..29fc34f --- /dev/null +++ b/cogs/adv_inc/PlayerDeath.py @@ -0,0 +1,41 @@ +import time +import pymysql +import importlib +import utils + +from cogs.adv_inc import Calculate + +importlib.reload(utils) +importlib.reload(Calculate) + + +async def character_death(player_stats, params): + # Create death entry + sql = 'CALL adventurersinc.add_player_graveyard_death(%s, %s, %s, %s, %s, %s);' + query_params = (params['nick'], player_stats['character_name'], player_stats['clan_name'], player_stats["total_items"], player_stats['challenge_rating'], str(params['game_version']),) + # print(f"1 {sql % query_params}") + await utils.sql_postgres(sql, query_params, False) + + # Delete players Inventory + sql = 'CALL adventurersinc.del_player_inventory(%s);' + query_params = (params['nick'],) + # print(f"2 {sql % query_params}") + await utils.sql_postgres(sql, query_params, False) + + # Delete players opponent + sql = 'CALL adventurersinc.del_player_enemies(%s);' + query_params = (params['nick'],) + # print(f"3 {sql % query_params}") + await utils.sql_postgres(sql, query_params, False) + + # Delete players shop + sql = 'CALL adventurersinc.del_player_shop(%s);' + query_params = (params['nick'],) + # print(f"4 {sql % query_params}") + await utils.sql_postgres(sql, query_params, False) + + # Update player record for new character + lose gold on death + sql = 'CALL adventurersinc.set_player_death(%s);' + query_params = (params['nick'],) + # print(f"5 {sql % query_params}") + await utils.sql_postgres(sql, query_params, False) diff --git a/cogs/adv_inc/PlayerStats.py b/cogs/adv_inc/PlayerStats.py new file mode 100644 index 0000000..2416ff3 --- /dev/null +++ b/cogs/adv_inc/PlayerStats.py @@ -0,0 +1,79 @@ +import sys +import math +import os +import importlib +import utils + +from cogs.adv_inc import Calculate + +importlib.reload(utils) +importlib.reload(Calculate) + + +async def print_stats(params): + player_stats = await refresh_stats(params) + + dodge_perc = await Calculate.get_dodge_chance(player_stats['dexterity'], player_stats['dodge']) + luck_chance = await Calculate.get_luck_chance(player_stats['luck']) + armour_perc = await Calculate.get_armour_percentage(player_stats['armour'], player_stats['strength'], player_stats['constitution']) + crit_perc = await Calculate.get_crit_percentage(player_stats['dexterity'], player_stats['crit']) + block_perc = await Calculate.get_block_chance(player_stats['strength'], player_stats['block']) + + emb = await utils.embed(params["ctx"], f"Stats of {player_stats['character_name']} {player_stats['clan_name']}", "") + emb = await utils.field(emb, "Race", f"{player_stats['race']}", True) + emb = await utils.field(emb, "HP", f"{player_stats['hp']}/{player_stats['max_hp']}", True) + emb = await utils.field(emb, "STR", f"{player_stats['strength']}", True) + emb = await utils.field(emb, "Challenge Rating", f"{player_stats['challenge_rating']}", True) + emb = await utils.field(emb, "DEX", f"{player_stats['dexterity']}", True) + emb = await utils.field(emb, "CON", f"{player_stats['constitution']}", True) + emb = await utils.field(emb, "INT", f"{player_stats['intelligence']}", True) + emb = await utils.field(emb, "Gold", f"{player_stats['currency']}", True) + emb = await utils.field(emb, "Dodge", f"{player_stats['dodge']} / ({math.floor(dodge_perc * 100)}%)", True) + emb = await utils.field(emb, "Crit", f"{player_stats['crit']} / ({math.floor(crit_perc * 100)}%)", True) + emb = await utils.field(emb, "Armour", f"{player_stats['armour']} / ({math.floor(armour_perc * 100)}%)", True) + emb = await utils.field(emb, "Accuracy", f"{player_stats['accuracy']}", True) + emb = await utils.field(emb, "Resistance", f"{player_stats['resistance']}", True) + emb = await utils.field(emb, "Luck", f"{player_stats['luck']} / ({luck_chance})", True) + emb = await utils.field(emb, "Block", f"{player_stats['block']} / ({math.floor(block_perc * 100)}%)", True) + emb = await utils.field(emb, "Items", f"{player_stats['total_items']}", True) + + return emb + + +async def refresh_stats(params): + sql_player_info = await utils.sql_postgres("SELECT adventurersinc.get_player_info(%s);", (params['nick'],), True) + sql_player_stats = await utils.sql_postgres("SELECT adventurersinc.get_player_stats(%s);", (params['nick'],), True) + + # print(f"sql_player_info: {sql_player_info}") + # print(f"sql_player_info[0][0]: {sql_player_info[0][0]}") + + if sql_player_info[0][0] is None: + return None + else: + player_stats = {'nick': sql_player_info[0][0]['nick'], + 'currency': sql_player_info[0][0]['currency'], + 'clan_name': sql_player_info[0][0]['clan_name'], + 'character_name': sql_player_info[0][0]['character_name'], + 'player_state': sql_player_info[0][0]['player_state'], + 'alive': sql_player_info[0][0]['alive'], + 'challenge_rating': sql_player_info[0][0]['challenge_rating'], + 'rested_heal': sql_player_info[0][0]['rested_heal'], + 'hp': sql_player_info[0][0]['hp'], + 'max_hp': int(sql_player_stats[0][0]['constitution'] * 2), + 'attribute_points': sql_player_info[0][0]['attribute_points'], + 'hands_req': sql_player_stats[0][0]['hands_req'], + 'unit_type': 'player', + 'strength': sql_player_stats[0][0]['strength'], + 'dexterity': sql_player_stats[0][0]['dexterity'], + 'constitution': sql_player_stats[0][0]['constitution'], + 'intelligence': sql_player_stats[0][0]['intelligence'], + 'dodge': sql_player_stats[0][0]['intelligence'], + 'crit': sql_player_stats[0][0]['crit'], + 'armour': sql_player_stats[0][0]['armour'], + 'accuracy': sql_player_stats[0][0]['accuracy'], + 'resistance': sql_player_stats[0][0]['resistance'], + 'luck': sql_player_stats[0][0]['luck'], + 'block': sql_player_stats[0][0]['block'], + 'total_items': sql_player_info[0][0]['total_items'], + 'race': sql_player_info[0][0]['race']} + return player_stats diff --git a/cogs/adv_inc/Resting.py b/cogs/adv_inc/Resting.py new file mode 100644 index 0000000..b425abb --- /dev/null +++ b/cogs/adv_inc/Resting.py @@ -0,0 +1,204 @@ +#Python modules +import math +import re +import sys +import os +import importlib +import utils + +from cogs.adv_inc import PlayerStats +from cogs.adv_inc import Enemy +from cogs.adv_inc import Items + +importlib.reload(utils) +importlib.reload(PlayerStats) +importlib.reload(Enemy) +importlib.reload(Items) + + +async def player_resting(params, player_stats): + # Inventory + if params["cmd1"].lower() == 'i' or params["cmd1"].lower() == 'inventory': + try: + params["cmd2"] = int(params["cmd2"]) + except ValueError: + params["cmd2"] = 1 + + obj_player_inventory = await utils.sql_postgres("SELECT adventurersinc.get_player_inventory(%s, %s);", (params["nick"], (int(params["cmd2"]) * 5) - 5,), True) + # print(f"obj_player_inventory {obj_player_inventory}") + if not obj_player_inventory: + return "You have no items." + int_total_pages = int(math.ceil(obj_player_inventory[0][0]["total_items"] / 5)) + + str_output = "" + # print("#total pages", int_total_pages) + if 0 < params["cmd2"] <= int_total_pages: + str_output = f'Page {params["cmd2"]} of {int_total_pages}. (http://adventurersinc.lelong.uk/inventory/{params["nick"]})\n' + # print(str_output) + + for item in obj_player_inventory: + str_equipped = 'Equipped ' if item[0]["equipped"] == 1 else 'Unequipped' + str_hands = "--" if str(item[0]["hands_req"]) == '0' else str(item[0]["hands_req"]) + "H" + + str_output = f"{str_output}{item[0]['item_id']} {str_equipped} {str_hands} {item[0]['equipment_colour']} {item[0]['equipment_name']}\n" + return str_output + + # Equip WIP + elif params["cmd1"].lower() == 'e' or params["cmd1"].lower() == 'equip': + # Check to un-equip + if params["cmd2"] == 'u' or params["cmd2"] == 'unequip': + await utils.sql_postgres("CALL adventurersinc.set_player_unequip_all(%s)", (params["nick"],), False) + return "All items have been unequipped." + + elif params["cmd2"].isdigit(): + # Check to see if an ID was supplied + sql_item = await utils.sql_postgres("SELECT adventurersinc.get_player_inventory_item(%s,%s);", (params["nick"], params["cmd2"],), True) + if sql_item[0][0] is not None: + # If selected item is weapon + if sql_item[0][0]['equipment_type'] == 'weapon': + sql_hands_used = await utils.sql_postgres("SELECT adventurersinc.get_player_equip_hands_used(%s)", (params["nick"],), True) + if sql_hands_used[0][0] is None: + sql_hands_used[0][0]["hands_req"] = 0 + + if sql_hands_used[0][0]["hands_req"] + sql_item[0][0]['hands_req'] <= 2 and sql_item[0][0]['equipped'] == 0: + await utils.sql_postgres("CALL adventurersinc.set_player_equipped_item(%s, %s, %s);", (params["cmd2"], True, params["nick"],), False) + return f"Equipping your {sql_item[0][0]['equipment_colour']}{sql_item[0][0]['equipment_name']}." + + elif sql_item[0][0]['equipped'] == 1: + await utils.sql_postgres("CALL adventurersinc.set_player_equipped_item(%s, %s, %s);", (params["cmd2"], False, params["nick"],), False) + return f"Unequipping your {sql_item[0][0]['equipment_colour']}{sql_item[0][0]['equipment_name']}." + + else: + return "You can only wield one two-handed weapon, or two one-handed weapons." + + # If selected item is Armor + elif sql_item[0][0]['equipment_type'] == 'armour': + sql_armour = await utils.sql_postgres("SELECT adventurersinc.get_player_equip_armour_slot(%s, %s)", (params["nick"], sql_item[0][0]['equipment_slot'],), True) + + # print(sql_armour) + if sql_item[0][0]['equipped'] is False and sql_armour[0][0] is None: + await utils.sql_postgres("CALL adventurersinc.set_player_equipped_item(%s, %s, %s);", (params["cmd2"], True, params["nick"],), False) + return f"Equipping your {sql_item[0][0]['equipment_colour']}{sql_item[0][0]['equipment_name']}." + + elif sql_item[0][0]['equipped'] is True: + await utils.sql_postgres("CALL adventurersinc.set_player_equipped_item(%s, %s, %s);", (params["cmd2"], False, params["nick"],), False) + return f"Unequipping your {sql_item[0][0]['equipment_colour']}{sql_item[0][0]['equipment_name']}." + + else: + return "You already have an item in this slot." + else: + return "This item does not exist." + + # All other checks failed, print help message + else: + return "Available commands: e (u)nequip all, e " + + # Destroy WIP + elif params["cmd1"].lower() == 'd' or params["cmd1"].lower() == 'destroy': + if re.match("^[0-9]+$", params["cmd2"]): + c.execute("SELECT ID,nick,EquipmentColour,EquipmentSlot,equipment_type,EquipmentName,equipped,hands_req FROM Items_PlayerInventory WHERE nick='%s' AND ID=%s",(params["nick"], params["cmd2"],)) + sql_item = c.fetchone() + item_name = sql_item['EquipmentName'] + item_colour = sql_item['EquipmentColour'] + if sql_item is not None: + c.execute("DELETE FROM Items_PlayerInventory WHERE nick='%s' AND ID=%s",(params["nick"], params["cmd2"]));db.commit(); + return f"Your {item_name} has been destroyed." + + # Battle + elif params["cmd1"].lower() == 'b' or params["cmd1"].lower() == 'battle': + enemy = {} + if player_stats['challenge_rating'] == int(math.ceil(player_stats['challenge_rating'] / 4) * 4): + enemy = await Enemy.create_enemy(enemy, player_stats, params) + return f"Your fighting has caught the attention of the {enemy['enemy_name']}." + else: + enemy = await Enemy.create_enemy(enemy, player_stats, params) + return f"You've been attacked by {enemy['enemy_name']}." + + # Character + elif params["cmd1"].lower() == 'c' or params["cmd1"].lower() == 'character': + return await PlayerStats.print_stats(params) + + # Shop + elif params["cmd1"].lower() == 's' or params["cmd1"].lower() == 'shop': + if params["cmd2"] is '': + sql_shop_inventory = await utils.sql_postgres("SELECT adventurersinc.get_player_shop_all(%s, %s);", (params["nick"], '%'), True) + str_output = f"You have {player_stats['currency']} gold.\n" + for sql_itm in sql_shop_inventory: + str_output = f"{str_output}" + \ + f"{sql_itm[0]['shop_id']} " + \ + f"{sql_itm[0]['equipment_colour']} " + \ + f"{sql_itm[0]['equipment_name']} " + \ + f"{sql_itm[0]['shop_cost']} gold\n" + return str_output + else: + sql_shop_items = await utils.sql_postgres("SELECT adventurersinc.get_player_shop_all(%s, %s);", (params["nick"], params["cmd2"],), True) + # Check is sql_shop_items returns None + if not sql_shop_items: + return "The shopkeep doesn't know what item you ask for." + else: + chosen_item = None + for item in sql_shop_items: + if int(item[0]['shop_id']) == int(params['cmd2']): + chosen_item = item[0] + + # Check if chosen item cost can be purchased + if player_stats['currency'] < chosen_item['shop_cost']: + return "You cannot afford this item." + + # Proceed with purchase + await Items.add_to_inventory(params, chosen_item) + await utils.sql_postgres("CALL adventurersinc.del_player_shop_item(%s, %s);", (str(params["nick"]), params["cmd2"],), False) + await utils.sql_postgres("CALL adventurersinc.set_player_gold(%s, %s);", (chosen_item['shop_cost'], params["nick"],), False) + return f"The {chosen_item['equipment_colour']}{chosen_item['equipment_name']} has been added to your inventory." + + # Heal + elif params["cmd1"].lower() == 'r' or params["cmd1"].lower() == 'rest': + player_stats = await PlayerStats.refresh_stats(params) + if player_stats['rested_heal'] == 0: + if player_stats['hp'] >= player_stats['max_hp']: + await utils.sql_postgres("CALL adventurersinc.set_player_health(%s, %s)", (player_stats['hp'], params["nick"],), False) + return "You rest. You are already at max HP." + + # If heal is an over-heal, heal to max instead + elif round(player_stats['max_hp']/2 + player_stats['hp']) > player_stats['max_hp']: + int_hp_gained = player_stats['max_hp'] + await utils.sql_postgres("CALL adventurersinc.set_player_health(%s, %s)", (int_hp_gained, params["nick"],), False) + return "You rest and your wounds heal completely." + + # Otherwise heal 50% + elif player_stats['hp'] < player_stats['max_hp']: + int_hp_gained = round(player_stats['max_hp']/2 + player_stats['hp']) + await utils.sql_postgres("CALL adventurersinc.set_player_health(%s, %s)", (int_hp_gained, params["nick"],), False) + return f"You rest and you recover {round(player_stats['max_hp']/2)}HP." + + else: + return "You rest." + + # DEBUG - CREATE WEAPON + elif params["cmd1"].lower() == '_viewitem': + return await Items.generate_equipment(params, params["cmd2"]) + + # DEBUG - TEST ITEM GEN WEAPON + elif params["cmd1"].lower() == '_fabled': + return await Items.item_test() + + # DEBUG - Resolve an itemcode + elif params["cmd1"].lower() == '_mergeitemcodes': + item_codes = params["cmd2"].split('_') + return Items.MergeItemCodes(item_codes[0], item_codes[1]) + + # Version + elif params["cmd1"].lower() == 'v' or params["cmd1"].lower() == 'version': + return "Version 1.3 - Notes can be found at: http://www.lexicade.uk/dev.php?view=patchnotes" + + # Admin commands + elif params["cmd1"].lower() == 'genitem' and params["nick"] == 182588470135488512: + await Items.add_to_inventory(params, await Items.generate_equipment(params, '0:0:0:0:1')) + + # Death + elif params["cmd1"].lower() == 'suicide': + CharacterDeath(player_stats, params) + return "You committed suicide." + + else: + return "Available commands: (i)nventory, (e)quip, (b)attle, (c)haracter, (s)hop, (r)est, (v)ersion, (d)estroy." diff --git a/cogs/adv_inc/__init__.py b/cogs/adv_inc/__init__.py new file mode 100644 index 0000000..e69de29 -- cgit v1.2.3