move sync with interface

requirements.txt

 coverage==4.4.1
 Dijkstar==2.2
 execnet==1.4.1
+freezegun==0.3.9
 numpy==1.13.1
 packaging==16.8
 psutil==5.2.2
 pytest-cov==2.5.1
 pytest-timeout==1.2.0
 pytest-xdist==1.16.0
+python-dateutil==2.6.1
 PyYAML==3.12
 redis==2.10.6
 six==1.10.0

sandbox/tile/config.yaml

 core:
-    cycle_duration: 0.125
+    cycle_duration: 0.25
     use_x_cores: 1
 terminals:
     sync: True
+game:
+    move:
+        walk_ref_time: 3
+        run_ref_time: 1.5

sandbox/tile/gui/actor.py

             'actors/man_w5.png',
             'actors/man_w6.png',
             'actors/man_w7.png',
-            'actors/man_w8.png',
-            'actors/man_w9.png',
-            'actors/man_w10.png',
         ],
         # ANIMATION_CRAWL: [
         #     'actors/man_c1.png',

sandbox/tile/terminal/base.py

 from sandbox.tile.simulation.subject import Man as ManSubject
 from sandbox.tile.gui.actor import Man as ManActor
 from synergine2_cocos2d.terminal import GameTerminal
-from synergine2_xyz.move import MoveEvent
+from synergine2_xyz.move import FinishMoveEvent
+from synergine2_xyz.move import StartMoveEvent
 
 
 class CocosTerminal(GameTerminal):
     subscribed_events = [
-        MoveEvent,
+        FinishMoveEvent,
+        StartMoveEvent,
     ]
 
     def __init__(self, *args, asynchronous: bool, map_dir_path: str, **kwargs):

synergine2_cocos2d/gui.py

 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.middleware import TMXMiddleware
 from synergine2_cocos2d.user_action import UserAction
-from synergine2_xyz.move import MoveEvent
+from synergine2_xyz.move import FinishMoveEvent
+from synergine2_xyz.move import StartMoveEvent
 from synergine2_xyz.utils import get_angle
 from synergine2_xyz.xyz import XYZSubjectMixin
 
         )
 
         self.terminal.register_event_handler(
-            MoveEvent,
-            self.move_subject,
+            FinishMoveEvent,
+            self.set_subject_position,
         )
 
+        self.terminal.register_event_handler(
+            StartMoveEvent,
+            self.start_move_subject,
+        )
+
+        # configs
+        self.move_duration_ref = float(self.config.resolve('game.move.walk_ref_time'))
+
     def get_layer_middleware(self) -> MapMiddleware:
         return TMXMiddleware(
             self.config,
         subject_mapper = self.subject_mapper_factory.get_subject_mapper(subject)
         subject_mapper.append(subject, self.layer_manager)
 
-    def move_subject(self, event: MoveEvent):
+    def set_subject_position(self, event: FinishMoveEvent):
         actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
+        new_world_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(event.to_position)
+
+        actor.set_position(*new_world_position)
 
+    def start_move_subject(self, event: StartMoveEvent):
+        actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
         new_world_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(event.to_position)
 
-        move_action = MoveTo(new_world_position, 0.5)
+        move_action = MoveTo(new_world_position, self.move_duration_ref)
         actor.do(move_action)
-        actor.do(Animate(ANIMATION_WALK, 0.5, 1))
+        actor.do(Animate(ANIMATION_WALK, duration=self.move_duration_ref, cycle_duration=2))
         actor.rotation = get_angle(event.from_position, event.to_position)

synergine2_cocos2d/interaction.py

                 )
 
     def get_package_for_terminal(self) -> TerminalPackage:
-        # TODO: MoveEvent ?
+        # TODO: FinishMoveEvent ?
         actions = []
         mouse_grid_position = self.layer_manager.grid_manager.get_grid_position(
             self.layer_manager.scrolling_manager.screen_to_world(

synergine2_xyz/move.py

 # coding: utf-8
 import typing
+from random import randint
+
+import time
 
 from synergine2.config import Config
-from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import SimulationBehaviour, Subject
 from synergine2.simulation import SubjectBehaviour
 from synergine2.simulation import SubjectMechanism
 from synergine2.simulation import Intention
 
 
 class MoveToIntention(Intention):
-    def __init__(self, move_to: typing.Tuple[int, int]) -> None:
+    def __init__(
+        self,
+        move_to: typing.Tuple[int, int],
+        start_time: float,
+    ) -> None:
         self.move_to = move_to
         self.path = []  # type: typing.List[typing.Tuple[int, int]]
         self.path_progression = -1  # type: int
+        self.last_intention_time = start_time
+        self.just_reach = False
+        self.initial = True
 
 
 class RequestMoveBehaviour(SimulationBehaviour):
 
         try:
             subject = self.simulation.subjects.index[subject_id]
-            subject.intentions.set(self.move_intention_class(move_to))
+            subject.intentions.set(self.move_intention_class(move_to, start_time=time.time()))
         except KeyError:
             # TODO: log error here
             pass
 
             return {
                 'new_path': new_path,
+                'last_intention_time': move.last_intention_time,
+                'just_reach': move.just_reach,
+                'initial': move.initial,
             }
 
         except IndexError:  # TODO: Specialize ? No movement left
             return None
 
 
-class MoveEvent(Event):
+class FinishMoveEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        from_position: typing.Tuple[int, int],
+        to_position: typing.Tuple[int, int],
+        *args,
+        **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self.subject_id = subject_id
+        self.from_position = from_position
+        self.to_position = to_position
+
+    def repr_debug(self) -> str:
+        return '{}: subject_id:{}, from_position:{} to_position: {}'.format(
+            type(self).__name__,
+            self.subject_id,
+            self.from_position,
+            self.to_position,
+        )
+
+
+class StartMoveEvent(Event):
     def __init__(
         self,
         subject_id: int,
     use = [MoveToMechanism]
     move_to_mechanism = MoveToMechanism
 
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+        subject: Subject,
+    ) -> None:
+        super().__init__(config, simulation, subject)
+        self._duration = float(self.config.resolve('game.move.walk_ref_time'))
+
     def run(self, data):
         # 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:
+
+            if time.time() - move_to_data['last_intention_time'] >= self._duration:
+                move_to_data['reach_next'] = True
+            elif move_to_data['just_reach'] or move_to_data['initial']:
+                move_to_data['reach_next'] = False
+            else:
+                return False
+
             return move_to_data
+
         return False
 
     def action(self, data) -> [Event]:
                 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
-            new_position = move.path[move.path_progression]
             previous_position = self.subject.position
-            self.subject.position = new_position
+            new_position = move.path[move.path_progression + 1]
+
+            if data['reach_next']:
+                # TODO: fin de path
+                move.path_progression += 1
+                self.subject.position = new_position
+                move.last_intention_time = time.time()
+                move.just_reach = True
+                event = FinishMoveEvent(self.subject.id, previous_position, new_position)
+            else:
+                move.just_reach = False
+                event = StartMoveEvent(self.subject.id, previous_position, new_position)
+
+            move.initial = False
+            # Note: Need to explicitly set to update shared data
             self.subject.intentions.set(move)
 
-            return [MoveEvent(self.subject.id, previous_position, new_position)]
+            return [event]
 
         except KeyError:
             # TODO: log ? Il devrait y avoir un move puisque data du run/mechanism !

tests/test_move.py

+# coding: utf-8
+import time
+
+from freezegun import freeze_time
+
+from synergine2.config import Config
+from synergine2_xyz.move import MoveToBehaviour, MoveToMechanism, MoveToIntention, StartMoveEvent, FinishMoveEvent
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.subjects import XYZSubject
+from tests import BaseTest
+
+
+class MySubject(XYZSubject):
+    pass
+
+
+class MySimulation(XYZSimulation):
+    pass
+
+
+class TestMove(BaseTest):
+    def test_behaviour_cycle(self):
+        config = Config({
+            'game': {
+                'move': {
+                    'walk_ref_time': 2,
+                }
+            }
+        })
+        simulation = MySimulation(config)
+        subject = MySubject(config, simulation)
+        behaviour = MoveToBehaviour(config, simulation, subject)
+
+        with freeze_time("2000-01-01 00:00:00"):
+            move_intention = MoveToIntention((0, 3), time.time())
+
+            assert move_intention.path_progression == -1
+            assert move_intention.just_reach is False
+            assert move_intention.initial is True
+
+            subject.intentions.set(move_intention)
+            move_data = {
+                'new_path': [(0, 1), (0, 2)],
+                'last_intention_time': time.time(),
+                'just_reach': False,
+                'initial': True,
+            }
+            data = {
+                MoveToMechanism: move_data,
+            }
+            run_data = behaviour.run(data)
+
+            assert move_data == run_data
+            events = behaviour.action(run_data)
+
+        assert events
+        assert 1 == len(events)
+        assert isinstance(events[0], StartMoveEvent)
+
+        assert move_intention.path_progression == -1
+        assert move_intention.just_reach is False
+        assert move_intention.initial is False
+
+        # Update data like mechanism do it
+        move_data['last_intention_time'] = move_intention.last_intention_time
+        move_data['just_reach'] = move_intention.just_reach
+        move_data['initial'] = move_intention.initial
+
+        # Only one second, no reach
+        with freeze_time("2000-01-01 00:00:01"):
+            run_data = behaviour.run(data)
+
+        assert run_data is False
+
+        # Two second, step reach
+        with freeze_time("2000-01-01 00:00:02"):
+            run_data = behaviour.run(data)
+
+            assert {
+                       'new_path': [(0, 1), (0, 2)],
+                       'initial': False,
+                       'just_reach': False,
+                       'last_intention_time': 946684800.0,
+                       'reach_next': True,
+                   } == run_data
+
+            events = behaviour.action(run_data)
+
+            assert events
+            assert 1 == len(events)
+            assert isinstance(events[0], FinishMoveEvent)
+
+        # Update data like mechanism do it
+        move_data['last_intention_time'] = move_intention.last_intention_time
+        move_data['just_reach'] = move_intention.just_reach
+        move_data['initial'] = move_intention.initial
+
+        # Three seconds, start a new move
+        with freeze_time("2000-01-01 00:00:03"):
+            run_data = behaviour.run(data)
+
+            assert {
+                       'new_path': [(0, 1), (0, 2)],
+                       'initial': False,
+                       'just_reach': True,
+                       'last_intention_time': 946684802.0,
+                       'reach_next': False,
+                   } == run_data
+
+            events = behaviour.action(run_data)
+
+            assert events
+            assert 1 == len(events)
+            assert isinstance(events[0], StartMoveEvent)
+
+        # Update data like mechanism do it
+        move_data['last_intention_time'] = move_intention.last_intention_time
+        move_data['just_reach'] = move_intention.just_reach
+        move_data['initial'] = move_intention.initial
+
+        # Four seconds, start a new move
+        with freeze_time("2000-01-01 00:00:04"):
+            run_data = behaviour.run(data)
+
+            assert {
+                       'new_path': [(0, 1), (0, 2)],
+                       'initial': False,
+                       'just_reach': False,
+                       'last_intention_time': 946684802.0,
+                       'reach_next': True,
+                   } == run_data
+
+            events = behaviour.action(run_data)
+
+            assert events
+            assert 1 == len(events)
+            assert isinstance(events[0], FinishMoveEvent)