Adopt new move algorithms and add move with rotation

config.yaml

         walk_ref_time: 3
         run_ref_time: 1
         crawl_ref_time: 10
+        rotate_ref_time: 0  # seconds per degrees
         subject:
           tank1:
             global_move_coeff: 3
+            rotate_ref_time: 0.1111  # seconds per degrees
     building:
       draw_interior_gap: 2
 

opencombat/gui/actor.py

             )
         ]
 
+    def can_rotate_instant(self) -> bool:
+        return True
+
     def get_animation_appliable_images(
         self,
         animation_name: str,
     def weapons(self) -> typing.List[str]:
         # TODO BS 2018-01-26: Will be managed by complex part of code
         return [RIFFLE]
+
+    def can_rotate_instant(self) -> bool:
+        return False

opencombat/gui/base.py

 from pyglet.window import key
 
 from cocos.actions import MoveTo as BaseMoveTo
+from cocos.actions import MoveTo as RotateTo
 from synergine2_cocos2d.audio import AudioLibrary as BaseAudioLibrary
 from synergine2_cocos2d.interaction import InteractionManager
 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.util import PathManager
 
+from opencombat.gui.animation import ANIMATION_WALK
+from opencombat.gui.animation import ANIMATION_CRAWL
 from opencombat.gui.fire import GuiFiringEvent
 from opencombat.simulation.interior import InteriorManager
 from opencombat.simulation.tmx import TileMap
 from synergine2.config import Config
 from synergine2.terminals import Terminal
 from synergine2_cocos2d.actions import MoveTo
-from opencombat.gui.animation import ANIMATION_CRAWL
-from opencombat.gui.animation import ANIMATION_WALK
 from synergine2_cocos2d.animation import Animate
 from synergine2_cocos2d.gl import draw_line
 from synergine2_cocos2d.gui import EditLayer as BaseEditLayer
 from synergine2_cocos2d.gui import Gui
 from synergine2_cocos2d.gui import TMXGui
 from synergine2_cocos2d.layer import LayerManager
-from synergine2_xyz.move.simulation import FinishMoveEvent
-from synergine2_xyz.move.simulation import StartMoveEvent
+from opencombat.simulation import move
 from synergine2_xyz.physics import Physics
 from synergine2_xyz.utils import get_angle
 from opencombat.simulation.event import NewVisibleOpponent
         self.debug_gui = self.config.resolve('global.debug_gui', False)
 
         self.terminal.register_event_handler(
-            FinishMoveEvent,
+            move.SubjectFinishTileMoveEvent,
+            self.set_subject_position,
+        )
+        self.terminal.register_event_handler(
+            move.SubjectFinishMoveEvent,
             self.set_subject_position,
         )
 
         self.terminal.register_event_handler(
-            StartMoveEvent,
+            move.SubjectStartTileMoveEvent,
             self.start_move_subject,
         )
 
         self.terminal.register_event_handler(
+            move.SubjectStartRotationEvent,
+            self.start_rotate_subject,
+        )
+
+        self.terminal.register_event_handler(
+            move.SubjectFinishRotationEvent,
+            self.rotate_subject,
+        )
+
+        self.terminal.register_event_handler(
             NewVisibleOpponent,
             self.new_visible_opponent,
         )
         self.layer_manager.interaction_manager.register(MoveCrawlActorInteraction, self.layer_manager)
         self.layer_manager.interaction_manager.register(FireActorInteraction, self.layer_manager)
 
-    def set_subject_position(self, event: FinishMoveEvent):
+    def set_subject_position(
+        self,
+        event: typing.Union[move.SubjectFinishMoveEvent, move.SubjectFinishTileMoveEvent]
+    ):
         actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
-        new_world_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(event.to_position)
+        new_world_position = self.layer_manager\
+            .grid_manager\
+            .get_world_position_of_grid_position(event.move_to)
 
         actor.stop_actions((BaseMoveTo,))
         actor.set_position(*new_world_position)
 
-    def start_move_subject(self, event: StartMoveEvent):
+    def start_move_subject(
+        self,
+        event: typing.Union[move.SubjectFinishTileMoveEvent, move.SubjectContinueTileMoveEvent, move.SubjectFinishMoveEvent],  # nopep8
+    ):
         actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
-        new_world_position = self.layer_manager.grid_manager.get_world_position_of_grid_position(event.to_position)
-        actor_mode = actor.get_mode_for_gui_action(event.gui_action)
+        new_world_position = self.layer_manager\
+            .grid_manager\
+            .get_world_position_of_grid_position(event.move_to)
 
+        # FIXME BS 20180319: compute/config for cycle duration? ?
         if event.gui_action == UserAction.ORDER_MOVE:
             animation = ANIMATION_WALK
             cycle_duration = 2
                 'Gui action {} unknown'.format(event.gui_action)
             )
 
-        move_duration = event.move_duration
+        move_duration = event.duration
         move_action = MoveTo(new_world_position, move_duration)
         actor.do(move_action)
-        actor.do(Animate(animation, duration=move_duration, cycle_duration=cycle_duration))
-        actor.rotation = get_angle(event.from_position, event.to_position)
-        actor.mode = actor_mode
+        actor.do(Animate(
+            animation,
+            duration=move_duration,
+            cycle_duration=cycle_duration,
+        ))
+        if actor.can_rotate_instant():
+            actor.rotation = get_angle(actor.subject.position, event.move_to)
+        actor.mode = actor.get_mode_for_gui_action(animation)
+
+    def start_rotate_subject(self, event: move.SubjectStartRotationEvent):
+        actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
+        rotate_action = RotateTo(event.rotate_absolute, event.duration)
+        actor.do(rotate_action)
+
+    def rotate_subject(self, event: move.SubjectFinishRotationEvent):
+        actor = self.layer_manager.subject_layer.subjects_index[event.subject_id]
+        actor.rotation = event.rotation_absolute
 
     def new_visible_opponent(self, event: NewVisibleOpponent):
         self.visible_or_no_longer_visible_opponent(event, (153, 0, 153))

opencombat/simulation/behaviour.py

 from opencombat.simulation.mechanism import OpponentVisibleMechanism
 from opencombat.user_action import UserAction
 from synergine2.simulation import Event
-from synergine2_xyz.move.simulation import MoveToBehaviour as BaseMoveToBehaviour
-
-
-class MoveToBehaviour(BaseMoveToBehaviour):
-    def is_terminated(self) -> bool:
-        return COLLECTION_ALIVE not in self.subject.collections
-
-    def _can_move_to_next_step(self, move_to_data: dict) -> bool:
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
-            return time.time() - move_to_data['last_intention_time'] >= \
-                   self.subject.walk_duration
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
-            return time.time() - move_to_data['last_intention_time'] >= \
-                   self.subject.run_duration
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
-            return time.time() - move_to_data['last_intention_time'] >= \
-                   self.subject.crawl_duration
-
-        raise NotImplementedError(
-            'Gui action {} unknown'.format(move_to_data['gui_action'])
-        )
-
-    def get_move_duration(self, move_to_data: dict) -> float:
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
-            return self.subject.walk_duration
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
-            return self.subject.run_duration
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
-            return self.subject.crawl_duration
-
-        raise NotImplementedError(
-            'Gui action {} unknown'.format(move_to_data['gui_action'])
-        )
-
-    def finalize_event(self, move_to_data: dict, event: Event) -> None:
-        event.move_duration = self.get_move_duration(move_to_data)
+# from synergine2_xyz.move.simulation import MoveToBehaviour as BaseMoveToBehaviour
+#
+#
+# class MoveToBehaviour(BaseMoveToBehaviour):
+#     def is_terminated(self) -> bool:
+#         return COLLECTION_ALIVE not in self.subject.collections
+#
+#     def _can_move_to_next_step(self, move_to_data: dict) -> bool:
+#         if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
+#             return time.time() - move_to_data['last_intention_time'] >= \
+#                    self.subject.walk_duration
+#         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
+#             return time.time() - move_to_data['last_intention_time'] >= \
+#                    self.subject.run_duration
+#         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
+#             return time.time() - move_to_data['last_intention_time'] >= \
+#                    self.subject.crawl_duration
+#
+#         raise NotImplementedError(
+#             'Gui action {} unknown'.format(move_to_data['gui_action'])
+#         )
+#
+#     # FIXME remove this func when code with new move
+#     def get_move_duration(self, move_to_data: dict) -> float:
+#         if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
+#             return self.subject.walk_duration
+#         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
+#             return self.subject.run_duration
+#         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
+#             return self.subject.crawl_duration
+#
+#         raise NotImplementedError(
+#             'Gui action {} unknown'.format(move_to_data['gui_action'])
+#         )
+#
+#     def finalize_event(self, move_to_data: dict, event: Event) -> None:
+#         event.move_duration = self.get_move_duration(move_to_data)
 
 
 class LookAroundBehaviour(AliveSubjectBehaviour):

opencombat/simulation/move.py

+# coding: utf-8
+import time
+import typing
+
+from synergine2.simulation import SubjectBehaviour, SubjectMechanism
+from synergine2.simulation import Event
+from synergine2_xyz.move.intention import MoveToIntention
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.utils import get_angle
+
+from opencombat.const import COLLECTION_ALIVE
+from opencombat.user_action import UserAction
+
+
+class SubjectStartRotationEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        rotate_relative: float,
+        rotate_absolute: float,
+        duration: float,
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.rotate_relative = rotate_relative
+        self.rotate_absolute = rotate_absolute
+        self.duration = duration
+        self.gui_action = gui_action
+
+
+class SubjectContinueRotationEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        rotate_relative: float,
+        duration: float,
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.rotate_relative = rotate_relative
+        self.duration = duration
+        self.gui_action = gui_action
+
+
+class SubjectFinishRotationEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        rotation_absolute: float,
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.rotation_absolute = rotation_absolute
+        self.gui_action = gui_action
+
+
+class SubjectStartTileMoveEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        move_to: typing.Tuple[int, int],
+        duration: float,
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.move_to = move_to
+        self.duration = duration
+        self.gui_action = gui_action
+
+
+class SubjectContinueTileMoveEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        move_to: typing.Tuple[int, int],
+        duration: float,
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.move_to = move_to
+        self.duration = duration
+        self.gui_action = gui_action
+
+
+class SubjectFinishTileMoveEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        move_to: typing.Tuple[int, int],
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.move_to = move_to
+        self.gui_action = gui_action
+
+
+class SubjectFinishMoveEvent(Event):
+    def __init__(
+        self,
+        subject_id: int,
+        move_to: typing.Tuple[int, int],
+        gui_action: UserAction,
+    ) -> None:
+        self.subject_id = subject_id
+        self.move_to = move_to
+        self.gui_action = gui_action
+
+
+class MoveToMechanism(SubjectMechanism):
+    def run(self) -> dict:
+        try:
+            # TODO: MoveToIntention doit être configurable
+            move = self.subject.intentions.get(MoveToIntention)  # type: MoveToIntention
+        except KeyError:
+            return {}
+
+        if COLLECTION_ALIVE not in self.subject.collections:
+            return {}
+
+        return move.get_data()
+
+
+class MoveWithRotationBehaviour(SubjectBehaviour):
+    use = [MoveToMechanism]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.simulation = typing.cast(XYZSimulation, self.simulation)
+
+    def run(self, data) -> object:
+        """
+        Compute data relative to move
+        """
+        data = data[MoveToMechanism]
+        if not data:
+            return False
+
+        # Prepare data
+        to = data['to']  # type: typing.Tuple(int, int)
+        return_data = {}
+        now = time.time()
+
+        # Test if it's first time
+        if not data.get('path'):
+            return_data['path'] = self.simulation.physics.found_path(
+                start=self.subject.position,
+                end=to,
+                subject=self.subject,
+            )
+            # find path algorithm can skip start position, add it if not in
+            if return_data['path'][0] != self.subject.position:
+                return_data['path'] = [self.subject.position] + return_data['path']
+            data['path'] = return_data['path']
+
+        # Prepare data
+        path = data['path']  # type: typing.List[typing.Tuple(int, int)]
+        path_index = path.index(self.subject.position)
+        next_position = path[path_index + 1]
+        next_position_direction = get_angle(self.subject.position, next_position)
+        rotate_relative = next_position_direction - self.subject.direction
+
+        # Test if finish move
+        if path_index == len(path) - 1:
+            return {
+                'move_to_finished': to,
+                'gui_action': data['gui_action'],
+            }
+
+        # Check if moving
+        if self.subject.moving_to == next_position:
+            if self.subject.start_move + self.subject.move_duration > now:
+                # Let moving
+                return {
+                    'tile_move_to': next_position,
+                    'gui_action': data['gui_action'],
+                }
+            return_data['tile_move_to_finished'] = self.subject.moving_to
+            # Must consider new position of subject
+            path_index = path.index(return_data['tile_move_to_finished'])
+            if path_index == len(path) - 1:
+                return {
+                    'move_to_finished': to,
+                    'gui_action': data['gui_action'],
+                }
+            next_position = path[path_index + 1]
+            next_position_direction = get_angle(
+                return_data['tile_move_to_finished'],
+                next_position,
+            )
+            rotate_relative = next_position_direction - self.subject.direction
+
+        # Check if rotating
+        if self.subject.rotate_to != -1:
+            # If it is not finished
+            if self.subject.start_rotation + self.subject.rotate_duration > now:
+                # Let rotation do it's job
+                return {
+                    'rotate_relative': rotate_relative,
+                    'rotate_absolute': next_position_direction,
+                    'gui_action': data['gui_action'],
+                }
+            # rotation finish
+            return_data['rotate_to_finished'] = self.subject.rotate_to
+
+        # Check if need to rotate
+        if not return_data.get('rotate_to_finished') \
+                and self.subject.direction != next_position_direction:
+            return_data.update({
+                'rotate_relative': rotate_relative,
+                'rotate_absolute': next_position_direction,
+                'gui_action': data['gui_action'],
+            })
+            return return_data
+
+        # Need to move to next tile
+        return_data['tile_move_to'] = next_position
+        return_data['gui_action'] = data['gui_action']
+        return return_data
+
+    def action(self, data) -> [Event]:
+        events = []
+        now = time.time()
+
+        if data.get('path'):
+            move = self.subject.intentions.get(MoveToIntention)
+            move.path = data['path']
+            self.subject.intentions.set(move)
+
+        if data.get('tile_move_to_finished'):
+            self.subject.position = data['tile_move_to_finished']
+            self.subject.moving_to = (-1, -1)
+            self.subject.start_move = -1
+            self.subject.move_duration = -1
+            events.append(SubjectFinishTileMoveEvent(
+                subject_id=self.subject.id,
+                move_to=data['tile_move_to_finished'],
+                gui_action=data['gui_action'],
+            ))
+
+        if data.get('move_to_finished'):
+            self.subject.position = data['move_to_finished']
+            self.subject.moving_to = (-1, -1)
+            self.subject.start_move = -1
+            self.subject.move_duration = -1
+            self.subject.intentions.remove(MoveToIntention)
+            events.append(SubjectFinishMoveEvent(
+                subject_id=self.subject.id,
+                move_to=data['move_to_finished'],
+                gui_action=data['gui_action'],
+            ))
+
+        if data.get('rotate_to_finished'):
+            self.subject.rotate_to = -1
+            self.subject.rotate_duration = -1
+            self.subject.start_rotation = -1
+            self.subject.direction = data['rotate_to_finished']
+
+            events.append(SubjectFinishRotationEvent(
+                subject_id=self.subject.id,
+                rotation_absolute=data['rotate_to_finished'],
+                gui_action=data['gui_action'],
+            ))
+
+        if data.get('rotate_relative'):
+            # Test if rotation is already started
+            if self.subject.rotate_to == data['rotate_absolute']:
+                # look at progression
+                rotate_since = now - self.subject.start_rotation
+                rotate_progress = rotate_since / self.subject.rotate_duration
+                rotation_to_do = self.subject.rotate_to - self.subject.direction
+                rotation_done = rotation_to_do * rotate_progress
+                self.subject.direction = self.subject.direction + rotation_done
+                rotation_left = self.subject.rotate_to - self.subject.direction
+                duration = self.subject.get_rotate_duration(angle=rotation_left)
+                self.subject.rotate_duration = duration
+                self.subject.start_rotation = now
+
+                return [SubjectContinueRotationEvent(
+                    subject_id=self.subject.id,
+                    rotate_relative=rotation_left,
+                    duration=duration,
+                    gui_action=data['gui_action'],
+                )]
+            else:
+                duration = self.subject.get_rotate_duration(angle=data['rotate_relative'])
+                self.subject.rotate_to = data['rotate_absolute']
+                self.subject.rotate_duration = duration
+                self.subject.start_rotation = time.time()
+
+                events.append(SubjectStartRotationEvent(
+                    subject_id=self.subject.id,
+                    rotate_relative=data['rotate_relative'],
+                    rotate_absolute=data['rotate_absolute'],
+                    duration=duration,
+                    gui_action=data['gui_action'],
+                ))
+
+        if data.get('tile_move_to'):
+            # It is already moving ?
+            if self.subject.moving_to == data.get('tile_move_to'):
+                # look at progression
+                move_since = now - self.subject.start_move
+                move_progress = move_since / self.subject.move_duration
+                move_done = self.subject.move_duration * move_progress
+                duration = self.subject.move_duration - move_done
+                self.subject.move_duration = duration
+
+                return [SubjectContinueTileMoveEvent(
+                    subject_id=self.subject.id,
+                    move_to=data['tile_move_to'],
+                    duration=duration,
+                    gui_action=data['gui_action'],
+                )]
+            else:
+                move = self.subject.intentions.get(MoveToIntention)
+                move_type_duration = self.subject.get_move_duration(move)
+                # FIXME: duration depend next tile type, etc
+                # see opencombat.gui.base.Game#start_move_subject
+                duration = move_type_duration * 1
+                self.subject.moving_to = data['tile_move_to']
+                self.subject.move_duration = duration
+                self.subject.start_move = time.time()
+                events.append(SubjectStartTileMoveEvent(
+                    subject_id=self.subject.id,
+                    move_to=data['tile_move_to'],
+                    duration=duration,
+                    gui_action=data['gui_action'],
+                ))
+
+        return events
+
+
+class MoveBehaviour(SubjectBehaviour):
+    use = [MoveToMechanism]
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.simulation = typing.cast(XYZSimulation, self.simulation)
+
+    def run(self, data) -> object:
+        """
+        Compute data relative to move
+        """
+        data = data[MoveToMechanism]
+        if not data:
+            return False
+
+        # Prepare data
+        to = data['to']  # type: typing.Tuple(int, int)
+        return_data = {}
+        now = time.time()
+
+        # Test if it's first time
+        if not data.get('path'):
+            return_data['path'] = self.simulation.physics.found_path(
+                start=self.subject.position,
+                end=to,
+                subject=self.subject,
+            )
+            # find path algorithm can skip start position, add it if not in
+            if return_data['path'][0] != self.subject.position:
+                return_data['path'] = [self.subject.position] + return_data['path']
+            data['path'] = return_data['path']
+
+        # Prepare data
+        path = data['path']  # type: typing.List[typing.Tuple(int, int)]
+        path_index = path.index(self.subject.position)
+        next_position = path[path_index + 1]
+
+        # Test if finish move
+        if path_index == len(path) - 1:
+            return {
+                'move_to_finished': to,
+                'gui_action': data['gui_action'],
+            }
+
+        # Check if moving
+        if self.subject.moving_to == next_position:
+            if self.subject.start_move + self.subject.move_duration > now:
+                # Let moving
+                return {
+                    'tile_move_to': next_position,
+                    'gui_action': data['gui_action'],
+                }
+            return_data['tile_move_to_finished'] = self.subject.moving_to
+            # Must consider new position of subject
+            path_index = path.index(return_data['tile_move_to_finished'])
+            if path_index == len(path) - 1:
+                return {
+                    'move_to_finished': to,
+                    'gui_action': data['gui_action'],
+                }
+            next_position = path[path_index + 1]
+
+        # Need to move to next tile
+        return_data['tile_move_to'] = next_position
+        return_data['gui_action'] = data['gui_action']
+        return return_data
+
+    def action(self, data) -> [Event]:
+        events = []
+        now = time.time()
+
+        if data.get('path'):
+            move = self.subject.intentions.get(MoveToIntention)
+            move.path = data['path']
+            self.subject.intentions.set(move)
+
+        if data.get('tile_move_to_finished'):
+            self.subject.position = data['tile_move_to_finished']
+            self.subject.moving_to = (-1, -1)
+            self.subject.start_move = -1
+            self.subject.move_duration = -1
+            events.append(SubjectFinishTileMoveEvent(
+                subject_id=self.subject.id,
+                move_to=data['tile_move_to_finished'],
+                gui_action=data['gui_action'],
+            ))
+
+        if data.get('move_to_finished'):
+            self.subject.position = data['move_to_finished']
+            self.subject.moving_to = (-1, -1)
+            self.subject.start_move = -1
+            self.subject.move_duration = -1
+            self.subject.intentions.remove(MoveToIntention)
+            events.append(SubjectFinishMoveEvent(
+                subject_id=self.subject.id,
+                move_to=data['move_to_finished'],
+                gui_action=data['gui_action'],
+            ))
+
+        if data.get('tile_move_to'):
+            # It is already moving ?
+            if self.subject.moving_to == data.get('tile_move_to'):
+                # look at progression
+                move_since = now - self.subject.start_move
+                move_progress = move_since / self.subject.move_duration
+                move_done = self.subject.move_duration * move_progress
+                duration = self.subject.move_duration - move_done
+                self.subject.move_duration = duration
+                self.subject.start_move = time.time()
+
+                return [SubjectContinueTileMoveEvent(
+                    subject_id=self.subject.id,
+                    move_to=data['tile_move_to'],
+                    duration=duration,
+                    gui_action=data['gui_action'],
+                )]
+            else:
+                move = self.subject.intentions.get(MoveToIntention)
+                move_type_duration = self.subject.get_move_duration(move)
+                # FIXME: duration depend next tile type, etc
+                # see opencombat.gui.base.Game#start_move_subject
+                duration = move_type_duration * 1
+                self.subject.moving_to = data['tile_move_to']
+                self.subject.move_duration = duration
+                self.subject.start_move = time.time()
+                events.append(SubjectStartTileMoveEvent(
+                    subject_id=self.subject.id,
+                    move_to=data['tile_move_to'],
+                    duration=duration,
+                    gui_action=data['gui_action'],
+                ))
+
+        return events

opencombat/simulation/subject.py

 # coding: utf-8
 import typing
 
-from synergine2.simulation import SubjectBehaviourSelector, SubjectBehaviour
+from synergine2.simulation import SubjectBehaviourSelector
+from synergine2.simulation import SubjectBehaviour
+from opencombat.user_action import UserAction
+from synergine2_xyz.move.intention import MoveToIntention
 
 from opencombat.const import COLLECTION_ALIVE
 from opencombat.const import COMBAT_MODE_DEFENSE
 from opencombat.simulation.base import BaseSubject
-from opencombat.simulation.behaviour import MoveToBehaviour
+from opencombat.simulation.move import MoveBehaviour
+from opencombat.simulation.move import MoveWithRotationBehaviour
 from opencombat.simulation.behaviour import EngageOpponent
 from opencombat.simulation.behaviour import LookAroundBehaviour
 from synergine2.share import shared
     start_collections = [
         COLLECTION_ALIVE,
     ]
-    behaviours_classes = [
-        MoveToBehaviour,
-        LookAroundBehaviour,
-        EngageOpponent,
-    ]
     visible_opponent_ids = shared.create_self('visible_opponent_ids', lambda: [])
     combat_mode = shared.create_self('combat_mode', COMBAT_MODE_DEFENSE)
     behaviour_selector_class = TileBehaviourSelector
 
+    direction = shared.create_self('direction', 0)
+    moving_to = shared.create_self('moving_to', (-1, -1))
+    move_duration = shared.create_self('move_duration', -1)
+    start_move = shared.create_self('start_move', -1)
+
+    rotate_to = shared.create_self('rotate_to', -1)
+    rotate_duration = shared.create_self('rotate_duration', -1)
+    start_rotation = shared.create_self('start_rotation', -1)
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._walk_ref_time = float(self.config.resolve('game.move.walk_ref_time'))
         self._run_ref_time = float(self.config.resolve('game.move.run_ref_time'))
         self._crawl_ref_time = float(self.config.resolve('game.move.crawl_ref_time'))
+        self._rotate_ref_time = float(self.config.resolve('game.move.rotate_ref_time'))
+        self.direction = kwargs.get('direction', 0)
 
     @property
     def global_move_coeff(self) -> float:
 
     @property
     def run_duration(self) -> float:
+        """
+        :return: move to tile time (s) when running
+        """
         return self._run_ref_time * self.global_move_coeff
 
     @property
     def walk_duration(self) -> float:
+        """
+        :return: move to tile time (s) when walking
+        """
         return self._walk_ref_time * self.global_move_coeff
 
     @property
     def crawl_duration(self) -> float:
+        """
+        :return: move to tile time (s) when crawling
+        """
         return self._crawl_ref_time * self.global_move_coeff
 
+    def get_rotate_duration(self, angle: float) -> float:
+        return angle * self._rotate_ref_time
+
+    def get_move_duration(self, move: MoveToIntention) -> float:
+        gui_action = move.gui_action
+
+        if gui_action == UserAction.ORDER_MOVE:
+            return self.walk_duration
+        if gui_action == UserAction.ORDER_MOVE_FAST:
+            return self.run_duration
+        if gui_action == UserAction.ORDER_MOVE_CRAWL:
+            return self.crawl_duration
+
+        raise NotImplementedError(
+            'Gui action {} unknown'.format(move.gui_action)
+        )
+
 
 class ManSubject(TileSubject):
-    pass
+    behaviours_classes = [
+        MoveBehaviour,
+        LookAroundBehaviour,
+        EngageOpponent,
+    ]  # type: typing.List[SubjectBehaviour]
+
 
 class TankSubject(TileSubject):
+    behaviours_classes = [
+        MoveWithRotationBehaviour,
+        LookAroundBehaviour,
+        EngageOpponent,
+    ]  # type: typing.List[SubjectBehaviour]
+
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         # TODO BS 2018-01-26: This coeff will be dependent of real
             'game.move.subject.tank1.global_move_coeff',
             3,
         )
+        self._rotate_ref_time = float(self.config.resolve(
+            'game.move.subject.tank1.rotate_ref_time',
+            0.1111,
+        ))
 
     @property
     def global_move_coeff(self) -> float:

opencombat/terminal/base.py

 from opencombat.simulation.physics import TilePhysics
 from synergine2_cocos2d.terminal import GameTerminal
 from synergine2_cocos2d.util import get_map_file_path_from_dir
-from synergine2_xyz.move.simulation import FinishMoveEvent
-from synergine2_xyz.move.simulation import StartMoveEvent
+from opencombat.simulation import move
 
 
 class CocosTerminal(GameTerminal):
     main_process = True
 
     subscribed_events = [
-        FinishMoveEvent,
-        StartMoveEvent,
+        move.SubjectFinishTileMoveEvent,
+        move.SubjectFinishMoveEvent,
+        move.SubjectStartTileMoveEvent,
+        move.SubjectStartRotationEvent,
+        move.SubjectFinishRotationEvent,
         NewVisibleOpponent,
         NoLongerVisibleOpponent,
         FireEvent,

test_config.yaml

+core:
+    cycle_duration: 0.25
+    use_x_cores: 2
+terminals:
+    sync: True
+game:
+    look_around:
+        frequency: 1
+    engage:
+        frequency: 1
+    move:
+        walk_ref_time: 3
+        run_ref_time: 1
+        crawl_ref_time: 10
+        rotate_ref_time: 0  # seconds per degrees
+        subject:
+          tank1:
+            global_move_coeff: 3
+            rotate_ref_time: 0.1111  # seconds per degrees
+    building:
+      draw_interior_gap: 2
+
+global:
+    cache_dir_path: 'cache'
+    include_path:
+      maps:
+        - "maps"
+      graphics:
+        - "medias/images"
+      sounds:
+        - "medias/sounds"
+    logging_level: ERROR
+    debug: false
+    debug_gui: false

tests/conftest.py

+# coding: utf-8
+from tests.fixtures.main import *

tests/fixtures/main.py

+# coding: utf-8
+import pytest
+from synergine2.config import Config
+
+
+@pytest.fixture()
+def config() -> Config:
+    config_ = Config()
+    config_.load_yaml('test_config.yaml')
+    return config_

tests/move/__init__.py

+# coding: utf-8

tests/move/test_move.py

+# coding: utf-8
+import pytest
+from freezegun import freeze_time
+from synergine2_xyz.move.intention import MoveToIntention
+from synergine2_xyz.simulation import XYZSimulation
+
+from opencombat.simulation.move import MoveWithRotationBehaviour
+from opencombat.simulation.move import MoveToMechanism
+from opencombat.simulation.move import MoveBehaviour
+from opencombat.simulation.move import SubjectFinishMoveEvent
+from opencombat.simulation.move import SubjectStartRotationEvent
+from opencombat.simulation.move import SubjectFinishRotationEvent
+from opencombat.simulation.move import SubjectContinueRotationEvent
+from opencombat.simulation.move import SubjectStartTileMoveEvent
+from opencombat.simulation.move import SubjectContinueTileMoveEvent
+from opencombat.simulation.move import SubjectFinishTileMoveEvent
+from opencombat.simulation.subject import TankSubject
+from opencombat.simulation.subject import ManSubject
+from opencombat.user_action import UserAction
+
+
+def test_move_and_rotate_behaviour__begin_rotate(config):
+    simulation = XYZSimulation(config)
+    simulation.physics.graph.add_edge('0.0', '1.1', {})
+    simulation.physics.graph.add_edge('1.1', '2.1', {})
+
+    subject = TankSubject(
+        config,
+        simulation,
+        position=(0, 0),
+    )
+    move = MoveToIntention(
+        to=(2, 1),
+        gui_action=UserAction.ORDER_MOVE,
+    )
+    subject.intentions.set(move)
+
+    move_behaviour = MoveWithRotationBehaviour(
+        config=config,
+        simulation=simulation,
+        subject=subject,
+    )
+
+    # Rotation required to begin move
+    with freeze_time("2000-01-01 00:00:00", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+            'gui_action': UserAction.ORDER_MOVE,'gui_action': UserAction.ORDER_MOVE,
+            'path': [
+                (0, 0),
+                (1, 1),
+                (2, 1),
+            ],
+            'rotate_relative': 45,
+            'rotate_absolute': 45,
+        } == data
+
+        events = move_behaviour.action(data)
+        assert events
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectStartRotationEvent)
+        assert 45.0 == events[0].rotate_relative
+        assert 4.9995 == events[0].duration
+        assert subject.position == (0, 0)
+        assert subject.direction == 0
+        assert subject.rotate_to == 45
+        assert subject.start_rotation == 946684800.0
+        assert subject.rotate_duration == 4.9995
+        assert subject.intentions.get(MoveToIntention)
+
+    # This is 1 second before end of rotation
+    with freeze_time("2000-01-01 00:00:04", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'rotate_relative': 45,
+                   'rotate_absolute': 45,
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueRotationEvent)
+        assert 9 == round(events[0].rotate_relative)
+        assert 0.9995 == events[0].duration
+        assert subject.position == (0, 0)
+        assert int(subject.direction) == 36
+        assert subject.rotate_to == 45
+        assert subject.start_rotation == 946684804.0
+        assert subject.rotate_duration == 0.9995
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are now just after rotation duration, a move will start
+    with freeze_time("2000-01-01 00:00:05", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (1, 1),
+                   'rotate_to_finished': 45,
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 2 == len(events)
+        assert isinstance(events[1], SubjectStartTileMoveEvent)
+        assert isinstance(events[0], SubjectFinishRotationEvent)
+        assert (1, 1) == events[1].move_to
+        assert 9.0 == events[1].duration
+        assert subject.position == (0, 0)
+        assert subject.moving_to == (1, 1)
+        assert subject.move_duration == 9.0
+        assert subject.start_move == 946684805.0
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are during the move
+    with freeze_time("2000-01-01 00:00:13", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (1, 1),
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueTileMoveEvent)
+        assert (1, 1) == events[0].move_to
+        assert 1.0 == events[0].duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are after the move
+    with freeze_time("2000-01-01 00:00:14", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to_finished': (1, 1),
+                   'rotate_relative': 45,
+                   'rotate_absolute': 90,
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 2 == len(events)
+        assert isinstance(events[0], SubjectFinishTileMoveEvent)
+        assert isinstance(events[1], SubjectStartRotationEvent)
+        assert (1, 1) == events[0].move_to
+        assert 4.9995 == events[1].duration
+        assert 45 == events[1].rotate_relative
+        assert (1, 1) == subject.position
+        assert (-1, -1) == subject.moving_to
+        assert -1 == subject.start_move
+        assert -1 == subject.move_duration
+        assert subject.rotate_to == 90
+        assert subject.start_rotation == 946684814.0
+        assert subject.rotate_duration == 4.9995
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are rotating
+    with freeze_time("2000-01-01 00:00:18", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'rotate_relative': 45,
+                   'rotate_absolute': 90,
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueRotationEvent)
+        assert 9 == round(events[0].rotate_relative)
+        assert 0.9995 == events[0].duration
+        assert subject.position == (1, 1)
+        assert int(subject.direction) == 81
+        assert subject.rotate_to == 90
+        assert subject.start_rotation == 946684818.0
+        assert subject.rotate_duration == 0.9995
+        assert subject.intentions.get(MoveToIntention)
+
+    # We finish rotating and start to move to final tile
+    with freeze_time("2000-01-01 00:00:19", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (2, 1),
+                   'rotate_to_finished': 90,
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 2 == len(events)
+        assert isinstance(events[1], SubjectStartTileMoveEvent)
+        assert isinstance(events[0], SubjectFinishRotationEvent)
+        assert (2, 1) == events[1].move_to
+        assert 9.0 == events[1].duration
+        assert subject.position == (1, 1)
+        assert subject.moving_to == (2, 1)
+        assert subject.move_duration == 9.0
+        assert subject.start_move == 946684819.0
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are moving to final tile
+    with freeze_time("2000-01-01 00:00:27", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (2, 1),
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueTileMoveEvent)
+        assert (2, 1) == events[0].move_to
+        assert 1.0 == events[0].duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # We arrived on final tile
+    with freeze_time("2000-01-01 00:00:28", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'move_to_finished': (2, 1),
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectFinishMoveEvent)
+        assert (2, 1) == events[0].move_to
+        assert (2, 1) == subject.position
+        assert (-1, -1) == subject.moving_to
+        assert -1 == subject.start_move
+        assert -1 == subject.move_duration
+        with pytest.raises(KeyError):
+            assert subject.intentions.get(MoveToIntention)
+
+
+def test_move_and_rotate_behaviour__begin_move(config):
+    simulation = XYZSimulation(config)
+    simulation.physics.graph.add_edge('0.0', '0.1', {})
+    simulation.physics.graph.add_edge('0.1', '1.1', {})
+
+    subject = TankSubject(
+        config,
+        simulation,
+        position=(0, 0),
+    )
+    move = MoveToIntention(
+        to=(1, 1),
+        gui_action=UserAction.ORDER_MOVE,
+    )
+    subject.intentions.set(move)
+
+    move_behaviour = MoveWithRotationBehaviour(
+        config=config,
+        simulation=simulation,
+        subject=subject,
+    )
+
+    # First is a move
+    with freeze_time("2000-01-01 00:00:00", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'path': [
+                       (0, 0),
+                       (0, 1),
+                       (1, 1),
+                   ],
+                   'tile_move_to': (0, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectStartTileMoveEvent)
+        assert (0, 1) == events[0].move_to
+        assert 9.0 == events[0].duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # Continue the move, rest 1s
+    with freeze_time("2000-01-01 00:00:08", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (0, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueTileMoveEvent)
+        assert (0, 1) == events[0].move_to
+        assert 1.0 == events[0].duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # Tile move finished, begin a rotate
+    with freeze_time("2000-01-01 00:00:09", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to_finished': (0, 1),
+                   'rotate_relative': 90,
+                   'rotate_absolute': 90,
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 2 == len(events)
+        assert isinstance(events[0], SubjectFinishTileMoveEvent)
+        assert isinstance(events[1], SubjectStartRotationEvent)
+        assert (0, 1) == events[0].move_to
+        assert 10 == round(events[1].duration)
+        assert 90 == events[1].rotate_relative
+        assert (0, 1) == subject.position
+        assert (-1, -1) == subject.moving_to
+        assert -1 == subject.start_move
+        assert -1 == subject.move_duration
+        assert subject.rotate_to == 90
+        assert subject.start_rotation == 946684809.0
+        assert round(subject.rotate_duration) == 10
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are rotating, rest 1s
+    with freeze_time("2000-01-01 00:00:18", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'rotate_relative': 90,
+                   'rotate_absolute': 90,
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueRotationEvent)
+        assert 9 == round(events[0].rotate_relative)
+        assert 1 == round(events[0].duration)
+        assert subject.position == (0, 1)
+        assert int(subject.direction) == 81
+        assert subject.rotate_to == 90
+        assert subject.start_rotation == 946684818.0
+        assert round(subject.rotate_duration) == 1
+        assert subject.intentions.get(MoveToIntention)
+
+    # We finish rotating and start to move to final tile
+    with freeze_time("2000-01-01 00:00:19", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (1, 1),
+                   'rotate_to_finished': 90,
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 2 == len(events)
+        assert isinstance(events[1], SubjectStartTileMoveEvent)
+        assert isinstance(events[0], SubjectFinishRotationEvent)
+        assert (1, 1) == events[1].move_to
+        assert 9.0 == events[1].duration
+        assert subject.position == (0, 1)
+        assert subject.moving_to == (1, 1)
+        assert subject.move_duration == 9.0
+        assert subject.start_move == 946684819.0
+        assert subject.intentions.get(MoveToIntention)
+
+    # Continue the move, rest 1s
+    with freeze_time("2000-01-01 00:00:27", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (1, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueTileMoveEvent)
+        assert (1, 1) == events[0].move_to
+        assert 1.0 == events[0].duration
+        assert subject.moving_to == (1, 1)
+        assert subject.move_duration == 1.0
+        assert subject.start_move == 946684819.0
+        assert subject.intentions.get(MoveToIntention)
+
+    # We arrived on final tile
+    with freeze_time("2000-01-01 00:00:28", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'move_to_finished': (1, 1),
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectFinishMoveEvent)
+        assert (1, 1) == events[0].move_to
+        assert (1, 1) == subject.position
+        assert (-1, -1) == subject.moving_to
+        assert -1 == subject.start_move
+        assert -1 == subject.move_duration
+        with pytest.raises(KeyError):
+            assert subject.intentions.get(MoveToIntention)
+
+
+def test_move_behaviour(config):
+    simulation = XYZSimulation(config)
+    simulation.physics.graph.add_edge('0.0', '0.1', {})
+    simulation.physics.graph.add_edge('0.1', '1.1', {})
+
+    subject = ManSubject(
+        config,
+        simulation,
+        position=(0, 0),
+    )
+    move = MoveToIntention(
+        to=(1, 1),
+        gui_action=UserAction.ORDER_MOVE,
+    )
+    subject.intentions.set(move)
+
+    move_behaviour = MoveBehaviour(
+        config=config,
+        simulation=simulation,
+        subject=subject,
+    )
+
+    # First begin move
+    with freeze_time("2000-01-01 00:00:00", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'path': [
+                       (0, 0),
+                       (0, 1),
+                       (1, 1),
+                   ],
+                   'tile_move_to': (0, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectStartTileMoveEvent)
+        assert (0, 1) == events[0].move_to
+        assert 3.0 == events[0].duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # Continue the move, rest 1s
+    with freeze_time("2000-01-01 00:00:02", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (0, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueTileMoveEvent)
+        assert (0, 1) == events[0].move_to
+        assert 1.0 == events[0].duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # Tile move finished, begin a new move
+    with freeze_time("2000-01-01 00:00:03", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to_finished': (0, 1),
+                   'tile_move_to': (1, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 2 == len(events)
+        assert isinstance(events[0], SubjectFinishTileMoveEvent)
+        assert isinstance(events[1], SubjectStartTileMoveEvent)
+        assert (0, 1) == events[0].move_to
+        assert (1, 1) == events[1].move_to
+        assert 3 == events[1].duration
+        assert (0, 1) == subject.position
+        assert (1, 1) == subject.moving_to
+        assert 946684803.0 == subject.start_move
+        assert 3 == subject.move_duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # We are moving, rest 1s
+    with freeze_time("2000-01-01 00:00:05", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'tile_move_to': (1, 1),
+               } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectContinueTileMoveEvent)
+        assert (1, 1) == events[0].move_to
+        assert 1.0 == events[0].duration
+        assert (0, 1) == subject.position
+        assert (1, 1) == subject.moving_to
+        assert 946684805.0 == subject.start_move
+        assert 1 == subject.move_duration
+        assert subject.intentions.get(MoveToIntention)
+
+    # We arrived on final tile
+    with freeze_time("2000-01-01 00:00:06", tz_offset=0):
+        data = move_behaviour.run({MoveToMechanism: move.get_data()})
+        assert {
+                   'gui_action': UserAction.ORDER_MOVE,
+                   'move_to_finished': (1, 1),
+        } == data
+
+        events = move_behaviour.action(data)
+        assert 1 == len(events)
+        assert isinstance(events[0], SubjectFinishMoveEvent)
+        assert (1, 1) == events[0].move_to
+        assert (1, 1) == subject.position
+        assert (-1, -1) == subject.moving_to
+        assert -1 == subject.start_move
+        assert -1 == subject.move_duration
+        with pytest.raises(KeyError):
+            assert subject.intentions.get(MoveToIntention)