Adapt code for new move algos

synergine2/simulation.py

@@ -6,6 +6,7 @@ import time
 from synergine2.base import BaseObject
 from synergine2.base import IdentifiedObject
 from synergine2.config import Config
+from synergine2.exceptions import ConfigurationError
 from synergine2.share import shared
 from synergine2.utils import get_mechanisms_classes
 
@@ -33,7 +34,7 @@ class IntentionManager(object):
 
     def remove(self, intention_type: typing.Type[Intention]) -> None:
         intentions = self.intentions
-        del self.intentions[intention_type]
+        del intentions[intention_type]
         self.intentions = intentions
 
     def remove_all(self) -> None:
@@ -412,3 +413,60 @@ class SubjectBehaviourSelector(BaseObject):
         behaviours: typing.Dict[typing.Type[SubjectBehaviour], object],
     ) -> typing.Dict[typing.Type[SubjectBehaviour], object]:
         return behaviours
+
+
+class BehaviourStep(object):
+    def proceed(self) -> 'BehaviourStep':
+        raise NotImplementedError()
+
+    def generate_data(self) -> typing.Any:
+        raise NotImplementedError()
+
+    def get_events(self) -> typing.List[Event]:
+        raise NotImplementedError()
+
+
+class SubjectComposedBehaviour(SubjectBehaviour):
+    """
+    SubjectComposedBehaviour receive data in run (and will will it's step with it).
+    These data can be the first data of behaviour, or last behaviour subject data
+    produced in action.
+    SubjectComposedBehaviour produce data in run only if something happen and must be
+    given in future run.
+    """
+    step_classes = None  # type: typing.List[typing.Tuple[typing.Type[BehaviourStep], typing.Callable[[typing.Any], bool]]]  # nopep8
+
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+        subject: Subject,
+    ) -> None:
+        super().__init__(config, simulation, subject)
+        if self.step_classes is None:
+            raise ConfigurationError(
+                '{}: you must set step_classes class attribute'.format(
+                    self.__class__.__name__,
+                ),
+            )
+
+    def get_step(self, data) -> BehaviourStep:
+        for step_class, step_test_callable in self.step_classes:
+            if step_test_callable(data):
+                return step_class(**data)
+
+        raise ConfigurationError(
+            '{}: No step choose for following data: {}'.format(
+                self.__class__.__name__,
+                data,
+            ),
+        )
+
+    def run(self, data):
+        step = self.get_step(data)
+        next_step = step.proceed()
+        return next_step.generate_data()
+
+    def action(self, data):
+        step = self.get_step(data)
+        return step.get_events()

synergine2_xyz/move/intention.py

@@ -7,14 +7,16 @@ from synergine2.simulation import Intention
 class MoveToIntention(Intention):
     def __init__(
         self,
-        move_to: typing.Tuple[int, int],
-        start_time: float,
+        to: typing.Tuple[int, int],
         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
+        self.to = to
+        self.gui_action = gui_action
+        self.path = None  # type: typing.List[typing.Tuple[int, int]]
+
+    def get_data(self) -> dict:
+        return {
+            'to': self.to,
+            'gui_action': self.gui_action,
+            'path': self.path,
+        }

synergine2_xyz/move/simulation.py

@@ -1,233 +0,0 @@
-# coding: utf-8
-import time
-import typing
-
-from synergine2.config import Config
-from synergine2.simulation import SimulationBehaviour
-from synergine2.simulation import Simulation
-from synergine2.simulation import Event
-from synergine2.simulation import SubjectMechanism
-from synergine2.simulation import SubjectBehaviour
-from synergine2_xyz.move.intention import MoveToIntention
-from synergine2_xyz.simulation import XYZSimulation
-
-
-class RequestMoveBehaviour(SimulationBehaviour):
-    move_intention_class = MoveToIntention
-
-    @classmethod
-    def merge_data(cls, new_data, start_data=None):
-        # TODO: behaviour/Thing dedicated to Gui -> Simulation ?
-        pass  # This behaviour is designed to be launch by terminal
-
-    def __init__(
-        self,
-        config: Config,
-        simulation: Simulation,
-    ):
-        super().__init__(config, simulation)
-        self.simulation = typing.cast(XYZSimulation, self.simulation)
-
-    def run(self, data):
-        # TODO: behaviour/Thing dedicated to Gui -> Simulation ?
-        pass  # This behaviour is designed to be launch by terminal
-
-    def action(self, data) -> typing.List[Event]:
-        subject_id = data['subject_id']
-        move_to = data['move_to']
-
-        try:
-            subject = self.simulation.subjects.index[subject_id]
-            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
-
-        return []
-
-
-class MoveToMechanism(SubjectMechanism):
-    def run(self):
-        # TODO: Si move to: Si nouveau: a*, si bloque, a*, sinon rien
-        # TODO: pourquoi un mechanism plutot que dans run du behaviour ? faire en sorte que lorsque on calcule,
-        # si un subject est déjà passé par là et qu'il va au même endroit, ne pas recalculer.
-        try:
-            # TODO: MoveToIntention doit être configurable
-            move = self.subject.intentions.get(MoveToIntention)
-            move = typing.cast(MoveToIntention, move)
-            new_path = None
-
-            if not move.path:
-                move.path = self.simulation.physics.found_path(
-                    start=self.subject.position,
-                    end=move.move_to,
-                    subject=self.subject,
-                )
-
-                # Note: We are in process, move change will be lost
-                new_path = move.path
-
-                # move.path = []
-                # new_path = move.path
-                # for i in range(20):
-                #     move.path.append((
-                #         self.subject.position[0],
-                #         self.subject.position[1] + i,
-                #     ))
-
-            next_move = move.path[move.path_progression + 1]
-            # TODO: fin de path
-            if not self.simulation.is_possible_position(next_move):
-                # TODO: refaire le path
-                new_path = ['...']
-
-            return {
-                'new_path': new_path,
-                '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
-            return {
-                'finished': True,
-            }
-        except KeyError:  # TODO: Specialize ? No MoveIntention
-            return None
-
-
-class FinishMoveEvent(Event):
-    def __init__(
-        self,
-        subject_id: int,
-        from_position: typing.Tuple[int, int],
-        to_position: typing.Tuple[int, int],
-        gui_action: typing.Any,
-        move_duration: float=0.0,
-        *args,
-        **kwargs
-    ):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-        self.from_position = from_position
-        self.to_position = to_position
-        self.gui_action = gui_action
-        self.move_duration = move_duration
-
-    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,
-        from_position: typing.Tuple[int, int],
-        to_position: typing.Tuple[int, int],
-        gui_action: typing.Any,
-        move_duration: float=0.0,
-        *args,
-        **kwargs
-    ):
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-        self.from_position = from_position
-        self.to_position = to_position
-        self.gui_action = gui_action
-        self.move_duration = move_duration
-
-    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 MoveToBehaviour(SubjectBehaviour):
-    move_to_mechanism = MoveToMechanism
-    use = [move_to_mechanism]
-
-    def run(self, data):
-        move_to_data = data[self.move_to_mechanism]
-        if move_to_data:
-            if move_to_data.get('finished'):
-                return move_to_data
-
-            if self._can_move_to_next_step(move_to_data):
-                move_to_data['reach_next'] = True
-                return move_to_data
-
-            if self._is_fresh_new_step(move_to_data):
-                move_to_data['reach_next'] = False
-                return move_to_data
-
-        return False
-
-    def _can_move_to_next_step(self, move_to_data: dict) -> bool:
-        raise NotImplementedError()
-
-    def _is_fresh_new_step(self, move_to_data: dict) -> bool:
-        return move_to_data['just_reach'] or move_to_data['initial']
-
-    def finalize_event(self, move_to_data: dict, event: Event) -> None:
-        pass
-
-    def action(self, data) -> [Event]:
-        # TODO: MoveToIntention doit être configurable
-        try:
-            if data.get('finished'):
-                self.subject.intentions.remove(MoveToIntention)
-                return []
-            move = self.subject.intentions.get(MoveToIntention)
-        except KeyError:  # TODO: Specialize exception
-            # Action don't exist anymore
-            return []
-
-        move = typing.cast(MoveToIntention, move)
-        new_path = data['new_path']
-        if new_path:
-            move.path = new_path
-            move.path_progression = -1
-
-        previous_position = self.subject.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,
-                gui_action=move.gui_action,
-            )
-        else:
-            move.just_reach = False
-            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
-        self.subject.intentions.set(move)
-        self.finalize_event(data, event)
-
-        return [event]

tests/test_composed_behaviour.py

@@ -0,0 +1,165 @@
+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+from synergine2.simulation import SubjectComposedBehaviour
+from synergine2.simulation import BehaviourStep
+from synergine2.simulation import Event
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.subjects import XYZSubject
+from tests import BaseTest
+
+
+class BeginFirstEvent(Event):
+    pass
+
+
+class FinishFirstEvent(Event):
+    pass
+
+
+class BeginSecondEvent(Event):
+    pass
+
+
+class FinishSecondEvent(Event):
+    pass
+
+
+class BeginBaseEvent(Event):
+    pass
+
+
+class FinishBaseEvent(Event):
+    pass
+
+
+class MyFirstStep(BehaviourStep):
+    def __init__(self, base: int, first: float=-0.5):
+        self.base = base
+        self.first = first
+
+    def proceed(self) -> 'BehaviourStep':
+        self.first += 0.5
+
+        if self.first == 1:
+            next_step = MySecondStep(
+                base=self.base,
+            )
+            next_step.proceed()
+            return next_step
+
+        return self
+
+    def generate_data(self) -> typing.Any:
+        return {
+            'base': self.base,
+            'first': self.first,
+        }
+
+    def get_events(self) -> typing.List[Event]:
+        if self.base == 0 and self.first == 0:
+            return [BeginBaseEvent(), BeginFirstEvent()]
+
+        if self.first == 0:
+            return [BeginFirstEvent()]
+
+        if self.first == 1:
+            return [FinishFirstEvent(), BeginSecondEvent()]
+
+        return []
+
+
+class MySecondStep(BehaviourStep):
+    def __init__(self, base: int, second: float=-0.5):
+        self.base = base
+        self.second = second
+
+    def proceed(self) -> 'BehaviourStep':
+        self.second += 0.5
+
+        if self.second == 1:
+            self.base = 1
+
+        return self
+
+    def get_events(self) -> typing.List[Event]:
+        if self.second == 0:
+            return [BeginSecondEvent(), FinishFirstEvent()]
+
+        if self.second == 1:
+            return [FinishSecondEvent(), FinishBaseEvent()]
+
+        return []
+
+    def generate_data(self) -> typing.Any:
+        return {
+            'base': self.base,
+            'second': self.second,
+        }
+
+
+class MyComposedBehaviour(SubjectComposedBehaviour):
+    step_classes = [
+        (MySecondStep, lambda d: 'second' in d),
+        (MyFirstStep, lambda d: 'first' in d or d.get('base') == 0),
+    ]
+
+
+class TestComposedBehaviour(BaseTest):
+    def test_subject_composed_behaviour(self):
+        config = Config({})
+        simulation = XYZSimulation(config)
+        subject = XYZSubject(config, simulation)
+
+        my_composed_behaviour = MyComposedBehaviour(
+            config=config,
+            simulation=simulation,
+            subject=subject,
+        )
+
+        # Thirst cycle, ThirstStep is reached and produce event
+        data = my_composed_behaviour.run({
+            'base': 0,
+        })
+        assert {'base': 0, 'first': 0} == data
+
+        events = my_composed_behaviour.action(data)
+        assert events
+        assert 2 == len(events)
+        assert isinstance(events[0], BeginBaseEvent)
+        assert isinstance(events[1], BeginFirstEvent)
+
+        # Second cycle (with previous cycle data), there is data but no events
+        data = my_composed_behaviour.run(data)
+        assert {'base': 0, 'first': 0.5} == data
+
+        events = my_composed_behaviour.action(data)
+        assert not events
+
+        # Third cycle (still with previous cycle data) there is data but and events
+        data = my_composed_behaviour.run(data)
+        assert {'base': 0, 'second': 0} == data
+
+        events = my_composed_behaviour.action(data)
+        assert events
+        assert 2 == len(events)
+        assert isinstance(events[0], BeginSecondEvent)
+        assert isinstance(events[1], FinishFirstEvent)
+
+        # Fourth cycle (still with previous cycle data) there is data but no events
+        data = my_composed_behaviour.run(data)
+        assert {'base': 0, 'second': 0.5} == data
+
+        events = my_composed_behaviour.action(data)
+        assert not events
+
+        # Cycle 5 (still with previous cycle data) there is data and events
+        data = my_composed_behaviour.run(data)
+        assert {'base': 1, 'second': 1} == data
+
+        events = my_composed_behaviour.action(data)
+        assert events
+        assert 2 == len(events)
+        assert isinstance(events[0], FinishSecondEvent)
+        assert isinstance(events[1], FinishBaseEvent)

tests/test_move.py

@@ -1,166 +0,0 @@
-# coding: utf-8
-import time
-
-from freezegun import freeze_time
-
-from synergine2.config import Config
-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):
-    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 = 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)
-
-            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,
-                'gui_action': UserAction.ORDER_MOVE,
-            }
-            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,
-                       'gui_action': UserAction.ORDER_MOVE,
-                   } == 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,
-                       'gui_action': UserAction.ORDER_MOVE,
-                   } == 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,
-                       'gui_action': UserAction.ORDER_MOVE,
-                   } == run_data
-
-            events = behaviour.action(run_data)
-
-            assert events
-            assert 1 == len(events)
-            assert isinstance(events[0], FinishMoveEvent)