tilemap-parser 1.0.0__tar.gz → 1.1.0__tar.gz

{tilemap_parser-1.0.0/src/tilemap_parser.egg-info → tilemap_parser-1.1.0}/PKG-INFO

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

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

{tilemap_parser-1.0.0 → tilemap_parser-1.1.0}/src/tilemap_parser/__init__.py

@@ -10,6 +10,30 @@ from .animation import (
     parse_animation_file,
     parse_animation_json,
 )
+from .collision import (
+    CapsuleShape,
+    CharacterCollision,
+    CircleShape,
+    CollisionCache,
+    CollisionParseError,
+    CollisionPolygon,
+    RectangleShape,
+    TileCollisionData,
+    TilesetCollision,
+    clear_collision_cache,
+    get_cached_character_collision,
+    get_cached_tileset_collision,
+    load_character_collision,
+    load_tileset_collision,
+    parse_character_collision,
+    parse_tileset_collision,
+)
+from .collision_runner import (
+    CollisionResult,
+    CollisionRunner,
+    ICollidableSprite,
+    MovementMode,
+)
 from .map_loader import TilemapData, load_map
 from .map_parse import (
     MapParseError,
@@ -36,8 +60,18 @@ __all__ = [
     "AnimationMarker",
     "AnimationParseError",
     "AnimationPlayer",
+    "CapsuleShape",
+    "CharacterCollision",
+    "CircleShape",
+    "CollisionCache",
+    "CollisionParseError",
+    "CollisionPolygon",
+    "CollisionResult",
+    "CollisionRunner",
+    "ICollidableSprite",
     "LayerRenderStats",
     "MapParseError",
+    "MovementMode",
     "ParsedAutotileGroup",
     "ParsedAutotileRule",
     "ParsedLayer",
@@ -48,14 +82,24 @@ __all__ = [
     "ParsedProjectState",
     "ParsedTile",
     "ParsedTileset",
+    "RectangleShape",
     "SpriteAnimationSet",
+    "TileCollisionData",
     "TileLayerRenderer",
+    "TilesetCollision",
     "TilemapData",
+    "clear_collision_cache",
+    "get_cached_character_collision",
+    "get_cached_tileset_collision",
+    "load_character_collision",
     "load_map",
+    "load_tileset_collision",
     "parse_animation_dict",
     "parse_animation_file",
     "parse_animation_json",
+    "parse_character_collision",
     "parse_map_dict",
     "parse_map_file",
     "parse_map_json",
+    "parse_tileset_collision",
 ]

tilemap_parser-1.1.0/src/tilemap_parser/collision.py

@@ -0,0 +1,344 @@
+"""
+Collision data parser and runtime utilities for tilemap collision systems.
+
+This module provides parsers for both tileset collision (polygon-based) and
+character collision (geometric shapes) data generated by the tilemap editor.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+JsonDict = Dict[str, Any]
+Point = Tuple[float, float]
+IntPoint = Tuple[int, int]
+
+
+class CollisionParseError(ValueError):
+    """Raised when collision data cannot be parsed"""
+    pass
+
+
+@dataclass
+class CollisionPolygon:
+    """Polygon collision shape for a tile"""
+
+    vertices: List[Point]
+    one_way: bool = False
+
+    def transform(self, tile_x: float, tile_y: float) -> "CollisionPolygon":
+        """Transform polygon to world space coordinates"""
+        world_vertices = [(tile_x + vx, tile_y + vy) for vx, vy in self.vertices]
+        return CollisionPolygon(vertices=world_vertices, one_way=self.one_way)
+
+    def is_valid(self) -> bool:
+        """Check if polygon has at least 3 vertices"""
+        return len(self.vertices) >= 3
+
+
+@dataclass
+class TileCollisionData:
+    """Collision data for a single tile"""
+
+    tile_id: int
+    shapes: List[CollisionPolygon] = field(default_factory=list)
+
+    def has_collision(self) -> bool:
+        """Check if tile has any valid collision shapes"""
+        return any(shape.is_valid() for shape in self.shapes)
+
+
+@dataclass
+class TilesetCollision:
+    """Complete collision data for a tileset"""
+
+    tileset_name: str
+    tile_size: IntPoint
+    tiles: Dict[int, TileCollisionData] = field(default_factory=dict)
+
+    def get_tile_collision(self, tile_id: int) -> Optional[TileCollisionData]:
+        """Get collision data for a specific tile"""
+        return self.tiles.get(tile_id)
+
+    def has_collision(self, tile_id: int) -> bool:
+        """Check if tile has collision data"""
+        tile_data = self.get_tile_collision(tile_id)
+        return tile_data is not None and tile_data.has_collision()
+
+    def get_world_shapes(
+        self, tile_id: int, tile_x: float, tile_y: float
+    ) -> List[CollisionPolygon]:
+        """Get collision shapes transformed to world space"""
+        tile_data = self.get_tile_collision(tile_id)
+        if not tile_data:
+            return []
+        return [shape.transform(tile_x, tile_y) for shape in tile_data.shapes]
+
+
+@dataclass
+class RectangleShape:
+    """Rectangle collision shape"""
+
+    width: float
+    height: float
+    offset: Point = (0.0, 0.0)
+
+    def get_bounds(self, x: float, y: float) -> Tuple[float, float, float, float]:
+        """Get AABB bounds in world space (left, top, right, bottom)"""
+        left = x + self.offset[0]
+        top = y + self.offset[1]
+        return (left, top, left + self.width, top + self.height)
+
+
+@dataclass
+class CircleShape:
+    """Circle collision shape"""
+
+    radius: float
+    offset: Point = (0.0, 0.0)
+
+    def get_center(self, x: float, y: float) -> Point:
+        """Get center position in world space"""
+        return (x + self.offset[0], y + self.offset[1])
+
+
+@dataclass
+class CapsuleShape:
+    """Capsule collision shape (vertical orientation)"""
+
+    radius: float
+    height: float
+    offset: Point = (0.0, 0.0)
+
+    def get_top_center(self, x: float, y: float) -> Point:
+        """Get top circle center in world space"""
+        return (x + self.offset[0], y + self.offset[1])
+
+    def get_bottom_center(self, x: float, y: float) -> Point:
+        """Get bottom circle center in world space"""
+        return (x + self.offset[0], y + self.offset[1] + self.height)
+
+
+CharacterShapeType = Union[RectangleShape, CircleShape, CapsuleShape]
+
+
+@dataclass
+class CharacterCollision:
+    """Complete collision data for a character sprite"""
+
+    name: str
+    shape: CharacterShapeType
+    properties: Dict[str, Any] = field(default_factory=dict)
+
+
+def parse_tileset_collision(data: JsonDict) -> TilesetCollision:
+    """
+    Parse tileset collision data from dictionary.
+
+    Args:
+        data: Dictionary loaded from .collision.json file
+
+    Returns:
+        TilesetCollision object
+
+    Raises:
+        CollisionParseError: If data format is invalid
+    """
+    try:
+        tileset_name = data["tileset_name"]
+        tile_size_raw = data["tile_size"]
+        tile_size = (int(tile_size_raw[0]), int(tile_size_raw[1]))
+
+        tiles: Dict[int, TileCollisionData] = {}
+        tiles_data = data.get("tiles", {})
+
+        for tile_id_str, tile_data in tiles_data.items():
+            tile_id = int(tile_id_str)
+            shapes: List[CollisionPolygon] = []
+
+            for shape_data in tile_data.get("shapes", []):
+                vertices = [tuple(v) for v in shape_data["vertices"]]
+                one_way = shape_data.get("one_way", False)
+                shapes.append(CollisionPolygon(vertices=vertices, one_way=one_way))
+
+            tiles[tile_id] = TileCollisionData(tile_id=tile_id, shapes=shapes)
+
+        return TilesetCollision(
+            tileset_name=tileset_name, tile_size=tile_size, tiles=tiles
+        )
+    except (KeyError, ValueError, TypeError) as e:
+        raise CollisionParseError(f"Invalid tileset collision data: {e}") from e
+
+
+def parse_character_collision(data: JsonDict) -> CharacterCollision:
+    """
+    Parse character collision data from dictionary.
+
+    Args:
+        data: Dictionary loaded from .collision.json file
+
+    Returns:
+        CharacterCollision object
+
+    Raises:
+        CollisionParseError: If data format is invalid
+    """
+    try:
+        name = data["name"]
+        shape_data = data["shape"]
+        shape_type = shape_data["type"]
+        offset = tuple(shape_data.get("offset", (0.0, 0.0)))
+
+        if shape_type == "rectangle":
+            shape = RectangleShape(
+                width=float(shape_data["width"]),
+                height=float(shape_data["height"]),
+                offset=offset,
+            )
+        elif shape_type == "circle":
+            shape = CircleShape(radius=float(shape_data["radius"]), offset=offset)
+        elif shape_type == "capsule":
+            shape = CapsuleShape(
+                radius=float(shape_data["radius"]),
+                height=float(shape_data["height"]),
+                offset=offset,
+            )
+        else:
+            raise CollisionParseError(f"Unknown shape type: {shape_type}")
+
+        properties = data.get("properties", {})
+
+        return CharacterCollision(name=name, shape=shape, properties=properties)
+    except (KeyError, ValueError, TypeError) as e:
+        raise CollisionParseError(f"Invalid character collision data: {e}") from e
+
+
+def load_tileset_collision(
+    tileset_path: Union[str, Path],
+) -> Optional[TilesetCollision]:
+    """
+    Load tileset collision data from file.
+
+    Args:
+        tileset_path: Path to tileset image file
+
+    Returns:
+        TilesetCollision object or None if collision file doesn't exist
+
+    Raises:
+        CollisionParseError: If collision file exists but is invalid
+    """
+    tileset_path = Path(tileset_path)
+    collision_path = tileset_path.with_suffix(".collision.json")
+
+    if not collision_path.exists():
+        return None
+
+    try:
+        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:
+        raise CollisionParseError(f"Cannot load {collision_path}: {e}") from e
+
+
+def load_character_collision(
+    sprite_path: Union[str, Path],
+) -> Optional[CharacterCollision]:
+    """
+    Load character collision data from file.
+
+    Args:
+        sprite_path: Path to character sprite image file
+
+    Returns:
+        CharacterCollision object or None if collision file doesn't exist
+
+    Raises:
+        CollisionParseError: If collision file exists but is invalid
+    """
+    sprite_path = Path(sprite_path)
+    collision_path = sprite_path.with_suffix(".collision.json")
+
+    if not collision_path.exists():
+        return None
+
+    try:
+        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:
+        raise CollisionParseError(f"Cannot load {collision_path}: {e}") from e
+
+
+class CollisionCache:
+    """
+    Optimized collision data cache with fast lookups.
+
+    Caches parsed collision data to avoid repeated file I/O and parsing.
+    Useful for runtime performance in game engines.
+    """
+
+    def __init__(self):
+        self._tileset_cache: Dict[str, Optional[TilesetCollision]] = {}
+        self._character_cache: Dict[str, Optional[CharacterCollision]] = {}
+
+    def get_tileset_collision(
+        self, tileset_path: Union[str, Path]
+    ) -> Optional[TilesetCollision]:
+        """Get tileset collision data (cached)"""
+        key = str(Path(tileset_path).resolve())
+
+        if key not in self._tileset_cache:
+            self._tileset_cache[key] = load_tileset_collision(tileset_path)
+
+        return self._tileset_cache[key]
+
+    def get_character_collision(
+        self, sprite_path: Union[str, Path]
+    ) -> Optional[CharacterCollision]:
+        """Get character collision data (cached)"""
+        key = str(Path(sprite_path).resolve())
+
+        if key not in self._character_cache:
+            self._character_cache[key] = load_character_collision(sprite_path)
+
+        return self._character_cache[key]
+
+    def clear(self):
+        """Clear all cached collision data"""
+        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_character(self, sprite_path: Union[str, Path]):
+        """Preload character collision data into cache"""
+        self.get_character_collision(sprite_path)
+
+
+_global_cache = CollisionCache()
+
+
+def get_cached_tileset_collision(
+    tileset_path: Union[str, Path],
+) -> Optional[TilesetCollision]:
+    """Get tileset collision using global cache"""
+    return _global_cache.get_tileset_collision(tileset_path)
+
+
+def get_cached_character_collision(
+    sprite_path: Union[str, Path],
+) -> Optional[CharacterCollision]:
+    """Get character collision using global cache"""
+    return _global_cache.get_character_collision(sprite_path)
+
+
+def clear_collision_cache():
+    """Clear global collision cache"""
+    _global_cache.clear()

tilemap_parser-1.1.0/src/tilemap_parser/collision_runner.py

@@ -0,0 +1,580 @@
+"""
+Collision runner with ready-to-use movement modes for games.
+
+Provides optimized collision detection and response for common game types:
+- Slide: Smooth sliding along walls (top-down games)
+- Platformer: Gravity-based movement with jump mechanics
+- RPG: Grid-based or free movement with tile blocking
+
+All runners work through a defined interface that any sprite class can implement.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional, Protocol, Tuple, Union
+
+from .collision import (
+    CapsuleShape,
+    CircleShape,
+    CollisionCache,
+    CollisionPolygon,
+    RectangleShape,
+    TilesetCollision,
+)
+
+Point = Tuple[float, float]
+Vector2 = Tuple[float, float]
+
+
+
+
+
+
+
+class ICollidableSprite(Protocol):
+    """
+    Interface that any sprite/character class must implement to use collision runners.
+    
+    Required attributes:
+        x (float): World X position
+        y (float): World Y position
+        collision_shape (RectangleShape | CircleShape | CapsuleShape): Collision shape
+    
+    Optional attributes:
+        vx (float): X velocity (for physics-based runners)
+        vy (float): Y velocity (for physics-based runners)
+        on_ground (bool): Whether sprite is on ground (for platformer)
+    """
+    
+    x: float
+    y: float
+    collision_shape: Union[RectangleShape, CircleShape, CapsuleShape]
+    
+    
+    vx: float
+    vy: float
+    on_ground: bool
+
+
+
+
+
+
+
+def point_in_polygon(point: Point, vertices: List[Point]) -> bool:
+    """Check if point is inside polygon using ray casting"""
+    x, y = point
+    n = len(vertices)
+    inside = False
+    
+    p1x, p1y = vertices[0]
+    for i in range(1, n + 1):
+        p2x, p2y = vertices[i % n]
+        if y > min(p1y, p2y):
+            if y <= max(p1y, p2y):
+                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
+        p1x, p1y = p2x, p2y
+    
+    return inside
+
+
+def rect_polygon_collision(
+    rect_x: float, rect_y: float, rect_w: float, rect_h: float,
+    vertices: List[Point]
+) -> bool:
+    """Check if rectangle collides with polygon"""
+    
+    corners = [
+        (rect_x, rect_y),
+        (rect_x + rect_w, rect_y),
+        (rect_x, rect_y + rect_h),
+        (rect_x + rect_w, rect_y + rect_h),
+    ]
+    
+    for corner in corners:
+        if point_in_polygon(corner, vertices):
+            return True
+    
+    
+    for vx, vy in vertices:
+        if rect_x <= vx <= rect_x + rect_w and rect_y <= vy <= rect_y + rect_h:
+            return True
+    
+    return False
+
+
+def circle_polygon_collision(
+    center: Point, radius: float, vertices: List[Point]
+) -> bool:
+    """Check if circle collides with polygon"""
+    
+    if point_in_polygon(center, vertices):
+        return True
+    
+    
+    cx, cy = center
+    n = len(vertices)
+    
+    for i in range(n):
+        x1, y1 = vertices[i]
+        x2, y2 = vertices[(i + 1) % n]
+        
+        
+        dx = x2 - x1
+        dy = y2 - y1
+        
+        
+        fx = cx - x1
+        fy = cy - y1
+        
+        
+        if dx == 0 and dy == 0:
+            dist = math.sqrt((cx - x1) ** 2 + (cy - y1) ** 2)
+        else:
+            t = max(0, min(1, (fx * dx + fy * dy) / (dx * dx + dy * dy)))
+            closest_x = x1 + t * dx
+            closest_y = y1 + t * dy
+            dist = math.sqrt((cx - closest_x) ** 2 + (cy - closest_y) ** 2)
+        
+        if dist <= radius:
+            return True
+    
+    return False
+
+
+def get_shape_bounds(
+    sprite: ICollidableSprite
+) -> Tuple[float, float, float, float]:
+    """Get AABB bounds for sprite (left, top, right, bottom)"""
+    shape = sprite.collision_shape
+    
+    if isinstance(shape, RectangleShape):
+        left = sprite.x + shape.offset[0]
+        top = sprite.y + shape.offset[1]
+        return (left, top, left + shape.width, top + shape.height)
+    elif isinstance(shape, CircleShape):
+        cx, cy = shape.get_center(sprite.x, sprite.y)
+        r = shape.radius
+        return (cx - r, cy - r, cx + r, cy + r)
+    elif isinstance(shape, CapsuleShape):
+        top_center = shape.get_top_center(sprite.x, sprite.y)
+        r = shape.radius
+        h = shape.height
+        return (top_center[0] - r, top_center[1], top_center[0] + r, top_center[1] + h + r * 2)
+    
+    return (sprite.x, sprite.y, sprite.x + 32, sprite.y + 32)
+
+
+def check_sprite_polygon_collision(
+    sprite: ICollidableSprite, polygon: CollisionPolygon
+) -> bool:
+    """Check if sprite collides with polygon"""
+    shape = sprite.collision_shape
+    
+    if isinstance(shape, RectangleShape):
+        left, top, right, bottom = get_shape_bounds(sprite)
+        return rect_polygon_collision(left, top, right - left, bottom - top, polygon.vertices)
+    elif isinstance(shape, CircleShape):
+        center = shape.get_center(sprite.x, sprite.y)
+        return circle_polygon_collision(center, shape.radius, polygon.vertices)
+    elif isinstance(shape, CapsuleShape):
+        
+        left, top, right, bottom = get_shape_bounds(sprite)
+        return rect_polygon_collision(left, top, right - left, bottom - top, polygon.vertices)
+    
+    return False
+
+
+
+
+
+
+
+class MovementMode(Enum):
+    """Movement modes for collision runner"""
+    SLIDE = "slide"  
+    PLATFORMER = "platformer"  
+    RPG = "rpg"  
+
+
+
+
+
+
+
+@dataclass
+class CollisionResult:
+    """Result of collision detection and resolution"""
+    collided: bool = False
+    final_x: float = 0.0
+    final_y: float = 0.0
+    hit_wall_x: bool = False
+    hit_wall_y: bool = False
+    hit_ceiling: bool = False
+    on_ground: bool = False
+    slide_vector: Optional[Vector2] = None
+
+
+class CollisionRunner:
+    """
+    Ready-to-use collision runner with multiple movement modes.
+    
+    Handles collision detection and response for common game types.
+    Works with any sprite class that implements ICollidableSprite interface.
+    """
+    
+    def __init__(
+        self,
+        collision_cache: CollisionCache,
+        tile_size: Tuple[int, int] = (32, 32),
+        mode: MovementMode = MovementMode.SLIDE
+    ):
+        """
+        Initialize collision runner.
+        
+        Args:
+            collision_cache: Cache with preloaded collision data
+            tile_size: Size of tiles in pixels (width, height)
+            mode: Movement mode (slide, platformer, rpg)
+        """
+        self.cache = collision_cache
+        self.tile_size = tile_size
+        self.mode = mode
+        
+        
+        self.gravity = 800.0  
+        self.max_fall_speed = 600.0  
+        self.jump_strength = -400.0  
+        
+        
+        self.slide_friction = 0.1  
+        
+        
+        self.rpg_snap_to_grid = False  
+    
+    def get_tile_at(
+        self, world_x: float, world_y: float
+    ) -> Tuple[int, int]:
+        """Convert world position to tile coordinates"""
+        tile_x = int(world_x // self.tile_size[0])
+        tile_y = int(world_y // self.tile_size[1])
+        return (tile_x, tile_y)
+    
+    def get_tile_shapes(
+        self,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,  
+        world_x: float,
+        world_y: float
+    ) -> List[CollisionPolygon]:
+        """Get collision shapes at world position"""
+        tile_x, tile_y = self.get_tile_at(world_x, world_y)
+        tile_id = tile_map.get((tile_x, tile_y))
+        
+        if tile_id is None or not tileset_collision.has_collision(tile_id):
+            return []
+        
+        tile_world_x = tile_x * self.tile_size[0]
+        tile_world_y = tile_y * self.tile_size[1]
+        
+        return tileset_collision.get_world_shapes(tile_id, tile_world_x, tile_world_y)
+    
+    def get_nearby_tile_shapes(
+        self,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        sprite: ICollidableSprite,
+        margin: int = 1
+    ) -> List[CollisionPolygon]:
+        """Get all collision shapes near sprite"""
+        left, top, right, bottom = get_shape_bounds(sprite)
+        
+        min_tile_x = int(left // self.tile_size[0]) - margin
+        max_tile_x = int(right // self.tile_size[0]) + margin
+        min_tile_y = int(top // self.tile_size[1]) - margin
+        max_tile_y = int(bottom // self.tile_size[1]) + margin
+        
+        shapes = []
+        for tile_y in range(min_tile_y, max_tile_y + 1):
+            for tile_x in range(min_tile_x, max_tile_x + 1):
+                tile_id = tile_map.get((tile_x, tile_y))
+                if tile_id is None or not tileset_collision.has_collision(tile_id):
+                    continue
+                
+                tile_world_x = tile_x * self.tile_size[0]
+                tile_world_y = tile_y * self.tile_size[1]
+                
+                tile_shapes = tileset_collision.get_world_shapes(
+                    tile_id, tile_world_x, tile_world_y
+                )
+                shapes.extend(tile_shapes)
+        
+        return shapes
+    
+    def move_and_slide(
+        self,
+        sprite: ICollidableSprite,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        delta_x: float,
+        delta_y: float
+    ) -> CollisionResult:
+        """
+        Move sprite with sliding collision response.
+        
+        Best for top-down games where sprite should slide along walls.
+        
+        Args:
+            sprite: Sprite to move (must implement ICollidableSprite)
+            tileset_collision: Tileset collision data
+            tile_map: Dictionary mapping (tile_x, tile_y) to tile_id
+            delta_x: X movement amount
+            delta_y: Y movement amount
+            
+        Returns:
+            CollisionResult with final position and collision info
+        """
+        result = CollisionResult(final_x=sprite.x, final_y=sprite.y)
+        
+        if delta_x == 0 and delta_y == 0:
+            return result
+        
+        
+        old_x, old_y = sprite.x, sprite.y
+        sprite.x += delta_x
+        sprite.y += delta_y
+        
+        shapes = self.get_nearby_tile_shapes(tileset_collision, tile_map, sprite)
+        
+        
+        collided = any(check_sprite_polygon_collision(sprite, shape) for shape in shapes)
+        
+        if not collided:
+            result.final_x = sprite.x
+            result.final_y = sprite.y
+            return result
+        
+        
+        result.collided = True
+        
+        
+        sprite.x = old_x + delta_x
+        sprite.y = old_y
+        
+        x_collided = any(check_sprite_polygon_collision(sprite, shape) for shape in shapes)
+        
+        if x_collided:
+            sprite.x = old_x
+            result.hit_wall_x = True
+        
+        
+        sprite.x = old_x
+        sprite.y = old_y + delta_y
+        
+        y_collided = any(check_sprite_polygon_collision(sprite, shape) for shape in shapes)
+        
+        if y_collided:
+            sprite.y = old_y
+            result.hit_wall_y = True
+        
+        
+        if not x_collided:
+            sprite.x = old_x + delta_x
+        if not y_collided:
+            sprite.y = old_y + delta_y
+        
+        result.final_x = sprite.x
+        result.final_y = sprite.y
+        
+        
+        if x_collided and not y_collided:
+            result.slide_vector = (0, delta_y)
+        elif y_collided and not x_collided:
+            result.slide_vector = (delta_x, 0)
+        
+        return result
+    
+    def move_platformer(
+        self,
+        sprite: ICollidableSprite,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        dt: float,
+        input_x: float = 0.0,
+        jump_pressed: bool = False
+    ) -> CollisionResult:
+        """
+        Move sprite with platformer physics (gravity, jumping).
+        
+        Best for side-scrolling platformer games.
+        
+        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
+            
+        Returns:
+            CollisionResult with final position and collision info
+        """
+        result = CollisionResult(final_x=sprite.x, final_y=sprite.y)
+        
+        
+        if not getattr(sprite, 'on_ground', False):
+            sprite.vy += self.gravity * dt
+            sprite.vy = min(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
+        
+        
+        sprite.x += delta_x
+        shapes = self.get_nearby_tile_shapes(tileset_collision, tile_map, sprite)
+        
+        if any(check_sprite_polygon_collision(sprite, shape) for shape in shapes):
+            sprite.x = old_x
+            sprite.vx = 0
+            result.hit_wall_x = True
+        
+        
+        sprite.y += delta_y
+        shapes = self.get_nearby_tile_shapes(tileset_collision, tile_map, sprite)
+        
+        collided_y = False
+        
+        for shape in shapes:
+            if check_sprite_polygon_collision(sprite, shape):
+                if shape.one_way and sprite.vy > 0:
+                    if old_y + get_shape_bounds(sprite)[3] - old_y <= min(v[1] for v in shape.vertices):
+                        collided_y = True
+                        break
+        
+        if collided_y:
+            sprite.y = old_y
+            
+            if sprite.vy > 0:  
+                sprite.vy = 0
+                sprite.on_ground = True
+                result.on_ground = True
+            elif sprite.vy < 0:  
+                sprite.vy = 0
+                result.hit_ceiling = True
+        else:
+            sprite.on_ground = False
+        
+        result.final_x = sprite.x
+        result.final_y = sprite.y
+        result.collided = result.hit_wall_x or collided_y
+        
+        return result
+    
+    def move_rpg(
+        self,
+        sprite: ICollidableSprite,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        delta_x: float,
+        delta_y: float
+    ) -> CollisionResult:
+        """
+        Move sprite with RPG-style blocking (no sliding).
+        
+        Best for grid-based RPG games where movement is blocked by walls.
+        
+        Args:
+            sprite: Sprite to move
+            tileset_collision: Tileset collision data
+            tile_map: Dictionary mapping (tile_x, tile_y) to tile_id
+            delta_x: X movement amount
+            delta_y: Y movement amount
+            
+        Returns:
+            CollisionResult with final position and collision info
+        """
+        result = CollisionResult(final_x=sprite.x, final_y=sprite.y)
+        
+        if delta_x == 0 and delta_y == 0:
+            return result
+        
+        
+        old_x, old_y = sprite.x, sprite.y
+        sprite.x += delta_x
+        sprite.y += delta_y
+        
+        shapes = self.get_nearby_tile_shapes(tileset_collision, tile_map, sprite)
+        
+        
+        collided = any(check_sprite_polygon_collision(sprite, shape) for shape in shapes)
+        
+        if collided:
+            
+            sprite.x = old_x
+            sprite.y = old_y
+            result.collided = True
+            result.hit_wall_x = delta_x != 0
+            result.hit_wall_y = delta_y != 0
+        else:
+            result.final_x = sprite.x
+            result.final_y = sprite.y
+        
+        return result
+    
+    def move(
+        self,
+        sprite: ICollidableSprite,
+        tileset_collision: TilesetCollision,
+        tile_map: dict,
+        delta_x: float = 0.0,
+        delta_y: float = 0.0,
+        dt: float = 0.016,
+        **kwargs
+    ) -> CollisionResult:
+        """
+        Move sprite using configured movement mode.
+        
+        This is a convenience method that calls the appropriate movement function
+        based on the runner's mode.
+        
+        Args:
+            sprite: Sprite to move
+            tileset_collision: Tileset collision data
+            tile_map: Dictionary mapping (tile_x, tile_y) to tile_id
+            delta_x: X movement amount (for slide/rpg modes)
+            delta_y: Y movement amount (for slide/rpg modes)
+            dt: Delta time in seconds (for platformer mode)
+            **kwargs: Additional mode-specific arguments
+            
+        Returns:
+            CollisionResult with final position and collision info
+        """
+        if self.mode == MovementMode.SLIDE:
+            return self.move_and_slide(sprite, tileset_collision, tile_map, delta_x, delta_y)
+        elif self.mode == MovementMode.PLATFORMER:
+            return self.move_platformer(
+                sprite, tileset_collision, tile_map, dt,
+                input_x=kwargs.get('input_x', 0.0),
+                jump_pressed=kwargs.get('jump_pressed', False)
+            )
+        elif self.mode == MovementMode.RPG:
+            return self.move_rpg(sprite, tileset_collision, tile_map, delta_x, delta_y)
+        
+        return CollisionResult(final_x=sprite.x, final_y=sprite.y)

{tilemap_parser-1.0.0 → tilemap_parser-1.1.0}/src/tilemap_parser/map_parse.py

@@ -81,7 +81,9 @@ def _optional_dict(value: Any, path: str) -> Optional[JsonDict]:
 def _parse_point(text: str, path: str) -> Point:
     if not isinstance(text, str):
         raise MapParseError(_ctx(path, "expected point string"))
-    matched = re.search(rf"(-?\d+)[{re.escape(string.punctuation)}](-?\d+)$", text.strip())
+    matched = re.search(
+        rf"(-?\d+)[{re.escape(string.punctuation)}](-?\d+)$", text.strip()
+    )
     if matched is None:
         raise MapParseError(_ctx(path, f"invalid point {text!r}"))
     return int(matched.group(1)), int(matched.group(2))
@@ -224,7 +226,9 @@ def _parse_objects(objs_obj: JsonDict, ctx: str) -> Dict[int, ParsedObject]:
         area_dict = _require_dict(obj_dict.get("area"), f"{ctx}.{key}.area")
         area = _parse_object_area(area_dict, f"{ctx}.{key}.area")
         ttype = _coerce_int(obj_dict.get("ttype"), f"{ctx}.{key}.ttype")
-        tileset_type = _require_str(obj_dict.get("tileset_type", "object"), f"{ctx}.{key}.tileset_type")
+        tileset_type = _require_str(
+            obj_dict.get("tileset_type", "object"), f"{ctx}.{key}.tileset_type"
+        )
         variant = _coerce_int(obj_dict.get("variant"), f"{ctx}.{key}.variant")
         props = _optional_dict(obj_dict.get("properties"), f"{ctx}.{key}.properties")
         result[oid] = ParsedObject(
@@ -246,14 +250,22 @@ def _parse_layer(layer_obj: JsonDict, layer_id: int, ctx: str) -> ParsedLayer:
         locked=_coerce_bool(layer_obj.get("locked", False), f"{ctx}.locked"),
         opacity=_coerce_float(layer_obj.get("opacity", 1.0), f"{ctx}.opacity"),
         z_index=_coerce_int(layer_obj.get("z_index", layer_id), f"{ctx}.z_index"),
-        properties=_optional_dict(layer_obj.get("properties"), f"{ctx}.properties") or {},
+        properties=_optional_dict(layer_obj.get("properties"), f"{ctx}.properties")
+        or {},
+    )
+    layer.tiles = _parse_tiles(
+        _require_dict(layer_obj.get("tiles", {}), f"{ctx}.tiles"), f"{ctx}.tiles"
     )
-    layer.tiles = _parse_tiles(_require_dict(layer_obj.get("tiles", {}), f"{ctx}.tiles"), f"{ctx}.tiles")
 
     if layer.layer_type == "object":
-        layer.objects = _parse_objects(_require_dict(layer_obj.get("objects", {}), f"{ctx}.objects"), f"{ctx}.objects")
+        layer.objects = _parse_objects(
+            _require_dict(layer_obj.get("objects", {}), f"{ctx}.objects"),
+            f"{ctx}.objects",
+        )
         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")
+            layer.next_object_id = _coerce_int(
+                layer_obj["next_object_id"], f"{ctx}.next_object_id"
+            )
     return layer
 
 
@@ -264,13 +276,24 @@ def _parse_rule(rule_obj: JsonDict, ctx: str) -> ParsedAutotileRule:
         pair_list = _require_list(pair, f"{ctx}.neighbors[{idx}]")
         if len(pair_list) != 2:
             raise MapParseError(_ctx(f"{ctx}.neighbors[{idx}]", "expected [x, y]"))
-        neighbors.append((_coerce_int(pair_list[0], f"{ctx}.neighbors[{idx}][0]"), _coerce_int(pair_list[1], f"{ctx}.neighbors[{idx}][1]")))
+        neighbors.append(
+            (
+                _coerce_int(pair_list[0], f"{ctx}.neighbors[{idx}][0]"),
+                _coerce_int(pair_list[1], f"{ctx}.neighbors[{idx}][1]"),
+            )
+        )
 
     variants_raw = _require_list(rule_obj.get("variant_ids", []), f"{ctx}.variant_ids")
-    variant_ids = [_coerce_int(v, f"{ctx}.variant_ids[{i}]") for i, v in enumerate(variants_raw)]
+    variant_ids = [
+        _coerce_int(v, f"{ctx}.variant_ids[{i}]") for i, v in enumerate(variants_raw)
+    ]
     tileset_path = _require_str(rule_obj.get("tileset_path", ""), f"{ctx}.tileset_path")
     tileset_index_raw = rule_obj.get("tileset_index")
-    tileset_index = _coerce_int(tileset_index_raw, f"{ctx}.tileset_index") if tileset_index_raw is not None else None
+    tileset_index = (
+        _coerce_int(tileset_index_raw, f"{ctx}.tileset_index")
+        if tileset_index_raw is not None
+        else None
+    )
     return ParsedAutotileRule(
         name=_require_str(rule_obj.get("name"), f"{ctx}.name"),
         neighbors=neighbors,
@@ -284,8 +307,13 @@ def _parse_rule(rule_obj: JsonDict, ctx: str) -> ParsedAutotileRule:
 
 def _parse_group(group_obj: JsonDict, ctx: str) -> ParsedAutotileGroup:
     rules_raw = _require_list(group_obj.get("rules", []), f"{ctx}.rules")
-    rules = [_parse_rule(_require_dict(r, f"{ctx}.rules[{i}]"), f"{ctx}.rules[{i}]") for i, r in enumerate(rules_raw)]
-    return ParsedAutotileGroup(name=_require_str(group_obj.get("name"), f"{ctx}.name"), rules=rules)
+    rules = [
+        _parse_rule(_require_dict(r, f"{ctx}.rules[{i}]"), f"{ctx}.rules[{i}]")
+        for i, r in enumerate(rules_raw)
+    ]
+    return ParsedAutotileGroup(
+        name=_require_str(group_obj.get("name"), f"{ctx}.name"), rules=rules
+    )
 
 
 def _parse_tilesets_list(tilesets_raw: List[Any], ctx: str) -> List[ParsedTileset]:
@@ -303,8 +331,14 @@ def _parse_tilesets_list(tilesets_raw: List[Any], ctx: str) -> List[ParsedTilese
         if raw_tile_props is not None:
             tp_obj = _require_dict(raw_tile_props, f"{ctx}[{i}].tile_properties")
             for k, v in tp_obj.items():
-                tile_props[str(k)] = _require_dict(v, f"{ctx}[{i}].tile_properties[{k!r}]")
-        out.append(ParsedTileset(path=path, type=ts_type, properties=props, tile_properties=tile_props))
+                tile_props[str(k)] = _require_dict(
+                    v, f"{ctx}[{i}].tile_properties[{k!r}]"
+                )
+        out.append(
+            ParsedTileset(
+                path=path, type=ts_type, properties=props, tile_properties=tile_props
+            )
+        )
     return out
 
 
@@ -341,9 +375,17 @@ def parse_map_dict(root: JsonDict) -> ParsedMap:
     root = _require_dict(root, "root")
     meta_obj = _require_dict(root.get("meta"), "meta")
     tile_size = _parse_point_field(meta_obj.get("tile_size"), "meta.tile_size")
-    map_size = _parse_point_field(meta_obj.get("map_size"), "meta.map_size", default=f"{tile_size[0]};{tile_size[1]}")
+    map_size = _parse_point_field(
+        meta_obj.get("map_size"),
+        "meta.map_size",
+        default=f"{tile_size[0]};{tile_size[1]}",
+    )
     init_raw = meta_obj.get("initial_map_size")
-    initial_map_size = map_size if init_raw is None else _parse_point_field(init_raw, "meta.initial_map_size")
+    initial_map_size = (
+        map_size
+        if init_raw is None
+        else _parse_point_field(init_raw, "meta.initial_map_size")
+    )
 
     meta = ParsedMeta(
         tile_size=tile_size,
@@ -360,7 +402,9 @@ def parse_map_dict(root: JsonDict) -> ParsedMap:
         layers: List[ParsedLayer] = []
     else:
         layers = [
-            _parse_layer(_require_dict(layer, f"data.layers[{i}]"), i, f"data.layers[{i}]")
+            _parse_layer(
+                _require_dict(layer, f"data.layers[{i}]"), i, f"data.layers[{i}]"
+            )
             for i, layer in enumerate(_require_list(layers_raw, "data.layers"))
         ]
     if not layers:
@@ -368,17 +412,35 @@ def parse_map_dict(root: JsonDict) -> ParsedMap:
 
     project_obj = _require_dict(root.get("project_state", {}), "project_state")
     rules = [
-        _parse_rule(_require_dict(rule, f"project_state.rules[{i}]"), f"project_state.rules[{i}]")
-        for i, rule in enumerate(_require_list(project_obj.get("rules", []), "project_state.rules"))
+        _parse_rule(
+            _require_dict(rule, f"project_state.rules[{i}]"),
+            f"project_state.rules[{i}]",
+        )
+        for i, rule in enumerate(
+            _require_list(project_obj.get("rules", []), "project_state.rules")
+        )
     ]
     groups = [
-        _parse_group(_require_dict(group, f"project_state.groups[{i}]"), f"project_state.groups[{i}]")
-        for i, group in enumerate(_require_list(project_obj.get("groups", []), "project_state.groups"))
+        _parse_group(
+            _require_dict(group, f"project_state.groups[{i}]"),
+            f"project_state.groups[{i}]",
+        )
+        for i, group in enumerate(
+            _require_list(project_obj.get("groups", []), "project_state.groups")
+        )
     ]
-    project_state = ParsedProjectState(rules=rules, groups=groups, automap_rules=project_obj.get("automap_rules"))
+    project_state = ParsedProjectState(
+        rules=rules, groups=groups, automap_rules=project_obj.get("automap_rules")
+    )
 
     tilesets = _parse_resources(root.get("resources", {}), "resources")
-    return ParsedMap(meta=meta, layers=layers, tilesets=tilesets, project_state=project_state, raw=root)
+    return ParsedMap(
+        meta=meta,
+        layers=layers,
+        tilesets=tilesets,
+        project_state=project_state,
+        raw=root,
+    )
 
 
 def parse_map_json(text: str) -> ParsedMap:

{tilemap_parser-1.0.0 → tilemap_parser-1.1.0}/src/tilemap_parser/renderer.py

@@ -16,10 +16,17 @@ class LayerRenderStats:
 
 
 class TileLayerRenderer:
-    def __init__(self, data: TilemapData, *, include_hidden_layers: bool = False) -> None:
+    def __init__(
+        self, data: TilemapData, *, include_hidden_layers: bool = False
+    ) -> None:
         self.data = data
-        self.tile_layers = data.get_tile_layers_dict(include_hidden=include_hidden_layers)
-        self._sorted_layer_ids = sorted(self.tile_layers.keys(), key=lambda lid: (self.tile_layers[lid].z_index, lid))
+        self.tile_layers = data.get_tile_layers_dict(
+            include_hidden=include_hidden_layers
+        )
+        self._sorted_layer_ids = sorted(
+            self.tile_layers.keys(),
+            key=lambda lid: (self.tile_layers[lid].z_index, lid),
+        )
         self._variant_cache: Dict[Tuple[int, int], Optional[Surface]] = {}
         self._tile_w, self._tile_h = data.tile_size
 
@@ -29,7 +36,9 @@ class TileLayerRenderer:
     def _get_cached_variant(self, ttype: int, variant: int) -> Optional[Surface]:
         key = (ttype, variant)
         if key not in self._variant_cache:
-            self._variant_cache[key] = self.data.get_tile_surface(ttype, variant, copy_surface=True)
+            self._variant_cache[key] = self.data.get_tile_surface(
+                ttype, variant, copy_surface=True
+            )
         return self._variant_cache[key]
 
     def warm_cache(self) -> None:
@@ -38,6 +47,7 @@ class TileLayerRenderer:
             for tile in layer.tiles.values():
                 if isinstance(tile.ttype, int):
                     self._get_cached_variant(tile.ttype, tile.variant)
+        self.data = None
 
     def render(
         self,
@@ -79,4 +89,6 @@ class TileLayerRenderer:
                 target.blit(cell, (x * self._tile_w - cam_x, y * self._tile_h - cam_y))
                 drawn += 1
 
-        return LayerRenderStats(drawn_tiles=drawn, skipped_tiles=skipped, visible_layers=visible_layers)
+        return LayerRenderStats(
+            drawn_tiles=drawn, skipped_tiles=skipped, visible_layers=visible_layers
+        )

{tilemap_parser-1.0.0 → tilemap_parser-1.1.0/src/tilemap_parser.egg-info}/PKG-INFO

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

@@ -3,6 +3,8 @@ README.md
 pyproject.toml
 src/tilemap_parser/__init__.py
 src/tilemap_parser/animation.py
+src/tilemap_parser/collision.py
+src/tilemap_parser/collision_runner.py
 src/tilemap_parser/map_loader.py
 src/tilemap_parser/map_parse.py
 src/tilemap_parser/renderer.py