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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 4.2.7
+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.7 → tilemap_parser-4.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "4.2.7"
+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.7 → 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.7 → 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.7 → tilemap_parser-4.2.8}/src/tilemap_parser/runtime/map_object.py

@@ -27,7 +27,7 @@ from .collision_cache import CollisionCache
 from .map_loader import TilemapData
 
 
-@final
+
 class MapObject:
     """
     A game object loaded from a tilemap, carrying a surface for

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.7 → 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.7
+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.7 → 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

tilemap_parser-4.2.8/tests/test_navigation.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+import pytest
+
+from tilemap_parser.parser.collision import (
+    CollisionPolygon,
+    RectangleShape,
+    TileCollisionData,
+    TilesetCollision,
+)
+from tilemap_parser.runtime.navigation import NavGrid, Pathfinder, PathFollower
+from tilemap_parser.runtime.tile_collision import CollisionRunner
+
+TILE_SIZE = 32
+FULL_TILE = [(0.0, 0.0), (32.0, 0.0), (32.0, 32.0), (0.0, 32.0)]
+
+MAP = [
+    [1, 1, 1, 1, 1, 1],
+    [1, 0, 0, 0, 0, 1],
+    [1, 0, 1, 0, 0, 1],
+    [1, 0, 0, 0, 0, 1],
+    [1, 0, 0, 0, 0, 1],
+    [1, 1, 1, 1, 1, 1],
+]
+
+ROWS = len(MAP)
+COLS = len(MAP[0])
+
+START_TILE = (1, 2)
+GOAL_TILE = (4, 4)
+
+
+class MockSprite:
+    def __init__(self, x: float, y: float) -> None:
+        self.x = x
+        self.y = y
+        self.collision_shape = RectangleShape(width=18, height=26, offset=(-9, -13))
+
+
+def build_tile_map() -> dict:
+    tile_map = {}
+    for r in range(ROWS):
+        for c in range(COLS):
+            if MAP[r][c] == 1:
+                tile_map[(c, r)] = 0
+    return tile_map
+
+
+def build_tileset() -> TilesetCollision:
+    return TilesetCollision(
+        tileset_name="test",
+        tile_size=(TILE_SIZE, TILE_SIZE),
+        tiles={
+            0: TileCollisionData(
+                tile_id=0,
+                shapes=[CollisionPolygon(vertices=FULL_TILE)],
+            ),
+        },
+    )
+
+
+class TestNavigation:
+    def setup_method(self):
+        self.tile_map = build_tile_map()
+        self.tileset = build_tileset()
+        self.runner = CollisionRunner.from_game_type("rpg", (TILE_SIZE, TILE_SIZE))
+        self.nav_grid = NavGrid(self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE))
+        self.pathfinder = Pathfinder(self.nav_grid)
+        self.follower = PathFollower((TILE_SIZE, TILE_SIZE))
+
+    def test_path_exists_around_wall(self):
+        path = self.pathfinder.find_path(START_TILE, GOAL_TILE)
+        assert path is not None, "A* should find a path"
+        assert path[0] == START_TILE
+        assert path[-1] == GOAL_TILE
+        assert len(path) >= 3
+
+    def test_no_path_into_solid_wall(self):
+        path = self.pathfinder.find_path(START_TILE, (2, 2))
+        assert path is None
+
+    def test_no_path_outside_map(self):
+        path = self.pathfinder.find_path(START_TILE, (-1, -1))
+        assert path is None
+
+    def test_path_avoids_wall_tiles(self):
+        path = self.pathfinder.find_path(START_TILE, GOAL_TILE)
+        for tx, ty in path[1:-1]:
+            assert MAP[ty][tx] == 0, f"path goes through wall at ({tx}, {ty})"
+
+    def test_path_same_start_and_goal(self):
+        path = self.pathfinder.find_path((1, 1), (1, 1))
+        assert path == [(1, 1)]
+
+    def test_follower_reaches_goal(self):
+        path = self.pathfinder.find_path(START_TILE, GOAL_TILE)
+        assert path is not None
+
+        cx = START_TILE[0] * TILE_SIZE + TILE_SIZE * 0.5
+        cy = START_TILE[1] * TILE_SIZE + TILE_SIZE * 0.5
+        sprite = MockSprite(x=cx, y=cy)
+
+        waypoint_idx = 0
+        max_steps = 300
+        arrived = False
+
+        for _ in range(max_steps):
+            waypoint_idx, arrived, _, _ = self.follower.update_rpg(
+                sprite, path, waypoint_idx, self.runner,
+                self.tileset, self.tile_map, speed=150.0, dt=0.016,
+            )
+            if arrived:
+                break
+
+        assert arrived, (
+            f"sprite stuck at ({sprite.x:.1f}, {sprite.y:.1f}) "
+            f"waypoint {waypoint_idx}/{len(path)}"
+        )
+
+        gx = GOAL_TILE[0] * TILE_SIZE + TILE_SIZE * 0.5
+        gy = GOAL_TILE[1] * TILE_SIZE + TILE_SIZE * 0.5
+        dx = gx - sprite.x
+        dy = gy - sprite.y
+        assert (dx * dx + dy * dy) ** 0.5 < TILE_SIZE * 0.5, "sprite should be near goal tile"
+
+    def test_follower_stops_at_end_of_path(self):
+        path = self.pathfinder.find_path(START_TILE, GOAL_TILE)
+        assert path is not None
+
+        cx = START_TILE[0] * TILE_SIZE + TILE_SIZE * 0.5
+        cy = START_TILE[1] * TILE_SIZE + TILE_SIZE * 0.5
+        sprite = MockSprite(x=cx, y=cy)
+
+        _, arrived, _, _ = self.follower.update_rpg(
+            sprite, [], 0, self.runner,
+            self.tileset, self.tile_map,
+        )
+        assert arrived is True
+
+        _, arrived, _, _ = self.follower.update_rpg(
+            sprite, path, len(path), self.runner,
+            self.tileset, self.tile_map,
+        )
+        assert arrived is True
+
+    def test_nav_grid_walkable_tiles(self):
+        assert self.nav_grid.is_walkable(1, 1) is True
+        assert self.nav_grid.is_walkable(0, 0) is False
+        assert self.nav_grid.is_walkable(2, 2) is False
+        assert self.nav_grid.is_walkable(4, 4) is True
+
+    def test_nav_grid_solid(self):
+        assert self.nav_grid.is_solid(0, 0) is True
+        assert self.nav_grid.is_solid(1, 1) is False
+
+    def test_out_of_bounds_not_walkable(self):
+        assert self.nav_grid.is_walkable(-1, 0) is False
+        assert self.nav_grid.is_walkable(100, 100) is False
+
+    def test_out_of_bounds_solid(self):
+        assert self.nav_grid.is_solid(-1, 0) is True
+        assert self.nav_grid.is_solid(100, 100) is True
+
+    def test_get_neighbors_no_diagonals(self):
+        neighbors = self.nav_grid.get_neighbors(3, 3)
+        expected = {(3, 2), (3, 4), (2, 3), (4, 3)}
+        assert set(neighbors) == expected
+
+    def test_get_neighbors_with_diagonals(self):
+        neighbors = self.nav_grid.get_neighbors(3, 3, diagonals=True)
+        for nx, ny in neighbors:
+            assert self.nav_grid.is_walkable(nx, ny), f"({nx}, {ny}) not walkable"
+        assert (2, 2) not in neighbors
+        assert (3, 2) in neighbors
+        assert (4, 3) in neighbors
+
+    def test_neighbor_near_wall_excludes_wall(self):
+        neighbors = self.nav_grid.get_neighbors(2, 1)
+        for nx, ny in neighbors:
+            assert self.nav_grid.is_walkable(nx, ny), f"neighbor ({nx}, {ny}) is wall"
+
+
+class TestNavGridErosion:
+    def setup_method(self):
+        self.tile_map = build_tile_map()
+        self.tileset = build_tileset()
+        self.base = NavGrid(self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE))
+
+    def test_erosion_blocks_adjacent(self):
+        eroded = self.base.erode(1.0)
+        assert eroded.is_solid(0, 0) is True
+        assert eroded.is_solid(1, 1) is True
+        assert eroded.is_solid(1, 2) is True
+        assert eroded.is_solid(2, 1) is True
+
+    def test_erosion_does_not_affect_base(self):
+        self.base.erode(1.0)
+        assert self.base.is_walkable(1, 1) is True
+
+    def test_erosion_margin_half(self):
+        eroded = self.base.erode(0.5)
+        assert eroded.is_walkable(1, 1) is False
+        assert eroded.is_walkable(3, 3) is True
+
+    def test_copy_is_independent(self):
+        copy = self.base.copy()
+        assert copy.is_walkable(1, 1) is True
+        eroded = copy.erode(1.0)
+        assert copy.is_walkable(1, 1) is True
+        assert eroded.is_walkable(1, 1) is False
+
+    def test_for_entity_small_vs_large(self):
+        small = NavGrid.for_entity(
+            self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE), sprite_width=16
+        )
+        large = NavGrid.for_entity(
+            self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE), sprite_width=64
+        )
+        assert small.is_walkable(3, 3) is True
+        assert large.is_walkable(3, 3) is False
+
+    def test_for_entity_caching(self):
+        cache: dict = {}
+        a = NavGrid.for_entity(
+            self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE),
+            sprite_width=32, cache=cache,
+        )
+        b = NavGrid.for_entity(
+            self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE),
+            sprite_width=32, cache=cache,
+        )
+        assert a is b
+
+    def test_erosion_blocks_narrow_gap_no_alternate(self):
+        w, h = 6, 6
+        tight_map: dict[tuple[int, int], int] = {}
+        for x in range(w):
+            for y in range(h):
+                if x == 0 or x == w - 1 or y == 0 or y == h - 1:
+                    continue
+                if x == 3 and y != 3:
+                    tight_map[(x, y)] = 0
+        ts = TilesetCollision(
+            tileset_name="test",
+            tile_size=(TILE_SIZE, TILE_SIZE),
+            tiles={
+                0: TileCollisionData(
+                    tile_id=0,
+                    shapes=[CollisionPolygon(vertices=FULL_TILE)],
+                ),
+            },
+        )
+        base = NavGrid(tight_map, ts, (TILE_SIZE, TILE_SIZE), map_size=(w, h))
+        pf = Pathfinder(base)
+        path = pf.find_path((1, 1), (4, 4))
+        assert path is not None
+        assert (3, 3) in path
+
+        eroded = base.erode(1.0)
+        pf_eroded = Pathfinder(eroded)
+        path_eroded = pf_eroded.find_path((1, 1), (4, 4))
+        assert path_eroded is None
+
+
+class TestPathfinderClosedSet:
+    def setup_method(self):
+        self.tile_map = build_tile_map()
+        self.tileset = build_tileset()
+        self.nav_grid = NavGrid(self.tile_map, self.tileset, (TILE_SIZE, TILE_SIZE))
+        self.pathfinder = Pathfinder(self.nav_grid)
+
+    def test_path_found_with_closed_set(self):
+        path = self.pathfinder.find_path(START_TILE, GOAL_TILE)
+        assert path is not None
+        assert path[0] == START_TILE
+        assert path[-1] == GOAL_TILE
+
+    def test_no_path_with_closed_set(self):
+        path = self.pathfinder.find_path(START_TILE, (2, 2))
+        assert path is None
+
+
+class TestPathFollowerStalling:
+    def setup_method(self):
+        self.tile_map = build_tile_map()
+        self.tileset = build_tileset()
+        self.runner = CollisionRunner.from_game_type("rpg", (TILE_SIZE, TILE_SIZE))
+        self.follower = PathFollower((TILE_SIZE, TILE_SIZE))
+
+    def test_update_rpg_returns_stall_info(self):
+        path = [(2, 2)]
+        sprite = MockSprite(x=5 * TILE_SIZE, y=5 * TILE_SIZE)
+        idx, done, hwx, hwy = self.follower.update_rpg(
+            sprite, path, 0, self.runner,
+            self.tileset, self.tile_map, speed=150.0, dt=0.016,
+        )
+        assert isinstance(hwx, bool)
+        assert isinstance(hwy, bool)
+
+    def test_update_rpg_arrived_has_no_stall(self):
+        path = [(2, 2)]
+        sprite = MockSprite(
+            x=2 * TILE_SIZE + TILE_SIZE * 0.5,
+            y=2 * TILE_SIZE + TILE_SIZE * 0.5,
+        )
+        _, done, hwx, hwy = self.follower.update_rpg(
+            sprite, path, 0, self.runner,
+            self.tileset, self.tile_map, speed=150.0, dt=0.016,
+        )
+        assert done is True
+        assert hwx is False
+        assert hwy is False

{tilemap_parser-4.2.7 → tilemap_parser-4.2.8}/tests/test_object_surfaces.py

@@ -1,16 +1,14 @@
 import json
+import sys
 import tempfile
 from pathlib import Path
 
 import pygame
 import pytest
 
-import sys
 sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
-
 from tilemap_parser.runtime.map_loader import TilemapData
-from tilemap_parser.parser.map_parse import ParsedObject, ParsedObjectArea
-
+from tilemap_parser.parser.map_parse import ParsedObject, ParsedObjectArea, parse_map_dict
 
 MINIMAL_MAP_META = {
     "tile_size": "16;16",
@@ -188,5 +186,94 @@ class TestObjectSurfaces:
             tileset_type="object",
             variant=0,
         )
-        surf = td.get_object_surface(obj)
-        assert surf is None
+
+
+class TestParsedLayerTtypes:
+    def test_object_layer_ttypes_after_parse(self):
+        payload = {
+            "meta": {"tile_size": "16;16", "map_size": "10;10", "version": "1.1"},
+            "resources": {"tilesets": [{"path": "a.png", "type": "tile"}, {"path": "b.png", "type": "tile"}]},
+            "project_state": {"rules": [], "groups": []},
+            "data": {
+                "layers": [
+                    {
+                        "name": "Objs",
+                        "type": "object",
+                        "visible": True,
+                        "locked": False,
+                        "opacity": 1.0,
+                        "z_index": 0,
+                        "properties": {},
+                        "tiles": {},
+                        "objects": {
+                            "1": {
+                                "area": {"x": 0, "y": 0, "w": 16, "h": 16},
+                                "ttype": 0,
+                                "tileset_type": "object",
+                                "variant": 0,
+                                "properties": {},
+                            },
+                            "2": {
+                                "area": {"x": 0, "y": 0, "w": 16, "h": 16},
+                                "ttype": 1,
+                                "tileset_type": "object",
+                                "variant": 0,
+                                "properties": {},
+                            },
+                            "3": {
+                                "area": {"x": 0, "y": 0, "w": 16, "h": 16},
+                                "ttype": 0,
+                                "tileset_type": "object",
+                                "variant": 1,
+                                "properties": {},
+                            },
+                        },
+                    },
+                    {
+                        "name": "Tiles",
+                        "type": "tile",
+                        "visible": True,
+                        "locked": False,
+                        "opacity": 1.0,
+                        "z_index": 1,
+                        "tiles": {},
+                    },
+                ],
+            },
+        }
+        parsed = parse_map_dict(payload)
+        obj_layer = parsed.layers[0]
+        tile_layer = parsed.layers[1]
+
+        assert obj_layer.ttypes == {0, 1}
+        assert tile_layer.ttypes == set()
+
+    def test_object_layer_empty_ttypes(self):
+        payload = {
+            "meta": {"tile_size": "16;16", "map_size": "10;10", "version": "1.1"},
+            "resources": {"tilesets": []},
+            "project_state": {"rules": [], "groups": []},
+            "data": {
+                "layers": [
+                    {
+                        "name": "Empty",
+                        "type": "object",
+                        "visible": True,
+                        "locked": False,
+                        "opacity": 1.0,
+                        "z_index": 0,
+                        "properties": {},
+                        "tiles": {},
+                        "objects": {},
+                    }
+                ],
+            },
+        }
+        parsed = parse_map_dict(payload)
+        assert parsed.layers[0].ttypes == set()
+
+    def test_ttypes_preserved_through_tilemap_data(self, map_data):
+        td, *_ = map_data
+        layer = td.get_layer("Object Layer 1")
+        assert layer is not None
+        assert layer.ttypes == {0}