def test_stat_sub(self): stat1 = Stats({'Tech': 3, 'Contract': 4}) stat2 = Stats({'Tech': 1, 'Artifact': 6}) stat_sub = stat1 - stat2 self.assertEqual(stat_sub.get_value('Tech'), 2) self.assertEqual(stat_sub.get_value('Contract'), 4) self.assertEqual(stat_sub.get_value('Artifact'), -6)
def __init__(self, name, reward_type, stats=None, materials=0, rewards=None, obtainable=True, essential=False): self.name = name self.reward_type = reward_type self.stat_requirement = Stats(stats) or Stats(empty_stats) self.material_requirement = materials self.reward_requirement = rewards or [] self.obtainable = obtainable self.essential = essential
def __init__(self, members, stats=None, enabled=True): self.members = members if stats is None: self.stat_bonus = Stats() else: self.stat_bonus = Stats(stats) self.enabled = enabled self.status = "unset" self.progress = 0
def test_objects_dont_affect_each_other(self): blank1 = Stats() blank2 = Stats() self.assertEqual(blank1.sum_stat(), 0) self.assertEqual(blank2.sum_stat(), 0) blank2.increase_stat('Tech', 2) self.assertEqual(blank1.sum_stat(), 0) self.assertEqual(blank2.sum_stat(), 2)
def __init__(self, name, stats=None): self.name = name self.stats = Stats(stats) or Stats() self.status = "available" self.route_progress = 0 self.route_complete = False self.romance_status = "single" self.romance_partner = "none" self.days_off = 0
def test_stat_equals(self): stat1 = Stats() stat2 = Stats() self.assertEqual(stat1 == stat2, True) stat3 = Stats({'Tech': 3}) stat4 = Stats({'Contract': 4}) self.assertEqual(stat1 == stat3, False) self.assertEqual(stat4 == stat3, False) stat5 = Stats({'Tech': 3, 'Contract': 4}) self.assertEqual(stat4 + stat3 == stat5, True)
def test_spend_stats(self): inventory = Inventory() self.assertEqual(inventory.accumulated_stats['RD'].sum_stat(), 0) self.assertEqual(inventory.accumulated_stats['Exploration'].sum_stat(), 0) inventory.accumulate_stats(Stats({'Tech': 3, 'Contract': 2}), 'RD') self.assertEqual(inventory.accumulated_stats['RD'].sum_stat(), 5) self.assertEqual(inventory.accumulated_stats['Exploration'].sum_stat(), 0) inventory.spend_stats(Stats({'Tech': 1}), 'RD') self.assertEqual(inventory.accumulated_stats['RD'].sum_stat(), 4) self.assertEqual(inventory.accumulated_stats['Exploration'].sum_stat(), 0)
def __init__(self, properties: SimulationProperties): self.__stats = Stats(properties.num_sources, properties.num_devices) self.__generators = [ Generator(i, l, self.__stats) for i, l in enumerate(properties.source_lambdas) ] self.__devices = [ Device(i, t, self.__stats) for i, t in enumerate(properties.device_taus) ] self.__buffer = Buffer(properties.buffer_capacity, self.__stats) self.__max_requests = properties.max_requests self.__global_time = 0
def __get_default_stats(self) -> Stats: return Stats(level=1, max_hp=300, strength=100, satiation=300, potion=0, bom=0)
def get_pokemon_by_name(self, name, level=50): """Method that takes a pokemon name and return a complete pokemon object without moves. :param name: The pokemon name :param level: The pokemon level :return: A pokemon object with stats but empty moves """ cursor = self.db_connection.cursor(prepared=True) parametric_query = "SELECT * FROM Pokemon as pkmn WHERE pkmn.name = %s" cursor.execute(parametric_query, (name.replace("'", ""), )) result = cursor.fetchall() stats = Stats(result[0][2], result[0][3], result[0][4], result[0][5], result[0][6], result[0][7], level=level, is_base=True) pkmn_name = result[0][1] weight_kg = result[0][10] if not result[0][9]: type_list = [PokemonType[result[0][8]]] else: type_list = [PokemonType[result[0][8]], PokemonType[result[0][9]]] return Pokemon(pkmn_name, type_list, "", stats, {}, [], weight_kg, StatusType.Normal, [], None, level)
def possible_rewards(self, stats=None, team=None, material=0): stats = stats or Stats() rewards = self.list_obtained_reward_names() possible_rewards = [] for reward in self.pending_rewards: if reward.meets_requirements(stats=stats, rewards=rewards, team=team, material=material): possible_rewards.append(reward) return possible_rewards
def __get_default_stats(self) -> Stats: floor = self.__game_info.floor min_level = math.ceil(floor / 2) level = random.randint(min_level, floor) max_hp = 60 * \ (self.type + math.ceil(level / 2)) + \ (level - 1) * 10 strength = math.ceil(max_hp / 8) return Stats(level=level, max_hp=max_hp, strength=strength)
def filter_rd_and_exploration(self): my_dict = { 'Tech': 1, 'Contract': 4, 'Artifact': 3, 'Fragment': 2, 'Memento': 3 } stat = Stats(my_dict) self.assertEqual(stat.get_value('Tech'), 1) self.assertEqual(stat.get_value('Memento'), 3) self.assertEqual(stat.filter_rd().get_value('Tech'), 1) self.assertEqual(stat.filter_rd().get_value('Memento'), 0) self.assertEqual(stat.filter_exploration().get_value('Tech'), 0) self.assertEqual(stat.filter_exploration().get_value('Memento'), 3)
def test_stat_addition(self): kota_stats = Stats(KOTA_STATS) luke_stats = Stats(LUKE_STATS) self.assertEqual(kota_stats.get_value('Contract'), KOTA_STATS['Contract']) self.assertEqual(luke_stats.get_value('Contract'), LUKE_STATS['Contract']) stat_sum = kota_stats + luke_stats self.assertEqual(stat_sum.get_value('Contract'), KOTA_STATS['Contract'] + LUKE_STATS['Contract']) self.assertEqual(luke_stats.get_value('Contract'), LUKE_STATS['Contract']) self.assertEqual(kota_stats.get_value('Contract'), KOTA_STATS['Contract'])
def test_stat_doesnt_modify_dictionary(self): my_dict = {'Tech': 3, 'Contract': 2} copy = my_dict.copy() not_blank = Stats(my_dict) self.assertEqual(not_blank.sum_stat(), 5) self.assertEqual(copy['Tech'], my_dict['Tech']) not_blank.increase_stat('Tech', 2) self.assertEqual(not_blank.sum_stat(), 7) self.assertEqual(copy['Tech'], my_dict['Tech'])
class Reward: def __init__(self, name, reward_type, stats=None, materials=0, rewards=None, obtainable=True, essential=False): self.name = name self.reward_type = reward_type self.stat_requirement = Stats(stats) or Stats(empty_stats) self.material_requirement = materials self.reward_requirement = rewards or [] self.obtainable = obtainable self.essential = essential def meets_requirements(self, stats, rewards=None, team=None, material=0): rewards = rewards or [] return self.meets_stat_requirements(stats) and\ self.meets_reward_requirements(rewards) and\ self.meets_type_requirements(team) and\ self.meets_material_requirements(material) and\ self.obtainable def meets_type_requirements(self, team=None): if team is not None: if self.reward_type not in preset_reward_types[team]: return False return True def meets_material_requirements(self, material): return self.material_requirement <= material def meets_stat_requirements(self, stats): return stats.meets(self.stat_requirement) def meets_reward_requirements(self, rewards=None): required_rewards = rewards or [] meets = True for reward in self.reward_requirement: if reward not in required_rewards: meets = False break return meets def total_requirements(self): return self.stat_requirement.sum_stat() + self.material_requirement
def test_get_team_relationship_bonus(self): dict_copy = preset_couple_stats['Luke,Black'] route_max = preset_maximum_relationship_length['Luke,Black'] luke_black = Relationship(['Luke', 'Black'], preset_couple_stats['Luke,Black']['stats']) rel_list = RelationshipList() rel_list.add_relationship(luke_black) self.assertEqual(rel_list.sum_bonus().get_value('Tech'), 0) self.assertEqual(rel_list.sum_bonus().get_value('Tech'), 0) self.assertEqual(rel_list.get_relationships_with_guests('Luke,Black,Kota,Onsen').sum_bonus().get_value('Tech'), 0) self.assertEqual(rel_list.get_relationship_status('Luke,Black'), 'unset') # test again after completing the relationship rel_list.advance_relationship('Luke,Black', amount=route_max, max_progress=route_max) self.assertEqual(rel_list.get_relationship_status('Luke,Black'), 'complete') self.assertEqual(rel_list.relationships[0].get_bonus_stats().get_value('Tech'), 1) self.assertEqual(rel_list.sum_bonus(), Stats(preset_couple_stats['Luke,Black']['stats'])) self.assertEqual(rel_list.get_relationships_with_guests('Luke,Black,Kota,Onsen').sum_bonus().get_value('Tech'), preset_couple_stats['Luke,Black']['stats']['Tech']) # make sure dict is not being modified self.assertEqual(dict_copy['stats']['Tech'], preset_couple_stats['Luke,Black']['stats']['Tech'])
def __init__(self, *args, **kwargs): super(StatusUpdateTest, self).__init__(*args, **kwargs) stats = Stats( 100, 100, 100, 100, 100, 100, ) self.pokemon1 = Pokemon("Incineroar", [pk.Fire, pk.Dark], "Male", stats, None, None, None, None, None, None, 50) self.pokemon2 = Pokemon("Kyogre", [pk.Water], "", stats, None, None, None, None, None, None, 50) self.pokemon3 = Pokemon("Qwilfish", [pk.Water, pk.Poison], "Male", stats, None, None, None, None, None, None, 50) self.pokemon4 = Pokemon("Gyarados", [pk.Water, pk.Flying], "Male", stats, None, None, None, None, None, None, 50) self.battle_field = BattleFieldSingle(self.pokemon1, self.pokemon2, {1: self.pokemon4}, {1: self.pokemon3}) self.battle_field.player_id = "pokeid"
def __init__(self, *args, **kwargs): super(MinMaxTest, self).__init__(*args, **kwargs) self.stat = Stats(100, 100, 100, 100, 100, 100, ) self.pokemon1a = Pokemon("Incineroar", [pk.Fire, pk.Dark], "Male", self.stat, {}, [], 80.50, StatusType.Normal, [], None, 50) self.pokemon2a = Pokemon("Starmie", [pk.Water, pk.Psychic], "Female", self.stat, {}, [], 80, StatusType.Normal, [], None, 50) self.pokemon1b = Pokemon("Charizard", [pk.Fire, pk.Flying], "Male", self.stat, {}, [], 90.50, StatusType.Normal, [], None, 50) self.pokemon1c = Pokemon("Venusaur", [pk.Grass, pk.Poison], "Male", self.stat, {}, [], 100, StatusType.Normal, [], None, 50) self.pokemon1d = Pokemon("Raichu", [pk.Electric], "Male", self.stat, {}, [], 30, StatusType.Normal, [], None, 50) self.pokemon1e = Pokemon("Shiftry", [pk.Grass, pk.Dark], "Male", self.stat, {}, [], 59.6, StatusType.Normal, [], None, 50) self.pokemon1f = Pokemon("Arbok", [pk.Poison], "Male", self.stat, {}, [], 65, StatusType.Normal, [], None, 50) self.pokemon1a.moves[1] = SingleMove('Flamethrower', 100, 90, MoveCategory.Special, 15, 0, False, 1, pk.Fire, StatsType.Spa, [], [], StatsType.Spd, 10, None, ("normal", StatusType.Brn)) self.pokemon1a.moves[2] = SingleMove('Bite', 1, 60, MoveCategory.Physical, 25, 0, False, 1, pk.Dark, StatsType.Atk, [], [], StatsType.Def, 30, ("normal", StatusType.Flinch), None) self.pokemon2a.moves[1] = SingleMove('Hydropump', 1, 110, MoveCategory.Special, 5, 0, False, 1, pk.Water, StatsType.Spa, [], [], StatsType.Spd, 100, None, None) self.pokemon2a.moves[2] = SingleMove('Psy Beam', 1, 65, MoveCategory.Special, 20, 0, False, 1, pk.Psychic, StatsType.Spa, [], [], StatsType.Spd, 10, ("normal", StatusType.Confusion), None) self.battleField = BattleFieldSingle(self.pokemon1a, self.pokemon2a, {1: self.pokemon1a, 2: self.pokemon1b, 3: self.pokemon1c, 4: self.pokemon1d, 5: self.pokemon1e, 6: self.pokemon1f}, {1: self.pokemon2a}) self.search = IterativeDeepeningMinMax()
def test_gets_top_stat_correctly(self): stat = Stats({'Tech': 1, 'Artifact': 3, 'Danger': 2}) self.assertEqual(stat.top_stat(), 'Artifact')
def test_stat_sum(self): empty = Stats() self.assertEqual(empty.sum_stat(), 0) full = Stats({'Tech': 2, 'Contract': 4}) self.assertEqual(full.sum_stat(), 6)
def test_met_requirements(self): luke_stats = Stats(LUKE_STATS) kota_stats = Stats(KOTA_STATS) contract_2 = Stats({'Contract': 2}) self.assertEqual(luke_stats.meets(contract_2), False) self.assertEqual(kota_stats.meets(contract_2), True)
def test_max_stats(self): luke_stats = Stats(LUKE_STATS) self.assertEqual('Contract' not in luke_stats.top_stats(), True) self.assertEqual('Fragment' in luke_stats.top_stats(), True) self.assertEqual('Surveying' in luke_stats.top_stats(), True)
def test_stats_initialize_not_empty(self): new_stats = Stats(KOTA_STATS) self.assertEqual(new_stats.get_value('Contract'), KOTA_STATS['Contract'])
def update(self): Factors.save() Stats.refresh()
def test_does_not_accept_incorrect_stat_names(self): stat = Stats({'Tech': 2, 'whatever': 5}) self.assertEqual(len(stat.stat_dict.keys()), 7) self.assertEqual('whatever' in stat.stat_dict.keys(), False) self.assertEqual(stat.sum_stat(), 2)
def test_stats_initialize_empty(self): new_stats = Stats() self.assertEqual(new_stats.get_value('Danger'), 0)
def test_stat_bonus_creating_properly(self): relationship = Relationship(['Luke', 'Black'], stats=preset_couple_stats['Luke,Black']['stats']) self.assertEqual(relationship.stat_bonus.get_value('Contract'), Stats(preset_couple_stats['Luke,Black']).get_value('Contract'))
def test_default_stat_list(self): my_dict = {'Tech': 1, 'Contract': 4, 'Artifact': 3} stat = Stats(my_dict) self.assertEqual(stat.list_stats()[0]['stat'], 'Contract') self.assertEqual(len(stat.list_stats()), 3)
def test_filtered_stat_list(self): my_dict = {'Tech': 1, 'Contract': 4, 'Artifact': 3} stat = Stats(my_dict) self.assertEqual( stat.list_stats(['Tech', 'Artifact'])[0]['stat'], 'Artifact')