zombie-escape 1.2.1__tar.gz → 1.3.1__tar.gz

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.2.1
+Version: 1.3.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>
@@ -59,6 +59,10 @@ Open **Settings** from the title to toggle gameplay assists:
 -   **Flashlight pickups:** Enable flashlight spawns that expand your visible radius when collected.
 -   **Steel beams:** Adds tougher single-cell obstacles (5% density) that block movement; hidden when stacked with an inner wall until that wall is destroyed.
 
+### Shared Seeds
+
+The title screen also lets you enter a numeric **seed**. Type digits (or pass `--seed <number>` on the CLI) to lock the procedural layout, wall placement, and pickups; share that seed with a friend and you will both play the exact same stage even on different machines. The current seed is shown at the bottom right of the title screen and in-game HUD. Backspace reverts to an automatically generated value so you can quickly roll a fresh challenge.
+
 ## Game Rules
 
 ### Stages

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/README.md

@@ -38,6 +38,10 @@ Open **Settings** from the title to toggle gameplay assists:
 -   **Flashlight pickups:** Enable flashlight spawns that expand your visible radius when collected.
 -   **Steel beams:** Adds tougher single-cell obstacles (5% density) that block movement; hidden when stacked with an inner wall until that wall is destroyed.
 
+### Shared Seeds
+
+The title screen also lets you enter a numeric **seed**. Type digits (or pass `--seed <number>` on the CLI) to lock the procedural layout, wall placement, and pickups; share that seed with a friend and you will both play the exact same stage even on different machines. The current seed is shown at the bottom right of the title screen and in-game HUD. Backspace reverts to an automatically generated value so you can quickly roll a fresh challenge.
+
 ## Game Rules
 
 ### Stages

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/__about__.py

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

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/entities.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import math
-import random
 from enum import Enum
 from typing import Callable, Iterable, Self
 
@@ -55,6 +54,9 @@ from .constants import (
     ZOMBIE_SIGHT_RANGE,
     ZOMBIE_SPEED,
 )
+from .rng import get_rng
+
+RNG = get_rng()
 
 
 # --- Camera Class ---
@@ -357,16 +359,16 @@ class Survivor(pygame.sprite.Sprite):
 
 
 def random_position_outside_building() -> tuple[int, int]:
-    side = random.choice(["top", "bottom", "left", "right"])
+    side = RNG.choice(["top", "bottom", "left", "right"])
     margin = 0
     if side == "top":
-        x, y = random.randint(0, LEVEL_WIDTH), -margin
+        x, y = RNG.randint(0, LEVEL_WIDTH), -margin
     elif side == "bottom":
-        x, y = random.randint(0, LEVEL_WIDTH), LEVEL_HEIGHT + margin
+        x, y = RNG.randint(0, LEVEL_WIDTH), LEVEL_HEIGHT + margin
     elif side == "left":
-        x, y = -margin, random.randint(0, LEVEL_HEIGHT)
+        x, y = -margin, RNG.randint(0, LEVEL_HEIGHT)
     else:
-        x, y = LEVEL_WIDTH + margin, random.randint(0, LEVEL_HEIGHT)
+        x, y = LEVEL_WIDTH + margin, RNG.randint(0, LEVEL_HEIGHT)
     return x, y
 
 
@@ -398,12 +400,12 @@ class Zombie(pygame.sprite.Sprite):
             if speed > ZOMBIE_SPEED
             else NORMAL_ZOMBIE_SPEED_JITTER
         )
-        self.speed = speed + random.uniform(-jitter, jitter)
+        self.speed = speed + RNG.uniform(-jitter, jitter)
         self.x = float(self.rect.centerx)
         self.y = float(self.rect.centery)
-        self.mode = random.choice(list(ZombieMode))
+        self.mode = RNG.choice(list(ZombieMode))
         self.last_mode_change_time = pygame.time.get_ticks()
-        self.mode_change_interval = ZOMBIE_MODE_CHANGE_INTERVAL_MS + random.randint(
+        self.mode_change_interval = ZOMBIE_MODE_CHANGE_INTERVAL_MS + RNG.randint(
             -1000, 1000
         )
         self.was_in_sight = False
@@ -413,9 +415,9 @@ class Zombie(pygame.sprite.Sprite):
             self.mode = force_mode
         else:
             possible_modes = list(ZombieMode)
-            self.mode = random.choice(possible_modes)
+            self.mode = RNG.choice(possible_modes)
         self.last_mode_change_time = pygame.time.get_ticks()
-        self.mode_change_interval = ZOMBIE_MODE_CHANGE_INTERVAL_MS + random.randint(
+        self.mode_change_interval = ZOMBIE_MODE_CHANGE_INTERVAL_MS + RNG.randint(
             -1000, 1000
         )
 
@@ -439,9 +441,9 @@ class Zombie(pygame.sprite.Sprite):
                     * self.speed
                     * 0.8
                 )
-            move_y = random.uniform(-self.speed * 0.6, self.speed * 0.6)
+            move_y = RNG.uniform(-self.speed * 0.6, self.speed * 0.6)
         elif self.mode == ZombieMode.FLANK_Y:
-            move_x = random.uniform(-self.speed * 0.6, self.speed * 0.6)
+            move_x = RNG.uniform(-self.speed * 0.6, self.speed * 0.6)
             if dist > 0:
                 move_y = (
                     (dy_target / abs(dy_target) if dy_target != 0 else 0)
@@ -512,7 +514,7 @@ class Zombie(pygame.sprite.Sprite):
         away_dy = next_y - closest.y
         away_dist = math.hypot(away_dx, away_dy)
         if away_dist == 0:
-            angle = random.uniform(0, 2 * math.pi)
+            angle = RNG.uniform(0, 2 * math.pi)
             away_dx, away_dy = math.cos(angle), math.sin(angle)
             away_dist = 1
 

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/gameplay/logic.py

@@ -4,7 +4,6 @@ from bisect import bisect_left
 from typing import Any, Mapping, Sequence
 
 import math
-import random
 
 import pygame
 
@@ -56,6 +55,7 @@ from ..constants import (
 from ..localization import translate as _
 from ..level_blueprints import choose_blueprint
 from ..models import Areas, GameData, Groups, ProgressState, Stage
+from ..rng import get_rng
 from ..entities import (
     Camera,
     Car,
@@ -70,6 +70,7 @@ from ..entities import (
 )
 
 LOGICAL_SCREEN_RECT = pygame.Rect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT)
+RNG = get_rng()
 
 __all__ = [
     "create_zombie",
@@ -118,7 +119,7 @@ def create_zombie(
     fast_conf = config.get("fast_zombies", {})
     fast_enabled = fast_conf.get("enabled", True)
     if fast_enabled:
-        base_speed = random.uniform(ZOMBIE_SPEED, FAST_ZOMBIE_BASE_SPEED)
+        base_speed = RNG.uniform(ZOMBIE_SPEED, FAST_ZOMBIE_BASE_SPEED)
     else:
         base_speed = ZOMBIE_SPEED
     base_speed = min(base_speed, PLAYER_SPEED - 0.05)
@@ -263,7 +264,7 @@ def place_new_car(
 
     max_attempts = 150
     for attempt in range(max_attempts):
-        cell = random.choice(walkable_cells)
+        cell = RNG.choice(walkable_cells)
         c_x, c_y = cell.center
         temp_car = Car(c_x, c_y)
         temp_rect = temp_car.rect.inflate(30, 30)
@@ -305,7 +306,7 @@ def place_fuel_can(
     min_car_dist = 200
 
     for attempt in range(200):
-        cell = random.choice(walkable_cells)
+        cell = RNG.choice(walkable_cells)
         if (
             math.hypot(cell.centerx - player.x, cell.centery - player.y)
             < min_player_dist
@@ -325,7 +326,7 @@ def place_fuel_can(
         return FuelCan(cell.centerx, cell.centery)
 
     # Fallback: drop near a random walkable cell
-    cell = random.choice(walkable_cells)
+    cell = RNG.choice(walkable_cells)
     return FuelCan(cell.centerx, cell.centery)
 
 
@@ -343,7 +344,7 @@ def place_flashlight(
     min_car_dist = 200
 
     for attempt in range(200):
-        cell = random.choice(walkable_cells)
+        cell = RNG.choice(walkable_cells)
         if (
             math.hypot(cell.centerx - player.x, cell.centery - player.y)
             < min_player_dist
@@ -361,7 +362,7 @@ def place_flashlight(
                 continue
         return Flashlight(cell.centerx, cell.centery)
 
-    cell = random.choice(walkable_cells)
+    cell = RNG.choice(walkable_cells)
     return Flashlight(cell.centerx, cell.centery)
 
 
@@ -409,7 +410,7 @@ def place_companion(
     min_car_dist = 180
 
     for attempt in range(200):
-        cell = random.choice(walkable_cells)
+        cell = RNG.choice(walkable_cells)
         if (
             math.hypot(cell.centerx - player.x, cell.centery - player.y)
             < min_player_dist
@@ -427,7 +428,7 @@ def place_companion(
                 continue
         return Companion(cell.centerx, cell.centery)
 
-    cell = random.choice(walkable_cells)
+    cell = RNG.choice(walkable_cells)
     return Companion(cell.centerx, cell.centery)
 
 
@@ -443,10 +444,10 @@ def scatter_positions_on_walkable(
 
     clamped_rate = max(0.0, min(1.0, spawn_rate))
     for cell in walkable_cells:
-        if random.random() >= clamped_rate:
+        if RNG.random() >= clamped_rate:
             continue
-        jitter_x = random.uniform(-cell.width * jitter_ratio, cell.width * jitter_ratio)
-        jitter_y = random.uniform(
+        jitter_x = RNG.uniform(-cell.width * jitter_ratio, cell.width * jitter_ratio)
+        jitter_y = RNG.uniform(
             -cell.height * jitter_ratio, cell.height * jitter_ratio
         )
         positions.append((int(cell.centerx + jitter_x), int(cell.centery + jitter_y)))
@@ -500,7 +501,7 @@ def update_survivors(game_data: GameData) -> None:
         dy = point[1] - survivor.y
         dist = math.hypot(dx, dy)
         if dist == 0:
-            angle = random.uniform(0, math.tau)
+            angle = RNG.uniform(0, math.tau)
             dx, dy = math.cos(angle), math.sin(angle)
             dist = 1
         if dist < min_dist:
@@ -527,7 +528,7 @@ def update_survivors(game_data: GameData) -> None:
             dy = other.y - survivor.y
             dist = math.hypot(dx, dy)
             if dist == 0:
-                angle = random.uniform(0, math.tau)
+                angle = RNG.uniform(0, math.tau)
                 dx, dy = math.cos(angle), math.sin(angle)
                 dist = 1
             if dist < survivor_overlap:
@@ -637,7 +638,6 @@ def log_waiting_car_count(game_data: GameData, *, force: bool = False) -> None:
     current = len(game_data.waiting_cars)
     if not force and current == game_data.last_logged_waiting_cars:
         return
-    stage_id = getattr(game_data.stage, "id", "unknown")
     game_data.last_logged_waiting_cars = current
 
 
@@ -662,7 +662,7 @@ def add_survivor_message(game_data: GameData, text: str) -> None:
 def random_survivor_conversion_line() -> str:
     if not SURVIVOR_CONVERSION_LINE_KEYS:
         return ""
-    key = random.choice(SURVIVOR_CONVERSION_LINE_KEYS)
+    key = RNG.choice(SURVIVOR_CONVERSION_LINE_KEYS)
     return _(key)
 
 
@@ -685,8 +685,8 @@ def drop_survivors_from_car(game_data: GameData, origin: tuple[int, int]) -> Non
     for survivor_idx in range(count):
         placed = False
         for attempt in range(6):
-            angle = random.uniform(0, math.tau)
-            dist = random.uniform(16, 40)
+            angle = RNG.uniform(0, math.tau)
+            dist = RNG.uniform(16, 40)
             pos = (
                 origin[0] + math.cos(angle) * dist,
                 origin[1] + math.sin(angle) * dist,
@@ -878,6 +878,7 @@ def initialize_game_state(config: dict[str, Any], stage: Stage) -> GameData:
         survivors_rescued=0,
         survivor_messages=[],
         survivor_capacity=SURVIVOR_MAX_SAFE_PASSENGERS,
+        seed=None,
     )
 
     # Create sprite groups
@@ -937,7 +938,7 @@ def setup_player_and_cars(
 
     def pick_center(cells: list[pygame.Rect]) -> tuple[int, int]:
         return (
-            random.choice(cells).center
+            RNG.choice(cells).center
             if cells
             else (LEVEL_WIDTH // 2, LEVEL_HEIGHT // 2)
         )
@@ -952,7 +953,7 @@ def setup_player_and_cars(
         """Favor distant cells for the first car, otherwise fall back to random picks."""
         if not car_candidates:
             return (player_pos[0] + 200, player_pos[1])
-        random.shuffle(car_candidates)
+        RNG.shuffle(car_candidates)
         for candidate in car_candidates:
             if (
                 math.hypot(
@@ -1275,7 +1276,7 @@ def check_interactions(
                 state.game_over_at = state.game_over_at or pygame.time.get_ticks()
             else:
                 if walkable_cells:
-                    new_cell = random.choice(walkable_cells)
+                    new_cell = RNG.choice(walkable_cells)
                     companion.teleport(new_cell.center)
                 else:
                     companion.teleport((LEVEL_WIDTH // 2, LEVEL_HEIGHT // 2))

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/level_blueprints.py

@@ -1,6 +1,6 @@
 # Blueprint generator for randomized layouts.
 
-import random
+from .rng import get_rng
 
 GRID_COLS = 48
 GRID_ROWS = 30
@@ -12,6 +12,8 @@ WALL_MIN_LEN = 3
 WALL_MAX_LEN = 10
 SPAWN_MARGIN = 3  # keep spawns away from walls/edges
 SPAWN_ZOMBIES = 3
+
+RNG = get_rng()
 STEEL_BEAM_CHANCE = 0.05
 
 # Legend:
@@ -61,7 +63,7 @@ def _init_grid(cols: int, rows: int) -> list[list[str]]:
 
 def _place_exits(grid: list[list[str]], exits_per_side: int) -> None:
     cols, rows = len(grid[0]), len(grid)
-    rng = random.randint
+    rng = RNG.randint
     used = set()
 
     def pick_pos(side: str) -> tuple[int, int]:
@@ -87,13 +89,13 @@ def _place_exits(grid: list[list[str]], exits_per_side: int) -> None:
 
 def _place_internal_walls(grid: list[list[str]]) -> None:
     cols, rows = len(grid[0]), len(grid)
-    rng = random.randint
+    rng = RNG.randint
     # Avoid placing walls adjacent to exits: collect forbidden cells (exits + neighbors)
     forbidden = _collect_exit_adjacent_cells(grid)
 
     for _ in range(NUM_WALL_LINES):
         length = rng(WALL_MIN_LEN, WALL_MAX_LEN)
-        horizontal = random.choice([True, False])
+        horizontal = RNG.choice([True, False])
         if horizontal:
             y = rng(2, rows - 3)
             x = rng(2, cols - 2 - length)
@@ -125,7 +127,7 @@ def _place_steel_beams(
                 continue
             if grid[y][x] not in (".", "1"):
                 continue
-            if random.random() < chance:
+            if RNG.random() < chance:
                 beams.add((x, y))
     return beams
 
@@ -139,8 +141,8 @@ def _pick_empty_cell(
     attempts = 0
     while attempts < 2000:
         attempts += 1
-        x = random.randint(margin, cols - margin - 1)
-        y = random.randint(margin, rows - margin - 1)
+        x = RNG.randint(margin, cols - margin - 1)
+        y = RNG.randint(margin, rows - margin - 1)
         if grid[y][x] == "." and (x, y) not in forbidden:
             return x, y
     # Fallback: scan for any acceptable cell

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/locales/ui.en.json

@@ -16,7 +16,10 @@
       "settings": "Settings",
       "quit": "Quit",
       "locked_suffix": "[Locked]",
-      "window_hint": "Resize window: [ to shrink, ] to enlarge (menu only)"
+      "window_hint": "Resize window: [ to shrink, ] to enlarge (menu only)",
+      "seed_label": "Seed: %{value}",
+      "seed_hint": "Type 0-9 to set a custom seed, Backspace clears",
+      "seed_empty": "(auto)"
     },
     "stages": {
       "stage1": {
@@ -47,7 +50,8 @@
       "fast": "FastZ",
       "car_hint": "CarHint",
       "flashlight": "Flashlight",
-      "steel": "Steel"
+      "steel": "Steel",
+      "seed": "Seed %{value}"
     },
     "hud": {
       "need_fuel": "Need fuel to drive!",

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/locales/ui.ja.json

@@ -16,7 +16,10 @@
       "settings": "設定",
       "quit": "終了",
       "locked_suffix": "[Locked]",
-      "window_hint": "[キーでウィンドウを小さく、]キーで大きく(メニュー画面のみ)"
+      "window_hint": "[キーでウィンドウを小さく、]キーで大きく(メニュー画面のみ)",
+      "seed_label": "シード: %{value}",
+      "seed_hint": "数字キーで入力、BSでクリア",
+      "seed_empty": "(自動)"
     },
     "stages": {
       "stage1": {
@@ -47,7 +50,8 @@
       "fast": "高速ゾ",
       "car_hint": "車ヒント",
       "flashlight": "懐中電灯",
-      "steel": "鉄筋"
+      "steel": "鉄筋",
+      "seed": "シード %{value}"
     },
     "hud": {
       "need_fuel": "燃料が必要です！",

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/models.py

@@ -49,6 +49,7 @@ class ProgressState:
     survivors_rescued: int
     survivor_messages: list
     survivor_capacity: int
+    seed: int | None
 
 
 @dataclass

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/render.py

@@ -280,6 +280,7 @@ def _draw_status_bar(
     config: dict[str, Any],
     *,
     stage: Stage | None = None,
+    seed: int | None = None,
 ) -> None:
     """Render a compact status bar with current config flags and stage info."""
     bar_rect = pygame.Rect(
@@ -327,6 +328,13 @@ def _draw_status_bar(
         text_surface = font.render(status_text, False, color)
         text_rect = text_surface.get_rect(left=12, centery=bar_rect.centery)
         screen.blit(text_surface, text_rect)
+        if seed is not None:
+            seed_text = _("status.seed", value=str(seed))
+            seed_surface = font.render(seed_text, False, LIGHT_GRAY)
+            seed_rect = seed_surface.get_rect(
+                right=bar_rect.right - 12, centery=bar_rect.centery
+            )
+            screen.blit(seed_surface, seed_rect)
     except pygame.error as e:
         print(f"Error rendering status bar: {e}")
 
@@ -573,7 +581,7 @@ def draw(
                 screen.blit(msg_surface, msg_rect)
         except pygame.error as e:
             print(f"Error rendering survivor message: {e}")
-    _draw_status_bar(screen, assets, config, stage=stage)
+    _draw_status_bar(screen, assets, config, stage=stage, seed=state.seed)
     if do_flip:
         if present_fn:
             present_fn(screen)

zombie_escape-1.3.1/src/zombie_escape/rng.py

@@ -0,0 +1,132 @@
+"""Deterministic random number helpers for reproducible runs."""
+
+from __future__ import annotations
+
+import secrets
+from typing import MutableSequence, Sequence, TypeVar
+
+T = TypeVar("T")
+
+
+def generate_seed() -> int:
+    """Return a positive 63-bit seed for ad-hoc runs."""
+    return secrets.randbits(63) or 1
+
+
+class DeterministicRNG:
+    """Mersenne Twister MT19937 implementation for deterministic runs."""
+
+    _N = 624
+    _M = 397
+    _MATRIX_A = 0x9908B0DF
+    _UPPER_MASK = 0x80000000
+    _LOWER_MASK = 0x7FFFFFFF
+
+    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)
+
+    def seed(self, value: int | None) -> None:
+        """Seed using the MT19937 initialization routine."""
+        if value is None:
+            value = generate_seed()
+        try:
+            normalized = int(value)
+        except (TypeError, ValueError) as exc:
+            raise ValueError(f"Invalid seed value: {value}") from exc
+        self._seed_value = normalized
+        seed32 = normalized & 0xFFFFFFFF
+        if seed32 == 0:
+            seed32 = 5489  # default MT seed
+        self._state[0] = seed32
+        for i in range(1, self._N):
+            prev = self._state[i - 1]
+            self._state[i] = (
+                (1812433253 * (prev ^ (prev >> 30)) + i) & 0xFFFFFFFF
+            )
+        self._index = self._N
+
+    @property
+    def seed_value(self) -> int | None:
+        return self._seed_value
+
+    def random(self) -> float:
+        """Return a float in the range [0.0, 1.0)."""
+        return self._next() / 4294967296.0  # 2**32
+
+    def randint(self, a: int, b: int) -> int:
+        if a > b:
+            raise ValueError("Lower bound must be <= upper bound for randint")
+        return a + self._randbelow(b - a + 1)
+
+    def choice(self, seq: Sequence[T]) -> T:
+        if not seq:
+            raise IndexError("Cannot choose from an empty sequence")
+        idx = self._randbelow(len(seq))
+        return seq[idx]
+
+    def shuffle(self, seq: MutableSequence[T]) -> None:
+        for i in range(len(seq) - 1, 0, -1):
+            j = self._randbelow(i + 1)
+            seq[i], seq[j] = seq[j], seq[i]
+
+    def uniform(self, a: float, b: float) -> float:
+        return a + (b - a) * self.random()
+
+    def _next(self) -> int:
+        return self._extract_number()
+
+    def _randbelow(self, bound: int) -> int:
+        if bound <= 0:
+            raise ValueError("Upper bound must be positive")
+        # Rejection sampling to avoid bias
+        limit = (1 << 32) - ((1 << 32) % bound)
+        while True:
+            value = self._next()
+            if value < limit:
+                return value % bound
+
+    def _extract_number(self) -> int:
+        if self._index >= self._N:
+            self._twist()
+        y = self._state[self._index]
+        self._index += 1
+        y ^= (y >> 11)
+        y ^= (y << 7) & 0x9D2C5680
+        y ^= (y << 15) & 0xEFC60000
+        y ^= (y >> 18)
+        return y & 0xFFFFFFFF
+
+    def _twist(self) -> None:
+        for i in range(self._N):
+            x = (self._state[i] & self._UPPER_MASK) + (
+                self._state[(i + 1) % self._N] & self._LOWER_MASK
+            )
+            xA = x >> 1
+            if x & 1:
+                xA ^= self._MATRIX_A
+            self._state[i] = self._state[(i + self._M) % self._N] ^ xA
+        self._index = 0
+
+
+_GLOBAL_RNG = DeterministicRNG()
+
+
+def get_rng() -> DeterministicRNG:
+    return _GLOBAL_RNG
+
+
+def seed_rng(seed: int | None) -> int:
+    _GLOBAL_RNG.seed(seed)
+    assert _GLOBAL_RNG.seed_value is not None
+    return _GLOBAL_RNG.seed_value
+
+
+__all__ = [
+    "DeterministicRNG",
+    "generate_seed",
+    "get_rng",
+    "seed_rng",
+]

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/screens/__init__.py

@@ -48,6 +48,9 @@ class ScreenTransition:
     stage: Stage | None = None
     game_data: GameData | None = None
     config: dict | None = None
+    seed: int | None = None
+    seed_text: str | None = None
+    seed_is_auto: bool = False
 
 
 current_window_scale = DEFAULT_WINDOW_SCALE  # Applied to the OS window only

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/screens/game_over.py

@@ -6,7 +6,8 @@ import pygame
 from pygame import surface, time
 
 from ..colors import BLACK, GREEN, LIGHT_GRAY, RED, WHITE
-from ..localization import translate as _
+from ..font_utils import load_font
+from ..localization import get_font_settings, translate as _
 from ..models import GameData, Stage
 from ..render import RenderAssets, draw_level_overview, show_message
 from ..screens import ScreenID, ScreenTransition, present
@@ -119,6 +120,19 @@ def game_over_screen(
             (screen_width // 2, screen_height // 2 + 24),
         )
 
+        if state.seed is not None:
+            try:
+                font_settings = get_font_settings()
+                font = load_font(font_settings.resource, font_settings.scaled_size(11))
+                seed_text = _("status.seed", value=str(state.seed))
+                seed_surface = font.render(seed_text, False, LIGHT_GRAY)
+                seed_rect = seed_surface.get_rect(
+                    right=screen_width - 14, bottom=screen_height - 12
+                )
+                screen.blit(seed_surface, seed_rect)
+            except pygame.error as exc:
+                print(f"Error rendering game-over seed text: {exc}")
+
         present(screen)
         clock.tick(fps)
 

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/screens/gameplay.py

@@ -15,6 +15,7 @@ from ..gameplay import logic
 from ..localization import translate as _
 from ..models import Stage
 from ..render import draw, show_message
+from ..rng import generate_seed, seed_rng
 from ..screens import ScreenID, ScreenTransition, present
 
 if TYPE_CHECKING:
@@ -29,6 +30,7 @@ def gameplay_screen(
     stage: Stage,
     *,
     show_pause_overlay: bool,
+    seed: int | None,
     render_assets: "RenderAssets",
 ) -> ScreenTransition:
     """Main gameplay loop that returns the next screen transition."""
@@ -36,7 +38,11 @@ def gameplay_screen(
     screen_width = screen.get_width()
     screen_height = screen.get_height()
 
+    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.state.seed = applied_seed
     paused_manual = False
     paused_focus = False
     last_fov_target = None

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/screens/title.py

@@ -11,6 +11,15 @@ from ..localization import get_font_settings, translate as _
 from ..models import Stage
 from ..render import show_message
 from ..screens import ScreenID, ScreenTransition, nudge_window_scale, present
+from ..rng import generate_seed
+
+MAX_SEED_DIGITS = 19
+
+
+def _generate_auto_seed_text() -> str:
+    raw = generate_seed()
+    trimmed = raw // 100  # drop lower 2 digits for stability
+    return str(trimmed % 100000).zfill(5)
 
 
 def title_screen(
@@ -22,6 +31,8 @@ def title_screen(
     stages: Sequence[Stage],
     default_stage_id: str,
     screen_size: tuple[int, int],
+    seed_text: str | None = None,
+    seed_is_auto: bool = False,
 ) -> ScreenTransition:
     """Display the title menu and return the selected transition."""
 
@@ -40,12 +51,30 @@ def title_screen(
         ),
         0,
     )
+    generated = seed_text is None
+    current_seed_text = seed_text if seed_text is not None else _generate_auto_seed_text()
+    current_seed_auto = seed_is_auto or generated
 
     while True:
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
-                return ScreenTransition(ScreenID.EXIT)
+                return ScreenTransition(
+                    ScreenID.EXIT,
+                    seed_text=current_seed_text,
+                    seed_is_auto=current_seed_auto,
+                )
             if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_BACKSPACE:
+                    current_seed_text = _generate_auto_seed_text()
+                    current_seed_auto = True
+                    continue
+                if event.unicode and event.unicode.isdigit():
+                    if current_seed_auto:
+                        current_seed_text = ""
+                        current_seed_auto = False
+                    if len(current_seed_text) < MAX_SEED_DIGITS:
+                        current_seed_text += event.unicode
+                    continue
                 if event.key == pygame.K_LEFTBRACKET:
                     nudge_window_scale(0.5)
                     continue
@@ -59,13 +88,26 @@ def title_screen(
                 elif event.key in (pygame.K_RETURN, pygame.K_SPACE):
                     current = options[selected]
                     if current["type"] == "stage" and current.get("available"):
+                        seed_value = int(current_seed_text) if current_seed_text else None
                         return ScreenTransition(
-                            ScreenID.GAMEPLAY, stage=current["stage"]
+                            ScreenID.GAMEPLAY,
+                            stage=current["stage"],
+                            seed=seed_value,
+                            seed_text=current_seed_text,
+                            seed_is_auto=current_seed_auto,
                         )
                     if current["type"] == "settings":
-                        return ScreenTransition(ScreenID.SETTINGS)
+                        return ScreenTransition(
+                            ScreenID.SETTINGS,
+                            seed_text=current_seed_text,
+                            seed_is_auto=current_seed_auto,
+                        )
                     if current["type"] == "quit":
-                        return ScreenTransition(ScreenID.EXIT)
+                        return ScreenTransition(
+                            ScreenID.EXIT,
+                            seed_text=current_seed_text,
+                            seed_is_auto=current_seed_auto,
+                        )
 
         screen.fill(BLACK)
         show_message(
@@ -117,11 +159,25 @@ def title_screen(
                 desc_rect = desc_surface.get_rect(center=(width // 2, height // 2 + 74))
                 screen.blit(desc_surface, desc_rect)
 
+            seed_font = load_font(font_settings.resource, font_settings.scaled_size(12))
+            seed_value_display = (
+                current_seed_text if current_seed_text else _("menu.seed_empty")
+            )
+            seed_label = _("status.seed", value=seed_value_display)
+            seed_surface = seed_font.render(seed_label, False, LIGHT_GRAY)
+            seed_rect = seed_surface.get_rect(right=width - 14, bottom=height - 12)
+            screen.blit(seed_surface, seed_rect)
+
             hint_font = load_font(font_settings.resource, font_settings.scaled_size(11))
             hint_text = _("menu.window_hint")
             hint_surface = hint_font.render(hint_text, False, LIGHT_GRAY)
-            hint_rect = hint_surface.get_rect(center=(width // 2, height - 50))
+            hint_rect = hint_surface.get_rect(center=(width // 2, height - 60))
             screen.blit(hint_surface, hint_rect)
+
+            seed_hint = _("menu.seed_hint")
+            seed_hint_surface = hint_font.render(seed_hint, False, GRAY)
+            seed_hint_rect = seed_hint_surface.get_rect(left=14, bottom=height - 12)
+            screen.blit(seed_hint_surface, seed_hint_rect)
         except pygame.error as e:
             print(f"Error rendering title screen: {e}")
 

{zombie_escape-1.2.1 → zombie_escape-1.3.1}/src/zombie_escape/zombie_escape.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
+import argparse
 import sys
 import traceback  # For error reporting
-from typing import Any
+from typing import Any, Tuple
 
 import pygame
 
@@ -26,9 +27,26 @@ from .models import GameData, Stage, STAGES, DEFAULT_STAGE_ID
 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 title_screen
+from .screens.title import MAX_SEED_DIGITS, title_screen
 from .gameplay.logic import calculate_car_speed_for_passengers
 
+
+def _parse_cli_args(argv: list[str]) -> Tuple[argparse.Namespace, list[str]]:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--hide-pause-overlay", action="store_true")
+    parser.add_argument("--seed")
+    return parser.parse_known_args(argv)
+
+
+def _sanitize_seed_text(raw: str | None) -> tuple[str | None, bool]:
+    if not raw:
+        return None, True
+    stripped = raw.strip()
+    if not stripped.isdigit():
+        print("Ignoring --seed value because it must contain only digits.")
+        return None, True
+    return stripped[:MAX_SEED_DIGITS], False
+
 # Re-export the gameplay helpers constants for external callers/tests.
 __all__ = [
     "main",
@@ -41,6 +59,9 @@ __all__ = [
 
 # --- Main Entry Point ---
 def main() -> None:
+    args, remaining = _parse_cli_args(sys.argv[1:])
+    sys.argv = [sys.argv[0]] + remaining
+
     pygame.init()
     try:
         pygame.font.init()
@@ -54,7 +75,9 @@ def main() -> None:
     screen = pygame.Surface((SCREEN_WIDTH, SCREEN_HEIGHT)).convert_alpha()
     clock = pygame.time.Clock()
 
-    hide_pause_overlay = "--hide-pause-overlay" in sys.argv
+    hide_pause_overlay = bool(args.hide_pause_overlay)
+    cli_seed_text, cli_seed_is_auto = _sanitize_seed_text(args.seed)
+    title_seed_text, title_seed_is_auto = cli_seed_text, cli_seed_is_auto
 
     config: dict[str, Any]
     config, config_path = load_config()
@@ -66,12 +89,14 @@ def main() -> None:
     pending_stage: Stage | None = None
     pending_game_data: GameData | None = None
     pending_config: dict[str, Any] | None = None
+    pending_seed: int | None = None
     running = True
 
     while running:
         transition: ScreenTransition | None = None
 
         if next_screen == ScreenID.TITLE:
+            seed_input = None if title_seed_is_auto else title_seed_text
             transition = title_screen(
                 screen,
                 clock,
@@ -80,7 +105,12 @@ def main() -> None:
                 stages=STAGES,
                 default_stage_id=DEFAULT_STAGE_ID,
                 screen_size=(SCREEN_WIDTH, SCREEN_HEIGHT),
+                seed_text=seed_input,
+                seed_is_auto=title_seed_is_auto,
             )
+            if transition.seed_text is not None:
+                title_seed_text = transition.seed_text
+                title_seed_is_auto = transition.seed_is_auto
         elif next_screen == ScreenID.SETTINGS:
             config = settings_screen(
                 screen,
@@ -95,6 +125,8 @@ def main() -> None:
         elif next_screen == ScreenID.GAMEPLAY:
             stage = pending_stage
             pending_stage = None
+            seed_value = pending_seed
+            pending_seed = None
             if stage is None:
                 transition = ScreenTransition(ScreenID.TITLE)
             else:
@@ -106,6 +138,7 @@ def main() -> None:
                         FPS,
                         stage,
                         show_pause_overlay=not hide_pause_overlay,
+                        seed=seed_value,
                         render_assets=RENDER_ASSETS,
                     )
                 except SystemExit:
@@ -143,6 +176,10 @@ def main() -> None:
         pending_stage = transition.stage
         pending_game_data = transition.game_data
         pending_config = transition.config
+        pending_seed = transition.seed
+        if transition.next_screen == ScreenID.GAMEPLAY:
+            title_seed_text = cli_seed_text
+            title_seed_is_auto = cli_seed_is_auto
         next_screen = transition.next_screen
 
     pygame.quit()  # Quit pygame only once at the very end of main