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_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_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_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_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_direction_to_combination(self): start = Point(1, 2) end = Point(5, 0) answer = start.get_direction_to(end) self.assertEqual(answer, CompositeDirection(E, E, E, E, S, S)) magnitude = sqrt(20) self.assertAlmostEqual(answer.value[0], 4/magnitude, places=7) self.assertAlmostEqual(answer.value[1], -2/magnitude, places=7)
def test_set_point(self): tile = Tile() self.assertIsNone(tile.get_point()) self.assertFalse(tile.has_point()) tile.set_point(Point(1, 1)) self.assertEqual(tile.get_point(), Point(1, 1)) self.assertTrue(tile.has_point())
def test_get_slope_neg(self): point_1 = Point(1, 2) point_2 = Point(0, 4) slope = get_slope(point_1, point_2) self.assertEqual(slope, -2) point_1 = Point(2, 2) point_2 = Point(0, 3) slope = get_slope(point_1, point_2) self.assertEqual(slope, -0.5)
def test_get_slope_pos(self): point_1 = Point(1, 2) point_2 = Point(2, 4) slope = get_slope(point_1, point_2) self.assertEqual(slope, 2) point_1 = Point(1, 2) point_2 = Point(3, 3) slope = get_slope(point_1, point_2) self.assertEqual(slope, 0.5)
def test_get_movement_points_with_path_only_to_max_mv(self): map_ = Map(3, 3, [Tile() for _ in range(9)]) answer = MovementCalculator(map_).get_movement_points_with_path( Point(0, 0), 1) expected = { Point(0, 0): (0, []), Point(0, 1): (1, [N]), Point(1, 0): (1, [E]) } self.assertEqual(answer, expected)
def test_get_movement_points_only_includes_distances_on_map(self): map_ = Map(2, 2, [Tile() for _ in range(4)]) answer = MovementCalculator(map_).get_movement_points(Point(0, 0), 100) expected = { Point(0, 0): 0, Point(0, 1): 1, Point(1, 0): 1, Point(1, 1): 2 } self.assertEqual(answer, expected)
def test_generate_path_start_not_origin(self): start = Point(1, 2) the_path = list(start.generate_path([N, E, S, W])) expected = [Point(1, 3), Point(2, 3), Point(2, 2), Point(1, 2)] self.assertEqual(the_path, expected) start = Point(-1, -2) the_path = list(start.generate_path([N, E, S, W])) expected = [Point(-1, -1), Point(0, -1), Point(0, -2), Point(-1, -2)] self.assertEqual(the_path, expected)
def test_get_movement_points_with_path_chooses_smallest_move_pts_different_order( self): elevations = { Point(0, 0): 2, Point(1, 0): 0, 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) origin = Point(0, 1) expected = { Point(0, 0): (2, [S]), Point(1, 0): (2, [E, S]), # point(1, 0) has two different ways from 0,1 Point(0, 1): (0, []), Point(1, 1): (1, [E]) } # one way costs 2 and one way costs 3 self.assertEqual( MovementCalculator(map_).get_movement_points_with_path(origin, 10), expected)
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_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_at_distance_second_test(self): answer = Point(0, 0).at_distance(2) expected = [Point(0, -2), Point(-1, -1), Point(1, -1), Point(-2, 0), Point(2, 0), Point(-1, 1), Point(1, 1), Point(0, 2)] self.assertEqual(answer, expected)
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_get_movement_points_with_path_only_includes_distances_on_map( self): map_ = Map(2, 2, [Tile() for _ in range(4)]) answer = MovementCalculator(map_).get_movement_points_with_path( Point(0, 0), 100) expected = { Point(0, 0): (0, []), Point(0, 1): (1, [N]), Point(1, 0): (1, [E]), Point(1, 1): (2, [E, N]) } self.assertEqual(answer, expected)
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 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_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_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_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 __init__(self, width: int, height: int, tiles: List[Tile]): self._all_points = Point(0, 0).to_rectangle(width, height) self._tiles = dict.fromkeys(self._all_points, None) # type: Dict[Point, Tile] self._points_to_units = {} # type: Dict[Point, Soldier] self._units_to_points = {} # type: Dict[Soldier, Point] self._lay_tiles(tiles)
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_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_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_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_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_init_creates_empty_table_with_unique_sets(self): points = [ Point(0, 0), Point(1, 0), Point(2, 0), Point(0, 1), Point(1, 1), Point(2, 1) ] tiles = [Tile(point=pt) for pt in points] map_ = Map(3, 2, tiles) listener = PerimeterListener(map_) expected = {pt: set() for pt in points} self.assertEqual(listener._watchers_at_point, expected) listener._watchers_at_point[Point(0, 0)].add(1) self.assertEqual(listener._watchers_at_point[Point(1, 0)], set())