move with Dijkstar lib

requirements.txt

 appdirs==1.4.2
 cocos2d==0.6.4
 coverage==4.4.1
+Dijkstar==2.2
 execnet==1.4.1
 packaging==16.8
 psutil==5.2.2

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 MoveEvent
 
 
 class CocosTerminal(GameTerminal):
     subscribed_events = [
-
+        MoveEvent,
     ]
 
     def __init__(self, *args, asynchronous: bool, map_dir_path: str, **kwargs):

synergine2_cocos2d/actions.py

+# coding: utf-8
+from cocos.actions import MoveTo as BaseMoveTo
+
+
+class MoveTo(BaseMoveTo):
+    def update(self, t):
+        super().update(t)
+        self.target.need_update_cshape = True

synergine2_cocos2d/gui.py

 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.exception import InteractionNotFound
 from synergine2_cocos2d.exception import OuterWorldPosition
 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.middleware import TMXMiddleware
 from synergine2_cocos2d.user_action import UserAction
+from synergine2_xyz.move import MoveEvent
 from synergine2_xyz.xyz import XYZSubjectMixin
 
 
             read_queue_interval,
         )
 
+        self.terminal.register_event_handler(
+            MoveEvent,
+            self.move_subject,
+        )
+
     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 move_subject(self, event: MoveEvent):
+        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.position)
+        new_window_position = self.layer_manager.scrolling_manager.world_to_screen(*new_world_position)
+
+        move_action = MoveTo(new_window_position, 0.5)
+        actor.do(move_action)

synergine2_cocos2d/layer.py

         return world_positions
 
 
+class SubjectLayer(cocos.layer.ScrollableLayer):
+    def __init__(self, parallax: int=1):
+        super().__init__(parallax)
+        self.subjects_index = {}
+
+    def add_subject(self, actor: 'Actor') -> None:
+        self.add(actor)
+        self.subjects_index[actor.subject.id] = actor
+
+
 class LayerManager(object):
     def __init__(
         self,
 
         self.background_sprite = None  # type: cocos.sprite.Sprite
         self.ground_layer = None  # type: cocos.tiles.RectMapLayer
-        self.subject_layer = None  # type: cocos.layer.ScrollableLayer
+        self.subject_layer = None  # type: SubjectLayer
         self.top_layer = None  # type: cocos.tiles.RectMapLayer
 
     def init(self) -> None:
 
         self.background_sprite = self.middleware.get_background_sprite()
         self.ground_layer = self.middleware.get_ground_layer()
-        self.subject_layer = cocos.layer.ScrollableLayer()
+        self.subject_layer = SubjectLayer()
         self.top_layer = self.middleware.get_top_layer()
 
         self.main_layer.add(self.background_sprite)
         self.top_layer.set_view(0, 0, self.top_layer.px_width, self.top_layer.px_height)
 
     def add_subject(self, subject: 'Actor') -> None:
-        self.subject_layer.add(subject)
+        self.subject_layer.add_subject(subject)
 
     def remove_subject(self, subject: 'Actor') -> None:
         self.subject_layer.remove(subject)

synergine2_xyz/move.py

 # coding: utf-8
 import typing
 
+from dijkstar import find_path
+
 from synergine2.config import Config
 from synergine2.simulation import SimulationBehaviour
 from synergine2.simulation import SubjectBehaviour
             # TODO: MoveToIntention doit être configurable
             move = self.subject.intentions.get(MoveToIntention)
             move = typing.cast(MoveToIntention, move)
-            new_path = move.path or None
+            new_path = None
 
             if not move.path:
-                # TODO: Fake to test
-                new_path = []
-                for i in range(20):
-                    new_path.append((
-                        self.subject.position[0],
-                        self.subject.position[1] + i,
-                    ))
-
-            next_move = new_path[move.path_progression + 1]
+                # TODO: Must be XYZSimulation !
+                start = '{}.{}'.format(*self.subject.position)
+                end = '{}.{}'.format(*move.move_to)
+
+                found_path = find_path(self.simulation.graph, start, end)
+                move.path = []
+
+                for position in found_path[0]:
+                    x, y = map(int, position.split('.'))
+                    move.path.append((x, y))
+
+                # 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': new_path,
             }
 
-        except KeyError:
+        except IndexError:  # TODO: Specialize ? No movement left
+            return None
+        except KeyError:  # TODO: Specialize ? No MoveIntention
             return None
 
 
             # TODO: progression et lorsque "vraiment avance d'une case" envoyer le Move
             # pour le moment on move direct
             # TODO: fin de path
-            move.path_progression += 1  # BUG: ca progresse pas ?
+            move.path_progression += 1
             new_position = move.path[move.path_progression]
             self.subject.position = new_position
 

synergine2_xyz/simulation.py

 # coding: utf-8
 import typing
 
+from dijkstar import Graph
+
+from synergine2.config import Config
 from synergine2.simulation import Simulation as BaseSimulation
 from synergine2_xyz.subjects import XYZSubjects
 from synergine2_xyz.subjects import XYZSubject
 class XYZSimulation(BaseSimulation):
     accepted_subject_class = XYZSubjects
 
+    def __init__(
+        self,
+        config: Config,
+    ) -> None:
+        super().__init__(config)
+        self.graph = Graph()
+
+        # TODO: Le graph devra être calculé à partir de données comme tmx
+        for y in range(40):
+            for x in range(70):
+                position = '{}.{}'.format(x, y)
+                neighbors = []
+
+                for modifier_x, modifier_y in (
+                    (+1, +1),
+                    (+1, +0),
+                    (+1, -1),
+                    (+0, -1),
+                    (-1, -1),
+                    (-1, +0),
+                    (-1, -1),
+                    (+0, +1),
+                ):
+                    try:
+                        neighbors.append('{}.{}'.format(x+modifier_x, y+modifier_y))
+                    except ValueError:
+                        pass
+
+                for neighbor in neighbors:
+                    neighbor_x, neighbor_y = map(int, neighbor.split('.'))
+
+                    if neighbor_x > 39 or neighbor_x < 0:
+                        continue
+
+                    if neighbor_y > 69 or neighbor_y < 0:
+                        continue
+
+                    # TODO: Voir https://pypi.python.org/pypi/Dijkstar/2.2
+                    self.graph.add_edge(position, neighbor, 1)
+
     def is_possible_subject_position(self, subject: XYZSubject, position: tuple) -> bool:
         return self.is_possible_position(position)