zombie-escape 1.14.4__py3-none-any.whl → 1.15.2__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.14.4"
+__version__ = "1.15.2"

zombie_escape/config.py

@@ -11,6 +11,7 @@ APP_NAME = "ZombieEscape"
 DEFAULT_CONFIG: dict[str, Any] = {
     "language": "en",
     "footprints": {"enabled": True},
+    "visual": {"shadows": {"enabled": True}},
     "fast_zombies": {"enabled": False, "ratio": 0.1},
     "car_hint": {"enabled": True, "delay_ms": 180_000},
     "steel_beams": {"enabled": False, "chance": 0.05},

zombie_escape/entities.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import math
-from typing import Callable, Iterable, Sequence, cast
+from typing import TYPE_CHECKING, Callable, Iterable, Sequence, cast
 
 try:
     from typing import Self
@@ -13,10 +13,14 @@ except ImportError:  # pragma: no cover - Python 3.10 fallback
 import pygame
 from pygame import rect
 
+if TYPE_CHECKING:
+    from .models import LevelLayout
+
 from .entities_constants import (
     BUDDY_FOLLOW_SPEED,
     BUDDY_RADIUS,
     BUDDY_WALL_DAMAGE,
+    BUDDY_WALL_DAMAGE_RANGE,
     CAR_HEALTH,
     CAR_HEIGHT,
     CAR_SPEED,
@@ -50,9 +54,6 @@ from .entities_constants import (
     ZOMBIE_SIGHT_RANGE,
     ZOMBIE_SPEED,
     ZOMBIE_TRACKER_FAR_SCENT_RADIUS,
-    ZOMBIE_TRACKER_CROWD_BAND_LENGTH,
-    ZOMBIE_TRACKER_CROWD_BAND_WIDTH,
-    ZOMBIE_TRACKER_CROWD_COUNT,
     ZOMBIE_TRACKER_NEWER_FOOTPRINT_MS,
     ZOMBIE_TRACKER_RELOCK_DELAY_MS,
     ZOMBIE_TRACKER_SCAN_INTERVAL_MS,
@@ -97,7 +98,7 @@ from .render_assets import (
 from .render_constants import ANGLE_BINS, ZOMBIE_NOSE_COLOR
 from .rng import get_rng
 from .screen_constants import SCREEN_HEIGHT, SCREEN_WIDTH
-from .world_grid import WallIndex, apply_tile_edge_nudge, walls_for_radius
+from .world_grid import WallIndex, apply_cell_edge_nudge, walls_for_radius
 
 RNG = get_rng()
 
@@ -335,9 +336,7 @@ MovementStrategy = Callable[
         Iterable["Zombie"],
         list[Footprint],
         int,
-        int,
-        int,
-        set[tuple[int, int]] | None,
+        "LevelLayout",
     ],
     tuple[float, float],
 ]
@@ -669,16 +668,15 @@ class Player(pygame.sprite.Sprite):
         *,
         wall_index: WallIndex | None = None,
         cell_size: int | None = None,
-        level_width: int | None = None,
-        level_height: int | None = None,
-        pitfall_cells: set[tuple[int, int]] | None = None,
-        walkable_cells: list[tuple[int, int]] | None = None,
+        layout: LevelLayout,
     ) -> None:
         if self.in_car:
             return
 
-        if level_width is None or level_height is None:
-            raise ValueError("level_width/level_height are required for movement")
+        pitfall_cells = layout.pitfall_cells
+        walkable_cells = layout.walkable_cells
+        level_width = layout.field_rect.width
+        level_height = layout.field_rect.height
 
         now = pygame.time.get_ticks()
         if self.is_jumping:
@@ -882,18 +880,13 @@ class Survivor(pygame.sprite.Sprite):
         *,
         wall_index: WallIndex | None = None,
         cell_size: int | None = None,
-        wall_cells: set[tuple[int, int]] | None = None,
-        pitfall_cells: set[tuple[int, int]] | None = None,
-        walkable_cells: list[tuple[int, int]] | None = None,
-        bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] | None = None,
-        grid_cols: int | None = None,
-        grid_rows: int | None = None,
-        level_width: int | None = None,
-        level_height: int | None = None,
+        layout: LevelLayout,
         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")
+        pitfall_cells = layout.pitfall_cells
+        walkable_cells = layout.walkable_cells
+        level_width = layout.field_rect.width
+        level_height = layout.field_rect.height
 
         now = pygame.time.get_ticks()
         if self.is_jumping:
@@ -928,17 +921,14 @@ class Survivor(pygame.sprite.Sprite):
             move_x = (dx / dist) * BUDDY_FOLLOW_SPEED
             move_y = (dy / dist) * BUDDY_FOLLOW_SPEED
 
-            if cell_size is not None and wall_cells is not None and grid_cols is not None and grid_rows is not None:
-                move_x, move_y = apply_tile_edge_nudge(
+            if cell_size is not None:
+                move_x, move_y = apply_cell_edge_nudge(
                     self.x,
                     self.y,
                     move_x,
                     move_y,
+                    layout=layout,
                     cell_size=cell_size,
-                    wall_cells=wall_cells,
-                    bevel_corners=bevel_corners,
-                    grid_cols=grid_cols,
-                    grid_rows=grid_rows,
                 )
 
             self._update_input_facing(move_x, move_y)
@@ -986,7 +976,12 @@ class Survivor(pygame.sprite.Sprite):
                 if hit_wall or blocked_by_pitfall:
                     if hit_wall:
                         if hit_wall.alive():
-                            hit_wall._take_damage(amount=max(1, BUDDY_WALL_DAMAGE))
+                            dx_to_player = player_pos[0] - self.x
+                            dy_to_player = player_pos[1] - self.y
+                            if dx_to_player * dx_to_player + dy_to_player * dy_to_player <= (
+                                BUDDY_WALL_DAMAGE_RANGE * BUDDY_WALL_DAMAGE_RANGE
+                            ):
+                                hit_wall._take_damage(amount=max(1, BUDDY_WALL_DAMAGE))
                         if _is_inner_wall(hit_wall):
                             inner_wall_hit = True
                     self.x -= move_x
@@ -1017,7 +1012,12 @@ class Survivor(pygame.sprite.Sprite):
                 if hit_wall or blocked_by_pitfall:
                     if hit_wall:
                         if hit_wall.alive():
-                            hit_wall._take_damage(amount=max(1, BUDDY_WALL_DAMAGE))
+                            dx_to_player = player_pos[0] - self.x
+                            dy_to_player = player_pos[1] - self.y
+                            if dx_to_player * dx_to_player + dy_to_player * dy_to_player <= (
+                                BUDDY_WALL_DAMAGE_RANGE * BUDDY_WALL_DAMAGE_RANGE
+                            ):
+                                hit_wall._take_damage(amount=max(1, BUDDY_WALL_DAMAGE))
                         if _is_inner_wall(hit_wall):
                             inner_wall_hit = True
                     self.y -= move_y
@@ -1069,17 +1069,14 @@ class Survivor(pygame.sprite.Sprite):
             )
         )
 
-        if cell_size is not None and wall_cells is not None and grid_cols is not None and grid_rows is not None:
-            move_x, move_y = apply_tile_edge_nudge(
+        if cell_size is not None:
+            move_x, move_y = apply_cell_edge_nudge(
                 self.x,
                 self.y,
                 move_x,
                 move_y,
+                layout=layout,
                 cell_size=cell_size,
-                wall_cells=wall_cells,
-                bevel_corners=bevel_corners,
-                grid_cols=grid_cols,
-                grid_rows=grid_rows,
             )
 
         if move_x:
@@ -1199,66 +1196,34 @@ def _zombie_tracker_movement(
     nearby_zombies: Iterable[Zombie],
     footprints: list[Footprint],
     cell_size: int,
-    grid_cols: int,
-    grid_rows: int,
-    outer_wall_cells: set[tuple[int, int]] | None,
-    pitfall_cells: set[tuple[int, int]] | None,
+    layout: LevelLayout,
 ) -> tuple[float, float]:
     is_in_sight = zombie._update_mode(player_center, ZOMBIE_TRACKER_SIGHT_RANGE)
     if not is_in_sight:
-        if _zombie_tracker_is_crowded(zombie, nearby_zombies):
+        if zombie.tracker_force_wander:
             last_target_time = zombie.tracker_target_time
             if last_target_time is None:
                 last_target_time = pygame.time.get_ticks()
             zombie.tracker_relock_after_time = last_target_time + ZOMBIE_TRACKER_RELOCK_DELAY_MS
             zombie.tracker_target_pos = None
-            return _zombie_wander_move(
+            return _zombie_wander_movement(
                 zombie,
                 walls,
                 cell_size=cell_size,
-                grid_cols=grid_cols,
-                grid_rows=grid_rows,
-                outer_wall_cells=outer_wall_cells,
-                pitfall_cells=pitfall_cells,
+                layout=layout,
             )
         _zombie_update_tracker_target(zombie, footprints, walls)
         if zombie.tracker_target_pos is not None:
             return _zombie_move_toward(zombie, zombie.tracker_target_pos)
-        return _zombie_wander_move(
+        return _zombie_wander_movement(
             zombie,
             walls,
             cell_size=cell_size,
-            grid_cols=grid_cols,
-            grid_rows=grid_rows,
-            outer_wall_cells=outer_wall_cells,
-            pitfall_cells=pitfall_cells,
+            layout=layout,
         )
     return _zombie_move_toward(zombie, player_center)
 
 
-def _zombie_wander_movement(
-    zombie: Zombie,
-    _player_center: tuple[int, int],
-    walls: list[Wall],
-    _nearby_zombies: Iterable[Zombie],
-    _footprints: list[Footprint],
-    cell_size: int,
-    grid_cols: int,
-    grid_rows: int,
-    outer_wall_cells: set[tuple[int, int]] | None,
-    pitfall_cells: set[tuple[int, int]] | None,
-) -> tuple[float, float]:
-    return _zombie_wander_move(
-        zombie,
-        walls,
-        cell_size=cell_size,
-        grid_cols=grid_cols,
-        grid_rows=grid_rows,
-        outer_wall_cells=outer_wall_cells,
-        pitfall_cells=pitfall_cells,
-    )
-
-
 def _zombie_wall_hug_has_wall(
     zombie: Zombie,
     walls: list[Wall],
@@ -1308,10 +1273,7 @@ def _zombie_wall_hug_movement(
     _nearby_zombies: Iterable[Zombie],
     _footprints: list[Footprint],
     cell_size: int,
-    grid_cols: int,
-    grid_rows: int,
-    outer_wall_cells: set[tuple[int, int]] | None,
-    pitfall_cells: set[tuple[int, int]] | None,
+    layout: LevelLayout,
 ) -> tuple[float, float]:
     is_in_sight = zombie._update_mode(player_center, ZOMBIE_TRACKER_SIGHT_RANGE)
     if zombie.wall_hug_angle is None:
@@ -1342,14 +1304,11 @@ def _zombie_wall_hug_movement(
         else:
             if is_in_sight:
                 return _zombie_move_toward(zombie, player_center)
-            return _zombie_wander_move(
+            return _zombie_wander_movement(
                 zombie,
                 walls,
                 cell_size=cell_size,
-                grid_cols=grid_cols,
-                grid_rows=grid_rows,
-                outer_wall_cells=outer_wall_cells,
-                pitfall_cells=pitfall_cells,
+                layout=layout,
             )
 
     sensor_distance = ZOMBIE_WALL_HUG_SENSOR_DISTANCE + zombie.radius
@@ -1405,21 +1364,15 @@ def _zombie_normal_movement(
     _nearby_zombies: Iterable[Zombie],
     _footprints: list[Footprint],
     cell_size: int,
-    grid_cols: int,
-    grid_rows: int,
-    outer_wall_cells: set[tuple[int, int]] | None,
-    pitfall_cells: set[tuple[int, int]] | None,
+    layout: LevelLayout,
 ) -> tuple[float, float]:
     is_in_sight = zombie._update_mode(player_center, ZOMBIE_SIGHT_RANGE)
     if not is_in_sight:
-        return _zombie_wander_move(
+        return _zombie_wander_movement(
             zombie,
             walls,
             cell_size=cell_size,
-            grid_cols=grid_cols,
-            grid_rows=grid_rows,
-            outer_wall_cells=outer_wall_cells,
-            pitfall_cells=pitfall_cells,
+            layout=layout,
         )
     return _zombie_move_toward(zombie, player_center)
 
@@ -1429,6 +1382,7 @@ def _zombie_update_tracker_target(
     footprints: list[Footprint],
     walls: list[Wall],
 ) -> None:
+    # footprints are ordered oldest -> newest by time.
     now = pygame.time.get_ticks()
     if now - zombie.tracker_last_scan_time < zombie.tracker_scan_interval_ms:
         return
@@ -1436,43 +1390,42 @@ def _zombie_update_tracker_target(
     if not footprints:
         zombie.tracker_target_pos = None
         return
-    nearby: list[Footprint] = []
     last_target_time = zombie.tracker_target_time
     far_radius_sq = ZOMBIE_TRACKER_FAR_SCENT_RADIUS * ZOMBIE_TRACKER_FAR_SCENT_RADIUS
-    latest_fp_time: int | None = None
     relock_after = zombie.tracker_relock_after_time
+    far_candidates: list[tuple[float, Footprint]] = []
     for fp in footprints:
         dx = fp.pos[0] - zombie.x
         dy = fp.pos[1] - zombie.y
-        if dx * dx + dy * dy <= far_radius_sq:
-            if latest_fp_time is None or fp.time > latest_fp_time:
-                latest_fp_time = fp.time
+        d2 = dx * dx + dy * dy
+        if d2 <= far_radius_sq:
+            far_candidates.append((d2, fp))
+    if not far_candidates:
+        return
+    latest_fp_time = far_candidates[-1][1].time
     use_far_scan = last_target_time is None or (
         latest_fp_time is not None and latest_fp_time - last_target_time >= ZOMBIE_TRACKER_NEWER_FOOTPRINT_MS
     )
     scan_radius = ZOMBIE_TRACKER_FAR_SCENT_RADIUS if use_far_scan else ZOMBIE_TRACKER_SCENT_RADIUS
     scent_radius_sq = scan_radius * scan_radius
     min_target_dist_sq = (FOOTPRINT_STEP_DISTANCE * 0.5) ** 2
-    for fp in footprints:
+
+    newer: list[Footprint] = []
+    for d2, fp in far_candidates:
         pos = fp.pos
         fp_time = fp.time
         if relock_after is not None and fp_time < relock_after:
             continue
-        dx = pos[0] - zombie.x
-        dy = pos[1] - zombie.y
-        if dx * dx + dy * dy <= min_target_dist_sq:
+        if d2 <= min_target_dist_sq:
             continue
-        if dx * dx + dy * dy <= scent_radius_sq:
-            nearby.append(fp)
+        if d2 <= scent_radius_sq:
+            if last_target_time is None or fp_time > last_target_time:
+                newer.append(fp)
 
-    if not nearby:
+    if not newer:
         return
 
-    nearby.sort(key=lambda fp: fp.time)
-    if last_target_time is not None:
-        newer = [fp for fp in nearby if fp.time > last_target_time]
-    else:
-        newer = nearby
+    newer.sort(key=lambda fp: fp.time)
 
     if use_far_scan or last_target_time is None:
         candidates = list(reversed(newer))[:ZOMBIE_TRACKER_SCENT_TOP_K]
@@ -1504,11 +1457,7 @@ def _zombie_update_tracker_target(
     if last_target_time is None:
         return
 
-    candidates = [fp for fp in nearby if fp.time > last_target_time]
-    if not candidates:
-        return
-    candidates.sort(key=lambda fp: fp.time)
-    next_fp = candidates[0]
+    next_fp = newer[0]
     zombie.tracker_target_pos = next_fp.pos
     zombie.tracker_target_time = next_fp.time
     if relock_after is not None and next_fp.time >= relock_after:
@@ -1516,50 +1465,17 @@ def _zombie_update_tracker_target(
     return
 
 
-def _zombie_tracker_is_crowded(
-    zombie: Zombie,
-    nearby_zombies: Iterable[Zombie],
-) -> bool:
-    dx = zombie.last_move_dx
-    dy = zombie.last_move_dy
-    if abs(dx) <= 0.001 and abs(dy) <= 0.001:
-        return False
-    angle = math.atan2(dy, dx)
-    angle_step = math.pi / 4.0
-    angle_bin = int(round(angle / angle_step)) % 8
-    dir_x = math.cos(angle_bin * angle_step)
-    dir_y = math.sin(angle_bin * angle_step)
-    perp_x = -dir_y
-    perp_y = dir_x
-    half_width = ZOMBIE_TRACKER_CROWD_BAND_WIDTH * 0.5
-    length = ZOMBIE_TRACKER_CROWD_BAND_LENGTH
-    count = 0
-    for other in nearby_zombies:
-        if other is zombie or not other.alive() or not other.tracker:
-            continue
-        offset_x = other.x - zombie.x
-        offset_y = other.y - zombie.y
-        forward = offset_x * dir_x + offset_y * dir_y
-        if forward <= 0 or forward > length:
-            continue
-        side = offset_x * perp_x + offset_y * perp_y
-        if abs(side) <= half_width:
-            count += 1
-            if count >= ZOMBIE_TRACKER_CROWD_COUNT:
-                return True
-    return False
-
-
-def _zombie_wander_move(
+def _zombie_wander_movement(
     zombie: Zombie,
     walls: list[Wall],
     *,
     cell_size: int,
-    grid_cols: int,
-    grid_rows: int,
-    outer_wall_cells: set[tuple[int, int]] | None,
-    pitfall_cells: set[tuple[int, int]] | None,
+    layout: LevelLayout,
 ) -> tuple[float, float]:
+    grid_cols = layout.grid_cols
+    grid_rows = layout.grid_rows
+    outer_wall_cells = layout.outer_wall_cells
+    pitfall_cells = layout.pitfall_cells
     now = pygame.time.get_ticks()
     changed_angle = False
     if now - zombie.last_wander_change_time > zombie.wander_change_interval:
@@ -1700,12 +1616,12 @@ class Zombie(pygame.sprite.Sprite):
         self.tracker_last_scan_time = 0
         self.tracker_scan_interval_ms = ZOMBIE_TRACKER_SCAN_INTERVAL_MS
         self.tracker_relock_after_time: int | None = None
+        self.tracker_force_wander = False
         self.wall_hug_side = RNG.choice([-1.0, 1.0]) if wall_hugging else 0.0
         self.wall_hug_angle = RNG.uniform(0, math.tau) if wall_hugging else None
         self.wall_hug_last_wall_time: int | None = None
         self.wall_hug_last_side_has_wall = False
         self.wall_hug_stuck_flag = False
-        self.pos_history: list[tuple[float, float]] = []
         self.wander_angle = RNG.uniform(0, math.tau)
         self.wander_interval_ms = ZOMBIE_TRACKER_WANDER_INTERVAL_MS if tracker else ZOMBIE_WANDER_INTERVAL_MS
         self.last_wander_change_time = pygame.time.get_ticks()
@@ -1721,6 +1637,13 @@ class Zombie(pygame.sprite.Sprite):
         self.was_in_sight = is_in_sight
         return is_in_sight
 
+    def _apply_wall_contact_damage(self: Self, walls: list[Wall]) -> None:
+        possible_walls = [w for w in walls if abs(w.rect.centerx - self.x) < 100 and abs(w.rect.centery - self.y) < 100]
+        for wall in possible_walls:
+            if _circle_wall_collision((self.x, self.y), self.radius, wall):
+                if wall.alive():
+                    wall._take_damage(amount=ZOMBIE_WALL_DAMAGE)
+
     def _handle_wall_collision(self: Self, next_x: float, next_y: float, walls: list[Wall]) -> tuple[float, float]:
         final_x, final_y = next_x, next_y
 
@@ -1753,6 +1676,7 @@ class Zombie(pygame.sprite.Sprite):
         zombies: Iterable[Zombie],
     ) -> tuple[float, float]:
         """If another zombie is too close, steer directly away from the closest one."""
+        orig_move_x, orig_move_y = move_x, move_y
         next_x = self.x + move_x
         next_y = self.y + move_y
 
@@ -1796,6 +1720,16 @@ class Zombie(pygame.sprite.Sprite):
 
         move_x = (away_dx / away_dist) * self.speed
         move_y = (away_dy / away_dist) * self.speed
+        if self.wall_hugging:
+            if orig_move_x or orig_move_y:
+                orig_angle = math.atan2(orig_move_y, orig_move_x)
+                new_angle = math.atan2(move_y, move_x)
+                diff = (new_angle - orig_angle + math.pi) % math.tau - math.pi
+                if abs(diff) > math.pi / 2.0:
+                    clamped = math.copysign(math.pi / 2.0, diff)
+                    new_angle = orig_angle + clamped
+                    move_x = math.cos(new_angle) * self.speed
+                    move_y = math.sin(new_angle) * self.speed
         return move_x, move_y
 
     def _apply_aging(self: Self) -> None:
@@ -1849,23 +1783,6 @@ class Zombie(pygame.sprite.Sprite):
                 color=ZOMBIE_NOSE_COLOR,
             )
 
-    def _update_stuck_state(self: Self) -> None:
-        history = self.pos_history
-        history.append((self.x, self.y))
-        if len(history) > 20:
-            history.pop(0)
-            max_dist_sq = max((self.x - hx) ** 2 + (self.y - hy) ** 2 for hx, hy in history)
-            self.wall_hug_stuck_flag = max_dist_sq < 25
-        if not self.wall_hug_stuck_flag:
-            return
-        if self.wall_hugging:
-            if self.wall_hug_angle is None:
-                self.wall_hug_angle = self.wander_angle
-            self.wall_hug_angle = (self.wall_hug_angle + math.pi) % math.tau
-            self.wall_hug_side *= -1.0
-        self.wall_hug_stuck_flag = False
-        self.pos_history = []
-
     def _avoid_pitfalls(
         self: Self,
         pitfall_cells: set[tuple[int, int]],
@@ -1907,18 +1824,13 @@ class Zombie(pygame.sprite.Sprite):
         footprints: list[Footprint] | None = None,
         *,
         cell_size: int,
-        grid_cols: int,
-        grid_rows: int,
-        level_width: int,
-        level_height: int,
-        outer_wall_cells: set[tuple[int, int]] | None = None,
-        wall_cells: set[tuple[int, int]] | None = None,
-        pitfall_cells: set[tuple[int, int]] | None = None,
-        bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] | None = None,
+        layout: LevelLayout,
     ) -> None:
         if self.carbonized:
             return
-        self._update_stuck_state()
+        level_width = layout.field_rect.width
+        level_height = layout.field_rect.height
+        self._apply_wall_contact_damage(walls)
         self._apply_aging()
         dx_player = player_center[0] - self.x
         dy_player = player_center[1] - self.y
@@ -1932,30 +1844,45 @@ class Zombie(pygame.sprite.Sprite):
             nearby_zombies,
             footprints or [],
             cell_size,
-            grid_cols,
-            grid_rows,
-            outer_wall_cells,
-            pitfall_cells,
+            layout,
         )
         if dist_to_player_sq <= avoid_radius_sq or self.wall_hugging:
             move_x, move_y = self._avoid_other_zombies(move_x, move_y, nearby_zombies)
-        if wall_cells is not None:
-            move_x, move_y = apply_tile_edge_nudge(
-                self.x,
-                self.y,
-                move_x,
-                move_y,
-                cell_size=cell_size,
-                wall_cells=wall_cells,
-                bevel_corners=bevel_corners,
-                grid_cols=grid_cols,
-                grid_rows=grid_rows,
-            )
+        move_x, move_y = apply_cell_edge_nudge(
+            self.x,
+            self.y,
+            move_x,
+            move_y,
+            layout=layout,
+            cell_size=cell_size,
+        )
         self._update_facing_from_movement(move_x, move_y)
         self._apply_render_overlays()
         self.last_move_dx = move_x
         self.last_move_dy = move_y
-        final_x, final_y = self._handle_wall_collision(self.x + move_x, self.y + move_y, walls)
+        possible_walls = [w for w in walls if abs(w.rect.centerx - self.x) < 100 and abs(w.rect.centery - self.y) < 100]
+        final_x = self.x
+        final_y = self.y
+        if move_x:
+            next_x = final_x + move_x
+            for wall in possible_walls:
+                if _circle_wall_collision((next_x, final_y), self.radius, wall):
+                    if wall.alive():
+                        wall._take_damage(amount=ZOMBIE_WALL_DAMAGE)
+                    if wall.alive():
+                        next_x = final_x
+                        break
+            final_x = next_x
+        if move_y:
+            next_y = final_y + move_y
+            for wall in possible_walls:
+                if _circle_wall_collision((final_x, next_y), self.radius, wall):
+                    if wall.alive():
+                        wall._take_damage(amount=ZOMBIE_WALL_DAMAGE)
+                    if wall.alive():
+                        next_y = final_y
+                        break
+            final_y = next_y
 
         if not (0 <= final_x < level_width and 0 <= final_y < level_height):
             self.kill()

zombie_escape/entities_constants.py

@@ -11,10 +11,14 @@ 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
+BUDDY_FOLLOW_START_DISTANCE = 30
+BUDDY_FOLLOW_STOP_DISTANCE = 100
+BUDDY_WALL_DAMAGE_RANGE = 50
+BUDDY_MERGE_DISTANCE = 40
 HUMANOID_WALL_BUMP_FRAMES = 7
 
 # --- Jump settings ---
-PLAYER_JUMP_RANGE = 15  # px (enough to clear one 50px tile)
+PLAYER_JUMP_RANGE = 15  # px (enough to clear one 50px cell)
 SURVIVOR_JUMP_RANGE = int(PLAYER_JUMP_RANGE * 0.7)  # px
 JUMP_DURATION_MS = 200
 JUMP_SCALE_MAX = 0.15
@@ -54,6 +58,7 @@ ZOMBIE_TRACKER_WANDER_INTERVAL_MS = 2500
 ZOMBIE_TRACKER_CROWD_BAND_WIDTH = 50
 ZOMBIE_TRACKER_CROWD_BAND_LENGTH = 50
 ZOMBIE_TRACKER_CROWD_COUNT = 5
+ZOMBIE_TRACKER_GRID_CROWD_COUNT = 3
 ZOMBIE_TRACKER_RELOCK_DELAY_MS = 3000
 ZOMBIE_WALL_HUG_SENSOR_DISTANCE = 24
 ZOMBIE_WALL_HUG_PROBE_ANGLE_DEG = 45
@@ -85,6 +90,10 @@ __all__ = [
     "FOV_RADIUS",
     "BUDDY_RADIUS",
     "BUDDY_FOLLOW_SPEED",
+    "BUDDY_FOLLOW_START_DISTANCE",
+    "BUDDY_FOLLOW_STOP_DISTANCE",
+    "BUDDY_WALL_DAMAGE_RANGE",
+    "BUDDY_MERGE_DISTANCE",
     "HUMANOID_WALL_BUMP_FRAMES",
     "SURVIVOR_RADIUS",
     "SURVIVOR_APPROACH_RADIUS",
@@ -113,6 +122,7 @@ __all__ = [
     "ZOMBIE_TRACKER_CROWD_BAND_WIDTH",
     "ZOMBIE_TRACKER_CROWD_BAND_LENGTH",
     "ZOMBIE_TRACKER_CROWD_COUNT",
+    "ZOMBIE_TRACKER_GRID_CROWD_COUNT",
     "ZOMBIE_TRACKER_RELOCK_DELAY_MS",
     "ZOMBIE_WALL_HUG_SENSOR_DISTANCE",
     "ZOMBIE_WALL_HUG_PROBE_ANGLE_DEG",

zombie_escape/export_images.py

@@ -22,7 +22,7 @@ from .entities_constants import (
     SURVIVOR_RADIUS,
     ZOMBIE_RADIUS,
 )
-from .level_constants import DEFAULT_TILE_SIZE
+from .level_constants import DEFAULT_CELL_SIZE
 from .render_assets import (
     build_car_directional_surfaces,
     build_car_surface,
@@ -81,7 +81,7 @@ def _pick_directional_surface(surfaces: list[pygame.Surface], *, bin_index: int
     return surfaces[bin_index % len(surfaces)]
 
 
-def _build_pitfall_tile(cell_size: int) -> pygame.Surface:
+def _build_pitfall_cell(cell_size: int) -> pygame.Surface:
     surface = pygame.Surface((cell_size, cell_size), pygame.SRCALPHA)
     rect = surface.get_rect()
     pygame.draw.rect(surface, PITFALL_ABYSS_COLOR, rect)
@@ -116,7 +116,7 @@ def _build_pitfall_tile(cell_size: int) -> pygame.Surface:
     return surface
 
 
-def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE, output_scale: int = 4) -> list[Path]:
+def export_images(output_dir: Path, *, cell_size: int = DEFAULT_CELL_SIZE, output_scale: int = 4) -> list[Path]:
     _ensure_pygame_ready()
 
     saved: list[Path] = []
@@ -267,7 +267,7 @@ def export_images(output_dir: Path, *, cell_size: int = DEFAULT_TILE_SIZE, outpu
     _save_surface(outer_wall, outer_wall_path, scale=output_scale)
     saved.append(outer_wall_path)
 
-    pitfall = _build_pitfall_tile(cell_size)
+    pitfall = _build_pitfall_cell(cell_size)
     pitfall_path = out / "pitfall.png"
     _save_surface(pitfall, pitfall_path, scale=output_scale)
     saved.append(pitfall_path)