tilemap-parser 3.1.2__tar.gz → 3.1.4__tar.gz

{tilemap_parser-3.1.2 → tilemap_parser-3.1.4}/PKG-INFO

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

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

@@ -104,6 +104,7 @@ class TilemapData:
                         self.warnings.append(
                             f"Unresolved tileset ref {tile.ttype!r} at layer {layer.name!r} cell {pos}"
                         )
+                        continue
                     tile.ttype = idx
 
     @property

{tilemap_parser-3.1.2 → tilemap_parser-3.1.4}/src/tilemap_parser/runtime/renderer.py

@@ -34,6 +34,11 @@ class TileLayerRenderer:
             raise ValueError(f"render_scale must be positive, got {self._rs}")
         self._eff_w = int(self._tile_w * self._rs)
         self._eff_h = int(self._tile_h * self._rs)
+        if self._eff_w <= 0 or self._eff_h <= 0:
+            raise ValueError(
+                f"effective tile size ({self._eff_w}, {self._eff_h}) must be positive; "
+                f"got tile_size=({self._tile_w}, {self._tile_h}) render_scale={self._rs}"
+            )
 
     def get_layer_dict(self) -> Dict[int, object]:
         return dict(self.tile_layers)

{tilemap_parser-3.1.2 → tilemap_parser-3.1.4}/src/tilemap_parser/runtime/tile_collision.py

@@ -906,6 +906,126 @@ class CollisionRunner:
         result.collided = result.hit_wall_x or collided_y
         return result
 
+    def move_platformer_with_slide(
+        self,
+        sprite: ICollidableSprite,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        dt: float,
+        input_x: float = 0.0,
+        jump_pressed: bool = False,
+        max_iterations: int = 4,
+    ) -> CollisionResult:
+        """
+        Move sprite with platformer physics and combined slope-sliding collision.
+
+        Uses iterative normal projection for movement resolution instead of
+        separate X/Y sweeps. This allows smooth movement on slopes — walking
+        up a slope ascends the player, walking down follows the surface.
+
+        One-way platforms are treated as solid (same as move_and_slide).
+        Use move_platformer() if you need one-way pass-through from below.
+
+        Args:
+            sprite: Sprite to move (must have vx, vy, on_ground attributes)
+            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
+            max_iterations: Max slope-slide iterations (default 4)
+
+        Returns:
+            CollisionResult with final position and collision info
+        """
+        result = self._result
+        result.collided    = False
+        result.hit_wall_x  = False
+        result.hit_wall_y  = False
+        result.hit_ceiling = False
+        result.on_ground   = False
+        result.slide_vector = None
+        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 jump_pressed and getattr(sprite, "on_ground", False):
+            sprite.vy = self.jump_strength
+
+        sprite.vx = input_x * 200.0
+
+        delta_x = sprite.vx * dt
+        delta_y = sprite.vy * dt
+        old_x, old_y = sprite.x, sprite.y
+
+        if delta_x == 0 and delta_y == 0:
+            return result
+
+        motion_x, motion_y = delta_x, delta_y
+        collided = False
+
+        for _ in range(max_iterations):
+            if abs(motion_x) < 0.01 and abs(motion_y) < 0.01:
+                break
+
+            sprite.x = old_x + motion_x
+            sprite.y = old_y + motion_y
+
+            hit = self._first_colliding_shape(sprite, tileset_collision, tile_map)
+            if hit is None:
+                break
+
+            sprite.x = old_x
+            sprite.y = old_y
+            collided = True
+
+            poly, ox, oy = hit
+            normal = self._get_collision_normal_from_motion(
+                sprite, poly, ox, oy, motion_x, motion_y, self.render_scale
+            )
+            if normal is None:
+                break
+
+            dot = motion_x * normal[0] + motion_y * normal[1]
+            if dot < 0:
+                motion_x -= normal[0] * dot
+                motion_y -= normal[1] * dot
+            else:
+                break
+
+        result.final_x = sprite.x
+        result.final_y = sprite.y
+        result.collided = collided
+
+        if collided:
+            if sprite.vy >= 0:
+                sprite.y += 1.0
+                if self._collides_at(sprite, tileset_collision, tile_map):
+                    result.on_ground = True
+                    sprite.on_ground = True
+                    sprite.vy = 0.0
+                else:
+                    sprite.on_ground = False
+                sprite.y -= 1.0
+
+            if sprite.vy < 0:
+                sprite.y -= 1.0
+                if self._collides_at(sprite, tileset_collision, tile_map):
+                    result.hit_ceiling = True
+                    sprite.vy = 0.0
+                sprite.y += 1.0
+
+            if abs(result.final_x - old_x) < 0.01 and abs(delta_x) > 0.01:
+                result.hit_wall_x = True
+        else:
+            sprite.on_ground = False
+
+        return result
+
     def move_rpg(
         self,
         sprite: ICollidableSprite,

{tilemap_parser-3.1.2 → tilemap_parser-3.1.4}/src/tilemap_parser.egg-info/PKG-INFO

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