zombie-escape 1.12.0__py3-none-any.whl → 1.13.1__py3-none-any.whl

zombie_escape/render_assets.py

@@ -12,20 +12,22 @@ from .colors import (
     BLUE,
     DARK_RED,
     ORANGE,
-    RED,
     STEEL_BEAM_COLOR,
     STEEL_BEAM_LINE_COLOR,
-    TRACKER_OUTLINE_COLOR,
-    WALL_FOLLOWER_OUTLINE_COLOR,
     YELLOW,
     EnvironmentPalette,
     get_environment_palette,
 )
+from .entities_constants import INTERNAL_WALL_BEVEL_DEPTH
 from .render_constants import (
+    ANGLE_BINS,
     BUDDY_COLOR,
+    HAND_SPREAD_RAD,
     HUMANOID_OUTLINE_COLOR,
     HUMANOID_OUTLINE_WIDTH,
     SURVIVOR_COLOR,
+    ZOMBIE_BODY_COLOR,
+    ZOMBIE_OUTLINE_COLOR,
     FogRing,
     RenderAssets,
 )
@@ -44,6 +46,118 @@ def _draw_outlined_circle(
         pygame.draw.circle(surface, outline_color, center, radius, width=outline_width)
 
 
+def _brighten_color(
+    color: tuple[int, int, int], *, factor: float = 1.25
+) -> tuple[int, int, int]:
+    return tuple(min(255, int(c * factor + 0.5)) for c in color)
+
+
+ANGLE_STEP = math.tau / ANGLE_BINS
+
+_PLAYER_UPSCALE_FACTOR = 4
+_CAR_UPSCALE_FACTOR = 4
+
+_PLAYER_DIRECTIONAL_CACHE: dict[tuple[int, int], list[pygame.Surface]] = {}
+_SURVIVOR_DIRECTIONAL_CACHE: dict[
+    tuple[int, bool, bool, int], list[pygame.Surface]
+] = {}
+_ZOMBIE_DIRECTIONAL_CACHE: dict[tuple[int, bool, int], list[pygame.Surface]] = {}
+_RUBBLE_SURFACE_CACHE: dict[tuple, pygame.Surface] = {}
+
+RUBBLE_ROTATION_DEG = 5.0
+RUBBLE_OFFSET_RATIO = 0.06
+RUBBLE_SCALE_RATIO = 0.9
+RUBBLE_SHADOW_RATIO = 0.9
+
+
+def _scale_color(
+    color: tuple[int, int, int], *, ratio: float
+) -> tuple[int, int, int]:
+    return tuple(max(0, min(255, int(c * ratio + 0.5))) for c in color)
+
+
+def rubble_offset_for_size(size: int) -> int:
+    return max(1, int(round(size * RUBBLE_OFFSET_RATIO)))
+
+
+def angle_bin_from_vector(
+    dx: float, dy: float, *, bins: int = ANGLE_BINS
+) -> int | None:
+    if dx == 0 and dy == 0:
+        return None
+    angle = math.atan2(dy, dx)
+    if angle < 0:
+        angle += math.tau
+    step = math.tau / bins
+    return int(round(angle / step)) % bins
+
+
+def _hand_defaults(radius: int) -> tuple[int, int]:
+    hand_radius = max(1, int(radius * 0.5))
+    hand_distance = max(hand_radius + 1, int(radius * 1.0))
+    return hand_radius, hand_distance
+
+
+def _draw_capped_circle(
+    surface: pygame.Surface,
+    center: tuple[int, int],
+    radius: int,
+    base_color: tuple[int, int, int],
+    cap_color: tuple[int, int, int],
+    outline_color: tuple[int, int, int],
+    outline_width: int,
+    *,
+    angle_rad: float = 0.0,
+    hand_spread_rad: float = HAND_SPREAD_RAD,
+    hand_radius: int | None = None,
+    hand_distance: int | None = None,
+    draw_hands: bool = True,
+) -> None:
+    if hand_radius is None or hand_distance is None:
+        hand_radius, hand_distance = _hand_defaults(radius)
+    if draw_hands:
+        for direction in (-1, 1):
+            hand_angle = angle_rad + (hand_spread_rad * direction)
+            hand_x = int(round(center[0] + math.cos(hand_angle) * hand_distance))
+            hand_y = int(round(center[1] + math.sin(hand_angle) * hand_distance))
+            pygame.draw.circle(surface, base_color, (hand_x, hand_y), hand_radius)
+    pygame.draw.circle(surface, cap_color, center, radius)
+    if outline_width > 0:
+        pygame.draw.circle(surface, outline_color, center, radius, width=outline_width)
+
+
+def _build_capped_surface(
+    radius: int,
+    base_color: tuple[int, int, int],
+    cap_color: tuple[int, int, int],
+    angle_bin: int,
+    *,
+    outline_scale: int = 1,
+    draw_hands: bool = True,
+    outline_color: tuple[int, int, int] = HUMANOID_OUTLINE_COLOR,
+) -> pygame.Surface:
+    hand_radius, hand_distance = _hand_defaults(radius)
+    max_extent = max(radius, hand_distance + hand_radius)
+    size = max_extent * 2 + 2
+    surface = pygame.Surface((size, size), pygame.SRCALPHA)
+    center = (max_extent + 1, max_extent + 1)
+    angle_rad = (angle_bin % ANGLE_BINS) * ANGLE_STEP
+    _draw_capped_circle(
+        surface,
+        center,
+        radius,
+        base_color,
+        cap_color,
+        outline_color,
+        HUMANOID_OUTLINE_WIDTH * outline_scale,
+        angle_rad=angle_rad,
+        hand_radius=hand_radius,
+        hand_distance=hand_distance,
+        draw_hands=draw_hands,
+    )
+    return surface
+
+
 @dataclass(frozen=True)
 class PolygonSpec:
     size: tuple[int, int]
@@ -93,7 +207,7 @@ SHOES_SPEC = PolygonSpec(
         [
             (1, 1),
             (7, 1),
-            (7, 4),
+            (8, 4),
             (13, 6),
             (13, 9),
             (1, 9),
@@ -274,55 +388,145 @@ def resolve_steel_beam_colors(
     return STEEL_BEAM_COLOR, STEEL_BEAM_LINE_COLOR
 
 
-def build_player_surface(radius: int) -> pygame.Surface:
-    surface = pygame.Surface((radius * 2 + 2, radius * 2 + 2), pygame.SRCALPHA)
-    _draw_outlined_circle(
-        surface,
-        (radius + 1, radius + 1),
+def build_player_directional_surfaces(
+    radius: int, *, bins: int = ANGLE_BINS
+) -> list[pygame.Surface]:
+    cache_key = (radius, bins)
+    if cache_key in _PLAYER_DIRECTIONAL_CACHE:
+        return _PLAYER_DIRECTIONAL_CACHE[cache_key]
+    surfaces = build_humanoid_directional_surfaces(
         radius,
-        BLUE,
-        HUMANOID_OUTLINE_COLOR,
-        HUMANOID_OUTLINE_WIDTH,
+        base_color=BLUE,
+        cap_color=_brighten_color(BLUE),
+        bins=bins,
+        outline_color=HUMANOID_OUTLINE_COLOR,
     )
-    return surface
+    _PLAYER_DIRECTIONAL_CACHE[cache_key] = surfaces
+    return surfaces
 
 
-def build_survivor_surface(radius: int, *, is_buddy: bool) -> pygame.Surface:
-    surface = pygame.Surface((radius * 2, radius * 2), pygame.SRCALPHA)
-    fill_color = BUDDY_COLOR if is_buddy else SURVIVOR_COLOR
-    _draw_outlined_circle(
+def build_humanoid_directional_surfaces(
+    radius: int,
+    *,
+    base_color: tuple[int, int, int],
+    cap_color: tuple[int, int, int],
+    bins: int = ANGLE_BINS,
+    draw_hands: bool = True,
+    outline_color: tuple[int, int, int],
+) -> list[pygame.Surface]:
+    base_radius = radius * _PLAYER_UPSCALE_FACTOR
+    base_surface = _build_capped_surface(
+        base_radius,
+        base_color,
+        cap_color,
+        0,
+        outline_scale=_PLAYER_UPSCALE_FACTOR,
+        draw_hands=draw_hands,
+        outline_color=outline_color,
+    )
+    target_surface = _build_capped_surface(
+        radius,
+        base_color,
+        cap_color,
+        0,
+        draw_hands=draw_hands,
+        outline_color=outline_color,
+    )
+    target_size = target_surface.get_size()
+    scale = target_size[0] / base_surface.get_width()
+    half_step_deg = 360.0 / (bins * 5)
+    surfaces: list[pygame.Surface] = []
+    for idx in range(bins):
+        rotation_deg = -(idx * 360.0 / bins - half_step_deg)
+        rotated = pygame.transform.rotozoom(base_surface, rotation_deg, scale)
+        framed = pygame.Surface(target_size, pygame.SRCALPHA)
+        framed.blit(rotated, rotated.get_rect(center=framed.get_rect().center))
+        surfaces.append(framed)
+    return surfaces
+
+
+def draw_humanoid_hand(
+    surface: pygame.Surface,
+    *,
+    radius: int,
+    angle_rad: float,
+    color: tuple[int, int, int],
+    hand_radius: int | None = None,
+    hand_distance: int | None = None,
+) -> None:
+    if hand_radius is None or hand_distance is None:
+        hand_radius, hand_distance = _hand_defaults(radius)
+    center_x, center_y = surface.get_rect().center
+    hand_x = int(round(center_x + math.cos(angle_rad) * hand_distance))
+    hand_y = int(round(center_y + math.sin(angle_rad) * hand_distance))
+    pygame.draw.circle(surface, color, (hand_x, hand_y), hand_radius)
+
+
+def draw_humanoid_nose(
+    surface: pygame.Surface,
+    *,
+    radius: int,
+    angle_rad: float,
+    color: tuple[int, int, int],
+) -> None:
+    center_x, center_y = surface.get_rect().center
+    nose_length = max(2, int(radius * 0.45))
+    nose_offset = max(1, int(radius * 0.35))
+    start_x = center_x + math.cos(angle_rad) * nose_offset
+    start_y = center_y + math.sin(angle_rad) * nose_offset
+    end_x = center_x + math.cos(angle_rad) * (nose_offset + nose_length)
+    end_y = center_y + math.sin(angle_rad) * (nose_offset + nose_length)
+    pygame.draw.line(
         surface,
-        (radius, radius),
+        color,
+        (int(start_x), int(start_y)),
+        (int(end_x), int(end_y)),
+        width=2,
+    )
+
+
+def build_survivor_directional_surfaces(
+    radius: int,
+    *,
+    is_buddy: bool,
+    bins: int = ANGLE_BINS,
+    draw_hands: bool = True,
+) -> list[pygame.Surface]:
+    cache_key = (radius, is_buddy, draw_hands, bins)
+    if cache_key in _SURVIVOR_DIRECTIONAL_CACHE:
+        return _SURVIVOR_DIRECTIONAL_CACHE[cache_key]
+    fill_color = BUDDY_COLOR if is_buddy else SURVIVOR_COLOR
+    surfaces = build_humanoid_directional_surfaces(
         radius,
-        fill_color,
-        HUMANOID_OUTLINE_COLOR,
-        HUMANOID_OUTLINE_WIDTH,
+        base_color=fill_color,
+        cap_color=_brighten_color(fill_color),
+        bins=bins,
+        draw_hands=draw_hands,
+        outline_color=HUMANOID_OUTLINE_COLOR,
     )
-    return surface
+    _SURVIVOR_DIRECTIONAL_CACHE[cache_key] = surfaces
+    return surfaces
 
 
-def build_zombie_surface(
+def build_zombie_directional_surfaces(
     radius: int,
     *,
-    tracker: bool = False,
-    wall_follower: bool = False,
-) -> pygame.Surface:
-    if tracker:
-        outline_color = TRACKER_OUTLINE_COLOR
-    elif wall_follower:
-        outline_color = WALL_FOLLOWER_OUTLINE_COLOR
-    else:
-        outline_color = DARK_RED
-    surface = pygame.Surface((radius * 2, radius * 2), pygame.SRCALPHA)
-    _draw_outlined_circle(
-        surface,
-        (radius, radius),
+    bins: int = ANGLE_BINS,
+    draw_hands: bool = True,
+) -> list[pygame.Surface]:
+    cache_key = (radius, draw_hands, bins)
+    if cache_key in _ZOMBIE_DIRECTIONAL_CACHE:
+        return _ZOMBIE_DIRECTIONAL_CACHE[cache_key]
+    surfaces = build_humanoid_directional_surfaces(
         radius,
-        RED,
-        outline_color,
-        1,
+        base_color=ZOMBIE_BODY_COLOR,
+        cap_color=_brighten_color(ZOMBIE_BODY_COLOR),
+        bins=bins,
+        draw_hands=draw_hands,
+        outline_color=ZOMBIE_OUTLINE_COLOR,
     )
-    return surface
+    _ZOMBIE_DIRECTIONAL_CACHE[cache_key] = surfaces
+    return surfaces
 
 
 def build_car_surface(width: int, height: int) -> pygame.Surface:
@@ -336,53 +540,100 @@ def paint_car_surface(
     height: int,
     color: tuple[int, int, int],
 ) -> None:
-    surface.fill((0, 0, 0, 0))
+    upscale = _CAR_UPSCALE_FACTOR
+    if upscale > 1:
+        up_width = width * upscale
+        up_height = height * upscale
+        up_surface = pygame.Surface((up_width, up_height), pygame.SRCALPHA)
+        _paint_car_surface_base(
+            up_surface, width=up_width, height=up_height, color=color
+        )
+        scaled = pygame.transform.smoothscale(up_surface, (width, height))
+        surface.fill((0, 0, 0, 0))
+        surface.blit(scaled, (0, 0))
+        return
+    _paint_car_surface_base(surface, width=width, height=height, color=color)
 
-    body_rect = pygame.Rect(1, 4, width - 2, height - 8)
-    front_cap_height = max(8, body_rect.height // 3)
-    front_cap = pygame.Rect(
-        body_rect.left, body_rect.top, body_rect.width, front_cap_height
-    )
-    windshield_rect = pygame.Rect(
-        body_rect.left + 4,
-        body_rect.top + 3,
-        body_rect.width - 8,
-        front_cap_height - 5,
-    )
 
-    trim_color = tuple(int(c * 0.55) for c in color)
-    front_cap_color = tuple(min(255, int(c * 1.08)) for c in color)
-    body_color = color
-    window_color = (70, 110, 150)
-    wheel_color = (35, 35, 35)
-
-    wheel_width = width // 3
-    wheel_height = 6
-    for y in (body_rect.top + 4, body_rect.bottom - wheel_height - 4):
-        left_wheel = pygame.Rect(2, y, wheel_width, wheel_height)
-        right_wheel = pygame.Rect(width - wheel_width - 2, y, wheel_width, wheel_height)
-        pygame.draw.rect(surface, wheel_color, left_wheel, border_radius=3)
-        pygame.draw.rect(surface, wheel_color, right_wheel, border_radius=3)
-
-    pygame.draw.rect(surface, body_color, body_rect, border_radius=4)
-    pygame.draw.rect(surface, trim_color, body_rect, width=2, border_radius=4)
-    pygame.draw.rect(surface, front_cap_color, front_cap, border_radius=10)
-    pygame.draw.rect(surface, trim_color, front_cap, width=2, border_radius=10)
-    pygame.draw.rect(surface, window_color, windshield_rect, border_radius=4)
-
-    headlight_color = (245, 245, 200)
-    for x in (front_cap.left + 5, front_cap.right - 5):
-        pygame.draw.circle(surface, headlight_color, (x, body_rect.top + 5), 2)
-    grille_rect = pygame.Rect(front_cap.centerx - 6, front_cap.top + 2, 12, 6)
-    pygame.draw.rect(surface, trim_color, grille_rect, border_radius=2)
+def _paint_car_surface_base(
+    surface: pygame.Surface,
+    *,
+    width: int,
+    height: int,
+    color: tuple[int, int, int],
+) -> None:
+    surface.fill((0, 0, 0, 0))
+
+    trim_color = tuple(int(c * 0.6) for c in color)
+    body_color = tuple(min(255, int(c * 1.15)) for c in color)
     tail_light_color = (255, 80, 50)
-    for x in (body_rect.left + 5, body_rect.right - 5):
-        pygame.draw.rect(
-            surface,
-            tail_light_color,
-            (x - 2, body_rect.bottom - 5, 4, 3),
-            border_radius=1,
+    headlight_color = (200, 200, 200)
+
+    base_width = 150.0
+    base_height = 210.0
+    scale_x = width / base_width
+    scale_y = height / base_height
+
+    def _rect(x: float, y: float, w: float, h: float) -> pygame.Rect:
+        return pygame.Rect(
+            int(round(x * scale_x)),
+            int(round(y * scale_y)),
+            max(1, int(round(w * scale_x))),
+            max(1, int(round(h * scale_y))),
+        )
+
+    def _radius(value: float) -> int:
+        return max(1, int(round(value * min(scale_x, scale_y))))
+
+    body_top = _rect(0, 0, 150, 140)
+    body_bottom = _rect(0, 70, 150, 140)
+    rear_bed = _rect(16, 98, 118, 88)
+
+    pygame.draw.rect(surface, trim_color, body_top, border_radius=_radius(50))
+    pygame.draw.rect(surface, trim_color, body_bottom, border_radius=_radius(37))
+    pygame.draw.rect(surface, body_color, rear_bed)
+
+    tail_left = _rect(30, 190, 30, 20)
+    tail_right = _rect(90, 190, 30, 20)
+    pygame.draw.rect(surface, tail_light_color, tail_left)
+    pygame.draw.rect(surface, tail_light_color, tail_right)
+
+    headlight_left = _rect(15, 7, 40, 20)
+    headlight_right = _rect(95, 7, 40, 20)
+    pygame.draw.ellipse(surface, headlight_color, headlight_left)
+    pygame.draw.ellipse(surface, headlight_color, headlight_right)
+
+
+def build_car_directional_surfaces(
+    base_surface: pygame.Surface, *, bins: int = ANGLE_BINS
+) -> list[pygame.Surface]:
+    """Return pre-rotated car surfaces matching angle_bin_from_vector bins."""
+    surfaces: list[pygame.Surface] = []
+    upscale = _CAR_UPSCALE_FACTOR
+    if upscale > 1:
+        src_size = base_surface.get_size()
+        upscale_surface = pygame.transform.scale(
+            base_surface,
+            (src_size[0] * upscale, src_size[1] * upscale),
         )
+    else:
+        upscale_surface = base_surface
+    for idx in range(bins):
+        angle_rad = idx * ANGLE_STEP
+        rotation_deg = -math.degrees(angle_rad) - 90
+        rotated = pygame.transform.rotate(upscale_surface, rotation_deg)
+        if upscale > 1:
+            scaled = pygame.transform.smoothscale(
+                rotated,
+                (
+                    max(1, rotated.get_width() // upscale),
+                    max(1, rotated.get_height() // upscale),
+                ),
+            )
+            surfaces.append(scaled)
+        else:
+            surfaces.append(rotated)
+    return surfaces
 
 
 def paint_wall_surface(
@@ -472,6 +723,80 @@ def paint_wall_surface(
         _draw_face(surface)
 
 
+def build_rubble_wall_surface(
+    size: int,
+    *,
+    fill_color: tuple[int, int, int],
+    border_color: tuple[int, int, int],
+    angle_deg: float,
+    offset_px: int | None = None,
+    scale_ratio: float = RUBBLE_SCALE_RATIO,
+    shadow_ratio: float = RUBBLE_SHADOW_RATIO,
+    bevel_depth: int = INTERNAL_WALL_BEVEL_DEPTH,
+) -> pygame.Surface:
+    offset_px = offset_px if offset_px is not None else rubble_offset_for_size(size)
+    safe_size = max(1, size)
+    base_size = max(1, int(round(safe_size * scale_ratio)))
+    tuned_bevel = min(bevel_depth, max(1, base_size // 2))
+    cache_key = (
+        safe_size,
+        fill_color,
+        border_color,
+        angle_deg,
+        offset_px,
+        scale_ratio,
+        shadow_ratio,
+        tuned_bevel,
+    )
+    cached = _RUBBLE_SURFACE_CACHE.get(cache_key)
+    if cached is not None:
+        return cached
+
+    top_surface = pygame.Surface((base_size, base_size), pygame.SRCALPHA)
+    paint_wall_surface(
+        top_surface,
+        fill_color=fill_color,
+        border_color=border_color,
+        bevel_depth=tuned_bevel,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+
+    shadow_fill = _scale_color(fill_color, ratio=shadow_ratio)
+    shadow_border = _scale_color(border_color, ratio=shadow_ratio)
+    shadow_surface = pygame.Surface((base_size, base_size), pygame.SRCALPHA)
+    paint_wall_surface(
+        shadow_surface,
+        fill_color=shadow_fill,
+        border_color=shadow_border,
+        bevel_depth=tuned_bevel,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+
+    if angle_deg:
+        top_surface = pygame.transform.rotate(top_surface, angle_deg)
+        shadow_surface = pygame.transform.rotate(shadow_surface, angle_deg)
+
+    final_surface = pygame.Surface((safe_size, safe_size), pygame.SRCALPHA)
+    center = final_surface.get_rect().center
+
+    shadow_rect = shadow_surface.get_rect(
+        center=(center[0] + offset_px, center[1] + offset_px)
+    )
+    final_surface.blit(shadow_surface, shadow_rect.topleft)
+
+    top_rect = top_surface.get_rect(center=center)
+    final_surface.blit(top_surface, top_rect.topleft)
+
+    _RUBBLE_SURFACE_CACHE[cache_key] = final_surface
+    return final_surface
+
+
 def paint_steel_beam_surface(
     surface: pygame.Surface,
     *,
@@ -522,43 +847,6 @@ def paint_steel_beam_surface(
     surface.blit(top_surface, top_rect.topleft)
 
 
-def paint_zombie_surface(
-    surface: pygame.Surface,
-    *,
-    radius: int,
-    palm_angle: float | None = None,
-    tracker: bool = False,
-    wall_follower: bool = False,
-) -> None:
-    if tracker:
-        outline_color = TRACKER_OUTLINE_COLOR
-    elif wall_follower:
-        outline_color = WALL_FOLLOWER_OUTLINE_COLOR
-    else:
-        outline_color = DARK_RED
-    surface.fill((0, 0, 0, 0))
-    _draw_outlined_circle(
-        surface,
-        (radius, radius),
-        radius,
-        RED,
-        outline_color,
-        1,
-    )
-    if palm_angle is None:
-        return
-    palm_radius = max(1, radius // 3)
-    palm_offset = radius - palm_radius * 0.3
-    palm_x = radius + math.cos(palm_angle) * palm_offset
-    palm_y = radius + math.sin(palm_angle) * palm_offset
-    pygame.draw.circle(
-        surface,
-        outline_color,
-        (int(palm_x), int(palm_y)),
-        palm_radius,
-    )
-
-
 def build_fuel_can_surface(width: int, height: int) -> pygame.Surface:
     return _draw_polygon_surface(width, height, FUEL_CAN_SPEC)
 
@@ -572,6 +860,7 @@ def build_shoes_surface(width: int, height: int) -> pygame.Surface:
 
 
 __all__ = [
+    "angle_bin_from_vector",
     "EnvironmentPalette",
     "FogRing",
     "RenderAssets",
@@ -580,14 +869,20 @@ __all__ = [
     "resolve_car_color",
     "resolve_steel_beam_colors",
     "CAR_COLOR_SCHEMES",
-    "build_player_surface",
-    "build_survivor_surface",
-    "build_zombie_surface",
+    "build_player_directional_surfaces",
+    "build_humanoid_directional_surfaces",
+    "draw_humanoid_hand",
+    "draw_humanoid_nose",
+    "build_survivor_directional_surfaces",
+    "build_zombie_directional_surfaces",
     "build_car_surface",
+    "build_car_directional_surfaces",
     "paint_car_surface",
     "paint_wall_surface",
+    "build_rubble_wall_surface",
+    "rubble_offset_for_size",
+    "RUBBLE_ROTATION_DEG",
     "paint_steel_beam_surface",
-    "paint_zombie_surface",
     "build_fuel_can_surface",
     "build_flashlight_surface",
     "build_shoes_surface",

zombie_escape/render_constants.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass
 
 from .entities_constants import FOV_RADIUS, PLAYER_RADIUS
@@ -11,9 +12,14 @@ HUMANOID_OUTLINE_COLOR = (0, 80, 200)
 HUMANOID_OUTLINE_WIDTH = 1
 BUDDY_COLOR = (0, 180, 63)
 SURVIVOR_COLOR = (198, 198, 198)
+ZOMBIE_BODY_COLOR = (180, 0, 0)
+ZOMBIE_OUTLINE_COLOR = (255, 60, 60)
+ZOMBIE_NOSE_COLOR = (255, 80, 80)
 FALLING_ZOMBIE_COLOR = (45, 45, 45)
 FALLING_WHIRLWIND_COLOR = (200, 200, 200, 120)
 FALLING_DUST_COLOR = (70, 70, 70, 130)
+ANGLE_BINS = 16
+HAND_SPREAD_RAD = math.radians(75)
 
 
 @dataclass(frozen=True)
@@ -61,6 +67,15 @@ ENTITY_SHADOW_EDGE_SOFTNESS = 0.32
 PLAYER_SHADOW_RADIUS_MULT = 1.6
 PLAYER_SHADOW_ALPHA_MULT = 0.8
 
+# --- Pitfall rendering ---
+PITFALL_ABYSS_COLOR = (21, 20, 20)
+PITFALL_SHADOW_RIM_COLOR = (38, 34, 34)
+PITFALL_SHADOW_WIDTH = 6
+PITFALL_EDGE_METAL_COLOR = (110, 110, 115)
+PITFALL_EDGE_STRIPE_COLOR = (75, 75, 80)
+PITFALL_EDGE_STRIPE_SPACING = 6
+PITFALL_EDGE_DEPTH_OFFSET = 3
+
 FOG_RINGS = [
     FogRing(radius_factor=0.536, thickness=2),
     FogRing(radius_factor=0.645, thickness=3),
@@ -93,6 +108,11 @@ __all__ = [
     "FALLING_ZOMBIE_COLOR",
     "FALLING_WHIRLWIND_COLOR",
     "FALLING_DUST_COLOR",
+    "ZOMBIE_BODY_COLOR",
+    "ZOMBIE_OUTLINE_COLOR",
+    "ZOMBIE_NOSE_COLOR",
+    "ANGLE_BINS",
+    "HAND_SPREAD_RAD",
     "HUMANOID_OUTLINE_COLOR",
     "HUMANOID_OUTLINE_WIDTH",
     "SURVIVOR_COLOR",
@@ -110,6 +130,13 @@ __all__ = [
     "ENTITY_SHADOW_EDGE_SOFTNESS",
     "PLAYER_SHADOW_RADIUS_MULT",
     "PLAYER_SHADOW_ALPHA_MULT",
+    "PITFALL_ABYSS_COLOR",
+    "PITFALL_SHADOW_RIM_COLOR",
+    "PITFALL_SHADOW_WIDTH",
+    "PITFALL_EDGE_METAL_COLOR",
+    "PITFALL_EDGE_STRIPE_COLOR",
+    "PITFALL_EDGE_STRIPE_SPACING",
+    "PITFALL_EDGE_DEPTH_OFFSET",
     "FLASHLIGHT_HATCH_EXTRA_SCALE",
     "build_render_assets",
 ]