use map for move costs

sandbox/tile/maps/003/terrain.tsx

  <image source="terrain.png" width="64" height="64"/>
  <tile id="0">
   <properties>
-   <property name="name" type="str" value="Wood wall"/>
-   <property name="traversable_by_man" type="bool" value="false"/>
-   <property name="traversable_by_vehicle" type="bool" value="false"/>
+   <property name="name" type="str" value="Grass"/>
+   <property name="traversable_by_man" type="bool" value="true"/>
+   <property name="traversable_by_vehicle" type="bool" value="true"/>
   </properties>
  </tile>
  <tile id="1">
   <properties>
-   <property name="name" type="str" value="Grass"/>
-   <property name="traversable_by_man" type="bool" value="true"/>
-   <property name="traversable_by_vehicle" type="bool" value="true"/>
+   <property name="name" type="str" value="Wood wall"/>
+   <property name="traversable_by_man" type="bool" value="false"/>
+   <property name="traversable_by_vehicle" type="bool" value="false"/>
   </properties>
  </tile>
 </tileset>

sandbox/tile/simulation/base.py

 # coding: utf-8
+import tmx
+
+from sandbox.tile.simulation.physics import TerrainTile
+from sandbox.tile.simulation.physics import TileMoveCostComputer
 from synergine2.config import Config
-from synergine2_xyz.physics import Physics, TMXPhysics
+from synergine2_xyz.map import TMXMap
+from synergine2_xyz.physics import Physics
+from synergine2_xyz.physics import TMXPhysics
 from synergine2_xyz.simulation import XYZSimulation
 from synergine2_xyz.subjects import XYZSubjects
 from synergine2_xyz.subjects import XYZSubject
 
 
+class TileMap(TMXMap):
+    xyz_tile_class = TerrainTile
+
+    def get_default_tileset(self) -> tmx.Tileset:
+        return self.tmx_tilesets['terrain']
+
+
+class TilePhysics(TMXPhysics):
+    tmx_map_class = TileMap
+    move_cost_computer_class = TileMoveCostComputer
+
+
 class TileStrategySimulation(XYZSimulation):
     behaviours_classes = [
 
         super().__init__(config)
 
     def create_physics(self) -> Physics:
-        return TMXPhysics(
+        return TilePhysics(
             config=self.config,
             map_file_path=self.map_file_path,
         )

sandbox/tile/simulation/physics.py

+# coding: utf-8
+from synergine2_xyz.map import XYZTile
+from synergine2_xyz.physics import MoveCostComputer
+
+if False:
+    from sandbox.tile.simulation.base import BaseSubject
+
+
+class TerrainTile(XYZTile):
+    pass
+
+
+class TileMoveCostComputer(MoveCostComputer):
+    def compute_move_cost(
+        self,
+        subject: 'BaseSubject',
+        tile: TerrainTile,
+        previous_node: str,
+        next_node: str,
+        unknown,
+    ) -> float:
+        # TODO: Objets/IT qui compute les couts de déplacement
+
+        if not tile.property('traversable_by_man'):
+            # TODO: revoir la lib disjkstar because les mecs traverses quand meme ...
+            return 1000000000000000000000000
+
+        return 1.0

synergine2_xyz/exceptions.py

+# coding: utf-8
+from synergine2.exceptions import SynergineException
+
+
+class XYZException(SynergineException):
+    pass
+
+
+class MapException(XYZException):
+    pass
+
+
+class ImproperlyConfiguredMap(MapException):
+    pass

synergine2_xyz/map.py

 
 import tmx
 
+from synergine2_xyz.exceptions import ImproperlyConfiguredMap
 
-class UnconstructedTile(object):
+
+class XYZTile(object):
+    def __init__(self, tile: tmx.Tile) -> None:
+        self.tile = tile
+
+    def property(self, name: str) -> typing.Union[str, int, float]:
+        for property in self.tile.properties:
+            if property.name == name:
+                return property.value
+
+        raise ImproperlyConfiguredMap('Tile with id "{}" don\'t contains "{}" property'.format(
+            self.tile.id,
+            name,
+        ))
+
+
+class UnconstructedTile(XYZTile):
     pass
 
 
 class TMXMap(object):
+    xyz_tile_class = XYZTile
+
     def __init__(self, map_file_path: str) -> None:
         self.tmx_map = tmx.TileMap.load(map_file_path)
         self.tmx_layers = {}  # type: typing.Dict[str, tmx.Layer]
-        self.tmx_layer_tiles = {}  # type: typing.Dict[str, typing.Dict[str, tmx.Tile]]
+        self.tmx_layer_tiles = {}  # type: typing.Dict[str, typing.Dict[str, XYZTile]]
         self.tmx_tilesets = {}  # type: typing.Dict[str, tmx.Tileset]
-        self.tmx_tiles = {}  # type: typing.Dict[int, tmx.Tile]
+        self.tmx_tiles = {}  # type: typing.Dict[int, XYZTile]
         self._load()
 
     @property
     def width(self) -> int:
         return self.tmx_map.width
 
+    def get_default_tileset(self) -> tmx.Tileset:
+        return list(self.tmx_tilesets.values())[0]
+
+    def get_default_tile(self) -> XYZTile:
+        tileset = self.get_default_tileset()
+        return self.xyz_tile_class(tileset.tiles[0])
+
     def _load(self) -> None:
         self._load_layers()
         self._load_tilesets()
         for tileset in self.tmx_map.tilesets:
             self.tmx_tilesets[tileset.name] = tileset
             for tile in tileset.tiles:
-                self.tmx_tiles[tileset.firstgid + tile.id] = tile
+                self.tmx_tiles[tileset.firstgid + tile.id] = self.xyz_tile_class(tile)
 
     def _load_tiles(self) -> None:
         for layer_name, layer in self.tmx_layers.items():
-            x, y = -1, -1
+            x, y = -1, 0
             self.tmx_layer_tiles[layer_name] = {}
 
             # no tiles
                 position_key = '{}.{}'.format(x, y)
 
                 if not layer_tile.gid:
-                    tile = None
+                    tile = self.get_default_tile()
                 elif not layer_tile.gid in self.tmx_tiles:
-                    tile = UnconstructedTile()
+                    # tile = UnconstructedTile()
+                    tile = self.get_default_tile()
                 else:
                     tile = self.tmx_tiles[layer_tile.gid]
 
     def tileset(self, name: str) -> tmx.Tileset:
         return self.tmx_tilesets[name]
 
-    def tile(self, gid: int) -> tmx.Tile:
+    def tile(self, gid: int) -> XYZTile:
         return self.tmx_tiles[gid]
+
+    def layer_tiles(self, name: str) -> typing.Dict[str, XYZTile]:
+        return self.tmx_layer_tiles[name]

synergine2_xyz/move.py

                 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

synergine2_xyz/physics.py

 # coding: utf-8
 import typing
 
-import tmx
 from dijkstar import Graph
 from dijkstar import find_path
 
 from synergine2.config import Config
-from synergine2_xyz.map import TMXMap
-from synergine2_xyz.tmx_utils import get_layer_by_name
+from synergine2_xyz.map import TMXMap, XYZTile
+from synergine2_xyz.subjects import XYZSubject
+from synergine2_xyz.xyz import get_neighbor_positions
+
+
+class MoveCostComputer(object):
+    def __init__(
+        self,
+        config: Config,
+    ) -> None:
+        self.config = config
+
+    def for_subject(self, subject: XYZSubject):
+        # TODO: Verifier ce que sont les parametres pour les nommer correctement
+        def move_cost_func(previous_node: str, next_node: str, tile: XYZTile, unknown):
+            return self.compute_move_cost(subject, tile, previous_node, next_node, unknown)
+        return move_cost_func
+
+    def compute_move_cost(
+        self,
+        subject: XYZSubject,
+        tile: XYZTile,
+        previous_node: str,
+        next_node: str,
+        unknown,
+    ) -> float:
+        return 1.0
 
 
 class Physics(object):
+    move_cost_computer_class = MoveCostComputer
+
     def __init__(
         self,
         config: Config,
     ) -> None:
         self.config = config
         self.graph = Graph()
+        self.move_cost_computer = self.move_cost_computer_class(config)
 
     def load(self) -> None:
         raise NotImplementedError()
         self,
         start: typing.Tuple[int, int],
         end: typing.Tuple[int, int],
+        subject: XYZSubject,
     ) -> typing.List[typing.Tuple[int, int]]:
         start_key = self.position_to_key(start)
         end_key = self.position_to_key(end)
 
-        found_path = find_path(self.graph, start_key, end_key)
+        found_path = find_path(self.graph, start_key, end_key, cost_func=self.move_cost_computer.for_subject(subject))
         regular_path = []
         for position in found_path[0][1:]:
             x, y = map(int, position.split('.'))
 
 
 class TMXPhysics(Physics):
+    tmx_map_class = TMXMap
+
     def __init__(
         self,
         config: Config,
     ) -> None:
         super().__init__(config)
         self.map_file_path = map_file_path
+        self.tmx_map = self.tmx_map_class(map_file_path)
 
     def load(self) -> None:
         self.load_graph_from_map(self.map_file_path)
 
     def load_graph_from_map(self, map_file_path: str) -> None:
-        tmx_map = TMXMap(map_file_path)
-
         # TODO: tmx_map contient tout en cache, faire le dessous en exploitant tmx_map.
-        for y in range(tmx_map.height):
-            for x in range(tmx_map.width):
+        for y in range(self.tmx_map.height):
+            for x in range(self.tmx_map.width):
                 position = self.position_to_key((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 > 69 or neighbor_x < 0:
+
+                for neighbor_position in get_neighbor_positions((x, y)):
+                    neighbor = '{}.{}'.format(*neighbor_position)
+                    neighbor_x, neighbor_y = neighbor_position
+
+                    if neighbor_x > self.tmx_map.width-1 or neighbor_x < 0:
                         continue
 
-                    if neighbor_y > 69 or neighbor_y < 0:
+                    if neighbor_y > self.tmx_map.height-1 or neighbor_y < 0:
                         continue
 
-                    # TODO: Voir https://pypi.python.org/pypi/Dijkstar/2.2
-                    self.graph.add_edge(position, neighbor, 1)
+                    # Note: movement consider future tile properties
+                    to_tile = self.tmx_map.layer_tiles('terrain')[neighbor]
+                    # Note: Voir https://pypi.python.org/pypi/Dijkstar/2.2
+                    self.graph.add_edge(position, neighbor, to_tile)

synergine2_xyz/xyz.py

 # coding: utf-8
+import typing
 from math import acos
 from math import degrees
 from math import sqrt
         degree,
         DIRECTION_FROM_NORTH_DEGREES,
     ))
+
+
+def get_neighbor_positions(position: typing.Tuple[int, int]) -> typing.List[typing.Tuple[int, int]]:
+    neighbors = []
+
+    for modifier_x, modifier_y, modifier_z in DIRECTION_MODIFIERS.values():
+        neighbors.append((position[0] + modifier_x, position[1] + modifier_y))
+
+    return neighbors