tilemap-parser 3.1.9__tar.gz → 3.1.12__tar.gz

{tilemap_parser-3.1.9 → tilemap_parser-3.1.12}/PKG-INFO

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

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

@@ -45,6 +45,15 @@ __all__ = [
     "TileLayerRenderer",
     "TilesetCollision",
     "TilemapData",
+    "Particle",
+    "ParticleEmitter",
+    "ParticleRenderer",
+    "ParticleSystem",
+    "ParticleSystemConfig",
+    "SpriteBatchRenderer",
+    "clear_texture_caches",
+    "parse_particle_dict",
+    "parse_particle_file",
     "aabb_overlap",
     "check_collision",
     "circle_vs_circle",

{tilemap_parser-3.1.9 → tilemap_parser-3.1.12}/src/tilemap_parser/parser/__init__.py

@@ -46,6 +46,14 @@ from .map_parse import (
     parse_map_json,
 )
 from .node_parse import ParsedNode, parse_nodes_dict, parse_nodes_file
+from .particle import (
+    ALPHA_FADE_MODES,
+    EMISSION_SHAPES,
+    PARTICLE_SHAPES,
+    ParticleSystemConfig,
+    parse_particle_dict,
+    parse_particle_file,
+)
 
 __all__ = [
     "AnimationClip",
@@ -90,4 +98,10 @@ __all__ = [
     "parse_nodes_file",
     "parse_object_collision",
     "parse_tileset_collision",
+    "ALPHA_FADE_MODES",
+    "EMISSION_SHAPES",
+    "PARTICLE_SHAPES",
+    "ParticleSystemConfig",
+    "parse_particle_dict",
+    "parse_particle_file",
 ]

tilemap_parser-3.1.12/src/tilemap_parser/parser/particle.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from .map_parse import (
+    JsonDict,
+    MapParseError,
+    _coerce_float,
+    _coerce_int,
+    _optional_dict,
+    _require_dict,
+    _require_list,
+    _require_str,
+    _ctx,
+)
+
+
+EMISSION_SHAPES = ["point", "rect", "circle", "line"]
+PARTICLE_SHAPES = ["circle", "square", "diamond", "star", "sparkle", "smoke", "heart", "line"]
+ALPHA_FADE_MODES = ["none", "fade_out", "fade_in", "fade_both"]
+
+
+@dataclass
+class ParticleSystemConfig:
+    name: str
+    emission_shape: str = "point"
+    particle_shape: str = "circle"
+    particle_size_min: int = 2
+    particle_size_max: int = 6
+    spawn_rate: int = 20
+    max_particles: int = 100
+    lifetime_min: float = 0.5
+    lifetime_max: float = 2.0
+    speed_min: float = 20.0
+    speed_max: float = 60.0
+    direction: float = -1.0
+    spread: float = 45.0
+    gravity_x: float = 0.0
+    gravity_y: float = 30.0
+    start_color_r: int = 255
+    start_color_g: int = 200
+    start_color_b: int = 100
+    start_color_a: int = 255
+    end_color_r: int = 255
+    end_color_g: int = 100
+    end_color_b: int = 50
+    end_color_a: int = 0
+    start_scale: float = 1.0
+    end_scale: float = 0.3
+    rotation_speed: float = 0.0
+    alpha_fade: str = "fade_out"
+
+    def to_dict(self) -> JsonDict:
+        return {
+            "emission_shape": self.emission_shape,
+            "particle_shape": self.particle_shape,
+            "particle_size_min": self.particle_size_min,
+            "particle_size_max": self.particle_size_max,
+            "spawn_rate": self.spawn_rate,
+            "max_particles": self.max_particles,
+            "lifetime_min": self.lifetime_min,
+            "lifetime_max": self.lifetime_max,
+            "speed_min": self.speed_min,
+            "speed_max": self.speed_max,
+            "direction": self.direction,
+            "spread": self.spread,
+            "gravity_x": self.gravity_x,
+            "gravity_y": self.gravity_y,
+            "start_color_r": self.start_color_r,
+            "start_color_g": self.start_color_g,
+            "start_color_b": self.start_color_b,
+            "start_color_a": self.start_color_a,
+            "end_color_r": self.end_color_r,
+            "end_color_g": self.end_color_g,
+            "end_color_b": self.end_color_b,
+            "end_color_a": self.end_color_a,
+            "start_scale": self.start_scale,
+            "end_scale": self.end_scale,
+            "rotation_speed": self.rotation_speed,
+            "alpha_fade": self.alpha_fade,
+        }
+
+    @classmethod
+    def from_dict(cls, d: JsonDict, name: str = "") -> "ParticleSystemConfig":
+        def g(key: str, default: Any = 0) -> Any:
+            return d.get(key, default)
+
+        cfg = cls(name=name)
+        cfg.emission_shape = str(g("emission_shape", "point"))
+        if cfg.emission_shape not in EMISSION_SHAPES:
+            cfg.emission_shape = "point"
+        cfg.particle_shape = str(g("particle_shape", "circle"))
+        if cfg.particle_shape not in PARTICLE_SHAPES:
+            cfg.particle_shape = "circle"
+        cfg.alpha_fade = str(g("alpha_fade", "fade_out"))
+        if cfg.alpha_fade not in ALPHA_FADE_MODES:
+            cfg.alpha_fade = "fade_out"
+        cfg.particle_size_min = max(1, int(g("particle_size_min", 2)))
+        cfg.particle_size_max = max(cfg.particle_size_min, int(g("particle_size_max", 6)))
+        cfg.spawn_rate = max(1, int(g("spawn_rate", 20)))
+        cfg.max_particles = max(1, int(g("max_particles", 100)))
+        cfg.lifetime_min = max(0.1, float(g("lifetime_min", 0.5)))
+        cfg.lifetime_max = max(cfg.lifetime_min, float(g("lifetime_max", 2.0)))
+        cfg.speed_min = max(0.0, float(g("speed_min", 20)))
+        cfg.speed_max = max(cfg.speed_min, float(g("speed_max", 60)))
+        cfg.direction = float(g("direction", -1))
+        cfg.spread = max(0.0, min(360.0, float(g("spread", 45))))
+        cfg.gravity_x = float(g("gravity_x", 0))
+        cfg.gravity_y = float(g("gravity_y", 30))
+        cfg.start_color_r = max(0, min(255, int(g("start_color_r", 255))))
+        cfg.start_color_g = max(0, min(255, int(g("start_color_g", 200))))
+        cfg.start_color_b = max(0, min(255, int(g("start_color_b", 100))))
+        cfg.start_color_a = max(0, min(255, int(g("start_color_a", 255))))
+        cfg.end_color_r = max(0, min(255, int(g("end_color_r", 255))))
+        cfg.end_color_g = max(0, min(255, int(g("end_color_g", 100))))
+        cfg.end_color_b = max(0, min(255, int(g("end_color_b", 50))))
+        cfg.end_color_a = max(0, min(255, int(g("end_color_a", 0))))
+        cfg.start_scale = max(0.1, float(g("start_scale", 1.0)))
+        cfg.end_scale = max(0.1, float(g("end_scale", 0.3)))
+        cfg.rotation_speed = float(g("rotation_speed", 0))
+        return cfg
+
+
+def _parse_system(raw: Any, ctx: str) -> ParticleSystemConfig:
+    d = _require_dict(raw, ctx)
+    name = str(d.get("name", ""))
+    cfg_raw = _optional_dict(d.get("config"), f"{ctx}.config")
+    if cfg_raw is None:
+        cfg_raw = {}
+    return ParticleSystemConfig.from_dict(cfg_raw, name=name)
+
+
+def parse_particle_dict(root: JsonDict) -> List[ParticleSystemConfig]:
+    root = _require_dict(root, "root")
+    raw_systems = _require_list(root.get("particle_systems", []), "root.particle_systems")
+    return [_parse_system(item, f"root.particle_systems[{i}]") for i, item in enumerate(raw_systems)]
+
+
+def parse_particle_file(path: Union[str, Path]) -> List[ParticleSystemConfig]:
+    p = Path(path)
+    if not p.is_file():
+        raise MapParseError(f"Not a file: {p}")
+    try:
+        text = p.read_text(encoding="utf-8")
+    except OSError as e:
+        raise MapParseError(f"Cannot read {p}: {e}") from e
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError as e:
+        raise MapParseError(f"Invalid JSON in {p}: {e}") from e
+    return parse_particle_dict(payload)

{tilemap_parser-3.1.9 → tilemap_parser-3.1.12}/src/tilemap_parser/runtime/__init__.py

@@ -24,6 +24,15 @@ from .object_collision import (
 )
 from .renderer import LayerRenderStats, TileLayerRenderer
 from .area_node import AreaNode
+from .particles import (
+    Particle,
+    ParticleEmitter,
+    ParticleEmitterNode,
+    ParticleRenderer,
+    ParticleSystem,
+    SpriteBatchRenderer,
+    clear_texture_caches,
+)
 
 __all__ = [
     "AnimationPlayer",
@@ -49,4 +58,11 @@ __all__ = [
     "load_map",
     "load_object_collision",
     "load_tileset_collision",
+    "Particle",
+    "ParticleEmitter",
+    "ParticleEmitterNode",
+    "ParticleRenderer",
+    "ParticleSystem",
+    "SpriteBatchRenderer",
+    "clear_texture_caches",
 ]

{tilemap_parser-3.1.9 → tilemap_parser-3.1.12}/src/tilemap_parser/runtime/map_loader.py

@@ -10,6 +10,8 @@ from pygame import Rect, Surface
 
 from ..parser.map_parse import MapParseError, ParsedLayer, ParsedMap, ParsedTile, parse_map_file
 from ..parser.node_parse import parse_nodes_dict
+from .area_node import AreaNode
+from .particles import ParticleEmitterNode
 
 PathLike = Union[str, Path]
 
@@ -29,6 +31,8 @@ class TilemapData:
         self.resolved_paths = resolved_paths
         self.warnings = warnings
         self.map_path = map_path
+        self.area_nodes: List[AreaNode] = []
+        self.particle_emitters: List[ParticleEmitterNode] = []
         self._tw, self._th = parsed.meta.tile_size
         self._build_path_index()
         self._normalize_tile_ttypes()
@@ -40,6 +44,7 @@ class TilemapData:
         *,
         extra_search_base: Optional[Path] = None,
         skip_missing_images: bool = True,
+        nodes_dir: Optional[PathLike] = None,
     ) -> "TilemapData":
         p = Path(path)
         parsed = parse_map_file(p)
@@ -69,12 +74,16 @@ class TilemapData:
                 surfaces.append(None)
 
         nodes_name = f"{p.stem}.nodes.json"
-        nodes_candidates = [
-            map_dir / nodes_name,
-            map_dir.parent / "nodes" / nodes_name,
-        ]
-        if extra_search_base is not None:
-            nodes_candidates.append(extra_search_base / "nodes" / nodes_name)
+        nodes_candidates: List[Path] = []
+        if nodes_dir is not None:
+            nodes_candidates.append(Path(nodes_dir) / nodes_name)
+        else:
+            nodes_candidates = [
+                map_dir / nodes_name,
+                map_dir.parent / "nodes" / nodes_name,
+            ]
+            if extra_search_base is not None:
+                nodes_candidates.append(extra_search_base / "nodes" / nodes_name)
         for nodes_path in nodes_candidates:
             if nodes_path.is_file():
                 try:
@@ -89,7 +98,12 @@ class TilemapData:
                     warnings.append(f"Failed to load nodes: {e}")
                 break
 
-        return cls(parsed, surfaces, resolved_paths, warnings, map_path=p)
+        result = cls(parsed, surfaces, resolved_paths, warnings, map_path=p)
+        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"
+        ]
+        return result
 
     def _build_path_index(self) -> None:
         self._path_to_index: Dict[str, int] = {}
@@ -246,5 +260,5 @@ def _resolve_resource_path(path_str: str, map_dir: Path, extra_search_base: Opti
     return candidate
 
 
-def load_map(path: PathLike, *, extra_search_base: Optional[Path] = None, skip_missing_images: bool = True) -> TilemapData:
-    return TilemapData.load(path, extra_search_base=extra_search_base, skip_missing_images=skip_missing_images)
+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)