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

zombie_escape/__about__.py

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

zombie_escape/colors.py

@@ -2,7 +2,12 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-# Basic palette
+
+def _clamp(value: float) -> int:
+    return max(0, min(255, int(value)))
+
+
+# Basic palette.
 WHITE: tuple[int, int, int] = (255, 255, 255)
 BLACK: tuple[int, int, int] = (0, 0, 0)
 RED: tuple[int, int, int] = (255, 0, 0)
@@ -13,8 +18,6 @@ LIGHT_GRAY: tuple[int, int, int] = (200, 200, 200)
 YELLOW: tuple[int, int, int] = (255, 255, 0)
 ORANGE: tuple[int, int, int] = (255, 165, 0)
 DARK_RED: tuple[int, int, int] = (139, 0, 0)
-TRACKER_OUTLINE_COLOR: tuple[int, int, int] = (170, 70, 220)
-WALL_FOLLOWER_OUTLINE_COLOR: tuple[int, int, int] = (140, 140, 140)
 
 
 @dataclass(frozen=True)
@@ -32,10 +35,6 @@ class EnvironmentPalette:
     outer_wall_border: tuple[int, int, int]
 
 
-def _clamp(value: float) -> int:
-    return max(0, min(255, int(value)))
-
-
 def _adjust_color(
     color: tuple[int, int, int], *, brightness: float = 1.0, saturation: float = 1.0
 ) -> tuple[int, int, int]:
@@ -56,6 +55,7 @@ DEFAULT_AMBIENT_PALETTE_KEY = "default"
 NO_FLASHLIGHT_PALETTE_KEY = "no_flashlight"
 DAWN_AMBIENT_PALETTE_KEY = "dawn"
 
+
 # Base palette used throughout gameplay (matches the previous constants).
 _DEFAULT_ENVIRONMENT_PALETTE = EnvironmentPalette(
     floor_primary=(43, 57, 70),
@@ -72,10 +72,14 @@ _DEFAULT_ENVIRONMENT_PALETTE = EnvironmentPalette(
 # Dark, desaturated palette that sells the "alone without a flashlight" vibe.
 _GLOOM_ENVIRONMENT_PALETTE = EnvironmentPalette(
     floor_primary=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.floor_primary, brightness=0.8, saturation=0.75
+        _DEFAULT_ENVIRONMENT_PALETTE.floor_primary,
+        brightness=0.8,
+        saturation=0.75,
     ),
     floor_secondary=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.floor_secondary, brightness=0.8, saturation=0.75
+        _DEFAULT_ENVIRONMENT_PALETTE.floor_secondary,
+        brightness=0.8,
+        saturation=0.75,
     ),
     fall_zone_primary=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.fall_zone_primary,
@@ -88,10 +92,14 @@ _GLOOM_ENVIRONMENT_PALETTE = EnvironmentPalette(
         saturation=0.75,
     ),
     outside=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.outside, brightness=0.8, saturation=0.75
+        _DEFAULT_ENVIRONMENT_PALETTE.outside,
+        brightness=0.8,
+        saturation=0.75,
     ),
     inner_wall=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall, brightness=0.8, saturation=0.75
+        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall,
+        brightness=0.8,
+        saturation=0.75,
     ),
     inner_wall_border=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.inner_wall_border,
@@ -99,7 +107,9 @@ _GLOOM_ENVIRONMENT_PALETTE = EnvironmentPalette(
         saturation=0.75,
     ),
     outer_wall=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.outer_wall, brightness=0.8, saturation=0.75
+        _DEFAULT_ENVIRONMENT_PALETTE.outer_wall,
+        brightness=0.8,
+        saturation=0.75,
     ),
     outer_wall_border=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.outer_wall_border,
@@ -181,8 +191,6 @@ __all__ = [
     "YELLOW",
     "ORANGE",
     "DARK_RED",
-    "TRACKER_OUTLINE_COLOR",
-    "WALL_FOLLOWER_OUTLINE_COLOR",
     "DAWN_AMBIENT_PALETTE_KEY",
     "INTERNAL_WALL_COLOR",
     "INTERNAL_WALL_BORDER_COLOR",

zombie_escape/entities.py

@@ -16,6 +16,7 @@ from pygame import rect
 from .entities_constants import (
     BUDDY_FOLLOW_SPEED,
     BUDDY_RADIUS,
+    BUDDY_WALL_DAMAGE,
     CAR_HEALTH,
     CAR_HEIGHT,
     CAR_SPEED,
@@ -26,13 +27,14 @@ from .entities_constants import (
     FLASHLIGHT_WIDTH,
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
-    SHOES_HEIGHT,
-    SHOES_WIDTH,
+    HUMANOID_WALL_BUMP_FRAMES,
     INTERNAL_WALL_BEVEL_DEPTH,
     INTERNAL_WALL_HEALTH,
     PLAYER_RADIUS,
     PLAYER_SPEED,
     PLAYER_WALL_DAMAGE,
+    SHOES_HEIGHT,
+    SHOES_WIDTH,
     STEEL_BEAM_HEALTH,
     SURVIVOR_APPROACH_RADIUS,
     SURVIVOR_APPROACH_SPEED,
@@ -59,20 +61,24 @@ from .entities_constants import (
 )
 from .gameplay.constants import FOOTPRINT_STEP_DISTANCE
 from .models import Footprint
+from .render_constants import ANGLE_BINS, ZOMBIE_NOSE_COLOR
 from .render_assets import (
     EnvironmentPalette,
+    angle_bin_from_vector,
     build_beveled_polygon,
+    build_car_directional_surfaces,
     build_car_surface,
     build_flashlight_surface,
     build_fuel_can_surface,
+    build_player_directional_surfaces,
     build_shoes_surface,
-    build_player_surface,
-    build_survivor_surface,
-    build_zombie_surface,
+    build_survivor_directional_surfaces,
+    build_zombie_directional_surfaces,
+    draw_humanoid_hand,
+    draw_humanoid_nose,
     paint_car_surface,
     paint_steel_beam_surface,
     paint_wall_surface,
-    paint_zombie_surface,
     resolve_car_color,
     resolve_steel_beam_colors,
     resolve_wall_colors,
@@ -229,6 +235,14 @@ class SteelBeam(pygame.sprite.Sprite):
         )
 
 
+def _is_inner_wall(wall: pygame.sprite.Sprite) -> bool:
+    if isinstance(wall, SteelBeam):
+        return True
+    if isinstance(wall, Wall):
+        return wall.palette_category == "inner_wall"
+    return False
+
+
 MovementStrategy = Callable[
     [
         "Zombie",
@@ -242,6 +256,8 @@ MovementStrategy = Callable[
     ],
     tuple[float, float],
 ]
+
+
 def _sprite_center_and_radius(
     sprite: pygame.sprite.Sprite,
 ) -> tuple[tuple[int, int], float]:
@@ -567,7 +583,14 @@ class Player(pygame.sprite.Sprite):
     ) -> None:
         super().__init__()
         self.radius = PLAYER_RADIUS
-        self.image = build_player_surface(self.radius)
+        self.facing_bin = 0
+        self.input_facing_bin = 0
+        self.wall_bump_counter = 0
+        self.wall_bump_flip = 1
+        self.inner_wall_hit = False
+        self.inner_wall_cell = None
+        self.directional_images = build_player_directional_surfaces(self.radius)
+        self.image = self.directional_images[self.facing_bin]
         self.rect = self.image.get_rect(center=(x, y))
         self.speed = PLAYER_SPEED
         self.in_car = False
@@ -591,6 +614,9 @@ class Player(pygame.sprite.Sprite):
         if level_width is None or level_height is None:
             raise ValueError("level_width/level_height are required for movement")
 
+        inner_wall_hit = False
+        inner_wall_cell: tuple[int, int] | None = None
+
         if dx != 0:
             self.x += dx
             self.x = min(level_width, max(0, self.x))
@@ -606,6 +632,13 @@ class Player(pygame.sprite.Sprite):
                 for wall in hit_list_x:
                     if wall.alive():
                         wall._take_damage(amount=damage)
+                        if _is_inner_wall(wall):
+                            inner_wall_hit = True
+                            if inner_wall_cell is None and cell_size:
+                                inner_wall_cell = (
+                                    int(wall.rect.centerx // cell_size),
+                                    int(wall.rect.centery // cell_size),
+                                )
                 self.x -= dx * 1.5
                 self.rect.centerx = int(self.x)
 
@@ -624,10 +657,51 @@ class Player(pygame.sprite.Sprite):
                 for wall in hit_list_y:
                     if wall.alive():
                         wall._take_damage(amount=damage)
+                        if _is_inner_wall(wall):
+                            inner_wall_hit = True
+                            if inner_wall_cell is None and cell_size:
+                                inner_wall_cell = (
+                                    int(wall.rect.centerx // cell_size),
+                                    int(wall.rect.centery // cell_size),
+                                )
                 self.y -= dy * 1.5
                 self.rect.centery = int(self.y)
 
         self.rect.center = (int(self.x), int(self.y))
+        self.inner_wall_hit = inner_wall_hit
+        self.inner_wall_cell = inner_wall_cell
+        self._update_facing_for_bump(inner_wall_hit)
+
+    def update_facing_from_input(self: Self, dx: float, dy: float) -> None:
+        if self.in_car:
+            return
+        new_bin = angle_bin_from_vector(dx, dy)
+        if new_bin is None:
+            return
+        self.input_facing_bin = new_bin
+
+    def _update_facing_for_bump(self: Self, inner_wall_hit: bool) -> None:
+        if self.in_car:
+            return
+        if inner_wall_hit:
+            self.wall_bump_counter += 1
+            if self.wall_bump_counter % HUMANOID_WALL_BUMP_FRAMES == 0:
+                self.wall_bump_flip *= -1
+            bumped_bin = (self.input_facing_bin + self.wall_bump_flip) % ANGLE_BINS
+            self._set_facing_bin(bumped_bin)
+            return
+        if self.wall_bump_counter:
+            self.wall_bump_counter = 0
+            self.wall_bump_flip = 1
+        self._set_facing_bin(self.input_facing_bin)
+
+    def _set_facing_bin(self: Self, new_bin: int) -> None:
+        if new_bin == self.facing_bin:
+            return
+        center = self.rect.center
+        self.facing_bin = new_bin
+        self.image = self.directional_images[self.facing_bin]
+        self.rect = self.image.get_rect(center=center)
 
 
 class Survivor(pygame.sprite.Sprite):
@@ -643,10 +717,16 @@ class Survivor(pygame.sprite.Sprite):
         super().__init__()
         self.is_buddy = is_buddy
         self.radius = BUDDY_RADIUS if is_buddy else SURVIVOR_RADIUS
-        self.image = build_survivor_surface(
+        self.facing_bin = 0
+        self.input_facing_bin = 0
+        self.wall_bump_counter = 0
+        self.wall_bump_flip = 1
+        self.directional_images = build_survivor_directional_surfaces(
             self.radius,
             is_buddy=is_buddy,
+            draw_hands=is_buddy,
         )
+        self.image = self.directional_images[self.facing_bin]
         self.rect = self.image.get_rect(center=(int(x), int(y)))
         self.x = float(self.rect.centerx)
         self.y = float(self.rect.centery)
@@ -683,6 +763,7 @@ class Survivor(pygame.sprite.Sprite):
         grid_rows: int | None = None,
         level_width: int | None = None,
         level_height: int | None = None,
+        wall_target_cell: tuple[int, int] | None = None,
     ) -> None:
         if level_width is None or level_height is None:
             raise ValueError("level_width/level_height are required for movement")
@@ -691,11 +772,19 @@ class Survivor(pygame.sprite.Sprite):
                 self.rect.center = (int(self.x), int(self.y))
                 return
 
-            dx = player_pos[0] - self.x
-            dy = player_pos[1] - self.y
+            target_pos = player_pos
+            if wall_target_cell is not None and cell_size is not None:
+                target_pos = (
+                    wall_target_cell[0] * cell_size + cell_size // 2,
+                    wall_target_cell[1] * cell_size + cell_size // 2,
+                )
+
+            dx = target_pos[0] - self.x
+            dy = target_pos[1] - self.y
             dist_sq = dx * dx + dy * dy
             if dist_sq <= 0:
                 self.rect.center = (int(self.x), int(self.y))
+                self._update_facing_for_bump(False)
                 return
 
             dist = math.sqrt(dist_sq)
@@ -720,32 +809,45 @@ class Survivor(pygame.sprite.Sprite):
                     grid_rows=grid_rows,
                 )
 
+            self._update_input_facing(move_x, move_y)
+            inner_wall_hit = False
+
             if move_x:
                 self.x += move_x
                 self.rect.centerx = int(self.x)
-                if spritecollideany_walls(
+                wall = spritecollideany_walls(
                     self,
                     walls,
                     wall_index=wall_index,
                     cell_size=cell_size,
-                ):
+                )
+                if wall:
+                    if wall.alive():
+                        wall._take_damage(amount=max(1, BUDDY_WALL_DAMAGE))
+                    if _is_inner_wall(wall):
+                        inner_wall_hit = True
                     self.x -= move_x
                     self.rect.centerx = int(self.x)
             if move_y:
                 self.y += move_y
                 self.rect.centery = int(self.y)
-                if spritecollideany_walls(
+                wall = spritecollideany_walls(
                     self,
                     walls,
                     wall_index=wall_index,
                     cell_size=cell_size,
-                ):
+                )
+                if wall:
+                    if wall.alive():
+                        wall._take_damage(amount=max(1, BUDDY_WALL_DAMAGE))
+                    if _is_inner_wall(wall):
+                        inner_wall_hit = True
                     self.y -= move_y
                     self.rect.centery = int(self.y)
 
             overlap_radius = (self.radius + PLAYER_RADIUS) * 1.05
-            dx_after = player_pos[0] - self.x
-            dy_after = player_pos[1] - self.y
+            dx_after = target_pos[0] - self.x
+            dy_after = target_pos[1] - self.y
             dist_after_sq = dx_after * dx_after + dy_after * dy_after
             if 0 < dist_after_sq < overlap_radius * overlap_radius:
                 dist_after = math.sqrt(dist_after_sq)
@@ -757,6 +859,7 @@ class Survivor(pygame.sprite.Sprite):
             self.x = min(level_width, max(0, self.x))
             self.y = min(level_height, max(0, self.y))
             self.rect.center = (int(self.x), int(self.y))
+            self._update_facing_for_bump(inner_wall_hit)
             return
 
         dx = player_pos[0] - self.x
@@ -772,6 +875,8 @@ class Survivor(pygame.sprite.Sprite):
         move_x = (dx / dist) * SURVIVOR_APPROACH_SPEED
         move_y = (dy / dist) * SURVIVOR_APPROACH_SPEED
 
+        self._update_input_facing(move_x, move_y)
+
         if (
             cell_size is not None
             and wall_cells is not None
@@ -814,6 +919,37 @@ class Survivor(pygame.sprite.Sprite):
                 self.rect.centery = int(self.y)
 
         self.rect.center = (int(self.x), int(self.y))
+        self._update_facing_for_bump(False)
+
+    def _update_input_facing(self: Self, dx: float, dy: float) -> None:
+        new_bin = angle_bin_from_vector(dx, dy)
+        if new_bin is None:
+            return
+        self.input_facing_bin = new_bin
+
+    def _update_facing_for_bump(self: Self, inner_wall_hit: bool) -> None:
+        if not self.is_buddy:
+            self._set_facing_bin(self.input_facing_bin)
+            return
+        if inner_wall_hit:
+            self.wall_bump_counter += 1
+            if self.wall_bump_counter % HUMANOID_WALL_BUMP_FRAMES == 0:
+                self.wall_bump_flip *= -1
+            bumped_bin = (self.input_facing_bin + self.wall_bump_flip) % ANGLE_BINS
+            self._set_facing_bin(bumped_bin)
+            return
+        if self.wall_bump_counter:
+            self.wall_bump_counter = 0
+            self.wall_bump_flip = 1
+        self._set_facing_bin(self.input_facing_bin)
+
+    def _set_facing_bin(self: Self, new_bin: int) -> None:
+        if new_bin == self.facing_bin:
+            return
+        center = self.rect.center
+        self.facing_bin = new_bin
+        self.image = self.directional_images[self.facing_bin]
+        self.rect = self.image.get_rect(center=center)
 
 
 def random_position_outside_building(
@@ -1224,13 +1360,15 @@ class Zombie(pygame.sprite.Sprite):
     ) -> None:
         super().__init__()
         self.radius = ZOMBIE_RADIUS
+        self.facing_bin = 0
         self.tracker = tracker
         self.wall_follower = wall_follower
         self.carbonized = False
-        self.image = build_zombie_surface(
-            self.radius, tracker=self.tracker, wall_follower=self.wall_follower
+        self.directional_images = build_zombie_directional_surfaces(
+            self.radius,
+            draw_hands=False,
         )
-        self._redraw_image()
+        self.image = self.directional_images[self.facing_bin]
         self.rect = self.image.get_rect(center=(x, y))
         jitter_base = FAST_ZOMBIE_BASE_SPEED if speed > ZOMBIE_SPEED else ZOMBIE_SPEED
         jitter = jitter_base * 0.2
@@ -1269,15 +1407,6 @@ class Zombie(pygame.sprite.Sprite):
             0, self.wander_interval_ms + RNG.randint(-500, 500)
         )
 
-    def _redraw_image(self: Self, palm_angle: float | None = None) -> None:
-        paint_zombie_surface(
-            self.image,
-            radius=self.radius,
-            palm_angle=palm_angle,
-            tracker=self.tracker,
-            wall_follower=self.wall_follower,
-        )
-
     def _update_mode(
         self: Self, player_center: tuple[int, int], sight_range: float
     ) -> bool:
@@ -1384,6 +1513,53 @@ class Zombie(pygame.sprite.Sprite):
         slowdown_ratio = 1.0 - progress * (1.0 - ZOMBIE_AGING_MIN_SPEED_RATIO)
         self.speed = self.initial_speed * slowdown_ratio
 
+    def _set_facing_bin(self: Self, new_bin: int) -> None:
+        if new_bin == self.facing_bin:
+            return
+        center = self.rect.center
+        self.facing_bin = new_bin
+        self.image = self.directional_images[self.facing_bin]
+        self.rect = self.image.get_rect(center=center)
+
+    def _update_facing_from_movement(self: Self, dx: float, dy: float) -> None:
+        new_bin = angle_bin_from_vector(dx, dy)
+        if new_bin is None:
+            return
+        self._set_facing_bin(new_bin)
+
+    def _apply_render_overlays(self: Self) -> None:
+        base_surface = self.directional_images[self.facing_bin]
+        needs_overlay = self.tracker or (
+            self.wall_follower
+            and self.wall_follow_side != 0
+            and self.wall_follow_last_side_has_wall
+        )
+        if not needs_overlay:
+            self.image = base_surface
+            return
+        self.image = base_surface.copy()
+        angle_rad = (self.facing_bin % ANGLE_BINS) * (math.tau / ANGLE_BINS)
+        if self.tracker:
+            draw_humanoid_nose(
+                self.image,
+                radius=self.radius,
+                angle_rad=angle_rad,
+                color=ZOMBIE_NOSE_COLOR,
+            )
+        if (
+            self.wall_follower
+            and self.wall_follow_side != 0
+            and self.wall_follow_last_side_has_wall
+        ):
+            side_sign = 1.0 if self.wall_follow_side > 0 else -1.0
+            hand_angle = angle_rad + side_sign * (math.pi / 2.0)
+            draw_humanoid_hand(
+                self.image,
+                radius=self.radius,
+                angle_rad=hand_angle,
+                color=ZOMBIE_NOSE_COLOR,
+            )
+
     def _update_stuck_state(self: Self) -> None:
         history = self.pos_history
         history.append((self.x, self.y))
@@ -1453,18 +1629,8 @@ class Zombie(pygame.sprite.Sprite):
                 grid_cols=grid_cols,
                 grid_rows=grid_rows,
             )
-        if self.wall_follower and self.wall_follow_side != 0:
-            if move_x != 0 or move_y != 0:
-                heading = math.atan2(move_y, move_x)
-            elif self.wall_follow_angle is not None:
-                heading = self.wall_follow_angle
-            else:
-                heading = self.wander_angle
-            if self.wall_follow_side > 0:
-                palm_angle = heading + (math.pi / 2.0)
-            else:
-                palm_angle = heading - (math.pi / 2.0)
-            self._redraw_image(palm_angle)
+        self._update_facing_from_movement(move_x, move_y)
+        self._apply_render_overlays()
         final_x, final_y = self._handle_wall_collision(
             self.x + move_x, self.y + move_y, walls
         )
@@ -1482,23 +1648,31 @@ class Zombie(pygame.sprite.Sprite):
             return
         self.carbonized = True
         self.speed = 0
+        self.image = self.directional_images[self.facing_bin].copy()
         self.image.fill((0, 0, 0, 0))
         color = (80, 80, 80)
-        pygame.draw.circle(self.image, color, (self.radius, self.radius), self.radius)
+        center = self.image.get_rect().center
+        pygame.draw.circle(self.image, color, center, self.radius)
         pygame.draw.circle(
-            self.image, (30, 30, 30), (self.radius, self.radius), self.radius, width=1
+            self.image,
+            (30, 30, 30),
+            center,
+            self.radius,
+            width=1,
         )
 
 
 class Car(pygame.sprite.Sprite):
     def __init__(self: Self, x: int, y: int, *, appearance: str = "default") -> None:
         super().__init__()
+        self.facing_bin = ANGLE_BINS * 3 // 4
+        self.input_facing_bin = self.facing_bin
         self.original_image = build_car_surface(CAR_WIDTH, CAR_HEIGHT)
+        self.directional_images: list[pygame.Surface] = []
         self.appearance = appearance
         self.image = self.original_image.copy()
         self.rect = self.image.get_rect(center=(x, y))
         self.speed = CAR_SPEED
-        self.angle = 0
         self.x = float(self.rect.centerx)
         self.y = float(self.rect.centery)
         self.health = CAR_HEALTH
@@ -1520,10 +1694,28 @@ class Car(pygame.sprite.Sprite):
             height=CAR_HEIGHT,
             color=color,
         )
-        self.image = pygame.transform.rotate(self.original_image, self.angle)
+        self.directional_images = build_car_directional_surfaces(self.original_image)
+        self.image = self.directional_images[self.facing_bin]
         old_center = self.rect.center
         self.rect = self.image.get_rect(center=old_center)
 
+    def update_facing_from_input(self: Self, dx: float, dy: float) -> None:
+        new_bin = angle_bin_from_vector(dx, dy)
+        if new_bin is None:
+            return
+        self.input_facing_bin = new_bin
+        self._set_facing_bin(self.input_facing_bin)
+
+    def _set_facing_bin(self: Self, new_bin: int) -> None:
+        if new_bin == self.facing_bin:
+            return
+        if not self.directional_images:
+            return
+        center = self.rect.center
+        self.facing_bin = new_bin
+        self.image = self.directional_images[self.facing_bin]
+        self.rect = self.image.get_rect(center=center)
+
     def move(
         self: Self,
         dx: float,
@@ -1537,11 +1729,6 @@ class Car(pygame.sprite.Sprite):
         if dx == 0 and dy == 0:
             self.rect.center = (int(self.x), int(self.y))
             return
-        target_angle = math.degrees(math.atan2(-dy, dx)) - 90
-        self.angle = target_angle
-        self.image = pygame.transform.rotate(self.original_image, self.angle)
-        old_center = (self.x, self.y)
-        self.rect = self.image.get_rect(center=old_center)
         new_x = self.x + dx
         new_y = self.y + dy
 

zombie_escape/entities_constants.py

@@ -11,6 +11,7 @@ PLAYER_SPEED = 1.4
 FOV_RADIUS = 124  # approximate legacy FOV (80) * 1.55 cap
 BUDDY_RADIUS = HUMANOID_RADIUS
 BUDDY_FOLLOW_SPEED = PLAYER_SPEED * 0.7
+HUMANOID_WALL_BUMP_FRAMES = 7
 
 # --- Survivor settings (Stage 4) ---
 SURVIVOR_RADIUS = HUMANOID_RADIUS
@@ -49,8 +50,8 @@ ZOMBIE_WALL_FOLLOW_TARGET_GAP = 4.0
 ZOMBIE_WALL_FOLLOW_LOST_WALL_MS = 2500
 
 # --- Car and fuel settings ---
-CAR_WIDTH = 15
-CAR_HEIGHT = 25
+CAR_WIDTH = 16
+CAR_HEIGHT = 24
 CAR_SPEED = 2
 CAR_HEALTH = 20
 CAR_WALL_DAMAGE = 1
@@ -62,6 +63,7 @@ INTERNAL_WALL_HEALTH = 40 * 100
 INTERNAL_WALL_BEVEL_DEPTH = 6
 STEEL_BEAM_HEALTH = int(INTERNAL_WALL_HEALTH * 1.5)
 PLAYER_WALL_DAMAGE = 100
+BUDDY_WALL_DAMAGE = int(PLAYER_WALL_DAMAGE * 0.7)
 ZOMBIE_WALL_DAMAGE = 1
 
 __all__ = [
@@ -71,6 +73,7 @@ __all__ = [
     "FOV_RADIUS",
     "BUDDY_RADIUS",
     "BUDDY_FOLLOW_SPEED",
+    "HUMANOID_WALL_BUMP_FRAMES",
     "SURVIVOR_RADIUS",
     "SURVIVOR_APPROACH_RADIUS",
     "SURVIVOR_APPROACH_SPEED",
@@ -110,5 +113,6 @@ __all__ = [
     "INTERNAL_WALL_BEVEL_DEPTH",
     "STEEL_BEAM_HEALTH",
     "PLAYER_WALL_DAMAGE",
+    "BUDDY_WALL_DAMAGE",
     "ZOMBIE_WALL_DAMAGE",
 ]

zombie_escape/gameplay/footprints.py

@@ -26,6 +26,10 @@ def get_shrunk_sprite(
 
     new_sprite = pygame.sprite.Sprite()
     new_sprite.rect = rect
+    if hasattr(sprite_obj, "radius"):
+        base_radius = getattr(sprite_obj, "radius", None)
+        if base_radius is not None:
+            new_sprite.radius = base_radius * min(scale_x, scale_y)
 
     return new_sprite