Add functionality to advance the model stepwise (#52)

model/model.go

@@ -65,14 +65,36 @@ func (m *Model) Seed(seed ...uint64) *Model {
 	return m
 }
 
-// Run runs the model.
+// Run the model. Initializes the model if it is not already initialized.
+// Finalizes the model after the run.
 //
 // Runs until Terminate in the resource resource.Termination is set to true
 // (see [resource.Termination]).
 func (m *Model) Run() {
 	m.Systems.run()
 }
 
+// Initialize the model.
+func (m *Model) Initialize() {
+	m.Systems.initialize()
+}
+
+// Update the model's systems.
+// Return whether the run should continue.
+func (m *Model) Update() bool {
+	return m.Systems.UpdateSystems()
+}
+
+// UpdateUI the model's UI systems.
+func (m *Model) UpdateUI() {
+	m.Systems.UpdateUISystems()
+}
+
+// Finalize the model.
+func (m *Model) Finalize() {
+	m.Systems.finalize()
+}
+
 // Reset resets the world and removes all systems.
 //
 // Can be used to run systematic simulations without the need to re-allocate memory for each run.

model/model_test.go

@@ -25,6 +25,26 @@ func TestModel(t *testing.T) {
 	}
 }
 
+func TestModelStep(t *testing.T) {
+	m := model.New()
+
+	for i := 0; i < 3; i++ {
+		m.Reset()
+		m.Seed(123)
+
+		m.AddSystem(&system.FixedTermination{
+			Steps: 10,
+		})
+
+		m.Initialize()
+
+		for m.Update() {
+			m.UpdateUI()
+		}
+		m.Finalize()
+	}
+}
+
 func TestModelSeed(t *testing.T) {
 	m := model.New()
 	m.Seed(123)

model/systems.go

@@ -206,10 +206,12 @@ func (s *Systems) initialize() {
 
 	s.nextDraw = time.Time{}
 	s.nextUpdate = time.Time{}
+
+	s.tickRes.Get().Tick = 0
 }
 
 // Update all systems.
-func (s *Systems) update() {
+func (s *Systems) update() bool {
 	s.locked = true
 	update := s.updateSystems()
 	s.updateUISystems(update)
@@ -223,6 +225,32 @@ func (s *Systems) update() {
 	} else {
 		s.wait()
 	}
+
+	return !s.termRes.Get().Terminate
+}
+
+// UpdateSystems updates all normal systems
+func (s *Systems) UpdateSystems() bool {
+	s.locked = true
+	updated := s.updateSystems()
+	s.locked = false
+
+	s.removeSystems()
+
+	if updated {
+		time := s.tickRes.Get()
+		time.Tick++
+	}
+	return !s.termRes.Get().Terminate
+}
+
+// UpdateUISystems updates all UI systems
+func (s *Systems) UpdateUISystems() {
+	s.locked = true
+	s.updateUISystems(true)
+	s.locked = false
+
+	s.removeSystems()
 }
 
 // Calculates and waits the time until the next update of UI update.
@@ -316,12 +344,7 @@ func (s *Systems) run() {
 		s.initialize()
 	}
 
-	time := s.tickRes.Get()
-	time.Tick = 0
-	terminate := s.termRes.Get()
-
-	for !terminate.Terminate {
-		s.update()
+	for s.update() {
 	}
 
 	s.finalize()