59e4bcce1c
* Add a visible frame one tile beyond the normal screen in debug mode. * Fix the display of motion paths for mounted traps in debug mode. * Add an animation for the warp trap.
398 lines
17 KiB
Python
398 lines
17 KiB
Python
"""Top-level game loop, states, HUD, and the death/respawn/win flow."""
|
|
|
|
import os
|
|
import glob
|
|
import pygame
|
|
|
|
from . import settings as S
|
|
from .assets import AssetStore
|
|
from .level import Level
|
|
from .player import Player, InputState
|
|
|
|
HUD_H = 46 # height of the status bar above the play area
|
|
MIN_W = 480 # keep the window wide enough for the HUD text
|
|
|
|
|
|
class Game:
|
|
def __init__(self, level_paths, assets_dir, debug=False):
|
|
pygame.init()
|
|
pygame.display.set_caption(S.CAPTION)
|
|
self.level_paths = level_paths
|
|
self.force_debug = debug # --debug: turn debug view on for every level
|
|
self.assets = AssetStore(assets_dir)
|
|
self.clock = pygame.time.Clock()
|
|
self.hud_font = pygame.font.SysFont("consolas,menlo,monospace", 22, bold=True)
|
|
self.big_font = pygame.font.SysFont("consolas,menlo,monospace", 40, bold=True)
|
|
|
|
self.index = 0
|
|
self.running = True
|
|
self.state = "playing" # playing | dying | won_level | won_all
|
|
self.death_timer = 0.0 # counts down during the "dying" pause
|
|
self.death_rect = None # where to draw the corpse
|
|
self.deaths = 0 # total deaths this session
|
|
self.level_deaths = 0 # deaths on the current level (resets per level)
|
|
self._pending_reload = False # F5: reload the level file on next respawn
|
|
|
|
# Size the window ONCE to fit the largest level, then never resize it —
|
|
# calling set_mode again mid-session recreates the window (it flickers /
|
|
# looks like it closes). Smaller levels are centred within it. The debug
|
|
# view reveals a margin of overscan around a level, so budget for it here
|
|
# (for any level that will be shown in debug) or it'd be clipped.
|
|
dims = [self._draw_size(lv) for lv in map(Level, self.level_paths)]
|
|
self.win_w = max(max(w for w, _ in dims), MIN_W)
|
|
self.win_h = max(h for _, h in dims) + HUD_H
|
|
self.screen = pygame.display.set_mode((self.win_w, self.win_h))
|
|
|
|
self._load_current()
|
|
|
|
# --- level management ----------------------------------------------------
|
|
def _debug_margin(self, level):
|
|
"""Pixels of overscan drawn around a level in the debug view (0 if it
|
|
won't be shown in debug)."""
|
|
if not (self.force_debug or level.debug):
|
|
return 0
|
|
return S.DEBUG_VIEW_MARGIN * level.tile
|
|
|
|
def _draw_size(self, level):
|
|
"""The pixel size the level's play surface occupies, including any debug
|
|
overscan margin on both sides."""
|
|
m = self._debug_margin(level)
|
|
return level.width + 2 * m, level.height + 2 * m
|
|
|
|
def _load_current(self):
|
|
self.level = Level(self.level_paths[self.index])
|
|
if self.force_debug:
|
|
self.level.debug = True # CLI flag overrides the per-level setting
|
|
self.player = Player(self.level)
|
|
self.battery = self.level.battery
|
|
# In debug, grow the play surface by a margin and shift all drawing into
|
|
# it (render_offset) so geometry just off the map is visible.
|
|
m = self._debug_margin(self.level)
|
|
self.level.render_offset = (m, m)
|
|
world_w, world_h = self._draw_size(self.level)
|
|
self.world = pygame.Surface((world_w, world_h))
|
|
# Centre the play area in the fixed window, below the HUD.
|
|
ox = (self.win_w - world_w) // 2
|
|
oy = HUD_H + (self.win_h - HUD_H - world_h) // 2
|
|
self.world_pos = (ox, oy)
|
|
self.state = "playing"
|
|
self.death_timer = 0.0
|
|
self.death_rect = None
|
|
self.level_deaths = 0 # fresh count for the level we just loaded
|
|
|
|
def _start_death(self):
|
|
# Begin the death pause: freeze everything, leave the corpse on screen.
|
|
# Traps are deliberately NOT reset yet — that happens on respawn.
|
|
if self.state != "playing":
|
|
return
|
|
self.deaths += 1
|
|
self.level_deaths += 1
|
|
self.state = "dying"
|
|
self.death_timer = S.DEATH_PAUSE
|
|
self.death_rect = self.player.rect.copy()
|
|
# Let traps settle into a final look before the scene freezes — e.g. a
|
|
# phase block that was mid-materialise snaps to fully visible.
|
|
for t in self.level.traps:
|
|
t.finalize_all()
|
|
|
|
def _respawn(self):
|
|
if self._pending_reload:
|
|
# F5 hot-reload: re-read the level file from disk (picks up edits),
|
|
# keeping the death the reload just counted.
|
|
self._pending_reload = False
|
|
kept = self.level_deaths
|
|
try:
|
|
self._load_current()
|
|
self.level_deaths = kept
|
|
except Exception as ex: # bad edit -> don't crash
|
|
print(f"[reload] {self.level_paths[self.index]}: {ex}")
|
|
self.player.respawn()
|
|
self.level.reset()
|
|
self.battery = self.level.battery
|
|
else:
|
|
self.player.respawn()
|
|
self.level.reset()
|
|
self.battery = self.level.battery # phone gets plugged back in at start
|
|
self.state = "playing"
|
|
|
|
def _reload_level(self):
|
|
# Hot-reload the current level from disk. Counts as a death — plays the
|
|
# death beat and bumps the counters — so it also escapes soft-locks.
|
|
if self.state != "playing":
|
|
return
|
|
self._pending_reload = True
|
|
self._start_death()
|
|
|
|
def _reach_goal(self):
|
|
# Freeze everything and play the battery-charging animation; the win
|
|
# splash follows once it finishes.
|
|
self.state = "charging"
|
|
self.charge_timer = 0.0
|
|
tf = max(0.0, self.battery / self.level.battery) if self.level.battery else 0.0
|
|
self.charge_from = tf * (self.level.battery_pct / 100.0) # near-empty start
|
|
self._final = self.index + 1 >= len(self.level_paths)
|
|
|
|
def _advance(self):
|
|
self.index += 1
|
|
self._load_current()
|
|
|
|
def _replay(self):
|
|
# Fresh session after clearing everything.
|
|
self.index = 0
|
|
self.deaths = 0
|
|
self._load_current()
|
|
|
|
def _start_fade(self, action):
|
|
# Fade to black, run `action` (load a level) at full black, then fade in.
|
|
# Snapshot the current frame (the splash) so the fade-out dips *it* to
|
|
# black instead of flashing the underlying world.
|
|
self.fade_snapshot = self.screen.copy()
|
|
self.state = "fading"
|
|
self.fade_timer = 0.0
|
|
self.fade_phase = "out"
|
|
self.fade_action = action
|
|
|
|
def _update_fade(self, dt):
|
|
self.fade_timer += dt
|
|
if self.fade_timer < S.FADE_TIME:
|
|
return
|
|
if self.fade_phase == "out":
|
|
self.fade_action() # swap levels while the screen is black
|
|
self.state = "fading" # _load_current() flips to "playing"; undo it
|
|
self.fade_phase = "in"
|
|
self.fade_timer = 0.0
|
|
else:
|
|
self.state = "playing"
|
|
|
|
# --- input ---------------------------------------------------------------
|
|
def _poll_events(self):
|
|
inp = InputState()
|
|
for e in pygame.event.get():
|
|
if e.type == pygame.QUIT:
|
|
self.running = False
|
|
elif e.type == pygame.KEYDOWN:
|
|
if e.key == pygame.K_ESCAPE:
|
|
self.running = False
|
|
elif e.key in (pygame.K_SPACE, pygame.K_w, pygame.K_UP):
|
|
inp.jump_pressed = True
|
|
elif e.key == pygame.K_r:
|
|
self._start_death() # manual give-up / restart
|
|
elif e.key == pygame.K_F5:
|
|
self._reload_level() # hot-reload from disk (counts as a death)
|
|
elif self.state == "won_level" and e.key == pygame.K_RETURN:
|
|
self._start_fade(self._advance)
|
|
elif self.state == "won_all" and e.key == pygame.K_RETURN:
|
|
self._start_fade(self._replay)
|
|
|
|
keys = pygame.key.get_pressed()
|
|
inp.left = keys[pygame.K_a] or keys[pygame.K_LEFT]
|
|
inp.right = keys[pygame.K_d] or keys[pygame.K_RIGHT]
|
|
inp.down = keys[pygame.K_s] or keys[pygame.K_DOWN]
|
|
inp.jump_held = keys[pygame.K_SPACE] or keys[pygame.K_w] or keys[pygame.K_UP]
|
|
return inp
|
|
|
|
# --- main loop -----------------------------------------------------------
|
|
def run(self):
|
|
while self.running:
|
|
dt = self.clock.tick(S.FPS) / 1000.0
|
|
dt = min(dt, 1 / 30) # clamp to avoid tunneling on lag spikes
|
|
inp = self._poll_events()
|
|
|
|
if self.state == "playing":
|
|
self._update_play(dt, inp)
|
|
elif self.state == "dying":
|
|
# Scene is frozen; just count down, then reset and respawn.
|
|
self.death_timer -= dt
|
|
if self.death_timer <= 0:
|
|
self._respawn()
|
|
elif self.state == "charging":
|
|
# Everything stops while the battery animates up to full.
|
|
self.charge_timer += dt
|
|
if self.charge_timer >= S.CHARGE_TIME:
|
|
self.state = "won_all" if self._final else "won_level"
|
|
elif self.state == "fading":
|
|
self._update_fade(dt)
|
|
|
|
self._draw()
|
|
pygame.quit()
|
|
|
|
def _update_play(self, dt, inp):
|
|
self.battery -= dt
|
|
self.level.update(dt, self)
|
|
self.player.update(dt, inp)
|
|
|
|
# death conditions
|
|
pr = self.player.rect
|
|
died = self.battery <= 0
|
|
died = died or pr.top > self.level.height + 160 # fell out of the world
|
|
died = died or self.player.crushed # pinched by a moving block
|
|
if not died:
|
|
for hz in self.level.hazard_rects():
|
|
if pr.colliderect(hz):
|
|
died = True
|
|
break
|
|
if died:
|
|
self._start_death()
|
|
return
|
|
|
|
# reached the charger?
|
|
if pr.colliderect(self.level.goal_rect):
|
|
self._reach_goal()
|
|
|
|
# --- rendering -----------------------------------------------------------
|
|
def _draw(self):
|
|
# Fade-out: dip the frozen splash frame to black (level not swapped yet).
|
|
if self.state == "fading" and self.fade_phase == "out":
|
|
self.screen.blit(self.fade_snapshot, (0, 0))
|
|
p = min(1.0, self.fade_timer / S.FADE_TIME)
|
|
overlay = pygame.Surface(self.screen.get_size())
|
|
overlay.fill((0, 0, 0))
|
|
overlay.set_alpha(int(255 * p))
|
|
self.screen.blit(overlay, (0, 0))
|
|
pygame.display.flip()
|
|
return
|
|
|
|
self.world.fill(S.COLOR_BG)
|
|
self.level.draw(self.world, self.assets)
|
|
if self.state == "dying" and self.death_rect is not None:
|
|
# The traps stay drawn in their moment-of-death state; the player is
|
|
# replaced by a corpse sprite where they fell.
|
|
sprite = self.assets.get("player_dead", self.death_rect.w, self.death_rect.h)
|
|
self.world.blit(sprite, self.death_rect.move(self.level.render_offset))
|
|
else:
|
|
self.player.draw(self.world, self.assets)
|
|
|
|
self.screen.fill((12, 12, 18))
|
|
self.screen.blit(self.world, self.world_pos)
|
|
self._draw_hud(hide_battery=(self.state == "charging"))
|
|
|
|
if self.state == "dying":
|
|
# A red tint that fades as the corpse lingers.
|
|
alpha = int(140 * (self.death_timer / S.DEATH_PAUSE))
|
|
overlay = pygame.Surface(self.screen.get_size(), pygame.SRCALPHA)
|
|
overlay.fill((200, 40, 40, alpha))
|
|
self.screen.blit(overlay, (0, 0))
|
|
|
|
if self.state == "charging":
|
|
self._draw_charge_anim()
|
|
|
|
if self.state == "won_level":
|
|
plural = "death" if self.level_deaths == 1 else "deaths"
|
|
self._draw_win_splash("LEVEL COMPLETE — phone charged!",
|
|
f"{self.level_deaths} {plural} here · {self.deaths} total · ENTER for the next level")
|
|
elif self.state == "won_all":
|
|
self._draw_win_splash("YOU MADE IT! Phone fully charged.",
|
|
f"All levels cleared with {self.deaths} deaths. ENTER to replay")
|
|
|
|
if self.state == "fading": # fade-in only; fade-out returned early above
|
|
p = min(1.0, self.fade_timer / S.FADE_TIME)
|
|
overlay = pygame.Surface(self.screen.get_size())
|
|
overlay.fill((0, 0, 0))
|
|
overlay.set_alpha(int(255 * (1 - p)))
|
|
self.screen.blit(overlay, (0, 0))
|
|
|
|
pygame.display.flip()
|
|
|
|
@staticmethod
|
|
def _draw_battery(surf, rect, fill_frac, col):
|
|
"""Draw a battery (frame + fill + nub) into an arbitrary rect, so the
|
|
same widget serves the HUD and the blown-up charging animation."""
|
|
r = max(2, rect.h // 6)
|
|
inset = max(2, rect.h // 10)
|
|
pygame.draw.rect(surf, (60, 60, 72), rect, border_radius=r)
|
|
pygame.draw.rect(surf, (28, 30, 40),
|
|
rect.inflate(-inset, -inset), border_radius=r)
|
|
fw = int((rect.w - inset * 2) * max(0.0, min(1.0, fill_frac)))
|
|
if fill_frac > 0:
|
|
fw = max(inset, fw)
|
|
pygame.draw.rect(surf, col, (rect.x + inset, rect.y + inset, fw, rect.h - inset * 2),
|
|
border_radius=r)
|
|
nub_w, nub_h = max(3, rect.h // 4), rect.h // 2
|
|
pygame.draw.rect(surf, (60, 60, 72),
|
|
(rect.right, rect.centery - nub_h // 2, nub_w, nub_h))
|
|
|
|
def _draw_hud(self, hide_battery=False):
|
|
w = self.screen.get_width()
|
|
pygame.draw.rect(self.screen, (18, 20, 30), (0, 0, w, HUD_H))
|
|
|
|
# battery bar. The phone is dying, so the bar *looks* near-empty from the
|
|
# start (scaled by the level's battery_pct); the seconds text below is the
|
|
# real timer. Fill drains proportionally to the time left. Hidden while
|
|
# the charge animation flies the battery to centre stage.
|
|
bar_w, bar_h = 180, 20
|
|
bx, by = 12, (HUD_H - bar_h) // 2
|
|
if not hide_battery:
|
|
time_frac = max(0.0, self.battery / self.level.battery) if self.level.battery else 0.0
|
|
visual = time_frac * (self.level.battery_pct / 100.0)
|
|
col = (240, 170, 60) if time_frac > 0.25 else (240, 80, 80)
|
|
self._draw_battery(self.screen, pygame.Rect(bx, by, bar_w, bar_h), visual, col)
|
|
|
|
secs = max(0.0, self.battery)
|
|
label = self.hud_font.render(f"{secs:4.1f}s", True, S.COLOR_HUD)
|
|
self.screen.blit(label, (bx + bar_w + 16, by - 1))
|
|
|
|
deaths = self.hud_font.render(
|
|
f"deaths {self.level_deaths} / {self.deaths} total", True, S.COLOR_HUD)
|
|
self.screen.blit(deaths, (w - deaths.get_width() - 12, by - 1))
|
|
|
|
name = self.hud_font.render(self.level.name, True, S.COLOR_HUD)
|
|
self.screen.blit(name, (w - deaths.get_width() - name.get_width() - 32, by - 1))
|
|
|
|
def _hero_battery(self):
|
|
"""The enlarged battery's resting rect — centre of screen, ~60% wide.
|
|
Shared by the charge animation (its target) and the win splash (so it
|
|
stays put, full, while the splash is up)."""
|
|
W, H = self.screen.get_size()
|
|
bar_w, bar_h = 180, 20
|
|
scale = min(W * 0.6, 520) / bar_w
|
|
rect = pygame.Rect(0, 0, round(bar_w * scale), round(bar_h * scale))
|
|
rect.center = (W // 2, H // 2)
|
|
return rect
|
|
|
|
def _draw_charge_anim(self):
|
|
"""The charging beat: dim the frozen scene, then fly the battery out of
|
|
the HUD toward the centre and grow it (brought toward the viewer) while
|
|
it fills to 100%."""
|
|
W, H = self.screen.get_size()
|
|
t = min(1.0, self.charge_timer / S.CHARGE_TIME)
|
|
move_p = 1 - (1 - min(1.0, t / 0.4)) ** 3 # ease-out; centred by 40%
|
|
fill_p = max(0.0, min(1.0, (t - 0.2) / 0.6)) # fill from 20%..80%
|
|
fill = self.charge_from + (1.0 - self.charge_from) * fill_p
|
|
|
|
dim = pygame.Surface((W, H), pygame.SRCALPHA)
|
|
dim.fill((6, 8, 14, int(195 * move_p)))
|
|
self.screen.blit(dim, (0, 0))
|
|
|
|
bar_w, bar_h = 180, 20
|
|
home = pygame.Vector2(12 + bar_w / 2, (HUD_H - bar_h) // 2 + bar_h / 2)
|
|
target = self._hero_battery()
|
|
pos = home.lerp(pygame.Vector2(target.center), move_p)
|
|
rect = pygame.Rect(0, 0,
|
|
round(bar_w + (target.w - bar_w) * move_p),
|
|
round(bar_h + (target.h - bar_h) * move_p))
|
|
rect.center = (round(pos.x), round(pos.y))
|
|
self._draw_battery(self.screen, rect, fill, (90, 220, 120))
|
|
|
|
pct = int(round(fill * 100))
|
|
num = self.big_font.render(f"{pct}%", True, (150, 245, 180))
|
|
self.screen.blit(num, num.get_rect(center=(W // 2, rect.top - 36)))
|
|
|
|
def _draw_win_splash(self, title, subtitle):
|
|
"""Level-complete overlay: keep the charged hero battery centred, with
|
|
the message above and below it."""
|
|
W, H = self.screen.get_size()
|
|
dim = pygame.Surface((W, H), pygame.SRCALPHA)
|
|
dim.fill((10, 12, 20, 205))
|
|
self.screen.blit(dim, (0, 0))
|
|
rect = self._hero_battery()
|
|
self._draw_battery(self.screen, rect, 1.0, (90, 220, 120))
|
|
t = self.big_font.render(title, True, (120, 240, 160))
|
|
self.screen.blit(t, t.get_rect(center=(W // 2, rect.top - 40)))
|
|
s = self.hud_font.render(subtitle, True, S.COLOR_HUD)
|
|
self.screen.blit(s, s.get_rect(center=(W // 2, rect.bottom + 34)))
|
|
|
|
def discover_levels(levels_dir):
|
|
paths = sorted(glob.glob(os.path.join(levels_dir, "*.yaml")) +
|
|
glob.glob(os.path.join(levels_dir, "*.yml")))
|
|
return paths
|