def test_get_movement_points_not_affected_by_unit_on_origin(self):
map_ = Map(2, 2, [Tile() for _ in range(4)])
origin = Point(0, 0)
map_.place_unit(Soldier(), origin)
answer = MovementCalculator(map_).get_movement_points(origin, 100)
expected = {
Point(0, 0): 0,
Point(0, 1): 1,
Point(1, 0): 1,
Point(1, 1): 2
}
self.assertEqual(answer, expected)
def test_allies_in_range_advantage(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): -1, Point(2, 0): 1}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin, below, above = self.a_units
origin.equip_weapon(RangedWeapon(10, 10, 10, 10))
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(below, Point(1, 0))
the_map.place_unit(above, Point(2, 0))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_range(origin)
expected = {below: (1, 1), above: (2, -1)}
self.assertEqual(answer, expected)
def test_allies_in_range_melee_weapon(self):
points_to_elevation = {
Point(1, 0): -3,
Point(0, 1): 4,
Point(1, 1): 0,
Point(2, 1): -4,
Point(1, 2): 3
}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 3, tiles)
origin, below, above = self.a_units
far_below = Soldier()
far_above = Soldier()
self.team_a.add_player(far_above)
self.team_a.add_player(far_below)
origin.equip_weapon(MeleeWeapon(10, 10, 10, 10))
the_map.place_unit(origin, Point(1, 1))
the_map.place_unit(below, Point(1, 0))
the_map.place_unit(above, Point(1, 2))
the_map.place_unit(far_above, Point(0, 1))
the_map.place_unit(far_below, Point(2, 1))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_range(origin)
expected = {below: (1, 1), above: (1, -1)}
self.assertEqual(answer, expected)
def test_get_movement_points_with_path_with_occupied_space_in_place(self):
elevations = {
Point(0, 0): 2,
Point(1, 0): 0,
Point(2, 0): 3,
Point(0, 1): 1,
Point(1, 1): 0,
Point(2, 1): 2,
Point(0, 2): 2,
Point(1, 2): 0,
Point(2, 2): 1
}
tiles = [
Tile(point=point, elevation=elevation)
for point, elevation in elevations.items()
]
map_ = Map(3, 3, tiles)
occupied_point = Point(1, 1)
origin = Point(1, 2)
map_.place_unit(Soldier(), origin)
map_.place_unit(Soldier(), occupied_point)
expected = {
Point(0, 0): (6, [W, S, S]),
Point(1, 0): (7, [W, S, S, E]),
Point(2, 0): (6, [E, S, S]),
Point(0, 1): (4, [W, S]),
Point(2, 1): (4, [E, S]),
Point(0, 2): (3, [W]),
Point(1, 2): (0, []),
Point(2, 2): (2, [E])
}
self.assertEqual(
MovementCalculator(map_).get_movement_points_with_path(origin, 10),
expected)
def test_allies_in_sight_by_obstructed_view(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): 1, Point(2, 0): 0}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin, in_sight, out_of_sight = self.a_units
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(in_sight, Point(1, 0))
the_map.place_unit(out_of_sight, Point(2, 0))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_sight(origin)
expected = {
in_sight: 1,
}
self.assertEqual(answer, expected)
def test_enemies_in_range_by_obstructed_view(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): 1, Point(2, 0): 0}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin = self.a_units[0]
in_range, out_of_range = self.b_units[0:2]
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(in_range, Point(1, 0))
the_map.place_unit(out_of_range, Point(2, 0))
origin.equip_weapon(RangedWeapon(10, 10, 1, 1))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.enemies_in_range(origin)
expected = {
in_range: (1, -1),
}
self.assertEqual(answer, expected)
class TestTargetFinder(unittest.TestCase):
def setUp(self):
self.map_length = 20
self.map = Map(self.map_length, self.map_length,
[Tile() for _ in range(self.map_length**2)])
self.team_a = Team(Point(self.map_length - 1, 0), self.map)
self.team_b = Team(Point(0, self.map_length - 1), self.map)
team_size = 3
self.a_units = [Soldier() for _ in range(team_size)]
self.b_units = [Soldier() for _ in range(team_size)]
for a_unit, b_unit in zip(self.a_units, self.b_units):
self.team_a.add_player(a_unit)
self.team_b.add_player(b_unit)
def test_get_team(self):
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
for unit in self.a_units + self.b_units:
test_team = test.get_team(unit)
self.assertTrue(test_team.is_on_team(unit))
def test_init_copies_team_list(self):
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
teams[0] = 'not a team'
teams[1] = 'nope'
for unit in self.a_units + self.b_units:
test_team = test.get_team(unit)
self.assertTrue(test_team.is_on_team(unit))
def test_allies_in_sight_answer_excludes_non_allies(self):
all_units = self.a_units + self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[0]
self.assertEqual(test_unit.get_sight_range(), 10)
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.allies_in_sight(test_unit)
expected = {self.a_units[1]: 2, self.a_units[2]: 4}
self.assertEqual(answer, expected)
def test_allies_in_sight_no_allies(self):
all_units = self.a_units[0:1] + self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[0]
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.allies_in_sight(test_unit)
self.assertEqual(answer, {})
def test_allies_in_sight_by_obstructed_view(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): 1, Point(2, 0): 0}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin, in_sight, out_of_sight = self.a_units
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(in_sight, Point(1, 0))
the_map.place_unit(out_of_sight, Point(2, 0))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_sight(origin)
expected = {
in_sight: 1,
}
self.assertEqual(answer, expected)
def test_allies_in_sight_by_sight_range(self):
origin, in_sight, out_of_sight = self.a_units
self.map.place_unit(origin, Point(0, 0))
self.map.place_unit(in_sight, Point(10, 0))
self.map.place_unit(out_of_sight, Point(11, 0))
tf = TargetFinder(self.map, [self.team_a, self.team_b])
answer = tf.allies_in_sight(origin)
expected = {
in_sight: 10,
}
self.assertEqual(answer, expected)
self.map.remove_unit(Point(10, 0))
self.map.remove_unit(Point(11, 0))
self.map.place_unit(in_sight, Point(5, 5))
self.map.place_unit(out_of_sight, Point(5, 6))
answer = tf.allies_in_sight(origin)
self.assertEqual(answer, expected)
def test_allies_in_sight_different_sight_range(self):
class NewSoldier(Soldier):
def get_sight_range(self):
return 3
short_sighted = NewSoldier()
self.team_a.add_player(short_sighted)
in_sight, also_in_sight, out_of_sight = self.a_units
self.map.place_unit(short_sighted, Point(0, 0))
self.map.place_unit(in_sight, Point(3, 0))
self.map.place_unit(also_in_sight, Point(2, 1))
self.map.place_unit(out_of_sight, Point(4, 0))
tf = TargetFinder(self.map, [self.team_a, self.team_b])
answer = tf.allies_in_sight(short_sighted)
expected = {in_sight: 3, also_in_sight: 3}
self.assertEqual(answer, expected)
def test_enemies_in_sight_answer_excludes_non_enemies(self):
all_units = self.a_units + self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[3]
self.assertEqual(test_unit.get_sight_range(), 10)
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.enemies_in_sight(test_unit)
expected = {self.a_units[0]: 6, self.a_units[1]: 4, self.a_units[2]: 2}
self.assertEqual(answer, expected)
def test_enemies_in_sight_no_enemies(self):
all_units = self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[2]
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.enemies_in_sight(test_unit)
self.assertEqual(answer, {})
def test_enemies_in_sight_by_obstructed_view(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): 1, Point(2, 0): 0}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin = self.a_units[0]
in_sight, out_of_sight = self.b_units[0:2]
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(in_sight, Point(1, 0))
the_map.place_unit(out_of_sight, Point(2, 0))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.enemies_in_sight(origin)
expected = {
in_sight: 1,
}
self.assertEqual(answer, expected)
def test_enemies_in_sight_by_sight_range(self):
origin = self.a_units[0]
in_sight, out_of_sight = self.b_units[0:2]
self.map.place_unit(origin, Point(0, 0))
self.map.place_unit(in_sight, Point(10, 0))
self.map.place_unit(out_of_sight, Point(11, 0))
tf = TargetFinder(self.map, [self.team_a, self.team_b])
answer = tf.enemies_in_sight(origin)
expected = {
in_sight: 10,
}
self.assertEqual(answer, expected)
self.map.remove_unit(Point(10, 0))
self.map.remove_unit(Point(11, 0))
self.map.place_unit(in_sight, Point(5, 5))
self.map.place_unit(out_of_sight, Point(5, 6))
answer = tf.enemies_in_sight(origin)
self.assertEqual(answer, expected)
def test_enemies_in_sight_different_sight_range(self):
class NewSoldier(Soldier):
def get_sight_range(self):
return 3
short_sighted = NewSoldier()
self.team_a.add_player(short_sighted)
in_sight, also_in_sight, out_of_sight = self.b_units
self.map.place_unit(short_sighted, Point(0, 0))
self.map.place_unit(in_sight, Point(3, 0))
self.map.place_unit(also_in_sight, Point(2, 1))
self.map.place_unit(out_of_sight, Point(4, 0))
tf = TargetFinder(self.map, [self.team_a, self.team_b])
answer = tf.enemies_in_sight(short_sighted)
expected = {in_sight: 3, also_in_sight: 3}
self.assertEqual(answer, expected)
def test_allies_in_range_answer_excludes_non_allies(self):
all_units = self.a_units + self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[0]
test_unit.equip_weapon(RangedWeapon(10, 10, 10, 10))
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.allies_in_range(test_unit)
expected = {self.a_units[1]: (2, 0), self.a_units[2]: (4, 0)}
self.assertEqual(answer, expected)
def test_allies_in_range_no_allies(self):
all_units = self.a_units[0:1] + self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[0]
test_unit.equip_weapon(RangedWeapon(10, 10, 10, 10))
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.allies_in_range(test_unit)
self.assertEqual(answer, {})
def test_allies_in_range_by_obstructed_view(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): 1, Point(2, 0): 0}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin, in_range, out_of_sight = self.a_units
origin.equip_weapon(RangedWeapon(10, 10, 10, 10))
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(in_range, Point(1, 0))
the_map.place_unit(out_of_sight, Point(2, 0))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_range(origin)
expected = {
in_range: (1, -1),
}
self.assertEqual(answer, expected)
def test_allies_in_range_by_weapon_range(self):
origin, in_range, out_of_range = self.a_units
for weapon_range in range(1, 5):
self.map.remove_all_units()
self.map.place_unit(origin, Point(0, 0))
self.map.place_unit(in_range, Point(weapon_range, 0))
self.map.place_unit(out_of_range, Point(weapon_range + 1, 0))
tf = TargetFinder(self.map, [self.team_a, self.team_b])
origin.equip_weapon(RangedWeapon(1, 1, weapon_range, 1))
answer = tf.allies_in_range(origin)
expected = {
in_range: (weapon_range, 0),
}
self.assertEqual(answer, expected)
def test_allies_in_range_advantage(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): -1, Point(2, 0): 1}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin, below, above = self.a_units
origin.equip_weapon(RangedWeapon(10, 10, 10, 10))
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(below, Point(1, 0))
the_map.place_unit(above, Point(2, 0))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_range(origin)
expected = {below: (1, 1), above: (2, -1)}
self.assertEqual(answer, expected)
def test_allies_in_range_melee_weapon(self):
points_to_elevation = {
Point(1, 0): -3,
Point(0, 1): 4,
Point(1, 1): 0,
Point(2, 1): -4,
Point(1, 2): 3
}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 3, tiles)
origin, below, above = self.a_units
far_below = Soldier()
far_above = Soldier()
self.team_a.add_player(far_above)
self.team_a.add_player(far_below)
origin.equip_weapon(MeleeWeapon(10, 10, 10, 10))
the_map.place_unit(origin, Point(1, 1))
the_map.place_unit(below, Point(1, 0))
the_map.place_unit(above, Point(1, 2))
the_map.place_unit(far_above, Point(0, 1))
the_map.place_unit(far_below, Point(2, 1))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.allies_in_range(origin)
expected = {below: (1, 1), above: (1, -1)}
self.assertEqual(answer, expected)
def test_enemies_in_range_answer_excludes_non_enemies(self):
all_units = self.a_units + self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[3]
test_unit.equip_weapon(RangedWeapon(10, 10, 10, 10))
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.enemies_in_range(test_unit)
expected = {
self.a_units[0]: (6, 0),
self.a_units[1]: (4, 0),
self.a_units[2]: (2, 0)
}
self.assertEqual(answer, expected)
def test_enemies_in_range_no_enemies(self):
all_units = self.b_units
for index, unit in enumerate(all_units):
self.map.place_unit(unit, Point(index, index))
test_unit = all_units[2]
teams = [self.team_a, self.team_b]
test = TargetFinder(self.map, teams)
answer = test.enemies_in_range(test_unit)
self.assertEqual(answer, {})
def test_enemies_in_range_by_obstructed_view(self):
points_to_elevation = {Point(0, 0): 0, Point(1, 0): 1, Point(2, 0): 0}
tiles = [
Tile(elevation=elevation, point=point)
for point, elevation in points_to_elevation.items()
]
the_map = Map(3, 1, tiles)
origin = self.a_units[0]
in_range, out_of_range = self.b_units[0:2]
the_map.place_unit(origin, Point(0, 0))
the_map.place_unit(in_range, Point(1, 0))
the_map.place_unit(out_of_range, Point(2, 0))
origin.equip_weapon(RangedWeapon(10, 10, 1, 1))
tf = TargetFinder(the_map, [self.team_a, self.team_b])
answer = tf.enemies_in_range(origin)
expected = {
in_range: (1, -1),
}
self.assertEqual(answer, expected)
def test_enemies_in_range_by_weapon_range(self):
origin = self.a_units[0]
in_range, out_of_range = self.b_units[0:2]
self.map.place_unit(origin, Point(0, 0))
self.map.place_unit(in_range, Point(10, 0))
self.map.place_unit(out_of_range, Point(11, 0))
origin.equip_weapon(RangedWeapon(10, 10, 10, 10))
tf = TargetFinder(self.map, [self.team_a, self.team_b])
answer = tf.enemies_in_range(origin)
expected = {
in_range: (10, 0),
}
self.assertEqual(answer, expected)
self.map.remove_unit(Point(10, 0))
self.map.remove_unit(Point(11, 0))
self.map.place_unit(in_range, Point(5, 5))
self.map.place_unit(out_of_range, Point(5, 6))
answer = tf.enemies_in_range(origin)
self.assertEqual(answer, expected)
class TestTeam(unittest.TestCase):
def setUp(self):
tiles = [Tile() for _ in range(9)]
self.map = Map(3, 3, tiles)
self.team = Team(Point(1, 1), self.map)
def test_init(self):
tiles = [Tile() for _ in range(9)]
the_map = Map(3, 3, tiles)
team = Team(Point(0, 0), the_map)
self.assertEqual(team.deployed, [])
self.assertEqual(team.undeployed, [])
self.assertEqual(team.home, Point(0, 0))
def test_deployed_and_undeployed_returns_a_copy(self):
x = self.team.undeployed
x.append(123)
self.assertEqual(self.team.undeployed, [])
x = self.team.deployed
x.append(123)
self.assertEqual(self.team.deployed, [])
def test_add_player(self):
unit = Soldier()
self.team.add_player(unit)
self.assertEqual(self.team.undeployed, [unit])
def test_add_player_dupe(self):
unit = Soldier()
self.team.add_player(unit)
self.team.add_player(unit)
self.assertEqual(self.team.undeployed, [unit])
def test_add_player_multiple_players(self):
unit = Soldier()
unit_2 = Soldier()
self.team.add_player(unit)
self.team.add_player(unit_2)
self.assertEqual(self.team.undeployed, [unit, unit_2])
def test_unteam_player_undeployed(self):
unit = Soldier()
unit_2 = Soldier()
self.team.add_player(unit)
self.team.add_player(unit_2)
self.team.unteam_player(unit)
self.assertEqual(self.team.undeployed, [unit_2])
def test_unteam_player_deployed(self):
unit = Soldier()
unit_2 = Soldier()
self.team.add_player(unit)
self.team.add_player(unit_2)
self.team.spawn()
self.team.spawn()
self.team.unteam_player(unit)
self.assertEqual(self.team.deployed, [unit_2])
def test_unteam_player_not_in_team(self):
unit = Soldier()
self.assertRaises(ValueError, self.team.unteam_player, unit)
def test_is_on_team_true(self):
unit = Soldier()
self.team.add_player(unit)
self.assertTrue(self.team.is_on_team(unit))
self.team.spawn()
self.assertTrue(self.team.is_on_team(unit))
def test_is_on_team_false(self):
unit = Soldier()
self.team.add_player(unit)
self.assertFalse(self.team.is_on_team(Soldier()))
def test_spawn(self):
units = [Soldier(), Soldier(), Soldier()]
for soldier in units:
self.team.add_player(soldier)
for _ in range(3):
self.team.spawn()
self.assertEqual(self.map.get_unit(Point(1, 0)), units[0])
self.assertEqual(self.map.get_unit(Point(0, 1)), units[1])
self.assertEqual(self.map.get_unit(Point(2, 1)), units[2])
self.assertRaises(ValueError, self.team.spawn)
def test_spawn_uses_undeployed_as_a_queue(self):
units = [Soldier(), Soldier(), Soldier()]
for soldier in units:
self.team.add_player(soldier)
self.assertEqual(self.team.undeployed, units)
self.team.spawn()
self.assertEqual(self.team.undeployed, units[1:])
self.assertEqual(self.team.deployed, units[0:1])
self.team.spawn()
self.assertEqual(self.team.undeployed, units[2:])
self.assertEqual(self.team.deployed, units[0:2])
self.team.spawn()
self.assertEqual(self.team.undeployed, [])
self.assertEqual(self.team.deployed, units)
def test_spawn_no_unplaced_players(self):
unit = Soldier()
self.team.add_player(unit)
self.team.spawn()
self.assertRaises(ValueError, self.team.spawn)
def test_spawn_no_room_on_map(self):
units = [Soldier() for _ in range(10)]
for soldier in units:
self.team.add_player(soldier)
for _ in range(8):
self.team.spawn()
self.assertRaises(ValueError, self.team.spawn)
def test_spawn_with_obstacles_at_distance_one(self):
obstacles = self.team.home.at_distance(1)
for point in obstacles:
self.map.place_unit(Soldier(), point)
units = [Soldier() for _ in range(3)]
for soldier in units:
self.team.add_player(soldier)
for _ in range(len(units)):
self.team.spawn()
expected_points = [Point(0, 0), Point(2, 0), Point(0, 2)]
for soldier, point in zip(units, expected_points):
self.assertEqual(self.map.get_unit(point), soldier)
def test_spawn_with_obstacles_some_at_distance_one_and_some_at_distance_two(
self):
obstacles = [Point(1, 0), Point(0, 1), Point(0, 0), Point(2, 2)]
for point in obstacles:
self.map.place_unit(Soldier(), point)
units = [Soldier() for _ in range(3)]
for soldier in units:
self.team.add_player(soldier)
for _ in range(len(units)):
self.team.spawn()
expected_points = [Point(2, 1), Point(1, 2), Point(2, 0)]
for soldier, point in zip(units, expected_points):
self.assertEqual(self.map.get_unit(point), soldier)
def test_spawn_return_value(self):
unit = Soldier()
self.team.add_player(unit)
self.assertEqual(self.team.spawn(), (unit, Point(1, 0)))
def test_place_unit_and_then_spawn_raises_error(self):
unit = Soldier()
self.team.add_player(unit)
self.map.place_unit(unit, Point(1, 0))
self.assertRaises(MapPlacementError, self.team.spawn)
class TestMap(unittest.TestCase):
def setUp(self):
self.unit = Soldier()
self.width = 5
self.height = 3
self.tiles = get_tiles_without_points(self.width, self.height)
self.map = Map(self.width, self.height, self.tiles)
def test_init_pointless_tiles(self):
for point in Point(0, 0).to_rectangle(5, 3):
self.assertIs(self.map.get_tile(point), self.tiles.pop(0))
def test_init_pointed_tiles(self):
width = 5
height = 3
tiles = get_tiles_with_points(width, height)
test_map = Map(width, height, tiles)
for point in Point(0, 0).to_rectangle(width, height):
self.assertIs(test_map.get_tile(point), tiles.pop(0))
def test_init_mixed_tiles(self):
width = 2
height = 2
tiles = [Tile(point=Point(0, 0)), Tile(), Tile(), Tile(point=Point(1, 1))]
self.assertFalse(tiles[1].has_point())
test_map = Map(width, height, tiles)
for tile in tiles:
self.assertTrue(tile.has_point())
for point in Point(0, 0).to_rectangle(width, height):
self.assertIs(test_map.get_tile(point), tiles.pop(0))
def test_init_raises_error_point_outside_map(self):
tiles = get_tiles_with_points(1, 3)
self.assertRaises(MapPlacementError, Map, 2, 2, tiles)
def test_init_raises_error_two_tiles_same_point(self):
tiles = [Tile(point=Point(0, 0)), Tile(point=Point(0, 0))]
self.assertRaises(MapPlacementError, Map, 2, 2, tiles)
def test_init_raises_error_if_more_tiles_than_points(self):
tiles = get_tiles_without_points(5, 5)
self.assertRaises(MapPlacementError, Map, 2, 2, tiles)
def test_init_if_tiles_do_not_fill_points(self):
tiles = get_tiles_without_points(3, 2)
test_map = Map(3, 3, tiles)
for point in Point(0, 0).to_rectangle(3, 2):
self.assertIs(test_map.get_tile(point), tiles.pop(0))
for point in Point(0, 2).to_rectangle(3, 1):
self.assertFalse(test_map.has_tile(point))
def test_get_size(self):
to_test = Map(3, 5, [])
self.assertEqual(to_test.get_size(), (3, 5))
def test_get_elevation(self):
elevations = {Point(0, 0): 1, Point(1, 0): 2,
Point(0, 1): -1, Point(1, 1): 0}
tiles = [Tile(point=point, elevation=elevation) for point, elevation in elevations.items()]
map_ = Map(2, 2, tiles)
self.assertEqual(map_.get_elevation(Point(0, 0)), 1)
self.assertEqual(map_.get_elevation(Point(1, 0)), 2)
self.assertEqual(map_.get_elevation(Point(0, 1)), -1)
self.assertEqual(map_.get_elevation(Point(1, 1)), 0)
def test_get_elevation_empty_tile_and_not_on_map(self):
elevations = {Point(0, 0): 1, Point(1, 0): 2,
Point(0, 1): -1, }
tiles = [Tile(point=point, elevation=elevation) for point, elevation in elevations.items()]
map_ = Map(2, 2, tiles)
self.assertEqual(map_.get_elevation(Point(1, 1)), float('-inf'))
self.assertEqual(map_.get_elevation(Point(-1, -1)), float('-inf'))
def test_is_on_map_true(self):
points = Point(0, 0).to_rectangle(self.width, self.height)
for point in points:
self.assertTrue(self.map.is_on_map(point))
def test_is_on_map_false(self):
points = [Point(-1, -1), Point(5, 5), Point(1, 10), Point(10, 1)]
for point in points:
self.assertFalse(self.map.is_on_map(point))
def test_has_tile_off_map(self):
self.assertFalse(self.map.has_tile(Point(-1, -1)))
def test_has_tile_empty_map_point(self):
self.assertFalse(Map(2, 2, []).has_tile(Point(0, 0)))
def test_has_tile_true(self):
self.assertTrue(self.map.has_tile(Point(0, 0)))
def test_get_tile(self):
self.assertIs(self.map.get_tile(Point(0, 0)), self.tiles[0])
def test_get_tile_none(self):
self.assertIsNone(Map(2, 2, []).get_tile(Point(1, 1)))
def test_can_place_unit_true(self):
self.assertTrue(self.map.can_place_unit(Point(1, 1)))
def test_can_place_unit_false_by_not_on_map(self):
self.assertFalse(self.map.can_place_unit(Point(10, 1)))
def test_can_place_unit_false_by_no_tile(self):
self.assertFalse(Map(2, 2, []).can_place_unit(Point(1, 1)))
def test_can_place_unit_false_by_occupied_by_unit(self):
self.map.place_unit(self.unit, Point(1, 1))
self.assertFalse(self.map.can_place_unit(Point(1, 1)))
def test_get_unit_is_none_when_no_unit(self):
self.assertIsNone(self.map.get_unit(Point(1, 1)))
def test_get_unit(self):
unit = Soldier()
point = Point(1, 1)
self.map.place_unit(unit, point)
self.assertIs(unit, self.map.get_unit(point))
self.assertIsNone(self.map.get_unit(Point(0, 0)))
def test_get_point(self):
self.map.place_unit(self.unit, Point(0, 0))
self.assertEqual(self.map.get_point(self.unit), Point(0, 0))
self.map.remove_unit(Point(0, 0))
self.map.place_unit(self.unit, Point(0, 1))
self.assertEqual(self.map.get_point(self.unit), Point(0, 1))
def test_get_point_none(self):
self.assertEqual(self.map.get_point(self.unit), None)
def test_place_unit_error_by_not_on_map(self):
self.assertRaises(MapPlacementError, self.map.place_unit, self.unit, Point(10, 1))
def test_place_unit_error_by_no_tile(self):
test_map = Map(2, 2, [])
self.assertRaises(MapPlacementError, test_map.place_unit, self.unit, Point(1, 1))
def test_place_unit_error_by_occupied_by_unit(self):
unit_2 = Soldier()
self.map.place_unit(self.unit, Point(1, 1))
self.assertRaises(MapPlacementError, self.map.place_unit, unit_2, Point(1, 1))
def test_place_unit_error_by_unit_placed_twice(self):
self.map.place_unit(self.unit, Point(0, 0))
self.assertRaises(MapPlacementError, self.map.place_unit, self.unit, Point(1, 2))
def test_place_unit(self):
self.map.place_unit(self.unit, Point(1, 1))
self.assertIs(self.map.get_unit(Point(1, 1)), self.unit)
self.assertEqual(self.map.get_point(self.unit), Point(1, 1))
def test_has_unit_point_not_on_map_false(self):
self.assertFalse(self.map.has_unit(Point(-1, -1)))
def test_has_unit_false(self):
self.assertFalse(self.map.has_unit(Point(1, 1)))
def test_has_unit_true(self):
self.map.place_unit(Soldier(), Point(1, 1))
self.assertTrue(self.map.has_unit(Point(1, 1)))
self.assertFalse(self.map.has_unit(Point(2, 1)))
def test_remove_unit(self):
self.map.place_unit(self.unit, Point(1, 1))
self.map.remove_unit(Point(1, 1))
self.assertTrue(self.map.can_place_unit(Point(1, 1)))
self.assertEqual(self.map.get_point(self.unit), None)