Implement behaviour selector

sandbox/engulf/behaviour.py

 # coding: utf-8
+import typing
 from random import choice
 
 from sandbox.engulf.const import COLLECTION_GRASS
-from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour
+from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour, SubjectBehaviourSelector
 from synergine2.simulation import Event
 from synergine2.utils import ChunkManager
 from synergine2.xyz import ProximitySubjectMechanism, DIRECTIONS, DIRECTION_SLIGHTLY
         if not self.subject.previous_direction:
             return choice(DIRECTIONS)
         return choice(DIRECTION_SLIGHTLY[self.subject.previous_direction])
+
+
+class CellBehaviourSelector(SubjectBehaviourSelector):
+    # If behaviour in sublist, only one be kept in sublist
+    behaviour_hierarchy = (  # TODO: refact it
+        (
+            Eat,
+            SearchFood,
+            Explore,
+        ),
+    )
+
+    def reduce_behaviours(
+        self,
+        behaviours: typing.Dict[typing.Type[SubjectBehaviour], dict],
+    ) -> typing.Dict[typing.Type[SubjectBehaviour], dict]:
+        return behaviours  # TODO: code it

sandbox/engulf/subject.py

 # coding: utf-8
-from sandbox.engulf.behaviour import GrowUp, SearchFood, Eat, Explore
+from sandbox.engulf.behaviour import GrowUp, SearchFood, Eat, Explore, CellBehaviourSelector
 from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS
 from synergine2.simulation import Subject
 from synergine2.xyz import XYZSubjectMixin
         Eat,
         Explore,
     ]
+    behaviour_selector_class = CellBehaviourSelector
 
 
 class Grass(XYZSubjectMixin, Subject):

synergine2/cycle.py

 
         # Duplicate list to prevent conflicts with behaviours subjects manipulations
         for subject in self.simulation.subjects[:]:
-            for behaviour_class, behaviour_data in results.get(subject.id, {}).items():
+            subject_behaviours = results.get(subject.id, {})
+            if subject.behaviour_selector:
+                # TODO: Looging
+                subject_behaviours = subject.behaviour_selector.reduce_behaviours(dict(subject_behaviours))
+
+            for behaviour_class, behaviour_data in subject_behaviours.items():
                 # TODO: Ajouter une etape de selection des actions a faire (genre neuronnal)
                 # (genre se cacher et fuir son pas compatibles)
                 behaviour_events = subject.behaviours[behaviour_class].action(behaviour_data)

synergine2/simulation.py

 # coding: utf-8
 import collections
+import typing
 
 from synergine2.base import BaseObject
 from synergine2.utils import get_mechanisms_classes
 class Subject(object):
     collections = []
     behaviours_classes = []
+    behaviour_selector_class = None  # type: typing.Type[SubjectBehaviourSelector]
 
     def __init__(self, simulation: 'Simulation'):
         self.id = id(self)  # We store object id because it's lost between process
         self.simulation = simulation
         self.behaviours = {}
         self.mechanisms = {}
+        self.behaviour_selector = None  # type: SubjectBehaviourSelector
+        if self.behaviour_selector_class:
+            self.behaviour_selector = self.behaviour_selector_class()
 
         for collection in self.collections:
             self.simulation.collections[collection].append(self)
         Return events will be give to terminals
         """
         raise NotImplementedError()
+
+
+class SubjectBehaviourSelector(BaseObject):
+    def reduce_behaviours(
+        self,
+        behaviours: typing.Dict[typing.Type[SubjectBehaviour], dict],
+    ) -> typing.Dict[typing.Type[SubjectBehaviour], dict]:
+        raise NotImplementedError()