def test_neighbour_function(self):
# full neighborhood
neigh_list = square_grid_neighbours(10, SquareGridCoordinate(1, 1))
assert len(neigh_list) == 8
# corner
neigh_list = square_grid_neighbours(10, SquareGridCoordinate(9, 9))
assert len(neigh_list) == 3
# line
neigh_list = square_grid_neighbours(10, SquareGridCoordinate(0, 5))
assert len(neigh_list) == 5
def test_neighbour_function(self):
# full neighborhood
neigh_list = square_grid_neighbours(10, SquareGridCoordinate(1, 1))
assert len(neigh_list) == 8
# corner
neigh_list = square_grid_neighbours(10, SquareGridCoordinate(9, 9))
assert len(
neigh_list
) == 8 # Used to work fine. Changed from 3, since now we have 'infinite' grid
# line
neigh_list = square_grid_neighbours(10, SquareGridCoordinate(0, 5))
assert len(
neigh_list
) == 8 # Used to work fine. Changed from 5, since now we have 'infinite' grid
def _eat(self) -> Dict[int, SquareGridCoordinate]:
"""
Sharks that are adjacent to a Fish square eat and move into fish square (and do not move after)
:return: list[(oid, prev_coordinate)]
"""
_debug = 'Turn: {:<3} - Eat - '.format(self._sim_turn)
simulation_params = self.get_simulation_parameters(self._sid)
# get a randomized df of all sharks
sharks = self._persistence.get_animals_by_type(
sim_id=self._sid, animal_type=Animal.Shark).sample(frac=1)
sharks_eating = dict()
shark_update = dict()
for idx, shark in sharks.iterrows():
# get shark neighbour square
shark_position = SquareGridCoordinate(shark.coord_x, shark.coord_y)
shark_neighbour = square_grid_neighbours(
simulation_params.grid_size, shark_position)
# try to find fish
has_fish = self._persistence.has_fish_in_square(
sim_id=self._sid, coordinates=shark_neighbour)
if len(has_fish) > 0:
# Shark is eating
random.shuffle(has_fish)
eating_coord = has_fish[0]
if self._persistence.eat_animal_in_square(
sim_id=self._sid, coordinate=eating_coord):
_logger.debug('{}Shark {} {} eat Fish {} and move'.format(
_debug, shark.oid, shark_position, eating_coord))
# keep shark ref and position
sharks_eating[shark.oid] = shark_position
# move shark to eating position
self._persistence.move_animal(sim_id=self._sid,
animal_id=shark.oid,
new_position=eating_coord)
# add to update dictionary
shark_update[shark.oid] = {'last_fed': self._sim_turn}
else:
raise ImpossibleAction(
'Something went wrong in Shark: {} feeding in {}'.
format(shark, has_fish[0]))
else:
_logger.debug('{}turn: {}, No fish to eat for shark {}'.format(
_debug, self._sim_turn, shark.oid))
self._persistence.update_animals(sim_id=self._sid,
update_dict=shark_update)
_logger.debug('{}{} sharks have eaten'.format(_debug,
len(sharks_eating)))
return sharks_eating
def test_animal_function(self):
client = SimulationClient('sqlite:///:memory:')
# init DB
sid = client.init_simulation(**sim_config)
# add a bunch of animals
a_list = [(Animal.Fish, SquareGridCoordinate(x=1, y=1)),
(Animal.Fish, SquareGridCoordinate(x=2, y=1)),
(Animal.Fish, SquareGridCoordinate(x=3, y=1)),
(Animal.Fish, SquareGridCoordinate(x=1, y=3)),
(Animal.Fish, SquareGridCoordinate(x=3, y=2))]
for t, c in a_list:
client.init_animal(sim_id=sid,
current_turn=0,
animal_type=t,
coordinate=c)
coord_list = client.has_fish_in_square(
sim_id=sid, coordinates=[SquareGridCoordinate(1, 1)])
assert len(coord_list) == 1, 'There should be a single fish'
coord_list = client.has_fish_in_square(
sim_id=sid, coordinates=[SquareGridCoordinate(1, 2)])
assert len(coord_list) == 0, 'There should be no fish here'
neigh = square_grid_neighbours(grid_size=10,
coordinate=SquareGridCoordinate(2, 2))
coord_list = client.has_fish_in_square(sim_id=sid, coordinates=neigh)
assert len(coord_list) == 5, 'There should be 5 fishes here'
# eating animals
eaten = client.eat_animal_in_square(sim_id=sid,
coordinate=SquareGridCoordinate(
1, 1))
assert eaten, 'Fish in 1, 1 should have been eaten'
# can't eat dead Fish
eaten = client.eat_animal_in_square(sim_id=sid,
coordinate=SquareGridCoordinate(
1, 1))
assert not eaten, 'Should not be able to eat a dead Fish'
client.init_animal(sim_id=sid,
current_turn=0,
animal_type=Animal.Shark,
coordinate=SquareGridCoordinate(5, 5))
eaten = client.eat_animal_in_square(sim_id=sid,
coordinate=SquareGridCoordinate(
5, 5))
assert not eaten, 'Should not be able to eat a Shark'
def _move_animal_type(self, animal_type: Animal, already_moved: List[int]):
"""
Perform move action for a type of animal
:param animal_type:
:param already_moved:
:return:
"""
_debug = 'Turn: {:<3} - Move - '.format(self._sim_turn)
simulation_params = self.simulation_params
animals = self._persistence.get_animals_by_type(sim_id=self._sid, animal_type=animal_type).sample(frac=1)
for _, animal in animals.iterrows():
if animal.oid in already_moved:
# this one has already moved so not moving
_logger.debug('{}{} already moved'.format(_debug, animal.oid))
continue
elif animal.spawn_turn == self._sim_turn:
# fish was just spawn, not moving
_logger.debug('{}{} just spawned'.format(_debug, animal.oid))
continue
else:
neighbors = square_grid_neighbours(simulation_params.grid_size, SquareGridCoordinate(animal.coord_x,
animal.coord_y))
for neigh in neighbors:
if not self.check_if_occupied(neigh):
# move animal to this slot
# set occupation flag to False
occupation_flag = False
_logger.debug('{}{} moved to {}'.format(_debug, animal_type.name, neigh))
coord_to_remove = self._persistence.move_animal(sim_id=self._sid, animal_id=animal.oid,
new_position=neigh, occupied=occupation_flag)
self.update_occupied_coord(old_coord=coord_to_remove, new_coord=(neigh.x, neigh.y))
# set back to None
occupation_flag = None
# break # AM: why we don't have break here?! Seems like we are making unnecessary operations
else:
_logger.debug('{}{}: {} had no space to move to'.format(_debug, animal_type.name, animal.oid))
return
def _move_animal_type(self, animal_type: Animal, already_moved: List[int]):
"""
Perform move action for a type of animal
:param animal_type:
:param already_moved:
:return:
"""
_debug = 'Turn: {:<3} - Move - '.format(self._sim_turn)
simulation_params = self.get_simulation_parameters(self._sid)
animals = self._persistence.get_animals_by_type(
sim_id=self._sid, animal_type=animal_type).sample(frac=1)
for _, animal in animals.iterrows():
_logger.debug(animal)
if animal.oid in already_moved:
# this one has already moved so not moving
_logger.debug('{}{} already moved'.format(_debug, animal.oid))
continue
elif animal.spawn_turn == self._sim_turn:
# fish was just spawn, not moving
_logger.debug('{}{} just spawned'.format(_debug, animal.oid))
continue
else:
neighbors = square_grid_neighbours(
simulation_params.grid_size,
SquareGridCoordinate(animal.coord_x, animal.coord_y))
for neigh in neighbors:
if not self._persistence.coordinate_is_occupied(
self._sid, neigh):
# move animal to this slot
_logger.debug('{}{} oid[{}] moved to {}'.format(
_debug, animal_type.name, animal.oid, neigh))
self._persistence.move_animal(sim_id=self._sid,
animal_id=animal.oid,
new_position=neigh)
else:
_logger.debug(
'{}{}: {} had no space to move to'.format(
_debug, animal_type.name, animal.oid))
return
def _breed_and_move(
self, fed_sharks: Dict[int, SquareGridCoordinate]) -> List[int]:
"""
Sharks or Fish that can breed, do so in same square (and Move), others moves if free space
- Shark Breed first
- Then Fish
:parameter fed_sharks: list of sharks that fed and moved (breed, if possible, on previous position)
:return: return the list of animals that bred and moved
"""
# perform breed for
_debug = 'Turn: {:<3} - Breed - '.format(self._sim_turn)
simulation_params = self.get_simulation_parameters(self._sid)
moved = []
to_update = {}
# First for sharks
sharks = self._persistence.get_animals_by_type(
sim_id=self._sid, animal_type=Animal.Shark).sample(frac=1)
for idx, shark in sharks.iterrows():
# can shark breed?
if (self._sim_turn - shark.spawn_turn
) >= simulation_params.shark_breed_maturity:
# shark can breed
if random.randint(
0, 100) <= simulation_params.shark_breed_probability:
# shark is possibly breeding...
breed_coord = None
if shark.oid in fed_sharks:
# ...if shark has eaten...
breed_coord = fed_sharks[shark.oid]
if self._persistence.coordinate_is_occupied(
self._sid, breed_coord):
# someone took that space before breeding
_logger.debug(
'{}This shark {} breeding has fed and moved,' +
' cannot breed in {} because position is taken'
.format(_debug, shark.oid, breed_coord))
breed_coord = None
_logger.debug(
'{}This shark {} breeding has fed and moved, breeding in {}'
.format(_debug, shark.oid, breed_coord))
# shark has already moved to eating position
moved.append(shark.oid)
else:
# ... or if free space is available
neighbors = square_grid_neighbours(
simulation_params.grid_size,
SquareGridCoordinate(shark.coord_x, shark.coord_y))
for neigh in neighbors:
if not self._persistence.coordinate_is_occupied(
self._sid, neigh):
breed_coord = SquareGridCoordinate(
int(shark.coord_x), int(shark.coord_y))
# move shark to this slot
self._persistence.move_animal(
sim_id=self._sid,
animal_id=shark.oid,
new_position=neigh)
moved.append(shark.oid)
_logger.debug(
'{}Shark {} not fed breeding in {}, moving to {}'
.format(_debug, shark.oid, breed_coord,
neigh))
# break out of loop
break
if breed_coord is not None:
to_update[shark.oid] = {
'last_breed': self._sim_turn,
'breed_count': shark.breed_count + 1
}
# spawn new fish in breed_coord
new_oid = self._persistence.init_animal(
sim_id=self._sid,
current_turn=self._sim_turn,
animal_type=Animal.Shark,
coordinate=breed_coord)
_logger.debug('{}Spawning new shark {} {}'.format(
_debug, new_oid, breed_coord))
# Last Fishes, randomize
fishes = self._persistence.get_animals_by_type(
sim_id=self._sid, animal_type=Animal.Fish).sample(frac=1)
for idx, fish in fishes.iterrows():
# can fish breed?
if (self._sim_turn -
fish.spawn_turn) >= simulation_params.fish_breed_maturity:
# fish can breed
if random.randint(
0, 100) <= simulation_params.fish_breed_probability:
# fish is possibly breeding if free space is available
breed_coord = SquareGridCoordinate(int(fish.coord_x),
int(fish.coord_y))
_logger.debug(
'{}Fish breeding in {} if space is available'.format(
_debug, breed_coord))
neighbors = square_grid_neighbours(
simulation_params.grid_size,
SquareGridCoordinate(fish.coord_x, fish.coord_y))
for neigh in neighbors:
if not self._persistence.coordinate_is_occupied(
self._sid, neigh):
_logger.debug(
'{}Space found in {}, fish breed and move'.
format(_debug, neigh))
to_update[fish.oid] = {
'last_breed': self._sim_turn,
'breed_count': fish.breed_count + 1
}
# move fish to this slot
self._persistence.move_animal(sim_id=self._sid,
animal_id=fish.oid,
new_position=neigh)
moved.append(fish.oid)
# spawn new fish in breed_coord
self._persistence.init_animal(
sim_id=self._sid,
current_turn=self._sim_turn,
animal_type=Animal.Fish,
coordinate=breed_coord)
# break out of loop
break
# now, update all animals
if len(to_update) > 0:
_logger.debug('{}{} animals updated after breeding'.format(
_debug, len(to_update)))
self._persistence.update_animals(sim_id=self._sid,
update_dict=to_update)
# add shark that ate and did not breed to the moved list
for oid in fed_sharks.keys():
if oid not in moved:
_logger.debug('{}Shark {} did not breed after movin'.format(
_debug, oid))
moved.append(oid)
# return animal list that have already bred and moved
return moved
