def setUp(self):
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #G.#E#.###.#.#
# 2 #..#.#...#####
# 3 ##...#E#.#.G.#
# 4 ####.....#####
# 5 ##############
self.movement_cavern = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#...#####',
'##...#E#.#.G.#', '####.....#####', '##############'
])
# Manually change the units, so the elves are in the wrong order
logging.debug(self.movement_cavern.alive_elves())
self.movement_cavern.alive_elves()[0].loc.y = 4
self.assertEqual(self.movement_cavern.alive_elves()[0].loc.y, 4)
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #GE#.#.###.#.#
# 2 #E.#.#...#####
# 3 ##...#.#.#...#
# 4 ####.....#####
# 5 ##############
self.attack_cavern = Cavern([
'##############', '#GE#.#.###.#.#', '#E.#.#...#####',
'##...#.#.#...#', '####.....#####', '##############'
])
def setUp(self):
# The test map is given below:
#
# 1111111111222222222233333333334444444444555555
# 01234567890123456789012345678901234567890123456789012345
# 0 ########################################################
# 1 #......................................................#
# 2 #......................................................#
# 3 #......................................................#
# 4 #......................................................#
# 5 ########################################################
self.cavern = Cavern([
'########################################################',
'#......................................................#',
'#......................................................#',
'#......................................................#',
'#......................................................#',
'########################################################'
])
def setUp(self):
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #G.#E#.###.#.#
# 2 #..#.#..E#####
# 3 ##...#E#.#.G.#
# 4 ####...G.#####
# 5 ##############
self.cavern_1 = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#..E#####',
'##...#E#.#.G.#', '####...G.#####', '##############'
])
# The test map is given below:
#
# 012345
# 0 ######
# 1 #...G#
# 2 #....#
# 3 #....#
# 4 #G..E#
# 5 ######
self.cavern_2 = Cavern(
['######', '#...G#', '#....#', '#....#', '#G..E#', '######'])
self.cavern_custom = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#..E#####',
'##...#E#.#...#', '####...G.#####', '##############'
])
def setUp(self):
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #G.#E#.###.#.#
# 2 #..#.#...#####
# 3 ##...#E#.#.G.#
# 4 ####.....#####
# 5 ##############
# 6 #...##########
# 7 ##..##########
# 8 ##...#########
# 9 ##############
self.cavern = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#...#####',
'##...#E#.#.G.#', '####.....#####', '##############',
'#...##########', '##..##########', '##...#########',
'##############'
])
class TestPerformance(unittest.TestCase):
def setUp(self):
# The test map is given below:
#
# 1111111111222222222233333333334444444444555555
# 01234567890123456789012345678901234567890123456789012345
# 0 ########################################################
# 1 #......................................................#
# 2 #......................................................#
# 3 #......................................................#
# 4 #......................................................#
# 5 ########################################################
self.cavern = Cavern([
'########################################################',
'#......................................................#',
'#......................................................#',
'#......................................................#',
'#......................................................#',
'########################################################'
])
def test_long_path(self):
start_time = datetime.datetime.now()
shortest_path = self.cavern.path_length(Point(2, 2), Point(53, 3))
end_time = datetime.datetime.now()
expected_result = PathStep(51, Point(3, 2))
self.assertEqual(shortest_path, expected_result)
running_time = (end_time - start_time).total_seconds()
time_threshold_seconds = 1
self.assertTrue(
running_time <= time_threshold_seconds,
msg=
"Test did not complete in a reasonable time ({threshold} seconds). {elapsed} seconds elapsed."
.format(threshold=time_threshold_seconds, elapsed=running_time))
class TestUnitTurns(unittest.TestCase):
def setUp(self):
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #G.#E#.###.#.#
# 2 #..#.#..E#####
# 3 ##...#E#.#.G.#
# 4 ####...G.#####
# 5 ##############
self.cavern_1 = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#..E#####',
'##...#E#.#.G.#', '####...G.#####', '##############'
])
# The test map is given below:
#
# 012345
# 0 ######
# 1 #...G#
# 2 #....#
# 3 #....#
# 4 #G..E#
# 5 ######
self.cavern_2 = Cavern(
['######', '#...G#', '#....#', '#....#', '#G..E#', '######'])
self.cavern_custom = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#..E#####',
'##...#E#.#...#', '####...G.#####', '##############'
])
def test_full_round(self):
self.cavern_1.step(1)
# Check all the units moved correctly
self.assertIsNone(self.cavern_1.unit_at(Point(1, 1)))
self.assertTrue(type(self.cavern_1.unit_at(Point(2, 1))) == Goblin)
self.assertIsNone(self.cavern_1.unit_at(Point(4, 1)))
self.assertTrue(type(self.cavern_1.unit_at(Point(4, 2))) == Elf)
self.assertIsNone(self.cavern_1.unit_at(Point(8, 2)))
self.assertTrue(type(self.cavern_1.unit_at(Point(8, 3))) == Elf)
self.assertIsNone(self.cavern_1.unit_at(Point(6, 3)))
self.assertTrue(type(self.cavern_1.unit_at(Point(6, 4))) == Elf)
self.assertTrue(type(self.cavern_1.unit_at(Point(11, 3))) == Goblin)
self.assertTrue(type(self.cavern_1.unit_at(Point(7, 4))) == Goblin)
# Now check that all the units apart from the ones at (6, 4) and (7, 4) have 200 HP
self.assertTrue(self.cavern_1.unit_at(Point(2, 1)).hp == 200)
self.assertTrue(self.cavern_1.unit_at(Point(4, 2)).hp == 200)
self.assertTrue(self.cavern_1.unit_at(Point(8, 3)).hp == 200)
self.assertTrue(self.cavern_1.unit_at(Point(6, 4)).hp == 197)
self.assertTrue(self.cavern_1.unit_at(Point(11, 3)).hp == 200)
self.assertTrue(self.cavern_1.unit_at(Point(7, 4)).hp == 197)
def test_full_round_equal_distance(self):
self.cavern_2.step(1)
# Check all the units moved correctly
self.assertIsNone(self.cavern_2.unit_at(Point(4, 1)))
self.assertTrue(type(self.cavern_2.unit_at(Point(4, 2))) == Goblin)
self.assertIsNone(self.cavern_2.unit_at(Point(1, 4)))
self.assertTrue(type(self.cavern_2.unit_at(Point(2, 4))) == Goblin)
self.assertIsNone(self.cavern_2.unit_at(Point(4, 4)))
self.assertTrue(type(self.cavern_2.unit_at(Point(4, 3))) == Elf)
# Now check that all the units (apart from the first Goblin) have 200 HP
self.assertTrue(self.cavern_2.unit_at(Point(4, 2)).hp == 197)
self.assertTrue(self.cavern_2.unit_at(Point(2, 4)).hp == 200)
self.assertTrue(self.cavern_2.unit_at(Point(4, 3)).hp == 200)
def test_full_game_custom(self):
rounds_played, hp, winning_team = self.cavern_custom.play()
self.assertEqual(rounds_played, 68)
self.assertEqual(hp, 300)
self.assertEqual(winning_team, Elf)
def test_examples(self):
example_caverns = [
{
"starting_cavern": [
"#######", "#G..#E#", "#E#E.E#", "#G.##.#", "#...#E#",
"#...E.#", "#######"
],
"rounds_played":
37,
"remaining_hit_points":
982,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#E..EG#", "#.#G.E#", "#E.##E#", "#G..#.#",
"#..E#.#", "#######"
],
"rounds_played":
46,
"remaining_hit_points":
859,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#E.G#.#", "#.#G..#", "#G.#.G#", "#G..#.#",
"#...E.#", "#######"
],
"rounds_played":
35,
"remaining_hit_points":
793,
"winning_team":
Goblin
},
{
"starting_cavern": [
"#######", "#.E...#", "#.#..G#", "#.###.#", "#E#G#G#",
"#...#G#", "#######"
],
"rounds_played":
54,
"remaining_hit_points":
536,
"winning_team":
Goblin
},
{
"starting_cavern": [
"#########", "#G......#", "#.E.#...#", "#..##..G#",
"#...##..#", "#...#...#", "#.G...G.#", "#.....G.#",
"#########"
],
"rounds_played":
20,
"remaining_hit_points":
937,
"winning_team":
Goblin
},
]
for test_data in example_caverns:
rounds_played, hp, winning_team = Cavern(
test_data["starting_cavern"]).play()
self.assertEqual(rounds_played, test_data["rounds_played"])
self.assertEqual(hp, test_data["remaining_hit_points"])
self.assertEqual(winning_team, test_data["winning_team"])
def test_examples(self):
example_caverns = [
{
"starting_cavern": [
"#######", "#.G...#", "#...EG#", "#.#.#G#", "#..G#E#",
"#.....#", "#######"
],
"elf_attack":
15,
"rounds_played":
29,
"remaining_hit_points":
172,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#E..EG#", "#.#G.E#", "#E.##E#", "#G..#.#",
"#..E#.#", "#######"
],
"elf_attack":
4,
"rounds_played":
33,
"remaining_hit_points":
948,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#E.G#.#", "#.#G..#", "#G.#.G#", "#G..#.#",
"#...E.#", "#######"
],
"elf_attack":
15,
"rounds_played":
37,
"remaining_hit_points":
94,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#.E...#", "#.#..G#", "#.###.#", "#E#G#G#",
"#...#G#", "#######"
],
"elf_attack":
12,
"rounds_played":
39,
"remaining_hit_points":
166,
"winning_team":
Elf
},
{
"starting_cavern": [
"#########", "#G......#", "#.E.#...#", "#..##..G#",
"#...##..#", "#...#...#", "#.G...G.#", "#.....G.#",
"#########"
],
"elf_attack":
34,
"rounds_played":
30,
"remaining_hit_points":
38,
"winning_team":
Elf
},
]
for test_data in example_caverns:
cavern = Cavern(test_data["starting_cavern"],
elf_attack=test_data["elf_attack"],
ignore_elf_death=False)
try:
turns, hp, winning_team = cavern.play()
except UnitDiedException as ude:
self.fail("An elf died unexpectedly ({elf})".format(
elf=ude.unit.debug_str()))
self.assertEqual(turns, test_data["rounds_played"])
self.assertEqual(hp, test_data["remaining_hit_points"])
self.assertEqual(winning_team, test_data["winning_team"])
class TestPathFinding(unittest.TestCase):
def setUp(self):
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #G.#E#.###.#.#
# 2 #..#.#...#####
# 3 ##...#E#.#.G.#
# 4 ####.....#####
# 5 ##############
# 6 #...##########
# 7 ##..##########
# 8 ##...#########
# 9 ##############
self.cavern = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#...#####',
'##...#E#.#.G.#', '####.....#####', '##############',
'#...##########', '##..##########', '##...#########',
'##############'
])
def test_path_starts_on_wall(self):
shortest_path = self.cavern.path_length(Point(2, 0), Point(2, 1))
expected_result = None
self.assertEqual(shortest_path, expected_result)
def test_path_ends_on_wall(self):
shortest_path = self.cavern.path_length(Point(2, 1), Point(2, 0))
expected_result = None
self.assertEqual(shortest_path, expected_result)
def test_path_starts_on_unit(self):
shortest_path = self.cavern.path_length(Point(1, 1), Point(1, 2))
expected_result = PathStep(0, Point(1, 2))
self.assertEqual(shortest_path, expected_result)
def test_path_ends_on_unit(self):
shortest_path = self.cavern.path_length(Point(1, 2), Point(1, 1))
expected_result = PathStep(0, Point(1, 1))
self.assertEqual(shortest_path, expected_result)
def test_path_unreachable_because_wall(self):
shortest_path = self.cavern.path_length(Point(10, 1), Point(12, 1))
expected_result = None
self.assertEqual(shortest_path, expected_result)
def test_path_unreachable_because_unit(self):
shortest_path = self.cavern.path_length(Point(10, 3), Point(12, 3))
expected_result = None
self.assertEqual(shortest_path, expected_result)
def test_empty_path(self):
shortest_path = self.cavern.path_length(Point(2, 3), Point(4, 2))
expected_result = PathStep(2, Point(3, 3))
self.assertEqual(shortest_path, expected_result)
def test_valid_route_with_two_paths(self):
shortest_path = self.cavern.path_length(Point(1, 1), Point(4, 1))
expected_result = PathStep(6, Point(2, 1))
self.assertEqual(shortest_path, expected_result)
def test_path_with_unit_obstruction(self):
shortest_path = self.cavern.path_length(Point(6, 2), Point(6, 4))
expected_result = PathStep(5, Point(7, 2))
self.assertEqual(shortest_path, expected_result)
def test_path_with_overlapping_paths(self):
shortest_path_forward = self.cavern.path_length(
Point(1, 6), Point(4, 8))
expected_result_forward = PathStep(4, Point(2, 6))
shortest_path_backward = self.cavern.path_length(
Point(4, 8), Point(1, 6))
expected_result_backward = PathStep(4, Point(3, 8))
self.assertEqual(shortest_path_forward, expected_result_forward)
self.assertEqual(shortest_path_backward, expected_result_backward)
def test_examples(self):
example_caverns = [
{
"starting_cavern": [
"#######", "#G..#E#", "#E#E.E#", "#G.##.#", "#...#E#",
"#...E.#", "#######"
],
"rounds_played":
37,
"remaining_hit_points":
982,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#E..EG#", "#.#G.E#", "#E.##E#", "#G..#.#",
"#..E#.#", "#######"
],
"rounds_played":
46,
"remaining_hit_points":
859,
"winning_team":
Elf
},
{
"starting_cavern": [
"#######", "#E.G#.#", "#.#G..#", "#G.#.G#", "#G..#.#",
"#...E.#", "#######"
],
"rounds_played":
35,
"remaining_hit_points":
793,
"winning_team":
Goblin
},
{
"starting_cavern": [
"#######", "#.E...#", "#.#..G#", "#.###.#", "#E#G#G#",
"#...#G#", "#######"
],
"rounds_played":
54,
"remaining_hit_points":
536,
"winning_team":
Goblin
},
{
"starting_cavern": [
"#########", "#G......#", "#.E.#...#", "#..##..G#",
"#...##..#", "#...#...#", "#.G...G.#", "#.....G.#",
"#########"
],
"rounds_played":
20,
"remaining_hit_points":
937,
"winning_team":
Goblin
},
]
for test_data in example_caverns:
rounds_played, hp, winning_team = Cavern(
test_data["starting_cavern"]).play()
self.assertEqual(rounds_played, test_data["rounds_played"])
self.assertEqual(hp, test_data["remaining_hit_points"])
self.assertEqual(winning_team, test_data["winning_team"])
class TestUnitOrdering(unittest.TestCase):
def setUp(self):
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #G.#E#.###.#.#
# 2 #..#.#...#####
# 3 ##...#E#.#.G.#
# 4 ####.....#####
# 5 ##############
self.movement_cavern = Cavern([
'##############', '#G.#E#.###.#.#', '#..#.#...#####',
'##...#E#.#.G.#', '####.....#####', '##############'
])
# Manually change the units, so the elves are in the wrong order
logging.debug(self.movement_cavern.alive_elves())
self.movement_cavern.alive_elves()[0].loc.y = 4
self.assertEqual(self.movement_cavern.alive_elves()[0].loc.y, 4)
# The test map is given below:
#
# 1111
# 01234567890123
# 0 ##############
# 1 #GE#.#.###.#.#
# 2 #E.#.#...#####
# 3 ##...#.#.#...#
# 4 ####.....#####
# 5 ##############
self.attack_cavern = Cavern([
'##############', '#GE#.#.###.#.#', '#E.#.#...#####',
'##...#.#.#...#', '####.....#####', '##############'
])
def test_order_by_location(self):
# Kill all the goblins
for u in self.movement_cavern.alive_goblins():
u.hp = 0
elves = self.movement_cavern.alive_elves()
units = self.movement_cavern.order_units_by_position(elves)
self.assertEqual(units[0].loc.x, 6)
self.assertEqual(units[0].loc.y, 3)
self.assertEqual(units[1].loc.x, 4)
self.assertEqual(units[1].loc.y, 4)
def test_order_with_different_types(self):
elves = self.movement_cavern.alive_elves()
units = self.movement_cavern.order_units_by_position(elves)
self.assertEqual(units[0].loc.x, 6)
self.assertEqual(units[0].loc.y, 3)
self.assertEqual(units[1].loc.x, 4)
self.assertEqual(units[1].loc.y, 4)
def test_attack_order_by_hit_points(self):
# Set one of the units to a lower hit points
self.attack_cavern.alive_elves()[1].hp = 1
elves = self.attack_cavern.alive_elves()
units = self.attack_cavern.order_units_by_hit_points(elves)
self.assertEqual(units[0].loc.x, 1)
self.assertEqual(units[0].loc.y, 2)
self.assertEqual(units[1].loc.x, 2)
self.assertEqual(units[1].loc.y, 1)
def test_attack_order_by_location(self):
elves = self.attack_cavern.alive_elves()
units = self.attack_cavern.order_units_by_hit_points(elves)
self.assertEqual(units[0].loc.x, 2)
self.assertEqual(units[0].loc.y, 1)
self.assertEqual(units[1].loc.x, 1)
self.assertEqual(units[1].loc.y, 2)