Revert PR #161: Replace schedulers with AgentSet functionality (#170)

This commit reverts PR #161 projectmesa/mesa-examples#161

That PR assumed that time advancement would be done automatically, like proposed in #2223

We encountered some underlying issues with time, which we couldn't resolve in time.

Author: EwoutH

examples/boid_flockers/Flocker Test.ipynb

@@ -25,7 +25,7 @@
     "def draw_boids(model):\n",
     "    x_vals = []\n",
     "    y_vals = []\n",
-    "    for boid in model.agents:\n",
+    "    for boid in model.schedule.agents:\n",
     "        x, y = boid.pos\n",
     "        x_vals.append(x)\n",
     "        y_vals.append(y)\n",

examples/boid_flockers/boid_flockers/SimpleContinuousModule.py

@@ -18,7 +18,7 @@ def __init__(self, portrayal_method=None, canvas_height=500, canvas_width=500):
 
     def render(self, model):
         space_state = []
-        for obj in model.agents:
+        for obj in model.schedule.agents:
             portrayal = self.portrayal_method(obj)
             x, y = obj.pos
             x = (x - model.space.x_min) / (model.space.x_max - model.space.x_min)

examples/boid_flockers/boid_flockers/model.py

@@ -120,7 +120,7 @@ def __init__(
         self.vision = vision
         self.speed = speed
         self.separation = separation
-
+        self.schedule = mesa.time.RandomActivation(self)
         self.space = mesa.space.ContinuousSpace(width, height, True)
         self.factors = {"cohere": cohere, "separate": separate, "match": match}
         self.make_agents()
@@ -144,6 +144,7 @@ def make_agents(self):
                 **self.factors,
             )
             self.space.place_agent(boid, pos)
+            self.schedule.add(boid)
 
     def step(self):
-        self.agents.shuffle().do("step")
+        self.schedule.step()

examples/boltzmann_wealth_model/boltzmann_wealth_model/model.py

@@ -2,7 +2,7 @@
 
 
 def compute_gini(model):
-    agent_wealths = [agent.wealth for agent in model.agents]
+    agent_wealths = [agent.wealth for agent in model.schedule.agents]
     x = sorted(agent_wealths)
     N = model.num_agents
     B = sum(xi * (N - i) for i, xi in enumerate(x)) / (N * sum(x))
@@ -21,14 +21,14 @@ def __init__(self, N=100, width=10, height=10):
         super().__init__()
         self.num_agents = N
         self.grid = mesa.space.MultiGrid(width, height, True)
-
+        self.schedule = mesa.time.RandomActivation(self)
         self.datacollector = mesa.DataCollector(
             model_reporters={"Gini": compute_gini}, agent_reporters={"Wealth": "wealth"}
         )
         # Create agents
         for i in range(self.num_agents):
             a = MoneyAgent(i, self)
-
+            self.schedule.add(a)
             # Add the agent to a random grid cell
             x = self.random.randrange(self.grid.width)
             y = self.random.randrange(self.grid.height)
@@ -38,7 +38,7 @@ def __init__(self, N=100, width=10, height=10):
         self.datacollector.collect(self)
 
     def step(self):
-        self.agents.shuffle().do("step")
+        self.schedule.step()
         # collect data
         self.datacollector.collect(self)
 

examples/conways_game_of_life/conways_game_of_life/cell.py

@@ -24,7 +24,7 @@ def isAlive(self):
     def neighbors(self):
         return self.model.grid.iter_neighbors((self.x, self.y), True)
 
-    def determine_state(self):
+    def step(self):
         """
         Compute if the cell will be dead or alive at the next tick.  This is
         based on the number of alive or dead neighbors.  The state is not
@@ -46,7 +46,7 @@ def determine_state(self):
             if live_neighbors == 3:
                 self._nextState = self.ALIVE
 
-    def assume_state(self):
+    def advance(self):
         """
         Set the state to the new computed state -- computed in step().
         """

examples/conways_game_of_life/conways_game_of_life/model.py

@@ -14,6 +14,15 @@ def __init__(self, width=50, height=50):
         Create a new playing area of (width, height) cells.
         """
         super().__init__()
+
+        # Set up the grid and schedule.
+
+        # Use SimultaneousActivation which simulates all the cells
+        # computing their next state simultaneously.  This needs to
+        # be done because each cell's next state depends on the current
+        # state of all its neighbors -- before they've changed.
+        self.schedule = mesa.time.SimultaneousActivation(self)
+
         # Use a simple grid, where edges wrap around.
         self.grid = mesa.space.SingleGrid(width, height, torus=True)
 
@@ -24,14 +33,12 @@ def __init__(self, width=50, height=50):
             if self.random.random() < 0.1:
                 cell.state = cell.ALIVE
             self.grid.place_agent(cell, (x, y))
+            self.schedule.add(cell)
 
         self.running = True
 
     def step(self):
         """
-        Perform the model step in two stages:
-        - First, all cells assume their next state (whether they will be dead or alive)
-        - Then, all cells change state to their next state
+        Have the scheduler advance each cell by one step
         """
-        self.agents.do("determine_state")
-        self.agents.do("assume_state")
+        self.schedule.step()