engulf: predator eat prey

sandbox/engulf/behaviour.py

 import typing
 from random import choice
 
-from sandbox.engulf.const import COLLECTION_GRASS, COLLECTION_CELL
+from sandbox.engulf.const import COLLECTION_GRASS, COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_PREY
 from sandbox.engulf.exceptions import NotFoundWhereToGo
 from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour, SubjectBehaviourSelector
 from synergine2.simulation import Event
         self.eaten_new_density = eaten_new_density
 
 
+class EatenEvent(Event):
+    def __init__(self, eaten_id: int, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.eaten_id = eaten_id
+
+
 class AttackEvent(Event):
     def __init__(self, attacker_id: int, attacked_id: int, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.attacked_id = attacked_id
 
 
-class SearchGrass(SubjectBehaviour):
-    """
-    Si une nourriture a une case de distance et cellule non rassasié, move dans sa direction.
-    """
-    use = [GrassEatableDirectProximityMechanism]
+class SearchFood(SubjectBehaviour):
+    mechanism_data_class = NotImplemented
+
+    def get_required_appetite(self) -> float:
+        raise NotImplementedError()
 
     def run(self, data):
-        if self.subject.appetite < self.config.simulation.search_food_appetite_required:
+        if self.subject.appetite < self.get_required_appetite():
             return False
 
-        if not data[GrassEatableDirectProximityMechanism]:
+        if not data[self.mechanism_data_class]:
             return False
 
-        direction_degrees = [d['direction'] for d in data[GrassEatableDirectProximityMechanism]]
+        direction_degrees = [d['direction'] for d in data[self.mechanism_data_class]]
         return get_direction_from_north_degree(choice(direction_degrees))
 
     def action(self, data) -> [Event]:
         return [MoveTo(self.subject.id, position)]
 
 
-class EatGrass(SubjectBehaviour):
+class SearchGrass(SearchFood):
+    """
+    Si une nourriture a une case de distance et cellule non rassasié, move dans sa direction.
     """
-    Prduit un immobilisme si sur une case de nourriture, dans le cas ou la cellule n'est as rassasié.
+    use = [GrassEatableDirectProximityMechanism]
+    mechanism_data_class = use[0]
+
+    def get_required_appetite(self) -> float:
+        return self.config.simulation.search_food_appetite_required
+
+
+class SearchPrey(SearchFood):
+    """
+    Si une nourriture a une case de distance et cellule non rassasié, move dans sa direction.
     """
+    use = [PreyEatableDirectProximityMechanism]
+    mechanism_data_class = use[0]
+
+    def get_required_appetite(self) -> float:
+        return self.config.simulation.search_and_attack_prey_apetite_required
+
+
+class EatGrass(SubjectBehaviour):
     def run(self, data):
         if self.subject.appetite < self.config.simulation.eat_grass_required_density:
             return False
         )]
 
 
+class EatPrey(SubjectBehaviour):
+    def run(self, data):
+        if self.subject.appetite < self.config.simulation.search_and_attack_prey_apetite_required:
+            return False
+
+        for prey in self.simulation.collections.get(COLLECTION_PREY, []):
+            # TODO: Use simulation/xyz pre calculated indexes
+            if prey.position == self.subject.position:
+                return prey.id
+
+    def action(self, data) -> [Event]:
+        subject_id = data
+
+        # Cell already eaten ?
+        if subject_id not in self.simulation.subjects.index:
+            return []
+
+        prey = self.simulation.subjects.index[subject_id]
+        self.simulation.subjects.remove(prey)
+        self.subject.appetite -= self.config.simulation.eat_prey_required_density
+
+        return [EatenEvent(
+            eaten_id=prey.id,
+        )]
+
+
 class Explore(SubjectBehaviour):
     """
     Produit un mouvement au hasard (ou un immobilisme)
     use = []
 
     def run(self, data):
-        return True  # for now, want move every time
+        # TODO: Il faut pouvoir dire tel behaviour concerne que tel collections
+        if COLLECTION_ALIVE not in self.subject.collections:
+            return False
+
+        return True
 
     def action(self, data) -> [Event]:
         try:
     use = [PreyEatableDirectProximityMechanism]
 
     def run(self, data):
-        if data[PreyEatableDirectProximityMechanism]:
-            return choice(data[PreyEatableDirectProximityMechanism])
+        if self.subject.appetite < self.config.simulation.search_and_attack_prey_apetite_required:
+            return False
+
+        eatable_datas = data[PreyEatableDirectProximityMechanism]
+        attackable_datas = []
+
+        for eatable_data in eatable_datas:
+            if COLLECTION_ALIVE in eatable_data['subject'].collections:
+                attackable_datas.append(eatable_data)
+
+        if attackable_datas:
+            return choice(attackable_datas)
         return False
 
     def action(self, data) -> [Event]:
-        # TODO: Dommages / mort
+        attacked = self.simulation.subjects.index[data['subject'].id]
+
+        try:
+            # TODO il faut automatiser/Refactoriser le fait de retirer/ajouter un collection
+            self.simulation.collections[COLLECTION_ALIVE].remove(attacked)
+            attacked.collections.remove(COLLECTION_ALIVE)
+        except ValueError:
+            pass  # On considere qu'il a ete tué par une autre, TODO: en être sur ?
+
         return [AttackEvent(attacker_id=self.subject.id, attacked_id=data['subject'].id)]
 
 
     # If behaviour in sublist, only one be kept in sublist
     behaviour_hierarchy = (  # TODO: refact it
         (
+            EatPrey,
             EatGrass,  # TODO: Introduce priority with appetite
+            Attack,
+            SearchPrey,
             SearchGrass,  # TODO: Introduce priority with appetite
             Explore,
         ),

sandbox/engulf/config.yaml

     start_appetite: 50
     hungry_reduction: 0.25
     search_food_appetite_required: 30
+    search_and_attack_prey_apetite_required: 50
     eat_grass_required_density: 25
+    eat_prey_required_density: 100
     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, EatEvent, AttackEvent
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent, EatEvent, AttackEvent, EatenEvent
 from sandbox.engulf.subject import Cell, Grass, PreyCell, PredatorCell
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
         self.add(cell)
 
     def move(self, subject_id: int, position: tuple):
+        if subject_id not in self.cell_ids:
+            return  # Cell eaten before
+
         cell = self.cell_ids[subject_id]
 
         window_position = self.grid_manager.get_window_position(position[0], position[1])
         attacker = self.cell_ids[attacker_id]
         attacker.do(ScaleBy(1.7, duration=0.25))
 
+    def eaten(self, eaten_id: int):
+        eaten = self.cell_ids[eaten_id]
+        self.remove(eaten)
+        # TODO: refact: On a pas nettoyer self.cell_positions par exemple
+        del self.cell_ids[eaten_id]
+
 
 class GrassLayer(GridLayerMixin, BaseMainLayer):
     def __init__(self, game: 'Game', *args, **kwargs):
             AttackEvent,
             self.on_attack,
         )
+        self.terminal.register_event_handler(
+            EatenEvent,
+            self.on_eaten,
+        )
 
     def get_main_scene(self):
         return self.main_scene
             event.attacker_id,
             event.attacked_id,
         )
+
+    def on_eaten(self, event: EatenEvent):
+        self.main_layer.cells.eaten(
+            event.eaten_id,
+        )

sandbox/engulf/run.py

 sys.path.append(synergine2_ath)
 
 from random import randint, seed
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo, EatEvent, AttackEvent
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo, EatEvent, AttackEvent, EatenEvent
 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
         MoveTo,
         EatEvent,
         AttackEvent,
+        EatenEvent,
     ]
 
     def __init__(self, *args, **kwargs):

sandbox/engulf/simulation.py

         super().remove(value)
 
         if isinstance(value, Cell):
-            del self.cell_xyz[value.position]
+            try:
+                del self.cell_xyz[value.position]
+            except KeyError:
+                pass  # TODO: cE DICT DOIT CONTENIR DES LISTES DE SUBJECTS
 
         if isinstance(value, Grass):
             del self.grass_xyz[value.position]

sandbox/engulf/subject.py

 # coding: utf-8
-from sandbox.engulf.behaviour import GrowUp, SearchGrass, EatGrass, Explore, CellBehaviourSelector, Hungry, Attack
+from sandbox.engulf.behaviour import GrowUp, SearchGrass, EatGrass, Explore, CellBehaviourSelector, Hungry, Attack, \
+    SearchPrey, EatPrey
 from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS, \
     COLLECTION_PREY, COLLECTION_PREDATOR
 from synergine2.simulation import Subject
 
 class PredatorCell(Cell):
     collections = Cell.collections[:] + [COLLECTION_PREDATOR]
-    behaviours_classes = Cell.behaviours_classes[:] + [Attack]
+    behaviours_classes = Cell.behaviours_classes[:] + [SearchPrey, Attack, EatPrey]
 
 
 class Grass(XYZSubjectMixin, Subject):

synergine2/simulation.py

         config: Config,
         simulation: 'Simulation',
     ):
+        # TODO: Bannir les attribut de classe passé en reference ! Et meme virer les attr de classe tout court.
+        self.collections = self.collections[:]
+
         self.config = config
         self.id = id(self)  # We store object id because it's lost between process
         self.simulation = simulation

synergine2/xyz.py

 
     def remove(self, value: XYZSubjectMixin):
         super().remove(value)
-        del self.xyz[value.position]
+
+        try:
+            del self.xyz[value.position]
+        except KeyError:
+            pass  # TODO: cE DICT DOIT CONTENIR DES LISTES DE SUBJECTS
 
     def append(self, p_object: XYZSubjectMixin):
         super().append(p_object)