engulf: prey and predator

sandbox/engulf/behaviour.py

 import typing
 from random import choice
 
-from sandbox.engulf.const import COLLECTION_GRASS
+from sandbox.engulf.const import COLLECTION_GRASS, COLLECTION_CELL
 from sandbox.engulf.exceptions import NotFoundWhereToGo
 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, DIRECTION_FROM_NORTH_DEGREES, \
-    get_direction_from_north_degree
-from synergine2.xyz_utils import get_around_positions_of_positions, get_around_positions_of, get_position_for_direction
+from synergine2.xyz import ProximitySubjectMechanism, DIRECTIONS, DIRECTION_SLIGHTLY, get_direction_from_north_degree
+from synergine2.xyz_utils import get_around_positions_of_positions, get_position_for_direction
 
 # Import for typing hint
 if False:
     from sandbox.engulf.subject import Grass
+    from sandbox.engulf.subject import PreyCell
 
 
 class GrassGrownUp(Event):
         return events
 
 
-class EatableDirectProximityMechanism(ProximitySubjectMechanism):
+class GrassEatableDirectProximityMechanism(ProximitySubjectMechanism):
     distance = 1.41  # distance when on angle
     feel_collections = [COLLECTION_GRASS]
 
         return subject.density >= self.config.simulation.eat_grass_required_density
 
 
+class PreyEatableDirectProximityMechanism(ProximitySubjectMechanism):
+    distance = 1.41  # distance when on angle
+    feel_collections = [COLLECTION_CELL]
+
+    def acceptable_subject(self, subject: 'PreyCell') -> bool:
+        # TODO: N'attaquer que des "herbivores" ?
+        from sandbox.engulf.subject import PreyCell  # cyclic
+        return isinstance(subject, PreyCell)
+
+
 class MoveTo(Event):
     def __init__(self, subject_id: int, position: tuple, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.eaten_new_density = eaten_new_density
 
 
-class SearchFood(SubjectBehaviour):
+class AttackEvent(Event):
+    def __init__(self, attacker_id: int, attacked_id: int, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.attacker_id = attacker_id
+        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 = [EatableDirectProximityMechanism]
+    use = [GrassEatableDirectProximityMechanism]
 
     def run(self, data):
         if self.subject.appetite < self.config.simulation.search_food_appetite_required:
             return False
 
-        if not data[EatableDirectProximityMechanism]:
+        if not data[GrassEatableDirectProximityMechanism]:
             return False
 
-        direction_degrees = [d['direction'] for d in data[EatableDirectProximityMechanism]]
+        direction_degrees = [d['direction'] for d in data[GrassEatableDirectProximityMechanism]]
         return get_direction_from_north_degree(choice(direction_degrees))
 
     def action(self, data) -> [Event]:
         return [MoveTo(self.subject.id, position)]
 
 
-class Eat(SubjectBehaviour):
+class EatGrass(SubjectBehaviour):
     """
     Prduit un immobilisme si sur une case de nourriture, dans le cas ou la cellule n'est as rassasié.
     """
         return choice(DIRECTION_SLIGHTLY[self.subject.previous_direction])
 
 
+class Attack(SubjectBehaviour):
+    use = [PreyEatableDirectProximityMechanism]
+
+    def run(self, data):
+        if data[PreyEatableDirectProximityMechanism]:
+            return choice(data[PreyEatableDirectProximityMechanism])
+        return False
+
+    def action(self, data) -> [Event]:
+        # TODO: Dommages / mort
+        return [AttackEvent(attacker_id=self.subject.id, attacked_id=data['subject'].id)]
+
+
 class CellBehaviourSelector(SubjectBehaviourSelector):
     # If behaviour in sublist, only one be kept in sublist
     behaviour_hierarchy = (  # TODO: refact it
         (
-            Eat,  # TODO: Introduce priority with appetite
-            SearchFood,  # TODO: Introduce priority with appetite
+            EatGrass,  # TODO: Introduce priority with appetite
+            SearchGrass,  # TODO: Introduce priority with appetite
             Explore,
         ),
     )

sandbox/engulf/const.py

 
 
 COLLECTION_CELL = 'CELL'
+COLLECTION_PREY = 'PREY'
+COLLECTION_PREDATOR = 'PREDATOR'
 COLLECTION_ALIVE = 'ALIVE'
 COLLECTION_EATABLE = 'EATABLE'
 COLLECTION_GRASS = 'GRASS'

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
-from sandbox.engulf.subject import Cell, Grass
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent, EatEvent, AttackEvent
+from sandbox.engulf.subject import Cell, Grass, PreyCell, PredatorCell
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
 from synergine2_cocos2d.gui import MainLayer as BaseMainLayer
     def fake_move_rotate_duration(self):
         return self.move_duration / 3
 
-    def born(self, subject_id: int, grid_position):
-        cell = Sprite('resources/cell.png')
+    def born(self, subject_id: int, grid_position, cell_type):
+        png = 'resources/cell.png' if cell_type is PreyCell else 'resources/cellp.png'
+
+        cell = Sprite(png)
         cell.rotation = randint(0, 360)
         self.grid_manager.scale_sprite(cell)
         self.grid_manager.position_sprite(cell, grid_position)
         cell.do(move_action)
         cell.do(fake_rotate)
 
+    def attack(self, attacker_id: int, attacked_id: int):
+        attacker = self.cell_ids[attacker_id]
+        attacker.do(ScaleBy(1.7, duration=0.25))
+
 
 class GrassLayer(GridLayerMixin, BaseMainLayer):
     def __init__(self, game: 'Game', *args, **kwargs):
             EatEvent,
             self.on_eat,
         )
+        self.terminal.register_event_handler(
+            AttackEvent,
+            self.on_attack,
+        )
 
     def get_main_scene(self):
         return self.main_scene
     def before_received(self, package: TerminalPackage):
         if package.subjects:  # It's thirst package
             for subject in package.subjects:
-                if isinstance(subject, Cell):
-                    self.main_layer.cells.born(subject.id, subject.position)
+                if isinstance(subject, PreyCell):
+                    self.main_layer.cells.born(subject.id, subject.position, PreyCell)
+                if isinstance(subject, PredatorCell):
+                    self.main_layer.cells.born(subject.id, subject.position, PredatorCell)
                 if isinstance(subject, Grass):
                     self.main_layer.grasses.born(
                         subject.id,
             event.eaten_id,
             event.eaten_new_density,
         )
+
+    def on_attack(self, event: AttackEvent):
+        self.main_layer.cells.attack(
+            event.attacker_id,
+            event.attacked_id,
+        )

sandbox/engulf/run.py

 import logging
 import os
 import sys
+import typing
 
 synergine2_ath = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
 sys.path.append(synergine2_ath)
 
 from random import randint, seed
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo, EatEvent
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo, EatEvent, AttackEvent
 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
-from sandbox.engulf.subject import Cell, Grass
+from sandbox.engulf.subject import Cell, Grass, PreyCell, PredatorCell
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
         GrassSpawn,
         MoveTo,
         EatEvent,
+        AttackEvent,
     ]
 
     def __init__(self, *args, **kwargs):
     count: int,
     start_position: tuple,
     end_position: tuple,
+    cell_class: typing.Type[PreyCell],
 ) -> None:
     cells = []
 
             0,
         )
         if position not in subjects.cell_xyz:
-            cell = Cell(
+            cell = cell_class(
                 config,
                 simulation=subjects.simulation,
                 position=position,
     for grass in grasses:
         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,
-                )
-                distance = get_distance_between_points(around, grass.position)
-                new_grass.density = 100 - round((distance * 100) / 7)
-                subjects.append(new_grass)
+                if subjects.simulation.is_possible_position(around):
+                    new_grass = Grass(
+                        config,
+                        simulation=subjects.simulation,
+                        position=around,
+                    )
+                    distance = get_distance_between_points(around, grass.position)
+                    new_grass.density = 100 - round((distance * 100) / 7)
+                    subjects.append(new_grass)
 
 
 def main():
-    seed(0)
+    seed(42)
 
     config = Config()
     config.load_files(['sandbox/engulf/config.yaml'])
         30,
         (-34, -34, 0),
         (34, 34, 0),
+        cell_class=PreyCell,
+    )
+    fill_with_random_cells(
+        config,
+        subjects,
+        30,
+        (-34, -34, 0),
+        (34, 34, 0),
+        cell_class=PredatorCell,
     )
     fill_with_random_grass(
         config,

sandbox/engulf/subject.py

 # coding: utf-8
-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 sandbox.engulf.behaviour import GrowUp, SearchGrass, EatGrass, Explore, CellBehaviourSelector, Hungry, Attack
+from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS, \
+    COLLECTION_PREY, COLLECTION_PREDATOR
 from synergine2.simulation import Subject
 from synergine2.xyz import XYZSubjectMixin
 
     ]
     # TODO: Mettre en place la "selection/choix": car il y a deux move possible chaque cycle ci-dessous.
     behaviours_classes = [
-        SearchFood,
-        Eat,
         Explore,
         Hungry,
     ]
             self._appetite = value
 
 
+class PreyCell(Cell):
+    collections = Cell.collections[:] + [COLLECTION_PREY]
+    behaviours_classes = Cell.behaviours_classes[:] + [SearchGrass, EatGrass]
+
+
+class PredatorCell(Cell):
+    collections = Cell.collections[:] + [COLLECTION_PREDATOR]
+    behaviours_classes = Cell.behaviours_classes[:] + [Attack]
+
+
 class Grass(XYZSubjectMixin, Subject):
     collections = [
         COLLECTION_EATABLE,