implement run

sandbox/tile/config.yaml

 game:
     move:
         walk_ref_time: 3
-        run_ref_time: 1.5
+        run_ref_time: 1

sandbox/tile/gui/base.py

 # coding: utf-8
 from synergine2_cocos2d.gui import TMXGui
 from synergine2_cocos2d.interaction import MoveActorInteraction
+from synergine2_cocos2d.interaction import MoveFastActorInteraction
 
 
 class Game(TMXGui):
     def before_run(self) -> None:
         self.layer_manager.interaction_manager.register(MoveActorInteraction, self.layer_manager)
+        self.layer_manager.interaction_manager.register(MoveFastActorInteraction, self.layer_manager)
 
         # Test
         # from sandbox.tile.gui.actor import Man

synergine2_cocos2d/actor.py

         self.current_image = image
         self.need_update_cshape = False
 
+    def stop_actions(self, action_types: typing.Tuple[typing.Type[cocos.actions.Action], ...]) -> None:
+        for action in self.actions:
+            if isinstance(action, action_types):
+                self.remove_action(action)
+
     def update_cshape(self) -> None:
         self.cshape = collision_model.AARectShape(
             euclid.Vector2(self.position[0], self.position[1]),

synergine2_cocos2d/gui.py

 from cocos import collision_model
 from cocos import euclid
 from cocos.layer import ScrollableLayer
+from cocos.actions import MoveTo as BaseMoveTo
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
         if self.selection:
             if k == key.M:
                 self.user_action_pending = UserAction.ORDER_MOVE
+            if k == key.R:
+                self.user_action_pending = UserAction.ORDER_MOVE_FAST
 
         if k in binds:
             self.buttons[binds[k]] = 1
 
         # configs
         self.move_duration_ref = float(self.config.resolve('game.move.walk_ref_time'))
+        self.move_fast_duration_ref = float(self.config.resolve('game.move.run_ref_time'))
 
     def get_layer_middleware(self) -> MapMiddleware:
         return TMXMiddleware(
         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.stop_actions((BaseMoveTo,))
         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, self.move_duration_ref)
+        if event.gui_action == UserAction.ORDER_MOVE:
+            animation = ANIMATION_WALK
+            cycle_duration = 2
+            move_duration = self.move_duration_ref
+        elif event.gui_action == UserAction.ORDER_MOVE_FAST:
+            animation = ANIMATION_WALK
+            cycle_duration = 0.5
+            move_duration = self.move_fast_duration_ref
+        else:
+            raise NotImplementedError()
+
+        move_action = MoveTo(new_world_position, move_duration)
         actor.do(move_action)
-        actor.do(Animate(ANIMATION_WALK, duration=self.move_duration_ref, cycle_duration=2))
+        actor.do(Animate(animation, duration=move_duration, cycle_duration=cycle_duration))
         actor.rotation = get_angle(event.from_position, event.to_position)

synergine2_cocos2d/interaction.py

         raise NotImplementedError()
 
 
-class MoveActorInteraction(Interaction):
-    gui_action = UserAction.ORDER_MOVE
+class BaseMoveActorInteraction(Interaction):
+    gui_action = None
+    color = None
     request_move_behaviour_class = RequestMoveBehaviour
 
     def draw_pending(self) -> None:
                 draw_line(
                     self.layer_manager.scrolling_manager.world_to_screen(*pixel_position),
                     self.layer_manager.edit_layer.screen_mouse,
-                    (0, 0, 255),
+                    self.color,
                 )
 
     def get_package_for_terminal(self) -> TerminalPackage:
                 self.request_move_behaviour_class, {
                     'subject_id': actor.subject.id,
                     'move_to': mouse_grid_position,
+                    'gui_action': self.gui_action,
                 }
             ))
 
         return TerminalPackage(
             simulation_actions=actions,
         )
+
+
+class MoveActorInteraction(BaseMoveActorInteraction):
+    gui_action = UserAction.ORDER_MOVE
+    color = (0, 0, 255)
+
+
+class MoveFastActorInteraction(BaseMoveActorInteraction):
+    gui_action = UserAction.ORDER_MOVE_FAST
+    color = (72, 244, 66)

synergine2_cocos2d/user_action.py

 
 class UserAction(Enum):
     ORDER_MOVE = 'ORDER_MOVE'
+    ORDER_MOVE_FAST = 'ORDER_MOVE_FAST'

synergine2_xyz/move.py

 from synergine2.simulation import Intention
 from synergine2.simulation import Simulation
 from synergine2.simulation import Event
+from synergine2_cocos2d.user_action import UserAction
 from synergine2_xyz.simulation import XYZSimulation
 
 
         self,
         move_to: typing.Tuple[int, int],
         start_time: float,
+        gui_action: typing.Any,
     ) -> None:
         self.move_to = move_to
         self.path = []  # type: typing.List[typing.Tuple[int, int]]
         self.last_intention_time = start_time
         self.just_reach = False
         self.initial = True
+        self.gui_action = gui_action
 
 
 class RequestMoveBehaviour(SimulationBehaviour):
 
         try:
             subject = self.simulation.subjects.index[subject_id]
-            subject.intentions.set(self.move_intention_class(move_to, start_time=time.time()))
+            subject.intentions.set(self.move_intention_class(
+                move_to,
+                start_time=time.time(),
+                gui_action=data['gui_action'],
+            ))
         except KeyError:
             # TODO: log error here
             pass
                 'last_intention_time': move.last_intention_time,
                 'just_reach': move.just_reach,
                 'initial': move.initial,
+                'gui_action': move.gui_action,
             }
 
         except IndexError:  # TODO: Specialize ? No movement left
         subject_id: int,
         from_position: typing.Tuple[int, int],
         to_position: typing.Tuple[int, int],
+        gui_action: typing.Any,
         *args,
         **kwargs
     ):
         self.subject_id = subject_id
         self.from_position = from_position
         self.to_position = to_position
+        self.gui_action = gui_action
 
     def repr_debug(self) -> str:
         return '{}: subject_id:{}, from_position:{} to_position: {}'.format(
         subject_id: int,
         from_position: typing.Tuple[int, int],
         to_position: typing.Tuple[int, int],
+        gui_action: typing.Any,
         *args,
         **kwargs
     ):
         self.subject_id = subject_id
         self.from_position = from_position
         self.to_position = to_position
+        self.gui_action = gui_action
 
     def repr_debug(self) -> str:
         return '{}: subject_id:{}, from_position:{} to_position: {}'.format(
         subject: Subject,
     ) -> None:
         super().__init__(config, simulation, subject)
-        self._duration = float(self.config.resolve('game.move.walk_ref_time'))
+        self._walk_duration = float(self.config.resolve('game.move.walk_ref_time'))
+        self._run_duration = float(self.config.resolve('game.move.run_ref_time'))
 
     def run(self, data):
         move_to_data = data[self.move_to_mechanism]
         return False
 
     def _can_move_to_next_step(self, move_to_data: dict) -> bool:
-        return time.time() - move_to_data['last_intention_time'] >= self._duration
+        # TODO: Relation vers cocos ! Deplacer UserAction ?
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
+            return time.time() - move_to_data['last_intention_time'] >= self._walk_duration
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
+            return time.time() - move_to_data['last_intention_time'] >= self._run_duration
 
     def _is_fresh_new_step(self, move_to_data: dict) -> bool:
         return move_to_data['just_reach'] or move_to_data['initial']
             self.subject.position = new_position
             move.last_intention_time = time.time()
             move.just_reach = True
-            event = FinishMoveEvent(self.subject.id, previous_position, new_position)
+            event = FinishMoveEvent(
+                self.subject.id,
+                previous_position,
+                new_position,
+                gui_action=move.gui_action,
+            )
         else:
             move.just_reach = False
-            event = StartMoveEvent(self.subject.id, previous_position, new_position)
+            event = StartMoveEvent(
+                self.subject.id,
+                previous_position,
+                new_position,
+                gui_action=move.gui_action,
+            )
 
         move.initial = False
         # Note: Need to explicitly set to update shared data