def test_swap_elemental(self):
error = "Failed to swap Elementals in a valid Team slot"
monze = ElementalBuilder().build()
lofy = ElementalBuilder().build()
self.team.add_elemental(monze) # Position 0
self.team.swap(slot=0, elemental=lofy)
self.assertEqual(lofy.id, self.team.get_elemental(0).id, error)
def test_remove_elemental(self):
error = "Failed to remove an Elemental from the Team"
monze = ElementalBuilder().build()
lofy = ElementalBuilder().build()
self.team.add_elemental(monze) # Position 0
self.team.add_elemental(lofy) # Position 1
self.team.remove_elemental(0) # Remove monze
self.assertEqual(lofy.id, self.team.get_elemental(0).id, error)
def test_bench(self):
error = "CombatTeam incorrectly included the active CombatElemental in bench"
team = CombatTeam(
[ElementalBuilder().build(),
ElementalBuilder().build()])
Combat([team], [], Mock())
self.assertEqual(len(team.bench), 1, error)
self.assertEqual(team.bench[0].id, team.elementals[0].id, error)
def test_eligible_bench(self):
error = "CombatTeam incorrectly included knocked out CombatElementals in the eligible bench"
team = CombatTeam([
ElementalBuilder().with_current_hp(0).build(),
ElementalBuilder().build()
])
Combat([team], [], Mock())
self.assertEqual(len(team.eligible_bench), 0, error)
def get_player(self):
"""
:return: A Player object with 2 Elementals on their Team.
"""
player = PlayerBuilder().with_level(10).build()
player.add_elemental(ElementalBuilder().with_level(10).build())
player.add_elemental(ElementalBuilder().with_level(10).build())
return player
def test_skip_ko_active(self):
error = "CombatTeam incorrectly set a 0 HP Elemental as the active Elemental"
team = CombatTeam([
ElementalBuilder().with_current_hp(0).build(),
ElementalBuilder().build()
])
Combat([team], [], Mock())
self.assertGreater(team.active_elemental.current_hp, 0, error)
def test_find_neutral(self):
error = "Should have found a neutral elemental given a list"
elementals = [
ElementalBuilder().with_element(Elements.LIGHT).build(),
ElementalBuilder().with_element(Elements.EARTH).build(),
ElementalBuilder().with_element(Elements.WIND).build()
]
result = Effectiveness.find_effective(elementals, Elements.FIRE)
self.assertEqual(len(result), 1, error)
def test_reorder_elementals(self):
error = "Failed to reorder Elementals in a Team"
monze = ElementalBuilder().build()
lofy = ElementalBuilder().build()
self.team.add_elemental(monze) # Position 0
self.team.add_elemental(lofy) # Position 1
self.team.reorder(0, 1)
self.assertEqual(monze.id, self.team.get_elemental(1).id, error)
self.assertEqual(lofy.id, self.team.get_elemental(0).id, error)
def test_switch_ko(self):
error = "CombatTeam incorrectly allowed a knocked out CombatElemental to be switched in"
team = CombatTeam([
ElementalBuilder().with_current_hp(0).build(),
ElementalBuilder().build()
])
Combat([team], [], Mock())
is_switched = team.attempt_switch(team.elementals[0])
self.assertFalse(is_switched, error)
def test_get_enemy_target(self):
error = "Ability that targets an enemy didn't get the correct target"
team_a = CombatTeam([ElementalBuilder().build()],
PlayerBuilder().build())
team_b = CombatTeam([ElementalBuilder().build()],
PlayerBuilder().build())
combat = Combat([team_a], [team_b], Mock())
ability = Mock()
ability.targeting = Target.ENEMY
target = combat.get_target(ability, team_a.active_elemental)
self.assertEqual(target, team_b.active_elemental, error)
def test_mana_per_turn(self):
error = "CombatTeam eligible Elementals on the bench didn't gain mana on turn start"
team = CombatTeam(
[ElementalBuilder().build(),
ElementalBuilder().build()])
Combat([team], [], Mock())
bench = team.eligible_bench
starting_mana = bench[0].current_mana
team.turn_start()
resultant_mana = bench[0].current_mana
self.assertGreater(resultant_mana, starting_mana, error)
def test_physical_defence(self):
error = "Physical defence didn't reduce any damage"
low_def = CombatElementalBuilder().with_elemental(
ElementalBuilder().with_physical_def(1).build()).build()
high_def = CombatElementalBuilder().with_elemental(
ElementalBuilder().with_physical_def(30).build()).build()
actor = CombatElementalBuilder().build()
low_def_calculator = DamageCalculator(low_def, actor, Claw())
low_def_calculator.calculate()
high_def_calculator = DamageCalculator(high_def, actor, Claw())
high_def_calculator.calculate()
self.assertGreater(low_def_calculator.final_damage,
high_def_calculator.final_damage, error)
def test_rolling_thunder_duration(self):
error = "Rolling Thunder turn duration didn't decrement"
effect = RollingThunderEffect()
team = CombatTeam([ElementalBuilder().build()],
PlayerBuilder().build())
effect.applier = team.elementals[0]
enemy_team = CombatTeam([ElementalBuilder().build()],
PlayerBuilder().build())
get_mocked_combat(team, enemy_team)
enemy_team.add_status_effect(effect)
duration_before = effect.rounds_remaining
enemy_team.end_round()
self.assertLess(effect.rounds_remaining, duration_before, error)
def test_defend_priority(self):
error = "Defend wasn't faster than other abilities"
team_a = make_combat_team()
team_b = make_combat_team()
combat = get_mocked_combat(team_a, team_b)
faster = CombatElemental(ElementalBuilder().with_speed(10).build(),
team_b)
team_b.change_active_elemental(faster)
slower = CombatElemental(ElementalBuilder().with_speed(1).build(),
team_a)
team_a.change_active_elemental(slower)
combat.request_action(ElementalAction(faster, Claw(), combat))
combat.request_action(ElementalAction(slower, Defend(), combat))
self.assertIsInstance(combat.previous_round_actions[0].ability, Defend,
error)
def test_level_up(self):
error = "Elemental couldn't level"
elemental = ElementalBuilder().with_level(1).build()
before_level = elemental.level
self.level_up(elemental)
after_level = elemental.level
self.assertGreater(after_level, before_level, error)
def test_num_active_abilities(self):
error = "Elemental can incorrectly have more than 4 abilities active"
species = self.get_species()
elemental = ElementalBuilder().with_level(5).with_species(
species).build()
num_abilities = len(elemental.active_abilities)
self.assertEqual(num_abilities, 4, error)
def test_create_unique_attributes(self):
error = "Elemental can incorrectly have a duplicate attribute"
for i in range(100):
elemental = ElementalBuilder().build()
attributes = elemental.attributes
no_duplicates = len(attributes) == len(set(attributes))
self.assertIs(no_duplicates, True, error)
def test_max_num_elementals(self):
error = "A Team can incorrectly have more than 4 Elementals"
for i in range(5):
elemental = ElementalBuilder().build()
self.team.add_elemental(elemental)
self.assertEqual(self.team.size, 4, error)
self.assertEqual(self.team.is_space_available, False, error)
def test_level_exp_cap(self):
error = "Leveling up didn't increase the Elemental's required exp"
elemental = ElementalBuilder().with_level(1).build()
lower_requirement = elemental.exp_to_level
self.level_up(elemental)
higher_requirement = elemental.exp_to_level
self.assertGreater(higher_requirement, lower_requirement, error)
def test_reset_nickname(self):
error = "Elemental nickname couldn't be reset"
species = SpeciesBuilder().with_name("Richard").build()
elemental = ElementalBuilder().with_species(species).build()
elemental.nickname = "Logi"
elemental.reset_nickname()
self.assertEqual(elemental.nickname, "Richard", error)
def test_raise_attribute(self):
error = "Elemental who met requirements couldn't raise an attribute"
elemental = ElementalBuilder().with_level(10).build()
elemental.raise_attribute(elemental.attributes[0])
attributes = elemental.attributes
attribute_level = attributes[0].level
self.assertEqual(attribute_level, 1, error)
def test_multi_level_up(self):
error = "Elemental failed to level up multiple times with multiple levels' worth of experience"
elemental = ElementalBuilder().with_level(1).build()
before_level = elemental.level
exp_gained = elemental.exp_to_level * 5 # Arbitrary large amount of exp
elemental.add_exp(exp_gained)
after_level = elemental.level
self.assertGreater(after_level, before_level + 1, error)
def test_action_speed_priority(self):
error = "Faster elemental didn't attack first"
team_a = make_combat_team()
team_b = make_combat_team()
combat = get_mocked_combat(team_a, team_b)
slower = CombatElemental(ElementalBuilder().with_level(1).build(),
team_a)
team_a.change_active_elemental(slower)
faster = CombatElemental(
ElementalBuilder().with_level(10).with_nickname('loksy').build(),
team_b)
team_b.change_active_elemental(faster)
combat.request_action(ElementalAction(slower, Claw(), combat))
faster_action = ElementalAction(faster, Claw(), combat)
combat.request_action(faster_action)
expected = combat.previous_round_actions[0].actor.nickname
self.assertEqual(expected, faster.nickname, error)
def test_victory_elementalist_no_loot(self):
error = "Elementalist shouldn't award loot"
winning_teams = [CombatTeam([], PlayerBuilder().build())]
elemental = ElementalBuilder().with_species(Manapher()).build() # Manapher has 100% drop rate
losing_teams = [CombatTeam([elemental], NPCBuilder().build())]
generator = LootGenerator(winning_teams, losing_teams)
generator.generate_loot()
self.assertEqual(len(generator.items_dropped), 0, error)
def wild_elemental_loot(self):
error = "Wild elemental didn't award loot"
winning_teams = [CombatTeam.from_team(TeamBuilder().build())]
wild_elemental = ElementalBuilder().with_species(Manapher()).build() # Manapher has 100% drop rate
losing_teams = [CombatTeam([wild_elemental])] # Wild elemental teams have no owner
generator = LootGenerator(winning_teams, losing_teams)
generator.generate_loot()
self.assertGreater(len(generator.items_dropped), 0, error)
def test_available_abilities(self):
error = "Abilities weren't listed as available when learned"
species = self.get_species()
# Level until we learn all abilities
elemental = ElementalBuilder().with_level(5).with_species(
species).build()
num_abilities = len(elemental.available_abilities)
self.assertEqual(num_abilities, 5, error)
def test_swap_ability(self):
error = "Elemental couldn't swap an ability"
species = self.get_species()
elemental = ElementalBuilder().with_level(5).with_species(
species).build()
active_ability = elemental.active_abilities[0]
eligible_ability = elemental.eligible_abilities[0]
elemental.swap_ability(active_ability, eligible_ability)
self.assertIn(eligible_ability, elemental.active_abilities, error)
def test_eligible_abilities(self):
error = "Eligible abilities didn't separate active from available abilities correctly"
species = self.get_species()
elemental = ElementalBuilder().with_level(5).with_species(
species).build()
num_active = len(elemental.active_abilities)
num_available = len(elemental.available_abilities)
num_eligible = len(elemental.eligible_abilities)
self.assertEqual(num_eligible, num_available - num_active, error)
def test_elemental_action(self):
error = "ElementalAction could incorrectly trigger when the elemental is KOed."
elemental = ElementalBuilder().build()
team = CombatTeam([elemental], PlayerBuilder().build())
elemental.receive_damage(10000)
action = ElementalAction(actor=team.elementals[0],
ability=Claw(),
combat=Mock())
self.assertFalse(action.can_execute, error)
def test_duplicate_abilities(self):
error = "Elemental can incorrectly learn the same ability"
species = SpeciesBuilder().with_abilities(
[self.get_learnable_ability(1)]).build()
elemental = ElementalBuilder().with_level(5).with_species(
species).build()
print(elemental.active_abilities)
num_abilities = len(elemental.active_abilities)
self.assertEqual(num_abilities, 1, error)