engulf: grass grow up

sandbox/engulf/behaviour.py

+from synergine2.simulation import SubjectBehaviour
+from synergine2.simulation import Event
+
+
+class GrassGrownUp(Event):
+    def __init__(self, subject_id, density, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.subject_id = subject_id
+        self.density = density
+
+
+class GrowUp(SubjectBehaviour):
+    frequency = 20
+
+    def run(self, data):
+        return True
+
+    def action(self, data) -> [Event]:
+        self.subject.density += 1
+        return [GrassGrownUp(
+            self.subject.id,
+            self.subject.density,
+        )]

sandbox/engulf/gui.py

 
 import cocos
 from cocos.sprite import Sprite
+from sandbox.engulf.behaviour import GrassGrownUp
 from sandbox.engulf.subject import Cell, Grass
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
 class GrassLayer(GridLayerMixin, BaseMainLayer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.cells = {}
+        self.grasses = {}
 
-    def born(self, grid_position, opacity=100):
+    def born(self, subject_id, grid_position, opacity=100):
         grass = Sprite('resources/grass.png')
         grass.rotation = randint(0, 360)
         grass.opacity = opacity
         self.grid_manager.scale_sprite(grass)
         self.grid_manager.position_sprite(grass, grid_position)
-        self.cells[grid_position] = grass
+        self.grasses[subject_id] = grass
         self.add(grass)
 
+    def set_density(self, subject_id, density):
+        self.grasses[subject_id].opacity = density
+
 
 class MainLayer(GridLayerMixin, BaseMainLayer):
     def __init__(self, terminal, *args, **kwargs):
 
         self.main_layer = MainLayer(terminal=self.terminal)
         self.main_scene = cocos.scene.Scene(self.main_layer)
-        self.positions = {}
+
+        self.terminal.register_event_handler(
+            GrassGrownUp,
+            self.on_grass_grown_up,
+        )
 
     def get_main_scene(self):
         return self.main_scene
         if package.subjects:  # It's thirst package
             for subject in package.subjects:
                 if isinstance(subject, Cell):
-                    self.positions[subject.id] = subject.position
                     self.main_layer.cells.born(subject.position)
                 if isinstance(subject, Grass):
-                    self.positions[subject.id] = subject.position
                     self.main_layer.grasses.born(
+                        subject.id,
                         subject.position,
                         subject.density,
                     )
+
+    def on_grass_grown_up(self, event: GrassGrownUp):
+        self.main_layer.grasses.set_density(
+            event.subject_id,
+            event.density,
+        )

sandbox/engulf/run.py

 
 """
 from random import randint, seed
+from sandbox.engulf.behaviour import GrassGrownUp
 
 from sandbox.engulf.subject import Cell, Grass, COLLECTION_GRASS
 from synergine2.core import Core
 
 
 class GameTerminal(Terminal):
-    subscribed_events = []
+    subscribed_events = [
+        GrassGrownUp,
+    ]
 
     def __init__(self):
         super().__init__()

sandbox/engulf/subject.py

+from sandbox.engulf.behaviour import GrowUp
 from synergine2.simulation import Subject
 from synergine2.xyz import XYZSubjectMixin
 
         COLLECTION_EATABLE,
         COLLECTION_GRASS,
     ]
+    behaviours_classes = [
+        GrowUp,
+    ]
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)

synergine2/cycle.py

 
         self.simulation = simulation
         self.process_manager = process_manager
-        self.current_cycle = 0
+        self.current_cycle = -1
         self.first_cycle = True
 
     def next(self) -> [Event]:
             # To dispatch subjects add/removes, enable track on them
             self.simulation.subjects.track_changes = True
             self.first_cycle = False
+        self.current_cycle += 1
 
         events = []
         # TODO: gestion des behaviours non parallelisables
         for process_results in results_by_processes:
             results.update(process_results)
         for subject in self.simulation.subjects[:]:  # Duplicate list to prevent conflicts with behaviours subjects manipulations
-            for behaviour_class, behaviour_data in results[subject.id].items():
+            for behaviour_class, behaviour_data in results.get(subject.id, {}).items():
                 # TODO: Ajouter une etape de selection des actions a faire (genre neuronnal)
                 # (genre se cacher et fuir son pas compatibles)
                 actions_events = subject.behaviours[behaviour_class].action(behaviour_data)
 
     def get_behaviours_to_compute(self, mechanisable) -> [SubjectBehaviour, SimulationBehaviour]:
         # TODO: Implementer un systeme qui inhibe des behaviours (ex. someil inhibe avoir faim)
-        return mechanisable.behaviours.values()
+        behaviours = list(mechanisable.behaviours.values())
+
+        for behaviour in behaviours[:]:
+            if behaviour.frequency != 1:
+                if self.current_cycle % behaviour.frequency:
+                    behaviours.remove(behaviour)
+
+        return behaviours
 
     def apply_actions(
             self,

synergine2/simulation.py

 
 
 class SubjectBehaviour(object):
+    frequency = 1
+    use = []
+
     def __init__(
             self,
             simulation: Simulation,
 
 
 class SimulationBehaviour(object):
+    frequency = 1
+    use = []
+
     def __init__(
             self,
             simulation: Simulation,