move order

sandbox/engulf/behaviour.py

 
 from sandbox.engulf.const import COLLECTION_GRASS, COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_PREY
 from sandbox.engulf.exceptions import NotFoundWhereToGo
-from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour, SubjectBehaviourSelector
 from synergine2.simulation import Event
+from synergine2.simulation import SubjectBehaviour, SimulationMechanism, SimulationBehaviour, SubjectBehaviourSelector
 from synergine2.utils import ChunkManager
-from synergine2.xyz import ProximitySubjectMechanism, DIRECTIONS, DIRECTION_SLIGHTLY, get_direction_from_north_degree
-from synergine2.xyz_utils import get_around_positions_of_positions, get_position_for_direction
+from synergine2_xyz.xyz import DIRECTIONS, DIRECTION_SLIGHTLY, \
+    get_direction_from_north_degree
+from synergine2_xyz.mechanism import ProximitySubjectMechanism
+from synergine2_xyz.utils import get_around_positions_of_positions, get_position_for_direction
 
 # Import for typing hint
 if False:

sandbox/engulf/exceptions.py

 # coding: utf-8
-from synergine2.xyz import XYZException
+from synergine2_xyz.xyz import XYZException
 
 
 class NotFoundWhereToGo(XYZException):

sandbox/engulf/run.py

 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
-from sandbox.engulf.subject import Cell, Grass, PreyCell, PredatorCell
+from sandbox.engulf.subject import Grass, PreyCell, PredatorCell
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager, Terminal, TerminalPackage
 from sandbox.engulf.simulation import EngulfSubjects, Engulf
-from synergine2.xyz_utils import get_around_positions_of, get_distance_between_points
+from synergine2_xyz.utils import get_around_positions_of, get_distance_between_points
 
 
 class GameTerminal(Terminal):

sandbox/engulf/simulation.py

 # coding: utf-8
 from sandbox.engulf.behaviour import GrassSpawnBehaviour
 from sandbox.engulf.subject import Cell, Grass
-from synergine2.xyz import XYZSubjects, XYZSubjectMixin, XYZSimulation
+from synergine2_xyz.xyz import XYZSubjectMixin
+from synergine2_xyz.subjects import XYZSubjects
+from synergine2_xyz.simulation import XYZSimulation
 
 __author__ = 'bux'
 

sandbox/engulf/subject.py

 from sandbox.engulf.const import COLLECTION_CELL, COLLECTION_ALIVE, COLLECTION_EATABLE, COLLECTION_GRASS, \
     COLLECTION_PREY, COLLECTION_PREDATOR
 from synergine2.simulation import Subject
-from synergine2.xyz import XYZSubjectMixin
+from synergine2_xyz.xyz import XYZSubjectMixin
 
 
 class Cell(XYZSubjectMixin, Subject):

sandbox/life_game/run.py

 # coding: utf-8
+import logging
 import os
 import sys
 
-import logging
-
 synergine2_ath = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
 sys.path.append(synergine2_ath)
 
 
 from synergine2.config import Config
 from synergine2.log import get_default_logger
-from sandbox.life_game.simulation import Cell, LotOfCellsSignalBehaviour, LifeGame, \
+from sandbox.life_game.simulation import Cell, LifeGame, \
     EmptyPositionWithLotOfCellAroundEvent
 from sandbox.life_game.simulation import Empty
 from sandbox.life_game.simulation import CellDieEvent
 from sandbox.life_game.utils import get_subjects_from_str_representation
 from synergine2.core import Core
 from synergine2.cycle import CycleManager
-from synergine2.simulation import Simulation
 from synergine2.simulation import Event
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
 from synergine2.terminals import TerminalManager
-from synergine2.xyz_utils import get_str_representation_from_positions
+from synergine2_xyz.utils import get_str_representation_from_positions
 
 
 class SimplePrintTerminal(Terminal):

sandbox/life_game/simulation.py

 # coding: utf-8
-from synergine2.simulation import Subject, SimulationMechanism
-from synergine2.simulation import SimulationBehaviour
 from synergine2.simulation import Event
+from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import Subject, SimulationMechanism
 from synergine2.simulation import SubjectBehaviour
 from synergine2.utils import ChunkManager
-from synergine2.xyz import ProximitySubjectMechanism, ProximityMixin
-from synergine2.xyz import XYZSubjectMixin
-from synergine2.xyz import XYZSimulation
-from synergine2.xyz_utils import get_around_positions_of_positions, get_min_and_max
+from synergine2_xyz.xyz import ProximityMixin
+from synergine2_xyz.mechanism import ProximitySubjectMechanism
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.xyz import XYZSubjectMixin
+from synergine2_xyz.utils import get_around_positions_of_positions, get_min_and_max
 
 COLLECTION_CELL = 'COLLECTION_CELL'  # Collections of Cell type
 

sandbox/life_game/utils.py

 # coding: utf-8
-from sandbox.life_game.simulation import Empty
 from sandbox.life_game.simulation import Cell
+from sandbox.life_game.simulation import Empty
 from synergine2.simulation import Simulation
-from synergine2.xyz import XYZSubjects
-from synergine2.xyz_utils import get_positions_from_str_representation
+from synergine2_xyz.subjects import XYZSubjects
+from synergine2_xyz.utils import get_positions_from_str_representation
 
 
 def get_subjects_from_str_representation(

sandbox/tile/simulation/base.py

 # coding: utf-8
-from synergine2.simulation import Subject
-from synergine2.xyz import XYZSimulation
-from synergine2.xyz import XYZSubjectMixin
-from synergine2.xyz import XYZSubjects
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.xyz import XYZSubject
+from synergine2_xyz.subjects import XYZSubjects
 
 
 class TileStrategySimulation(XYZSimulation):
     pass
 
 
-class BaseSubject(XYZSubjectMixin, Subject):
+class BaseSubject(XYZSubject):
     pass

synergine2/simulation.py

 from synergine2.utils import get_mechanisms_classes
 
 
+class Intention(object):
+    pass
+
+
 class Subject(BaseObject):
     collections = []
     behaviours_classes = []
         self.simulation = simulation
         self.behaviours = {}
         self.mechanisms = {}
+        self.intentions = []  # type: typing.List[Intention]
         self.behaviour_selector = None  # type: SubjectBehaviourSelector
         if self.behaviour_selector_class:
             self.behaviour_selector = self.behaviour_selector_class()

synergine2_cocos2d/event.py

-# coding: utf-8
-
-"""
-WARNING: Do not import cocos/pyglet stuff here: cocos/pyglet modules must be loaded inside gui process.
-"""
-import typing
-
-from synergine2.simulation import Event
-
-
-class GuiRequestMoveEvent(Event):
-    def __init__(
-        self,
-        subject_id: int,
-        move_to_position: typing.Tuple[int, int],
-        *args,
-        **kwargs
-    ) -> None:
-        super().__init__(*args, **kwargs)
-        self.subject_id = subject_id
-        self.move_to_position = move_to_position

synergine2_cocos2d/gui.py

 from math import floor
 
 import pyglet
-from pyglet.window import mouse
 from pyglet.window import key
+from pyglet.window import mouse
 
 import cocos
 from cocos import collision_model
 from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
-from synergine2.xyz import XYZSubjectMixin
 from synergine2_cocos2d.actor import Actor
-from synergine2_cocos2d.exception import OuterWorldPosition
 from synergine2_cocos2d.exception import InteractionNotFound
-from synergine2_cocos2d.gl import rectangle_positions_type
+from synergine2_cocos2d.exception import OuterWorldPosition
 from synergine2_cocos2d.gl import draw_rectangle
+from synergine2_cocos2d.gl import rectangle_positions_type
 from synergine2_cocos2d.interaction import InteractionManager
 from synergine2_cocos2d.layer import LayerManager
-from synergine2_cocos2d.middleware import TMXMiddleware
 from synergine2_cocos2d.middleware import MapMiddleware
+from synergine2_cocos2d.middleware import TMXMiddleware
 from synergine2_cocos2d.user_action import UserAction
+from synergine2_xyz.xyz import XYZSubjectMixin
 
 
 class GridManager(object):

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, TerminalPackage
-from synergine2_cocos2d.event import GuiRequestMoveEvent
+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
 
 class MoveActorInteraction(Interaction):
     gui_action = UserAction.ORDER_MOVE
+    request_move_behaviour_class = RequestMoveBehaviour
 
     def draw_pending(self) -> None:
             for actor in self.layer_manager.edit_layer.selection:
 
     def get_package_for_terminal(self) -> TerminalPackage:
         # TODO: MoveEvent ?
-        events = []
+        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:
-            events.append(GuiRequestMoveEvent(
-                subject_id=actor.subject.id,
-                move_to_position=mouse_grid_position,
+            actions.append((
+                self.request_move_behaviour_class, {
+                    'subject_id': actor.subject.id,
+                    'move_to': mouse_grid_position,
+                }
             ))
 
         return TerminalPackage(
-            events=events
+            simulation_actions=actions,
         )

synergine2_xyz/__init__.py

+# coding: utf-8

synergine2_xyz/mechanism.py

+# coding: utf-8
+from synergine2.simulation import SubjectMechanism
+from synergine2_xyz.xyz import ProximityMixin
+
+
+class ProximitySubjectMechanism(ProximityMixin, SubjectMechanism):
+    def run(self):
+        return self.get_for_position(
+            position=self.subject.position,
+            simulation=self.simulation,
+            exclude_subject=self.subject,
+        )

synergine2_xyz/move.py

+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+from synergine2.simulation import SimulationBehaviour, SubjectBehaviour
+from synergine2.simulation import Intention
+from synergine2.simulation import Simulation
+from synergine2.simulation import Event
+from synergine2_xyz.simulation import XYZSimulation
+
+
+class MoveToIntention(Intention):
+    def __init__(self, move_to: typing.Tuple[int, int]) -> None:
+        self.move_to = move_to
+        self.path = []  # type: typing.List[typing.Tuple[int, int]]
+        self.path_progression = None  # type: int
+
+
+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.append(self.move_intention_class(move_to))
+        except KeyError:
+            # TODO: log error here
+            pass
+
+        return []
+
+
+class MoveToBehaviour(SubjectBehaviour):
+    def run(self, data):
+        # TODO: progresser dans l'intention (comment implementer ça?)
+        raise NotImplementedError()
+
+    def action(self, data) -> [Event]:
+        # TODO: effectuer un move vers une nouvelle position ou faire progresser "l'entre-deux"
+        raise NotImplementedError()

synergine2_xyz/simulation.py

+# coding: utf-8
+import typing
+
+from synergine2.simulation import Simulation as BaseSimulation
+from synergine2_xyz.xyz import XYZSubject
+from synergine2_xyz.subjects import XYZSubjects
+
+
+class XYZSimulation(BaseSimulation):
+    accepted_subject_class = XYZSubjects
+
+    def is_possible_subject_position(self, subject: XYZSubject, position: tuple) -> bool:
+        return self.is_possible_position(position)
+
+    def is_possible_position(self, position: tuple) -> bool:
+        return True

synergine2_xyz/subjects.py

+# coding: utf-8
+from synergine2.simulation import Subjects
+from synergine2_xyz.xyz import XYZSubjectMixin, PositionNotPossible
+
+
+class XYZSubjects(Subjects):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # TODO: accept multiple subjects as same position
+        # TODO: init xyz with given list
+        self.xyz = {}
+
+    def have_to_check_position_is_possible(self) -> bool:
+        return True
+
+    def remove(self, value: XYZSubjectMixin):
+        super().remove(value)
+
+        try:
+            self.xyz.get(value.position, []).remove(value)
+            if not self.xyz[value.position]:
+                del self.xyz[value.position]
+        except ValueError:
+            pass
+
+    def append(self, p_object: XYZSubjectMixin):
+        super().append(p_object)
+
+        if self.have_to_check_position_is_possible() \
+           and not self.simulation.is_possible_subject_position(p_object, p_object.position):
+            raise PositionNotPossible('Position {} for {} is not possible'.format(
+                str(p_object.position),
+                str(p_object),
+            ))
+
+        self.xyz.setdefault(p_object.position, []).append(p_object)

synergine2/xyz_utils.py → synergine2_xyz/utils.py

 # coding: utf-8
-from math import sqrt
 import collections
+from math import sqrt
 
-from synergine2.xyz import DIRECTION_MODIFIERS
+from synergine2_xyz.xyz import DIRECTION_MODIFIERS
 
 
 def get_positions_from_str_representation(str_representation):

synergine2/xyz.py → synergine2_xyz/xyz.py

 # coding: utf-8
-from math import sqrt
-from math import degrees
 from math import acos
+from math import degrees
+from math import sqrt
 
 from synergine2.exceptions import SynergineException
-from synergine2.simulation import SubjectMechanism, Subjects, Subject
-from synergine2.simulation import Simulation as BaseSimulation
-
+from synergine2.simulation import Subject
 
 """
 
         self._position = value
 
 
+class XYZSubject(XYZSubjectMixin, Subject):
+    pass
+
+
 class ProximityMixin(object):
     distance = 1
     feel_collections = [COLLECTION_XYZ]
 
     @classmethod
     def get_distance_of(cls, position, subject: XYZSubjectMixin):
-        from synergine2.xyz_utils import get_distance_between_points  # cyclic import
+        from synergine2_xyz.utils import get_distance_between_points  # cyclic import
         return get_distance_between_points(
             position,
             subject.position,
         return True
 
 
-class ProximitySubjectMechanism(ProximityMixin, SubjectMechanism):
-    def run(self):
-        return self.get_for_position(
-            position=self.subject.position,
-            simulation=self.simulation,
-            exclude_subject=self.subject,
-        )
-
-
-class XYZSubjects(Subjects):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # TODO: accept multiple subjects as same position
-        # TODO: init xyz with given list
-        self.xyz = {}
-
-    def have_to_check_position_is_possible(self) -> bool:
-        return True
-
-    def remove(self, value: XYZSubjectMixin):
-        super().remove(value)
-
-        try:
-            self.xyz.get(value.position, []).remove(value)
-            if not self.xyz[value.position]:
-                del self.xyz[value.position]
-        except ValueError:
-            pass
-
-    def append(self, p_object: XYZSubjectMixin):
-        super().append(p_object)
-
-        if self.have_to_check_position_is_possible() \
-           and not self.simulation.is_possible_subject_position(p_object, p_object.position):
-            raise PositionNotPossible('Position {} for {} is not possible'.format(
-                str(p_object.position),
-                str(p_object),
-            ))
-
-        self.xyz.setdefault(p_object.position, []).append(p_object)
-
-
-class XYZSimulation(BaseSimulation):
-    accepted_subject_class = XYZSubjects
-
-    def is_possible_subject_position(self, subject: XYZSubjectMixin, position: tuple) -> bool:
-        return self.is_possible_position(position)
-
-    def is_possible_position(self, position: tuple) -> bool:
-        return True
-
-
 def get_direction_from_north_degree(degree: float):
     for range, direction in DIRECTION_FROM_NORTH_DEGREES.items():
         if range[0] <= degree <= range[1]:

tests/test_life_game.py

 # coding: utf-8
 import collections
+
 from sandbox.life_game.simulation import Cell
 from sandbox.life_game.simulation import Empty
 from sandbox.life_game.utils import get_subjects_from_str_representation
 from synergine2.config import Config
 from synergine2.cycle import CycleManager
 from synergine2.log import SynergineLogger
-from synergine2.xyz import XYZSubjects
-from synergine2.xyz import XYZSimulation
-from synergine2.xyz_utils import get_str_representation_from_positions
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.subjects import XYZSubjects
+from synergine2_xyz.utils import get_str_representation_from_positions
 from tests import BaseTest
 from tests import str_kwargs
 

tests/test_xyz.py

 # -*- coding: utf-8 -*-
 from synergine2.config import Config
 from synergine2.simulation import Subject
-from synergine2.xyz import ProximitySubjectMechanism
-from synergine2.xyz import XYZSubjects
-from synergine2.xyz import XYZSimulation
-from synergine2.xyz import XYZSubjectMixin
-from synergine2.xyz_utils import get_positions_from_str_representation
-from synergine2.xyz_utils import get_str_representation_from_positions
+from synergine2_xyz.mechanism import ProximitySubjectMechanism
+from synergine2_xyz.simulation import XYZSimulation
+from synergine2_xyz.xyz import XYZSubjectMixin
+from synergine2_xyz.subjects import XYZSubjects
+from synergine2_xyz.utils import get_positions_from_str_representation
+from synergine2_xyz.utils import get_str_representation_from_positions
 from tests import BaseTest
 from tests import str_kwargs