crimsonland 0.1.0.dev1__py3-none-any.whl

crimson/views/animations.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyray as rl
+
+from ..creatures.anim import creature_anim_advance_phase, creature_anim_select_frame
+from ..creatures.spawn import CreatureFlags, CreatureTypeId, SPAWN_TEMPLATES, SpawnTemplate, resolve_tint
+from .registry import register_view
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.view import View, ViewContext
+
+UI_TEXT_SCALE = 1.0
+UI_TEXT_COLOR = rl.Color(220, 220, 220, 255)
+UI_HINT_COLOR = rl.Color(140, 140, 140, 255)
+UI_ERROR_COLOR = rl.Color(240, 80, 80, 255)
+
+
+@dataclass(frozen=True, slots=True)
+class TypeAnimInfo:
+    base: int
+    anim_rate: float
+    mirror: bool
+
+
+TYPE_ANIM: dict[CreatureTypeId, TypeAnimInfo] = {
+    CreatureTypeId.ZOMBIE: TypeAnimInfo(base=0x20, anim_rate=1.2, mirror=False),
+    CreatureTypeId.LIZARD: TypeAnimInfo(base=0x10, anim_rate=1.6, mirror=True),
+    CreatureTypeId.ALIEN: TypeAnimInfo(base=0x20, anim_rate=1.35, mirror=False),
+    CreatureTypeId.SPIDER_SP1: TypeAnimInfo(base=0x10, anim_rate=1.5, mirror=True),
+    CreatureTypeId.SPIDER_SP2: TypeAnimInfo(base=0x10, anim_rate=1.5, mirror=True),
+    CreatureTypeId.TROOPER: TypeAnimInfo(base=0x00, anim_rate=1.0, mirror=False),
+}
+
+
+class CreatureAnimationView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._textures: dict[str, rl.Texture] = {}
+        self._small: SmallFontData | None = None
+        self._templates: list[SpawnTemplate] = [
+            entry for entry in SPAWN_TEMPLATES if entry.type_id is not None and entry.creature is not None
+        ]
+        self._index = 0
+        self._phase = 0.0
+        self._move_speed = 2.0
+        self._size = 50.0
+        self._local_scale = 1.0
+        self._paused = False
+        self._last_dt = 0.0
+        self._last_step = 0.0
+        self._apply_template_defaults()
+
+    def _ui_line_height(self, scale: float = UI_TEXT_SCALE) -> int:
+        if self._small is not None:
+            return int(self._small.cell_size * scale)
+        return int(20 * scale)
+
+    def _draw_ui_text(
+        self,
+        text: str,
+        x: float,
+        y: float,
+        color: rl.Color,
+        scale: float = UI_TEXT_SCALE,
+    ) -> None:
+        if self._small is not None:
+            draw_small_text(self._small, text, x, y, scale, color)
+        else:
+            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
+
+    def open(self) -> None:
+        self._missing_assets.clear()
+        self._textures.clear()
+        self._small = load_small_font(self._assets_root, self._missing_assets)
+        for entry in self._templates:
+            if entry.creature is None:
+                continue
+            if entry.creature in self._textures:
+                continue
+            path = self._assets_root / "crimson" / "game" / f"{entry.creature}.png"
+            if not path.is_file():
+                self._missing_assets.append(str(path))
+                continue
+            self._textures[entry.creature] = rl.load_texture(str(path))
+        if self._missing_assets:
+            raise FileNotFoundError(f"Missing creature textures: {', '.join(self._missing_assets)}")
+
+    def close(self) -> None:
+        for texture in self._textures.values():
+            rl.unload_texture(texture)
+        self._textures.clear()
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+
+    def update(self, dt: float) -> None:
+        self._last_dt = dt
+        if self._paused:
+            self._last_step = 0.0
+            return
+        template = self._current_template()
+        if template is None or template.type_id is None:
+            return
+        info = TYPE_ANIM.get(template.type_id)
+        if info is None:
+            return
+        flags = template.flags or CreatureFlags(0)
+        self._phase, self._last_step = creature_anim_advance_phase(
+            self._phase,
+            anim_rate=info.anim_rate,
+            move_speed=self._move_speed,
+            dt=dt,
+            size=self._size,
+            local_scale=self._local_scale,
+            flags=flags,
+            ai_mode=0,
+        )
+
+    def _current_template(self) -> SpawnTemplate | None:
+        if not self._templates:
+            return None
+        return self._templates[self._index]
+
+    def _advance_template(self, delta: int) -> None:
+        if not self._templates:
+            return
+        self._index = (self._index + delta) % len(self._templates)
+        self._phase = 0.0
+        self._apply_template_defaults()
+
+    def _apply_template_defaults(self) -> None:
+        template = self._current_template()
+        if template is None:
+            return
+        self._move_speed = template.move_speed if template.move_speed is not None else 2.0
+        self._size = template.size if template.size is not None else 50.0
+
+    def _handle_input(self) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_RIGHT):
+            self._advance_template(1)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_LEFT):
+            self._advance_template(-1)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_UP):
+            self._move_speed = min(10.0, self._move_speed + 0.1)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_DOWN):
+            self._move_speed = max(0.0, self._move_speed - 0.1)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_PAGE_UP):
+            self._size = min(200.0, self._size + 1.0)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_PAGE_DOWN):
+            self._size = max(1.0, self._size - 1.0)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_RIGHT_BRACKET):
+            self._local_scale = min(1.0, self._local_scale + 0.05)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_LEFT_BRACKET):
+            self._local_scale = max(0.0, self._local_scale - 0.05)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_SPACE):
+            self._paused = not self._paused
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_R):
+            self._phase = 0.0
+
+    def draw(self) -> None:
+        rl.clear_background(rl.Color(12, 12, 14, 255))
+        if self._missing_assets:
+            message = "Missing assets: " + ", ".join(self._missing_assets)
+            self._draw_ui_text(message, 24, 24, UI_ERROR_COLOR)
+            return
+        if not self._templates:
+            self._draw_ui_text("No spawn templates loaded.", 24, 24, UI_TEXT_COLOR)
+            return
+
+        self._handle_input()
+        template = self._current_template()
+        if template is None or template.type_id is None or template.creature is None:
+            self._draw_ui_text("Invalid template.", 24, 24, UI_TEXT_COLOR)
+            return
+        texture = self._textures.get(template.creature)
+        if texture is None:
+            self._draw_ui_text("Missing texture for creature.", 24, 24, UI_TEXT_COLOR)
+            return
+        info = TYPE_ANIM.get(template.type_id)
+        if info is None:
+            self._draw_ui_text("Missing anim info.", 24, 24, UI_TEXT_COLOR)
+            return
+
+        frame, mirror_applied, mode = creature_anim_select_frame(
+            self._phase,
+            base_frame=info.base,
+            mirror_long=info.mirror,
+            flags=template.flags or CreatureFlags(0),
+        )
+        grid = 8
+        cell = texture.width / grid
+        row = frame // grid
+        col = frame % grid
+
+        margin = 24
+        title = f"{template.creature} (spawn 0x{template.spawn_id:02x})"
+        self._draw_ui_text(title, margin, margin, UI_TEXT_COLOR)
+        hint = (
+            "Left/Right: spawn template  Up/Down: move_speed  PgUp/PgDn: size  "
+            "[/]: local scale  Space: pause  R: reset"
+        )
+        self._draw_ui_text(hint, margin, margin + self._ui_line_height() + 6, UI_HINT_COLOR)
+
+        sheet_scale = min(
+            1.0,
+            (rl.get_screen_width() * 0.55 - margin * 2) / texture.width,
+            (rl.get_screen_height() - margin * 2 - 60) / texture.height,
+        )
+        sheet_x = margin
+        sheet_y = margin + 60
+        sheet_w = texture.width * sheet_scale
+        sheet_h = texture.height * sheet_scale
+
+        src = rl.Rectangle(0.0, 0.0, float(texture.width), float(texture.height))
+        dst = rl.Rectangle(float(sheet_x), float(sheet_y), float(sheet_w), float(sheet_h))
+        rl.draw_texture_pro(texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+        cell_w = sheet_w / grid
+        cell_h = sheet_h / grid
+        highlight = rl.Rectangle(
+            float(sheet_x + col * cell_w),
+            float(sheet_y + row * cell_h),
+            float(cell_w),
+            float(cell_h),
+        )
+        rl.draw_rectangle_lines_ex(highlight, 2, rl.Color(240, 200, 80, 255))
+
+        preview_scale = 3.0
+        preview_size = cell * preview_scale
+        preview_x = sheet_x + sheet_w + 40
+        preview_y = sheet_y + 40
+        src_frame = rl.Rectangle(
+            float(col * cell),
+            float(row * cell),
+            float(cell),
+            float(cell),
+        )
+        dst_frame = rl.Rectangle(float(preview_x), float(preview_y), float(preview_size), float(preview_size))
+        tint_r, tint_g, tint_b, tint_a = resolve_tint(template.tint)
+        tint = rl.Color(
+            max(0, min(255, int(tint_r * 255))),
+            max(0, min(255, int(tint_g * 255))),
+            max(0, min(255, int(tint_b * 255))),
+            max(0, min(255, int(tint_a * 255))),
+        )
+        rl.draw_texture_pro(texture, src_frame, dst_frame, rl.Vector2(0.0, 0.0), 0.0, tint)
+
+        info_lines = [
+            f"type_id={template.type_id.name}",
+            f"flags={int(template.flags or 0):#x}",
+            f"mode={mode}",
+            f"frame=0x{frame:02x}",
+            f"phase={self._phase:.6f}",
+            f"template.move_speed={template.move_speed!r}",
+            f"template.size={template.size!r}",
+            f"template.tint={template.tint!r}",
+            f"move_speed={self._move_speed:.2f}",
+            f"size={self._size:.1f}",
+            f"local_scale={self._local_scale:.2f}",
+            f"dt={self._last_dt:.4f}s  step={self._last_step:.6f}",
+            f"mirror_applied={'yes' if mirror_applied else 'no'}",
+            f"paused={'yes' if self._paused else 'no'}",
+        ]
+        y = int(preview_y + preview_size + 16)
+        for line in info_lines:
+            self._draw_ui_text(line, preview_x, y, UI_TEXT_COLOR)
+            y += self._ui_line_height() + 4
+
+
+@register_view("animations", "Creature animation preview")
+def build_animation_view(ctx: ViewContext) -> View:
+    return CreatureAnimationView(ctx)

crimson/views/arsenal_debug.py

@@ -0,0 +1,414 @@
+from __future__ import annotations
+
+import math
+import random
+
+import pyray as rl
+
+from grim.audio import AudioState, init_audio_state, shutdown_audio, update_audio
+from grim.config import ensure_crimson_cfg
+from grim.console import ConsoleLog, ConsoleState
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.view import View, ViewContext
+
+from ..creatures.spawn import SpawnId
+from ..game_modes import GameMode
+from ..game_world import GameWorld
+from ..gameplay import PlayerInput, weapon_assign_player
+from ..paths import default_runtime_dir
+from ..projectiles import ProjectileTypeId
+from ..ui.cursor import draw_aim_cursor
+from ..weapon_sfx import resolve_weapon_sfx_ref
+from ..weapons import (
+    WEAPON_BY_ID,
+    WEAPON_TABLE,
+    Weapon,
+    projectile_type_id_from_weapon_id,
+)
+from .registry import register_view
+
+
+WORLD_SIZE = 1024.0
+
+BG = rl.Color(10, 10, 12, 255)
+
+UI_TEXT = rl.Color(235, 235, 235, 255)
+UI_HINT = rl.Color(180, 180, 180, 255)
+UI_ERROR = rl.Color(240, 80, 80, 255)
+
+DEFAULT_SPAWN_IDS = (
+    SpawnId.ZOMBIE_CONST_GREY_42,
+    SpawnId.ZOMBIE_CONST_GREEN_BRUTE_43,
+    SpawnId.LIZARD_CONST_GREY_2F,
+    SpawnId.LIZARD_CONST_YELLOW_BOSS_30,
+    SpawnId.ALIEN_CONST_GREEN_24,
+    SpawnId.ALIEN_CONST_GREY_BRUTE_29,
+    SpawnId.ALIEN_CONST_RED_FAST_2B,
+    SpawnId.SPIDER_SP1_CONST_BLUE_40,
+    SpawnId.SPIDER_SP1_CONST_WHITE_FAST_3E,
+    SpawnId.SPIDER_SP2_RANDOM_35,
+)
+
+SPECIAL_PROJECTILES: dict[int, str] = {
+    9: "particle style 0 (plasma rifle)",
+    13: "secondary type 1 (seeker rockets)",
+    14: "secondary type 2 (plasma shotgun)",
+    16: "particle style 1 (hr flamer)",
+    17: "particle style 2 (mini-rocket swarmers)",
+    18: "secondary type 2 (rocket minigun)",
+    19: "secondary type 4 (pulse gun)",
+    43: "particle style 8 (rainbow gun)",
+}
+
+
+def _clamp(value: float, lo: float, hi: float) -> float:
+    if value < lo:
+        return lo
+    if value > hi:
+        return hi
+    return value
+
+
+def _fmt_float(value: float | None, *, digits: int = 3) -> str:
+    if value is None:
+        return "—"
+    return f"{float(value):.{digits}f}"
+
+
+def _fmt_int(value: int | None) -> str:
+    if value is None:
+        return "—"
+    return f"{int(value)}"
+
+
+def _fmt_hex(value: int | None) -> str:
+    if value is None:
+        return "—"
+    value = int(value)
+    return f"0x{value:02x} ({value})"
+
+
+def _projectile_type_label(type_id: int) -> str:
+    try:
+        name = ProjectileTypeId(int(type_id)).name.lower().replace("_", " ")
+    except ValueError:
+        name = "unknown"
+    return f"{name} (id {type_id})"
+
+
+class ArsenalDebugView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._small: SmallFontData | None = None
+
+        self._world = GameWorld(
+            assets_dir=ctx.assets_dir,
+            world_size=WORLD_SIZE,
+            demo_mode_active=False,
+            difficulty_level=0,
+            hardcore=False,
+        )
+        self._player = self._world.players[0] if self._world.players else None
+        self._aim_texture: rl.Texture | None = None
+        self._audio: AudioState | None = None
+        self._audio_rng: random.Random | None = None
+        self._console: ConsoleState | None = None
+
+        self._weapon_ids = sorted({int(entry.weapon_id) for entry in WEAPON_TABLE})
+        self._weapon_index = 0
+        self._spawn_ids = [int(spawn_id) for spawn_id in DEFAULT_SPAWN_IDS]
+        self._spawn_ring_radius = 280.0
+
+        self.close_requested = False
+        self._paused = False
+        self._screenshot_requested = False
+
+    def _ui_line_height(self, scale: float = 1.0) -> int:
+        if self._small is not None:
+            return int(self._small.cell_size * scale)
+        return int(20 * scale)
+
+    def _draw_ui_text(self, text: str, x: float, y: float, color: rl.Color, scale: float = 1.0) -> None:
+        if self._small is not None:
+            draw_small_text(self._small, text, x, y, scale, color)
+        else:
+            rl.draw_text(text, int(x), int(y), int(20 * scale), color)
+
+    def _selected_weapon_id(self) -> int:
+        if not self._weapon_ids:
+            return 0
+        return int(self._weapon_ids[self._weapon_index % len(self._weapon_ids)])
+
+    def _apply_weapon(self) -> None:
+        if self._player is None:
+            return
+        weapon_assign_player(self._player, self._selected_weapon_id())
+
+    def _reset_scene(self) -> None:
+        self._world.reset(seed=0xBEEF, player_count=1, spawn_x=WORLD_SIZE * 0.5, spawn_y=WORLD_SIZE * 0.5)
+        self._player = self._world.players[0] if self._world.players else None
+        self._apply_weapon()
+        self._reset_creatures()
+        self._world.update_camera(0.0)
+
+    def _reset_creatures(self) -> None:
+        self._world.creatures.reset()
+        self._world.state.projectiles.reset()
+        self._world.state.secondary_projectiles.reset()
+        self._world.state.particles.reset()
+        self._world.state.sprite_effects.reset()
+        self._world.state.effects.reset()
+        self._world.state.bonus_pool.reset()
+        self._world.fx_queue.clear()
+        self._world.fx_queue_rotated.clear()
+
+        player = self._player
+        if player is None:
+            return
+
+        count = max(1, len(self._spawn_ids))
+        base_x = float(player.pos_x)
+        base_y = float(player.pos_y)
+        for idx in range(count):
+            spawn_id = int(self._spawn_ids[idx % len(self._spawn_ids)])
+            angle = float(idx) / float(count) * math.tau
+            x = _clamp(base_x + math.cos(angle) * self._spawn_ring_radius, 48.0, WORLD_SIZE - 48.0)
+            y = _clamp(base_y + math.sin(angle) * self._spawn_ring_radius, 48.0, WORLD_SIZE - 48.0)
+            heading = angle + math.pi
+            self._world.creatures.spawn_template(
+                spawn_id,
+                (x, y),
+                heading,
+                self._world.state.rng,
+                rand=self._world.state.rng.rand,
+            )
+
+    def _handle_debug_input(self) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_ESCAPE):
+            self.close_requested = True
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_SPACE):
+            self._paused = not self._paused
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_LEFT_BRACKET):
+            self._weapon_index = (self._weapon_index - 1) % max(1, len(self._weapon_ids))
+            self._apply_weapon()
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_RIGHT_BRACKET):
+            self._weapon_index = (self._weapon_index + 1) % max(1, len(self._weapon_ids))
+            self._apply_weapon()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_T):
+            self._reset_creatures()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_BACKSPACE):
+            self._reset_scene()
+
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_P):
+            self._screenshot_requested = True
+
+    def _build_input(self) -> PlayerInput:
+        move_x = 0.0
+        move_y = 0.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_A):
+            move_x -= 1.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_D):
+            move_x += 1.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_W):
+            move_y -= 1.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_S):
+            move_y += 1.0
+
+        mouse = rl.get_mouse_position()
+        aim_x, aim_y = self._world.screen_to_world(float(mouse.x), float(mouse.y))
+
+        fire_down = rl.is_mouse_button_down(rl.MouseButton.MOUSE_BUTTON_LEFT)
+        fire_pressed = rl.is_mouse_button_pressed(rl.MouseButton.MOUSE_BUTTON_LEFT)
+        reload_pressed = rl.is_key_pressed(rl.KeyboardKey.KEY_R)
+
+        return PlayerInput(
+            move_x=move_x,
+            move_y=move_y,
+            aim_x=float(aim_x),
+            aim_y=float(aim_y),
+            fire_down=fire_down,
+            fire_pressed=fire_pressed,
+            reload_pressed=reload_pressed,
+        )
+
+    def _weapon_projectile_desc(self, weapon_id: int) -> str:
+        special = SPECIAL_PROJECTILES.get(int(weapon_id))
+        if special is not None:
+            return special
+        type_id = projectile_type_id_from_weapon_id(int(weapon_id))
+        if type_id is None:
+            return "particle/secondary"
+        return _projectile_type_label(type_id)
+
+    def _weapon_debug_lines(self, weapon: Weapon | None) -> list[str]:
+        player = self._player
+        if player is None:
+            return ["Arsenal debug: missing player"]
+
+        weapon_id = int(player.weapon_id)
+        name = weapon.name if weapon is not None and weapon.name else f"weapon_{weapon_id}"
+        index_label = f"{self._weapon_index + 1}/{max(1, len(self._weapon_ids))}"
+
+        lines = [
+            "Arsenal",
+            f"{name} (id {weapon_id})  [{index_label}]",
+            f"projectile: {self._weapon_projectile_desc(weapon_id)}",
+            f"ammo {player.ammo:.1f}/{player.clip_size:.1f}  reload {player.reload_timer:.2f}/{player.reload_timer_max:.2f}",
+            f"shot_cd {player.shot_cooldown:.3f}  spread {player.spread_heat:.3f}  muzzle {player.muzzle_flash_alpha:.2f}",
+        ]
+
+        if weapon is None:
+            return lines
+
+        fire_sfx = resolve_weapon_sfx_ref(weapon.fire_sound)
+        reload_sfx = resolve_weapon_sfx_ref(weapon.reload_sound)
+        lines.extend(
+            [
+                f"clip { _fmt_int(weapon.clip_size) }  reload { _fmt_float(weapon.reload_time) }  cooldown { _fmt_float(weapon.shot_cooldown) }",
+                f"pellets { _fmt_int(weapon.pellet_count) }  spread_inc { _fmt_float(weapon.spread_heat_inc) }  dmg_scale { _fmt_float(weapon.damage_scale) }  meta { _fmt_int(weapon.projectile_meta) }",
+                f"ammo_class { _fmt_int(weapon.ammo_class) }  flags { _fmt_hex(weapon.flags) }  icon { _fmt_int(weapon.icon_index) }",
+                f"sfx fire {fire_sfx or '—'}  reload {reload_sfx or '—'}",
+            ]
+        )
+        return lines
+
+    def open(self) -> None:
+        self._missing_assets.clear()
+        try:
+            self._small = load_small_font(self._assets_root, self._missing_assets)
+        except Exception:
+            self._small = None
+
+        runtime_dir = default_runtime_dir()
+        if runtime_dir.is_dir():
+            try:
+                self._world.config = ensure_crimson_cfg(runtime_dir)
+            except Exception:
+                self._world.config = None
+        else:
+            self._world.config = None
+
+        if self._world.config is not None:
+            try:
+                self._console = ConsoleState(
+                    base_dir=runtime_dir,
+                    log=ConsoleLog(base_dir=runtime_dir),
+                    assets_dir=self._assets_root,
+                )
+                self._audio = init_audio_state(self._world.config, self._assets_root, self._console)
+                self._audio_rng = random.Random(0xBEEF)
+                self._world.audio = self._audio
+                self._world.audio_rng = self._audio_rng
+            except Exception:
+                self._audio = None
+                self._audio_rng = None
+                self._console = None
+                self._world.audio = None
+                self._world.audio_rng = None
+
+        self._world.open()
+        self._aim_texture = self._world._load_texture(
+            "ui_aim",
+            cache_path="ui/ui_aim.jaz",
+            file_path="ui/ui_aim.png",
+        )
+        self._reset_scene()
+        rl.hide_cursor()
+
+    def close(self) -> None:
+        rl.show_cursor()
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+        if self._audio is not None:
+            shutdown_audio(self._audio)
+            self._audio = None
+            self._audio_rng = None
+            self._console = None
+        self._world.audio = None
+        self._world.audio_rng = None
+        self._world.close()
+        self._aim_texture = None
+
+    def consume_screenshot_request(self) -> bool:
+        requested = self._screenshot_requested
+        self._screenshot_requested = False
+        return requested
+
+    def update(self, dt: float) -> None:
+        self._handle_debug_input()
+
+        if self._paused:
+            dt = 0.0
+
+        player = self._player
+        if player is None:
+            return
+
+        input_state = self._build_input()
+        self._world.update(dt, inputs=[input_state], game_mode=int(GameMode.SURVIVAL))
+
+        if self._audio is not None:
+            update_audio(self._audio, dt)
+
+    def draw(self) -> None:
+        rl.clear_background(BG)
+
+        if self._world.ground is not None:
+            self._world._sync_ground_settings()
+            self._world.ground.process_pending()
+
+        self._world.draw(draw_aim_indicators=True)
+
+        warn_x = 24.0
+        warn_y = 24.0
+        warn_line = float(self._ui_line_height())
+        if self._missing_assets:
+            self._draw_ui_text("Missing assets (ui): " + ", ".join(self._missing_assets), warn_x, warn_y, UI_ERROR)
+            warn_y += warn_line
+        if self._world.missing_assets:
+            self._draw_ui_text(
+                "Missing assets (world): " + ", ".join(self._world.missing_assets),
+                warn_x,
+                warn_y,
+                UI_ERROR,
+            )
+            warn_y += warn_line
+
+        x = 16.0
+        y = 12.0
+        line = float(self._ui_line_height())
+
+        weapon = WEAPON_BY_ID.get(int(self._player.weapon_id)) if self._player is not None else None
+        for text in self._weapon_debug_lines(weapon):
+            self._draw_ui_text(text, x, y, UI_TEXT)
+            y += line
+
+        if self._player is not None:
+            alive = sum(1 for c in self._world.creatures.entries if c.active and c.hp > 0.0)
+            total = sum(1 for c in self._world.creatures.entries if c.active)
+            self._draw_ui_text(f"creatures alive {alive}/{total}", x, y, UI_TEXT)
+            y += line
+
+        y += 6.0
+        self._draw_ui_text(
+            "WASD move  LMB fire  R reload  [/] cycle weapons  Space pause  T respawn  Backspace reset  Esc quit",
+            x,
+            y,
+            UI_HINT,
+        )
+        y += line
+        self._draw_ui_text("P screenshot", x, y, UI_HINT)
+
+        mouse = rl.get_mouse_position()
+        draw_aim_cursor(self._world.particles_texture, self._aim_texture, x=float(mouse.x), y=float(mouse.y))
+
+
+@register_view("arsenal", "Arsenal")
+def build_arsenal_debug_view(ctx: ViewContext) -> View:
+    return ArsenalDebugView(ctx)