MoveAction: data are computed in Event

intelligine/core/exceptions.py

@@ -6,6 +6,10 @@ class SamePosition(MovementException):
     pass
 
 
+class UnableToFoundMovement(MovementException):
+    pass
+
+
 class PheromoneException(Exception):
     pass
 

intelligine/synergy/event/move/MoveAction.py

@@ -1,10 +1,8 @@
 from synergine.synergy.event.Action import Action
 from intelligine.synergy.event.move.MoveEvent import MoveEvent
 from synergine.synergy.event.exception.ActionAborted import ActionAborted
-from xyzworld.cst import POSITION
-from intelligine.cst import BRAIN_PART_MOVE, BRAIN_SCHEMA
+from intelligine.cst import BRAIN_PART_MOVE
 from xyzworld.cst import BLOCKED_SINCE
-from intelligine.synergy.event.move.direction import get_position_with_direction_decal
 
 
 class MoveAction(Action):
@@ -17,40 +15,22 @@ class MoveAction(Action):
         self._move_to_direction = None
 
     def prepare(self, context):
-        object_point = context.metas.value.get(POSITION, self._object_id)
-        direction = self._get_prepared_direction(context)
-        self._set_prepared_direction(context, object_point, direction)
-
-    def _get_prepared_direction(self, context):
-        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, self._object_id)
-        object_move_brain_part = object_brain_schema[BRAIN_PART_MOVE]
-        return object_move_brain_part.get_direction(context, self._object_id)
-
-    def _set_prepared_direction(self, context, object_point, direction):
-        move_to_point = get_position_with_direction_decal(direction, object_point)
-        if self._direction_point_is_possible(context, move_to_point):
-            self._move_to_point = move_to_point
-            self._move_to_direction = direction
-        else:
-            # TODO: mettre self._dont_move = True ?
-            pass
-
-    @staticmethod
-    def _direction_point_is_possible(context, direction_point):
-        return context.position_is_penetrable(direction_point)
+        # TODO: C'est event qui doit tout preparer. Action::prepare pourra meme disparaitre ?
+        pass
 
     def run(self, obj, context, synergy_manager):
         try:
             self._apply_move(obj, context)
         except ActionAborted:
+            # TODO: Dans l'obj ces lignes
             blocked_since = context.metas.value.get(BLOCKED_SINCE, self._object_id, allow_empty=True, empty_value=0)
-            context.metas.value.set(BLOCKED_SINCE, self._object_id, blocked_since+1)
+            context.metas.value.set(BLOCKED_SINCE, obj.get_id(), blocked_since+1)
 
     def _apply_move(self, obj, context):
         # TODO: il ne faut pas choisir une direction 14.
-        if self._move_to_point is None or self._move_to_direction == 14:
+        if MoveEvent.PARAM_DIRECTION not in self._parameters or self._parameters[MoveEvent.PARAM_DIRECTION] == 14:
             raise ActionAborted()
 
-        obj.set_position(self._move_to_point)
-        obj.set_previous_direction(self._move_to_direction)
+        obj.set_position(self._parameters[MoveEvent.PARAM_POSITION])
+        obj.set_previous_direction(self._parameters[MoveEvent.PARAM_DIRECTION])
         obj.get_brain().get_part(BRAIN_PART_MOVE).done(obj, context)

intelligine/synergy/event/move/MoveEvent.py

@@ -1,10 +1,17 @@
+from intelligine.core.exceptions import UnableToFoundMovement
+from intelligine.synergy.event.move.direction import get_position_with_direction_decal
+from synergine.core.exceptions import NotConcernedEvent
 from synergine.synergy.event.Event import Event
 from synergine.core.simulation.mechanism.Mechanism import Mechanism
-from intelligine.cst import COL_WALKER
+from intelligine.cst import COL_WALKER, BRAIN_SCHEMA, BRAIN_PART_MOVE
+from xyzworld.cst import POSITION
 
 
 class MoveEvent(Event):
 
+    PARAM_POSITION = 'pos'
+    PARAM_DIRECTION = 'dir'
+
     concern = COL_WALKER
 
     def __init__(self, actions):
@@ -12,4 +19,25 @@ class MoveEvent(Event):
         self._mechanism = Mechanism
 
     def _prepare(self, object_id, context, parameters={}):
-        return parameters
+        try:
+            direction = self._get_direction(object_id, context)
+        except UnableToFoundMovement:
+            raise NotConcernedEvent()
+
+        object_point = context.metas.value.get(POSITION, object_id)
+        move_to_point = get_position_with_direction_decal(direction, object_point)
+        # TODO: future: c le brain qui calcule ou aller, et donc si c possible
+        if self._direction_point_is_possible(context, move_to_point):
+            parameters[self.PARAM_POSITION] = move_to_point
+            parameters[self.PARAM_DIRECTION] = direction
+        # TODO: Sinon lever un NotConcernedEvent
+        return parameters
+
+    def _get_direction(self, object_id, context):
+        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
+        object_move_brain_part = object_brain_schema[BRAIN_PART_MOVE]
+        return object_move_brain_part.get_direction(context, object_id)
+
+    @staticmethod
+    def _direction_point_is_possible(context, direction_point):
+        return context.position_is_penetrable(direction_point)

intelligine/tests/simulation/mode/TestChangeMode.py

@@ -29,8 +29,8 @@ class TestChangeMode(Base):
         self._force_move = self._force_move
 
     @staticmethod
-    def _force_move(self_move_action, context, object_point):
-        object_movement_mode = context.metas.value.get(MOVE_MODE, self_move_action._object_id)
+    def _force_move(self_move_action, object_id, context):
+        object_movement_mode = context.metas.value.get(MOVE_MODE, object_id)
         if object_movement_mode == MOVE_MODE_GOHOME:
             return SOUTH
         return NORTH
@@ -44,7 +44,7 @@ class TestChangeMode(Base):
             def __init__(self, configuration):
                 super().__init__(configuration)
                 self._actions.remove(MoveAction)
-                TestMoveAction.force_direction = test_case._force_move
+                TestMoveAction.set_move_event(test_case._force_move)
                 self._actions.append(TestMoveAction)
         return TestColony(self._get_colony_configuration())
 

intelligine/tests/src/event/MoveAction.py

@@ -1,10 +1,10 @@
 from intelligine.synergy.event.move.MoveAction import MoveAction as BaseMoveAction
-from intelligine.synergy.event.move.direction import NORTH
+from intelligine.tests.src.event.MoveEvent import MoveEvent
 
 
 class MoveAction(BaseMoveAction):
 
-    force_direction = lambda self, context, object_id: NORTH
-
-    def _get_prepared_direction(self, context):
-        return self.force_direction(context, self._object_id)
+    @classmethod
+    def set_move_event(cls, force_direction_function, event=MoveEvent):
+        event.force_direction = force_direction_function
+        cls._listen = event