zombie-escape 1.5.4__py3-none-any.whl → 1.7.1__py3-none-any.whl

zombie_escape/rng.py

@@ -25,10 +25,10 @@ class DeterministicRNG:
     def __init__(self, seed: int | None = None) -> None:
         self._state = [0] * self._N
         self._index = self._N
-        self._seed_value: int | None = None
-        self.seed(seed)
+        self.__seed_value: int | None = None
+        self._seed(seed)
 
-    def seed(self, value: int | None) -> None:
+    def _seed(self, value: int | None) -> None:
         """Seed using the MT19937 initialization routine."""
         if value is None:
             value = generate_seed()
@@ -36,7 +36,7 @@ class DeterministicRNG:
             normalized = int(value)
         except (TypeError, ValueError) as exc:
             raise ValueError(f"Invalid seed value: {value}") from exc
-        self._seed_value = normalized
+        self.__seed_value = normalized
         seed32 = normalized & 0xFFFFFFFF
         if seed32 == 0:
             seed32 = 5489  # default MT seed
@@ -49,8 +49,8 @@ class DeterministicRNG:
         self._index = self._N
 
     @property
-    def seed_value(self) -> int | None:
-        return self._seed_value
+    def _seed_value(self) -> int | None:
+        return self.__seed_value
 
     def random(self) -> float:
         """Return a float in the range [0.0, 1.0)."""
@@ -119,9 +119,9 @@ def get_rng() -> DeterministicRNG:
 
 
 def seed_rng(seed: int | None) -> int:
-    _GLOBAL_RNG.seed(seed)
-    assert _GLOBAL_RNG.seed_value is not None
-    return _GLOBAL_RNG.seed_value
+    _GLOBAL_RNG._seed(seed)
+    assert _GLOBAL_RNG._seed_value is not None
+    return _GLOBAL_RNG._seed_value
 
 
 __all__ = [

zombie_escape/screens/__init__.py

@@ -53,7 +53,7 @@ class ScreenTransition:
 
 
 current_window_scale = DEFAULT_WINDOW_SCALE  # Applied to the OS window only
-current_fullscreen = False
+current_maximized = False
 last_window_scale = DEFAULT_WINDOW_SCALE
 current_window_size = (
     int(SCREEN_WIDTH * DEFAULT_WINDOW_SCALE),
@@ -80,18 +80,17 @@ def present(logical_surface: surface.Surface) -> None:
     window_size = _fetch_window_size(window)
     _update_window_size(window_size, source="frame")
     logical_size = logical_surface.get_size()
-    if current_fullscreen:
-        scale = max(
-            1,
-            min(
-                window_size[0] // logical_size[0],
-                window_size[1] // logical_size[1],
-            ),
-        )
-        scaled_width = logical_size[0] * scale
-        scaled_height = logical_size[1] * scale
+    if window_size == logical_size:
+        window.blit(logical_surface, (0, 0))
+    else:
+        # Preserve aspect ratio with letterboxing.
+        scale_x = window_size[0] / max(1, logical_size[0])
+        scale_y = window_size[1] / max(1, logical_size[1])
+        scale = min(scale_x, scale_y)
+        scaled_width = max(1, int(logical_size[0] * scale))
+        scaled_height = max(1, int(logical_size[1] * scale))
         window.fill((0, 0, 0))
-        if scale == 1 and (scaled_width, scaled_height) == logical_size:
+        if (scaled_width, scaled_height) == logical_size:
             scaled_surface = logical_surface
         else:
             scaled_surface = pygame.transform.scale(
@@ -100,12 +99,6 @@ def present(logical_surface: surface.Surface) -> None:
         offset_x = (window_size[0] - scaled_width) // 2
         offset_y = (window_size[1] - scaled_height) // 2
         window.blit(scaled_surface, (offset_x, offset_y))
-        pygame.display.flip()
-        return
-    if window_size == logical_size:
-        window.blit(logical_surface, (0, 0))
-    else:
-        pygame.transform.scale(logical_surface, window_size, window)
     pygame.display.flip()
 
 
@@ -113,17 +106,19 @@ def apply_window_scale(
     scale: float, *, game_data: "GameData | None" = None
 ) -> surface.Surface:
     """Resize the OS window; logical render surface stays constant."""
-    global current_window_scale, current_fullscreen, last_window_scale
+    global current_window_scale, current_maximized, last_window_scale
 
     clamped_scale = max(WINDOW_SCALE_MIN, min(WINDOW_SCALE_MAX, scale))
     current_window_scale = clamped_scale
     last_window_scale = clamped_scale
-    current_fullscreen = False
+    current_maximized = False
 
     window_width = max(1, int(SCREEN_WIDTH * current_window_scale))
     window_height = max(1, int(SCREEN_HEIGHT * current_window_scale))
 
-    new_window = pygame.display.set_mode((window_width, window_height))
+    new_window = pygame.display.set_mode(
+        (window_width, window_height), pygame.RESIZABLE
+    )
     _update_window_size((window_width, window_height), source="apply_scale")
     _update_window_caption(window_width, window_height)
 
@@ -144,19 +139,23 @@ def nudge_window_scale(
 def toggle_fullscreen(
     *, game_data: "GameData | None" = None
 ) -> surface.Surface | None:
-    """Toggle fullscreen without persisting the setting."""
-    global current_fullscreen, last_window_scale
-    if current_fullscreen:
-        current_fullscreen = False
+    """Toggle a maximized window without persisting the setting."""
+    global current_maximized, last_window_scale
+    if current_maximized:
+        current_maximized = False
         window_width = max(1, int(SCREEN_WIDTH * last_window_scale))
         window_height = max(1, int(SCREEN_HEIGHT * last_window_scale))
-        window = pygame.display.set_mode((window_width, window_height))
+        window = pygame.display.set_mode(
+            (window_width, window_height), pygame.RESIZABLE
+        )
+        _restore_window()
         _update_window_caption(window_width, window_height)
         _update_window_size((window_width, window_height), source="toggle_windowed")
     else:
         last_window_scale = current_window_scale
-        current_fullscreen = True
-        window = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
+        current_maximized = True
+        window = pygame.display.set_mode(_fetch_window_size(None), pygame.RESIZABLE)
+        _maximize_window()
         window_width, window_height = _fetch_window_size(window)
         _update_window_caption(window_width, window_height)
         _update_window_size((window_width, window_height), source="toggle_fullscreen")
@@ -182,7 +181,7 @@ def sync_window_size(
     _update_window_size(
         (window_width, window_height), source="window_event"
     )
-    if not current_fullscreen:
+    if not current_maximized:
         scale_x = window_width / max(1, SCREEN_WIDTH)
         scale_y = window_height / max(1, SCREEN_HEIGHT)
         scale = max(WINDOW_SCALE_MIN, min(WINDOW_SCALE_MAX, min(scale_x, scale_y)))
@@ -204,6 +203,7 @@ def _fetch_window_size(window: surface.Surface | None) -> tuple[int, int]:
     window_height = max(1, int(SCREEN_HEIGHT * last_window_scale))
     return window_width, window_height
 
+
 def _normalize_window_size(size: tuple[int, int]) -> tuple[int, int]:
     width = max(1, int(size[0]))
     height = max(1, int(size[1]))
@@ -220,3 +220,33 @@ def _update_window_size(size: tuple[int, int], *, source: str) -> None:
 
 def _update_window_caption(window_width: int, window_height: int) -> None:
     pygame.display.set_caption(f"Zombie Escape ({window_width}x{window_height})")
+
+
+def _maximize_window() -> None:
+    try:
+        from pygame import _sdl2 as sdl2  # type: ignore[import-not-found]
+    except Exception:
+        return
+    try:
+        window = sdl2.Window.from_display_module()
+    except Exception:
+        return
+    try:
+        window.maximize()
+    except Exception:
+        return
+
+
+def _restore_window() -> None:
+    try:
+        from pygame import _sdl2 as sdl2  # type: ignore[import-not-found]
+    except Exception:
+        return
+    try:
+        window = sdl2.Window.from_display_module()
+    except Exception:
+        return
+    try:
+        window.restore()
+    except Exception:
+        return

zombie_escape/screens/game_over.py

@@ -11,7 +11,7 @@ from ..models import GameData, Stage
 from ..render import (
     RenderAssets,
     draw_level_overview,
-    draw_status_bar,
+    _draw_status_bar,
     show_message,
 )
 from ..screens import (
@@ -46,7 +46,7 @@ def game_over_screen(
 
     while True:
         if not state.overview_created:
-            level_rect = game_data.areas.outer_rect
+            level_rect = game_data.layout.outer_rect
             level_width = level_rect[2]
             level_height = level_rect[3]
             overview_surface = pygame.Surface((level_width, level_height))
@@ -154,7 +154,7 @@ def game_over_screen(
             WHITE,
             (screen_width // 2, screen_height // 2 + 24),
         )
-        draw_status_bar(
+        _draw_status_bar(
             screen,
             render_assets,
             config,

zombie_escape/screens/gameplay.py

@@ -9,11 +9,29 @@ from ..colors import LIGHT_GRAY, RED, WHITE, YELLOW
 from ..gameplay_constants import (
     CAR_HINT_DELAY_MS_DEFAULT,
     DEFAULT_FLASHLIGHT_SPAWN_COUNT,
-    SURVIVOR_STAGE_WAITING_CAR_COUNT,
     SURVIVAL_TIME_ACCEL_SUBSTEPS,
     SURVIVAL_TIME_ACCEL_MAX_SUBSTEP,
 )
-from ..gameplay import logic
+from ..gameplay import (
+    apply_passenger_speed_penalty,
+    check_interactions,
+    cleanup_survivor_messages,
+    generate_level_from_blueprint,
+    initialize_game_state,
+    maintain_waiting_car_supply,
+    nearest_waiting_car,
+    place_flashlights,
+    place_fuel_can,
+    process_player_input,
+    setup_player_and_cars,
+    spawn_initial_zombies,
+    spawn_survivors,
+    sync_ambient_palette_with_flashlights,
+    update_entities,
+    update_footprints,
+    update_survival_timer,
+)
+from ..gameplay.spawn import _alive_waiting_cars
 from ..entities import build_wall_index
 from ..localization import translate as tr
 from ..models import Stage
@@ -51,7 +69,7 @@ def gameplay_screen(
     seed_value = seed if seed is not None else generate_seed()
     applied_seed = seed_rng(seed_value)
 
-    game_data = logic.initialize_game_state(config, stage)
+    game_data = initialize_game_state(config, stage)
     game_data.state.seed = applied_seed
     game_data.state.debug_mode = debug_mode
     if debug_mode and stage.survival_stage:
@@ -72,28 +90,26 @@ def gameplay_screen(
     ignore_focus_loss_until = 0
     last_fov_target = None
 
-    layout_data = logic.generate_level_from_blueprint(game_data, config)
-    logic.sync_ambient_palette_with_flashlights(game_data, force=True)
-    initial_waiting = (
-        SURVIVOR_STAGE_WAITING_CAR_COUNT if stage.rescue_stage else 1
-    )
-    player, waiting_cars = logic.setup_player_and_cars(
+    layout_data = generate_level_from_blueprint(game_data, config)
+    sync_ambient_palette_with_flashlights(game_data, force=True)
+    initial_waiting = max(0, stage.waiting_car_target_count)
+    player, waiting_cars = setup_player_and_cars(
         game_data, layout_data, car_count=initial_waiting
     )
     game_data.player = player
     game_data.waiting_cars = waiting_cars
     game_data.car = None
     # Only top up if initial placement spawned fewer than the intended baseline (shouldn't happen)
-    logic.maintain_waiting_car_supply(
-        game_data, minimum=logic.waiting_car_target_count(stage)
+    maintain_waiting_car_supply(
+        game_data, minimum=stage.waiting_car_target_count
     )
-    logic.apply_passenger_speed_penalty(game_data)
+    apply_passenger_speed_penalty(game_data)
 
-    logic.spawn_survivors(game_data, layout_data)
+    spawn_survivors(game_data, layout_data)
 
     if stage.requires_fuel:
-        fuel_spawn_count = getattr(stage, "fuel_spawn_count", 1)
-        fuel_can = logic.place_fuel_can(
+        fuel_spawn_count = stage.fuel_spawn_count
+        fuel_can = place_fuel_can(
             layout_data["walkable_cells"],
             player,
             cars=game_data.waiting_cars,
@@ -102,7 +118,7 @@ def gameplay_screen(
         if fuel_can:
             game_data.fuel = fuel_can
             game_data.groups.all_sprites.add(fuel_can, layer=1)
-    flashlights = logic.place_flashlights(
+    flashlights = place_flashlights(
         layout_data["walkable_cells"],
         player,
         cars=game_data.waiting_cars,
@@ -111,8 +127,8 @@ def gameplay_screen(
     game_data.flashlights = flashlights
     game_data.groups.all_sprites.add(flashlights, layer=1)
 
-    logic.spawn_initial_zombies(game_data, player, layout_data, config)
-    logic.update_footprints(game_data, config)
+    spawn_initial_zombies(game_data, player, layout_data, config)
+    update_footprints(game_data, config)
     last_fov_target = player
 
     while True:
@@ -246,17 +262,19 @@ def gameplay_screen(
         sub_dt = (
             min(dt, SURVIVAL_TIME_ACCEL_MAX_SUBSTEP) if accel_active else dt
         )
-        wall_index = build_wall_index(game_data.groups.wall_group)
+        wall_index = build_wall_index(
+            game_data.groups.wall_group, cell_size=game_data.cell_size
+        )
         frame_fov_target = None
         for _ in range(substeps):
             player_ref = game_data.player
             if player_ref is None:
                 break
             car_ref = game_data.car
-            player_dx, player_dy, car_dx, car_dy = logic.process_player_input(
+            player_dx, player_dy, car_dx, car_dy = process_player_input(
                 keys, player_ref, car_ref
             )
-            logic.update_entities(
+            update_entities(
                 game_data,
                 player_dx,
                 player_dy,
@@ -265,14 +283,14 @@ def gameplay_screen(
                 config,
                 wall_index=wall_index,
             )
-            logic.update_footprints(game_data, config)
+            update_footprints(game_data, config)
             step_ms = int(sub_dt * 1000)
             if accel_active:
                 step_ms = max(1, step_ms)
             game_data.state.elapsed_play_ms += step_ms
-            logic.update_survival_timer(game_data, step_ms)
-            logic.cleanup_survivor_messages(game_data.state)
-            sub_fov_target = logic.check_interactions(game_data, config)
+            update_survival_timer(game_data, step_ms)
+            cleanup_survivor_messages(game_data.state)
+            sub_fov_target = check_interactions(game_data, config)
             if sub_fov_target:
                 frame_fov_target = sub_fov_target
             if game_data.state.game_over or game_data.state.game_won:
@@ -302,7 +320,7 @@ def gameplay_screen(
             if not has_fuel and game_data.fuel and game_data.fuel.alive():
                 target_type = "fuel"
             elif not player.in_car and (
-                active_car or logic.alive_waiting_cars(game_data)
+                active_car or _alive_waiting_cars(game_data)
             ):
                 target_type = "car"
             else:
@@ -328,7 +346,7 @@ def gameplay_screen(
                     if active_car:
                         hint_target = active_car.rect.center
                     else:
-                        waiting_target = logic.nearest_waiting_car(
+                        waiting_target = nearest_waiting_car(
                             game_data, (player.x, player.y)
                         )
                         if waiting_target:

zombie_escape/screens/title.py

@@ -427,8 +427,11 @@ def title_screen(
                 current_seed_text if current_seed_text else tr("menu.seed_empty")
             )
             seed_label = tr("menu.seed_label", value=seed_value_display)
-            seed_surface = hint_font.render(seed_label, False, WHITE)
-            seed_rect = seed_surface.get_rect(bottomleft=(info_column_x, height - 30))
+            seed_surface = hint_font.render(seed_label, False, LIGHT_GRAY)
+            seed_offset_y = hint_line_height
+            seed_rect = seed_surface.get_rect(
+                bottomleft=(info_column_x, height - 30 + seed_offset_y)
+            )
             screen.blit(seed_surface, seed_rect)
 
             seed_hint = tr("menu.seed_hint")

zombie_escape/stage_constants.py

@@ -2,7 +2,8 @@
 
 from __future__ import annotations
 
-from .gameplay_constants import SURVIVOR_SPAWN_RATE, ZOMBIE_AGING_DURATION_FRAMES
+from .entities_constants import ZOMBIE_AGING_DURATION_FRAMES
+from .gameplay_constants import SURVIVOR_SPAWN_RATE
 from .models import Stage
 
 STAGES: list[Stage] = [
@@ -39,6 +40,7 @@ STAGES: list[Stage] = [
         description_key="stages.stage4.description",
         available=True,
         rescue_stage=True,
+        waiting_car_target_count=2,
         survivor_spawn_rate=SURVIVOR_SPAWN_RATE,
     ),
     Stage(
@@ -52,6 +54,7 @@ STAGES: list[Stage] = [
         fuel_spawn_count=0,
         exterior_spawn_weight=0.4,
         interior_spawn_weight=0.6,
+        initial_interior_spawn_rate=0.04,
     ),
     Stage(
         id="stage6",
@@ -70,6 +73,7 @@ STAGES: list[Stage] = [
         name_key="stages.stage7.name",
         description_key="stages.stage7.description",
         available=True,
+        wall_algorithm="grid_wire",
         buddy_required_count=1,
         requires_fuel=True,
         exterior_spawn_weight=0.7,
@@ -79,6 +83,35 @@ STAGES: list[Stage] = [
         zombie_wall_follower_ratio=0.3,
         zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
     ),
+    Stage(
+        id="stage8",
+        name_key="stages.stage8.name",
+        description_key="stages.stage8.description",
+        available=True,
+        tile_size=35,
+        wall_algorithm="grid_wire",
+        requires_fuel=True,
+        exterior_spawn_weight=0.4,
+        interior_spawn_weight=0.6,
+        zombie_normal_ratio=0,
+        zombie_tracker_ratio=0.3,
+        zombie_wall_follower_ratio=0.7,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+    ),
+    Stage(
+        id="stage9",
+        name_key="stages.stage9.name",
+        description_key="stages.stage9.description",
+        available=False,
+        rescue_stage=True,
+        tile_size=35,
+        requires_fuel=True,
+        exterior_spawn_weight=0.4,
+        interior_spawn_weight=0.6,
+        waiting_car_target_count=1,
+        survivor_spawn_rate=SURVIVOR_SPAWN_RATE,
+        zombie_aging_duration_frames=ZOMBIE_AGING_DURATION_FRAMES * 2,
+    ),
 ]
 DEFAULT_STAGE_ID = "stage1"
 

zombie_escape/zombie_escape.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import argparse
-from pathlib import Path
 import sys
 import traceback  # For error reporting
+from pathlib import Path
 from typing import Any, Tuple
 
 import pygame
@@ -13,32 +13,41 @@ try:
 except Exception:  # pragma: no cover - fallback version
     __version__ = "0.0.0-unknown"
 from .config import load_config, save_config
-from .gameplay_constants import (
+from .entities_constants import (
     CAR_SPEED,
     SURVIVOR_MAX_SAFE_PASSENGERS,
     SURVIVOR_MIN_SPEED_FACTOR,
 )
-from .render_constants import RENDER_ASSETS
+from .gameplay import calculate_car_speed_for_passengers
+from .level_constants import DEFAULT_TILE_SIZE
+from .localization import set_language
+from .models import GameData, Stage
+from .render_constants import build_render_assets
 from .screen_constants import (
     DEFAULT_WINDOW_SCALE,
     FPS,
     SCREEN_HEIGHT,
     SCREEN_WIDTH,
 )
-from .localization import set_language
-from .models import GameData, Stage
-from .stage_constants import DEFAULT_STAGE_ID, STAGES
 from .screens import ScreenID, ScreenTransition, apply_window_scale
 from .screens.game_over import game_over_screen
 from .screens.settings import settings_screen
 from .screens.title import MAX_SEED_DIGITS, title_screen
-from .gameplay.logic import calculate_car_speed_for_passengers
+from .stage_constants import DEFAULT_STAGE_ID, STAGES
 
 
 def _parse_cli_args(argv: list[str]) -> Tuple[argparse.Namespace, list[str]]:
     parser = argparse.ArgumentParser(add_help=False)
-    parser.add_argument("--debug", action="store_true", help="Enable debugging aids for Stage 5 and hide pause overlay")
-    parser.add_argument("--profile", action="store_true", help="Profile gameplay and write cProfile output to disk")
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debugging aids for Stage 5 and hide pause overlay",
+    )
+    parser.add_argument(
+        "--profile",
+        action="store_true",
+        help="Profile gameplay and write cProfile output to disk",
+    )
     parser.add_argument(
         "--profile-output",
         default="profile.prof",
@@ -57,6 +66,7 @@ def _sanitize_seed_text(raw: str | None) -> tuple[str | None, bool]:
         return None, True
     return stripped[:MAX_SEED_DIGITS], False
 
+
 # Re-export the gameplay helpers constants for external callers/tests.
 __all__ = [
     "main",
@@ -149,6 +159,7 @@ def main() -> None:
 
                         profiler = cProfile.Profile()
                         try:
+                            render_assets = build_render_assets(stage.tile_size)
                             transition = profiler.runcall(
                                 gameplay_screen,
                                 screen,
@@ -158,7 +169,7 @@ def main() -> None:
                                 stage,
                                 show_pause_overlay=not debug_mode,
                                 seed=seed_value,
-                                render_assets=RENDER_ASSETS,
+                                render_assets=render_assets,
                                 debug_mode=debug_mode,
                             )
                         finally:
@@ -171,6 +182,7 @@ def main() -> None:
                                 stats.print_stats(50)
                             print(f"Profile saved to {output_path} and {summary_path}")
                     else:
+                        render_assets = build_render_assets(stage.tile_size)
                         transition = gameplay_screen(
                             screen,
                             clock,
@@ -179,7 +191,7 @@ def main() -> None:
                             stage,
                             show_pause_overlay=not debug_mode,
                             seed=seed_value,
-                            render_assets=RENDER_ASSETS,
+                            render_assets=render_assets,
                             debug_mode=debug_mode,
                         )
                 except SystemExit:
@@ -197,6 +209,12 @@ def main() -> None:
             pending_game_data = None
             pending_stage = None
             pending_config = None
+            if game_data is not None:
+                render_assets = build_render_assets(game_data.cell_size)
+            elif stage is not None:
+                render_assets = build_render_assets(stage.tile_size)
+            else:
+                render_assets = build_render_assets(DEFAULT_TILE_SIZE)
             transition = game_over_screen(
                 screen,
                 clock,
@@ -204,7 +222,7 @@ def main() -> None:
                 FPS,
                 game_data=game_data,
                 stage=stage,
-                render_assets=RENDER_ASSETS,
+                render_assets=render_assets,
             )
         elif next_screen == ScreenID.EXIT:
             break

{zombie_escape-1.5.4.dist-info → zombie_escape-1.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.5.4
+Version: 1.7.1
 Summary: Top-down zombie survival game built with pygame.
 Project-URL: Homepage, https://github.com/tos-kamiya/zombie-escape
 Author-email: Toshihiro Kamiya <kamiya@mbj.nifty.com>

zombie_escape-1.7.1.dist-info/RECORD

@@ -0,0 +1,45 @@
+zombie_escape/__about__.py,sha256=lIj6_cutstDqHoeRxShnR7KSs9SmMDnDcdAglP59kh0,134
+zombie_escape/__init__.py,sha256=YSQnUghet8jxSvaGmKfzHfXXLlnvWh_xk10WGTDO2HM,173
+zombie_escape/colors.py,sha256=Cmu3wwSQgMqu75bTtsD3G85daQd96zNErnvGfXi3iVM,5771
+zombie_escape/config.py,sha256=Ncvsz6HzBknSjecorkm7CrkrzWUIksD30ykLPueanyw,2008
+zombie_escape/entities.py,sha256=50KJi3QkbTdcrTs-NOCEh_h9oLb9o7uU4K-pvZjfsH4,52101
+zombie_escape/entities_constants.py,sha256=WDQslNovvstSSavZCT0vrD4PESn0rVdKc1L4BqxLY0g,2851
+zombie_escape/font_utils.py,sha256=kkjcSlCTG3jO5zf5XUnirpJ-iL_Eg8ahzjZYGijF2JY,1206
+zombie_escape/gameplay_constants.py,sha256=I5g2xsd4Rck4d5tbWae2bm6Yfwp4ZAgujDLnDMsHxgM,758
+zombie_escape/level_blueprints.py,sha256=l7Xhg9bUp7Y5REpJKZtHcoWBO4r1sv0R34n77FLT5cE,9629
+zombie_escape/level_constants.py,sha256=fSrPXfkuKHlv9XqmaRq6aR9UhjpqZK2iJJgMc-TXGXc,281
+zombie_escape/localization.py,sha256=PK_lbKJjpzvLQr6xGvSiomXjKOxcbePtMbQkuX8DTF4,5322
+zombie_escape/models.py,sha256=noFWxsfudlzthFQF0L_KGOSs7IKp5UzkiIJ82mCFdGI,3648
+zombie_escape/progress.py,sha256=WCFc7JeMY6noBjnTIFyHrXQJSM1j8PwyPA7S8ZQwjTE,1713
+zombie_escape/render.py,sha256=VHiz4woL-qWbeNPX0q7ZPZnaPB5BPqIBzL7AKxx7Us0,30862
+zombie_escape/render_assets.py,sha256=66lRKQZ9fII6930WeQchIJRFeLLu7J3Cr155svpDrUM,16489
+zombie_escape/render_constants.py,sha256=yJ26KA7DF6ndYG3kAFaDkL-ljN1MgWbSEhR6nmWzzWI,2315
+zombie_escape/rng.py,sha256=gMAgpzYoNN1FxRG3aQ9fdXTDNAg48Rqz8YnB1nJ4Fpw,3787
+zombie_escape/screen_constants.py,sha256=MJaTlSWfN4VtN6pMqPQ6LF34XdJm0wqYLuRwa1pQuAU,559
+zombie_escape/stage_constants.py,sha256=ED-T_pXUJpbvChmjmzEQgjlR_WIFQXl_xw9bmACwAos,3583
+zombie_escape/zombie_escape.py,sha256=8RGn5bDX5kCFXgaM5JYE7_hmS7IHObyAJ9APdF7xTRw,8841
+zombie_escape/assets/fonts/Silkscreen-Regular.ttf,sha256=SVZ0CGAICeJRR-kiWsTzf0EOLfRadQaWxFAnUx-2Xxs,31960
+zombie_escape/assets/fonts/misaki_gothic.ttf,sha256=CWPhHonV-kCaegSKUujqLWI9dkp5mEiPikKRERYRxOE,1171204
+zombie_escape/gameplay/__init__.py,sha256=hv-37H7R7cQrK0Qr7FkcakwYME26pi31LC4r25s2Dxk,2349
+zombie_escape/gameplay/ambient.py,sha256=hoCOz6ciyejU0nmJwdLqmVfaoo-01CrVSMRLpFMz93w,1446
+zombie_escape/gameplay/constants.py,sha256=5n6IctC4HlquG0k8SJI3xv0wBTiw0-j33ALwBaRZJrw,1214
+zombie_escape/gameplay/footprints.py,sha256=LQ3wZNovzgO54kaGncZT4yrhnmoZVfROkTQ6wL_TVSY,1781
+zombie_escape/gameplay/interactions.py,sha256=QFtjv-5t2G6ek4AC3y5XWl15XQl5q9oK80ODNvd_Zt8,13476
+zombie_escape/gameplay/layout.py,sha256=m3QRbICDia9g2jEIiH_nQIW_27VeJyO__v1tFcSXbzI,6604
+zombie_escape/gameplay/movement.py,sha256=hZuHIwdmJAjXX7B7Qt_5vSEcjY5q3PH9UfsbzjBBfaE,7969
+zombie_escape/gameplay/spawn.py,sha256=qQnW5ZwvzLpqwzB9wss51pOjz-_XAfUVuwMogjXj5wQ,19774
+zombie_escape/gameplay/state.py,sha256=Yq2qIs7R9wt00svjK4CrEWm2jOyNGqTTGGRh8Gto2xo,4489
+zombie_escape/gameplay/survivors.py,sha256=bKUtwCS1qpIJUOVxh9413YIN1ZIV_VOfJJ3eqeKUetg,10469
+zombie_escape/gameplay/utils.py,sha256=2IwsQ1Fv8qVUWMP9JZ77tCV1slEJrokkiXAvQi7u81k,4921
+zombie_escape/locales/ui.en.json,sha256=zs3kffyaMdWRHdky8u7WFpqWujxzinSf5iHw1kNn7A0,4904
+zombie_escape/locales/ui.ja.json,sha256=_KOpdVJAbQJg-Z_q8oFeNYnSDB-YdAJKoTvmc6gQbB0,5336
+zombie_escape/screens/__init__.py,sha256=P5aDyqJ3ZXdTVi0AAsxK9scc0lPuydc-XHplNxpDbu0,8335
+zombie_escape/screens/game_over.py,sha256=_INwL2RYca4brIBErs9rAUPB9DtXYG0mYcSuT3RIA-4,6417
+zombie_escape/screens/gameplay.py,sha256=2tZl4lbFetlbFZOAqSNn3omv2p4H34pLD7rIqy7wZiM,13141
+zombie_escape/screens/settings.py,sha256=_KKdnnVdC-8KhMGVsQWWe0t00xa-ZQkatVQ7h7Vxs4c,16792
+zombie_escape/screens/title.py,sha256=rrXHWjag9j1khKvnU4NQgFg4x0V6FhiSdR0oTMOBmnc,17998
+zombie_escape-1.7.1.dist-info/METADATA,sha256=iCCHXxeJ2kVJHkLlSC_1qvyB5mdLh_SktRAG_-_vK5w,10116
+zombie_escape-1.7.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+zombie_escape-1.7.1.dist-info/entry_points.txt,sha256=JprxC-vvkBJgsOp0WJnGBZRJ_ESjjmyS-nsPExeiLHU,49
+zombie_escape-1.7.1.dist-info/licenses/LICENSE.txt,sha256=q-cJYG_K766eXSxQ7txWcWQ6nS2OF6c3HTVLesHbesU,1104
+zombie_escape-1.7.1.dist-info/RECORD,,