zombie-escape 1.10.1__py3-none-any.whl → 1.12.3__py3-none-any.whl

zombie_escape/render_assets.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import math
+from dataclasses import dataclass
 
 import pygame
 
@@ -10,21 +11,22 @@ from .colors import (
     BLACK,
     BLUE,
     DARK_RED,
-    RED,
-    TRACKER_OUTLINE_COLOR,
-    WALL_FOLLOWER_OUTLINE_COLOR,
-    YELLOW,
-    EnvironmentPalette,
     ORANGE,
     STEEL_BEAM_COLOR,
     STEEL_BEAM_LINE_COLOR,
+    YELLOW,
+    EnvironmentPalette,
     get_environment_palette,
 )
 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,
 )
@@ -43,6 +45,197 @@ 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]] = {}
+
+
+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]
+    polygons: list[list[tuple[int, int]]]
+
+
+FUEL_CAN_SPEC = PolygonSpec(
+    size=(13, 17),
+    polygons=[
+        [
+            (1, 1),
+            (7, 1),
+            (12, 6),
+            (12, 16),
+            (1, 16),
+        ],
+        [
+            (10, 1),
+            (12, 3),
+            (9, 4),
+            (7, 3),
+        ],
+    ],
+)
+
+FLASHLIGHT_SPEC = PolygonSpec(
+    size=(12, 10),
+    polygons=[
+        [
+            (1, 2),
+            (8, 2),
+            (8, 7),
+            (1, 7),
+        ],
+        [
+            (8, 1),
+            (11, 1),
+            (11, 8),
+            (8, 8),
+        ],
+    ],
+)
+
+SHOES_SPEC = PolygonSpec(
+    size=(14, 10),
+    polygons=[
+        [
+            (1, 1),
+            (7, 1),
+            (8, 4),
+            (13, 6),
+            (13, 9),
+            (1, 9),
+        ],
+    ],
+)
+
+
+def _scale_polygons(
+    spec: PolygonSpec,
+    dst_size: tuple[int, int],
+) -> list[list[tuple[int, int]]]:
+    src_w, src_h = spec.size
+    dst_w, dst_h = dst_size
+    scale_x = dst_w / max(1, src_w)
+    scale_y = dst_h / max(1, src_h)
+    scaled = []
+    for poly in spec.polygons:
+        scaled.append(
+            [
+                (
+                    int(round(x * scale_x)),
+                    int(round(y * scale_y)),
+                )
+                for x, y in poly
+            ]
+        )
+    return scaled
+
+
+def _draw_polygon_surface(
+    width: int,
+    height: int,
+    spec: PolygonSpec,
+) -> pygame.Surface:
+    surface = pygame.Surface((width, height), pygame.SRCALPHA)
+    draw_polygons = spec.polygons
+    if (width, height) != spec.size:
+        draw_polygons = _scale_polygons(spec, (width, height))
+    for poly in draw_polygons:
+        pygame.draw.polygon(surface, YELLOW, poly)
+        pygame.draw.polygon(surface, BLACK, poly, width=1)
+    return surface
+
+
 def build_beveled_polygon(
     width: int,
     height: int,
@@ -178,55 +371,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:
@@ -240,54 +523,101 @@ 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(
     surface: pygame.Surface,
@@ -426,101 +756,20 @@ 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:
-    surface = pygame.Surface((width, height), pygame.SRCALPHA)
-
-    # Jerrycan silhouette with cut corner
-    body_pts = [
-        (1, 4),
-        (width - 2, 4),
-        (width - 2, height - 2),
-        (1, height - 2),
-        (1, 8),
-        (4, 4),
-    ]
-    pygame.draw.polygon(surface, YELLOW, body_pts)
-    pygame.draw.polygon(surface, BLACK, body_pts, width=2)
-
-    cap_size = max(2, width // 4)
-    cap_rect = pygame.Rect(width - cap_size - 2, 1, cap_size, 3)
-    pygame.draw.rect(surface, YELLOW, cap_rect, border_radius=1)
-    pygame.draw.rect(surface, BLACK, cap_rect, width=1, border_radius=1)
-
-    # Cross brace accent
-    brace_color = (240, 200, 40)
-    pygame.draw.line(
-        surface, brace_color, (3, height // 2), (width - 4, height // 2), width=2
-    )
-    pygame.draw.line(
-        surface, BLACK, (3, height // 2), (width - 4, height // 2), width=1
-    )
-    return surface
+    return _draw_polygon_surface(width, height, FUEL_CAN_SPEC)
 
 
 def build_flashlight_surface(width: int, height: int) -> pygame.Surface:
-    surface = pygame.Surface((width, height), pygame.SRCALPHA)
+    return _draw_polygon_surface(width, height, FLASHLIGHT_SPEC)
 
-    body_color = (230, 200, 70)
-    trim_color = (80, 70, 40)
-    head_color = (200, 180, 90)
-    beam_color = (255, 240, 180, 150)
 
-    body_rect = pygame.Rect(1, 2, width - 4, height - 4)
-    head_rect = pygame.Rect(
-        body_rect.right - 3, body_rect.top - 1, 4, body_rect.height + 2
-    )
-    beam_points = [
-        (head_rect.right + 4, head_rect.centery),
-        (head_rect.right + 2, head_rect.top),
-        (head_rect.right + 2, head_rect.bottom),
-    ]
-
-    pygame.draw.rect(surface, body_color, body_rect, border_radius=2)
-    pygame.draw.rect(surface, trim_color, body_rect, width=1, border_radius=2)
-    pygame.draw.rect(surface, head_color, head_rect, border_radius=2)
-    pygame.draw.rect(surface, trim_color, head_rect, width=1, border_radius=2)
-    pygame.draw.polygon(surface, beam_color, beam_points)
-    return surface
+def build_shoes_surface(width: int, height: int) -> pygame.Surface:
+    return _draw_polygon_surface(width, height, SHOES_SPEC)
 
 
 __all__ = [
+    "angle_bin_from_vector",
     "EnvironmentPalette",
     "FogRing",
     "RenderAssets",
@@ -529,14 +778,18 @@ __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",
     "paint_steel_beam_surface",
-    "paint_zombie_surface",
     "build_fuel_can_surface",
     "build_flashlight_surface",
+    "build_shoes_surface",
 ]