tilemap-parser 1.1.1__tar.gz → 2.0.1__tar.gz

{tilemap_parser-1.1.1/src/tilemap_parser.egg-info → tilemap_parser-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 1.1.1
+Version: 2.0.1
 Summary: Standalone parser/loader for tilemap-editor JSON maps and sprite animation JSON.
 Author: tilemap parser contributors
 Classifier: Programming Language :: Python :: 3

{tilemap_parser-1.1.1 → tilemap_parser-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "1.1.1"
+version = "2.0.1"
 description = "Standalone parser/loader for tilemap-editor JSON maps and sprite animation JSON."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -26,4 +26,5 @@ include-package-data = false
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["tilemap_parser*"]
+exclude = ["webdocs*", "tests*"]
 namespaces = false

{tilemap_parser-1.1.1 → tilemap_parser-2.0.1}/src/tilemap_parser/collision.py

@@ -217,22 +217,24 @@ def parse_character_collision(data: JsonDict) -> CharacterCollision:
 
 
 def load_tileset_collision(
-    tileset_path: Union[str, Path],
+    collision_path: Union[str, Path],
 ) -> Optional[TilesetCollision]:
     """
-    Load tileset collision data from file.
+    Load tileset collision data from a collision JSON file.
+
+    The editor stores tileset collision files at:
+        <data_root>/collision/<tileset_stem>.collision.json
 
     Args:
-        tileset_path: Path to tileset image file
+        collision_path: Direct path to the .collision.json file.
 
     Returns:
-        TilesetCollision object or None if collision file doesn't exist
+        TilesetCollision object, or None if the file does not exist.
 
     Raises:
-        CollisionParseError: If collision file exists but is invalid
+        CollisionParseError: If the file exists but cannot be parsed.
     """
-    tileset_path = Path(tileset_path)
-    collision_path = tileset_path.with_suffix(".collision.json")
+    collision_path = Path(collision_path)
 
     if not collision_path.exists():
         return None
@@ -241,27 +243,29 @@ def load_tileset_collision(
         with open(collision_path, "r", encoding="utf-8") as f:
             data = json.load(f)
         return parse_tileset_collision(data)
-    except (OSError, json.JSONDecodeError) as e:
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as e:
         raise CollisionParseError(f"Cannot load {collision_path}: {e}") from e
 
 
 def load_character_collision(
-    sprite_path: Union[str, Path],
+    collision_path: Union[str, Path],
 ) -> Optional[CharacterCollision]:
     """
-    Load character collision data from file.
+    Load character collision data from a collision JSON file.
+
+    The editor stores character collision files at:
+        <data_root>/character_collision/<character_name>.collision.json
 
     Args:
-        sprite_path: Path to character sprite image file
+        collision_path: Direct path to the .collision.json file.
 
     Returns:
-        CharacterCollision object or None if collision file doesn't exist
+        CharacterCollision object, or None if the file does not exist.
 
     Raises:
-        CollisionParseError: If collision file exists but is invalid
+        CollisionParseError: If the file exists but cannot be parsed.
     """
-    sprite_path = Path(sprite_path)
-    collision_path = sprite_path.with_suffix(".collision.json")
+    collision_path = Path(collision_path)
 
     if not collision_path.exists():
         return None
@@ -270,7 +274,7 @@ def load_character_collision(
         with open(collision_path, "r", encoding="utf-8") as f:
             data = json.load(f)
         return parse_character_collision(data)
-    except (OSError, json.JSONDecodeError) as e:
+    except (OSError, UnicodeDecodeError, json.JSONDecodeError) as e:
         raise CollisionParseError(f"Cannot load {collision_path}: {e}") from e
 
 
@@ -280,6 +284,12 @@ class CollisionCache:
 
     Caches parsed collision data to avoid repeated file I/O and parsing.
     Useful for runtime performance in game engines.
+
+    All methods accept the direct path to the .collision.json file.
+
+    Typical paths produced by the editor:
+        Tileset:   <data_root>/collision/<stem>.collision.json
+        Character: <data_root>/character_collision/<name>.collision.json
     """
 
     def __init__(self):
@@ -287,24 +297,32 @@ class CollisionCache:
         self._character_cache: Dict[str, Optional[CharacterCollision]] = {}
 
     def get_tileset_collision(
-        self, tileset_path: Union[str, Path]
+        self, collision_path: Union[str, Path]
     ) -> Optional[TilesetCollision]:
-        """Get tileset collision data (cached)"""
-        key = str(Path(tileset_path).resolve())
+        """Get tileset collision data (cached).
+
+        Args:
+            collision_path: Direct path to the .collision.json file.
+        """
+        key = str(Path(collision_path).resolve())
 
         if key not in self._tileset_cache:
-            self._tileset_cache[key] = load_tileset_collision(tileset_path)
+            self._tileset_cache[key] = load_tileset_collision(collision_path)
 
         return self._tileset_cache[key]
 
     def get_character_collision(
-        self, sprite_path: Union[str, Path]
+        self, collision_path: Union[str, Path]
     ) -> Optional[CharacterCollision]:
-        """Get character collision data (cached)"""
-        key = str(Path(sprite_path).resolve())
+        """Get character collision data (cached).
+
+        Args:
+            collision_path: Direct path to the .collision.json file.
+        """
+        key = str(Path(collision_path).resolve())
 
         if key not in self._character_cache:
-            self._character_cache[key] = load_character_collision(sprite_path)
+            self._character_cache[key] = load_character_collision(collision_path)
 
         return self._character_cache[key]
 
@@ -313,30 +331,46 @@ class CollisionCache:
         self._tileset_cache.clear()
         self._character_cache.clear()
 
-    def preload_tileset(self, tileset_path: Union[str, Path]):
-        """Preload tileset collision data into cache"""
-        self.get_tileset_collision(tileset_path)
+    def preload_tileset(self, collision_path: Union[str, Path]):
+        """Preload tileset collision data into cache.
+
+        Args:
+            collision_path: Direct path to the .collision.json file.
+        """
+        self.get_tileset_collision(collision_path)
 
-    def preload_character(self, sprite_path: Union[str, Path]):
-        """Preload character collision data into cache"""
-        self.get_character_collision(sprite_path)
+    def preload_character(self, collision_path: Union[str, Path]):
+        """Preload character collision data into cache.
+
+        Args:
+            collision_path: Direct path to the .collision.json file.
+        """
+        self.get_character_collision(collision_path)
 
 
 _global_cache = CollisionCache()
 
 
 def get_cached_tileset_collision(
-    tileset_path: Union[str, Path],
+    collision_path: Union[str, Path],
 ) -> Optional[TilesetCollision]:
-    """Get tileset collision using global cache"""
-    return _global_cache.get_tileset_collision(tileset_path)
+    """Get tileset collision using global cache.
+
+    Args:
+        collision_path: Direct path to the .collision.json file.
+    """
+    return _global_cache.get_tileset_collision(collision_path)
 
 
 def get_cached_character_collision(
-    sprite_path: Union[str, Path],
+    collision_path: Union[str, Path],
 ) -> Optional[CharacterCollision]:
-    """Get character collision using global cache"""
-    return _global_cache.get_character_collision(sprite_path)
+    """Get character collision using global cache.
+
+    Args:
+        collision_path: Direct path to the .collision.json file.
+    """
+    return _global_cache.get_character_collision(collision_path)
 
 
 def clear_collision_cache():

{tilemap_parser-1.1.1 → tilemap_parser-2.0.1}/src/tilemap_parser/collision_runner.py

@@ -67,8 +67,8 @@ def point_in_polygon(point: Point, vertices: List[Point]) -> bool:
                 if x <= max(p1x, p2x):
                     if p1y != p2y:
                         xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
-                    if p1x == p2x or x <= xinters:
-                        inside = not inside
+                        if p1x == p2x or x <= xinters:
+                            inside = not inside
         p1x, p1y = p2x, p2y
 
     return inside

{tilemap_parser-1.1.1 → tilemap_parser-2.0.1/src/tilemap_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 1.1.1
+Version: 2.0.1
 Summary: Standalone parser/loader for tilemap-editor JSON maps and sprite animation JSON.
 Author: tilemap parser contributors
 Classifier: Programming Language :: Python :: 3

{tilemap_parser-1.1.1 → tilemap_parser-2.0.1}/src/tilemap_parser.egg-info/SOURCES.txt

@@ -12,4 +12,6 @@ src/tilemap_parser.egg-info/PKG-INFO
 src/tilemap_parser.egg-info/SOURCES.txt
 src/tilemap_parser.egg-info/dependency_links.txt
 src/tilemap_parser.egg-info/requires.txt
-src/tilemap_parser.egg-info/top_level.txt
+src/tilemap_parser.egg-info/top_level.txt
+tests/test_collision.py
+tests/test_collision_runner.py

tilemap_parser-2.0.1/tests/test_collision.py

@@ -0,0 +1,387 @@
+"""
+Tests for tilemap_parser.collision — covering the refactored API where
+load_tileset_collision() and load_character_collision() accept a direct
+path to the .collision.json file rather than deriving it from an image path.
+"""
+
+import json
+import pytest
+from pathlib import Path
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from tilemap_parser.collision import (
+    # parsers
+    parse_tileset_collision,
+    parse_character_collision,
+    # loaders
+    load_tileset_collision,
+    load_character_collision,
+    # cache
+    CollisionCache,
+    get_cached_tileset_collision,
+    get_cached_character_collision,
+    clear_collision_cache,
+    # data classes
+    TilesetCollision,
+    CharacterCollision,
+    RectangleShape,
+    CircleShape,
+    CapsuleShape,
+    CollisionPolygon,
+    CollisionParseError,
+)
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+FIXTURES = Path(__file__).parent.parent / "examples" / "fixtures"
+TILESET_COLLISION = FIXTURES / "collision" / "Terrain (32x32).collision.json"
+CHARACTER_COLLISION = FIXTURES / "character_collision" / "hero.collision.json"
+
+TILESET_DATA = {
+    "tileset_name": "test_tileset",
+    "tile_size": [32, 32],
+    "tiles": {
+        "0": {
+            "tile_id": 0,
+            "shapes": [
+                {
+                    "vertices": [[0.0, 0.0], [32.0, 0.0], [32.0, 32.0], [0.0, 32.0]],
+                    "one_way": False,
+                }
+            ],
+        },
+        "1": {
+            "tile_id": 1,
+            "shapes": [
+                {
+                    "vertices": [[0.0, 16.0], [32.0, 16.0], [32.0, 32.0], [0.0, 32.0]],
+                    "one_way": True,
+                }
+            ],
+        },
+    },
+}
+
+CHARACTER_RECT_DATA = {
+    "name": "player",
+    "shape": {"type": "rectangle", "width": 24.0, "height": 32.0, "offset": [4.0, 0.0]},
+    "properties": {"speed": 150},
+}
+
+CHARACTER_CIRCLE_DATA = {
+    "name": "ball",
+    "shape": {"type": "circle", "radius": 16.0, "offset": [0.0, 0.0]},
+    "properties": {},
+}
+
+CHARACTER_CAPSULE_DATA = {
+    "name": "snake",
+    "shape": {"type": "capsule", "radius": 8.0, "height": 48.0, "offset": [0.0, 0.0]},
+    "properties": {},
+}
+
+
+# ===========================================================================
+# parse_tileset_collision
+# ===========================================================================
+
+class TestParseTilesetCollision:
+    def test_basic_parse(self):
+        result = parse_tileset_collision(TILESET_DATA)
+        assert isinstance(result, TilesetCollision)
+        assert result.tileset_name == "test_tileset"
+        assert result.tile_size == (32, 32)
+        assert len(result.tiles) == 2
+
+    def test_tile_has_collision(self):
+        result = parse_tileset_collision(TILESET_DATA)
+        assert result.has_collision(0)
+        assert result.has_collision(1)
+        assert not result.has_collision(99)
+
+    def test_one_way_flag(self):
+        result = parse_tileset_collision(TILESET_DATA)
+        shapes = result.get_world_shapes(1, 0, 0)
+        assert shapes[0].one_way is True
+
+    def test_world_shapes_transform(self):
+        result = parse_tileset_collision(TILESET_DATA)
+        shapes = result.get_world_shapes(0, 100.0, 200.0)
+        assert len(shapes) == 1
+        # All vertices should be offset by (100, 200)
+        for vx, vy in shapes[0].vertices:
+            assert vx >= 100.0
+            assert vy >= 200.0
+
+    def test_world_shapes_missing_tile(self):
+        result = parse_tileset_collision(TILESET_DATA)
+        assert result.get_world_shapes(99, 0, 0) == []
+
+    def test_missing_tileset_name_raises(self):
+        bad = {k: v for k, v in TILESET_DATA.items() if k != "tileset_name"}
+        with pytest.raises(CollisionParseError):
+            parse_tileset_collision(bad)
+
+    def test_missing_tile_size_raises(self):
+        bad = {k: v for k, v in TILESET_DATA.items() if k != "tile_size"}
+        with pytest.raises(CollisionParseError):
+            parse_tileset_collision(bad)
+
+    def test_empty_tiles(self):
+        data = {"tileset_name": "empty", "tile_size": [16, 16], "tiles": {}}
+        result = parse_tileset_collision(data)
+        assert len(result.tiles) == 0
+
+
+# ===========================================================================
+# parse_character_collision
+# ===========================================================================
+
+class TestParseCharacterCollision:
+    def test_rectangle(self):
+        result = parse_character_collision(CHARACTER_RECT_DATA)
+        assert isinstance(result, CharacterCollision)
+        assert result.name == "player"
+        assert isinstance(result.shape, RectangleShape)
+        assert result.shape.width == 24.0
+        assert result.shape.height == 32.0
+        assert result.shape.offset == (4.0, 0.0)
+        assert result.properties["speed"] == 150
+
+    def test_circle(self):
+        result = parse_character_collision(CHARACTER_CIRCLE_DATA)
+        assert isinstance(result.shape, CircleShape)
+        assert result.shape.radius == 16.0
+
+    def test_capsule(self):
+        result = parse_character_collision(CHARACTER_CAPSULE_DATA)
+        assert isinstance(result.shape, CapsuleShape)
+        assert result.shape.radius == 8.0
+        assert result.shape.height == 48.0
+
+    def test_unknown_shape_raises(self):
+        bad = {
+            "name": "x",
+            "shape": {"type": "hexagon", "radius": 10.0},
+            "properties": {},
+        }
+        with pytest.raises(CollisionParseError):
+            parse_character_collision(bad)
+
+    def test_missing_name_raises(self):
+        bad = {k: v for k, v in CHARACTER_RECT_DATA.items() if k != "name"}
+        with pytest.raises(CollisionParseError):
+            parse_character_collision(bad)
+
+    def test_properties_default_empty(self):
+        data = {
+            "name": "ghost",
+            "shape": {"type": "circle", "radius": 10.0},
+        }
+        result = parse_character_collision(data)
+        assert result.properties == {}
+
+
+# ===========================================================================
+# Shape helpers
+# ===========================================================================
+
+class TestShapeHelpers:
+    def test_rectangle_get_bounds(self):
+        shape = RectangleShape(width=24.0, height=32.0, offset=(4.0, 0.0))
+        left, top, right, bottom = shape.get_bounds(100.0, 200.0)
+        assert left == 104.0
+        assert top == 200.0
+        assert right == 128.0
+        assert bottom == 232.0
+
+    def test_circle_get_center(self):
+        shape = CircleShape(radius=16.0, offset=(2.0, 3.0))
+        cx, cy = shape.get_center(100.0, 200.0)
+        assert cx == 102.0
+        assert cy == 203.0
+
+    def test_capsule_top_bottom(self):
+        shape = CapsuleShape(radius=8.0, height=48.0, offset=(0.0, 0.0))
+        top = shape.get_top_center(100.0, 200.0)
+        bottom = shape.get_bottom_center(100.0, 200.0)
+        assert top == (100.0, 200.0)
+        assert bottom == (100.0, 248.0)
+
+    def test_collision_polygon_is_valid(self):
+        valid = CollisionPolygon(vertices=[(0, 0), (1, 0), (1, 1)])
+        invalid = CollisionPolygon(vertices=[(0, 0), (1, 0)])
+        assert valid.is_valid()
+        assert not invalid.is_valid()
+
+    def test_collision_polygon_transform(self):
+        poly = CollisionPolygon(vertices=[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0)])
+        transformed = poly.transform(5.0, 7.0)
+        assert transformed.vertices[0] == (5.0, 7.0)
+        assert transformed.vertices[1] == (15.0, 7.0)
+        assert transformed.vertices[2] == (15.0, 17.0)
+
+
+# ===========================================================================
+# load_tileset_collision — direct path API
+# ===========================================================================
+
+class TestLoadTilesetCollision:
+    def test_loads_fixture(self):
+        result = load_tileset_collision(TILESET_COLLISION)
+        assert result is not None
+        assert isinstance(result, TilesetCollision)
+        assert result.tileset_name == "Terrain (32x32)"
+
+    def test_returns_none_for_missing_file(self, tmp_path):
+        result = load_tileset_collision(tmp_path / "nonexistent.collision.json")
+        assert result is None
+
+    def test_raises_on_invalid_json(self, tmp_path):
+        bad = tmp_path / "bad.collision.json"
+        bad.write_text("not json", encoding="utf-8")
+        with pytest.raises(CollisionParseError):
+            load_tileset_collision(bad)
+
+    def test_raises_on_wrong_schema(self, tmp_path):
+        bad = tmp_path / "bad.collision.json"
+        bad.write_text(json.dumps({"wrong": "schema"}), encoding="utf-8")
+        with pytest.raises(CollisionParseError):
+            load_tileset_collision(bad)
+
+    def test_accepts_string_path(self):
+        result = load_tileset_collision(str(TILESET_COLLISION))
+        assert result is not None
+
+    def test_fixture_tile_ids(self):
+        result = load_tileset_collision(TILESET_COLLISION)
+        assert result.has_collision(26)
+        assert result.has_collision(8)
+        assert not result.has_collision(0)
+
+    def test_non_json_file_raises(self, tmp_path):
+        # Passing a non-JSON file (e.g. an image) raises CollisionParseError,
+        # not silently returns None — the file exists so we try to parse it.
+        fake_image = tmp_path / "terrain.png"
+        fake_image.write_bytes(b"\x89PNG\r\n")
+        with pytest.raises(CollisionParseError):
+            load_tileset_collision(fake_image)
+
+
+# ===========================================================================
+# load_character_collision — direct path API
+# ===========================================================================
+
+class TestLoadCharacterCollision:
+    def test_loads_fixture(self):
+        result = load_character_collision(CHARACTER_COLLISION)
+        assert result is not None
+        assert isinstance(result, CharacterCollision)
+        assert result.name == "hero"
+
+    def test_returns_none_for_missing_file(self, tmp_path):
+        result = load_character_collision(tmp_path / "ghost.collision.json")
+        assert result is None
+
+    def test_raises_on_invalid_json(self, tmp_path):
+        bad = tmp_path / "bad.collision.json"
+        bad.write_text("{broken", encoding="utf-8")
+        with pytest.raises(CollisionParseError):
+            load_character_collision(bad)
+
+    def test_accepts_string_path(self):
+        result = load_character_collision(str(CHARACTER_COLLISION))
+        assert result is not None
+
+    def test_fixture_shape_type(self):
+        result = load_character_collision(CHARACTER_COLLISION)
+        assert isinstance(result.shape, RectangleShape)
+
+    def test_non_json_file_raises(self, tmp_path):
+        # Passing a non-JSON file (e.g. an image) raises CollisionParseError,
+        # not silently returns None — the file exists so we try to parse it.
+        fake_image = tmp_path / "hero.png"
+        fake_image.write_bytes(b"\x89PNG\r\n")
+        with pytest.raises(CollisionParseError):
+            load_character_collision(fake_image)
+
+
+# ===========================================================================
+# CollisionCache
+# ===========================================================================
+
+class TestCollisionCache:
+    def setup_method(self):
+        self.cache = CollisionCache()
+
+    def test_get_tileset_collision(self):
+        result = self.cache.get_tileset_collision(TILESET_COLLISION)
+        assert result is not None
+        assert result.tileset_name == "Terrain (32x32)"
+
+    def test_get_character_collision(self):
+        result = self.cache.get_character_collision(CHARACTER_COLLISION)
+        assert result is not None
+        assert result.name == "hero"
+
+    def test_missing_returns_none(self, tmp_path):
+        result = self.cache.get_tileset_collision(tmp_path / "nope.collision.json")
+        assert result is None
+
+    def test_caches_result(self):
+        r1 = self.cache.get_tileset_collision(TILESET_COLLISION)
+        r2 = self.cache.get_tileset_collision(TILESET_COLLISION)
+        assert r1 is r2  # same object — not re-parsed
+
+    def test_clear_removes_cache(self):
+        r1 = self.cache.get_tileset_collision(TILESET_COLLISION)
+        self.cache.clear()
+        r2 = self.cache.get_tileset_collision(TILESET_COLLISION)
+        assert r1 is not r2  # re-parsed after clear
+
+    def test_preload_tileset(self):
+        self.cache.preload_tileset(TILESET_COLLISION)
+        key = str(TILESET_COLLISION.resolve())
+        assert key in self.cache._tileset_cache
+
+    def test_preload_character(self):
+        self.cache.preload_character(CHARACTER_COLLISION)
+        key = str(CHARACTER_COLLISION.resolve())
+        assert key in self.cache._character_cache
+
+    def test_cache_key_is_resolved_path(self, tmp_path):
+        # Two different Path objects pointing to the same file should share a cache entry
+        link = tmp_path / "link.collision.json"
+        import shutil
+        shutil.copy(TILESET_COLLISION, link)
+        r1 = self.cache.get_tileset_collision(link)
+        r2 = self.cache.get_tileset_collision(link)
+        assert r1 is r2
+
+
+# ===========================================================================
+# Global cache helpers
+# ===========================================================================
+
+class TestGlobalCacheHelpers:
+    def setup_method(self):
+        clear_collision_cache()
+
+    def test_get_cached_tileset(self):
+        result = get_cached_tileset_collision(TILESET_COLLISION)
+        assert result is not None
+
+    def test_get_cached_character(self):
+        result = get_cached_character_collision(CHARACTER_COLLISION)
+        assert result is not None
+
+    def test_clear_collision_cache(self):
+        get_cached_tileset_collision(TILESET_COLLISION)
+        clear_collision_cache()
+        # After clear, a fresh load still works
+        result = get_cached_tileset_collision(TILESET_COLLISION)
+        assert result is not None

tilemap_parser-2.0.1/tests/test_collision_runner.py

@@ -0,0 +1,110 @@
+"""
+Tests for tilemap_parser.collision_runner — focusing on correctness of
+geometric utilities, especially the xinters bug fix in point_in_polygon.
+"""
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from tilemap_parser.collision_runner import point_in_polygon, CollisionRunner, MovementMode
+from tilemap_parser.collision import CollisionCache, RectangleShape
+
+
+# ===========================================================================
+# point_in_polygon
+# ===========================================================================
+
+# Simple axis-aligned square: (0,0) -> (10,0) -> (10,10) -> (0,10)
+SQUARE = [(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]
+
+# Triangle with a horizontal bottom edge — this is what triggered the xinters bug
+# vertices: (0,0), (10,0), (5,10)
+TRIANGLE_HORIZ_BASE = [(0.0, 0.0), (10.0, 0.0), (5.0, 10.0)]
+
+
+class TestPointInPolygon:
+    def test_inside_square(self):
+        assert point_in_polygon((5.0, 5.0), SQUARE) is True
+
+    def test_outside_square(self):
+        assert point_in_polygon((15.0, 5.0), SQUARE) is False
+        assert point_in_polygon((-1.0, 5.0), SQUARE) is False
+        assert point_in_polygon((5.0, -1.0), SQUARE) is False
+        assert point_in_polygon((5.0, 15.0), SQUARE) is False
+
+    def test_inside_triangle(self):
+        assert point_in_polygon((5.0, 5.0), TRIANGLE_HORIZ_BASE) is True
+
+    def test_outside_triangle(self):
+        assert point_in_polygon((0.5, 9.0), TRIANGLE_HORIZ_BASE) is False
+        assert point_in_polygon((9.5, 9.0), TRIANGLE_HORIZ_BASE) is False
+
+    # --- xinters bug regression tests ---
+    # A polygon with a horizontal edge at y=0. When the ray is cast from a point
+    # whose y equals the horizontal edge's y, the old code would read an
+    # uninitialised / stale xinters and flip `inside` incorrectly.
+
+    def test_horizontal_edge_does_not_use_stale_xinters(self):
+        # Point well inside — must not be flipped by the horizontal base edge
+        assert point_in_polygon((5.0, 5.0), TRIANGLE_HORIZ_BASE) is True
+
+    def test_point_below_horizontal_edge(self):
+        # y=-1 is outside regardless
+        assert point_in_polygon((5.0, -1.0), TRIANGLE_HORIZ_BASE) is False
+
+    def test_polygon_with_multiple_horizontal_edges(self):
+        # Rectangle has horizontal top and bottom edges
+        rect = [(0.0, 0.0), (20.0, 0.0), (20.0, 10.0), (0.0, 10.0)]
+        assert point_in_polygon((10.0, 5.0), rect) is True
+        assert point_in_polygon((10.0, 15.0), rect) is False
+        assert point_in_polygon((-1.0, 5.0), rect) is False
+
+    def test_first_iteration_no_unbound_xinters(self):
+        # Polygon whose very first edge is horizontal — this is the case that
+        # caused an UnboundLocalError before the fix (xinters never assigned
+        # yet when the stale-read branch was reached on i=1).
+        horiz_first = [(0.0, 5.0), (10.0, 5.0), (10.0, 0.0), (0.0, 0.0)]
+        # Point inside
+        assert point_in_polygon((5.0, 2.0), horiz_first) is True
+        # Point outside
+        assert point_in_polygon((5.0, 8.0), horiz_first) is False
+
+
+# ===========================================================================
+# CollisionRunner construction
+# ===========================================================================
+
+class TestCollisionRunnerConstruction:
+    def test_from_game_type_platformer(self):
+        cache = CollisionCache()
+        runner = CollisionRunner.from_game_type("platformer", cache, (32, 32))
+        assert runner.mode == MovementMode.PLATFORMER
+        assert runner.gravity > 0
+
+    def test_from_game_type_topdown(self):
+        cache = CollisionCache()
+        runner = CollisionRunner.from_game_type("topdown", cache, (32, 32))
+        assert runner.mode == MovementMode.SLIDE
+        assert runner.gravity == 0.0
+
+    def test_from_game_type_rpg(self):
+        cache = CollisionCache()
+        runner = CollisionRunner.from_game_type("rpg", cache, (32, 32))
+        assert runner.mode == MovementMode.RPG
+        assert runner.gravity == 0.0
+
+    def test_unknown_game_type_raises(self):
+        cache = CollisionCache()
+        with pytest.raises(ValueError):
+            CollisionRunner.from_game_type("unknown", cache, (32, 32))
+
+    def test_platformer_zero_gravity_raises(self):
+        cache = CollisionCache()
+        runner = CollisionRunner.from_game_type("platformer", cache, (32, 32))
+        runner.gravity = 0.0
+        with pytest.raises(ValueError):
+            runner.validate_config()