Tmx map cache manager

sandbox/tile/maps/003/terrain.tsx

+<?xml version="1.0" encoding="UTF-8"?>
+<tileset name="terrain" tilewidth="8" tileheight="8" spacing="1" tilecount="49" columns="7">
+ <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"/>
+  </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"/>
+  </properties>
+ </tile>
+</tileset>

sandbox/tile/run.py

     seed(seed_value)
 
     config = Config()
-    config.load_files(['sandbox/engulf/config.yaml'])
+    config.load_files(['sandbox/engulf/config.yaml'])  # TODO: heu ... engulf ??
     logger = get_default_logger(level=logging.ERROR)
 
-    simulation = TileStrategySimulation(config)
+    map_file_path = 'sandbox/tile/{}.tmx'.format(os.path.join(map_dir_path, os.path.basename(map_dir_path)))
+
+    simulation = TileStrategySimulation(config, map_file_path=map_file_path)
     subjects = TileStrategySubjects(simulation=simulation)
 
     for position in ((0, 0), (5, 3), (10, 6)):

sandbox/tile/simulation/base.py

 # coding: utf-8
+from synergine2.config import Config
+from synergine2_xyz.physics import Physics, TMXPhysics
 from synergine2_xyz.simulation import XYZSimulation
 from synergine2_xyz.subjects import XYZSubjects
 from synergine2_xyz.subjects import XYZSubject
 
     ]
 
+    def __init__(
+        self,
+        config: Config,
+        map_file_path: str,
+    ) -> None:
+        self.map_file_path = map_file_path
+        super().__init__(config)
+
+    def create_physics(self) -> Physics:
+        return TMXPhysics(
+            config=self.config,
+            map_file_path=self.map_file_path,
+        )
+
 
 class TileStrategySubjects(XYZSubjects):
     pass

synergine2/exceptions.py

     """
     Like of NotImplementError. Use it to declare method to implement but only if wanted.
     """
+
+
+class ConfigurationError(SynergineException):
+    pass

synergine2_xyz/exception.py

+# coding: utf-8

synergine2_xyz/map.py

+# coding: utf-8
+import typing
+
+import tmx
+
+
+class UnconstructedTile(object):
+    pass
+
+
+class TMXMap(object):
+    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_tilesets = {}  # type: typing.Dict[str, tmx.Tileset]
+        self.tmx_tiles = {}  # type: typing.Dict[int, tmx.Tile]
+        self._load()
+
+    @property
+    def height(self) -> int:
+        return self.tmx_map.height
+
+    @property
+    def width(self) -> int:
+        return self.tmx_map.width
+
+    def _load(self) -> None:
+        self._load_layers()
+        self._load_tilesets()
+        self._load_tiles()
+
+    def _load_layers(self) -> None:
+        for layer in self.tmx_map.layers:
+            self.tmx_layers[layer.name] = layer
+
+    def _load_tilesets(self) -> None:
+        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
+
+    def _load_tiles(self) -> None:
+        for layer_name, layer in self.tmx_layers.items():
+            x, y = -1, -1
+            self.tmx_layer_tiles[layer_name] = {}
+
+            # no tiles
+            if not isinstance(layer, tmx.Layer):
+                continue
+
+            for layer_tile in layer.tiles:
+                x += 1
+
+                if x == self.width:
+                    x = 0
+                    y += 1
+
+                position_key = '{}.{}'.format(x, y)
+
+                if not layer_tile.gid:
+                    tile = None
+                elif not layer_tile.gid in self.tmx_tiles:
+                    tile = UnconstructedTile()
+                else:
+                    tile = self.tmx_tiles[layer_tile.gid]
+
+                self.tmx_layer_tiles[layer_name][position_key] = tile
+
+    def layer(self, name: str) -> tmx.Layer:
+        return self.tmx_layers[name]
+
+    def tileset(self, name: str) -> tmx.Tileset:
+        return self.tmx_tilesets[name]
+
+    def tile(self, gid: int) -> tmx.Tile:
+        return self.tmx_tiles[gid]

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
             new_path = None
 
             if not move.path:
-                # 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][1:]:
-                    x, y = map(int, position.split('.'))
-                    move.path.append((x, y))
+                move.path = self.simulation.physics.found_path(
+                    start=self.subject.position,
+                    end=move.move_to,
+                )
 
                 # Note: We are in process, move change will be lost
                 new_path = move.path

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
+
+
+class Physics(object):
+    def __init__(
+        self,
+        config: Config,
+    ) -> None:
+        self.config = config
+        self.graph = Graph()
+
+    def load(self) -> None:
+        raise NotImplementedError()
+
+    def position_to_key(self, position: typing.Tuple[int, int]) -> str:
+        return '{}.{}'.format(*position)
+
+    def found_path(
+        self,
+        start: typing.Tuple[int, int],
+        end: typing.Tuple[int, int],
+    ) -> 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)
+        regular_path = []
+        for position in found_path[0][1:]:
+            x, y = map(int, position.split('.'))
+            regular_path.append((x, y))
+
+        return regular_path
+
+
+class TMXPhysics(Physics):
+    def __init__(
+        self,
+        config: Config,
+        map_file_path: str,
+    ) -> None:
+        super().__init__(config)
+        self.map_file_path = 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):
+                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:
+                        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)

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.physics import Physics
 from synergine2_xyz.subjects import XYZSubjects
 from synergine2_xyz.subjects import XYZSubject
 
         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 > 69 or neighbor_x < 0:
-                        continue
 
-                    if neighbor_y > 69 or neighbor_y < 0:
-                        continue
+        self.physics = self.create_physics()
+        self.physics.load()
 
-                    # TODO: Voir https://pypi.python.org/pypi/Dijkstar/2.2
-                    self.graph.add_edge(position, neighbor, 1)
-        pass
+    def create_physics(self) -> Physics:
+        raise NotImplementedError()
 
     def is_possible_subject_position(self, subject: XYZSubject, position: tuple) -> bool:
         return self.is_possible_position(position)

synergine2_xyz/tmx_utils.py

+# coding: utf-8
+from tmx import TileMap
+from tmx import Layer
+
+from synergine2.exceptions import ConfigurationError
+
+
+def get_layer_by_name(map_: TileMap, layer_name: str) -> Layer:
+    for layer in map_.layers:
+        if layer.name == layer_name:
+            return layer
+
+    raise ConfigurationError('No layer named "{}" in map')