tilemap-parser 3.1.21__tar.gz → 3.1.23__tar.gz

{tilemap_parser-3.1.21 → tilemap_parser-3.1.23}/PKG-INFO

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

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

@@ -53,6 +53,23 @@ class ParticleSystemConfig:
     rotation_speed: float = 0.0
     alpha_fade: str = "fade_out"
 
+    def apply_render_scale(self, scale: float) -> None:
+        """Scale dimensionful fields by *scale* (typically ``render_scale``).
+
+        Modifies ``particle_size_min``, ``particle_size_max``,
+        ``speed_min``, ``speed_max``, ``gravity_x``, and ``gravity_y``
+        in place.  Call once after loading config.
+
+        ``start_scale``, ``end_scale``, lifetimes, colors, angles, and
+        counts are intentionally left untouched.
+        """
+        self.particle_size_min = max(1, int(self.particle_size_min * scale))
+        self.particle_size_max = max(1, int(self.particle_size_max * scale))
+        self.speed_min *= scale
+        self.speed_max *= scale
+        self.gravity_x *= scale
+        self.gravity_y *= scale
+
     def to_dict(self) -> JsonDict:
         return {
             "emission_shape": self.emission_shape,

{tilemap_parser-3.1.21 → tilemap_parser-3.1.23}/src/tilemap_parser/runtime/__init__.py

@@ -1,3 +1,4 @@
+from .camera import Camera
 from .animation_player import AnimationPlayer, SpriteAnimationSet
 from .collision_cache import (
     CollisionCache,
@@ -38,6 +39,7 @@ from .particles import (
 __all__ = [
     "AnimationPlayer",
     "AreaNode",
+    "Camera",
     "CollisionCache",
     "CollisionHit",
     "CollisionResult",

tilemap_parser-3.1.23/src/tilemap_parser/runtime/camera.py

@@ -0,0 +1,176 @@
+"""
+Camera with centered or deadzone follow, lerp smoothing, screen-shake, and bounds clamping.
+
+Usage::
+
+    camera = Camera(800, 600, mode="centered")
+    camera.follow(player)
+
+    # each frame:
+    camera.update(dt)
+
+    # render with camera.offset:
+    tile_renderer.render(screen, camera.offset)
+    player.render(screen, camera.offset)
+"""
+
+from __future__ import annotations
+
+import math
+import random
+from typing import Optional, Tuple
+
+import pygame
+
+from ..utils.geometry import get_shape_aabb
+
+
+class Camera:
+    __slots__ = (
+        "x",
+        "y",
+        "viewport_w",
+        "viewport_h",
+        "mode",
+        "target",
+        "lerp_speed",
+        "deadzone",
+        "bounds",
+        "_shake_timer",
+        "_shake_intensity",
+        "_shake_ox",
+        "_shake_oy",
+    )
+
+    def __init__(
+        self,
+        viewport_width: int,
+        viewport_height: int,
+        mode: str = "centered",
+    ):
+        if mode not in ("centered", "deadzone"):
+            raise ValueError(f"Camera mode must be 'centered' or 'deadzone', got {mode!r}")
+
+        self.x = 0.0
+        self.y = 0.0
+        self.viewport_w = viewport_width
+        self.viewport_h = viewport_height
+        self.mode = mode
+        self.target = None
+        self.lerp_speed = 0.0
+        self.bounds = None
+
+        if mode == "deadzone":
+            dw = viewport_width * 0.5
+            dh = viewport_height * 0.5
+            self.deadzone = pygame.Rect(
+                (viewport_width - dw) / 2,
+                (viewport_height - dh) / 2,
+                dw,
+                dh,
+            )
+        else:
+            self.deadzone = None
+
+        self._shake_timer = 0.0
+        self._shake_intensity = 0.0
+        self._shake_ox = 0.0
+        self._shake_oy = 0.0
+
+    def follow(self, target) -> None:
+        """Set the entity the camera should follow.
+
+        *target* must have ``x``, ``y``, and ``collision_shape`` attributes
+        (any sprite managed by the collision runner satisfies this).
+        """
+        self.target = target
+
+    def shake(self, duration: float, intensity: float) -> None:
+        """Trigger a screen-shake effect.
+
+        Args:
+            duration: Seconds the shake lasts.
+            intensity: Maximum pixel offset applied each frame.
+        """
+        self._shake_timer = duration
+        self._shake_intensity = intensity
+
+    def update(self, dt: float) -> None:
+        """Advance the camera by *dt* seconds.
+
+        Computes the new position based on the follow mode, applies lerp,
+        clamps to bounds, and updates the screen-shake.
+        """
+        if self.target is not None:
+            l, t, r, b = get_shape_aabb(
+                self.target.x,
+                self.target.y,
+                self.target.collision_shape,
+            )
+            cx = (l + r) * 0.5
+            cy = (t + b) * 0.5
+
+            if self.mode == "centered":
+                self._move_toward(
+                    cx - self.viewport_w / 2,
+                    cy - self.viewport_h / 2,
+                    dt,
+                )
+            elif self.mode == "deadzone" and self.deadzone is not None:
+                self._follow_deadzone(cx, cy, dt)
+
+        # Bounds clamp
+        if self.bounds is not None:
+            min_x, min_y, max_x, max_y = self.bounds
+            self.x = max(min_x, min(self.x, max_x - self.viewport_w))
+            self.y = max(min_y, min(self.y, max_y - self.viewport_h))
+
+        # Shake
+        if self._shake_timer > 0:
+            self._shake_timer -= dt
+            i = self._shake_intensity
+            self._shake_ox = random.uniform(-i, i)
+            self._shake_oy = random.uniform(-i, i)
+            if self._shake_timer <= 0:
+                self._shake_timer = 0.0
+                self._shake_ox = 0.0
+                self._shake_oy = 0.0
+
+    @property
+    def offset(self) -> Tuple[float, float]:
+        """Camera offset including active screen-shake.
+
+        Pass this directly to render calls::
+
+            tile_renderer.render(screen, camera.offset)
+            player.render(screen, camera.offset)
+        """
+        return (self.x + self._shake_ox, self.y + self._shake_oy)
+
+    def _move_toward(self, target_x: float, target_y: float, dt: float) -> None:
+        if self.lerp_speed > 0:
+            t = 1.0 - math.exp(-self.lerp_speed * dt)
+            self.x += (target_x - self.x) * t
+            self.y += (target_y - self.y) * t
+        else:
+            self.x = target_x
+            self.y = target_y
+
+    def _follow_deadzone(self, cx: float, cy: float, dt: float) -> None:
+        # Target position in screen space
+        sx = cx - self.x
+        sy = cy - self.y
+        dz = self.deadzone
+        dx = dy = 0.0
+
+        if sx < dz.left:
+            dx = sx - dz.left
+        elif sx > dz.right:
+            dx = sx - dz.right
+
+        if sy < dz.top:
+            dy = sy - dz.top
+        elif sy > dz.bottom:
+            dy = sy - dz.bottom
+
+        self._move_toward(self.x + dx, self.y + dy, dt)

{tilemap_parser-3.1.21 → tilemap_parser-3.1.23}/src/tilemap_parser/runtime/map_loader.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import math
 from copy import deepcopy
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
@@ -31,6 +32,8 @@ class TilemapData:
         self.resolved_paths = resolved_paths
         self.warnings = warnings
         self.map_path = map_path
+        # Pixel/world offset applied while normalizing negative source coordinates.
+        self.origin_offset = (0, 0)
         self.area_nodes: List[AreaNode] = []
         self.particle_emitters: List[ParticleEmitterNode] = []
         self._tw, self._th = parsed.meta.tile_size
@@ -98,7 +101,9 @@ class TilemapData:
                     warnings.append(f"Failed to load nodes: {e}")
                 break
 
+        origin_offset = _normalize_origin(parsed)
         result = cls(parsed, surfaces, resolved_paths, warnings, map_path=p)
+        result.origin_offset = origin_offset
         result.area_nodes = [AreaNode(n) for n in parsed.nodes if n.node_type == "area"]
         result.particle_emitters = [
             ParticleEmitterNode(n) for n in parsed.nodes if n.node_type == "particle_emitter"
@@ -312,5 +317,83 @@ def _resolve_resource_path(path_str: str, map_dir: Path, extra_search_base: Opti
     return candidate
 
 
+def _normalize_origin(parsed: ParsedMap) -> Tuple[int, int]:
+    tw, th = parsed.meta.tile_size
+    rs = parsed.meta.render_scale
+    eff_w = int(tw * rs)
+    eff_h = int(th * rs)
+    if eff_w <= 0 or eff_h <= 0:
+        return (0, 0)
+
+    min_x = 0
+    min_y = 0
+    max_x = parsed.meta.map_size[0]
+    max_y = parsed.meta.map_size[1]
+
+    for layer in parsed.layers:
+        for x, y in layer.tiles.keys():
+            min_x = min(min_x, x)
+            min_y = min(min_y, y)
+            max_x = max(max_x, x + 1)
+            max_y = max(max_y, y + 1)
+
+        for obj in layer.objects.values():
+            left = math.floor(obj.area.x / eff_w)
+            top = math.floor(obj.area.y / eff_h)
+            right = math.ceil((obj.area.x + obj.area.w) / eff_w)
+            bottom = math.ceil((obj.area.y + obj.area.h) / eff_h)
+            min_x = min(min_x, left)
+            min_y = min(min_y, top)
+            max_x = max(max_x, right)
+            max_y = max(max_y, bottom)
+
+    for node in parsed.nodes:
+        left = math.floor(node.area.x / eff_w)
+        top = math.floor(node.area.y / eff_h)
+        right = math.ceil((node.area.x + node.area.w) / eff_w)
+        bottom = math.ceil((node.area.y + node.area.h) / eff_h)
+        min_x = min(min_x, left)
+        min_y = min(min_y, top)
+        max_x = max(max_x, right)
+        max_y = max(max_y, bottom)
+
+    if min_x >= 0 and min_y >= 0:
+        parsed.meta.map_size = (max_x, max_y)
+        return (0, 0)
+
+    shift_x = -min_x
+    shift_y = -min_y
+    pixel_shift_x = shift_x * eff_w
+    pixel_shift_y = shift_y * eff_h
+
+    for layer in parsed.layers:
+        if layer.tiles:
+            shifted_tiles = {}
+            for (x, y), tile in layer.tiles.items():
+                new_pos = (x + shift_x, y + shift_y)
+                tile.pos = new_pos
+                shifted_tiles[new_pos] = tile
+            layer.tiles = shifted_tiles
+
+        for obj in layer.objects.values():
+            obj.area.x += pixel_shift_x
+            obj.area.y += pixel_shift_y
+
+    for node in parsed.nodes:
+        node.area.x += pixel_shift_x
+        node.area.y += pixel_shift_y
+
+    parsed.meta.map_size = (max_x + shift_x, max_y + shift_y)
+    parsed.meta.initial_map_size = (
+        parsed.meta.initial_map_size[0] + shift_x,
+        parsed.meta.initial_map_size[1] + shift_y,
+    )
+    parsed.meta.scroll = (
+        parsed.meta.scroll[0] + pixel_shift_x,
+        parsed.meta.scroll[1] + pixel_shift_y,
+    )
+    return (pixel_shift_x, pixel_shift_y)
+
+
 def load_map(path: PathLike, *, extra_search_base: Optional[Path] = None, skip_missing_images: bool = True, nodes_dir: Optional[PathLike] = None) -> TilemapData:
     return TilemapData.load(path, extra_search_base=extra_search_base, skip_missing_images=skip_missing_images, nodes_dir=nodes_dir)

{tilemap_parser-3.1.21 → tilemap_parser-3.1.23}/src/tilemap_parser/runtime/object_collision.py

@@ -224,9 +224,7 @@ def check_collision(
                 depth=result.depth,
             )
 
-    # ------------------------------------------------------------------
     # Capsule pairs
-    # ------------------------------------------------------------------
     elif isinstance(shape_a, CapsuleShape) and isinstance(shape_b, CapsuleShape):
         p1 = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
         p2 = (p1[0], p1[1] + shape_a.height)

{tilemap_parser-3.1.21 → tilemap_parser-3.1.23}/src/tilemap_parser/runtime/tile_collision.py

@@ -790,6 +790,171 @@ class CollisionRunner:
 
         return best_edge
 
+    def move_grounded(
+        self,
+        sprite: ICollidableSprite,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        dt: float,
+        velocity: Optional[Vector2] = None,
+    ) -> CollisionResult:
+        """
+        Move sprite with basic grounded physics for simple entities.
+
+        A lightweight alternative to ``move_platformer()`` and
+        ``move_platformer_with_slide()`` for enemies and other
+        entities that need tilemap collision without platformer
+        features like jumping, one-way platforms, or slope walking.
+
+        Key behaviours:
+
+        * Applies gravity every frame when the sprite is not on the
+          ground.
+        * Resolves X collision (walls) by backing out the X axis and
+          zeroing horizontal velocity.
+        * Resolves Y collision via binary search so the sprite lands
+          exactly on the polygon surface --- critical for **partial
+          tiles** that only have collision in part of the tile (e.g.
+          a 32x32 tile whose collision polygon only occupies the
+          bottom 16 px).
+        * Detects walk-off-ledge: when the sprite was on the ground
+          and moves horizontally over empty space it is immediately
+          set airborne.
+
+        All collision uses the tile polygon shapes through the same
+        zero-allocation ``_collides_at`` machinery as the other
+        movement methods, so one-way platform polygons are treated
+        as solid geometry (they block both X and Y movement).
+
+        Args:
+            sprite: Sprite to move. Must expose ``x``, ``y``, ``vx``,
+                ``vy``, ``on_ground``, and ``collision_shape``.
+            tileset_collision: Tileset collision data.
+            tile_map: Dictionary mapping ``(tile_x, tile_y)`` to tile id.
+            dt: Frame delta time in seconds.
+            velocity: Optional explicit ``(vx, vy)``. When provided
+                the method skips gravity and uses this velocity directly
+                instead of reading from ``sprite.vx``/``sprite.vy``.
+                Useful for custom controllers, knockback, or flying
+                entities that should not receive gravity.
+
+        Returns:
+            :class:`CollisionResult` with final position and flags.
+        """
+        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
+
+        old_x, old_y = sprite.x, sprite.y
+        was_on_ground = getattr(sprite, "on_ground", False)
+
+        # --- resolve velocity -----------------------------------------------
+        if velocity is not None:
+            sprite.vx = velocity[0]
+            sprite.vy = velocity[1]
+        else:
+            if not was_on_ground:
+                sprite.vy += self.gravity * dt
+                if sprite.vy > self.max_fall_speed:
+                    sprite.vy = self.max_fall_speed
+
+        delta_x = sprite.vx * dt
+        delta_y = sprite.vy * dt
+
+        # --- X axis ---------------------------------------------------------
+        if delta_x != 0.0:
+            sprite.x = old_x + delta_x
+            sprite.y = old_y
+
+            if self._collides_at(sprite, tileset_collision, tile_map):
+                sprite.x = old_x
+                sprite.vx = 0.0
+                result.hit_wall_x = True
+                result.collided = True
+
+        # --- ledge detection ------------------------------------------------
+        # If the sprite was grounded and isn't actively falling, probe 1 px
+        # downward at the *new* X position.  When nothing is underneath we
+        # immediately leave the ground so gravity kicks in next frame.
+        # Not applied when velocity is explicitly passed (caller controls Y).
+        if velocity is None and was_on_ground and delta_y == 0.0:
+            saved_y = sprite.y
+            sprite.y += 1.0
+            ground_below = self._collides_at(sprite, tileset_collision, tile_map)
+            sprite.y = saved_y
+
+            if not ground_below:
+                sprite.on_ground = False
+                was_on_ground = False
+
+                # Begin falling immediately.
+                sprite.vy += self.gravity * dt
+                if sprite.vy > self.max_fall_speed:
+                    sprite.vy = self.max_fall_speed
+
+                delta_y = sprite.vy * dt
+
+        # --- Y axis ---------------------------------------------------------
+        sprite.y = sprite.y + delta_y
+
+        collided_y = self._collides_at(sprite, tileset_collision, tile_map)
+
+        if collided_y:
+            result.collided = True
+
+            if delta_y >= 0.0:
+                # Falling -> binary search for ground surface
+                sprite.y = old_y
+                lo, hi = old_y, old_y + delta_y
+
+                for _ in range(8):
+                    mid = (lo + hi) * 0.5
+                    sprite.y = mid
+
+                    if self._collides_at(sprite, tileset_collision, tile_map):
+                        hi = mid
+                    else:
+                        lo = mid
+
+                sprite.y = lo
+                sprite.vy = 0.0
+                sprite.on_ground = True
+                result.hit_wall_y = True
+                result.on_ground = True
+
+            else:
+                # Rising -> binary search for ceiling
+                sprite.y = old_y
+                lo, hi = old_y + delta_y, old_y
+
+                for _ in range(8):
+                    mid = (lo + hi) * 0.5
+                    sprite.y = mid
+
+                    if self._collides_at(sprite, tileset_collision, tile_map):
+                        lo = mid
+                    else:
+                        hi = mid
+
+                sprite.y = hi
+                sprite.vy = 0.0
+                result.hit_ceiling = True
+
+        elif delta_y > 0.0:
+            sprite.on_ground = False
+
+        result.final_x = sprite.x
+        result.final_y = sprite.y
+        result.on_ground = getattr(sprite, "on_ground", False)
+
+        return result
+
     def move_platformer(
         self,
         sprite: ICollidableSprite,

{tilemap_parser-3.1.21 → tilemap_parser-3.1.23}/src/tilemap_parser.egg-info/PKG-INFO

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

@@ -17,6 +17,7 @@ src/tilemap_parser/parser/particle.py
 src/tilemap_parser/runtime/__init__.py
 src/tilemap_parser/runtime/animation_player.py
 src/tilemap_parser/runtime/area_node.py
+src/tilemap_parser/runtime/camera.py
 src/tilemap_parser/runtime/collision_cache.py
 src/tilemap_parser/runtime/map_loader.py
 src/tilemap_parser/runtime/object_collision.py
@@ -25,10 +26,16 @@ src/tilemap_parser/runtime/renderer.py
 src/tilemap_parser/runtime/tile_collision.py
 src/tilemap_parser/utils/__init__.py
 src/tilemap_parser/utils/geometry.py
+tests/test_camera.py
 tests/test_collision.py
 tests/test_geometry.py
+tests/test_integration_animation.py
+tests/test_integration_collision.py
+tests/test_integration_map_loader.py
 tests/test_map_loader.py
+tests/test_move_grounded.py
 tests/test_object_collision.py
 tests/test_object_surfaces.py
+tests/test_particle_emitter.py
 tests/test_render_scale.py
 tests/test_tile_collision.py