tilemap-parser 5.0.3__tar.gz → 5.1.0__tar.gz

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "5.0.3"
+version = "5.1.0"
 description = "Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime."
 readme = "pypi-readme.md"
 requires-python = ">=3.10"

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/parser/collision.py

@@ -9,6 +9,7 @@ Provides parsing of collision data from JSON into data classes:
 
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -34,6 +35,13 @@ class CollisionPolygon:
         world_vertices = [(tile_x + vx * scale, tile_y + vy * scale) for vx, vy in self.vertices]
         return CollisionPolygon(vertices=world_vertices, one_way=self.one_way)
 
+    def scaled(self, scale: float) -> "CollisionPolygon":
+        """Return a copy with all vertices multiplied by *scale*."""
+        return CollisionPolygon(
+            vertices=[(vx * scale, vy * scale) for vx, vy in self.vertices],
+            one_way=self.one_way,
+        )
+
     def is_valid(self) -> bool:
         """Check if polygon has at least 3 vertices"""
         return len(self.vertices) >= 3
@@ -130,6 +138,14 @@ class RectangleShape:
         top = y + self.offset[1]
         return (left, top, left + self.width, top + self.height)
 
+    def scaled(self, scale: float) -> "RectangleShape":
+        """Return a copy with dimensions and offset multiplied by *scale*."""
+        return RectangleShape(
+            width=self.width * scale,
+            height=self.height * scale,
+            offset=(self.offset[0] * scale, self.offset[1] * scale),
+        )
+
 
 @dataclass
 class CircleShape:
@@ -142,6 +158,13 @@ class CircleShape:
         """Get center position in world space"""
         return (x + self.offset[0], y + self.offset[1])
 
+    def scaled(self, scale: float) -> "CircleShape":
+        """Return a copy with radius and offset multiplied by *scale*."""
+        return CircleShape(
+            radius=self.radius * scale,
+            offset=(self.offset[0] * scale, self.offset[1] * scale),
+        )
+
 
 @dataclass
 class CapsuleShape:
@@ -159,6 +182,14 @@ class CapsuleShape:
         """Get bottom circle center in world space"""
         return (x + self.offset[0], y + self.offset[1] + self.height)
 
+    def scaled(self, scale: float) -> "CapsuleShape":
+        """Return a copy with radius, height, and offset multiplied by *scale*."""
+        return CapsuleShape(
+            radius=self.radius * scale,
+            height=self.height * scale,
+            offset=(self.offset[0] * scale, self.offset[1] * scale),
+        )
+
 
 CharacterShapeType = Union[RectangleShape, CircleShape, CapsuleShape, CollisionPolygon]
 
@@ -173,6 +204,16 @@ class CharacterCollision:
     collision_layer: int = 1
     collision_mask: int = 0xFFFFFFFF
 
+    def scaled(self, scale: float) -> "CharacterCollision":
+        """Return a copy whose shape is scaled by *scale* (typically ``render_scale``)."""
+        return CharacterCollision(
+            name=self.name,
+            shape=self.shape.scaled(scale),
+            properties=dict(self.properties),
+            collision_layer=self.collision_layer,
+            collision_mask=self.collision_mask,
+        )
+
 
 @dataclass
 class ObjectCollisionRegionData:
@@ -255,19 +296,28 @@ def parse_tileset_collision(data: JsonDict) -> TilesetCollision:
         raise CollisionParseError(f"Invalid tileset collision data: {e}") from e
 
 
-def parse_character_collision(data: JsonDict) -> CharacterCollision:
+def parse_character_collision(data: JsonDict, render_scale: float = 1.0) -> CharacterCollision:
     """
     Parse character collision data from dictionary.
 
     Args:
         data: Dictionary loaded from .collision.json file
+        render_scale: Multiplier applied to shape dimensions and offsets
+            (no-op when 1.0).
 
     Returns:
         CharacterCollision object
 
     Raises:
-        CollisionParseError: If data format is invalid
+        CollisionParseError: If data format is invalid or render_scale is not
+            finite and greater than zero.
     """
+    if (
+        not isinstance(render_scale, (int, float))
+        or not math.isfinite(render_scale)
+        or render_scale <= 0
+    ):
+        raise CollisionParseError(f"render_scale must be finite and > 0, got {render_scale!r}")
     try:
         name = data["name"]
         shape_data = data["shape"]
@@ -312,7 +362,7 @@ def parse_character_collision(data: JsonDict) -> CharacterCollision:
             properties=properties,
             collision_layer=collision_layer,
             collision_mask=collision_mask,
-        )
+        ).scaled(render_scale)
     except (KeyError, ValueError, TypeError) as e:
         raise CollisionParseError(f"Invalid character collision data: {e}") from e
 

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/parser/collision_loader.py

@@ -55,6 +55,7 @@ def load_tileset_collision(
 
 def load_character_collision(
     collision_path: Union[str, Path],
+    render_scale: float = 1.0,
 ) -> CharacterCollision | None:
     """
     Load character collision data from a collision JSON file.
@@ -64,6 +65,8 @@ def load_character_collision(
 
     Args:
         collision_path: Direct path to the .collision.json file.
+        render_scale: Multiplier applied to shape dimensions and offsets
+            (no-op when 1.0).
 
     Returns:
         CharacterCollision object, or None if the file does not exist.
@@ -79,7 +82,7 @@ def load_character_collision(
     try:
         with open(collision_path, "r", encoding="utf-8") as f:
             data = json.load(f)
-        return parse_character_collision(data)
+        return parse_character_collision(data, render_scale=render_scale)
     except (OSError, UnicodeDecodeError, json.JSONDecodeError) as e:
         raise CollisionParseError(f"Cannot load {collision_path}: {e}") from e
 

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/animation_player.py

@@ -20,6 +20,9 @@ class SpriteAnimationSet:
     json_path: Optional[Path] = None
     grid_offset_x: int = 0
     grid_offset_y: int = 0
+    render_scale: float = 1.0
+    grid_columns: int = 0
+    grid_rows: int = 0
 
     @classmethod
     def load(
@@ -28,6 +31,7 @@ class SpriteAnimationSet:
         *,
         spritesheet_path: Optional[PathLike] = None,
         extra_search_base: Optional[Path] = None,
+        render_scale: float = 1.0,
     ) -> "SpriteAnimationSet":
         path = Path(json_path)
         library = parse_animation_file(path)
@@ -59,6 +63,29 @@ class SpriteAnimationSet:
         except pygame.error as e:
             raise AnimationParseError(f"Failed to load image {image_path}: {e}") from e
 
+        tw, th = library.tile_size
+        ox, oy = library.grid_offset
+        grid_columns = max(1, (surface.get_width() - ox) // tw)
+        grid_rows = max(1, (surface.get_height() - oy) // th)
+
+        if render_scale != 1.0:
+            if render_scale <= 0:
+                raise ValueError(f"render_scale must be > 0, got {render_scale}")
+            w, h = surface.get_size()
+            sw, sh = int(w * render_scale), int(h * render_scale)
+            stw, sth = int(tw * render_scale), int(th * render_scale)
+            if sw < 1 or sh < 1 or stw < 1 or sth < 1:
+                raise ValueError(f"render_scale {render_scale} produces zero-sized atlas cells")
+            if (
+                int(ox * render_scale) + grid_columns * stw > sw
+                or int(oy * render_scale) + grid_rows * sth > sh
+            ):
+                raise ValueError(
+                    f"render_scale {render_scale} cannot maintain atlas grid cell bounds"
+                )
+            surface = pygame.transform.scale(surface, (sw, sh))
+            library = _scaled_library(library, render_scale)
+
         return cls(
             library=library,
             surface=surface,
@@ -66,6 +93,9 @@ class SpriteAnimationSet:
             json_path=path,
             grid_offset_x=library.grid_offset[0],
             grid_offset_y=library.grid_offset[1],
+            render_scale=render_scale,
+            grid_columns=grid_columns,
+            grid_rows=grid_rows,
         )
 
     def get_content_bounds(self, clip_name: str) -> Optional[Rect]:
@@ -88,15 +118,10 @@ class SpriteAnimationSet:
 
     def get_image(self, variant_id: int, *, copy_surface: bool = True) -> Optional[Surface]:
         tw, th = self.library.tile_size
-        if tw <= 0 or th <= 0:
-            return None
-        available_w = self.surface.get_width() - self.grid_offset_x
-        available_h = self.surface.get_height() - self.grid_offset_y
-        if available_w < tw or available_h < th:
+        if tw <= 0 or th <= 0 or self.grid_columns <= 0 or self.grid_rows <= 0:
             return None
-        cols = max(1, available_w // tw)
-        col = variant_id % cols
-        row = variant_id // cols
+        col = variant_id % self.grid_columns
+        row = variant_id // self.grid_columns
         src = Rect(self.grid_offset_x + col * tw, self.grid_offset_y + row * th, tw, th)
         if not self.surface.get_rect().contains(src):
             return None
@@ -161,3 +186,19 @@ class AnimationPlayer:
         if variant not in self._frame_cache:
             self._frame_cache[variant] = self.animation_set.get_image(variant, copy_surface=True)
         return self._frame_cache[variant]
+
+
+def _scaled_library(library: AnimationLibrary, scale: float) -> AnimationLibrary:
+    """Return a copy of *library* whose grid geometry is scaled by *scale*.
+
+    Kept in lockstep with the scaled spritesheet surface so that
+    :meth:`SpriteAnimationSet.get_image` continues to address cells
+    correctly.
+    """
+    return AnimationLibrary(
+        animations=library.animations,
+        spritesheet_path=library.spritesheet_path,
+        tile_size=(int(library.tile_size[0] * scale), int(library.tile_size[1] * scale)),
+        grid_offset=(int(library.grid_offset[0] * scale), int(library.grid_offset[1] * scale)),
+        trim_transparent=library.trim_transparent,
+    )

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/collision_cache.py

@@ -8,7 +8,7 @@ repeated file I/O during runtime.
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional, Union
+from typing import Dict, Optional, Tuple, Union
 
 from ..parser.collision import (
     CharacterCollision,
@@ -39,7 +39,7 @@ class CollisionCache:
 
     def __init__(self):
         self._tileset_cache: Dict[str, Optional[TilesetCollision]] = {}
-        self._character_cache: Dict[str, Optional[CharacterCollision]] = {}
+        self._character_cache: Dict[Tuple[str, float], Optional[CharacterCollision]] = {}
         self._object_cache: Dict[str, Optional[ObjectCollisionData]] = {}
 
     def get_tileset_collision(
@@ -58,17 +58,21 @@ class CollisionCache:
         return self._tileset_cache[key]
 
     def get_character_collision(
-        self, collision_path: Union[str, Path]
+        self, collision_path: Union[str, Path], render_scale: float = 1.0
     ) -> Optional[CharacterCollision]:
         """Get character collision data (cached).
 
         Args:
             collision_path: Direct path to the .collision.json file.
+            render_scale: Multiplier applied to shape dimensions and offsets.
+                Cached per (path, render_scale) pair.
         """
-        key = str(Path(collision_path).resolve())
+        key = (str(Path(collision_path).resolve()), render_scale)
 
         if key not in self._character_cache:
-            self._character_cache[key] = load_character_collision(collision_path)
+            self._character_cache[key] = load_character_collision(
+                collision_path, render_scale=render_scale
+            )
 
         return self._character_cache[key]
 
@@ -134,13 +138,15 @@ def get_cached_tileset_collision(
 
 def get_cached_character_collision(
     collision_path: Union[str, Path],
+    render_scale: float = 1.0,
 ) -> Optional[CharacterCollision]:
     """Get character collision using global cache.
 
     Args:
         collision_path: Direct path to the .collision.json file.
+        render_scale: Multiplier applied to shape dimensions and offsets.
     """
-    return _global_cache.get_character_collision(collision_path)
+    return _global_cache.get_character_collision(collision_path, render_scale=render_scale)
 
 
 def get_cached_object_collision(

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/movement/platformer.py

@@ -8,6 +8,7 @@ from ...parser.collision import TilesetCollision
 from ..polygon_query import _check_sprite_polygon_offset, get_shape_bounds
 from ..protocols import ICollidableSprite
 from ..world import PhysicsWorld
+from .queries import _resolve_tile_data
 from .types import CollisionResult, Vector2
 
 
@@ -118,9 +119,7 @@ def move_platformer(
     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:
-                continue
-            tile_data = tileset_collision.tiles.get(tile_id)
+            tile_data = _resolve_tile_data(world, tileset_collision, tile_id)
             if tile_data is None:
                 continue
             ox = tile_x * tw

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/movement/queries.py

@@ -4,12 +4,31 @@ from __future__ import annotations
 
 import math
 
-from ...parser.collision import CollisionPolygon, TilesetCollision
+from ...parser.collision import CollisionPolygon, TileCollisionData, TilesetCollision
 from ..collision.hit import should_collide
 from ..polygon_query import _check_sprite_polygon_offset, get_shape_bounds
 from ..protocols import ICollidable, ICollidableSprite
 
 
+def _resolve_tile_data(
+    world,
+    tileset_collision: TilesetCollision,
+    tile_id: int | None,
+) -> TileCollisionData | None:
+    """Fetch collision data for *tile_id*, GID-routed when a world is attached.
+
+    With an attached world built via ``from_map(..., use_gids=True)`` the id
+    is range-routed against the map's grid resources (decoration tilesets can
+    never alias into the collision owner's local keys).  Without a world the
+    historic literal lookup applies.
+    """
+    if tile_id is None:
+        return None
+    if world is not None:
+        return world.resolve_collision(tile_id)
+    return tileset_collision.tiles.get(tile_id)
+
+
 def _collides_at(
     self,
     sprite: ICollidable,
@@ -35,9 +54,7 @@ def _collides_at(
     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:
-                continue
-            tile_data = tileset_collision.tiles.get(tile_id)
+            tile_data = _resolve_tile_data(world, tileset_collision, tile_id)
             if tile_data is None:
                 continue
             ox = tile_x * tw
@@ -72,9 +89,7 @@ def _first_colliding_shape(
     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:
-                continue
-            tile_data = tileset_collision.tiles.get(tile_id)
+            tile_data = _resolve_tile_data(world, tileset_collision, tile_id)
             if tile_data is None:
                 continue
             ox = tile_x * tw
@@ -113,9 +128,7 @@ def _collides_at_platformer(
     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:
-                continue
-            tile_data = tileset_collision.tiles.get(tile_id)
+            tile_data = _resolve_tile_data(world, tileset_collision, tile_id)
             if tile_data is None:
                 continue
             ox = tile_x * tw
@@ -218,9 +231,7 @@ def _find_walkable_ground_y(
     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:
-                continue
-            tile_data = tileset_collision.tiles.get(tile_id)
+            tile_data = _resolve_tile_data(world, tileset_collision, tile_id)
             if tile_data is None:
                 continue
             ox = tile_x * tw

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/movement/runner.py

@@ -151,13 +151,19 @@ class CollisionRunner:
         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):
+        world = self._resolve_world(None)
+        tile_data = queries._resolve_tile_data(world, tileset_collision, tile_id)
+        if tile_data is None:
             return []
 
         tile_world_x = tile_x * self._eff_tw
         tile_world_y = tile_y * self._eff_th
 
-        return tileset_collision.get_world_shapes(tile_id, tile_world_x, tile_world_y, self.render_scale)
+        return [
+            shape.transform(tile_world_x, tile_world_y, self.render_scale)
+            for shape in tile_data.shapes
+            if shape.is_valid()
+        ]
 
     def get_nearby_tile_shapes(
         self,
@@ -182,12 +188,11 @@ class CollisionRunner:
         max_tile_y = int(bottom // th) + margin
 
         shapes = []
+        world = self._resolve_world(None)
         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:
-                    continue
-                tile_data = tileset_collision.tiles.get(tile_id)
+                tile_data = queries._resolve_tile_data(world, tileset_collision, tile_id)
                 if tile_data is None:
                     continue
                 tile_world_x = tile_x * tw

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/navigation/nav_grid.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import math
 from typing import Dict, List, Optional, Tuple
 
-from ...parser.collision import TilesetCollision
+from ...parser.collision import TileCollisionData, TilesetCollision
 
 
 class NavGrid:
@@ -15,14 +15,15 @@ class NavGrid:
     """
 
     __slots__ = (
-        "tile_map",
-        "tileset_collision",
-        "tile_size",
-        "_eff_tw",
         "_eff_th",
-        "_width",
+        "_eff_tw",
+        "_gid_resolver",
         "_height",
         "_walkable",
+        "_width",
+        "tile_map",
+        "tile_size",
+        "tileset_collision",
     )
 
     def __init__(
@@ -32,9 +33,14 @@ class NavGrid:
         tile_size: Tuple[int, int],
         render_scale: float = 1.0,
         map_size: Optional[Tuple[int, int]] = None,
+        gid_resolver=None,
     ) -> None:
         self.tile_map = tile_map
         self.tileset_collision = tileset_collision
+        # Optional callable (int) -> TileCollisionData | None.  Pass
+        # ``physics_world.resolve_collision`` for GID-routed maps so ids from
+        # non-collidable grid tilesets resolve to None instead of aliasing.
+        self._gid_resolver = gid_resolver
         self.tile_size = tile_size
         self._eff_tw = tile_size[0] * render_scale
         self._eff_th = tile_size[1] * render_scale
@@ -52,11 +58,15 @@ class NavGrid:
 
         self._walkable = [[self._is_tile_walkable(x, y) for x in range(self._width)] for y in range(self._height)]
 
-    def _is_tile_walkable(self, tx: int, ty: int) -> bool:
-        tile_id = self.tile_map.get((tx, ty))
+    def _resolve(self, tile_id):
         if tile_id is None:
-            return True
-        tile_data = self.tileset_collision.tiles.get(tile_id)
+            return None
+        if self._gid_resolver is not None:
+            return self._gid_resolver(tile_id)
+        return self.tileset_collision.tiles.get(tile_id)
+
+    def _is_tile_walkable(self, tx: int, ty: int) -> bool:
+        tile_data = self._resolve(self.tile_map.get((tx, ty)))
         if tile_data is None:
             return True
         for poly in tile_data.shapes:
@@ -78,10 +88,7 @@ class NavGrid:
         return self._walkable[ty][tx]
 
     def is_one_way(self, tx: int, ty: int) -> bool:
-        tile_id = self.tile_map.get((tx, ty))
-        if tile_id is None:
-            return False
-        tile_data = self.tileset_collision.tiles.get(tile_id)
+        tile_data = self._resolve(self.tile_map.get((tx, ty)))
         if tile_data is None:
             return False
         has_one_way = False
@@ -104,6 +111,10 @@ class NavGrid:
         new._width = self._width
         new._height = self._height
         new._walkable = [row[:] for row in self._walkable]
+        # _gid_resolver lives in __slots__: dropping it here made every
+        # derived grid raise AttributeError once _resolve() ran (e.g. via
+        # is_one_way), and silently lost GID routing before that.
+        new._gid_resolver = self._gid_resolver
         return new
 
     def erode(self, margin: float) -> NavGrid:
@@ -155,16 +166,31 @@ class NavGrid:
         sprite_height: Optional[float] = None,
         render_scale: float = 1.0,
         map_size: Optional[Tuple[int, int]] = None,
-        cache: Optional[Dict[float, NavGrid]] = None,
+        cache: Optional[dict[tuple[float, bool], NavGrid]] = None,
+        gid_resolver=None,
     ) -> NavGrid:
+        """Build (or fetch from *cache*) an eroded grid for one entity size.
+
+        The cache is scoped to a single map/routing context and is keyed by
+        ``(margin, resolver_is_literal)`` so literal and GID-routed grids can
+        never cross-contaminate through a shared cache dict.
+        """
         tw = tile_size[0] * render_scale
         size = max(sprite_width, sprite_height if sprite_height is not None else sprite_width)
         margin = (size / 2.0) / tw
-        if cache is not None and margin in cache:
-            return cache[margin]
-        nav = cls(tile_map, tileset_collision, tile_size, render_scale, map_size).erode(margin)
+        key = (margin, gid_resolver is None)
+        if cache is not None and key in cache:
+            return cache[key]
+        nav = cls(
+            tile_map,
+            tileset_collision,
+            tile_size,
+            render_scale,
+            map_size,
+            gid_resolver=gid_resolver,
+        ).erode(margin)
         if cache is not None:
-            cache[margin] = nav
+            cache[key] = nav
         return nav
 
     def get_neighbors(self, tx: int, ty: int, *, diagonals: bool = False) -> List[Tuple[int, int]]:

{tilemap_parser-5.0.3 → tilemap_parser-5.1.0}/src/tilemap_parser/runtime/particles.py

@@ -177,6 +177,23 @@ def _make_heart_texture() -> Surface:
     return s
 
 
+def _make_line_texture() -> Surface:
+    # will be applied on next release not yet
+    """Vertical streak spanning the full canvas with a thin core.
+
+    Kept axis-aligned (not rotated): the renderer only rotates particles
+    when ``rotation_speed`` is non-zero, so a vertical line reads as a
+    falling streak for rain and stream effects.
+    """
+    s = Surface((PARTICLE_TEXTURE_SIZE, PARTICLE_TEXTURE_SIZE), pygame.SRCALPHA)
+    w = max(1, PARTICLE_TEXTURE_SIZE // 6)
+    x = (PARTICLE_TEXTURE_SIZE - w) // 2
+    pygame.draw.rect(s, (255, 255, 255, 255), Rect(x, 2, w, PARTICLE_TEXTURE_SIZE - 4))
+    pygame.draw.rect(s, (255, 255, 255, 140), Rect(x, 0, w, 2))
+    pygame.draw.rect(s, (255, 255, 255, 140), Rect(x, PARTICLE_TEXTURE_SIZE - 2, w, 2))
+    return s
+
+
 def _get_base_texture(shape: str) -> Surface:
     if shape not in _TEXTURE_CACHE:
         makers = {
@@ -188,6 +205,7 @@ def _get_base_texture(shape: str) -> Surface:
             "smoke": _make_smoke_texture,
             "fog": _make_fog_texture,
             "heart": _make_heart_texture,
+            "line": _make_line_texture,
         }
         maker = makers.get(shape, _make_circle_texture)
         _TEXTURE_CACHE[shape] = maker()