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_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_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_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 is_higher_than_start_by_bounding_xs(self, start: Point,
finish: Point) -> bool:
slope = get_slope(start, finish)
for delta_y in get_deltas_between(start.y, finish.y):
delta_x_1 = floor(delta_y / slope)
delta_x_2 = ceil(delta_y / slope)
if self.map.get_elevation(start.plus(
delta_x_1, delta_y)) > self.map.get_elevation(start):
return True
if self.map.get_elevation(start.plus(
delta_x_2, delta_y)) > self.map.get_elevation(start):
return True
return False
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 is_higher_than_start_by_bounding_ys(self, start: Point,
finish: Point) -> bool:
"""
use floor and ceil
"""
slope = get_slope(start, finish)
for delta_x in get_deltas_between(start.x, finish.x):
delta_y_1 = floor(slope * delta_x)
delta_y_2 = ceil(slope * delta_x)
if self.map.get_elevation(start.plus(
delta_x, delta_y_1)) > self.map.get_elevation(start):
return True
if self.map.get_elevation(start.plus(
delta_x, delta_y_2)) > self.map.get_elevation(start):
return True
return False
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 get_all_usable_points(self, origin: Point, max_distance: int) -> Dict[int, List[Point]]:
distances_to_points = dict.fromkeys(range(max_distance + 1), [])
largest_map_distance = sum(self._map.get_size())
stop_checking_map = min(largest_map_distance, max_distance) + 1
for distance in range(stop_checking_map):
on_map_pts = [point for point in origin.at_distance(distance)
if self._map.is_on_map(point) and self._map.has_tile(point)]
distances_to_points[distance] = on_map_pts
return distances_to_points
def get_all_usable_points_units_only(self, origin: Point, max_distance: int) -> Dict[int, List[Point]]:
distances_to_points = {key: [] for key in range(max_distance+1)}
largest_map_distance = sum(self._map.get_size())
stop_checking_map = min(largest_map_distance, max_distance) + 1
for distance in range(stop_checking_map):
on_map_pts = [point for point in origin.at_distance(distance)
if self._map.has_unit(point)]
distances_to_points[distance] = on_map_pts
return distances_to_points
