engulf: cell eating

sandbox/engulf/behaviour.py

     get_direction_from_north_degree
 from synergine2.xyz_utils import get_around_positions_of_positions, get_around_positions_of, get_position_for_direction
 
+# Import for typing hint
+if False:
+    from sandbox.engulf.subject import Grass
+
 
 class GrassGrownUp(Event):
     def __init__(self, subject_id, density, *args, **kwargs):
     distance = 1.41  # distance when on angle
     feel_collections = [COLLECTION_GRASS]
 
+    def acceptable_subject(self, subject: 'Grass') -> bool:
+        return subject.density >= self.config.simulation.eat_grass_required_density
+
 
 class MoveTo(Event):
     def __init__(self, subject_id: int, position: tuple, *args, **kwargs):
         )
 
 
+class EatEvent(Event):
+    def __init__(self, eaten_id: int, eater_id: int, eaten_new_density: float, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.eaten_id = eaten_id
+        self.eater_id = eater_id
+        self.eaten_new_density = eaten_new_density
+
+
 class SearchFood(SubjectBehaviour):
     """
     Si une nourriture a une case de distance et cellule non rassasié, move dans sa direction.
     use = [EatableDirectProximityMechanism]
 
     def run(self, data):
+        if self.subject.appetite < self.config.simulation.search_food_appetite_required:
+            return False
+
         if not data[EatableDirectProximityMechanism]:
             return False
 
     Prduit un immobilisme si sur une case de nourriture, dans le cas ou la cellule n'est as rassasié.
     """
     def run(self, data):
-        pass
+        if self.subject.appetite < self.config.simulation.eat_grass_required_density:
+            return False
+
+        for grass in self.simulation.collections.get(COLLECTION_GRASS, []):
+            if grass.position == self.subject.position:
+                return grass.id
+
+    def action(self, data) -> [Event]:
+        subject_id = data
+
+        grass = self.simulation.subjects.index[subject_id]  # TODO: cas ou grass disparu ?
+        grass.density -= self.config.simulation.eat_grass_density_reduction
+
+        self.subject.appetite -= self.config.simulation.eat_grass_appetite_reduction
+
+        # TODO: Comment mettre des logs (ne peuvent pas être passé aux subprocess)?
+
+        return [EatEvent(
+            eater_id=self.subject.id,
+            eaten_id=subject_id,
+            eaten_new_density=grass.density,
+        )]
 
 
 class Explore(SubjectBehaviour):
         return choice(DIRECTION_SLIGHTLY[self.subject.previous_direction])
 
 
+class Hungry(SubjectBehaviour):
+    def run(self, data):
+        return True
+
+    def action(self, data) -> [Event]:
+        self.subject.appetite += self.config.simulation.hungry_reduction
+        return []
+
+    def get_random_direction(self):
+        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,
+            Eat,  # TODO: Introduce priority with appetite
+            SearchFood,  # TODO: Introduce priority with appetite
             Explore,
         ),
     )
             if behaviour_class != exclude_behaviour_class:
                 try:
                     behaviour_position = sublist.index(behaviour_class)
+                    if position is None or behaviour_position < position:
+                        position = behaviour_position
                 except ValueError:
                     pass
-                if position is None or behaviour_position < position:
-                    position = behaviour_position
 
         return position

sandbox/engulf/config.yaml

     cycle_duration: 0.5
 terminals:
     sync: True
+simulation:
+    start_appetite: 50
+    hungry_reduction: 0.25
+    search_food_appetite_required: 30
+    eat_grass_required_density: 25
+    eat_grass_appetite_reduction: 5
+    eat_grass_density_reduction: 25

sandbox/engulf/gui.py

 import cocos
 from cocos.actions import MoveTo, Repeat, ScaleBy, Reverse, RotateTo
 from cocos.sprite import Sprite
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent, EatEvent
 from sandbox.engulf.subject import Cell, Grass
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
             MoveToEvent,
             self.on_move_to,
         )
+        self.terminal.register_event_handler(
+            EatEvent,
+            self.on_eat,
+        )
 
     def get_main_scene(self):
         return self.main_scene
             event.subject_id,
             event.position,
         )
+
+    def on_eat(self, event: EatEvent):
+        self.main_layer.grasses.set_density(
+            event.eaten_id,
+            event.eaten_new_density,
+        )

sandbox/engulf/run.py

 sys.path.append(synergine2_ath)
 
 from random import randint, seed
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, GrassSpawnBehaviour, MoveTo
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, GrassSpawnBehaviour, MoveTo, EatEvent
 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
         GrassGrownUp,
         GrassSpawn,
         MoveTo,
+        EatEvent,
     ]
 
     def __init__(self, *args, **kwargs):
 
 
 def fill_with_random_cells(
+    config,
     subjects: EngulfSubjects,
     count: int,
     start_position: tuple,
         )
         if position not in subjects.cell_xyz:
             cell = Cell(
+                config,
                 simulation=subjects.simulation,
                 position=position,
             )
 
 
 def fill_with_random_grass(
+    config,
     subjects: EngulfSubjects,
     start_count: int,
     start_position: tuple,
 
         if position not in subjects.grass_xyz:
             grass = Grass(
+                config,
                 simulation=subjects.simulation,
                 position=position,
             )
         for around in get_around_positions_of(grass.position, distance=density):
             if around not in subjects.grass_xyz:
                 new_grass = Grass(
+                    config,
                     simulation=subjects.simulation,
                     position=around,
                 )
 
 def main():
     seed(0)
-    simulation = Engulf()
+
+    config = Config()
+    config.load_files(['sandbox/engulf/config.yaml'])
+    logger = get_default_logger(level=logging.DEBUG)
+
+    simulation = Engulf(config)
     subjects = EngulfSubjects(simulation=simulation)
     fill_with_random_cells(
+        config,
         subjects,
         30,
         (-34, -34, 0),
         (34, 34, 0),
     )
     fill_with_random_grass(
+        config,
         subjects,
         5,
         (-34, -34, 0),
     )
     simulation.subjects = subjects
 
-    config = Config()
-    config.load_files(['sandbox/engulf/config.yaml'])
-    logger = get_default_logger(level=logging.DEBUG)
-
     core = Core(
         config=config,
         logger=logger,

sandbox/engulf/subject.py

 # coding: utf-8
-from sandbox.engulf.behaviour import GrowUp, SearchFood, Eat, Explore, CellBehaviourSelector
+from sandbox.engulf.behaviour import GrowUp, SearchFood, Eat, Explore, CellBehaviourSelector, Hungry
 from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS
 from synergine2.simulation import Subject
 from synergine2.xyz import XYZSubjectMixin
         SearchFood,
         Eat,
         Explore,
+        Hungry,
     ]
     behaviour_selector_class = CellBehaviourSelector
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._appetite = self.config.simulation.start_appetite  # /100
+
+    @property
+    def appetite(self) -> float:
+        return self._appetite
+
+    @appetite.setter
+    def appetite(self, value) -> None:
+        if value > 100:
+            self._appetite = 100
+        elif value < 0:
+            self._appetite = 0
+        else:
+            self._appetite = value
+
 
 class Grass(XYZSubjectMixin, Subject):
     collections = [

synergine2/simulation.py

 import typing
 
 from synergine2.base import BaseObject
+from synergine2.config import Config
 from synergine2.utils import get_mechanisms_classes
 
 
     behaviours_classes = []
     behaviour_selector_class = None  # type: typing.Type[SubjectBehaviourSelector]
 
-    def __init__(self, simulation: 'Simulation'):
+    def __init__(
+        self,
+        config: Config,
+        simulation: 'Simulation',
+    ):
+        self.config = config
         self.id = id(self)  # We store object id because it's lost between process
         self.simulation = simulation
         self.behaviours = {}
     def initialize(self):
         for mechanism_class in get_mechanisms_classes(self):
             self.mechanisms[mechanism_class] = mechanism_class(
+                config=self.config,
                 simulation=self.simulation,
                 subject=self,
             )
 
         for behaviour_class in self.behaviours_classes:
             self.behaviours[behaviour_class] = behaviour_class(
+                config=self.config,
                 simulation=self.simulation,
                 subject=self,
             )
     accepted_subject_class = Subjects
     behaviours_classes = []
 
-    def __init__(self):
+    def __init__(
+        self,
+        config: Config,
+    ):
+        self.config = config
         self.collections = collections.defaultdict(list)
         self._subjects = None
         self.behaviours = {}
     def initialize(self):
         for mechanism_class in get_mechanisms_classes(self):
             self.mechanisms[mechanism_class] = mechanism_class(
+                config=self.config,
                 simulation=self,
             )
 
         for behaviour_class in self.behaviours_classes:
             self.behaviours[behaviour_class] = behaviour_class(
+                config=self.config,
                 simulation=self,
             )
 
 class SubjectMechanism(BaseObject):
     def __init__(
             self,
+            config: Config,
             simulation: Simulation,
             subject: Subject,
     ):
+        self.config = config
         self.simulation = simulation
         self.subject = subject
 
 
     def __init__(
             self,
+            config: Config,
             simulation: Simulation,
     ):
+        self.config = config
         self.simulation = simulation
 
     def repr_debug(self) -> str:
 
     def __init__(
             self,
+            config: Config,
             simulation: Simulation,
             subject: Subject,
     ):
+        self.config = config
         self.simulation = simulation
         self.subject = subject
 
         Note: Returned data will be transfered from sub processes.
               Prefer scalar types.
         """
-        raise NotImplementedError()
+        raise NotImplementedError()  # TODO Test it and change to strictly False
 
     def action(self, data) -> [Event]:
         """
 
     def __init__(
             self,
+            config: Config,
             simulation: Simulation,
     ):
+        self.config = config
         self.simulation = simulation
 
     def run(self, data):

synergine2/xyz.py

                     ),
                     self.distance_round_decimals,
                 )
-                if distance <= self.distance:
+                if distance <= self.distance and self.acceptable_subject(subject):
                     direction = round(
                         get_degree_from_north(
                             position,
             subject.position,
         )
 
+    def acceptable_subject(self, subject: Subject) -> bool:
+        pass
+
 
 class ProximitySubjectMechanism(ProximityMixin, SubjectMechanism):
     def run(self):