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

zombie_escape/render_constants.py

@@ -11,6 +11,9 @@ HUMANOID_OUTLINE_COLOR = (0, 80, 200)
 HUMANOID_OUTLINE_WIDTH = 1
 BUDDY_COLOR = (0, 180, 63)
 SURVIVOR_COLOR = (198, 198, 198)
+FALLING_ZOMBIE_COLOR = (45, 45, 45)
+FALLING_WHIRLWIND_COLOR = (200, 200, 200, 120)
+FALLING_DUST_COLOR = (70, 70, 70, 130)
 
 
 @dataclass(frozen=True)
@@ -35,11 +38,14 @@ class RenderAssets:
     footprint_min_fade: float
     internal_wall_grid_snap: int
     flashlight_bonus_step: float
+    flashlight_hatch_extra_scale: float
+
 
 FOG_RADIUS_SCALE = 1.2
 FOG_HATCH_PIXEL_SCALE = 2
 
 FLASHLIGHT_FOG_SCALE_STEP = 0.3
+FLASHLIGHT_HATCH_EXTRA_SCALE = 0.12
 
 FOOTPRINT_RADIUS = 2
 FOOTPRINT_OVERVIEW_RADIUS = 3
@@ -55,6 +61,7 @@ FOG_RINGS = [
     FogRing(radius_factor=0.968, thickness=12),
 ]
 
+
 def build_render_assets(cell_size: int) -> RenderAssets:
     return RenderAssets(
         screen_width=SCREEN_WIDTH,
@@ -71,11 +78,15 @@ def build_render_assets(cell_size: int) -> RenderAssets:
         footprint_min_fade=FOOTPRINT_MIN_FADE,
         internal_wall_grid_snap=cell_size,
         flashlight_bonus_step=FLASHLIGHT_FOG_SCALE_STEP,
+        flashlight_hatch_extra_scale=FLASHLIGHT_HATCH_EXTRA_SCALE,
     )
 
 
 __all__ = [
     "BUDDY_COLOR",
+    "FALLING_ZOMBIE_COLOR",
+    "FALLING_WHIRLWIND_COLOR",
+    "FALLING_DUST_COLOR",
     "HUMANOID_OUTLINE_COLOR",
     "HUMANOID_OUTLINE_WIDTH",
     "SURVIVOR_COLOR",
@@ -83,5 +94,6 @@ __all__ = [
     "RenderAssets",
     "FOG_RADIUS_SCALE",
     "FLASHLIGHT_FOG_SCALE_STEP",
+    "FLASHLIGHT_HATCH_EXTRA_SCALE",
     "build_render_assets",
 ]

zombie_escape/screens/__init__.py

@@ -159,6 +159,7 @@ def toggle_fullscreen(
         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")
+    pygame.mouse.set_visible(not current_maximized)
     if game_data is not None:
         game_data.state.overview_created = False
     return window

zombie_escape/screens/game_over.py

@@ -14,6 +14,7 @@ from ..render import (
     _draw_status_bar,
     show_message,
 )
+from ..input_utils import is_confirm_event, is_select_event
 from ..screens import (
     ScreenID,
     ScreenTransition,
@@ -129,16 +130,16 @@ def game_over_screen(
                     LIGHT_GRAY,
                     (screen_width // 2, summary_y),
                 )
-            elif stage and stage.survival_stage:
-                elapsed_ms = max(0, state.survival_elapsed_ms)
-                goal_ms = max(0, state.survival_goal_ms)
+            elif stage and stage.endurance_stage:
+                elapsed_ms = max(0, state.endurance_elapsed_ms)
+                goal_ms = max(0, state.endurance_goal_ms)
                 if goal_ms:
                     elapsed_ms = min(elapsed_ms, goal_ms)
                 display_ms = int(elapsed_ms * SURVIVAL_FAKE_CLOCK_RATIO)
                 hours = display_ms // 3_600_000
                 minutes = (display_ms % 3_600_000) // 60_000
                 time_label = f"{int(hours):02d}:{int(minutes):02d}"
-                msg = tr("game_over.survival_duration", time=time_label)
+                msg = tr("game_over.endurance_duration", time=time_label)
                 show_message(
                     screen,
                     msg,
@@ -181,3 +182,6 @@ def game_over_screen(
                         stage=stage,
                         seed=state.seed,
                     )
+            if event.type in (pygame.CONTROLLERBUTTONDOWN, pygame.JOYBUTTONDOWN):
+                if is_select_event(event) or is_confirm_event(event):
+                    return ScreenTransition(ScreenID.TITLE)

zombie_escape/screens/gameplay.py

@@ -8,7 +8,6 @@ from pygame import surface, time
 from ..colors import LIGHT_GRAY, RED, WHITE, YELLOW
 from ..gameplay_constants import (
     CAR_HINT_DELAY_MS_DEFAULT,
-    DEFAULT_FLASHLIGHT_SPAWN_COUNT,
     SURVIVAL_TIME_ACCEL_SUBSTEPS,
     SURVIVAL_TIME_ACCEL_MAX_SUBSTEP,
 )
@@ -29,10 +28,21 @@ from ..gameplay import (
     sync_ambient_palette_with_flashlights,
     update_entities,
     update_footprints,
-    update_survival_timer,
+    update_endurance_timer,
+)
+from ..input_utils import (
+    CONTROLLER_BUTTON_DOWN,
+    CONTROLLER_DEVICE_ADDED,
+    CONTROLLER_DEVICE_REMOVED,
+    init_first_controller,
+    init_first_joystick,
+    is_accel_active,
+    is_select_event,
+    is_start_event,
+    read_gamepad_move,
 )
 from ..gameplay.spawn import _alive_waiting_cars
-from ..entities import build_wall_index
+from ..world_grid import build_wall_index
 from ..localization import translate as tr
 from ..models import Stage
 from ..render import draw, prewarm_fog_overlays, show_message
@@ -72,11 +82,11 @@ def gameplay_screen(
     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:
-        goal_ms = max(0, stage.survival_goal_ms)
+    if debug_mode and stage.endurance_stage:
+        goal_ms = max(0, stage.endurance_goal_ms)
         if goal_ms > 0:
             remaining = 3 * 60 * 1000  # 3 minutes in ms
-            game_data.state.survival_elapsed_ms = max(0, goal_ms - remaining)
+            game_data.state.endurance_elapsed_ms = max(0, goal_ms - remaining)
             game_data.state.dawn_ready = False
             game_data.state.dawn_prompt_at = None
             game_data.state.dawn_carbonized = False
@@ -88,7 +98,8 @@ def gameplay_screen(
     paused_manual = False
     paused_focus = False
     ignore_focus_loss_until = 0
-    last_fov_target = None
+    controller = init_first_controller()
+    joystick = init_first_joystick() if controller is None else None
 
     layout_data = generate_level_from_blueprint(game_data, config)
     sync_ambient_palette_with_flashlights(game_data, force=True)
@@ -118,19 +129,18 @@ def gameplay_screen(
         if fuel_can:
             game_data.fuel = fuel_can
             game_data.groups.all_sprites.add(fuel_can, layer=1)
+    flashlight_count = stage.initial_flashlight_count
     flashlights = place_flashlights(
         layout_data["walkable_cells"],
         player,
         cars=game_data.waiting_cars,
-        count=max(1, DEFAULT_FLASHLIGHT_SPAWN_COUNT),
+        count=max(0, flashlight_count),
     )
     game_data.flashlights = flashlights
     game_data.groups.all_sprites.add(flashlights, layer=1)
 
     spawn_initial_zombies(game_data, player, layout_data, config)
     update_footprints(game_data, config)
-    last_fov_target = player
-
     while True:
         dt = clock.tick(fps) / 1000.0
         if game_data.state.game_over or game_data.state.game_won:
@@ -144,7 +154,6 @@ def gameplay_screen(
                         render_assets,
                         screen,
                         game_data,
-                        last_fov_target,
                         config=config,
                         hint_color=None,
                         present_fn=present,
@@ -180,7 +189,22 @@ def gameplay_screen(
                 paused_focus = False
             if event.type == pygame.MOUSEBUTTONDOWN:
                 paused_focus = False
-                paused_manual = False
+            if event.type == pygame.JOYDEVICEADDED or (
+                CONTROLLER_DEVICE_ADDED is not None
+                and event.type == CONTROLLER_DEVICE_ADDED
+            ):
+                if controller is None:
+                    controller = init_first_controller()
+                if controller is None:
+                    joystick = init_first_joystick()
+            if event.type == pygame.JOYDEVICEREMOVED or (
+                CONTROLLER_DEVICE_REMOVED is not None
+                and event.type == CONTROLLER_DEVICE_REMOVED
+            ):
+                if controller and not controller.get_init():
+                    controller = None
+                if joystick and not joystick.get_init():
+                    joystick = None
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_s and (
                     pygame.key.get_mods() & pygame.KMOD_CTRL
@@ -192,10 +216,40 @@ def gameplay_screen(
                     }
                     print("STATE DEBUG:", state_snapshot)
                     continue
-                if event.key == pygame.K_ESCAPE:
-                    return ScreenTransition(ScreenID.TITLE)
-                if event.key == pygame.K_p:
-                    paused_manual = not paused_manual
+                if debug_mode:
+                    if event.key == pygame.K_ESCAPE:
+                        return ScreenTransition(ScreenID.TITLE)
+                    if event.key == pygame.K_p:
+                        paused_manual = not paused_manual
+                    continue
+                if paused_manual:
+                    if event.key == pygame.K_ESCAPE:
+                        return ScreenTransition(ScreenID.TITLE)
+                    if event.key == pygame.K_p:
+                        paused_manual = False
+                    continue
+                if event.key in (pygame.K_ESCAPE, pygame.K_p):
+                    paused_manual = True
+                    continue
+            if event.type == pygame.JOYBUTTONDOWN or (
+                CONTROLLER_BUTTON_DOWN is not None
+                and event.type == CONTROLLER_BUTTON_DOWN
+            ):
+                if debug_mode:
+                    if is_select_event(event):
+                        return ScreenTransition(ScreenID.TITLE)
+                    if is_start_event(event):
+                        paused_manual = not paused_manual
+                    continue
+                if paused_manual:
+                    if is_select_event(event):
+                        return ScreenTransition(ScreenID.TITLE)
+                    if is_start_event(event):
+                        paused_manual = False
+                    continue
+                if is_select_event(event) or is_start_event(event):
+                    paused_manual = True
+                    continue
 
         paused = paused_manual or paused_focus
         if paused:
@@ -203,7 +257,6 @@ def gameplay_screen(
                 render_assets,
                 screen,
                 game_data,
-                last_fov_target,
                 config=config,
                 do_flip=not show_pause_overlay,
                 present_fn=present,
@@ -211,17 +264,19 @@ def gameplay_screen(
             if show_pause_overlay:
                 overlay = pygame.Surface((screen_width, screen_height), pygame.SRCALPHA)
                 overlay.fill((0, 0, 0, 150))
+                pause_radius = 53
+                cx = screen_width // 2
+                cy = screen_height // 2 - 18
                 pygame.draw.circle(
                     overlay,
                     LIGHT_GRAY,
-                    (screen_width // 2, screen_height // 2),
-                    35,
+                    (cx, cy),
+                    pause_radius,
                     width=3,
                 )
-                bar_width = 8
-                bar_height = 30
-                gap = 9
-                cx, cy = screen_width // 2, screen_height // 2
+                bar_width = 10
+                bar_height = 38
+                gap = 12
                 pygame.draw.rect(
                     overlay,
                     LIGHT_GRAY,
@@ -238,12 +293,12 @@ def gameplay_screen(
                     tr("hud.paused"),
                     18,
                     WHITE,
-                    (screen_width // 2, screen_height // 2 + 24),
+                    (screen_width // 2, 28),
                 )
                 show_message(
                     screen,
-                    tr("hud.resume_hint"),
-                    18,
+                    tr("hud.pause_hint"),
+                    16,
                     LIGHT_GRAY,
                     (screen_width // 2, screen_height // 2 + 70),
                 )
@@ -254,8 +309,8 @@ def gameplay_screen(
         accel_allowed = not (
             game_data.state.game_over or game_data.state.game_won
         )
-        accel_active = accel_allowed and (
-            keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]
+        accel_active = accel_allowed and is_accel_active(
+            keys, controller, joystick
         )
         game_data.state.time_accel_active = accel_active
         substeps = SURVIVAL_TIME_ACCEL_SUBSTEPS if accel_active else 1
@@ -265,14 +320,14 @@ def gameplay_screen(
         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
+            pad_vector = read_gamepad_move(controller, joystick)
             player_dx, player_dy, car_dx, car_dy = process_player_input(
-                keys, player_ref, car_ref
+                keys, player_ref, car_ref, pad_input=pad_vector
             )
             update_entities(
                 game_data,
@@ -288,19 +343,12 @@ def gameplay_screen(
             if accel_active:
                 step_ms = max(1, step_ms)
             game_data.state.elapsed_play_ms += step_ms
-            update_survival_timer(game_data, step_ms)
+            update_endurance_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
+            check_interactions(game_data, config)
             if game_data.state.game_over or game_data.state.game_won:
                 break
 
-        if frame_fov_target:
-            last_fov_target = frame_fov_target
-        else:
-            frame_fov_target = last_fov_target
-
         player = game_data.player
         if player is None:
             raise ValueError("Player missing from game data")
@@ -309,7 +357,7 @@ def gameplay_screen(
         hint_delay = car_hint_conf.get("delay_ms", CAR_HINT_DELAY_MS_DEFAULT)
         elapsed_ms = game_data.state.elapsed_play_ms
         has_fuel = game_data.state.has_fuel
-        hint_enabled = car_hint_conf.get("enabled", True) and not stage.survival_stage
+        hint_enabled = car_hint_conf.get("enabled", True) and not stage.endurance_stage
         hint_target = None
         hint_color = YELLOW
         hint_expires_at = game_data.state.hint_expires_at
@@ -356,7 +404,6 @@ def gameplay_screen(
             render_assets,
             screen,
             game_data,
-            frame_fov_target,
             config=config,
             hint_target=hint_target,
             hint_color=hint_color,

zombie_escape/screens/settings.py

@@ -10,6 +10,19 @@ from pygame import surface, time
 from ..colors import BLACK, GREEN, LIGHT_GRAY, WHITE
 from ..config import DEFAULT_CONFIG, save_config
 from ..font_utils import load_font
+from ..input_utils import (
+    CONTROLLER_BUTTON_DOWN,
+    CONTROLLER_BUTTON_DPAD_DOWN,
+    CONTROLLER_BUTTON_DPAD_LEFT,
+    CONTROLLER_BUTTON_DPAD_RIGHT,
+    CONTROLLER_BUTTON_DPAD_UP,
+    CONTROLLER_DEVICE_ADDED,
+    CONTROLLER_DEVICE_REMOVED,
+    init_first_controller,
+    init_first_joystick,
+    is_confirm_event,
+    is_select_event,
+)
 from ..localization import (
     get_font_settings,
     get_language,
@@ -95,6 +108,8 @@ def settings_screen(
     selected = 0
     languages = language_options()
     language_codes = [lang.code for lang in languages]
+    controller = init_first_controller()
+    joystick = init_first_joystick() if controller is None else None
 
     def _ensure_parent(path: tuple[str, ...]) -> tuple[dict, str]:
         node = working
@@ -143,6 +158,15 @@ def settings_screen(
 
     def build_sections() -> list[dict]:
         return [
+            {
+                "label": tr("settings.sections.menu"),
+                "rows": [
+                    {
+                        "type": "action",
+                        "label": tr("settings.rows.return_to_title"),
+                    }
+                ],
+            },
             {
                 "label": tr("settings.sections.localization"),
                 "rows": [
@@ -210,6 +234,10 @@ def settings_screen(
     row_count = len(rows)
     last_language = get_language()
 
+    def _exit_settings() -> dict[str, Any]:
+        save_config(working, config_path)
+        return working
+
     while True:
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
@@ -217,6 +245,24 @@ def settings_screen(
             if event.type in (pygame.WINDOWSIZECHANGED, pygame.VIDEORESIZE):
                 sync_window_size(event)
                 continue
+            if event.type == pygame.JOYDEVICEADDED or (
+                CONTROLLER_DEVICE_ADDED is not None
+                and event.type == CONTROLLER_DEVICE_ADDED
+            ):
+                if controller is None:
+                    controller = init_first_controller()
+                if controller is None:
+                    joystick = init_first_joystick()
+            if event.type == pygame.JOYDEVICEREMOVED or (
+                CONTROLLER_DEVICE_REMOVED is not None
+                and event.type == CONTROLLER_DEVICE_REMOVED
+            ):
+                if controller and not controller.get_init():
+                    controller = None
+                if joystick and not joystick.get_init():
+                    joystick = None
+            if is_select_event(event):
+                return _exit_settings()
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_LEFTBRACKET:
                     nudge_window_scale(0.5)
@@ -228,8 +274,7 @@ def settings_screen(
                     toggle_fullscreen()
                     continue
                 if event.key in (pygame.K_ESCAPE, pygame.K_BACKSPACE):
-                    save_config(working, config_path)
-                    return working
+                    return _exit_settings()
                 if event.key in (pygame.K_UP, pygame.K_w):
                     selected = (selected - 1) % row_count
                 if event.key in (pygame.K_DOWN, pygame.K_s):
@@ -237,16 +282,18 @@ def settings_screen(
                 current_row = rows[selected]
                 row_type = current_row.get("type", "toggle")
                 if event.key in (pygame.K_SPACE, pygame.K_RETURN):
+                    if row_type == "action":
+                        return _exit_settings()
                     if row_type == "toggle":
                         toggle_row(current_row)
                     elif row_type == "choice":
                         cycle_choice(current_row, 1)
-                if event.key == pygame.K_LEFT:
+                if event.key == pygame.K_LEFT and row_type != "action":
                     if row_type == "toggle":
                         set_easy_value(current_row, True)
                     elif row_type == "choice":
                         cycle_choice(current_row, -1)
-                if event.key == pygame.K_RIGHT:
+                if event.key == pygame.K_RIGHT and row_type != "action":
                     if row_type == "toggle":
                         set_easy_value(current_row, False)
                     elif row_type == "choice":
@@ -254,6 +301,66 @@ def settings_screen(
                 if event.key == pygame.K_r:
                     working = copy.deepcopy(DEFAULT_CONFIG)
                     set_language(working.get("language"))
+            if event.type == pygame.JOYBUTTONDOWN or (
+                CONTROLLER_BUTTON_DOWN is not None
+                and event.type == CONTROLLER_BUTTON_DOWN
+            ):
+                current_row = rows[selected]
+                row_type = current_row.get("type", "toggle")
+                if is_confirm_event(event):
+                    if row_type == "action":
+                        return _exit_settings()
+                    if row_type == "toggle":
+                        toggle_row(current_row)
+                    elif row_type == "choice":
+                        cycle_choice(current_row, 1)
+                if CONTROLLER_BUTTON_DOWN is not None and event.type == CONTROLLER_BUTTON_DOWN:
+                    if (
+                        CONTROLLER_BUTTON_DPAD_UP is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_UP
+                    ):
+                        selected = (selected - 1) % row_count
+                    if (
+                        CONTROLLER_BUTTON_DPAD_DOWN is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_DOWN
+                    ):
+                        selected = (selected + 1) % row_count
+                    if (
+                        CONTROLLER_BUTTON_DPAD_LEFT is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_LEFT
+                        and row_type != "action"
+                    ):
+                        if row_type == "toggle":
+                            set_easy_value(current_row, True)
+                        elif row_type == "choice":
+                            cycle_choice(current_row, -1)
+                    if (
+                        CONTROLLER_BUTTON_DPAD_RIGHT is not None
+                        and event.button == CONTROLLER_BUTTON_DPAD_RIGHT
+                        and row_type != "action"
+                    ):
+                        if row_type == "toggle":
+                            set_easy_value(current_row, False)
+                        elif row_type == "choice":
+                            cycle_choice(current_row, 1)
+            if event.type == pygame.JOYHATMOTION:
+                current_row = rows[selected]
+                row_type = current_row.get("type", "toggle")
+                hat_x, hat_y = event.value
+                if hat_y == 1:
+                    selected = (selected - 1) % row_count
+                elif hat_y == -1:
+                    selected = (selected + 1) % row_count
+                if hat_x == -1 and row_type != "action":
+                    if row_type == "toggle":
+                        set_easy_value(current_row, True)
+                    elif row_type == "choice":
+                        cycle_choice(current_row, -1)
+                elif hat_x == 1 and row_type != "action":
+                    if row_type == "toggle":
+                        set_easy_value(current_row, False)
+                    elif row_type == "choice":
+                        cycle_choice(current_row, 1)
 
         current_language = get_language()
         if current_language != last_language:
@@ -284,8 +391,8 @@ def settings_screen(
             )
             highlight_color = (70, 70, 70)
 
-            row_height = 22
-            start_y = 52
+            row_height = 20
+            start_y = 46
 
             segment_width = 30
             segment_height = 18
@@ -294,7 +401,7 @@ def settings_screen(
 
             column_margin = 24
             column_width = screen_width // 2 - column_margin * 2
-            section_spacing = 6
+            section_spacing = 4
             row_indent = 12
             value_padding = 20
 
@@ -305,7 +412,7 @@ def settings_screen(
                     section["label"], False, LIGHT_GRAY
                 )
                 section_states[section["label"]] = {
-                    "next_y": y_cursor + header_surface.get_height() + 6,
+                    "next_y": y_cursor + header_surface.get_height() + 4,
                     "header_surface": header_surface,
                     "header_pos": (column_margin, y_cursor),
                 }
@@ -324,9 +431,13 @@ def settings_screen(
                 state = section_states[section_label]
                 col_x = column_margin + row_indent
                 row_width = column_width - row_indent + value_padding
-                value = _get_value(
-                    row["path"], row.get("easy_value", row.get("choices", [None])[0])
-                )
+                row_type = row.get("type", "toggle")
+                value = None
+                if row_type != "action":
+                    value = _get_value(
+                        row["path"],
+                        row.get("easy_value", row.get("choices", [None])[0]),
+                    )
                 row_y_current = state["next_y"]
                 state["next_y"] += row_height
 
@@ -344,7 +455,7 @@ def settings_screen(
                     )
                 )
                 screen.blit(label_surface, label_rect)
-                if row.get("type", "toggle") == "choice":
+                if row_type == "choice":
                     display_fn = row.get("get_display")
                     display_text = (
                         display_fn(value)
@@ -359,7 +470,7 @@ def settings_screen(
                         )
                     )
                     screen.blit(value_surface, value_rect)
-                else:
+                elif row_type == "toggle":
                     slider_y = row_y_current + (row_height - segment_height) // 2 - 2
                     slider_x = col_x + row_width - segment_total_width
                     left_rect = pygame.Rect(