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

{tilemap_parser-1.0.1/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.1
+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.1 → tilemap_parser-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "1.0.1"
+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.1 → 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.1 → 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.1
+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.1 → 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