crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/views/audio_bootstrap.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import random
+
+from grim.audio import AudioState, init_audio_state
+from grim.config import CrimsonConfig, ensure_crimson_cfg
+from grim.console import ConsoleLog, ConsoleState
+
+from ..assets_fetch import download_missing_paqs
+from ..paths import default_runtime_dir
+
+
+@dataclass(slots=True)
+class ViewAudioBootstrap:
+    config: CrimsonConfig | None
+    console: ConsoleState | None
+    audio: AudioState | None
+    audio_rng: random.Random | None
+
+
+def init_view_audio(assets_dir: Path, *, seed: int = 0xBEEF) -> ViewAudioBootstrap:
+    runtime_dir = default_runtime_dir()
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        config = ensure_crimson_cfg(runtime_dir)
+    except Exception:
+        return ViewAudioBootstrap(None, None, None, None)
+
+    console = ConsoleState(
+        base_dir=runtime_dir,
+        log=ConsoleLog(base_dir=runtime_dir),
+        assets_dir=assets_dir,
+    )
+    try:
+        download_missing_paqs(assets_dir, console)
+    except Exception as exc:
+        console.log.log(f"assets: download failed: {exc}")
+        console.log.flush()
+
+    try:
+        audio = init_audio_state(config, assets_dir, console)
+    except Exception:
+        return ViewAudioBootstrap(config, console, None, None)
+
+    return ViewAudioBootstrap(config, console, audio, random.Random(seed))

crimson/views/bonuses.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyray as rl
+
+from ..bonuses import BONUS_TABLE, BonusMeta
+from ..weapons import WEAPON_TABLE
+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)
+UI_HOVER_COLOR = rl.Color(240, 200, 80, 255)
+
+
+@dataclass(frozen=True, slots=True)
+class BonusIconGroup:
+    icon_id: int
+    bonuses: tuple[BonusMeta, ...]
+
+
+def _build_icon_groups() -> dict[int, BonusIconGroup]:
+    grouped: dict[int, list[BonusMeta]] = {}
+    for entry in BONUS_TABLE:
+        if entry.icon_id is None or entry.icon_id < 0:
+            continue
+        grouped.setdefault(entry.icon_id, []).append(entry)
+    return {icon_id: BonusIconGroup(icon_id=icon_id, bonuses=tuple(entries)) for icon_id, entries in grouped.items()}
+
+
+BONUS_ICON_GROUPS = _build_icon_groups()
+WEAPON_BONUS = next(
+    (entry for entry in BONUS_TABLE if entry.icon_id is not None and entry.icon_id < 0),
+    None,
+)
+
+
+class BonusIconView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._texture: rl.Texture | None = None
+        self._small: SmallFontData | None = None
+
+    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._small = load_small_font(self._assets_root, self._missing_assets)
+        path = self._assets_root / "crimson" / "game" / "bonuses.png"
+        if not path.is_file():
+            self._missing_assets.append("game/bonuses.png")
+            raise FileNotFoundError(f"Missing asset: {path}")
+        self._texture = rl.load_texture(str(path))
+
+    def close(self) -> None:
+        if self._texture is not None:
+            rl.unload_texture(self._texture)
+            self._texture = None
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+
+    def update(self, dt: float) -> None:
+        del dt
+
+    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 self._texture is None:
+            self._draw_ui_text("No bonuses texture loaded.", 24, 24, UI_TEXT_COLOR)
+            return
+
+        margin = 24
+        panel_gap = 32
+        panel_width = min(420, int(rl.get_screen_width() * 0.4))
+        available_width = rl.get_screen_width() - margin * 2 - panel_gap - panel_width
+        available_height = rl.get_screen_height() - margin * 2 - 60
+        scale = min(
+            3.0,
+            available_width / self._texture.width,
+            available_height / self._texture.height,
+        )
+        draw_w = self._texture.width * scale
+        draw_h = self._texture.height * scale
+        x = margin
+        y = margin + 60
+
+        src = rl.Rectangle(0.0, 0.0, float(self._texture.width), float(self._texture.height))
+        dst = rl.Rectangle(float(x), float(y), float(draw_w), float(draw_h))
+        rl.draw_texture_pro(self._texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+        grid = 4
+        cell_w = draw_w / grid
+        cell_h = draw_h / grid
+        for i in range(1, grid):
+            rl.draw_line(
+                int(x + i * cell_w),
+                int(y),
+                int(x + i * cell_w),
+                int(y + draw_h),
+                rl.Color(60, 60, 70, 255),
+            )
+            rl.draw_line(
+                int(x),
+                int(y + i * cell_h),
+                int(x + draw_w),
+                int(y + i * cell_h),
+                rl.Color(60, 60, 70, 255),
+            )
+
+        hovered_index = None
+        mouse = rl.get_mouse_position()
+        if x <= mouse.x <= x + draw_w and y <= mouse.y <= y + draw_h:
+            col = int((mouse.x - x) // cell_w)
+            row = int((mouse.y - y) // cell_h)
+            if 0 <= col < grid and 0 <= row < grid:
+                hovered_index = row * grid + col
+                hl = rl.Rectangle(
+                    float(x + col * cell_w),
+                    float(y + row * cell_h),
+                    float(cell_w),
+                    float(cell_h),
+                )
+                rl.draw_rectangle_lines_ex(hl, 3, UI_HOVER_COLOR)
+
+        info_x = x + draw_w + panel_gap
+        info_y = margin
+        self._draw_ui_text("bonuses.png (grid 4x4)", info_x, info_y, UI_TEXT_COLOR)
+        info_y += self._ui_line_height() + 12
+
+        if hovered_index is not None:
+            group = BONUS_ICON_GROUPS.get(hovered_index)
+            self._draw_ui_text(f"icon_id {hovered_index}", info_x, info_y, UI_TEXT_COLOR)
+            info_y += self._ui_line_height() + 6
+            if group is None:
+                self._draw_ui_text("no bonus mapping", info_x, info_y, UI_HINT_COLOR)
+                info_y += self._ui_line_height() + 6
+            else:
+                for entry in group.bonuses:
+                    bonus_id = int(entry.bonus_id)
+                    amount = entry.default_amount
+                    amount_label = f" default={amount}" if amount is not None else ""
+                    self._draw_ui_text(
+                        f"id {bonus_id:02d} {entry.name}{amount_label}",
+                        info_x,
+                        info_y,
+                        UI_TEXT_COLOR,
+                    )
+                    info_y += self._ui_line_height() + 4
+                    if entry.description:
+                        self._draw_ui_text(
+                            entry.description,
+                            info_x,
+                            info_y,
+                            UI_HINT_COLOR,
+                        )
+                        info_y += self._ui_line_height() + 4
+            info_y += 8
+
+        if WEAPON_BONUS is not None:
+            self._draw_ui_text("Weapon bonus icon", info_x, info_y, UI_TEXT_COLOR)
+            info_y += self._ui_line_height() + 4
+            weapon_id = WEAPON_BONUS.default_amount
+            weapon_name = None
+            if weapon_id is not None:
+                for weapon in WEAPON_TABLE:
+                    if weapon.weapon_id == weapon_id:
+                        weapon_name = weapon.name
+                        break
+            name_label = f" ({weapon_name})" if weapon_name else ""
+            weapon_label = f"icon_id = -1 → ui_wicons (default weapon {weapon_id}{name_label})"
+            self._draw_ui_text(weapon_label, info_x, info_y, UI_HINT_COLOR)
+
+
+@register_view("bonuses", "Bonus icon preview")
+def build_bonus_view(ctx: ViewContext) -> View:
+    return BonusIconView(ctx)

crimson/views/camera_debug.py

@@ -0,0 +1,359 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import math
+from pathlib import Path
+import time
+
+import pyray as rl
+
+from grim.assets import resolve_asset_path
+from grim.config import ensure_crimson_cfg
+from grim.terrain_render import GroundRenderer
+from grim.fonts.small import SmallFontData, draw_small_text, load_small_font
+from grim.view import View, ViewContext
+
+from ..paths import default_runtime_dir
+from .registry import register_view
+
+
+WORLD_SIZE = 1024.0
+WINDOW_W = 640
+WINDOW_H = 480
+GRID_STEP = 64.0
+LOG_INTERVAL_S = 0.1
+
+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(slots=True)
+class CameraDebugAssets:
+    base: rl.Texture
+    overlay: rl.Texture | None
+    detail: rl.Texture | None
+
+
+class CameraDebugView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._small: SmallFontData | None = None
+        self._assets: CameraDebugAssets | None = None
+        self._renderer: GroundRenderer | None = None
+        self._config_screen_w = float(WINDOW_W)
+        self._config_screen_h = float(WINDOW_H)
+        self._texture_scale = 1.0
+        self._use_config_screen = False
+        self._player_x = WORLD_SIZE * 0.5
+        self._player_y = WORLD_SIZE * 0.5
+        self._camera_x = -1.0
+        self._camera_y = -1.0
+        self._camera_target_x = -1.0
+        self._camera_target_y = -1.0
+        self._log_timer = 0.0
+        self._log_path: Path | None = None
+        self._log_file = None
+
+    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 _load_runtime_config(self) -> None:
+        runtime_dir = default_runtime_dir()
+        if not runtime_dir.is_dir():
+            return
+        try:
+            cfg = ensure_crimson_cfg(runtime_dir)
+        except Exception:
+            return
+        self._config_screen_w = float(cfg.screen_width)
+        self._config_screen_h = float(cfg.screen_height)
+        self._texture_scale = float(cfg.texture_scale)
+
+    def _camera_screen_size(self) -> tuple[float, float]:
+        if self._use_config_screen:
+            screen_w = float(self._config_screen_w)
+            screen_h = float(self._config_screen_h)
+        else:
+            screen_w = float(rl.get_screen_width())
+            screen_h = float(rl.get_screen_height())
+        if screen_w > WORLD_SIZE:
+            screen_w = WORLD_SIZE
+        if screen_h > WORLD_SIZE:
+            screen_h = WORLD_SIZE
+        return screen_w, screen_h
+
+    def _clamp_camera(self, cam_x: float, cam_y: float, screen_w: float, screen_h: float) -> tuple[float, float]:
+        min_x = screen_w - WORLD_SIZE
+        min_y = screen_h - WORLD_SIZE
+        if cam_x > -1.0:
+            cam_x = -1.0
+        if cam_y > -1.0:
+            cam_y = -1.0
+        if cam_x < min_x:
+            cam_x = min_x
+        if cam_y < min_y:
+            cam_y = min_y
+        return cam_x, cam_y
+
+    def _world_params(self) -> tuple[float, float, float, float, float, float]:
+        out_w = float(rl.get_screen_width())
+        out_h = float(rl.get_screen_height())
+        screen_w, screen_h = self._camera_screen_size()
+        cam_x, cam_y = self._clamp_camera(self._camera_x, self._camera_y, screen_w, screen_h)
+        scale_x = out_w / screen_w if screen_w > 0 else 1.0
+        scale_y = out_h / screen_h if screen_h > 0 else 1.0
+        return cam_x, cam_y, scale_x, scale_y, screen_w, screen_h
+
+    def _write_log(self, payload: dict) -> None:
+        if self._log_file is None:
+            return
+        try:
+            self._log_file.write(json.dumps(payload, sort_keys=True) + "\n")
+            self._log_file.flush()
+        except Exception:
+            self._log_file = None
+
+    def open(self) -> None:
+        rl.set_window_size(WINDOW_W, WINDOW_H)
+        self._missing_assets.clear()
+        self._small = load_small_font(self._assets_root, self._missing_assets)
+        base_path = resolve_asset_path(self._assets_root, "ter/ter_q1_base.png")
+        overlay_path = resolve_asset_path(self._assets_root, "ter/ter_q1_tex1.png")
+        if base_path is None:
+            self._missing_assets.append("ter/ter_q1_base.png")
+        if overlay_path is None:
+            self._missing_assets.append("ter/ter_q1_tex1.png")
+        if self._missing_assets:
+            raise FileNotFoundError("Missing assets: " + ", ".join(self._missing_assets))
+        base = rl.load_texture(str(base_path))
+        overlay = rl.load_texture(str(overlay_path)) if overlay_path is not None else None
+        detail = overlay or base
+        self._assets = CameraDebugAssets(base=base, overlay=overlay, detail=detail)
+
+        self._load_runtime_config()
+        self._renderer = GroundRenderer(
+            texture=base,
+            overlay=overlay,
+            overlay_detail=detail,
+            width=int(WORLD_SIZE),
+            height=int(WORLD_SIZE),
+            texture_scale=self._texture_scale,
+            screen_width=self._config_screen_w if self._use_config_screen else None,
+            screen_height=self._config_screen_h if self._use_config_screen else None,
+        )
+        self._renderer.schedule_generate(seed=0, layers=3)
+
+        log_dir = Path("artifacts") / "debug"
+        try:
+            log_dir.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            log_dir = Path("artifacts")
+        self._log_path = log_dir / "camera_debug.jsonl"
+        try:
+            self._log_file = self._log_path.open("w", encoding="utf-8")
+        except Exception:
+            self._log_file = None
+
+    def close(self) -> None:
+        if self._assets is not None:
+            rl.unload_texture(self._assets.base)
+            if self._assets.overlay is not None:
+                rl.unload_texture(self._assets.overlay)
+            self._assets = None
+        if self._renderer is not None:
+            if self._renderer.render_target is not None:
+                rl.unload_render_texture(self._renderer.render_target)
+            self._renderer = None
+        if self._small is not None:
+            rl.unload_texture(self._small.texture)
+            self._small = None
+        if self._log_file is not None:
+            try:
+                self._log_file.close()
+            except Exception:
+                pass
+            self._log_file = None
+
+    def update(self, dt: float) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_F1):
+            self._use_config_screen = not self._use_config_screen
+        speed = 120.0
+        if rl.is_key_down(rl.KeyboardKey.KEY_LEFT_SHIFT) or rl.is_key_down(rl.KeyboardKey.KEY_RIGHT_SHIFT):
+            speed *= 2.0
+        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
+        if move_x != 0.0 or move_y != 0.0:
+            length = math.hypot(move_x, move_y)
+            if length > 0.0:
+                move_x /= length
+                move_y /= length
+            self._player_x += move_x * speed * dt
+            self._player_y += move_y * speed * dt
+            self._player_x = max(0.0, min(WORLD_SIZE, self._player_x))
+            self._player_y = max(0.0, min(WORLD_SIZE, self._player_y))
+
+        screen_w, screen_h = self._camera_screen_size()
+        desired_x = (screen_w * 0.5) - self._player_x
+        desired_y = (screen_h * 0.5) - self._player_y
+        desired_x, desired_y = self._clamp_camera(desired_x, desired_y, screen_w, screen_h)
+        self._camera_target_x = desired_x
+        self._camera_target_y = desired_y
+
+        t = max(0.0, min(dt * 6.0, 1.0))
+        self._camera_x = self._camera_x + (desired_x - self._camera_x) * t
+        self._camera_y = self._camera_y + (desired_y - self._camera_y) * t
+
+        if self._renderer is not None:
+            self._renderer.texture_scale = self._texture_scale
+            if self._use_config_screen:
+                self._renderer.screen_width = self._config_screen_w
+                self._renderer.screen_height = self._config_screen_h
+            else:
+                self._renderer.screen_width = None
+                self._renderer.screen_height = None
+            self._renderer.process_pending()
+
+        self._log_timer += dt
+        if self._log_timer >= LOG_INTERVAL_S:
+            self._log_timer -= LOG_INTERVAL_S
+            cam_x, cam_y, scale_x, scale_y, screen_w, screen_h = self._world_params()
+            payload = {
+                "ts": time.time(),
+                "dt": dt,
+                "player": {"x": self._player_x, "y": self._player_y},
+                "camera": {"x": cam_x, "y": cam_y},
+                "camera_raw": {"x": self._camera_x, "y": self._camera_y},
+                "camera_target": {"x": self._camera_target_x, "y": self._camera_target_y},
+                "world": {"size": WORLD_SIZE},
+                "screen": {
+                    "window": {"w": rl.get_screen_width(), "h": rl.get_screen_height()},
+                    "camera": {"w": screen_w, "h": screen_h},
+                    "config": {"w": self._config_screen_w, "h": self._config_screen_h},
+                    "use_config": self._use_config_screen,
+                },
+                "texture_scale": self._texture_scale,
+                "scale": {"x": scale_x, "y": scale_y},
+                "uv": {
+                    "u0": -cam_x / WORLD_SIZE,
+                    "v0": -cam_y / WORLD_SIZE,
+                    "u1": (-cam_x + screen_w) / WORLD_SIZE,
+                    "v1": (-cam_y + screen_h) / WORLD_SIZE,
+                },
+            }
+            if self._log_path is not None:
+                payload["log_path"] = str(self._log_path)
+            self._write_log(payload)
+
+    def draw(self) -> None:
+        clear_color = rl.Color(10, 10, 12, 255)
+        rl.clear_background(clear_color)
+
+        if self._renderer is None:
+            self._draw_ui_text("Ground renderer not initialized.", 16, 16, UI_ERROR_COLOR)
+            return
+
+        cam_x, cam_y, scale_x, scale_y, screen_w, screen_h = self._world_params()
+        self._renderer.draw(cam_x, cam_y, screen_w=screen_w, screen_h=screen_h)
+
+        # Grid in world space
+        grid_major = rl.Color(70, 80, 95, 180)
+        grid_minor = rl.Color(40, 50, 65, 140)
+        for i in range(0, int(WORLD_SIZE) + 1, int(GRID_STEP)):
+            color = grid_major if i % 256 == 0 else grid_minor
+            sx = (float(i) + cam_x) * scale_x
+            sy0 = (0.0 + cam_y) * scale_y
+            sy1 = (WORLD_SIZE + cam_y) * scale_y
+            rl.draw_line(int(sx), int(sy0), int(sx), int(sy1), color)
+            sy = (float(i) + cam_y) * scale_y
+            sx0 = (0.0 + cam_x) * scale_x
+            sx1 = (WORLD_SIZE + cam_x) * scale_x
+            rl.draw_line(int(sx0), int(sy), int(sx1), int(sy), color)
+
+        # Player
+        px = (self._player_x + cam_x) * scale_x
+        py = (self._player_y + cam_y) * scale_y
+        rl.draw_circle(int(px), int(py), max(2, int(6 * (scale_x + scale_y) * 0.5)), rl.Color(255, 200, 120, 255))
+
+        # Minimap
+        out_w = float(rl.get_screen_width())
+        map_size = 160.0
+        margin = 12.0
+        map_x = out_w - map_size - margin
+        map_y = margin
+        rl.draw_rectangle(int(map_x), int(map_y), int(map_size), int(map_size), rl.Color(12, 12, 18, 220))
+        rl.draw_rectangle_lines(int(map_x), int(map_y), int(map_size), int(map_size), rl.Color(180, 180, 200, 220))
+
+        map_scale = map_size / WORLD_SIZE
+        view_left = -cam_x
+        view_top = -cam_y
+        view_w = screen_w
+        view_h = screen_h
+        vx = map_x + view_left * map_scale
+        vy = map_y + view_top * map_scale
+        vw = view_w * map_scale
+        vh = view_h * map_scale
+        rl.draw_rectangle_lines(int(vx), int(vy), int(vw), int(vh), rl.Color(120, 200, 255, 220))
+        mx = map_x + self._player_x * map_scale
+        my = map_y + self._player_y * map_scale
+        rl.draw_circle(int(mx), int(my), 3, rl.Color(255, 200, 120, 255))
+
+        # HUD
+        x = 16.0
+        y = 16.0
+        line = self._ui_line_height()
+        mode = "config" if self._use_config_screen else "window"
+        self._draw_ui_text(
+            f"window={int(out_w)}x{int(rl.get_screen_height())}  camera={int(screen_w)}x{int(screen_h)} ({mode})",
+            x,
+            y,
+            UI_TEXT_COLOR,
+        )
+        y += line
+        self._draw_ui_text(
+            f"config={int(self._config_screen_w)}x{int(self._config_screen_h)}  "
+            f"scale={scale_x:.3f},{scale_y:.3f}  tex={self._texture_scale:.2f}",
+            x,
+            y,
+            UI_TEXT_COLOR,
+        )
+        y += line
+        self._draw_ui_text(f"player={self._player_x:.1f},{self._player_y:.1f}", x, y, UI_TEXT_COLOR)
+        y += line
+        self._draw_ui_text(f"camera={cam_x:.1f},{cam_y:.1f}", x, y, UI_TEXT_COLOR)
+        y += line
+        if self._log_path is not None:
+            self._draw_ui_text(f"log: {self._log_path}", x, y, UI_HINT_COLOR, scale=0.9)
+            y += line
+        self._draw_ui_text("F1: toggle camera size (config/window)", x, y, UI_HINT_COLOR)
+
+
+@register_view("camera-debug", "Camera debug")
+def build_camera_debug_view(*, ctx: ViewContext) -> View:
+    return CameraDebugView(ctx)