move behaviour with gui interract

sandbox/tile/const.py

+# coding: utf-8
+
+COLLECTION_ALIVE = 'ALIVE'

sandbox/tile/simulation/base.py

 # coding: utf-8
 from synergine2_xyz.simulation import XYZSimulation
-from synergine2_xyz.xyz import XYZSubject
 from synergine2_xyz.subjects import XYZSubjects
+from synergine2_xyz.subjects import XYZSubject
 
 
 class TileStrategySimulation(XYZSimulation):

sandbox/tile/simulation/subject.py

 # coding: utf-8
+from sandbox.tile.const import COLLECTION_ALIVE
 from sandbox.tile.simulation.base import BaseSubject
+from synergine2_xyz.move import MoveToBehaviour
 
 
 class Man(BaseSubject):
-    pass
+    collections = [
+        COLLECTION_ALIVE,
+    ]
+    behaviours_classes = [
+        MoveToBehaviour,
+    ]
+    # TODO: implement (copied from engulf)
+    # behaviour_selector_class = CellBehaviourSelector

synergine2/simulation.py

     pass
 
 
+class IntentionManager(object):
+    def __init__(self) -> None:
+        self.intentions = {}  # type: typing.Dict[typing.Type[Intention], Intention]
+
+    def set(self, intention: Intention) -> None:
+        self.intentions[type(intention)] = intention
+
+    def get(self, intention_type: typing.Type[Intention]) -> Intention:
+        return self.intentions[intention_type]
+
+
 class Subject(BaseObject):
     collections = []
     behaviours_classes = []
         self.simulation = simulation
         self.behaviours = {}
         self.mechanisms = {}
-        self.intentions = []  # type: typing.List[Intention]
+        self.intentions = IntentionManager()
         self.behaviour_selector = None  # type: SubjectBehaviourSelector
         if self.behaviour_selector_class:
             self.behaviour_selector = self.behaviour_selector_class()
 
 class SubjectBehaviour(BaseObject):
     frequency = 1
-    use = []
+    use = []  # type: typing.List[typing.Type[SubjectMechanism]]
 
     def __init__(
             self,

synergine2_cocos2d/terminal.py

 
     def receive(self, package: TerminalPackage):
         self.gui.before_received(package)
+        # TODO: pas d'event après le move: il faut subscribe je crois :p
         super().receive(package)
         self.gui.after_received(package)
 

synergine2_xyz/move.py

 import typing
 
 from synergine2.config import Config
-from synergine2.simulation import SimulationBehaviour, SubjectBehaviour
+from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import SubjectBehaviour
+from synergine2.simulation import SubjectMechanism
 from synergine2.simulation import Intention
 from synergine2.simulation import Simulation
 from synergine2.simulation import Event
     def __init__(self, move_to: typing.Tuple[int, int]) -> None:
         self.move_to = move_to
         self.path = []  # type: typing.List[typing.Tuple[int, int]]
-        self.path_progression = None  # type: int
+        self.path_progression = -1  # type: int
 
 
 class RequestMoveBehaviour(SimulationBehaviour):
 
         try:
             subject = self.simulation.subjects.index[subject_id]
-            subject.intentions.append(self.move_intention_class(move_to))
+            subject.intentions.set(self.move_intention_class(move_to))
         except KeyError:
             # TODO: log error here
             pass
         return []
 
 
+class MoveToMechanism(SubjectMechanism):
+    def run(self):
+        # TODO: Si move to: Si nouveau: a*, si bloque, a*, sinon rien
+        # TODO: pourquoi un mechanism plutot que dans run du behaviour ? faire en sorte que lorsque on calcule,
+        # si un subject est déjà passé par là et qu'il va au même endroit, ne pas recalculer.
+        try:
+            # TODO: MoveToIntention doit être configurable
+            move = self.subject.intentions.get(MoveToIntention)
+            move = typing.cast(MoveToIntention, move)
+            new_path = move.path or None
+
+            if not move.path:
+                # TODO: Fake to test
+                new_path = []
+                for i in range(20):
+                    new_path.append((
+                        self.subject.position[0],
+                        self.subject.position[1] + i,
+                    ))
+
+            next_move = new_path[move.path_progression + 1]
+            # TODO: fin de path
+            if not self.simulation.is_possible_position(next_move):
+                # TODO: refaire le path
+                new_path = ['...']
+
+            return {
+                'new_path': new_path,
+            }
+
+        except KeyError:
+            return None
+
+
+class MoveEvent(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 MoveToBehaviour(SubjectBehaviour):
+    use = [MoveToMechanism]
+    move_to_mechanism = MoveToMechanism
+
     def run(self, data):
-        # TODO: progresser dans l'intention (comment implementer ça?)
-        raise NotImplementedError()
+        # TODO: on fait vraiment rien ici ? Note: meme si il n'y a pas de new_path, l'action doit s'effectuer
+        # du moment qu'il y a une intention de move
+        move_to_data = data[self.move_to_mechanism]
+        if move_to_data:
+            return move_to_data
+        return False
 
     def action(self, data) -> [Event]:
         # TODO: effectuer un move vers une nouvelle position ou faire progresser "l'entre-deux"
-        raise NotImplementedError()
+        new_path = data['new_path']
+        try:
+            # TODO: MoveToIntention doit être configurable
+            move = self.subject.intentions.get(MoveToIntention)
+            move = typing.cast(MoveToIntention, move)
+
+            if new_path:
+                move.path = new_path
+                move.path_progression = -1
+
+            # TODO: progression et lorsque "vraiment avance d'une case" envoyer le Move
+            # pour le moment on move direct
+            # TODO: fin de path
+            move.path_progression += 1  # BUG: ca progresse pas ?
+            new_position = move.path[move.path_progression]
+            self.subject.position = new_position
+
+            return [MoveEvent(self.subject.id, new_position)]
+
+        except KeyError:
+            # TODO: log ? Il devrait y avoir un move puisque data du run/mechanism !
+            pass

synergine2_xyz/simulation.py

 import typing
 
 from synergine2.simulation import Simulation as BaseSimulation
-from synergine2_xyz.xyz import XYZSubject
 from synergine2_xyz.subjects import XYZSubjects
+from synergine2_xyz.subjects import XYZSubject
 
 
 class XYZSimulation(BaseSimulation):

synergine2_xyz/subjects.py

 # coding: utf-8
 from synergine2.simulation import Subjects
-from synergine2_xyz.xyz import XYZSubjectMixin, PositionNotPossible
+from synergine2.simulation import Subject
+from synergine2_xyz.xyz import XYZSubjectMixin
+from synergine2_xyz.xyz import PositionNotPossible
 
 
 class XYZSubjects(Subjects):
                 str(p_object),
             ))
 
-        self.xyz.setdefault(p_object.position, []).append(p_object)
+        self.xyz.setdefault(p_object.position, []).append(p_object)
+
+
+class XYZSubject(XYZSubjectMixin, Subject):
+    pass

synergine2_xyz/xyz.py

         self._position = value
 
 
-class XYZSubject(XYZSubjectMixin, Subject):
-    pass
-
-
 class ProximityMixin(object):
     distance = 1
     feel_collections = [COLLECTION_XYZ]