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

zombie_escape/locales/ui.ja.json

@@ -16,7 +16,7 @@
       "settings": "設定",
       "quit": "終了",
       "locked_suffix": "[Locked]",
-      "window_hint": "[キーでウィンドウを小さく、]キーで大きく。\nF: フルスクリーン切替。\n（タイトル、設定画面のみ）",
+      "window_hint": "[キーでウィンドウを小さく、]キーで大きく。\nF: フルスクリーン切替。",
       "seed_label": "シード: %{value}",
       "seed_hint": "数字キーで入力、BSでクリア",
       "seed_empty": "(自動)",
@@ -25,6 +25,7 @@
         "resources": "リソース"
       },
       "readme": "README を開く",
+      "readme_stage6": "ステージ6以降の説明を開く",
       "hints": {
         "navigate": "上下: 項目選択",
         "page_switch": "左右: ステージ群切替",
@@ -33,7 +34,8 @@
       "option_help": {
         "settings": "設定画面を開いて言語や補助オプションを変更します。",
         "quit": "ゲームを終了します。",
-        "readme": "GitHub の README ページをブラウザで開きます。"
+        "readme": "GitHub の README ページをブラウザで開きます。",
+        "readme_stage6": "ステージ6以降の説明ページをブラウザで開きます。"
       }
     },
     "stages": {
@@ -127,6 +129,10 @@
       "stage15": {
         "name": "#15 分断ライン",
         "description": "建物中央を分断する危険地帯。横断には注意。"
+      },
+      "stage16": {
+        "name": "#16 奈落",
+        "description": "崩落した床パネルを回り込んでゾンビを誘い込もう。"
       }
     },
     "status": {
@@ -198,10 +204,14 @@
     "game_over": {
       "win": "脱出成功！",
       "lose": "ゲームオーバー",
+      "fell_into_abyss": "奈落の底へ落ちてしまった...",
       "prompt": "ESC/Space/Select/South: タイトルへ  R: 再挑戦",
       "scream": "ぎゃあーーー!!",
       "survivors_summary": "救出人数: %{count}",
       "endurance_duration": "逃げ延びた時間 %{time}"
+    },
+    "errors": {
+      "map_generation_failed": "マップの生成に失敗しました。シード値を変えるか、別のステージを選んでください。"
     }
   }
 }

zombie_escape/models.py

@@ -31,13 +31,15 @@ class LevelLayout:
     walkable_cells: list[tuple[int, int]]
     outer_wall_cells: set[tuple[int, int]]
     wall_cells: set[tuple[int, int]]
+    pitfall_cells: set[tuple[int, int]]
+    car_walkable_cells: set[tuple[int, int]]
     fall_spawn_cells: set[tuple[int, int]]
     bevel_corners: dict[tuple[int, int], tuple[bool, bool, bool, bool]]
 
 
 @dataclass
 class FallingZombie:
-    """Represents a zombie falling toward a target position."""
+    """Represents a zombie falling toward a target position or into a pit."""
 
     start_pos: tuple[int, int]
     target_pos: tuple[int, int]
@@ -46,8 +48,9 @@ class FallingZombie:
     fall_duration_ms: int
     dust_duration_ms: int
     tracker: bool
-    wall_follower: bool
+    wall_hugging: bool
     dust_started: bool = False
+    mode: str = "spawn"  # "spawn" (falling in) or "pitfall" (falling out)
 
 
 @dataclass
@@ -102,6 +105,7 @@ class ProgressState:
     last_zombie_spawn_time: int
     dawn_carbonized: bool
     debug_mode: bool
+    show_fps: bool
     falling_zombies: list[FallingZombie]
     falling_spawn_carry: int
     dust_rings: list[DustRing]
@@ -166,12 +170,14 @@ class Stage:
     interior_fall_spawn_weight: float = 0.0
     fall_spawn_zones: list[tuple[int, int, int, int]] = field(default_factory=list)
     fall_spawn_floor_ratio: float = 0.0
+    pitfall_density: float = 0.0
     zombie_tracker_ratio: float = 0.0
-    zombie_wall_follower_ratio: float = 0.0
+    zombie_wall_hugging_ratio: float = 0.0
     zombie_normal_ratio: float = 1.0
     zombie_aging_duration_frames: int = ZOMBIE_AGING_DURATION_FRAMES
     waiting_car_target_count: int = 1
     wall_algorithm: str = "default"
+    wall_rubble_ratio: float = 0.0
 
     @property
     def name(self) -> str:

zombie_escape/render.py

@@ -34,6 +34,8 @@ from .entities_constants import (
     FLASHLIGHT_WIDTH,
     FUEL_CAN_HEIGHT,
     FUEL_CAN_WIDTH,
+    INTERNAL_WALL_BEVEL_DEPTH,
+    JUMP_SHADOW_OFFSET,
     SHOES_HEIGHT,
     SHOES_WIDTH,
     ZOMBIE_RADIUS,
@@ -63,6 +65,11 @@ from .render_constants import (
     FALLING_ZOMBIE_COLOR,
     FLASHLIGHT_FOG_SCALE_ONE,
     FLASHLIGHT_FOG_SCALE_TWO,
+    PITFALL_ABYSS_COLOR,
+    PITFALL_EDGE_DEPTH_OFFSET,
+    PITFALL_EDGE_METAL_COLOR,
+    PITFALL_EDGE_STRIPE_COLOR,
+    PITFALL_EDGE_STRIPE_SPACING,
     PLAYER_SHADOW_ALPHA_MULT,
     PLAYER_SHADOW_RADIUS_MULT,
     SHADOW_MIN_RATIO,
@@ -314,9 +321,7 @@ def draw_level_overview(
     if flashlights:
         for flashlight in flashlights:
             if flashlight.alive():
-                pygame.draw.rect(
-                    surface, YELLOW, flashlight.rect, border_radius=2
-                )
+                pygame.draw.rect(surface, YELLOW, flashlight.rect, border_radius=2)
                 pygame.draw.rect(
                     surface, BLACK, flashlight.rect, width=2, border_radius=2
                 )
@@ -587,6 +592,8 @@ def _draw_fall_whirlwind(
     camera: Camera,
     center: tuple[int, int],
     progress: float,
+    *,
+    scale: float = 1.0,
 ) -> None:
     base_alpha = FALLING_WHIRLWIND_COLOR[3]
     alpha = int(max(0, min(255, base_alpha * (1.0 - progress))))
@@ -598,8 +605,9 @@ def _draw_fall_whirlwind(
         FALLING_WHIRLWIND_COLOR[2],
         alpha,
     )
-    swirl_radius = max(2, int(ZOMBIE_RADIUS * 1.1))
-    offset = max(1, int(ZOMBIE_RADIUS * 0.6))
+    safe_scale = max(0.4, scale)
+    swirl_radius = max(2, int(ZOMBIE_RADIUS * 1.1 * safe_scale))
+    offset = max(1, int(ZOMBIE_RADIUS * 0.6 * safe_scale))
     size = swirl_radius * 4
     swirl = pygame.Surface((size, size), pygame.SRCALPHA)
     cx = cy = size // 2
@@ -632,22 +640,42 @@ def _draw_falling_fx(
         if now < fall_start:
             if flashlight_count > 0 and pre_fx_ms > 0:
                 fx_progress = max(0.0, min(1.0, (now - fall.started_at_ms) / pre_fx_ms))
-                _draw_fall_whirlwind(screen, camera, fall.target_pos, fx_progress)
+                # Make the premonition grow with the impending drop scale.
+                pre_scale = 1.0 + (0.9 * fx_progress)
+                _draw_fall_whirlwind(
+                    screen,
+                    camera,
+                    fall.start_pos,
+                    fx_progress,
+                    scale=pre_scale,
+                )
             continue
         if now >= impact_at:
             continue
         fall_progress = max(0.0, min(1.0, (now - fall_start) / fall_duration_ms))
-        eased = 1.0 - (1.0 - fall_progress) * (1.0 - fall_progress)
-        x = fall.target_pos[0]
-        y = int(fall.start_pos[1] + (fall.target_pos[1] - fall.start_pos[1]) * eased)
-        world_rect = pygame.Rect(0, 0, ZOMBIE_RADIUS * 2, ZOMBIE_RADIUS * 2)
-        world_rect.center = (x, y)
+
+        if getattr(fall, "mode", "spawn") == "pitfall":
+            scale = 1.0 - fall_progress
+            scale = scale * scale
+            y_offset = 0.0
+        else:
+            eased = 1.0 - (1.0 - fall_progress) * (1.0 - fall_progress)
+            scale = 2.0 - (1.0 * eased)
+            # Add an extra vertical drop from above (1.5x wall depth)
+            y_offset = -INTERNAL_WALL_BEVEL_DEPTH * 1.5 * (1.0 - eased)
+
+        radius = ZOMBIE_RADIUS * scale
+        cx = fall.target_pos[0]
+        cy = fall.target_pos[1] + ZOMBIE_RADIUS - radius + y_offset
+
+        world_rect = pygame.Rect(0, 0, radius * 2, radius * 2)
+        world_rect.center = (int(cx), int(cy))
         screen_rect = camera.apply_rect(world_rect)
         pygame.draw.circle(
             screen,
             FALLING_ZOMBIE_COLOR,
             screen_rect.center,
-            ZOMBIE_RADIUS,
+            max(1, int(screen_rect.width / 2)),
         )
 
     for ring in list(dust_rings):
@@ -725,6 +753,7 @@ def _draw_status_bar(
     debug_mode: bool = False,
     zombie_group: sprite.Group | None = None,
     falling_spawn_carry: int | None = None,
+    show_fps: bool = False,
     fps: float | None = None,
 ) -> None:
     """Render a compact status bar with current config flags and stage info."""
@@ -766,14 +795,12 @@ def _draw_status_bar(
             zombies = [z for z in zombie_group if z.alive()]
             total = len(zombies)
             tracker = sum(1 for z in zombies if z.tracker)
-            wall = sum(1 for z in zombies if z.wall_follower)
+            wall = sum(1 for z in zombies if z.wall_hugging)
             normal = max(0, total - tracker - wall)
-            parts.append(f"Z:{total} N:{normal} T:{tracker} W:{wall}")
+            debug_counts = f"Z:{total} N:{normal} T:{tracker} W:{wall}"
             if falling_spawn_carry is not None:
-                parts.append(f"C:{max(0, falling_spawn_carry)}")
-        if fps is not None:
-            parts.append(f"FPS:{fps:.1f}")
-
+                debug_counts = f"{debug_counts} C:{max(0, falling_spawn_carry)}"
+            parts.append(debug_counts)
     status_text = " | ".join(parts)
     color = LIGHT_GRAY
 
@@ -790,7 +817,7 @@ def _draw_status_bar(
                 right=bar_rect.right - 12, centery=bar_rect.centery
             )
             screen.blit(seed_surface, seed_rect)
-        if debug_mode and fps is not None:
+        if show_fps and fps is not None:
             fps_text = f"FPS:{fps:.1f}"
             fps_surface = font.render(fps_text, False, LIGHT_GRAY)
             fps_rect = fps_surface.get_rect(
@@ -810,6 +837,7 @@ def _draw_play_area(
     field_rect: pygame.Rect,
     outside_cells: set[tuple[int, int]],
     fall_spawn_cells: set[tuple[int, int]],
+    pitfall_cells: set[tuple[int, int]],
 ) -> tuple[int, int, int, int, set[tuple[int, int]]]:
     xs, ys, xe, ye = (
         field_rect.left,
@@ -865,6 +893,43 @@ def _draw_play_area(
                 if sr.colliderect(screen.get_rect()):
                     pygame.draw.rect(screen, palette.outside, sr)
                 continue
+
+            if (x, y) in pitfall_cells:
+                lx, ly = (
+                    x * assets.internal_wall_grid_snap,
+                    y * assets.internal_wall_grid_snap,
+                )
+                r = pygame.Rect(
+                    lx,
+                    ly,
+                    assets.internal_wall_grid_snap,
+                    assets.internal_wall_grid_snap,
+                )
+                sr = camera.apply_rect(r)
+                if not sr.colliderect(screen.get_rect()):
+                    continue
+                pygame.draw.rect(screen, PITFALL_ABYSS_COLOR, sr)
+
+                if (x, y - 1) not in pitfall_cells:
+                    edge_h = max(
+                        1, INTERNAL_WALL_BEVEL_DEPTH - PITFALL_EDGE_DEPTH_OFFSET
+                    )
+                    pygame.draw.rect(
+                        screen, PITFALL_EDGE_METAL_COLOR, (sr.x, sr.y, sr.w, edge_h)
+                    )
+                    for sx in range(
+                        sr.x - edge_h, sr.right, PITFALL_EDGE_STRIPE_SPACING
+                    ):
+                        pygame.draw.line(
+                            screen,
+                            PITFALL_EDGE_STRIPE_COLOR,
+                            (max(sr.x, sx), sr.y),
+                            (min(sr.right - 1, sx + edge_h), sr.y + edge_h - 1),
+                            width=2,
+                        )
+
+                continue
+
             use_secondary = ((x // 2) + (y // 2)) % 2 == 0
             if (x, y) in fall_spawn_cells:
                 color = (
@@ -1021,8 +1086,13 @@ def _draw_entity_shadows(
         else:
             offset_x = 0.0
             offset_y = 0.0
+
+        jump_dy = 0.0
+        if getattr(entity, "is_jumping", False):
+            jump_dy = JUMP_SHADOW_OFFSET
+
         shadow_rect = shadow_surface.get_rect(
-            center=(int(cx + offset_x), int(cy + offset_y))
+            center=(int(cx + offset_x), int(cy + offset_y + jump_dy))
         )
         shadow_screen_rect = camera.apply_rect(shadow_rect)
         if not shadow_screen_rect.colliderect(screen_rect):
@@ -1081,8 +1151,13 @@ def _draw_single_entity_shadow(
     else:
         offset_x = 0.0
         offset_y = 0.0
+
+    jump_dy = 0.0
+    if getattr(entity, "is_jumping", False):
+        jump_dy = JUMP_SHADOW_OFFSET
+
     shadow_rect = shadow_surface.get_rect(
-        center=(int(cx + offset_x), int(cy + offset_y))
+        center=(int(cx + offset_x), int(cy + offset_y + jump_dy))
     )
     shadow_screen_rect = camera.apply_rect(shadow_rect)
     if not shadow_screen_rect.colliderect(screen_rect):
@@ -1525,6 +1600,7 @@ def draw(
         field_rect,
         outside_cells,
         game_data.layout.fall_spawn_cells,
+        game_data.layout.pitfall_cells,
     )
     shadow_layer = _get_shadow_layer(screen.get_size())
     shadow_layer.fill((0, 0, 0, 0))
@@ -1660,6 +1736,7 @@ def draw(
         debug_mode=state.debug_mode,
         zombie_group=zombie_group,
         falling_spawn_carry=state.falling_spawn_carry,
+        show_fps=state.show_fps,
         fps=fps,
     )
     if do_flip:

zombie_escape/render_assets.py

@@ -18,6 +18,7 @@ from .colors import (
     EnvironmentPalette,
     get_environment_palette,
 )
+from .entities_constants import INTERNAL_WALL_BEVEL_DEPTH
 from .render_constants import (
     ANGLE_BINS,
     BUDDY_COLOR,
@@ -61,6 +62,22 @@ _SURVIVOR_DIRECTIONAL_CACHE: dict[
     tuple[int, bool, bool, int], list[pygame.Surface]
 ] = {}
 _ZOMBIE_DIRECTIONAL_CACHE: dict[tuple[int, bool, int], list[pygame.Surface]] = {}
+_RUBBLE_SURFACE_CACHE: dict[tuple, pygame.Surface] = {}
+
+RUBBLE_ROTATION_DEG = 5.0
+RUBBLE_OFFSET_RATIO = 0.06
+RUBBLE_SCALE_RATIO = 0.9
+RUBBLE_SHADOW_RATIO = 0.9
+
+
+def _scale_color(
+    color: tuple[int, int, int], *, ratio: float
+) -> tuple[int, int, int]:
+    return tuple(max(0, min(255, int(c * ratio + 0.5))) for c in color)
+
+
+def rubble_offset_for_size(size: int) -> int:
+    return max(1, int(round(size * RUBBLE_OFFSET_RATIO)))
 
 
 def angle_bin_from_vector(
@@ -706,6 +723,80 @@ def paint_wall_surface(
         _draw_face(surface)
 
 
+def build_rubble_wall_surface(
+    size: int,
+    *,
+    fill_color: tuple[int, int, int],
+    border_color: tuple[int, int, int],
+    angle_deg: float,
+    offset_px: int | None = None,
+    scale_ratio: float = RUBBLE_SCALE_RATIO,
+    shadow_ratio: float = RUBBLE_SHADOW_RATIO,
+    bevel_depth: int = INTERNAL_WALL_BEVEL_DEPTH,
+) -> pygame.Surface:
+    offset_px = offset_px if offset_px is not None else rubble_offset_for_size(size)
+    safe_size = max(1, size)
+    base_size = max(1, int(round(safe_size * scale_ratio)))
+    tuned_bevel = min(bevel_depth, max(1, base_size // 2))
+    cache_key = (
+        safe_size,
+        fill_color,
+        border_color,
+        angle_deg,
+        offset_px,
+        scale_ratio,
+        shadow_ratio,
+        tuned_bevel,
+    )
+    cached = _RUBBLE_SURFACE_CACHE.get(cache_key)
+    if cached is not None:
+        return cached
+
+    top_surface = pygame.Surface((base_size, base_size), pygame.SRCALPHA)
+    paint_wall_surface(
+        top_surface,
+        fill_color=fill_color,
+        border_color=border_color,
+        bevel_depth=tuned_bevel,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+
+    shadow_fill = _scale_color(fill_color, ratio=shadow_ratio)
+    shadow_border = _scale_color(border_color, ratio=shadow_ratio)
+    shadow_surface = pygame.Surface((base_size, base_size), pygame.SRCALPHA)
+    paint_wall_surface(
+        shadow_surface,
+        fill_color=shadow_fill,
+        border_color=shadow_border,
+        bevel_depth=tuned_bevel,
+        bevel_mask=(False, False, False, False),
+        draw_bottom_side=False,
+        bottom_side_ratio=0.1,
+        side_shade_ratio=0.9,
+    )
+
+    if angle_deg:
+        top_surface = pygame.transform.rotate(top_surface, angle_deg)
+        shadow_surface = pygame.transform.rotate(shadow_surface, angle_deg)
+
+    final_surface = pygame.Surface((safe_size, safe_size), pygame.SRCALPHA)
+    center = final_surface.get_rect().center
+
+    shadow_rect = shadow_surface.get_rect(
+        center=(center[0] + offset_px, center[1] + offset_px)
+    )
+    final_surface.blit(shadow_surface, shadow_rect.topleft)
+
+    top_rect = top_surface.get_rect(center=center)
+    final_surface.blit(top_surface, top_rect.topleft)
+
+    _RUBBLE_SURFACE_CACHE[cache_key] = final_surface
+    return final_surface
+
+
 def paint_steel_beam_surface(
     surface: pygame.Surface,
     *,
@@ -788,6 +879,9 @@ __all__ = [
     "build_car_directional_surfaces",
     "paint_car_surface",
     "paint_wall_surface",
+    "build_rubble_wall_surface",
+    "rubble_offset_for_size",
+    "RUBBLE_ROTATION_DEG",
     "paint_steel_beam_surface",
     "build_fuel_can_surface",
     "build_flashlight_surface",

zombie_escape/render_constants.py

@@ -67,6 +67,15 @@ ENTITY_SHADOW_EDGE_SOFTNESS = 0.32
 PLAYER_SHADOW_RADIUS_MULT = 1.6
 PLAYER_SHADOW_ALPHA_MULT = 0.8
 
+# --- Pitfall rendering ---
+PITFALL_ABYSS_COLOR = (21, 20, 20)
+PITFALL_SHADOW_RIM_COLOR = (38, 34, 34)
+PITFALL_SHADOW_WIDTH = 6
+PITFALL_EDGE_METAL_COLOR = (110, 110, 115)
+PITFALL_EDGE_STRIPE_COLOR = (75, 75, 80)
+PITFALL_EDGE_STRIPE_SPACING = 6
+PITFALL_EDGE_DEPTH_OFFSET = 3
+
 FOG_RINGS = [
     FogRing(radius_factor=0.536, thickness=2),
     FogRing(radius_factor=0.645, thickness=3),
@@ -121,6 +130,13 @@ __all__ = [
     "ENTITY_SHADOW_EDGE_SOFTNESS",
     "PLAYER_SHADOW_RADIUS_MULT",
     "PLAYER_SHADOW_ALPHA_MULT",
+    "PITFALL_ABYSS_COLOR",
+    "PITFALL_SHADOW_RIM_COLOR",
+    "PITFALL_SHADOW_WIDTH",
+    "PITFALL_EDGE_METAL_COLOR",
+    "PITFALL_EDGE_STRIPE_COLOR",
+    "PITFALL_EDGE_STRIPE_SPACING",
+    "PITFALL_EDGE_DEPTH_OFFSET",
     "FLASHLIGHT_HATCH_EXTRA_SCALE",
     "build_render_assets",
 ]

zombie_escape/screens/game_over.py

@@ -18,8 +18,10 @@ from ..input_utils import is_confirm_event, is_select_event
 from ..screens import (
     ScreenID,
     ScreenTransition,
+    nudge_window_scale,
     present,
     sync_window_size,
+    toggle_fullscreen,
 )
 from ..gameplay_constants import SURVIVAL_FAKE_CLOCK_RATIO
 
@@ -174,6 +176,15 @@ def game_over_screen(
                 sync_window_size(event, game_data=game_data)
                 continue
             if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_LEFTBRACKET:
+                    nudge_window_scale(0.5, game_data=game_data)
+                    continue
+                if event.key == pygame.K_RIGHTBRACKET:
+                    nudge_window_scale(2.0, game_data=game_data)
+                    continue
+                if event.key == pygame.K_f:
+                    toggle_fullscreen(game_data=game_data)
+                    continue
                 if event.key in (pygame.K_ESCAPE, pygame.K_SPACE):
                     return ScreenTransition(ScreenID.TITLE)
                 if event.key == pygame.K_r and stage is not None: