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

zombie_escape/render_assets.py

@@ -12,20 +12,21 @@ 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 .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 +45,102 @@ 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]
@@ -93,7 +190,7 @@ SHOES_SPEC = PolygonSpec(
         [
             (1, 1),
             (7, 1),
-            (7, 4),
+            (8, 4),
             (13, 6),
             (13, 9),
             (1, 9),
@@ -274,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:
@@ -336,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,
@@ -522,43 +756,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 +769,7 @@ def build_shoes_surface(width: int, height: int) -> pygame.Surface:
 
 
 __all__ = [
+    "angle_bin_from_vector",
     "EnvironmentPalette",
     "FogRing",
     "RenderAssets",
@@ -580,14 +778,17 @@ __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",

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)
@@ -93,6 +99,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",

zombie_escape/screens/game_over.py

@@ -47,9 +47,9 @@ def game_over_screen(
 
     while True:
         if not state.overview_created:
-            level_rect = game_data.layout.outer_rect
-            level_width = level_rect[2]
-            level_height = level_rect[3]
+            level_rect = game_data.layout.field_rect
+            level_width = level_rect.width
+            level_height = level_rect.height
             overview_surface = pygame.Surface((level_width, level_height))
             footprints_to_draw = state.footprints if footprints_enabled else []
             draw_level_overview(

zombie_escape/screens/gameplay.py

@@ -120,10 +120,12 @@ def gameplay_screen(
     spawn_survivors(game_data, layout_data)
 
     occupied_centers: set[tuple[int, int]] = set()
+    cell_size = game_data.cell_size
     if stage.requires_fuel:
         fuel_spawn_count = stage.fuel_spawn_count
         fuel_can = place_fuel_can(
             layout_data["walkable_cells"],
+            cell_size,
             player,
             cars=game_data.waiting_cars,
             reserved_centers=occupied_centers,
@@ -136,6 +138,7 @@ def gameplay_screen(
     flashlight_count = stage.initial_flashlight_count
     flashlights = place_flashlights(
         layout_data["walkable_cells"],
+        cell_size,
         player,
         cars=game_data.waiting_cars,
         reserved_centers=occupied_centers,
@@ -149,6 +152,7 @@ def gameplay_screen(
     shoes_count = stage.initial_shoes_count
     shoes_list = place_shoes(
         layout_data["walkable_cells"],
+        cell_size,
         player,
         cars=game_data.waiting_cars,
         reserved_centers=occupied_centers,

zombie_escape/stage_constants.py

@@ -130,7 +130,7 @@ STAGES: list[Stage] = [
         available=True,
         rescue_stage=True,
         tile_size=40,
-        wall_algorithm="sparse",
+        wall_algorithm="sparse_moore.10%",
         exterior_spawn_weight=0.7,
         interior_spawn_weight=0.3,
         zombie_normal_ratio=0.4,
@@ -148,7 +148,7 @@ STAGES: list[Stage] = [
         grid_cols=120,
         grid_rows=7,
         available=True,
-        wall_algorithm="sparse",
+        wall_algorithm="sparse_moore.10%",
         exterior_spawn_weight=0.3,
         interior_spawn_weight=0.7,
         zombie_normal_ratio=0.5,
@@ -224,8 +224,8 @@ STAGES: list[Stage] = [
         description_key="stages.stage15.description",
         available=True,
         buddy_required_count=1,
-        grid_cols=70,
-        grid_rows=20,
+        grid_cols=64,
+        grid_rows=24,
         tile_size=35,
         wall_algorithm="grid_wire",
         requires_fuel=True,
@@ -237,7 +237,7 @@ STAGES: list[Stage] = [
         zombie_normal_ratio=0.5,
         zombie_wall_follower_ratio=0.5,
         fall_spawn_zones=[
-            (33, 2, 4, 16),
+            (33, 2, 4, 18),
         ],
         zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
         initial_shoes_count=1,

zombie_escape/zombie_escape.py

@@ -21,7 +21,7 @@ from .entities_constants import (
 from .gameplay import calculate_car_speed_for_passengers
 from .level_constants import DEFAULT_TILE_SIZE
 from .localization import set_language
-from .models import GameData, Stage
+from .models import Stage
 from .render_constants import RenderAssets, build_render_assets
 from .screen_constants import (
     DEFAULT_WINDOW_SCALE,

{zombie_escape-1.12.0.dist-info → zombie_escape-1.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.12.0
+Version: 1.12.3
 Summary: Top-down zombie survival game built with pygame.
 Project-URL: Homepage, https://github.com/tos-kamiya/zombie-escape
 Author-email: Toshihiro Kamiya <kamiya@mbj.nifty.com>
@@ -93,7 +93,7 @@ Open **Settings** from the title to toggle gameplay assists:
 
 ### Characters/Items
 
--   **Player:** A blue circle. Controlled with the WASD or arrow keys. When carrying fuel a tiny yellow square appears near the sprite so you can immediately see whether you're ready to drive.
+-   **Player:** A blue circle with small hands. Controlled with the WASD or arrow keys. When carrying fuel a tiny yellow square appears near the sprite so you can immediately see whether you're ready to drive.
 -   **Zombie:** A red circle. Will chase the player (or car) once detected.
     -   When out of sight, the zombie's movement mode will randomly switch every certain time (moving horizontally/vertically only, side-to-side movement, random movement, etc.).
     -   Variants with different behavior have been observed.
@@ -108,10 +108,11 @@ Open **Settings** from the title to toggle gameplay assists:
 -   **Flashlight:** Each pickup expands your visible radius by about 20% (grab two to reach the max boost).
 -   **Steel Beam (optional):** A square post with crossed diagonals; same collision as inner walls but with triple durability. Spawns independently of inner walls (may overlap them). If an inner wall covers a beam, the beam appears once the wall is destroyed.
 -   **Fuel Can (Stages 2 & 3):** A yellow jerrycan that only spawns on the fuel-run stages. Pick it up before driving the car; once collected the on-player indicator appears until you refuel the car.
--   **Buddy (Stage 3):** A green circle survivor with a blue outline who spawns somewhere in the building and waits.
+-   **Buddy (Stage 3):** A green circle survivor with small hands and a blue outline who spawns somewhere in the building and waits.
     -   Zombies only choose to pursue the buddy if they are on-screen; otherwise they ignore them.
     -   If a zombie tags the buddy off-screen, the buddy quietly respawns somewhere else instead of ending the run.
     -   Touch the buddy on foot to make them follow you (at 70% of player speed). Touch them while driving to pick them up.
+    -   If you bash an inner wall or steel beam, the buddy will drift toward that spot and help chip away at it.
 -   **Survivors (Stage 4):** Pale gray civilians with a blue outline, scattered indoors.
     - They stand still until you get close, then shuffle toward you at about one-third of player speed.
     - Zombies can convert them if both are on-screen; the survivor shouts a line and turns instantly.