zombie-escape 1.10.0__tar.gz → 1.10.1__tar.gz

{zombie_escape-1.10.0 → zombie_escape-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zombie-escape
-Version: 1.10.0
+Version: 1.10.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>
@@ -48,6 +48,7 @@ This game is a simple 2D top-down action game where the player aims to escape by
 <img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot1.png" width="400">
 <img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot2.png" width="400">
 <img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot3.png" width="400">
+<img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot4.png" width="400">
 
 ## Controls
 

{zombie_escape-1.10.0 → zombie_escape-1.10.1}/README.md

@@ -19,6 +19,7 @@ This game is a simple 2D top-down action game where the player aims to escape by
 <img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot1.png" width="400">
 <img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot2.png" width="400">
 <img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot3.png" width="400">
+<img src="https://raw.githubusercontent.com/tos-kamiya/zombie-escape/main/imgs/screenshot4.png" width="400">
 
 ## Controls
 

{zombie_escape-1.10.0 → zombie_escape-1.10.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.10.0"
+__version__ = "1.10.1"

{zombie_escape-1.10.0 → zombie_escape-1.10.1}/src/zombie_escape/colors.py

@@ -72,37 +72,39 @@ _DEFAULT_ENVIRONMENT_PALETTE = EnvironmentPalette(
 # Dark, desaturated palette that sells the "alone without a flashlight" vibe.
 _GLOOM_ENVIRONMENT_PALETTE = EnvironmentPalette(
     floor_primary=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.floor_primary, brightness=0.725, saturation=0.675
+        _DEFAULT_ENVIRONMENT_PALETTE.floor_primary, brightness=0.8, saturation=0.75
     ),
     floor_secondary=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.floor_secondary, brightness=0.74, saturation=0.65
+        _DEFAULT_ENVIRONMENT_PALETTE.floor_secondary, brightness=0.8, saturation=0.75
     ),
     fall_zone_primary=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.fall_zone_primary,
-        brightness=0.725,
-        saturation=0.675,
+        brightness=0.8,
+        saturation=0.75,
     ),
     fall_zone_secondary=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.fall_zone_secondary,
-        brightness=0.74,
-        saturation=0.65,
+        brightness=0.8,
+        saturation=0.75,
     ),
     outside=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.outside, brightness=0.7, saturation=0.625
+        _DEFAULT_ENVIRONMENT_PALETTE.outside, brightness=0.8, saturation=0.75
     ),
     inner_wall=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall, brightness=0.775, saturation=0.7
+        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall, brightness=0.8, saturation=0.75
     ),
     inner_wall_border=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall_border, brightness=0.775, saturation=0.7
+        _DEFAULT_ENVIRONMENT_PALETTE.inner_wall_border,
+        brightness=0.8,
+        saturation=0.75,
     ),
     outer_wall=_adjust_color(
-        _DEFAULT_ENVIRONMENT_PALETTE.outer_wall, brightness=0.75, saturation=0.675
+        _DEFAULT_ENVIRONMENT_PALETTE.outer_wall, brightness=0.8, saturation=0.75
     ),
     outer_wall_border=_adjust_color(
         _DEFAULT_ENVIRONMENT_PALETTE.outer_wall_border,
-        brightness=0.75,
-        saturation=0.675,
+        brightness=0.8,
+        saturation=0.75,
     ),
 )
 

{zombie_escape-1.10.0 → zombie_escape-1.10.1}/src/zombie_escape/render.py

@@ -41,6 +41,10 @@ from .render_constants import (
     FALLING_DUST_COLOR,
     FALLING_WHIRLWIND_COLOR,
     FALLING_ZOMBIE_COLOR,
+    SHADOW_MIN_RATIO,
+    SHADOW_OVERSAMPLE,
+    SHADOW_RADIUS_RATIO,
+    SHADOW_STEPS,
 )
 
 _SHADOW_TILE_CACHE: dict[tuple[int, int, float], surface.Surface] = {}
@@ -57,34 +61,45 @@ def _get_shadow_tile_surface(
     if key in _SHADOW_TILE_CACHE:
         return _SHADOW_TILE_CACHE[key]
     size = key[0]
-    surf = pygame.Surface((size, size), pygame.SRCALPHA)
+    oversample = SHADOW_OVERSAMPLE
+    render_size = size * oversample
+    render_surf = pygame.Surface((render_size, render_size), pygame.SRCALPHA)
     base_alpha = key[1]
     if edge_softness <= 0:
-        surf.fill((0, 0, 0, base_alpha))
+        render_surf.fill((0, 0, 0, base_alpha))
+        if oversample > 1:
+            surf = pygame.transform.smoothscale(render_surf, (size, size))
+        else:
+            surf = render_surf
         _SHADOW_TILE_CACHE[key] = surf
         return surf
 
     softness = max(0.0, min(1.0, edge_softness))
-    fade_band = max(1, int(size * softness))
-    base_radius = max(1, int(size * 0.18))
-
-    def draw_layer(inset: int, layer_alpha: int) -> None:
-        rect_size = size - inset * 2
+    fade_band = max(1, int(render_size * softness))
+    base_radius = max(1, int(render_size * SHADOW_RADIUS_RATIO))
+
+    render_surf.fill((0, 0, 0, 0))
+    steps = SHADOW_STEPS
+    min_ratio = SHADOW_MIN_RATIO
+    for idx in range(steps):
+        t = idx / (steps - 1) if steps > 1 else 1.0
+        inset = int(fade_band * t)
+        rect_size = render_size - inset * 2
         if rect_size <= 0:
-            return
+            continue
         radius = max(0, base_radius - inset)
+        layer_alpha = int(base_alpha * (min_ratio + (1.0 - min_ratio) * t))
         pygame.draw.rect(
-            surf,
+            render_surf,
             (0, 0, 0, layer_alpha),
             pygame.Rect(inset, inset, rect_size, rect_size),
             border_radius=radius,
         )
 
-    outer_alpha = int(base_alpha * 0.45)
-    mid_alpha = int(base_alpha * 0.7)
-    draw_layer(0, outer_alpha)
-    draw_layer(max(1, fade_band // 2), mid_alpha)
-    draw_layer(fade_band, base_alpha)
+    if oversample > 1:
+        surf = pygame.transform.smoothscale(render_surf, (size, size))
+    else:
+        surf = render_surf
     _SHADOW_TILE_CACHE[key] = surf
     return surf
 
@@ -280,19 +295,21 @@ def _get_hatch_pattern(
     fog_data: dict[str, Any],
     thickness: int,
     *,
-    pixel_scale: int = 1,
     color: tuple[int, int, int, int] | None = None,
 ) -> surface.Surface:
-    """Return cached ordered-dither tile surface (Bayer-style, optionally chunky)."""
+    """Return cached dot hatch tile surface (Bayer-ordered, optionally chunky)."""
     cache = fog_data.setdefault("hatch_patterns", {})
-    pixel_scale = max(1, pixel_scale)
-    key = (thickness, pixel_scale, color)
+    key = (thickness, color)
     if key in cache:
         return cache[key]
 
-    spacing = 20
+    spacing = 4
+    oversample = 3
     density = max(1, min(thickness, 16))
-    pattern = pygame.Surface((spacing, spacing), pygame.SRCALPHA)
+    pattern_size = spacing * 8
+    hi_spacing = spacing * oversample
+    hi_pattern_size = pattern_size * oversample
+    pattern = pygame.Surface((hi_pattern_size, hi_pattern_size), pygame.SRCALPHA)
 
     # 8x8 Bayer matrix values 0..63 for ordered dithering
     bayer = [
@@ -306,14 +323,20 @@ def _get_hatch_pattern(
         [63, 31, 55, 23, 61, 29, 53, 21],
     ]
     threshold = int((density / 16) * 64)
-    for y in range(spacing):
-        for x in range(spacing):
-            if bayer[y % 8][x % 8] < threshold:
-                pattern.set_at((x, y), color or (0, 0, 0, 255))
+    dot_radius = max(
+        1,
+        min(hi_spacing, int(math.ceil((density / 16) * hi_spacing))),
+    )
+    dot_color = color or (0, 0, 0, 255)
+    for grid_y in range(8):
+        for grid_x in range(8):
+            if bayer[grid_y][grid_x] < threshold:
+                cx = grid_x * hi_spacing + hi_spacing // 2
+                cy = grid_y * hi_spacing + hi_spacing // 2
+                pygame.draw.circle(pattern, dot_color, (cx, cy), dot_radius)
 
-    if pixel_scale > 1:
-        scaled_size = (spacing * pixel_scale, spacing * pixel_scale)
-        pattern = pygame.transform.scale(pattern, scaled_size)
+    if oversample > 1:
+        pattern = pygame.transform.smoothscale(pattern, (pattern_size, pattern_size))
 
     cache[key] = pattern
     return pattern
@@ -354,7 +377,6 @@ def _get_fog_overlay_surfaces(
         pattern = _get_hatch_pattern(
             fog_data,
             ring.thickness,
-            pixel_scale=assets.fog_hatch_pixel_scale,
             color=base_color,
         )
         p_w, p_h = pattern.get_size()
@@ -390,7 +412,7 @@ def _build_flashlight_fade_surface(
     *,
     start_ratio: float = 0.2,
     max_alpha: int = 220,
-    outer_extension: int = 50,
+    outer_extension: int = 30,
 ) -> surface.Surface:
     """Return a radial gradient so flashlight edges softly darken again."""
 
@@ -597,7 +619,11 @@ def _draw_status_bar(
     steel_on = config.get("steel_beams", {}).get("enabled", False)
     if stage:
         # Keep the label compact for the status bar
-        stage_label = f"#{stage.id[-1]}" if stage.id.startswith("stage") else stage.id
+        if stage.id.startswith("stage"):
+            stage_suffix = stage.id.removeprefix("stage")
+            stage_label = f"#{stage_suffix}" if stage_suffix else stage.id
+        else:
+            stage_label = stage.id
     else:
         stage_label = "#1"
 
@@ -723,6 +749,16 @@ def _draw_play_area(
     return xs, ys, xe, ye, outside_cells
 
 
+def abs_clip(value: float, min_v: float, max_v: float) -> float:
+    value_sign = 1.0 if value >= 0.0 else -1.0
+    value = abs(value)
+    if value < min_v:
+        value = min_v
+    elif value > max_v:
+        value = max_v
+    return value_sign * value
+
+
 def _draw_wall_shadows(
     screen: surface.Surface,
     camera: Camera,
@@ -732,7 +768,7 @@ def _draw_wall_shadows(
     outer_wall_cells: set[tuple[int, int]] | None,
     cell_size: int,
     light_source_pos: tuple[int, int] | None,
-    alpha: int = 54,
+    alpha: int = 68,
 ) -> None:
     if not wall_cells or cell_size <= 0 or light_source_pos is None:
         return
@@ -754,24 +790,25 @@ def _draw_wall_shadows(
     shadow_layer.fill((0, 0, 0, 0))
     screen_rect = screen.get_rect()
     px, py = light_source_pos
-    offset = max(2, int(cell_size * 0.3 * (shadow_size / cell_size) * 1.2))
     drew = False
+    clip_max = shadow_size * 0.25
     for cell_x, cell_y in inner_wall_cells:
         world_x = cell_x * cell_size
         world_y = cell_y * cell_size
+        wall_rect = pygame.Rect(world_x, world_y, cell_size, cell_size)
+        wall_screen_rect = camera.apply_rect(wall_rect)
+        if not wall_screen_rect.colliderect(screen_rect):
+            continue
         center_x = world_x + cell_size / 2
         center_y = world_y + cell_size / 2
-        dx = center_x - px
-        dy = center_y - py
-        dist = math.hypot(dx, dy)
-        if dist <= 1e-3:
-            continue
-        nx = dx / dist
-        ny = dy / dist
+        dx = (center_x - px) * 0.5
+        dy = (center_y - py) * 0.5
+        dx = int(abs_clip(dx, 0, clip_max))
+        dy = int(abs_clip(dy, 0, clip_max))
         shadow_rect = pygame.Rect(0, 0, shadow_size, shadow_size)
         shadow_rect.center = (
-            int(center_x + nx * offset),
-            int(center_y + ny * offset),
+            int(center_x + dx),
+            int(center_y + dy),
         )
         shadow_screen_rect = camera.apply_rect(shadow_rect)
         if not shadow_screen_rect.colliderect(screen_rect):
@@ -1195,7 +1232,9 @@ def draw(
         outer_wall_cells=game_data.layout.outer_wall_cells,
         cell_size=game_data.cell_size,
         light_source_pos=(
-            None if (stage and stage.endurance_stage and state.dawn_ready) else fov_target.rect.center
+            None
+            if (stage and stage.endurance_stage and state.dawn_ready)
+            else fov_target.rect.center
         )
         if fov_target
         else None,

{zombie_escape-1.10.0 → zombie_escape-1.10.1}/src/zombie_escape/render_constants.py

@@ -30,7 +30,6 @@ class RenderAssets:
     player_radius: int
     fov_radius: int
     fog_radius_scale: float
-    fog_hatch_pixel_scale: int
     fog_rings: list[FogRing]
     footprint_radius: int
     footprint_overview_radius: int
@@ -42,7 +41,6 @@ class RenderAssets:
 
 
 FOG_RADIUS_SCALE = 1.2
-FOG_HATCH_PIXEL_SCALE = 2
 
 FLASHLIGHT_FOG_SCALE_STEP = 0.3
 FLASHLIGHT_HATCH_EXTRA_SCALE = 0.12
@@ -53,12 +51,17 @@ FOOTPRINT_COLOR = (110, 200, 255)
 FOOTPRINT_LIFETIME_MS = 135000
 FOOTPRINT_MIN_FADE = 0.3
 
+SHADOW_OVERSAMPLE = 2
+SHADOW_STEPS = 10
+SHADOW_MIN_RATIO = 0.0
+SHADOW_RADIUS_RATIO = 0.3
+
 FOG_RINGS = [
-    FogRing(radius_factor=0.529, thickness=2),
-    FogRing(radius_factor=0.639, thickness=4),
-    FogRing(radius_factor=0.748, thickness=6),
-    FogRing(radius_factor=0.858, thickness=8),
-    FogRing(radius_factor=0.968, thickness=12),
+    FogRing(radius_factor=0.536, thickness=2),
+    FogRing(radius_factor=0.645, thickness=3),
+    FogRing(radius_factor=0.754, thickness=5),
+    FogRing(radius_factor=0.863, thickness=8),
+    FogRing(radius_factor=0.972, thickness=12),
 ]
 
 
@@ -70,7 +73,6 @@ def build_render_assets(cell_size: int) -> RenderAssets:
         player_radius=PLAYER_RADIUS,
         fov_radius=FOV_RADIUS,
         fog_radius_scale=FOG_RADIUS_SCALE,
-        fog_hatch_pixel_scale=FOG_HATCH_PIXEL_SCALE,
         fog_rings=FOG_RINGS,
         footprint_radius=FOOTPRINT_RADIUS,
         footprint_overview_radius=FOOTPRINT_OVERVIEW_RADIUS,
@@ -93,6 +95,10 @@ __all__ = [
     "FogRing",
     "RenderAssets",
     "FOG_RADIUS_SCALE",
+    "SHADOW_OVERSAMPLE",
+    "SHADOW_STEPS",
+    "SHADOW_MIN_RATIO",
+    "SHADOW_RADIUS_RATIO",
     "FLASHLIGHT_FOG_SCALE_STEP",
     "FLASHLIGHT_HATCH_EXTRA_SCALE",
     "build_render_assets",