tilemap-parser 4.2.6__tar.gz → 4.2.8__tar.gz

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 4.2.6
+Version: 4.2.8
 Summary: Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
 Author: tilemap parser contributors
 License:                     GNU GENERAL PUBLIC LICENSE

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "4.2.6"
+version = "4.2.8"
 description = "Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime."
 readme = "README.md"
 requires-python = ">=3.10"

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/src/tilemap_parser/parser/map_parse.py

@@ -165,6 +165,7 @@ class ParsedLayer:
     tiles: Dict[Point, ParsedTile] = field(default_factory=dict)
     objects: Dict[int, ParsedObject] = field(default_factory=dict)
     next_object_id: Optional[int] = None
+    ttypes: set[int] = field(default_factory=set)
 
 
 @dataclass
@@ -301,6 +302,8 @@ def _parse_layer(layer_obj: JsonDict, layer_id: int, ctx: str) -> ParsedLayer:
             _require_dict(layer_obj.get("objects", {}), f"{ctx}.objects"),
             f"{ctx}.objects",
         )
+        for obj in layer.objects.values():
+            layer.ttypes.add(obj.ttype)
         if "next_object_id" in layer_obj and layer_obj["next_object_id"] is not None:
             layer.next_object_id = _coerce_int(
                 layer_obj["next_object_id"], f"{ctx}.next_object_id"

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/src/tilemap_parser/runtime/__init__.py

@@ -28,6 +28,7 @@ from .object_collision import (
 )
 from .renderer import LayerRenderStats, TileLayerRenderer
 from .area_node import AreaNode
+from . import navigation
 from .particles import (
     Particle,
     ParticleEmitter,

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/src/tilemap_parser/runtime/map_object.py

@@ -16,7 +16,7 @@ Usage::
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Union, final
 
 import pygame
 from pygame import Surface
@@ -27,6 +27,7 @@ from .collision_cache import CollisionCache
 from .map_loader import TilemapData
 
 
+
 class MapObject:
     """
     A game object loaded from a tilemap, carrying a surface for
@@ -48,28 +49,34 @@ class MapObject:
     shape pairs when either object has multiple shapes.
     """
 
-    __slots__ = (
-        "x",
-        "y",
-        "surface",
-        "collision_shape",
-        "collision_shapes",
-        "collision_layer",
-        "collision_mask",
-        "y_sort_origin",
+    __slots__ = tuple(
+        sorted(
+            (
+                "x",
+                "y",
+                "surface",
+                "collision_shape",
+                "collision_shapes",
+                "collision_layer",
+                "collision_mask",
+                "y_sort_origin",
+                "ttype",
+            )
+        )
     )
 
     def __init__(
         self,
         x: float,
         y: float,
-        surface: Optional[Surface] = None,
-        collision_shape: Optional[CollisionPolygon] = None,
+        surface: Surface | None = None,
+        collision_shape: CollisionPolygon | None = None,
         *,
-        collision_shapes: Optional[List[CollisionPolygon]] = None,
+        collision_shapes: list[CollisionPolygon] | None = None,
         collision_layer: int = 1,
         collision_mask: int = 0xFFFFFFFF,
-        y_sort_origin: Optional[int] = None,
+        y_sort_origin: int | None = None,
+        ttype: int = -1,
     ) -> None:
         self.x = x
         self.y = y
@@ -86,13 +93,14 @@ class MapObject:
         self.collision_layer = collision_layer
         self.collision_mask = collision_mask
         self.y_sort_origin = y_sort_origin
+        self.ttype = ttype
 
     @property
     def has_collision(self) -> bool:
         return len(self.collision_shapes) > 0
 
 
-def _resolve_object_collision_filename(tileset_path: Union[str, Path]) -> str:
+def _resolve_object_collision_filename(tileset_path: str | Path) -> str:
     """Extract the object collision filename for a given tileset path.
 
     Example: ``"building7.png"`` → ``"building7.object_collision.json"``
@@ -102,11 +110,11 @@ def _resolve_object_collision_filename(tileset_path: Union[str, Path]) -> str:
 
 def load_map_objects(
     tilemap_data: TilemapData,
-    collision_dir: Union[str, Path],
+    collision_dir: str | Path,
     *,
-    cache: Optional[CollisionCache] = None,
+    cache: CollisionCache | None = None,
     require_collision: bool = True,
-) -> List[MapObject]:
+) -> list[MapObject]:
     """Load objects from a tilemap.
 
     Iterates every object layer in *tilemap_data*, resolves the
@@ -149,10 +157,10 @@ def load_map_objects(
         List of :class:`MapObject` instances.
     """
     collision_dir = Path(collision_dir)
-    objects: List[MapObject] = []
+    objects: list[MapObject] = []
     object_layers = tilemap_data.get_layers(layer_type="object")
 
-    loaded_collision: Dict[int, Optional[ObjectCollisionData]] = {}
+    loaded_collision: dict[int, ObjectCollisionData | None] = {}
 
     for layer in object_layers:
         for obj_id, obj in layer.objects.items():
@@ -171,9 +179,7 @@ def load_map_objects(
 
             ttype = obj.ttype
             if ttype not in loaded_collision:
-                collision_data = _load_collision_for_tileset(
-                    tilemap_data, ttype, collision_dir, cache
-                )
+                collision_data = _load_collision_for_tileset(tilemap_data, ttype, collision_dir, cache)
                 loaded_collision[ttype] = collision_data
 
             collision_data = loaded_collision[ttype]
@@ -186,6 +192,7 @@ def load_map_objects(
                     surface=surf,
                     collision_shape=None,
                     collision_shapes=[],
+                    ttype=obj.ttype,
                 )
                 objects.append(game_obj)
                 continue
@@ -209,6 +216,7 @@ def load_map_objects(
                     surface=surf,
                     collision_shape=None,
                     collision_shapes=[],
+                    ttype=obj.ttype,
                 )
                 objects.append(game_obj)
                 continue
@@ -221,6 +229,7 @@ def load_map_objects(
                 collision_shapes=world_shapes,
                 collision_layer=region_layer,
                 collision_mask=region_mask,
+                ttype=obj.ttype,
             )
             objects.append(game_obj)
 

tilemap_parser-4.2.8/src/tilemap_parser/runtime/navigation/__init__.py

@@ -0,0 +1,3 @@
+from .nav_grid import NavGrid
+from .pathfinder import Pathfinder
+from .path_follower import PathFollower

tilemap_parser-4.2.8/src/tilemap_parser/runtime/navigation/nav_grid.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import math
+from typing import Dict, List, Optional, Tuple
+
+from ...parser.collision import TilesetCollision
+
+
+class NavGrid:
+    """Walkability grid derived from tile collision data.
+
+    The base grid is a pure representation of the world — no entity size
+    or clearance baked in.  Entity-specific clearance is layered on via
+    ``erode(margin)`` which returns a derived grid with walls inflated.
+    """
+
+    __slots__ = (
+        "tile_map",
+        "tileset_collision",
+        "tile_size",
+        "_eff_tw",
+        "_eff_th",
+        "_width",
+        "_height",
+        "_walkable",
+    )
+
+    def __init__(
+        self,
+        tile_map: Dict[Tuple[int, int], int],
+        tileset_collision: TilesetCollision,
+        tile_size: Tuple[int, int],
+        render_scale: float = 1.0,
+        map_size: Optional[Tuple[int, int]] = None,
+    ) -> None:
+        self.tile_map = tile_map
+        self.tileset_collision = tileset_collision
+        self.tile_size = tile_size
+        self._eff_tw = tile_size[0] * render_scale
+        self._eff_th = tile_size[1] * render_scale
+
+        if map_size is not None:
+            self._width, self._height = map_size
+        else:
+            self._width = 0
+            self._height = 0
+            for tx, ty in tile_map:
+                if tx >= self._width:
+                    self._width = tx + 1
+                if ty >= self._height:
+                    self._height = ty + 1
+
+        self._walkable = [[self._is_tile_walkable(x, y) for x in range(self._width)] for y in range(self._height)]
+
+    def _is_tile_walkable(self, tx: int, ty: int) -> bool:
+        tile_id = self.tile_map.get((tx, ty))
+        if tile_id is None:
+            return True
+        tile_data = self.tileset_collision.tiles.get(tile_id)
+        if tile_data is None:
+            return True
+        for poly in tile_data.shapes:
+            if poly.is_valid() and not poly.one_way:
+                return False
+        return True
+
+    def _in_bounds(self, tx: int, ty: int) -> bool:
+        return 0 <= tx < self._width and 0 <= ty < self._height
+
+    def is_solid(self, tx: int, ty: int) -> bool:
+        if not self._in_bounds(tx, ty):
+            return True
+        return not self._walkable[ty][tx]
+
+    def is_walkable(self, tx: int, ty: int) -> bool:
+        if not self._in_bounds(tx, ty):
+            return False
+        return self._walkable[ty][tx]
+
+    def is_one_way(self, tx: int, ty: int) -> bool:
+        tile_id = self.tile_map.get((tx, ty))
+        if tile_id is None:
+            return False
+        tile_data = self.tileset_collision.tiles.get(tile_id)
+        if tile_data is None:
+            return False
+        has_one_way = False
+        for poly in tile_data.shapes:
+            if not poly.is_valid():
+                continue
+            if poly.one_way:
+                has_one_way = True
+            else:
+                return False
+        return has_one_way
+
+    def copy(self) -> NavGrid:
+        new = NavGrid.__new__(NavGrid)
+        new.tile_map = self.tile_map
+        new.tileset_collision = self.tileset_collision
+        new.tile_size = self.tile_size
+        new._eff_tw = self._eff_tw
+        new._eff_th = self._eff_th
+        new._width = self._width
+        new._height = self._height
+        new._walkable = [row[:] for row in self._walkable]
+        return new
+
+    def erode(self, margin: float) -> NavGrid:
+        new = self.copy()
+        new._erode_in_place(margin)
+        return new
+
+    def _erode_in_place(self, margin: float) -> None:
+        original = [row[:] for row in self._walkable]
+        r = int(math.ceil(margin + 0.5))
+
+        for sy in range(self._height):
+            for sx in range(self._width):
+                if not original[sy][sx]:
+                    continue
+                min_tx = max(0, sx - r)
+                max_tx = min(self._width - 1, sx + r)
+                min_ty = max(0, sy - r)
+                max_ty = min(self._height - 1, sy + r)
+                for ty in range(min_ty, max_ty + 1):
+                    for tx in range(min_tx, max_tx + 1):
+                        if original[ty][tx]:
+                            continue
+                        dx = abs(tx - sx)
+                        dy = abs(ty - sy)
+                        dist_x = max(0.0, dx - 0.5)
+                        dist_y = max(0.0, dy - 0.5)
+                        if dist_x == 0 and dist_y == 0:
+                            dist = 0.0
+                        elif dist_x == 0:
+                            dist = dist_y
+                        elif dist_y == 0:
+                            dist = dist_x
+                        else:
+                            dist = math.hypot(dist_x, dist_y)
+                        if dist <= margin:
+                            self._walkable[sy][sx] = False
+                            break
+                    if not self._walkable[sy][sx]:
+                        break
+
+    @classmethod
+    def for_entity(
+        cls,
+        tile_map: Dict[Tuple[int, int], int],
+        tileset_collision: TilesetCollision,
+        tile_size: Tuple[int, int],
+        sprite_width: float,
+        sprite_height: Optional[float] = None,
+        render_scale: float = 1.0,
+        map_size: Optional[Tuple[int, int]] = None,
+        cache: Optional[Dict[float, NavGrid]] = None,
+    ) -> NavGrid:
+        tw = tile_size[0] * render_scale
+        size = max(sprite_width, sprite_height if sprite_height is not None else sprite_width)
+        margin = (size / 2.0) / tw
+        if cache is not None and margin in cache:
+            return cache[margin]
+        nav = cls(tile_map, tileset_collision, tile_size, render_scale, map_size).erode(margin)
+        if cache is not None:
+            cache[margin] = nav
+        return nav
+
+    def get_neighbors(self, tx: int, ty: int, *, diagonals: bool = False) -> List[Tuple[int, int]]:
+        neighbors: List[Tuple[int, int]] = []
+        for dx, dy in [(0, -1), (0, 1), (-1, 0), (1, 0)]:
+            nx, ny = tx + dx, ty + dy
+            if self.is_walkable(nx, ny):
+                neighbors.append((nx, ny))
+        if diagonals:
+            for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]:
+                nx, ny = tx + dx, ty + dy
+                if not self.is_walkable(nx, ny):
+                    continue
+                if not self.is_walkable(tx + dx, ty) or not self.is_walkable(tx, ty + dy):
+                    continue
+                neighbors.append((nx, ny))
+        return neighbors

tilemap_parser-4.2.8/src/tilemap_parser/runtime/navigation/path_follower.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import math
+from typing import List, Optional, Tuple
+
+from ...parser.collision import TilesetCollision
+from ..protocols import ICollidable
+from ..tile_collision import CollisionRunner
+
+
+class PathFollower:
+    __slots__ = ("_eff_tw", "_eff_th", "arrival_distance")
+
+    def __init__(
+        self,
+        effective_tile_size: Tuple[float, float],
+        *,
+        arrival_distance: Optional[float] = None,
+    ) -> None:
+        self._eff_tw, self._eff_th = effective_tile_size
+        self.arrival_distance = (
+            arrival_distance
+            if arrival_distance is not None
+            else math.hypot(self._eff_tw, self._eff_th) * 0.2
+        )
+
+    def update_rpg(
+        self,
+        sprite: ICollidable,
+        path: List[Tuple[int, int]],
+        waypoint_index: int,
+        collision_runner: CollisionRunner,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        speed: float = 200.0,
+        dt: float = 0.016,
+    ) -> Tuple[int, bool, bool, bool]:
+        if not path or waypoint_index >= len(path):
+            return waypoint_index, True, False, False
+
+        while waypoint_index < len(path):
+            wx, wy = path[waypoint_index]
+            tx = wx * self._eff_tw + self._eff_tw * 0.5
+            ty = wy * self._eff_th + self._eff_th * 0.5
+            if math.hypot(tx - sprite.x, ty - sprite.y) < self.arrival_distance:
+                waypoint_index += 1
+            else:
+                break
+
+        if waypoint_index >= len(path):
+            return waypoint_index, True, False, False
+
+        wx, wy = path[waypoint_index]
+        tx = wx * self._eff_tw + self._eff_tw * 0.5
+        ty = wy * self._eff_th + self._eff_th * 0.5
+
+        dx = tx - sprite.x
+        dy = ty - sprite.y
+        dist = math.hypot(dx, dy)
+
+        if dist < 0.01:
+            delta_x = 0.0
+            delta_y = 0.0
+        else:
+            step = min(speed * dt, dist)
+            delta_x = (dx / dist) * step
+            delta_y = (dy / dist) * step
+
+        result = collision_runner.move_rpg(
+            sprite, tileset_collision, tile_map, delta_x, delta_y
+        )
+
+        if math.hypot(tx - sprite.x, ty - sprite.y) < self.arrival_distance:
+            waypoint_index += 1
+
+        return waypoint_index, waypoint_index >= len(path), result.hit_wall_x, result.hit_wall_y

tilemap_parser-4.2.8/src/tilemap_parser/runtime/navigation/pathfinder.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import heapq
+from typing import Dict, List, Optional, Set, Tuple
+
+from .nav_grid import NavGrid
+
+
+class Pathfinder:
+    __slots__ = ("nav_grid",)
+
+    def __init__(self, nav_grid: NavGrid) -> None:
+        self.nav_grid = nav_grid
+
+    def find_path(
+        self,
+        start: Tuple[int, int],
+        end: Tuple[int, int],
+        max_steps: int = 2000,
+    ) -> Optional[List[Tuple[int, int]]]:
+        sx, sy = start
+        ex, ey = end
+
+        if not self.nav_grid.is_walkable(ex, ey):
+            return None
+
+        open_set: List[Tuple[float, int, int]] = [(0.0, sx, sy)]
+        came_from: Dict[Tuple[int, int], Tuple[int, int]] = {}
+        g_score: Dict[Tuple[int, int], float] = {start: 0.0}
+        f_score: Dict[Tuple[int, int], float] = {
+            start: _manhattan(sx, sy, ex, ey)
+        }
+
+        closed: Set[Tuple[int, int]] = set()
+        steps = 0
+        while open_set and steps < max_steps:
+            _, cx, cy = heapq.heappop(open_set)
+            current = (cx, cy)
+
+            if current in closed:
+                continue
+            closed.add(current)
+            steps += 1
+
+            if current == end:
+                return _reconstruct_path(came_from, current)
+
+            for neighbor in self.nav_grid.get_neighbors(cx, cy):
+                tentative = g_score[current] + 1.0
+                if tentative < g_score.get(neighbor, float("inf")):
+                    came_from[neighbor] = current
+                    g_score[neighbor] = tentative
+                    f = tentative + _manhattan(
+                        neighbor[0], neighbor[1], ex, ey
+                    )
+                    f_score[neighbor] = f
+                    heapq.heappush(open_set, (f, neighbor[0], neighbor[1]))
+
+        return None
+
+
+def _manhattan(ax: int, ay: int, bx: int, by: int) -> float:
+    return float(abs(ax - bx) + abs(ay - by))
+
+
+def _reconstruct_path(
+    came_from: Dict[Tuple[int, int], Tuple[int, int]],
+    current: Tuple[int, int],
+) -> List[Tuple[int, int]]:
+    path = [current]
+    while current in came_from:
+        current = came_from[current]
+        path.append(current)
+    path.reverse()
+    return path

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 4.2.6
+Version: 4.2.8
 Summary: Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
 Author: tilemap parser contributors
 License:                     GNU GENERAL PUBLIC LICENSE

{tilemap_parser-4.2.6 → tilemap_parser-4.2.8}/src/tilemap_parser.egg-info/SOURCES.txt

@@ -27,6 +27,10 @@ src/tilemap_parser/runtime/particles.py
 src/tilemap_parser/runtime/protocols.py
 src/tilemap_parser/runtime/renderer.py
 src/tilemap_parser/runtime/tile_collision.py
+src/tilemap_parser/runtime/navigation/__init__.py
+src/tilemap_parser/runtime/navigation/nav_grid.py
+src/tilemap_parser/runtime/navigation/path_follower.py
+src/tilemap_parser/runtime/navigation/pathfinder.py
 src/tilemap_parser/utils/__init__.py
 src/tilemap_parser/utils/geometry.py
 tests/test_camera.py
@@ -39,6 +43,7 @@ tests/test_integration_map_loader.py
 tests/test_map_loader.py
 tests/test_map_object.py
 tests/test_move_grounded.py
+tests/test_navigation.py
 tests/test_object_collision.py
 tests/test_object_surfaces.py
 tests/test_particle_emitter.py