def test_get_living_players(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) unit_generator = UnitGenerator() unit = unit_generator.generate(is_player=True) dungeon.add_unit(unit) dead_unit = unit_generator.generate() dead_unit.kill() dungeon.add_unit(dead_unit) # test typical use case actual = dungeon.get_living_players() self.assertEqual(len(actual), 1) dead_players = dungeon.get_dead_players() self.assertEqual(len(dead_players), 0)
def test_get_xp_remaining_until_next_level_percentage(self): unit_generator = UnitGenerator() unit = unit_generator.generate() unit_level = UnitLevel() level_42_xp = unit_level.get_xp_for_level(42) ten_percent_of_total_xp = level_42_xp * .10 unit.experience = level_42_xp - ten_percent_of_total_xp total_xp = level_42_xp # Test 90% expected_percentage = 90 actual_percentage = unit.get_xp_remaining_until_next_level_percentage( total_xp) self.assertEqual(expected_percentage, actual_percentage) # Test 50% expected_fifty_percentage = 50 fifty_percent_of_total_xp = level_42_xp * .50 unit.experience = level_42_xp - fifty_percent_of_total_xp a_fifty = unit.get_xp_remaining_until_next_level_percentage(total_xp) self.assertEqual(expected_fifty_percentage, a_fifty) # Test xp over max level expected_one_twenty_percent = 120 max_level_xp = unit_level.get_xp_for_max_level() twenty_percent_of_max = max_level_xp * .20 unit.experience = max_level_xp + twenty_percent_of_max a_120 = unit.get_xp_remaining_until_next_level_percentage(max_level_xp) self.assertEqual(expected_one_twenty_percent, a_120)
def test_get_unit_by_name(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) unit_name = "quux" unit_generator = UnitGenerator() unit = unit_generator.generate(unit_name=unit_name) dungeon.add_unit(unit) self.assertTrue(len(dungeon.units), 0) # test exact match actual = dungeon.get_unit_by_name(unit_name) self.assertIsInstance(actual, Unit) # test invalid match actual = dungeon.get_unit_by_name("foo") self.assertIsNone(actual) # test case sensitivity actual = dungeon.get_unit_by_name(unit_name.upper()) self.assertIsInstance(actual, Unit) # test startswith actual = dungeon.get_unit_by_name(unit_name[0:1]) self.assertIsInstance(actual, Unit)
def test_generate(self): unit_gen = UnitGenerator() unit = unit_gen.generate() self.assertIsInstance(unit, Unit) self.assertTrue(len(unit.name) > 0) self.assertEqual(len(unit.effects), 0)
def test_get_hp_percentage(self): unit_generator = UnitGenerator() unit = unit_generator.generate() """ Full hp """ expected = 100 actual = unit.get_hp_percentage() self.assertEqual(expected, actual) """ Adjust HP and re-test """ hp_adjustment = 10 operator = "-" adjust_hp_effect = self._make_effect( operator=operator, hp_adjustment=hp_adjustment) self.assertEqual(adjust_hp_effect.hp_adjustment, hp_adjustment) self.assertEqual(adjust_hp_effect.operator, operator) # Apply effect unit.apply_effect(adjust_hp_effect) expected_adjusted = 90 actual_adjusted = unit.get_hp_percentage() self.assertEqual(expected_adjusted, actual_adjusted) """ Reset HP and try another percentage """ unit.hp = unit.calculate_hp() big_hp = 50 operator = "-" big_adjust_hp_effect = self._make_effect(operator=operator, hp_adjustment=big_hp) unit.apply_effect(big_adjust_hp_effect) expected_big_adjusted = 50 actual_big_adjusted = unit.get_hp_percentage() self.assertEqual(expected_big_adjusted, actual_big_adjusted) """ Reset HP to full """ unit.hp = unit.calculate_hp() expected_full = 100 actual_full = unit.get_hp_percentage() self.assertEqual(expected_full, actual_full)
def test_get_unit_status_distribution(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) """ living hostile player """ unit_generator = UnitGenerator() living_player = unit_generator.generate(is_player=True, combat_status="hostile") dungeon.add_unit(living_player) """ dead friendly NPC """ dead_friendly_unit = unit_generator.generate(combat_status="friendly") dead_friendly_unit.kill() dungeon.add_unit(dead_friendly_unit) """ living friendly NPC """ living_npc = unit_generator.generate(combat_status="friendly") dungeon.add_unit(living_npc) """ living hostile NPC """ hostile_living_npc = unit_generator.generate(combat_status="hostile") dungeon.add_unit(hostile_living_npc) # TODO: add undead here actual = dungeon.get_unit_status_distribution() expected = { "players": { "living": 1, "dead": 0, "undead": 0 }, "npc": { "hostile": { "living": 1, "dead": 0, "undead": 0 }, "friendly": { "living": 1, "dead": 1, "undead": 0 } } } self.assertEqual(expected, actual)
def test_get_unit_by_user_id(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) user_id = 42 unit_generator = UnitGenerator() unit = unit_generator.generate(user_id=user_id) dungeon.add_unit(unit) actual = dungeon.get_unit_by_user_id(user_id) self.assertIsInstance(actual, Unit)
def test_add_dungeon_units(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) unit_generator = UnitGenerator() unit = unit_generator.generate() dungeon.add_unit(unit) dungeon_unit = dungeon.units[0] self.assertIsInstance(dungeon_unit, Unit)
def test_get_random_living_unit(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) unit_generator = UnitGenerator() for j in range(0, 5): hostile_living_npc = unit_generator.generate(combat_status="hostile") dungeon.add_unit(hostile_living_npc) random_unit = dungeon.get_random_living_unit() self.assertIsInstance(random_unit, Unit)
def _make_unit(self, **kwargs): if "base_items" in kwargs: base_items = kwargs["base_items"] else: base_items = [] if "level" in kwargs: level = kwargs["level"] else: level = randrange(1, 100) unit_type_id = kwargs["unit_type_id"] unit_generator = UnitGenerator() return unit_generator.generate(base_items=base_items, unit_type_id=unit_type_id, level=level)
def test_get_living_unit_by_name(self): dungeon_model = self._get_dungeon_model() with LogCapture(): logger = logging.getLogger() dungeon = Dungeon(dungeon=dungeon_model, announcer={}, log=logger) unit_name = "baz" unit_generator = UnitGenerator() unit = unit_generator.generate(unit_name=unit_name) dungeon.add_unit(unit) # test typical use case actual = dungeon.get_living_unit_by_name(unit.get_name()) self.assertIsInstance(actual, Unit) unit.kill() actual = dungeon.get_living_unit_by_name(unit.get_name()) self.assertIsNone(actual)
def test_create_npc(self): unit_generator = UnitGenerator() unit = unit_generator.generate() self.assertEqual(unit.is_player, False) self.assertEqual(unit.is_npc, True)
def _make_unit(self, **kwargs): level = kwargs["level"] unit_generator = UnitGenerator() return unit_generator.generate(level=level)
def test_generate_unit_with_name(self): unit_name = "quux" unit_gen = UnitGenerator() unit = unit_gen.generate(unit_name=unit_name) self.assertEqual(unit.get_name(), unit_name)