def test_alternate_path(self, zombie):
environment = [
(Vector(2, 2), default_human()),
(Vector(1, 1), default_zombie()),
(Vector(1, 0), default_zombie()),
]
limits = BoundingBox(Vector(-100, -100), Vector(100, 100))
assert zombie.move(FakeViewpoint(environment), limits) == Vector(0, 1)
def test_chooses_shortest_best_move(self):
target_vectors = TargetVectors(
FakeViewpoint([(Vector(1, 2), default_zombie())]))
moves = [Vector.ZERO, Vector(1, 0), Vector(2, 0)]
assert Living().best_move(target_vectors, moves) == Vector.ZERO
# To make sure we're not lucking out based on the order
assert Living().best_move(target_vectors,
list(reversed(moves))) == Vector.ZERO
def test_zombie_approaches_human(self):
zombie = default_zombie()
human = default_human()
characters = {Point(0, 0): zombie, Point(2, 2): human}
area = Area(Point(0, 0), Point(3, 3))
roster = Roster.partitioned(characters,
area=area,
partition_func=LifeState.for_character)
roster = Tick(roster).next()
assert sorted(roster.positions) == [(Point(1, 1), zombie),
(Point(2, 2), human)]
def test_movement_with_zombies(self, zombie_vectors, moves):
target_vectors = TargetVectors(
FakeViewpoint([(v, default_zombie()) for v in zombie_vectors]))
best_move = Living().best_move(target_vectors, moves)
def distance_after_move(move):
return min((zombie - move).distance for zombie in zombie_vectors)
best_move_distance = distance_after_move(best_move)
note(f"Best distance, after {best_move}: {best_move_distance}")
for move in moves:
move_distance = distance_after_move(move)
note(f"Distance after {move}: {move_distance}")
assert all(best_move_distance >= distance_after_move(move)
for move in moves)
def env_contents(vector):
return default_zombie() if vector else zombie
def zombie(self):
return default_zombie()