zombie-escape 1.3.5__tar.gz → 1.3.8__tar.gz

{zombie_escape-1.3.5 → zombie_escape-1.3.8}/.gitignore

@@ -2,6 +2,10 @@
 node_modules/
 **/__pycache__/**
 dist/
+dev-samples/
+mplus_bitmap_fonts/
+shot*.png
+*.log
 
 package-lock.json
 package.json

{zombie_escape-1.3.5 → zombie_escape-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.3.5
+Version: 1.3.8
 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>
@@ -50,20 +50,7 @@ This game is a simple 2D top-down action game where the player aims to escape by
 -   **Window Scale (title/settings only):** `[` to shrink, `]` to enlarge
 -   **Time Acceleration:** Hold either `Shift` key to run the entire world 4x faster; release to return to normal speed.
 
-## Settings (Title Screen)
-
-Open **Settings** from the title to toggle gameplay assists:
-
--   **Footprints:** Leave breadcrumb trails so you can backtrack in the dark.
--   **Fast zombies:** Allow faster zombie variants; each zombie rolls a random speed between the normal and fast ranges.
--   **Car hint:** After a delay, show a small triangle pointing toward the fuel (Stage 2 before pickup) or the car.
--   **Steel beams:** Adds tougher single-cell obstacles (5% density) that block movement; hidden when stacked with an inner wall until that wall is destroyed.
-
-### Shared Seeds
-
-The title screen also lets you enter a numeric **seed**. Type digits (or pass `--seed <number>` on the CLI) to lock the procedural layout, wall placement, and pickups; share that seed with a friend and you will both play the exact same stage even on different machines. The current seed is shown at the bottom right of the title screen and in-game HUD. Backspace reverts to an automatically generated value so you can quickly roll a fresh challenge.
-
-## Game Rules
+## Title Screen
 
 ### Stages
 
@@ -75,8 +62,25 @@ At the title screen you can pick a stage:
 - **Stage 4: Evacuate Survivors** — start fueled, find the car, gather nearby civilians, and escape before zombies reach them. Stage 4 sprinkles extra parked cars across the map; slamming into one while already driving fully repairs your current ride and adds five more safe seats.
 - **Stage 5: Survive Until Dawn** — every car is bone-dry. Endure until the sun rises while the horde presses in from every direction. Once dawn hits, outdoor zombies carbonize and you must walk out through an existing exterior gap to win; cars remain unusable.
 
+**Stage names are red until cleared** and turn white after at least one clear.
+
 An objective reminder is shown at the top-left during play.
 
+### Shared Seeds
+
+The title screen also lets you enter a numeric **seed**. Type digits (or pass `--seed <number>` on the CLI) to lock the procedural layout, wall placement, and pickups; share that seed with a friend and you will both play the exact same stage even on different machines. The current seed is shown at the bottom right of the title screen and in-game HUD. Backspace reverts to an automatically generated value so you can quickly roll a fresh challenge.
+
+## Settings Screen
+
+Open **Settings** from the title to toggle gameplay assists:
+
+-   **Footprints:** Leave breadcrumb trails so you can backtrack in the dark.
+-   **Fast zombies:** Allow faster zombie variants; each zombie rolls a random speed between the normal and fast ranges.
+-   **Car hint:** After a delay, show a small triangle pointing toward the fuel (Stage 2 before pickup) or the car.
+-   **Steel beams:** Adds tougher single-cell obstacles (5% density) that block movement; hidden when stacked with an inner wall until that wall is destroyed.
+
+## Game Rules
+
 ### 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.

{zombie_escape-1.3.5 → zombie_escape-1.3.8}/README.md

@@ -29,20 +29,7 @@ This game is a simple 2D top-down action game where the player aims to escape by
 -   **Window Scale (title/settings only):** `[` to shrink, `]` to enlarge
 -   **Time Acceleration:** Hold either `Shift` key to run the entire world 4x faster; release to return to normal speed.
 
-## Settings (Title Screen)
-
-Open **Settings** from the title to toggle gameplay assists:
-
--   **Footprints:** Leave breadcrumb trails so you can backtrack in the dark.
--   **Fast zombies:** Allow faster zombie variants; each zombie rolls a random speed between the normal and fast ranges.
--   **Car hint:** After a delay, show a small triangle pointing toward the fuel (Stage 2 before pickup) or the car.
--   **Steel beams:** Adds tougher single-cell obstacles (5% density) that block movement; hidden when stacked with an inner wall until that wall is destroyed.
-
-### Shared Seeds
-
-The title screen also lets you enter a numeric **seed**. Type digits (or pass `--seed <number>` on the CLI) to lock the procedural layout, wall placement, and pickups; share that seed with a friend and you will both play the exact same stage even on different machines. The current seed is shown at the bottom right of the title screen and in-game HUD. Backspace reverts to an automatically generated value so you can quickly roll a fresh challenge.
-
-## Game Rules
+## Title Screen
 
 ### Stages
 
@@ -54,8 +41,25 @@ At the title screen you can pick a stage:
 - **Stage 4: Evacuate Survivors** — start fueled, find the car, gather nearby civilians, and escape before zombies reach them. Stage 4 sprinkles extra parked cars across the map; slamming into one while already driving fully repairs your current ride and adds five more safe seats.
 - **Stage 5: Survive Until Dawn** — every car is bone-dry. Endure until the sun rises while the horde presses in from every direction. Once dawn hits, outdoor zombies carbonize and you must walk out through an existing exterior gap to win; cars remain unusable.
 
+**Stage names are red until cleared** and turn white after at least one clear.
+
 An objective reminder is shown at the top-left during play.
 
+### Shared Seeds
+
+The title screen also lets you enter a numeric **seed**. Type digits (or pass `--seed <number>` on the CLI) to lock the procedural layout, wall placement, and pickups; share that seed with a friend and you will both play the exact same stage even on different machines. The current seed is shown at the bottom right of the title screen and in-game HUD. Backspace reverts to an automatically generated value so you can quickly roll a fresh challenge.
+
+## Settings Screen
+
+Open **Settings** from the title to toggle gameplay assists:
+
+-   **Footprints:** Leave breadcrumb trails so you can backtrack in the dark.
+-   **Fast zombies:** Allow faster zombie variants; each zombie rolls a random speed between the normal and fast ranges.
+-   **Car hint:** After a delay, show a small triangle pointing toward the fuel (Stage 2 before pickup) or the car.
+-   **Steel beams:** Adds tougher single-cell obstacles (5% density) that block movement; hidden when stacked with an inner wall until that wall is destroyed.
+
+## Game Rules
+
 ### 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.

{zombie_escape-1.3.5 → zombie_escape-1.3.8}/src/zombie_escape/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "1.3.5"
+__version__ = "1.3.8"

{zombie_escape-1.3.5 → zombie_escape-1.3.8}/src/zombie_escape/entities.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import math
 from enum import Enum
-from typing import Callable, Iterable, Self
+from typing import Callable, Iterable, Self, Sequence
 
 import pygame
 from pygame import rect
@@ -21,50 +21,50 @@ from .colors import (
     STEEL_BEAM_LINE_COLOR,
     YELLOW,
 )
-from .constants import (
-    CAR_HEIGHT,
+from .gameplay_constants import (
     CAR_HEALTH,
+    CAR_HEIGHT,
     CAR_SPEED,
-    CAR_WIDTH,
     CAR_WALL_DAMAGE,
+    CAR_WIDTH,
     COMPANION_COLOR,
     COMPANION_FOLLOW_SPEED,
     COMPANION_RADIUS,
-    FAST_ZOMBIE_SPEED_JITTER,
+    FAST_ZOMBIE_BASE_SPEED,
     FLASHLIGHT_HEIGHT,
     FLASHLIGHT_WIDTH,
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
+    INTERNAL_WALL_BEVEL_DEPTH,
     INTERNAL_WALL_HEALTH,
-    LEVEL_HEIGHT,
-    LEVEL_WIDTH,
-    NORMAL_ZOMBIE_SPEED_JITTER,
     PLAYER_RADIUS,
     PLAYER_SPEED,
     PLAYER_WALL_DAMAGE,
-    SCREEN_HEIGHT,
-    SCREEN_WIDTH,
     STEEL_BEAM_HEALTH,
     SURVIVOR_APPROACH_RADIUS,
     SURVIVOR_APPROACH_SPEED,
     SURVIVOR_COLOR,
     SURVIVOR_RADIUS,
+    ZOMBIE_AGING_DURATION_FRAMES,
+    ZOMBIE_AGING_MIN_SPEED_RATIO,
     ZOMBIE_MODE_CHANGE_INTERVAL_MS,
     ZOMBIE_RADIUS,
     ZOMBIE_SEPARATION_DISTANCE,
-    ZOMBIE_AGING_DURATION_FRAMES,
-    ZOMBIE_AGING_MIN_SPEED_RATIO,
     ZOMBIE_SIGHT_RANGE,
     ZOMBIE_SPEED,
     ZOMBIE_WALL_DAMAGE,
     car_body_radius,
 )
+from .level_constants import LEVEL_HEIGHT, LEVEL_WIDTH
+from .screen_constants import SCREEN_HEIGHT, SCREEN_WIDTH
 from .rng import get_rng
 
 RNG = get_rng()
 
 
-def circle_rect_collision(center: tuple[float, float], radius: float, rect_obj: rect.Rect) -> bool:
+def circle_rect_collision(
+    center: tuple[float, float], radius: float, rect_obj: rect.Rect
+) -> bool:
     """Return True if a circle overlaps the provided rectangle."""
     cx, cy = center
     closest_x = max(rect_obj.left, min(cx, rect_obj.right))
@@ -74,6 +74,242 @@ def circle_rect_collision(center: tuple[float, float], radius: float, rect_obj:
     return dx * dx + dy * dy <= radius * radius
 
 
+def _build_beveled_polygon(
+    width: int,
+    height: int,
+    depth: int,
+    bevels: tuple[bool, bool, bool, bool],
+) -> list[tuple[int, int]]:
+    d = max(0, min(depth, width // 2, height // 2))
+    if d == 0 or not any(bevels):
+        return [(0, 0), (width, 0), (width, height), (0, height)]
+
+    segments = max(4, d // 2)
+    tl, tr, br, bl = bevels
+    points: list[tuple[int, int]] = []
+
+    def add_point(x: float, y: float) -> None:
+        point = (int(round(x)), int(round(y)))
+        if not points or points[-1] != point:
+            points.append(point)
+
+    def add_arc(
+        center_x: float,
+        center_y: float,
+        radius: float,
+        start_deg: float,
+        end_deg: float,
+        *,
+        skip_first: bool = False,
+        skip_last: bool = False,
+    ) -> None:
+        for i in range(segments + 1):
+            if skip_first and i == 0:
+                continue
+            if skip_last and i == segments:
+                continue
+            t = i / segments
+            angle = math.radians(start_deg + (end_deg - start_deg) * t)
+            add_point(
+                center_x + radius * math.cos(angle),
+                center_y + radius * math.sin(angle),
+            )
+
+    add_point(d if tl else 0, 0)
+    if tr:
+        add_point(width - d, 0)
+        add_arc(width - d, d, d, -90, 0, skip_first=True)
+    else:
+        add_point(width, 0)
+    if br:
+        add_point(width, height - d)
+        add_arc(width - d, height - d, d, 0, 90, skip_first=True)
+    else:
+        add_point(width, height)
+    if bl:
+        add_point(d, height)
+        add_arc(d, height - d, d, 90, 180, skip_first=True)
+    else:
+        add_point(0, height)
+    if tl:
+        add_point(0, d)
+        add_arc(d, d, d, 180, 270, skip_first=True, skip_last=True)
+    return points
+
+
+def _point_in_polygon(
+    point: tuple[float, float], polygon: Sequence[tuple[float, float]]
+) -> bool:
+    x, y = point
+    inside = False
+    count = len(polygon)
+    j = count - 1
+    for i in range(count):
+        xi, yi = polygon[i]
+        xj, yj = polygon[j]
+        intersects = (yi > y) != (yj > y) and (
+            x < (xj - xi) * (y - yi) / (yj - yi + 0.000001) + xi
+        )
+        if intersects:
+            inside = not inside
+        j = i
+    return inside
+
+
+def _segments_intersect(
+    a1: tuple[float, float],
+    a2: tuple[float, float],
+    b1: tuple[float, float],
+    b2: tuple[float, float],
+) -> bool:
+    def orient(
+        p: tuple[float, float], q: tuple[float, float], r: tuple[float, float]
+    ) -> float:
+        return (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0])
+
+    def on_segment(
+        p: tuple[float, float], q: tuple[float, float], r: tuple[float, float]
+    ) -> bool:
+        return min(p[0], r[0]) <= q[0] <= max(p[0], r[0]) and min(p[1], r[1]) <= q[
+            1
+        ] <= max(p[1], r[1])
+
+    o1 = orient(a1, a2, b1)
+    o2 = orient(a1, a2, b2)
+    o3 = orient(b1, b2, a1)
+    o4 = orient(b1, b2, a2)
+
+    if (o1 > 0) != (o2 > 0) and (o3 > 0) != (o4 > 0):
+        return True
+    if o1 == 0 and on_segment(a1, b1, a2):
+        return True
+    if o2 == 0 and on_segment(a1, b2, a2):
+        return True
+    if o3 == 0 and on_segment(b1, a1, b2):
+        return True
+    if o4 == 0 and on_segment(b1, a2, b2):
+        return True
+    return False
+
+
+def _point_segment_distance_sq(
+    point: tuple[float, float],
+    seg_a: tuple[float, float],
+    seg_b: tuple[float, float],
+) -> float:
+    px, py = point
+    ax, ay = seg_a
+    bx, by = seg_b
+    dx = bx - ax
+    dy = by - ay
+    if dx == 0 and dy == 0:
+        return (px - ax) ** 2 + (py - ay) ** 2
+    t = ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)
+    t = max(0.0, min(1.0, t))
+    nearest_x = ax + t * dx
+    nearest_y = ay + t * dy
+    return (px - nearest_x) ** 2 + (py - nearest_y) ** 2
+
+
+def rect_polygon_collision(
+    rect_obj: rect.Rect, polygon: Sequence[tuple[float, float]]
+) -> bool:
+    min_x = min(p[0] for p in polygon)
+    max_x = max(p[0] for p in polygon)
+    min_y = min(p[1] for p in polygon)
+    max_y = max(p[1] for p in polygon)
+    if not rect_obj.colliderect(
+        pygame.Rect(min_x, min_y, max_x - min_x, max_y - min_y)
+    ):
+        return False
+
+    rect_points = [
+        (rect_obj.left, rect_obj.top),
+        (rect_obj.right, rect_obj.top),
+        (rect_obj.right, rect_obj.bottom),
+        (rect_obj.left, rect_obj.bottom),
+    ]
+    if any(_point_in_polygon(p, polygon) for p in rect_points):
+        return True
+    if any(rect_obj.collidepoint(p) for p in polygon):
+        return True
+
+    rect_edges = [
+        (rect_points[0], rect_points[1]),
+        (rect_points[1], rect_points[2]),
+        (rect_points[2], rect_points[3]),
+        (rect_points[3], rect_points[0]),
+    ]
+    poly_edges = [
+        (polygon[i], polygon[(i + 1) % len(polygon)]) for i in range(len(polygon))
+    ]
+    for edge_a in rect_edges:
+        for edge_b in poly_edges:
+            if _segments_intersect(edge_a[0], edge_a[1], edge_b[0], edge_b[1]):
+                return True
+    return False
+
+
+def circle_polygon_collision(
+    center: tuple[float, float],
+    radius: float,
+    polygon: Sequence[tuple[float, float]],
+) -> bool:
+    if _point_in_polygon(center, polygon):
+        return True
+    radius_sq = radius * radius
+    for i in range(len(polygon)):
+        a = polygon[i]
+        b = polygon[(i + 1) % len(polygon)]
+        if _point_segment_distance_sq(center, a, b) <= radius_sq:
+            return True
+    return False
+
+
+def collide_sprite_wall(
+    sprite: pygame.sprite.Sprite, wall: pygame.sprite.Sprite
+) -> bool:
+    if hasattr(sprite, "radius"):
+        center = sprite.rect.center
+        radius = float(getattr(sprite, "radius"))
+        if hasattr(wall, "collides_circle"):
+            return wall.collides_circle(center, radius)
+        return circle_rect_collision(center, radius, wall.rect)
+    if hasattr(wall, "collides_rect"):
+        return wall.collides_rect(sprite.rect)
+    if hasattr(sprite, "collides_rect"):
+        return sprite.collides_rect(wall.rect)
+    return sprite.rect.colliderect(wall.rect)
+
+
+def spritecollide_walls(
+    sprite: pygame.sprite.Sprite,
+    walls: pygame.sprite.Group,
+    *,
+    dokill: bool = False,
+) -> list[pygame.sprite.Sprite]:
+    return pygame.sprite.spritecollide(
+        sprite, walls, dokill, collided=collide_sprite_wall
+    )
+
+
+def spritecollideany_walls(
+    sprite: pygame.sprite.Sprite,
+    walls: pygame.sprite.Group,
+) -> pygame.sprite.Sprite | None:
+    return pygame.sprite.spritecollideany(sprite, walls, collided=collide_sprite_wall)
+
+
+def circle_wall_collision(
+    center: tuple[float, float],
+    radius: float,
+    wall: pygame.sprite.Sprite,
+) -> bool:
+    if hasattr(wall, "collides_circle"):
+        return wall.collides_circle(center, radius)
+    return circle_rect_collision(center, radius, wall.rect)
+
+
 # --- Camera Class ---
 class Wall(pygame.sprite.Sprite):
     def __init__(
@@ -87,20 +323,32 @@ class Wall(pygame.sprite.Sprite):
         color: tuple[int, int, int] = INTERNAL_WALL_COLOR,
         border_color: tuple[int, int, int] = INTERNAL_WALL_BORDER_COLOR,
         palette_category: str = "inner_wall",
+        bevel_depth: int = INTERNAL_WALL_BEVEL_DEPTH,
+        bevel_mask: tuple[bool, bool, bool, bool] | None = None,
         on_destroy: Callable[[Self], None] | None = None,
     ) -> None:
         super().__init__()
         safe_width = max(1, width)
         safe_height = max(1, height)
-        self.image = pygame.Surface((safe_width, safe_height))
+        self.image = pygame.Surface((safe_width, safe_height), pygame.SRCALPHA)
         self.base_color = color
         self.border_base_color = border_color
         self.palette_category = palette_category
         self.health = health
         self.max_health = max(1, health)
         self.on_destroy = on_destroy
+        self.bevel_depth = max(0, bevel_depth)
+        self.bevel_mask = bevel_mask or (False, False, False, False)
+        self._local_polygon = _build_beveled_polygon(
+            safe_width, safe_height, self.bevel_depth, self.bevel_mask
+        )
         self.update_color()
         self.rect = self.image.get_rect(topleft=(x, y))
+        self._collision_polygon = (
+            [(px + self.rect.x, py + self.rect.y) for px, py in self._local_polygon]
+            if self.bevel_depth > 0 and any(self.bevel_mask)
+            else None
+        )
 
     def take_damage(self: Self, *, amount: int = 1) -> None:
         if self.health > 0:
@@ -115,9 +363,10 @@ class Wall(pygame.sprite.Sprite):
                 self.kill()
 
     def update_color(self: Self) -> None:
+        self.image.fill((0, 0, 0, 0))
         if self.health <= 0:
-            self.image.fill((40, 40, 40))
             health_ratio = 0
+            fill_color = (40, 40, 40)
         else:
             health_ratio = max(0, self.health / self.max_health)
             mix = (
@@ -126,12 +375,44 @@ class Wall(pygame.sprite.Sprite):
             r = int(self.base_color[0] * mix)
             g = int(self.base_color[1] * mix)
             b = int(self.base_color[2] * mix)
-            self.image.fill((r, g, b))
+            fill_color = (r, g, b)
         # Bright edge to separate walls from floor
         br = int(self.border_base_color[0] * (0.6 + 0.4 * health_ratio))
         bg = int(self.border_base_color[1] * (0.6 + 0.4 * health_ratio))
         bb = int(self.border_base_color[2] * (0.6 + 0.4 * health_ratio))
-        pygame.draw.rect(self.image, (br, bg, bb), self.image.get_rect(), width=9)
+        border_color = (br, bg, bb)
+
+        if self.bevel_depth > 0 and any(self.bevel_mask):
+            pygame.draw.polygon(self.image, border_color, self._local_polygon)
+        else:
+            self.image.fill(border_color)
+        border_width = 18
+        inner_rect = self.image.get_rect().inflate(-border_width, -border_width)
+        if inner_rect.width > 0 and inner_rect.height > 0:
+            inner_depth = max(0, self.bevel_depth - border_width)
+            if inner_depth > 0 and any(self.bevel_mask):
+                inner_polygon = _build_beveled_polygon(
+                    inner_rect.width,
+                    inner_rect.height,
+                    inner_depth,
+                    self.bevel_mask,
+                )
+                inner_points = [
+                    (px + inner_rect.x, py + inner_rect.y) for px, py in inner_polygon
+                ]
+                pygame.draw.polygon(self.image, fill_color, inner_points)
+            else:
+                pygame.draw.rect(self.image, fill_color, inner_rect)
+
+    def collides_rect(self: Self, rect_obj: rect.Rect) -> bool:
+        if self._collision_polygon is None:
+            return self.rect.colliderect(rect_obj)
+        return rect_polygon_collision(rect_obj, self._collision_polygon)
+
+    def collides_circle(self: Self, center: tuple[float, float], radius: float) -> bool:
+        if self._collision_polygon is None:
+            return circle_rect_collision(center, radius, self.rect)
+        return circle_polygon_collision(center, radius, self._collision_polygon)
 
     def set_palette_colors(
         self: Self,
@@ -142,7 +423,11 @@ class Wall(pygame.sprite.Sprite):
     ) -> None:
         """Update the wall's base colors to match the current ambient palette."""
 
-        if not force and self.base_color == color and self.border_base_color == border_color:
+        if (
+            not force
+            and self.base_color == color
+            and self.border_base_color == border_color
+        ):
             return
         self.base_color = color
         self.border_base_color = border_color
@@ -247,7 +532,7 @@ class Player(pygame.sprite.Sprite):
             self.x += dx
             self.x = min(LEVEL_WIDTH, max(0, self.x))
             self.rect.centerx = int(self.x)
-            hit_list_x = pygame.sprite.spritecollide(self, walls, False)
+            hit_list_x = spritecollide_walls(self, walls)
             if hit_list_x:
                 damage = max(1, PLAYER_WALL_DAMAGE // len(hit_list_x))
                 for wall in hit_list_x:
@@ -260,7 +545,7 @@ class Player(pygame.sprite.Sprite):
             self.y += dy
             self.y = min(LEVEL_HEIGHT, max(0, self.y))
             self.rect.centery = int(self.y)
-            hit_list_y = pygame.sprite.spritecollide(self, walls, False)
+            hit_list_y = spritecollide_walls(self, walls)
             if hit_list_y:
                 damage = max(1, PLAYER_WALL_DAMAGE // len(hit_list_y))
                 for wall in hit_list_y:
@@ -323,13 +608,13 @@ class Companion(pygame.sprite.Sprite):
         if move_x != 0:
             self.x += move_x
             self.rect.centerx = int(self.x)
-            if pygame.sprite.spritecollideany(self, walls):
+            if spritecollideany_walls(self, walls):
                 self.x -= move_x
                 self.rect.centerx = int(self.x)
         if move_y != 0:
             self.y += move_y
             self.rect.centery = int(self.y)
-            if pygame.sprite.spritecollideany(self, walls):
+            if spritecollideany_walls(self, walls):
                 self.y -= move_y
                 self.rect.centery = int(self.y)
 
@@ -378,13 +663,13 @@ class Survivor(pygame.sprite.Sprite):
         if move_x:
             self.x += move_x
             self.rect.centerx = int(self.x)
-            if pygame.sprite.spritecollideany(self, walls):
+            if spritecollideany_walls(self, walls):
                 self.x -= move_x
                 self.rect.centerx = int(self.x)
         if move_y:
             self.y += move_y
             self.rect.centery = int(self.y)
-            if pygame.sprite.spritecollideany(self, walls):
+            if spritecollideany_walls(self, walls):
                 self.y -= move_y
                 self.rect.centery = int(self.y)
 
@@ -428,11 +713,8 @@ class Zombie(pygame.sprite.Sprite):
         else:
             x, y = random_position_outside_building()
         self.rect = self.image.get_rect(center=(x, y))
-        jitter = (
-            FAST_ZOMBIE_SPEED_JITTER
-            if speed > ZOMBIE_SPEED
-            else NORMAL_ZOMBIE_SPEED_JITTER
-        )
+        jitter_base = FAST_ZOMBIE_BASE_SPEED if speed > ZOMBIE_SPEED else ZOMBIE_SPEED
+        jitter = jitter_base * 0.2
         base_speed = speed + RNG.uniform(-jitter, jitter)
         self.initial_speed = base_speed
         self.speed = base_speed
@@ -500,21 +782,18 @@ class Zombie(pygame.sprite.Sprite):
             if abs(w.rect.centerx - self.x) < 100 and abs(w.rect.centery - self.y) < 100
         ]
 
-        temp_rect = self.rect.copy()
-        temp_rect.centerx = int(next_x)
-        temp_rect.centery = int(self.y)
         for wall in possible_walls:
-            if temp_rect.colliderect(wall.rect):
+            collides = circle_wall_collision((next_x, self.y), self.radius, wall)
+            if collides:
                 if wall.alive():
                     wall.take_damage(amount=ZOMBIE_WALL_DAMAGE)
                 if wall.alive():
                     final_x = self.x
                     break
 
-        temp_rect.centerx = int(final_x)
-        temp_rect.centery = int(next_y)
         for wall in possible_walls:
-            if temp_rect.colliderect(wall.rect):
+            collides = circle_wall_collision((final_x, next_y), self.radius, wall)
+            if collides:
                 if wall.alive():
                     wall.take_damage(amount=ZOMBIE_WALL_DAMAGE)
                 if wall.alive():
@@ -619,14 +898,30 @@ class Zombie(pygame.sprite.Sprite):
         self.image.fill((0, 0, 0, 0))
         color = (80, 80, 80)
         pygame.draw.circle(self.image, color, (self.radius, self.radius), self.radius)
-        pygame.draw.circle(self.image, (30, 30, 30), (self.radius, self.radius), self.radius, width=2)
+        pygame.draw.circle(
+            self.image, (30, 30, 30), (self.radius, self.radius), self.radius, width=2
+        )
 
 
 class Car(pygame.sprite.Sprite):
-    def __init__(self: Self, x: int, y: int) -> None:
+    COLOR_SCHEMES: dict[str, dict[str, tuple[int, int, int]]] = {
+        "default": {
+            "healthy": YELLOW,
+            "damaged": ORANGE,
+            "critical": DARK_RED,
+        },
+        "disabled": {
+            "healthy": (185, 185, 185),
+            "damaged": (150, 150, 150),
+            "critical": (110, 110, 110),
+        },
+    }
+
+    def __init__(self: Self, x: int, y: int, *, appearance: str = "default") -> None:
         super().__init__()
         self.original_image = pygame.Surface((CAR_WIDTH, CAR_HEIGHT), pygame.SRCALPHA)
-        self.base_color = YELLOW
+        self.appearance = appearance if appearance in self.COLOR_SCHEMES else "default"
+        self.base_color = self.COLOR_SCHEMES[self.appearance]["healthy"]
         self.image = self.original_image.copy()
         self.rect = self.image.get_rect(center=(x, y))
         self.speed = CAR_SPEED
@@ -645,11 +940,12 @@ class Car(pygame.sprite.Sprite):
 
     def update_color(self: Self) -> None:
         health_ratio = max(0, self.health / self.max_health)
-        color = YELLOW
+        palette = self.COLOR_SCHEMES.get(self.appearance, self.COLOR_SCHEMES["default"])
+        color = palette["healthy"]
         if health_ratio < 0.6:
-            color = ORANGE
+            color = palette["damaged"]
         if health_ratio < 0.3:
-            color = DARK_RED
+            color = palette["critical"]
         self.original_image.fill((0, 0, 0, 0))
 
         body_rect = pygame.Rect(1, 4, CAR_WIDTH - 2, CAR_HEIGHT - 8)
@@ -739,7 +1035,7 @@ class Car(pygame.sprite.Sprite):
         ]
         car_center = (new_x, new_y)
         for wall in possible_walls:
-            if circle_rect_collision(car_center, self.collision_radius, wall.rect):
+            if circle_wall_collision(car_center, self.collision_radius, wall):
                 hit_walls.append(wall)
         if hit_walls:
             self.take_damage(CAR_WALL_DAMAGE)