Add cell-centric discrete spaces (experimental)

benchmarks/Schelling/schelling.py

@@ -1,5 +1,5 @@
 from mesa import Agent, Model
-from mesa.space import SingleGrid
+from mesa.experimental.cell_space import Grid
 from mesa.time import RandomActivation
 
 
@@ -21,9 +21,7 @@ def __init__(self, unique_id, model, agent_type):
 
     def step(self):
         similar = 0
-        for neighbor in self.model.grid.iter_neighbors(
-            self.pos, moore=True, radius=self.model.radius
-        ):
+        for neighbor in self.cell.neighborhood().agents:
             if neighbor.type == self.type:
                 similar += 1
 
@@ -52,19 +50,19 @@ def __init__(
         self.radius = radius
 
         self.schedule = RandomActivation(self)
-        self.grid = SingleGrid(height, width, torus=True)
+        self.grid = Grid(height, width, torus=True)
 
         self.happy = 0
 
         # Set up agents
         # We use a grid iterator that returns
         # the coordinates of a cell as well as
         # its contents. (coord_iter)
-        for _cont, pos in self.grid.coord_iter():
+        for cell in self.grid:
             if self.random.random() < self.density:
                 agent_type = 1 if self.random.random() < self.minority_pc else 0
                 agent = SchellingAgent(self.next_id(), self, agent_type)
-                self.grid.place_agent(agent, pos)
+                cell.add_agent(agent)
                 self.schedule.add(agent)
 
     def step(self):

benchmarks/WolfSheep/agents.py

@@ -24,23 +24,24 @@ def step(self):
         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))
+        grass_patch = next(
+            obj for obj in self.cell.agents if isinstance(obj, GrassPatch)
+        )
         if grass_patch.fully_grown:
             self.energy += self.model.sheep_gain_from_food
             grass_patch.fully_grown = False
 
         # Death
         if self.energy < 0:
-            self.model.grid.remove_agent(self)
+            self.cell.remove_agent(self)
             self.model.schedule.remove(self)
         elif self.random.random() < self.model.sheep_reproduce:
             # Create a new sheep:
             self.energy /= 2
             lamb = Sheep(
-                self.model.next_id(), self.pos, self.model, self.moore, self.energy
+                self.model.next_id(), None, self.model, self.moore, self.energy
             )
-            self.model.grid.place_agent(lamb, self.pos)
+            self.cell.add_agent(lamb)
             self.model.schedule.add(lamb)
 
 
@@ -58,28 +59,24 @@ def step(self):
         self.energy -= 1
 
         # 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)]
+        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
 
             # Kill the sheep
-            self.model.grid.remove_agent(sheep_to_eat)
+            self.cell.remove_agent(sheep_to_eat)
             self.model.schedule.remove(sheep_to_eat)
 
         # Death or reproduction
         if self.energy < 0:
-            self.model.grid.remove_agent(self)
+            self.cell.remove_agent(self)
             self.model.schedule.remove(self)
         elif self.random.random() < self.model.wolf_reproduce:
             # Create a new wolf cub
             self.energy /= 2
-            cub = Wolf(
-                self.model.next_id(), self.pos, self.model, self.moore, self.energy
-            )
-            self.model.grid.place_agent(cub, cub.pos)
+            cub = Wolf(self.model.next_id(), None, self.model, self.moore, self.energy)
+            self.cell.add_agent(cub)
             self.model.schedule.add(cub)
 
 

benchmarks/WolfSheep/random_walk.py

@@ -3,9 +3,11 @@
 """
 
 from mesa import Agent
+from mesa.experimental.cell_space import Cell
 
 
 class RandomWalker(Agent):
+    cell: Cell
     """
     Class implementing random walker methods in a generalized manner.
 
@@ -31,7 +33,4 @@ def random_move(self):
         Step one cell in any allowable direction.
         """
         # Pick the next cell from the adjacent cells.
-        next_moves = self.model.grid.get_neighborhood(self.pos, self.moore, True)
-        next_move = self.random.choice(next_moves)
-        # Now move:
-        self.model.grid.move_agent(self, next_move)
+        self.cell.neighborhood().select_random_cell().add_agent(self)

benchmarks/WolfSheep/wolf_sheep.py

@@ -10,7 +10,7 @@
 """
 
 import mesa
-from mesa.space import MultiGrid
+from mesa.experimental.cell_space import Grid
 from mesa.time import RandomActivationByType
 
 from .agents import GrassPatch, Sheep, Wolf
@@ -63,40 +63,34 @@ def __init__(
         self.sheep_gain_from_food = sheep_gain_from_food
 
         self.schedule = RandomActivationByType(self)
-        self.grid = MultiGrid(self.height, self.width, torus=False)
+        self.grid = Grid(self.height, self.width, torus=False, capacity=None)
 
         # Create sheep:
         for _i in range(self.initial_sheep):
-            pos = (
-                self.random.randrange(self.width),
-                self.random.randrange(self.height),
-            )
+            cell = self.grid.all_cells.select_random_cell()
             energy = self.random.randrange(2 * self.sheep_gain_from_food)
-            sheep = Sheep(self.next_id(), pos, self, True, energy)
-            self.grid.place_agent(sheep, pos)
+            sheep = Sheep(self.next_id(), None, self, True, energy)
+            cell.add_agent(sheep)
             self.schedule.add(sheep)
 
         # Create wolves
         for _i in range(self.initial_wolves):
-            pos = (
-                self.random.randrange(self.width),
-                self.random.randrange(self.height),
-            )
+            cell = self.grid.all_cells.select_random_cell()
             energy = self.random.randrange(2 * self.wolf_gain_from_food)
-            wolf = Wolf(self.next_id(), pos, self, True, energy)
-            self.grid.place_agent(wolf, pos)
+            wolf = Wolf(self.next_id(), None, self, True, energy)
+            cell.add_agent(wolf)
             self.schedule.add(wolf)
 
         # Create grass patches
         possibly_fully_grown = [True, False]
-        for _agent, pos in self.grid.coord_iter():
+        for cell in self.grid:
             fully_grown = self.random.choice(possibly_fully_grown)
             if fully_grown:
                 countdown = self.grass_regrowth_time
             else:
                 countdown = self.random.randrange(self.grass_regrowth_time)
-            patch = GrassPatch(self.next_id(), pos, self, fully_grown, countdown)
-            self.grid.place_agent(patch, pos)
+            patch = GrassPatch(self.next_id(), None, self, fully_grown, countdown)
+            cell.add_agent(patch)
             self.schedule.add(patch)
 
     def step(self):

mesa/agent.py

@@ -22,6 +22,7 @@
 if TYPE_CHECKING:
     # We ensure that these are not imported during runtime to prevent cyclic
     # dependency.
+    from mesa.gridspace import Cell
     from mesa.model import Model
     from mesa.space import Position
 
@@ -46,6 +47,7 @@ def __init__(self, unique_id: int, model: Model) -> None:
         """
         self.unique_id = unique_id
         self.model = model
+        self.cell: Cell | None = None
         self.pos: Position | None = None
 
         # register agent