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')
