def select_target(self): """ Generates a Menu that asks user to select hero or enemy attribute and returns choice. """ print_centre("Select target:\n") target_menu = Menu.from_list([self.hero, self.enemy]) target = target_menu.handle_options() return target
def _check_space(self): """ Mark the Inventory as full or not full.""" if len(self) + 1 <= self.limit: self.full = False else: self.full = True print_centre("Inventory limit reached.") common.sleep()
def attack(self, target): """ Basic physical attack. Args: target (Character): object to deduct hp from. """ print_centre("\n{} attacks {}!".format(self.name, target.name)) target.alter_stat("hp", self.st, "-")
def transfer_gold_exp(self): """ Transfer gold and exp from enemy to hero if enemy is dead.""" if self.enemy.dead: msg = "{} recieved {} exp and {} gold!" msg = msg.format(self.hero.name, self.enemy.exp, self.enemy.gold) print_centre(msg) self.hero.exp += self.enemy.exp self.hero.gold += self.enemy.gold common.sleep()
def sell(self, item): """ Removes the item from the heros inventory and adds the sell price of the item to the players sell attr. Args: item (Item): item to remove. """ self.hero.inventory.remove_item(item.name) self.hero.gold += item.sell print_centre("Thank you for selling your {} to me!".format(item.name)) common.sleep()
def _reduce_mp(self): """ Lower _character mp by a given value.""" if self._character.mp >= self.mp_cost: self._character.mp -= self.mp_cost print_centre("{} uses {}!".format(self._character.name, self.att_name)) return True elif self._character.mp < self.mp_cost: print_centre("You don't have enough mp to use {}.\n".format( self.att_name)) return False
def handle_options(self): """ Extract and execute a method from self.options.""" try: print_centre(self.choices) choice = input(">> ") item = self.options[choice] return item except KeyError: msg = "{} is not a valid choice. Try again.\n" print_centre(msg.format(choice)) sleep() return self.handle_options()
def _determine_new_magic(self, before_mglv): """ Communicate new spell learned after leveling up. Args: before_mglv (HeroMagic): magic class before level up. """ if type(before_mglv) != type(self.magic): new_spells = set(dir(self.magic)) - set(dir(before_mglv)) if len(new_spells) > 1: raise ValueError("More than one new spell: {}".format(new_spells)) new_spell = list(new_spells)[0].replace("_", " ").title() print_centre("\nLearned {}!\n".format(new_spell)) time.sleep(3)
def _communicate_stat_change(self, stat, operator, value): """ Print character stat changes. Args: stat (str): hp, mp, st or ag. operator (str): '+' or '-'. value (int): number to alter the stat by. """ upordown = "increases" if operator == "+" else "decreases" msg = "{} {} {} by {}\n".format(self.name, stat.upper(), upordown, value) print_centre(msg) sleep()
def _determine_level(self): """ Determine level based upon exp value.""" before_mglv = self.magic next_level_exp = self.leveling.get(self.lv + 1) for leveled, experience in self.leveling.items(): if self._exp >= next_level_exp: if experience > self._exp: self.lv = leveled - 1 msg = "{} has reached level {}!".format(self.name, self.lv) self._determine_stats() print_centre(msg) time.sleep(3) self._determine_new_magic(before_mglv) break
def purchase(self, item): """ Transfers the item to the hero inventory and deducts the cost from the players gold attr. Args: item (Item): item to transfer. """ deduction = self.hero.gold - item.cost if deduction >= 0: self.hero.inventory.add_items(item) if self.hero.inventory.full is False: self.hero.gold = deduction print_centre("Enjoy your {}!".format(item.name)) common.sleep() else: print_centre("You don't have enough gold to purchase that!") common.sleep()
def _adjust_value_around_max(self, stat, value): """ Adjusts the parsed value such that it cannot increase the stat value above its maximum limit. Args: stat (str): hp, mp, st or ag. value (int): number to increase the stat by. """ max_stat = getattr(self, "_max_{}".format(stat)) current_stat = getattr(self, stat) if current_stat == max_stat: msg = "{} is already at the maximum value\n" print_centre(msg.format(stat.upper())) sleep() return 0 elif value + current_stat > max_stat: return max_stat - current_stat else: return value
def construct_store_screen(self): """ Clears screen and input, prints store owner & available gold.""" common.clear() print_centre(animations.get("Shopkeep")) print_centre("{}:\t{} gold".format(self.hero.name, self.hero.gold)) print_centre("Welcome to my store! How may I serve you today?\n") common.flush_input()
def flee(self): """ Attempt to run from battle.""" print_centre("{} attempts to flee!".format(self.hero.name)) common.sleep() # 20% chance of fleeing weighted_success = {True: 2, False: 8} flee_success = common.weighted_choice(weighted_success) if flee_success: print_centre("{} successfully ran away!\n".format(self.hero.name)) common.sleep() return True else: print_centre("{} couldn't get away!\n".format(self.hero.name)) common.sleep() return False
def _use_msg(self): print_centre("You shrieked into a {}!!!\n".format(self.name)) sleep()
def gold(self, amount): if amount < 0: print_centre("You do not have enough gold.") sleep() else: self._gold = amount
def _death(self): """ Communicate death to user and changes dead attribute.""" print_centre("{} is dead!".format(self.name)) self.dead = True sys.exit()
def construct_battle_screen(self): """ Clears screen and input, prints characters stats and animations.""" common.clear() print_centre(self.enemy.animation) print_centre("\n{}\n{}\n".format(self.hero, self.enemy)) common.flush_input()
def _use_msg(self): print_centre("You threw a {}!\n".format(self.name)) sleep()
def _use_msg(self): print_centre("Lets BRO DOWN with a {}!\n".format(self.name)) sleep()
def _use_msg(self): print_centre("{} has been used!\n".format(self.name.title())) sleep()
def _use_msg(self): print_centre("You uncorked a bottle of {}.\n".format(self.name)) sleep()
def death(self): """ Communicate death to user and change state.""" print_centre("{} is dead!\n".format(self.name)) self.dead = True
def _use_msg(self): print_centre("You slammed a {}!\n".format(self.name[:-1])) sleep()