tilemap-parser 3.1.15__tar.gz → 3.1.17__tar.gz

{tilemap_parser-3.1.15 → tilemap_parser-3.1.17}/PKG-INFO

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

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

{tilemap_parser-3.1.15 → tilemap_parser-3.1.17}/src/tilemap_parser/runtime/map_loader.py

@@ -8,7 +8,7 @@ from typing import Dict, List, Optional, Tuple, Union
 import pygame
 from pygame import Rect, Surface
 
-from ..parser.map_parse import MapParseError, ParsedLayer, ParsedMap, ParsedTile, parse_map_file
+from ..parser.map_parse import MapParseError, ParsedLayer, ParsedMap, ParsedObject, ParsedTile, parse_map_file
 from ..parser.node_parse import parse_nodes_dict
 from .area_node import AreaNode
 from .particles import ParticleEmitterNode
@@ -234,6 +234,36 @@ class TilemapData:
             return None
         return self.get_tile_surface(tile.ttype, tile.variant)
 
+    def get_object_surface(self, obj: ParsedObject, *, copy_surface: bool = True) -> Optional[Surface]:
+        return self.get_image(variant=obj.variant, ttype=obj.ttype, copy_surface=copy_surface)
+
+    def get_object_surface_by_id(
+        self, layer_id_or_name: Union[int, str], object_id: int, *, copy_surface: bool = True
+    ) -> Optional[Tuple[Surface, int, int]]:
+        layer = self.get_layer(layer_id_or_name)
+        if layer is None or layer.layer_type != "object":
+            return None
+        obj = layer.objects.get(object_id)
+        if obj is None:
+            return None
+        surf = self.get_object_surface(obj, copy_surface=copy_surface)
+        if surf is None:
+            return None
+        return surf, obj.area.x, obj.area.y
+
+    def get_object_surfaces(
+        self, layer_id_or_name: Union[int, str], *, copy_surface: bool = True
+    ) -> List[Tuple[Surface, int, int, int]]:
+        layer = self.get_layer(layer_id_or_name)
+        if layer is None or layer.layer_type != "object":
+            return []
+        result: List[Tuple[Surface, int, int, int]] = []
+        for oid, obj in layer.objects.items():
+            surf = self.get_object_surface(obj, copy_surface=copy_surface)
+            if surf is not None:
+                result.append((surf, obj.area.x, obj.area.y, oid))
+        return result
+
     def get_tileset_animation(self, ttype: int) -> Optional[dict]:
         if 0 <= ttype < len(self.parsed.tilesets):
             anim = self.parsed.tilesets[ttype].animation

{tilemap_parser-3.1.15 → tilemap_parser-3.1.17}/src/tilemap_parser/runtime/tile_collision.py

@@ -441,6 +441,7 @@ class CollisionRunner:
         self.gravity = 800.0
         self.max_fall_speed = 600.0
         self.jump_strength = -400.0
+        self.horizontal_speed = 200.0
 
         self.ground_snap_tolerance = 2.0
         self.step_height = 4.0
@@ -797,6 +798,7 @@ class CollisionRunner:
         dt: float,
         input_x: float = 0.0,
         jump_pressed: bool = False,
+        velocity: Optional[Vector2] = None,
     ) -> CollisionResult:
         """
         Move sprite with platformer physics (gravity, jumping).
@@ -808,8 +810,11 @@ class CollisionRunner:
             tileset_collision: Tileset collision data
             tile_map: Dictionary mapping (tile_x, tile_y) to tile_id
             dt: Delta time in seconds
-            input_x: Horizontal input (-1 to 1)
-            jump_pressed: Whether jump button is pressed
+            input_x: Horizontal input (-1 to 1) for built-in movement
+            jump_pressed: Whether jump button is pressed for built-in movement
+            velocity: Optional explicit velocity (vx, vy). When provided, the
+                runner skips built-in input/gravity/jump velocity calculation
+                and only resolves collision for that velocity.
 
         Returns:
             CollisionResult with final position and collision info
@@ -824,15 +829,19 @@ class CollisionRunner:
         result.final_x = sprite.x
         result.final_y = sprite.y
 
-        if not getattr(sprite, "on_ground", False):
-            sprite.vy += self.gravity * dt
-            if sprite.vy > self.max_fall_speed:
-                sprite.vy = self.max_fall_speed
+        if velocity is not None:
+            sprite.vx = velocity[0]
+            sprite.vy = velocity[1]
+        else:
+            if not getattr(sprite, "on_ground", False):
+                sprite.vy += self.gravity * dt
+                if sprite.vy > self.max_fall_speed:
+                    sprite.vy = self.max_fall_speed
 
-        if jump_pressed and getattr(sprite, "on_ground", False):
-            sprite.vy = self.jump_strength
+            if jump_pressed and getattr(sprite, "on_ground", False):
+                sprite.vy = self.jump_strength
 
-        sprite.vx = input_x * 200.0
+            sprite.vx = input_x * self.horizontal_speed
 
         delta_x = sprite.vx * dt
         delta_y = sprite.vy * dt
@@ -1325,6 +1334,7 @@ class CollisionRunner:
         dt: float,
         input_x: float = 0.0,
         jump_pressed: bool = False,
+        velocity: Optional[Vector2] = None,
     ) -> CollisionResult:
         """
         Slope-aware platformer movement.
@@ -1360,6 +1370,13 @@ class CollisionRunner:
             jump_pressed:
                 True if jump was pressed during this frame.
 
+            velocity:
+                Optional explicit velocity (vx, vy). When provided, the runner
+                skips built-in input/gravity/jump velocity calculation and only
+                resolves collision for that velocity. This is the preferred
+                path for dash, knockback, wind, moving-platform carry, or a
+                custom controller.
+
         Returns:
             CollisionResult describing the resolved movement and collision
             state after simulation.
@@ -1381,18 +1398,25 @@ class CollisionRunner:
         was_on_ground = getattr(sprite, "on_ground", False)
         jumped = False
 
-        if jump_pressed and was_on_ground:
-            sprite.vy = self.jump_strength
-            sprite.on_ground = False
-            jumped = True
-        elif not was_on_ground:
-            sprite.vy += self.gravity * dt
-            if sprite.vy > self.max_fall_speed:
-                sprite.vy = self.max_fall_speed
+        if velocity is not None:
+            sprite.vx = velocity[0]
+            sprite.vy = velocity[1]
+            if sprite.vy < 0.0:
+                sprite.on_ground = False
+                jumped = True
         else:
-            sprite.vy = min(sprite.vy, 0.0)
+            if jump_pressed and was_on_ground:
+                sprite.vy = self.jump_strength
+                sprite.on_ground = False
+                jumped = True
+            elif not was_on_ground:
+                sprite.vy += self.gravity * dt
+                if sprite.vy > self.max_fall_speed:
+                    sprite.vy = self.max_fall_speed
+            else:
+                sprite.vy = min(sprite.vy, 0.0)
 
-        sprite.vx = input_x * 200.0
+            sprite.vx = input_x * self.horizontal_speed
         delta_x = sprite.vx * dt
         delta_y = sprite.vy * dt
         bottom_offset = old_bottom - old_y
@@ -1662,6 +1686,7 @@ class CollisionRunner:
                 dt,
                 input_x=kwargs.get("input_x", 0.0),
                 jump_pressed=kwargs.get("jump_pressed", False),
+                velocity=kwargs.get("velocity"),
             )
         elif self.mode == MovementMode.RPG:
             return self.move_rpg(sprite, tileset_collision, tile_map, delta_x, delta_y)
@@ -1736,6 +1761,7 @@ class CollisionRunner:
             runner.gravity = 800.0
             runner.max_fall_speed = 600.0
             runner.jump_strength = -400.0
+            runner.horizontal_speed = 200.0
             runner.slide_friction = 0.1
             runner._game_type = "platformer"
             runner._strict = strict

{tilemap_parser-3.1.15 → tilemap_parser-3.1.17}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.15
+Version: 3.1.17
 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-3.1.15 → tilemap_parser-3.1.17}/src/tilemap_parser.egg-info/SOURCES.txt

@@ -29,5 +29,6 @@ tests/test_collision.py
 tests/test_geometry.py
 tests/test_map_loader.py
 tests/test_object_collision.py
+tests/test_object_surfaces.py
 tests/test_render_scale.py
 tests/test_tile_collision.py

tilemap_parser-3.1.17/tests/test_object_surfaces.py

@@ -0,0 +1,200 @@
+import json
+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
+
+
+MINIMAL_MAP_META = {
+    "tile_size": "16;16",
+    "map_size": "10;10",
+    "version": "1.1",
+}
+
+
+def _make_minimal_png(path: Path, size: tuple[int, int] = (32, 16)) -> None:
+    surf = pygame.Surface(size)
+    surf.fill((255, 0, 255))
+    pygame.image.save(surf, str(path))
+
+
+def _make_map_json_with_objects(tileset_path: str, data_dir: Path) -> Path:
+    payload = {
+        "meta": {**MINIMAL_MAP_META},
+        "resources": {"tilesets": [{"path": tileset_path, "type": "tile"}]},
+        "project_state": {"rules": [], "groups": []},
+        "data": {
+            "ongrid": {},
+            "layers": [
+                {
+                    "name": "Object Layer 1",
+                    "type": "object",
+                    "visible": True,
+                    "locked": False,
+                    "opacity": 1.0,
+                    "z_index": 1,
+                    "properties": {},
+                    "tiles": {},
+                    "objects": {
+                        "1": {
+                            "area": {"x": 10, "y": 20, "w": 16, "h": 16},
+                            "ttype": 0,
+                            "tileset_type": "object",
+                            "variant": 0,
+                            "properties": {},
+                        },
+                        "2": {
+                            "area": {"x": 50, "y": 60, "w": 32, "h": 32},
+                            "ttype": 0,
+                            "tileset_type": "object",
+                            "variant": 1,
+                            "properties": {"name": "foo"},
+                        },
+                    },
+                    "next_object_id": 3,
+                },
+                {
+                    "name": "Tile Layer",
+                    "type": "tile",
+                    "visible": True,
+                    "locked": False,
+                    "opacity": 1.0,
+                    "z_index": 0,
+                    "properties": {},
+                    "tiles": {},
+                    "objects": {},
+                },
+            ],
+        },
+    }
+    map_path = data_dir / "test_map_objects.json"
+    with open(map_path, "w") as f:
+        json.dump(payload, f, indent=2)
+    return map_path
+
+
+@pytest.fixture(autouse=True)
+def pygame_init():
+    pygame.display.init()
+    pygame.display.set_mode((1, 1))
+    yield
+    pygame.quit()
+
+
+@pytest.fixture
+def map_data():
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        data_dir = tmp / "data"
+        assets_dir = tmp / "assets"
+        data_dir.mkdir()
+        assets_dir.mkdir()
+        png = assets_dir / "tileset.png"
+        _make_minimal_png(png)
+        map_path = _make_map_json_with_objects("../assets/tileset.png", data_dir)
+        td = TilemapData.load(map_path)
+        yield td, data_dir, assets_dir, png
+
+
+class TestObjectSurfaces:
+    def test_get_object_surface_returns_surface(self, map_data):
+        td, *_ = map_data
+        obj = ParsedObject(
+            area=ParsedObjectArea(x=10, y=20, w=16, h=16),
+            ttype=0,
+            tileset_type="object",
+            variant=0,
+        )
+        surf = td.get_object_surface(obj)
+        assert surf is not None
+        assert isinstance(surf, pygame.Surface)
+        assert surf.get_size() == (16, 16)
+
+    def test_get_object_surface_from_parsed_object(self, map_data):
+        td, *_ = map_data
+        layer = td.get_layer("Object Layer 1")
+        assert layer is not None
+        obj = layer.objects.get(1)
+        assert obj is not None
+        surf = td.get_object_surface(obj)
+        assert surf is not None
+        assert isinstance(surf, pygame.Surface)
+
+    def test_get_object_surface_by_id_returns_surface_xy(self, map_data):
+        td, *_ = map_data
+        result = td.get_object_surface_by_id("Object Layer 1", 1)
+        assert result is not None
+        surf, x, y = result
+        assert isinstance(surf, pygame.Surface)
+        assert x == 10
+        assert y == 20
+
+    def test_get_object_surface_by_id_second_object(self, map_data):
+        td, *_ = map_data
+        result = td.get_object_surface_by_id("Object Layer 1", 2)
+        assert result is not None
+        surf, x, y = result
+        assert isinstance(surf, pygame.Surface)
+        assert surf.get_size() == (16, 16)
+        assert x == 50
+        assert y == 60
+
+    def test_get_object_surface_by_id_bad_layer_returns_none(self, map_data):
+        td, *_ = map_data
+        result = td.get_object_surface_by_id("Tile Layer", 1)
+        assert result is None
+
+    def test_get_object_surface_by_id_bad_layer_name(self, map_data):
+        td, *_ = map_data
+        result = td.get_object_surface_by_id("Nonexistent", 1)
+        assert result is None
+
+    def test_get_object_surface_by_id_bad_object_id(self, map_data):
+        td, *_ = map_data
+        result = td.get_object_surface_by_id("Object Layer 1", 999)
+        assert result is None
+
+    def test_get_object_surfaces_returns_all(self, map_data):
+        td, *_ = map_data
+        results = td.get_object_surfaces("Object Layer 1")
+        assert len(results) == 2
+
+        surf1, x1, y1, oid1 = results[0]
+        assert isinstance(surf1, pygame.Surface)
+        assert x1 == 10
+        assert y1 == 20
+        assert oid1 == 1
+
+        surf2, x2, y2, oid2 = results[1]
+        assert isinstance(surf2, pygame.Surface)
+        assert x2 == 50
+        assert y2 == 60
+        assert oid2 == 2
+
+    def test_get_object_surfaces_bad_layer(self, map_data):
+        td, *_ = map_data
+        results = td.get_object_surfaces("Tile Layer")
+        assert results == []
+
+    def test_get_object_surfaces_nonexistent_layer(self, map_data):
+        td, *_ = map_data
+        results = td.get_object_surfaces("Nonexistent")
+        assert results == []
+
+    def test_get_object_surface_with_out_of_range_ttype_returns_none(self, map_data):
+        td, *_ = map_data
+        obj = ParsedObject(
+            area=ParsedObjectArea(x=0, y=0, w=16, h=16),
+            ttype=999,
+            tileset_type="object",
+            variant=0,
+        )
+        surf = td.get_object_surface(obj)
+        assert surf is None

{tilemap_parser-3.1.15 → tilemap_parser-3.1.17}/tests/test_tile_collision.py

@@ -267,6 +267,43 @@ class TestMovePlatformer:
         assert sprite.x > 137
         assert result.hit_wall_x is False
 
+    def test_explicit_velocity_controls_horizontal_movement(self):
+        tile_map = {}
+        sprite = MockSprite(x=100, y=100)
+        sprite.vx = 0
+        sprite.vy = 0
+        sprite.on_ground = True
+
+        result = self.runner.move_platformer(
+            sprite,
+            self.tileset,
+            tile_map,
+            dt=0.016,
+            input_x=0,
+            velocity=(600.0, 0.0),
+        )
+
+        assert result.final_x == pytest.approx(109.6)
+        assert sprite.vx == pytest.approx(600.0)
+
+    def test_move_convenience_forwards_explicit_velocity(self):
+        sprite = MockSprite(x=100, y=100)
+        sprite.vx = 0
+        sprite.vy = 0
+        sprite.on_ground = True
+
+        result = self.runner.move(
+            sprite,
+            self.tileset,
+            {},
+            dt=0.016,
+            input_x=0,
+            velocity=(600.0, 0.0),
+        )
+
+        assert result.final_x == pytest.approx(109.6)
+        assert sprite.vx == pytest.approx(600.0)
+
 
 class TestMovePlatformerWithSlide:
     def setup_method(self):
@@ -334,6 +371,24 @@ class TestMovePlatformerWithSlide:
         assert sprite.x == 103
         assert result.hit_wall_x is True
 
+    def test_explicit_velocity_controls_dash_without_input_scaling(self):
+        sprite = MockSprite(x=100, y=100)
+        sprite.vx = 0
+        sprite.vy = 0
+        sprite.on_ground = True
+
+        result = self.runner.move_platformer_with_slide(
+            sprite,
+            self.tileset,
+            {},
+            dt=0.016,
+            input_x=0,
+            velocity=(600.0, 0.0),
+        )
+
+        assert result.final_x == pytest.approx(109.6)
+        assert sprite.vx == pytest.approx(600.0)
+
 
 class TestMoveRpg:
     def setup_method(self):