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)
