wolf-sheep

Author: quaquel

examples/wolf_sheep/wolf_sheep/agents.py

@@ -1,93 +1,83 @@
 import mesa
 
-from .random_walk import RandomWalker
+from mesa.experimental.cell_space import CellAgent, FixedAgent
 
 
-class Sheep(RandomWalker):
-    """
-    A sheep that walks around, reproduces (asexually) and gets eaten.
-
-    The init is the same as the RandomWalker.
-    """
+class Animal(CellAgent):
+    """The base animal class."""
 
-    energy = None
+    def __init__(self, model, energy, p_reproduce, energy_from_food, cell):
+        """Initializes an animal.
 
-    def __init__(self, model, moore, energy=None):
-        super().__init__(model, moore=moore)
+        Args:
+            model: a model instance
+            energy: starting amount of energy
+            p_reproduce: probability of sexless reproduction
+            energy_from_food: energy obtained from 1 unit of food
+            cell: the cell in which the animal starts
+        """
+        super().__init__(model)
         self.energy = energy
+        self.p_reproduce = p_reproduce
+        self.energy_from_food = energy_from_food
+        self.cell = cell
+
+    def spawn_offspring(self):
+        """Create offspring."""
+        self.energy /= 2
+        self.__class__(
+            self.model,
+            self.energy,
+            self.p_reproduce,
+            self.energy_from_food,
+            self.cell,
+        )
+
+    def feed(self): ...  # noqa: D102
 
     def step(self):
-        """
-        A model step. Move, then eat grass and reproduce.
-        """
-        self.random_move()
-        living = True
-
-        if self.model.grass:
-            # Reduce energy
-            self.energy -= 1
-
-            # If there is grass available, eat it
-            this_cell = self.model.grid.get_cell_list_contents([self.pos])
-            grass_patch = next(obj for obj in this_cell if isinstance(obj, GrassPatch))
-            if grass_patch.fully_grown:
-                self.energy += self.model.sheep_gain_from_food
-                grass_patch.fully_grown = False
+        """One step of the agent."""
+        self.cell = self.cell.neighborhood.select_random_cell()
+        self.energy -= 1
 
-            # Death
-            if self.energy < 0:
-                self.model.grid.remove_agent(self)
-                self.remove()
-                living = False
+        self.feed()
 
-        if living and self.random.random() < self.model.sheep_reproduce:
-            # Create a new sheep:
-            if self.model.grass:
-                self.energy /= 2
-            lamb = Sheep(self.model, self.moore, self.energy)
-            self.model.grid.place_agent(lamb, self.pos)
+        if self.energy < 0:
+            self.remove()
+        elif self.random.random() < self.p_reproduce:
+            self.spawn_offspring()
 
 
-class Wolf(RandomWalker):
-    """
-    A wolf that walks around, reproduces (asexually) and eats sheep.
-    """
+class Sheep(Animal):
+    """A sheep that walks around, reproduces (asexually) and gets eaten."""
 
-    energy = None
+    def feed(self):
+        """If possible eat the food in the current location."""
+        # If there is grass available, eat it
+        if self.model.grass:
+            grass_patch = next(
+                obj for obj in self.cell.agents if isinstance(obj, GrassPatch)
+            )
+            if grass_patch.fully_grown:
+                self.energy += self.energy_from_food
+                grass_patch.fully_grown = False
 
-    def __init__(self, model, moore, energy=None):
-        super().__init__(model, moore=moore)
-        self.energy = energy
 
-    def step(self):
-        self.random_move()
-        self.energy -= 1
+class Wolf(Animal):
+    """A wolf that walks around, reproduces (asexually) and eats sheep."""
 
-        # If there are sheep present, eat one
-        x, y = self.pos
-        this_cell = self.model.grid.get_cell_list_contents([self.pos])
-        sheep = [obj for obj in this_cell if isinstance(obj, Sheep)]
+    def feed(self):
+        """If possible eat the food in the current location."""
+        sheep = [obj for obj in self.cell.agents if isinstance(obj, Sheep)]
         if len(sheep) > 0:
             sheep_to_eat = self.random.choice(sheep)
-            self.energy += self.model.wolf_gain_from_food
+            self.energy += self.energy_from_food
 
             # Kill the sheep
-            self.model.grid.remove_agent(sheep_to_eat)
             sheep_to_eat.remove()
 
-        # Death or reproduction
-        if self.energy < 0:
-            self.model.grid.remove_agent(self)
-            self.remove()
-        else:
-            if self.random.random() < self.model.wolf_reproduce:
-                # Create a new wolf cub
-                self.energy /= 2
-                cub = Wolf(self.model, self.moore, self.energy)
-                self.model.grid.place_agent(cub, self.pos)
-
 
-class GrassPatch(mesa.Agent):
+class GrassPatch(FixedAgent):
     """
     A patch of grass that grows at a fixed rate and it is eaten by sheep
     """

examples/wolf_sheep/wolf_sheep/model.py

@@ -10,10 +10,12 @@
 """
 
 import mesa
+from  mesa.experimental.cell_space import OrthogonalMooreGrid
 
 from .agents import GrassPatch, Sheep, Wolf
 
 
+
 class WolfSheep(mesa.Model):
     """
     Wolf-Sheep Predation Model
@@ -50,6 +52,7 @@ def __init__(
         grass=False,
         grass_regrowth_time=30,
         sheep_gain_from_food=4,
+        seed=None
     ):
         """
         Create a new Wolf-Sheep model with the given parameters.
@@ -65,20 +68,16 @@ def __init__(
                                  once it is eaten
             sheep_gain_from_food: Energy sheep gain from grass, if enabled.
         """
-        super().__init__()
+        super().__init__(seed=None)
         # Set parameters
         self.width = width
         self.height = height
         self.initial_sheep = initial_sheep
         self.initial_wolves = initial_wolves
-        self.sheep_reproduce = sheep_reproduce
-        self.wolf_reproduce = wolf_reproduce
-        self.wolf_gain_from_food = wolf_gain_from_food
         self.grass = grass
         self.grass_regrowth_time = grass_regrowth_time
-        self.sheep_gain_from_food = sheep_gain_from_food
 
-        self.grid = mesa.space.MultiGrid(self.width, self.height, torus=True)
+        self.grid = OrthogonalMooreGrid((self.width, self.height), torus=True)
 
         collectors = {
             "Wolves": lambda m: len(m.agents_by_type[Wolf]),
@@ -95,20 +94,18 @@ def __init__(
             x = self.random.randrange(self.width)
             y = self.random.randrange(self.height)
             energy = self.random.randrange(2 * self.sheep_gain_from_food)
-            sheep = Sheep(self, True, energy)
-            self.grid.place_agent(sheep, (x, y))
+            Sheep(self, energy, sheep_reproduce, sheep_gain_from_food, self.grid[(x,y)])
 
         # Create wolves
         for _ in range(self.initial_wolves):
             x = self.random.randrange(self.width)
             y = self.random.randrange(self.height)
             energy = self.random.randrange(2 * self.wolf_gain_from_food)
-            wolf = Wolf(self, True, energy)
-            self.grid.place_agent(wolf, (x, y))
+            Wolf(self, energy, wolf_reproduce, wolf_gain_from_food, self.grid[(x,y)])
 
         # Create grass patches
         if self.grass:
-            for agent, (x, y) in self.grid.coord_iter():
+            for cell in self.grid.all_cells:
                 fully_grown = self.random.choice([True, False])
 
                 if fully_grown:
@@ -117,7 +114,7 @@ def __init__(
                     countdown = self.random.randrange(self.grass_regrowth_time)
 
                 patch = GrassPatch(self, fully_grown, countdown)
-                self.grid.place_agent(patch, (x, y))
+                patch.cell = cell
 
         self.running = True
         self.datacollector.collect(self)
@@ -128,7 +125,7 @@ def step(self):
         # Conceptually, it can be argued that this should be modelled differently.
         self.random.shuffle(self.agent_types)
         for agent_type in self.agent_types:
-            self.agents_by_type[agent_type].do("step")
+            self.agents_by_type[agent_type].shuffle_do("step")
 
         # collect data
         self.datacollector.collect(self)