reorganize move code

sandbox/tile/gui/base.py

 # coding: utf-8
+from pyglet.window import key
+from cocos.actions import MoveTo as BaseMoveTo
+from sandbox.tile.gui.move import MoveActorInteraction
+from sandbox.tile.gui.move import MoveFastActorInteraction
+from sandbox.tile.gui.move import MoveCrawlActorInteraction
+from synergine2_cocos2d.layer import LayerManager
+from synergine2_xyz.move.simulation import FinishMoveEvent
+from synergine2_xyz.move.simulation import StartMoveEvent
+
+from synergine2_xyz.utils import get_angle
+from synergine2.config import Config
+from synergine2.log import SynergineLogger
+from synergine2.terminals import Terminal
 from synergine2_cocos2d.gui import TMXGui
-from synergine2_cocos2d.interaction import MoveActorInteraction
-from synergine2_cocos2d.interaction import MoveFastActorInteraction
-from synergine2_cocos2d.interaction import MoveCrawlActorInteraction
+from synergine2_cocos2d.gui import EditLayer as BaseEditLayer
+from synergine2_cocos2d.actions import MoveTo
+from synergine2_cocos2d.animation import Animate
+# TODO NOW: MOVE
+from synergine2_cocos2d.animation import ANIMATION_CRAWL
+from synergine2_cocos2d.animation import ANIMATION_WALK
+
+from sandbox.tile.user_action import UserAction
+
+
+class EditLayer(BaseEditLayer):
+    def _on_key_press(self, k, m):
+        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 == key.C:
+                self.user_action_pending = UserAction.ORDER_MOVE_CRAWL
+
+
+class TileLayerManager(LayerManager):
+    edit_layer_class = EditLayer
 
 
 class Game(TMXGui):
+    layer_manager_class = TileLayerManager
+
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        terminal: Terminal,
+        read_queue_interval: float = 1 / 60.0,
+        map_dir_path: str=None,
+    ):
+        super().__init__(
+            config,
+            logger,
+            terminal,
+            read_queue_interval,
+            map_dir_path,
+        )
+
+        self.terminal.register_event_handler(
+            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'))
+        self.move_fast_duration_ref = float(self.config.resolve('game.move.run_ref_time'))
+        self.move_crawl_duration_ref = float(self.config.resolve('game.move.crawl_ref_time'))
+
     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)
         self.layer_manager.interaction_manager.register(MoveCrawlActorInteraction, self.layer_manager)
 
-        # Test
-        # from sandbox.tile.gui.actor import Man
-        # from cocos import euclid
-        #
-        # for i in range(10):
-        #     x = random.randint(0, 600)
-        #     y = random.randint(0, 300)
-        #     man = Man()
-        #     man.update_position(euclid.Vector2(x, y))
-        #     self.layer_manager.add_subject(man)
-        #     self.layer_manager.set_selectable(man)
-        #     man.scale = 1
-        #
-        #     if x % 2:
-        #         man.do(Animate(ANIMATION_WALK, 10, 4))
-        #     else:
-        #         man.do(Animate(ANIMATION_CRAWL, 20, 4))
+    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.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)
+
+        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
+        elif event.gui_action == UserAction.ORDER_MOVE_CRAWL:
+            animation = ANIMATION_CRAWL
+            cycle_duration = 2
+            move_duration = self.move_crawl_duration_ref
+        else:
+            raise NotImplementedError()
+
+        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)

sandbox/tile/gui/move.py

+# coding: utf-8
+from sandbox.tile.user_action import UserAction
+from synergine2.terminals import TerminalPackage
+from synergine2_cocos2d.gl import draw_line
+from synergine2_cocos2d.interaction import Interaction
+from synergine2_xyz.move.simulation import RequestMoveBehaviour
+
+
+class BaseMoveActorInteraction(Interaction):
+    gui_action = None
+    color = None
+    request_move_behaviour_class = RequestMoveBehaviour
+
+    def draw_pending(self) -> None:
+        for actor in self.layer_manager.edit_layer.selection:
+            grid_position = self.layer_manager.grid_manager.get_grid_position(actor.position)
+            pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(grid_position)
+
+            draw_line(
+                self.layer_manager.scrolling_manager.world_to_screen(*pixel_position),
+                self.layer_manager.edit_layer.screen_mouse,
+                self.color,
+            )
+
+    def get_package_for_terminal(self) -> TerminalPackage:
+        # TODO: FinishMoveEvent ?
+        actions = []
+        mouse_grid_position = self.layer_manager.grid_manager.get_grid_position(
+            self.layer_manager.scrolling_manager.screen_to_world(
+                *self.layer_manager.edit_layer.screen_mouse,
+            )
+        )
+
+        for actor in self.layer_manager.edit_layer.selection:
+            actions.append((
+                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)
+
+
+class MoveCrawlActorInteraction(BaseMoveActorInteraction):
+    gui_action = UserAction.ORDER_MOVE_CRAWL
+    color = (235, 244, 66)

sandbox/tile/run.py

 synergine2_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
 sys.path.append(synergine2_path)
 
-from synergine2_xyz.move import MoveToMechanism, MoveToBehaviour
 from sandbox.tile.simulation.subject import Man
 from sandbox.tile.simulation.base import TileStrategySimulation
 from sandbox.tile.simulation.base import TileStrategySubjects

sandbox/tile/simulation/behaviour.py

+# coding: utf-8
+import time
+
+from sandbox.tile.user_action import UserAction
+from synergine2.config import Config
+from synergine2.simulation import Simulation
+from synergine2.simulation import Subject
+from synergine2_xyz.move.simulation import MoveToBehaviour as BaseMoveToBehaviour
+
+
+class MoveToBehaviour(BaseMoveToBehaviour):
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+        subject: Subject,
+    ) -> None:
+        super().__init__(config, simulation, subject)
+        self._walk_duration = float(self.config.resolve('game.move.walk_ref_time'))
+        self._run_duration = float(self.config.resolve('game.move.run_ref_time'))
+        self._crawl_duration = float(self.config.resolve('game.move.crawl_ref_time'))
+
+    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._walk_duration
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
+            return time.time() - move_to_data['last_intention_time'] >= self._run_duration
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
+            return time.time() - move_to_data['last_intention_time'] >= self._crawl_duration

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
+from sandbox.tile.simulation.behaviour import MoveToBehaviour
 
 
 class Man(BaseSubject):

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 FinishMoveEvent
-from synergine2_xyz.move import StartMoveEvent
+from synergine2_xyz.move.simulation import FinishMoveEvent
+from synergine2_xyz.move.simulation import StartMoveEvent
 
 
 class CocosTerminal(GameTerminal):

sandbox/tile/user_action.py

+# coding: utf-8
+from synergine2_cocos2d.user_action import UserAction as BaseUserAction
+
+
+class UserAction(BaseUserAction):
+    ORDER_MOVE = 'ORDER_MOVE'
+    ORDER_MOVE_FAST = 'ORDER_MOVE_FAST'
+    ORDER_MOVE_CRAWL = 'ORDER_MOVE_CRAWL'

synergine2_cocos2d/gui.py

 from math import floor
 
 import pyglet
-from pyglet.window import key
 from pyglet.window import mouse
 
 import cocos
 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
 from synergine2.terminals import TerminalPackage
-from synergine2_cocos2d.actions import MoveTo
 from synergine2_cocos2d.actor import Actor
-from synergine2_cocos2d.animation import Animate, ANIMATION_CRAWL
-from synergine2_cocos2d.animation import ANIMATION_WALK
 from synergine2_cocos2d.exception import InteractionNotFound
 from synergine2_cocos2d.exception import OuterWorldPosition
 from synergine2_cocos2d.gl import draw_rectangle
 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.middleware import TMXMiddleware
 from synergine2_cocos2d.user_action import UserAction
-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
 
 
         mod_restricted_mov=None,
     ):
         # TODO: Clean init params
-        super(EditLayer, self).__init__()
+        super().__init__()
 
         self.config = config
         self.logger = logger
         self.sright = None
         self.sbottom = None
         self.s_top = None
-        self.user_action_pending = None  # UserAction
+        self.user_action_pending = None  # type: UserAction
 
         # opers that change cshape must ensure it goes to False,
         # selection opers must ensure it goes to True
                 pass
 
     def on_enter(self):
-        super(EditLayer, self).on_enter()
+        super().on_enter()
         scene = self.get_ancestor(cocos.scene.Scene)
         if self.elastic_box is None:
             self.elastic_box = MinMaxRect(self.layer_manager)
 
     def on_key_press(self, k, m):
         binds = self.bindings
-
-        # TODO: Clarify code
-        # Actions available if actor selected
-        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 == key.C:
-                self.user_action_pending = UserAction.ORDER_MOVE_CRAWL
+        self._on_key_press(k, m)
 
         if k in binds:
             self.buttons[binds[k]] = 1
             return True
         return False
 
+    def _on_key_press(self, k, m):
+        pass
+
     def on_key_release(self, k, m):
         binds = self.bindings
         if k in binds:
 
 
 class Gui(object):
+    layer_manager_class = LayerManager
+
     def __init__(
             self,
             config: Config,
             logger=self.logger,
             terminal=self.terminal,
         )
-        self.layer_manager = LayerManager(
+        self.layer_manager = self.layer_manager_class(
             self.config,
             self.logger,
             middleware=self.get_layer_middleware(),
             read_queue_interval,
         )
 
-        self.terminal.register_event_handler(
-            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'))
-        self.move_fast_duration_ref = float(self.config.resolve('game.move.run_ref_time'))
-        self.move_crawl_duration_ref = float(self.config.resolve('game.move.crawl_ref_time'))
-
     def get_layer_middleware(self) -> MapMiddleware:
         return TMXMiddleware(
             self.config,
     def append_subject(self, subject: XYZSubjectMixin) -> None:
         subject_mapper = self.subject_mapper_factory.get_subject_mapper(subject)
         subject_mapper.append(subject, self.layer_manager)
-
-    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.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)
-
-        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
-        elif event.gui_action == UserAction.ORDER_MOVE_CRAWL:
-            animation = ANIMATION_CRAWL
-            cycle_duration = 2
-            move_duration = self.move_crawl_duration_ref
-        else:
-            raise NotImplementedError()
-
-        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)

synergine2_cocos2d/interaction.py

 # coding: utf-8
 import typing
 
-from synergine2_xyz.move import RequestMoveBehaviour
-
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 from synergine2_cocos2d.exception import InteractionNotFound
-from synergine2_cocos2d.gl import draw_line
 from synergine2_cocos2d.layer import LayerManager
 from synergine2_cocos2d.user_action import UserAction
 
 
     def get_package_for_terminal(self) -> TerminalPackage:
         raise NotImplementedError()
-
-
-class BaseMoveActorInteraction(Interaction):
-    gui_action = None
-    color = None
-    request_move_behaviour_class = RequestMoveBehaviour
-
-    def draw_pending(self) -> None:
-            for actor in self.layer_manager.edit_layer.selection:
-                grid_position = self.layer_manager.grid_manager.get_grid_position(actor.position)
-                pixel_position = self.layer_manager.grid_manager.get_pixel_position_of_grid_position(grid_position)
-
-                draw_line(
-                    self.layer_manager.scrolling_manager.world_to_screen(*pixel_position),
-                    self.layer_manager.edit_layer.screen_mouse,
-                    self.color,
-                )
-
-    def get_package_for_terminal(self) -> TerminalPackage:
-        # TODO: FinishMoveEvent ?
-        actions = []
-        mouse_grid_position = self.layer_manager.grid_manager.get_grid_position(
-            self.layer_manager.scrolling_manager.screen_to_world(
-                *self.layer_manager.edit_layer.screen_mouse,
-            )
-        )
-
-        for actor in self.layer_manager.edit_layer.selection:
-            actions.append((
-                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)
-
-
-class MoveCrawlActorInteraction(BaseMoveActorInteraction):
-    gui_action = UserAction.ORDER_MOVE_CRAWL
-    color = (235, 244, 66)

synergine2_cocos2d/layer.py

 
 
 class LayerManager(object):
+    edit_layer_class = None  # type: typing.Type['EditLayer']
+
     def __init__(
         self,
         config: Config,
         self.subject_layer = None  # type: SubjectLayer
         self.top_layer = None  # type: cocos.tiles.RectMapLayer
 
+        from synergine2_cocos2d.gui import EditLayer
+        self.edit_layer_class = self.edit_layer_class or EditLayer
+
     def init(self) -> None:
         # TODO: cyclic import
         from synergine2_cocos2d.gui import MainLayer
-        from synergine2_cocos2d.gui import EditLayer
         from synergine2_cocos2d.gui import GridManager
 
         self.middleware.init()
                 'height': 1000,  # Note: world size
             }
         )
-        self.edit_layer = EditLayer(
+        self.edit_layer = self.edit_layer_class(
             self.config,
             self.logger,
             self,

synergine2_cocos2d/user_action.py

 
 
 class UserAction(Enum):
-    ORDER_MOVE = 'ORDER_MOVE'
-    ORDER_MOVE_FAST = 'ORDER_MOVE_FAST'
-    ORDER_MOVE_CRAWL = 'ORDER_MOVE_CRAWL'
+    pass

synergine2_xyz/move/intention.py

+# coding: utf-8
+import typing
+
+from synergine2.simulation import Intention
+
+
+class MoveToIntention(Intention):
+    def __init__(
+        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.path_progression = -1  # type: int
+        self.last_intention_time = start_time
+        self.just_reach = False
+        self.initial = True
+        self.gui_action = gui_action

synergine2_xyz/move.py → synergine2_xyz/move/simulation.py

 # coding: utf-8
-import typing
-from random import randint
-
 import time
+import typing
 
 from synergine2.config import Config
-from synergine2.simulation import SimulationBehaviour, Subject
-from synergine2.simulation import SubjectBehaviour
-from synergine2.simulation import SubjectMechanism
-from synergine2.simulation import Intention
+from synergine2.simulation import SimulationBehaviour
 from synergine2.simulation import Simulation
 from synergine2.simulation import Event
-from synergine2_cocos2d.user_action import UserAction
+from synergine2.simulation import SubjectMechanism
+from synergine2.simulation import SubjectBehaviour
+from synergine2_xyz.move.intention import MoveToIntention
 from synergine2_xyz.simulation import XYZSimulation
 
 
-class MoveToIntention(Intention):
-    def __init__(
-        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.path_progression = -1  # type: int
-        self.last_intention_time = start_time
-        self.just_reach = False
-        self.initial = True
-        self.gui_action = gui_action
-
-
 class RequestMoveBehaviour(SimulationBehaviour):
     move_intention_class = MoveToIntention
 
     use = [MoveToMechanism]
     move_to_mechanism = MoveToMechanism
 
-    def __init__(
-        self,
-        config: Config,
-        simulation: Simulation,
-        subject: Subject,
-    ) -> None:
-        super().__init__(config, simulation, subject)
-        self._walk_duration = float(self.config.resolve('game.move.walk_ref_time'))
-        self._run_duration = float(self.config.resolve('game.move.run_ref_time'))
-        self._crawl_duration = float(self.config.resolve('game.move.crawl_ref_time'))
-
     def run(self, data):
         move_to_data = data[self.move_to_mechanism]
         if move_to_data:
         return False
 
     def _can_move_to_next_step(self, move_to_data: dict) -> bool:
-        # 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
-        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
-            return time.time() - move_to_data['last_intention_time'] >= self._crawl_duration
+        raise NotImplementedError()
 
     def _is_fresh_new_step(self, move_to_data: dict) -> bool:
         return move_to_data['just_reach'] or move_to_data['initial']

tests/test_move.py

 from freezegun import freeze_time
 
 from synergine2.config import Config
-from synergine2_cocos2d.user_action import UserAction
-from synergine2_xyz.move import MoveToBehaviour, MoveToMechanism, MoveToIntention, StartMoveEvent, FinishMoveEvent
+from synergine2.simulation import Simulation, Subject
+from synergine2_cocos2d.user_action import UserAction as BaseUserAction
+from synergine2_xyz.move.intention import MoveToIntention
+from synergine2_xyz.move.simulation import MoveToMechanism
+from synergine2_xyz.move.simulation import StartMoveEvent
+from synergine2_xyz.move.simulation import FinishMoveEvent
 from synergine2_xyz.simulation import XYZSimulation
 from synergine2_xyz.subjects import XYZSubject
 from tests import BaseTest
+from synergine2_xyz.move.simulation import MoveToBehaviour as BaseMoveToBehaviour
+
+
+class MyMoveToBehaviour(BaseMoveToBehaviour):
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+        subject: Subject,
+    ) -> None:
+        super().__init__(config, simulation, subject)
+        self._walk_duration = float(self.config.resolve('game.move.walk_ref_time'))
+
+    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._walk_duration
+
+
+class UserAction(BaseUserAction):
+    ORDER_MOVE = 'ORDER_MOVE'
 
 
 class MySubject(XYZSubject):
             'game': {
                 'move': {
                     'walk_ref_time': 2,
-                    'run_ref_time': 2,
-                    'crawl_ref_time': 2,
                 }
             }
         })
         simulation = MySimulation(config)
         subject = MySubject(config, simulation)
-        behaviour = MoveToBehaviour(config, simulation, subject)
+        behaviour = MyMoveToBehaviour(config, simulation, subject)
 
         with freeze_time("2000-01-01 00:00:00"):
             move_intention = MoveToIntention((0, 3), time.time(), gui_action=UserAction.ORDER_MOVE)