engulf: cel movement

requirements.txt

+appdirs==1.4.2
 cocos2d==0.6.4
+packaging==16.8
+pkg-resources==0.0.0
 py==1.4.31
 pyglet==1.2.4
+pymlconf==0.7.0
+pyparsing==2.1.10
 pytest==3.0.4
+PyYAML==3.12
 six==1.10.0

sandbox/engulf/behaviour.py

 # coding: utf-8
+from random import randint
+
+from sandbox.engulf.const import COLLECTION_GRASS
 from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour
 from synergine2.simulation import Event
 from synergine2.utils import ChunkManager
-from synergine2.xyz_utils import get_around_positions_of_positions
+from synergine2.xyz import ProximitySubjectMechanism
+from synergine2.xyz_utils import get_around_positions_of_positions, get_around_positions_of
 
 
 class GrassGrownUp(Event):
                 ))
 
         return events
+
+
+class EatableDirectProximityMechanism(ProximitySubjectMechanism):
+    distance = 1.41  # distance when on angle
+    feel_collections = [COLLECTION_GRASS]
+
+
+class MoveTo(Event):
+    def __init__(self, subject_id: int, position: tuple, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.subject_id = subject_id
+        self.position = position
+
+    def repr_debug(self) -> str:
+        return '{}: subject_id:{}, position:{}'.format(
+            type(self).__name__,
+            self.subject_id,
+            self.position,
+        )
+
+
+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):
+        pass
+
+
+class Eat(SubjectBehaviour):
+    """
+    Prduit un immobilisme si sur une case de nourriture, dans le cas ou la cellule n'est as rassasié.
+    """
+    def run(self, data):
+        pass
+
+
+class Explore(SubjectBehaviour):
+    """
+    Produit un mouvement au hasard (ou un immobilisme)
+    """
+    use = []
+
+    def action(self, data) -> [Event]:
+        position = self.get_random_around_position()
+        return [MoveTo(self.subject.id, position)]
+
+    def run(self, data):
+        return True  # for now, want move every time
+
+    def get_random_around_position(self):
+        around_positions = get_around_positions_of(self.subject.position)
+        return around_positions[randint(0, len(around_positions)-1)]

sandbox/engulf/config.yaml

+core:
+    cycle_duration: 0.5
+terminals:
+    sync: True

sandbox/engulf/const.py

+# coding: utf-8
+
+
+COLLECTION_CELL = 'CELL'
+COLLECTION_ALIVE = 'ALIVE'
+COLLECTION_EATABLE = 'EATABLE'
+COLLECTION_GRASS = 'GRASS'

sandbox/engulf/gui.py

 from random import randint
 
 import cocos
+from cocos.actions import MoveTo, Repeat, ScaleBy, Reverse, RotateTo
 from cocos.sprite import Sprite
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent
 from sandbox.engulf.subject import Cell, Grass
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
 from synergine2_cocos2d.gui import MainLayer as BaseMainLayer
 
+cell_scale = ScaleBy(1.1, duration=0.25)
+
 
 class CellsLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, game: 'Game', *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self.cells = {}
+        self.game = game
+        self.cell_positions = {}
+        self.cell_ids = {}
+
+    @property
+    def move_duration(self):
+        return self.game.cycle_duration
+
+    @property
+    def fake_move_rotate_duration(self):
+        return self.move_duration / 3
 
-    def born(self, grid_position):
+    def born(self, subject_id: int, grid_position):
         cell = Sprite('resources/cell.png')
         cell.rotation = randint(0, 360)
         self.grid_manager.scale_sprite(cell)
         self.grid_manager.position_sprite(cell, grid_position)
-        self.cells[grid_position] = cell
+        self.cell_positions[grid_position] = cell
+        self.cell_ids[subject_id] = cell
+        cell.do(Repeat(cell_scale + Reverse(cell_scale)))
         self.add(cell)
 
+    def move(self, subject_id: int, position: tuple):
+        cell = self.cell_ids[subject_id]
+
+        window_position = self.grid_manager.get_window_position(position[0], position[1])
+        move_action = MoveTo(window_position, self.move_duration)
+
+        fake_rotate = RotateTo(randint(0, 360), self.fake_move_rotate_duration)
+
+        cell.do(move_action)
+        cell.do(fake_rotate)
+
 
 class GrassLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, game: 'Game', *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.game = game
         self.grasses = {}
 
     def born(self, subject_id, grid_position, opacity=100):
 
 
 class MainLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, terminal, *args, **kwargs):
+    def __init__(self, game: 'Game', terminal, *args, **kwargs):
         super().__init__(terminal, *args, **kwargs)
+        self.game = game
 
-        self.cells = CellsLayer(terminal=terminal)
+        self.cells = CellsLayer(game=game, terminal=terminal)
         self.add(self.cells)
 
-        self.grasses = GrassLayer(terminal=terminal)
+        self.grasses = GrassLayer(game=game, terminal=terminal)
         self.add(self.grasses)
 
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-        self.main_layer = MainLayer(terminal=self.terminal)
+        self.main_layer = MainLayer(game=self, terminal=self.terminal)
         self.main_scene = cocos.scene.Scene(self.main_layer)
 
+        # Event registering
         self.terminal.register_event_handler(
             GrassGrownUp,
             self.on_grass_grown_up,
             GrassSpawn,
             self.on_grass_spawn,
         )
+        self.terminal.register_event_handler(
+            MoveToEvent,
+            self.on_move_to,
+        )
 
     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.main_layer.cells.born(subject.position)
+                    self.main_layer.cells.born(subject.id, subject.position)
                 if isinstance(subject, Grass):
                     self.main_layer.grasses.born(
                         subject.id,
             event.subject_id,
             event.density,  # TODO: Recupe ces données depuis local plutôt que event ?
         )
+
+    def on_move_to(self, event: MoveToEvent):
+        self.main_layer.cells.move(
+            event.subject_id,
+            event.position,
+        )

sandbox/engulf/run.py

 sys.path.append(synergine2_ath)
 
 from random import randint, seed
-from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, GrassSpawnBehaviour
+from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, GrassSpawnBehaviour, MoveTo
 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
-from sandbox.engulf.subject import Cell, Grass, COLLECTION_GRASS
+from sandbox.engulf.subject import Cell, Grass
+from sandbox.engulf.const import COLLECTION_GRASS
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
     subscribed_events = [
         GrassGrownUp,
         GrassSpawn,
+        MoveTo,
     ]
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.gui = None
+        self.asynchronous = False  # TODO: config
 
     def receive(self, package: TerminalPackage):
         self.gui.before_received(package)
 
     def run(self):
         from sandbox.engulf import gui
-        self.gui = gui.Game(self)
+        self.gui = gui.Game(self.config, self.logger, self)
         self.gui.run()
 
 
     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,
             terminals=[GameTerminal(
+                config,
+                logger,
                 asynchronous=False,
             )]
         ),
-        cycles_per_seconds=1,
+        cycles_per_seconds=1/config.core.cycle_duration,
     )
     core.run()
 

sandbox/engulf/subject.py

 # coding: utf-8
-from sandbox.engulf.behaviour import GrowUp
+from sandbox.engulf.behaviour import GrowUp, SearchFood, Eat, Explore
+from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS
 from synergine2.simulation import Subject
 from synergine2.xyz import XYZSubjectMixin
 
-COLLECTION_CELL = 'CELL'
-COLLECTION_ALIVE = 'ALIVE'
-COLLECTION_EATABLE = 'EATABLE'
-COLLECTION_GRASS = 'GRASS'
-
 
 class Cell(XYZSubjectMixin, Subject):
     collections = [
         COLLECTION_ALIVE,
         COLLECTION_EATABLE,
     ]
+    behaviours_classes = [
+        SearchFood,
+        Eat,
+        Explore,
+    ]
 
 
 class Grass(XYZSubjectMixin, Subject):

sandbox/life_game/gui.py

 from sandbox.life_game.simulation import CellBornEvent
 from sandbox.life_game.simulation import CellDieEvent, Cell, InvertCellStateBehaviour, \
     EmptyPositionWithLotOfCellAroundEvent
+from synergine2.config import Config
+from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.gui import Gui, GridLayerMixin, MainLayer as BaseMainLayer
 class LifeGameGui(Gui):
     def __init__(
             self,
+            config: Config,
+            logger: SynergineLogger,
             terminal: Terminal,
             read_queue_interval: float=1 / 60.0,
     ):
-        super().__init__(terminal, read_queue_interval)
+        super().__init__(config, logger, terminal, read_queue_interval)
 
         self.main_layer = MainLayer(terminal=self.terminal)
         self.main_scene = cocos.scene.Scene(self.main_layer)

sandbox/life_game/run.py

         CellBornEvent,
     ]
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self._cycle_born_count = 0
         self._cycle_die_count = 0
         self.register_event_handler(CellDieEvent, self.record_die)
         EmptyPositionWithLotOfCellAroundEvent,
     ]
 
-    def __init__(self):
-        super().__init__()
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         self.subjects = None
         self.gui = None
 
 
     def run(self):
         from sandbox.life_game import gui
-        self.gui = gui.LifeGameGui(self)
+        self.gui = gui.LifeGameGui(self.config, self.logger, self)
         self.gui.run()
 
 
         terminal_manager=TerminalManager(
             config=config,
             logger=logger,
-            terminals=[CocosTerminal(), SimplePrintTerminal()]
+            terminals=[
+                CocosTerminal(config, logger),
+                SimplePrintTerminal(config, logger),
+            ]
         ),
     )
     core.run()

synergine2/config.py

 # coding: utf-8
+from pymlconf import ConfigManager
 
 
-class Config(dict):
+class Config(ConfigManager):
     pass

synergine2/terminals.py

     # who are not instance of listed classes
     subscribed_events = [Event]
 
-    def __init__(self, asynchronous: bool=True):
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        asynchronous: bool=True,
+    ):
+        self.config = config
+        self.logger = logger
         self._input_queue = None
         self._output_queue = None
         self._stop_required = False

synergine2_cocos2d/gui.py

 from cocos.layer import ScrollableLayer, Layer
 from cocos.sprite import Sprite
 
+from synergine2.config import Config
+from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 
 class Gui(object):
     def __init__(
             self,
+            config: Config,
+            logger: SynergineLogger,
             terminal: Terminal,
             read_queue_interval: float= 1/60.0,
     ):
+        self.config = config
+        self.logger = logger,
         self._read_queue_interval = read_queue_interval
         self.terminal = terminal
+        self.cycle_duration = self.config.core.cycle_duration
         cocos.director.director.init()
 
     def run(self):