zombie-escape 1.7.1__py3-none-any.whl → 1.8.0__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.7.1"
+__version__ = "1.8.0"

zombie_escape/entities.py

@@ -131,6 +131,86 @@ def walls_for_radius(
     return candidates
 
 
+def apply_tile_edge_nudge(
+    x: float,
+    y: float,
+    dx: float,
+    dy: float,
+    *,
+    cell_size: int,
+    wall_cells: set[tuple[int, int]] | None,
+    bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] | None = None,
+    grid_cols: int,
+    grid_rows: int,
+    strength: float = 0.03,
+    edge_margin_ratio: float = 0.15,
+    min_margin: float = 2.0,
+) -> tuple[float, float]:
+    if dx == 0 and dy == 0:
+        return dx, dy
+    if cell_size <= 0 or not wall_cells:
+        return dx, dy
+    cell_x = int(x // cell_size)
+    cell_y = int(y // cell_size)
+    if cell_x < 0 or cell_y < 0 or cell_x >= grid_cols or cell_y >= grid_rows:
+        return dx, dy
+    speed = math.hypot(dx, dy)
+    if speed <= 0:
+        return dx, dy
+
+    edge_margin = max(min_margin, cell_size * edge_margin_ratio)
+    left_dist = x - (cell_x * cell_size)
+    right_dist = ((cell_x + 1) * cell_size) - x
+    top_dist = y - (cell_y * cell_size)
+    bottom_dist = ((cell_y + 1) * cell_size) - y
+
+    def apply_push(dist: float, direction: float) -> float:
+        if dist >= edge_margin:
+            return 0.0
+        ratio = (edge_margin - dist) / edge_margin
+        return ratio * speed * strength * direction
+
+    if (cell_x - 1, cell_y) in wall_cells:
+        dx += apply_push(left_dist, 1.0)
+    if (cell_x + 1, cell_y) in wall_cells:
+        dx += apply_push(right_dist, -1.0)
+    if (cell_x, cell_y - 1) in wall_cells:
+        dy += apply_push(top_dist, 1.0)
+    if (cell_x, cell_y + 1) in wall_cells:
+        dy += apply_push(bottom_dist, -1.0)
+
+    def apply_corner_push(dist_a: float, dist_b: float, boost: float = 1.0) -> float:
+        if dist_a >= edge_margin or dist_b >= edge_margin:
+            return 0.0
+        ratio = (edge_margin - min(dist_a, dist_b)) / edge_margin
+        return ratio * speed * strength * boost
+
+    if bevel_corners:
+        boosted = 1.25
+        corner_wall = bevel_corners.get((cell_x - 1, cell_y - 1))
+        if corner_wall and corner_wall[2]:
+            push = apply_corner_push(left_dist, top_dist, boosted)
+            dx += push
+            dy += push
+        corner_wall = bevel_corners.get((cell_x + 1, cell_y - 1))
+        if corner_wall and corner_wall[3]:
+            push = apply_corner_push(right_dist, top_dist, boosted)
+            dx -= push
+            dy += push
+        corner_wall = bevel_corners.get((cell_x + 1, cell_y + 1))
+        if corner_wall and corner_wall[0]:
+            push = apply_corner_push(right_dist, bottom_dist, boosted)
+            dx -= push
+            dy -= push
+        corner_wall = bevel_corners.get((cell_x - 1, cell_y + 1))
+        if corner_wall and corner_wall[1]:
+            push = apply_corner_push(left_dist, bottom_dist, boosted)
+            dx += push
+            dy -= push
+
+    return dx, dy
+
+
 def _walls_for_sprite(
     sprite: pygame.sprite.Sprite,
     wall_index: WallIndex,
@@ -471,7 +551,9 @@ class Wall(pygame.sprite.Sprite):
             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:
+    def _collides_circle(
+        self: Self, center: tuple[float, float], radius: float
+    ) -> bool:
         if not _circle_rect_collision(center, radius, self.rect):
             return False
         if self._collision_polygon is None:
@@ -673,6 +755,11 @@ class Survivor(pygame.sprite.Sprite):
         *,
         wall_index: WallIndex | None = None,
         cell_size: int | None = None,
+        wall_cells: set[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,
     ) -> None:
@@ -694,6 +781,24 @@ 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(
+                    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,
+                )
+
             if move_x:
                 self.x += move_x
                 self.rect.centerx = int(self.x)
@@ -746,6 +851,24 @@ class Survivor(pygame.sprite.Sprite):
         move_x = (dx / dist) * SURVIVOR_APPROACH_SPEED
         move_y = (dy / dist) * SURVIVOR_APPROACH_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(
+                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,
+            )
+
         if move_x:
             self.x += move_x
             self.rect.centerx = int(self.x)
@@ -1068,19 +1191,17 @@ def _zombie_wander_move(
     if at_x_edge or at_y_edge:
         if outer_wall_cells is not None:
             if at_x_edge:
-                inward_cell = (
-                    (1, cell_y) if cell_x == 0 else (grid_cols - 2, cell_y)
-                )
+                inward_cell = (1, cell_y) if cell_x == 0 else (grid_cols - 2, cell_y)
                 if inward_cell not in outer_wall_cells:
-                    inward_dx = zombie.speed if cell_x == 0 else -zombie.speed
-                    return inward_dx, 0.0
+                    target_x = (inward_cell[0] + 0.5) * cell_size
+                    target_y = (inward_cell[1] + 0.5) * cell_size
+                    return zombie_move_toward(zombie, (target_x, target_y))
             if at_y_edge:
-                inward_cell = (
-                    (cell_x, 1) if cell_y == 0 else (cell_x, grid_rows - 2)
-                )
+                inward_cell = (cell_x, 1) if cell_y == 0 else (cell_x, grid_rows - 2)
                 if inward_cell not in outer_wall_cells:
-                    inward_dy = zombie.speed if cell_y == 0 else -zombie.speed
-                    return 0.0, inward_dy
+                    target_x = (inward_cell[0] + 0.5) * cell_size
+                    target_y = (inward_cell[1] + 0.5) * cell_size
+                    return zombie_move_toward(zombie, (target_x, target_y))
         else:
 
             def path_clear(next_x: float, next_y: float) -> bool:
@@ -1103,12 +1224,12 @@ def _zombie_wander_move(
                 inward_dy = zombie.speed if cell_y == 0 else -zombie.speed
                 if path_clear(zombie.x, zombie.y + inward_dy):
                     return 0.0, inward_dy
-        if at_x_edge:
-            direction = 1.0 if math.sin(zombie.wander_angle) >= 0 else -1.0
-            return 0.0, direction * zombie.speed
-        if at_y_edge:
-            direction = 1.0 if math.cos(zombie.wander_angle) >= 0 else -1.0
-            return direction * zombie.speed, 0.0
+        # if at_x_edge:
+        #     direction = 1.0 if math.sin(zombie.wander_angle) >= 0 else -1.0
+        #     return 0.0, direction * zombie.speed
+        # if at_y_edge:
+        #     direction = 1.0 if math.cos(zombie.wander_angle) >= 0 else -1.0
+        #     return direction * zombie.speed, 0.0
 
     move_x = math.cos(zombie.wander_angle) * zombie.speed
     move_y = math.sin(zombie.wander_angle) * zombie.speed
@@ -1230,47 +1351,8 @@ class Zombie(pygame.sprite.Sprite):
                     final_y = self.y
                     break
 
-        for wall in possible_walls:
-            final_x, final_y = self._apply_bevel_corner_repulsion(
-                final_x, final_y, wall
-            )
-
         return final_x, final_y
 
-    def _apply_bevel_corner_repulsion(
-        self: Self, x: float, y: float, wall: Wall
-    ) -> tuple[float, float]:
-        bevel_depth = int(getattr(wall, "bevel_depth", 0) or 0)
-        bevel_mask = getattr(wall, "bevel_mask", None)
-        if bevel_depth <= 0 or not bevel_mask or not any(bevel_mask):
-            return x, y
-
-        influence = self.radius + bevel_depth
-        repel_ratio = 0.03
-        corners = (
-            (bevel_mask[0], wall.rect.left, wall.rect.top, -1.0, -1.0),  # tl
-            (bevel_mask[1], wall.rect.right, wall.rect.top, 1.0, -1.0),  # tr
-            (bevel_mask[2], wall.rect.right, wall.rect.bottom, 1.0, 1.0),  # br
-            (bevel_mask[3], wall.rect.left, wall.rect.bottom, -1.0, 1.0),  # bl
-        )
-        for enabled, corner_x, corner_y, dir_x, dir_y in corners:
-            if not enabled:
-                continue
-            dx = x - corner_x
-            dy = y - corner_y
-            if abs(dx) > influence or abs(dy) > influence:
-                continue
-            dist = math.hypot(dx, dy)
-            if dist >= influence:
-                continue
-            push = (influence - dist) * repel_ratio
-            if push <= 0:
-                continue
-            x += dir_x * push
-            y += dir_y * push
-
-        return x, y
-
     def _avoid_other_zombies(
         self: Self,
         move_x: float,
@@ -1368,6 +1450,9 @@ class Zombie(pygame.sprite.Sprite):
         level_width: int,
         level_height: int,
         outer_wall_cells: set[tuple[int, int]] | None = None,
+        wall_cells: set[tuple[int, int]] | None = None,
+        bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]]
+        | None = None,
     ) -> None:
         if self.carbonized:
             return
@@ -1390,6 +1475,18 @@ class Zombie(pygame.sprite.Sprite):
         )
         if dist_to_player_sq <= avoid_radius_sq or self.wall_follower:
             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,
+            )
         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)
@@ -1407,9 +1504,8 @@ class Zombie(pygame.sprite.Sprite):
         )
 
         if not (0 <= final_x < level_width and 0 <= final_y < level_height):
-            final_x, final_y = random_position_outside_building(
-                level_width, level_height
-            )
+            self.kill()
+            return
 
         self.x = final_x
         self.y = final_y
@@ -1462,7 +1558,14 @@ class Car(pygame.sprite.Sprite):
         old_center = self.rect.center
         self.rect = self.image.get_rect(center=old_center)
 
-    def move(self: Self, dx: float, dy: float, walls: Iterable[Wall]) -> None:
+    def move(
+        self: Self,
+        dx: float,
+        dy: float,
+        walls: Iterable[Wall],
+        *,
+        walls_nearby: bool = False,
+    ) -> None:
         if self.health <= 0:
             return
         if dx == 0 and dy == 0:
@@ -1477,11 +1580,15 @@ class Car(pygame.sprite.Sprite):
         new_y = self.y + dy
 
         hit_walls = []
-        possible_walls = [
-            w
-            for w in walls
-            if abs(w.rect.centery - self.y) < 100 and abs(w.rect.centerx - new_x) < 100
-        ]
+        if walls_nearby:
+            possible_walls = list(walls)
+        else:
+            possible_walls = [
+                w
+                for w in walls
+                if abs(w.rect.centery - self.y) < 100
+                and abs(w.rect.centerx - new_x) < 100
+            ]
         car_center = (new_x, new_y)
         for wall in possible_walls:
             if _circle_wall_collision(car_center, self.collision_radius, wall):

zombie_escape/gameplay/constants.py

@@ -8,11 +8,6 @@ from ..entities_constants import ZOMBIE_AGING_DURATION_FRAMES
 SURVIVOR_SPEED_PENALTY_PER_PASSENGER = 0.08
 SURVIVOR_OVERLOAD_DAMAGE_RATIO = 0.2
 SURVIVOR_MESSAGE_DURATION_MS = 2000
-SURVIVOR_CONVERSION_LINE_KEYS = [
-    "stages.stage4.conversion_lines.line1",
-    "stages.stage4.conversion_lines.line2",
-    "stages.stage4.conversion_lines.line3",
-]
 
 # --- Footprint settings (gameplay) ---
 FOOTPRINT_STEP_DISTANCE = 40
@@ -34,7 +29,6 @@ __all__ = [
     "SURVIVOR_SPEED_PENALTY_PER_PASSENGER",
     "SURVIVOR_OVERLOAD_DAMAGE_RATIO",
     "SURVIVOR_MESSAGE_DURATION_MS",
-    "SURVIVOR_CONVERSION_LINE_KEYS",
     "FOOTPRINT_STEP_DISTANCE",
     "FOOTPRINT_MAX",
     "MAX_ZOMBIES",

zombie_escape/gameplay/layout.py

@@ -74,6 +74,7 @@ def generate_level_from_blueprint(
     player_cells: list[pygame.Rect] = []
     car_cells: list[pygame.Rect] = []
     zombie_cells: list[pygame.Rect] = []
+    bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]] = {}
     palette = get_environment_palette(game_data.state.ambient_palette_key)
 
     def add_beam_to_groups(beam: SteelBeam) -> None:
@@ -139,6 +140,8 @@ def generate_level_from_blueprint(
                     and not _has_wall(x - 1, y)
                     and not _has_wall(x - 1, y + 1),
                 )
+                if any(bevel_mask):
+                    bevel_corners[(x, y)] = bevel_mask
                 wall = Wall(
                     cell_rect.x,
                     cell_rect.y,
@@ -181,6 +184,8 @@ def generate_level_from_blueprint(
     game_data.layout.outside_rects = outside_rects
     game_data.layout.walkable_cells = walkable_cells
     game_data.layout.outer_wall_cells = outer_wall_cells
+    game_data.layout.wall_cells = wall_cells
+    game_data.layout.bevel_corners = bevel_corners
 
     return {
         "player_cells": player_cells,

zombie_escape/gameplay/movement.py

@@ -5,7 +5,16 @@ from typing import Any, Sequence
 
 import pygame
 
-from ..entities import Car, Player, Survivor, Wall, WallIndex, Zombie, walls_for_radius
+from ..entities import (
+    Car,
+    Player,
+    Survivor,
+    Wall,
+    WallIndex,
+    Zombie,
+    apply_tile_edge_nudge,
+    walls_for_radius,
+)
 from ..entities_constants import (
     CAR_SPEED,
     PLAYER_SPEED,
@@ -20,7 +29,10 @@ from .utils import rect_visible_on_screen
 
 
 def process_player_input(
-    keys: Sequence[bool], player: Player, car: Car | None
+    keys: Sequence[bool],
+    player: Player,
+    car: Car | None,
+    pad_input: tuple[float, float] = (0.0, 0.0),
 ) -> tuple[float, float, float, float]:
     """Process keyboard input and return movement deltas."""
     dx_input, dy_input = 0, 0
@@ -32,6 +44,8 @@ def process_player_input(
         dx_input -= 1
     if keys[pygame.K_d] or keys[pygame.K_RIGHT]:
         dx_input += 1
+    dx_input += pad_input[0]
+    dy_input += pad_input[1]
 
     player_dx, player_dy, car_dx, car_dy = 0, 0, 0, 0
 
@@ -75,6 +89,8 @@ def update_entities(
     camera = game_data.camera
     stage = game_data.stage
     active_car = car if car and car.alive() else None
+    wall_cells = game_data.layout.wall_cells
+    bevel_corners = game_data.layout.bevel_corners
 
     all_walls = list(wall_group) if wall_index is None else None
 
@@ -92,14 +108,36 @@ def update_entities(
 
     # Update player/car movement
     if player.in_car and active_car:
+        car_dx, car_dy = apply_tile_edge_nudge(
+            active_car.x,
+            active_car.y,
+            car_dx,
+            car_dy,
+            cell_size=game_data.cell_size,
+            wall_cells=wall_cells,
+            bevel_corners=bevel_corners,
+            grid_cols=stage.grid_cols,
+            grid_rows=stage.grid_rows,
+        )
         car_walls = _walls_near((active_car.x, active_car.y), 150.0)
-        active_car.move(car_dx, car_dy, car_walls)
+        active_car.move(car_dx, car_dy, car_walls, walls_nearby=wall_index is not None)
         player.rect.center = active_car.rect.center
         player.x, player.y = active_car.x, active_car.y
     elif not player.in_car:
         # Ensure player is in all_sprites if not in car
         if player not in all_sprites:
             all_sprites.add(player, layer=2)
+        player_dx, player_dy = apply_tile_edge_nudge(
+            player.x,
+            player.y,
+            player_dx,
+            player_dy,
+            cell_size=game_data.cell_size,
+            wall_cells=wall_cells,
+            bevel_corners=bevel_corners,
+            grid_cols=stage.grid_cols,
+            grid_rows=stage.grid_rows,
+        )
         player.move(
             player_dx,
             player_dy,
@@ -217,4 +255,6 @@ def update_entities(
             level_width=game_data.level_width,
             level_height=game_data.level_height,
             outer_wall_cells=game_data.layout.outer_wall_cells,
+            wall_cells=game_data.layout.wall_cells,
+            bevel_corners=game_data.layout.bevel_corners,
         )

zombie_escape/gameplay/spawn.py

@@ -58,6 +58,35 @@ def _car_appearance_for_stage(stage: Stage | None) -> str:
     return "disabled" if stage and stage.survival_stage else "default"
 
 
+def _pick_zombie_variant(stage: Stage | None) -> tuple[bool, bool]:
+    normal_ratio = 1.0
+    tracker_ratio = 0.0
+    wall_follower_ratio = 0.0
+    if stage is not None:
+        normal_ratio = max(0.0, min(1.0, stage.zombie_normal_ratio))
+        tracker_ratio = max(0.0, min(1.0, stage.zombie_tracker_ratio))
+        wall_follower_ratio = max(0.0, min(1.0, stage.zombie_wall_follower_ratio))
+        if normal_ratio + tracker_ratio + wall_follower_ratio <= 0:
+            normal_ratio = 1.0
+            tracker_ratio = 0.0
+            wall_follower_ratio = 0.0
+        if (
+            normal_ratio == 1.0
+            and (tracker_ratio > 0.0 or wall_follower_ratio > 0.0)
+            and tracker_ratio + wall_follower_ratio <= 1.0
+        ):
+            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_follower_ratio)
+    total_ratio = normal_ratio + tracker_ratio + wall_follower_ratio
+    if total_ratio <= 0:
+        return False, False
+    pick = RNG.random() * total_ratio
+    if pick < normal_ratio:
+        return False, False
+    if pick < normal_ratio + tracker_ratio:
+        return True, False
+    return False, True
+
+
 def _create_zombie(
     config: dict[str, Any],
     *,
@@ -75,44 +104,19 @@ def _create_zombie(
     else:
         base_speed = ZOMBIE_SPEED
     base_speed = min(base_speed, PLAYER_SPEED - 0.05)
-    normal_ratio = 1.0
-    tracker_ratio = 0.0
-    wall_follower_ratio = 0.0
     if stage is not None:
-        normal_ratio = max(0.0, min(1.0, stage.zombie_normal_ratio))
-        tracker_ratio = max(0.0, min(1.0, stage.zombie_tracker_ratio))
-        wall_follower_ratio = max(0.0, min(1.0, stage.zombie_wall_follower_ratio))
-        if normal_ratio + tracker_ratio + wall_follower_ratio <= 0:
-            normal_ratio = 1.0
-            tracker_ratio = 0.0
-            wall_follower_ratio = 0.0
-        if (
-            normal_ratio == 1.0
-            and (tracker_ratio > 0.0 or wall_follower_ratio > 0.0)
-            and tracker_ratio + wall_follower_ratio <= 1.0
-        ):
-            normal_ratio = max(0.0, 1.0 - tracker_ratio - wall_follower_ratio)
         aging_duration_frames = max(
             1.0,
             float(stage.zombie_aging_duration_frames),
         )
     else:
         aging_duration_frames = ZOMBIE_AGING_DURATION_FRAMES
-    picked_tracker = False
-    picked_wall_follower = False
-    total_ratio = normal_ratio + tracker_ratio + wall_follower_ratio
-    if total_ratio > 0:
-        pick = RNG.random() * total_ratio
-        if pick < normal_ratio:
-            pass
-        elif pick < normal_ratio + tracker_ratio:
-            picked_tracker = True
-        else:
-            picked_wall_follower = True
-    if tracker is None:
-        tracker = picked_tracker
-    if wall_follower is None:
-        wall_follower = picked_wall_follower
+    if tracker is None or wall_follower is None:
+        picked_tracker, picked_wall_follower = _pick_zombie_variant(stage)
+        if tracker is None:
+            tracker = picked_tracker
+        if wall_follower is None:
+            wall_follower = picked_wall_follower
     if tracker:
         wall_follower = False
     if tracker:
@@ -440,10 +444,13 @@ def spawn_initial_zombies(
     )
 
     for pos in positions:
+        tracker, wall_follower = _pick_zombie_variant(game_data.stage)
         tentative = _create_zombie(
             config,
             start_pos=pos,
             stage=game_data.stage,
+            tracker=tracker,
+            wall_follower=wall_follower,
         )
         if spritecollideany_walls(tentative, wall_group):
             continue

zombie_escape/gameplay/state.py

@@ -83,6 +83,8 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
             outside_rects=[],
             walkable_cells=[],
             outer_wall_cells=set(),
+            wall_cells=set(),
+            bevel_corners={},
         ),
         fog={
             "hatch_patterns": {},