crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/views/terrain.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyray as rl
+
+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_ERROR_COLOR = rl.Color(240, 80, 80, 255)
+
+
+@dataclass(frozen=True, slots=True)
+class TerrainTexture:
+    terrain_id: int
+    name: str
+    texture: rl.Texture
+
+
+TERRAIN_TEXTURES: list[tuple[int, str, str]] = [
+    (0, "ter_q1_base", "ter/ter_q1_base.png"),
+    (1, "ter_q1_tex1", "ter/ter_q1_tex1.png"),
+    (2, "ter_q2_base", "ter/ter_q2_base.png"),
+    (3, "ter_q2_tex1", "ter/ter_q2_tex1.png"),
+    (4, "ter_q3_base", "ter/ter_q3_base.png"),
+    (5, "ter_q3_tex1", "ter/ter_q3_tex1.png"),
+    (6, "ter_q4_base", "ter/ter_q4_base.png"),
+    (7, "ter_q4_tex1", "ter/ter_q4_tex1.png"),
+    (8, "fb_q1", "ter/fb_q1.png"),
+    (9, "fb_q2", "ter/fb_q2.png"),
+    (10, "fb_q3", "ter/fb_q3.png"),
+    (11, "fb_q4", "ter/fb_q4.png"),
+]
+
+
+class TerrainView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._textures: list[TerrainTexture] = []
+        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._textures.clear()
+        self._small = load_small_font(self._assets_root, self._missing_assets)
+        for terrain_id, name, rel_path in TERRAIN_TEXTURES:
+            path = self._assets_root / "crimson" / rel_path
+            if not path.is_file():
+                self._missing_assets.append(rel_path)
+                continue
+            texture = rl.load_texture(str(path))
+            self._textures.append(TerrainTexture(terrain_id=terrain_id, name=name, texture=texture))
+        if self._missing_assets:
+            raise FileNotFoundError(f"Missing terrain assets: {', '.join(self._missing_assets)}")
+
+    def close(self) -> None:
+        for entry in self._textures:
+            rl.unload_texture(entry.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:
+        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 not self._textures:
+            self._draw_ui_text("No terrain textures loaded.", 24, 24, UI_TEXT_COLOR)
+            return
+
+        cols = 4
+        rows = (len(self._textures) + cols - 1) // cols
+        margin = 24
+        gap_x = 16
+        gap_y = 20
+        label_height = self._ui_line_height()
+
+        cell_w = max(entry.texture.width for entry in self._textures)
+        cell_h = max(entry.texture.height for entry in self._textures)
+        max_width = rl.get_screen_width() - margin * 2 - gap_x * (cols - 1)
+        max_height = rl.get_screen_height() - margin * 2 - gap_y * (rows - 1)
+        max_height -= rows * label_height
+        scale = min(1.0, max_width / (cols * cell_w), max_height / (rows * cell_h))
+
+        for idx, entry in enumerate(self._textures):
+            row = idx // cols
+            col = idx % cols
+            x = margin + col * (cell_w * scale + gap_x)
+            y = margin + row * (cell_h * scale + gap_y + label_height)
+            label = f"{entry.terrain_id:02d} {entry.name}"
+            self._draw_ui_text(label, x, y, UI_TEXT_COLOR)
+            dst = rl.Rectangle(
+                float(x),
+                float(y + label_height),
+                float(entry.texture.width * scale),
+                float(entry.texture.height * scale),
+            )
+            src = rl.Rectangle(0.0, 0.0, float(entry.texture.width), float(entry.texture.height))
+            rl.draw_texture_pro(entry.texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+
+@register_view("terrain", "Terrain textures")
+def build_terrain_view(ctx: ViewContext) -> View:
+    return TerrainView(ctx)

crimson/views/ui.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyray as rl
+
+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 UiTexture:
+    name: str
+    texture: rl.Texture
+
+
+class UiTextureView:
+    def __init__(self, ctx: ViewContext) -> None:
+        self._assets_root = ctx.assets_dir
+        self._missing_assets: list[str] = []
+        self._textures: list[UiTexture] = []
+        self._index = 0
+        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._textures.clear()
+        self._small = load_small_font(self._assets_root, self._missing_assets)
+        ui_dir = self._assets_root / "crimson" / "ui"
+        if not ui_dir.is_dir():
+            self._missing_assets.append("ui/")
+            raise FileNotFoundError(f"Missing UI assets directory: {ui_dir}")
+        for path in sorted(ui_dir.glob("*.png")):
+            texture = rl.load_texture(str(path))
+            self._textures.append(UiTexture(name=path.name, texture=texture))
+
+    def close(self) -> None:
+        for entry in self._textures:
+            rl.unload_texture(entry.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:
+        del dt
+
+    def _advance(self, delta: int) -> None:
+        if not self._textures:
+            return
+        self._index = (self._index + delta) % len(self._textures)
+
+    def _handle_input(self) -> None:
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_RIGHT):
+            self._advance(1)
+        if rl.is_key_pressed(rl.KeyboardKey.KEY_LEFT):
+            self._advance(-1)
+
+    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._textures:
+            self._draw_ui_text("No UI textures loaded.", 24, 24, UI_TEXT_COLOR)
+            return
+
+        self._handle_input()
+        entry = self._textures[self._index]
+
+        margin = 24
+        header_y = margin
+        line_height = self._ui_line_height()
+        title = f"{self._index + 1}/{len(self._textures)} {entry.name}"
+        self._draw_ui_text(title, margin, header_y, UI_TEXT_COLOR)
+        header_y += line_height + 6
+        self._draw_ui_text("Left/Right: texture", margin, header_y, UI_HINT_COLOR)
+
+        available_width = rl.get_screen_width() - margin * 2
+        available_height = rl.get_screen_height() - (header_y + line_height + margin)
+        scale = min(
+            2.0,
+            available_width / entry.texture.width,
+            available_height / entry.texture.height,
+        )
+        draw_w = entry.texture.width * scale
+        draw_h = entry.texture.height * scale
+        x = margin + (available_width - draw_w) / 2
+        y = header_y + line_height + (available_height - draw_h) / 2
+
+        src = rl.Rectangle(0.0, 0.0, float(entry.texture.width), float(entry.texture.height))
+        dst = rl.Rectangle(float(x), float(y), float(draw_w), float(draw_h))
+        rl.draw_texture_pro(entry.texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+
+@register_view("ui", "UI texture preview")
+def build_ui_view(ctx: ViewContext) -> View:
+    return UiTextureView(ctx)

crimson/views/wicons.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pyray as rl
+
+from ..weapons import WEAPON_TABLE, Weapon
+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 WeaponIconGroup:
+    icon_index: int
+    weapons: tuple[Weapon, ...]
+
+
+def _build_icon_groups() -> dict[int, WeaponIconGroup]:
+    grouped: dict[int, list[Weapon]] = {}
+    for entry in WEAPON_TABLE:
+        icon_index = entry.icon_index
+        if icon_index is None or icon_index < 0 or icon_index > 31:
+            continue
+        grouped.setdefault(icon_index, []).append(entry)
+    return {
+        icon_index: WeaponIconGroup(icon_index=icon_index, weapons=tuple(entries))
+        for icon_index, entries in grouped.items()
+    }
+
+
+WEAPON_ICON_GROUPS = _build_icon_groups()
+
+
+class WeaponIconView:
+    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" / "ui" / "ui_wicons.png"
+        if not path.is_file():
+            self._missing_assets.append("ui/ui_wicons.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 weapon icon 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
+
+        cols = 4
+        rows = 8
+        icon_w = self._texture.width / cols
+        icon_h = self._texture.height / rows
+        scale = min(2.5, available_width / (cols * icon_w), available_height / (rows * icon_h))
+
+        x = margin
+        y = margin + 60
+        hovered_index = None
+        mouse = rl.get_mouse_position()
+
+        for idx in range(cols * rows):
+            row = idx // cols
+            col = idx % cols
+            dst_x = x + col * icon_w * scale
+            dst_y = y + row * icon_h * scale
+            dst = rl.Rectangle(float(dst_x), float(dst_y), float(icon_w * scale), float(icon_h * scale))
+            src = rl.Rectangle(float(col * icon_w), float(row * icon_h), float(icon_w), float(icon_h))
+            rl.draw_texture_pro(self._texture, src, dst, rl.Vector2(0.0, 0.0), 0.0, rl.WHITE)
+
+            if dst_x <= mouse.x <= dst_x + dst.width and dst_y <= mouse.y <= dst_y + dst.height:
+                hovered_index = idx
+                rl.draw_rectangle_lines_ex(dst, 3, UI_HOVER_COLOR)
+
+            self._draw_ui_text(
+                f"{idx:02d}",
+                dst_x + 4,
+                dst_y + 4,
+                UI_HINT_COLOR,
+                scale=0.75,
+            )
+
+        info_x = x + cols * icon_w * scale + panel_gap
+        info_y = margin
+        self._draw_ui_text(
+            "ui_wicons.png (8x8 grid, 2x1 subrects)",
+            info_x,
+            info_y,
+            UI_TEXT_COLOR,
+        )
+        info_y += self._ui_line_height() + 12
+
+        if hovered_index is not None:
+            frame = hovered_index * 2
+            self._draw_ui_text(
+                f"icon_index {hovered_index}  frame {frame}",
+                info_x,
+                info_y,
+                UI_TEXT_COLOR,
+            )
+            info_y += self._ui_line_height() + 6
+            group = WEAPON_ICON_GROUPS.get(hovered_index)
+            if group is None:
+                self._draw_ui_text("no weapon mapping", info_x, info_y, UI_HINT_COLOR)
+                info_y += self._ui_line_height() + 6
+            else:
+                for weapon in group.weapons:
+                    name = weapon.name or f"weapon_{weapon.weapon_id}"
+                    self._draw_ui_text(name, info_x, info_y, UI_TEXT_COLOR)
+                    info_y += self._ui_line_height() + 4
+
+
+@register_view("wicons", "Weapon icon preview")
+def build_weapon_icon_view(ctx: ViewContext) -> View:
+    return WeaponIconView(ctx)

crimson/weapon_sfx.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from .weapons import WEAPON_BY_ID
+
+WEAPON_TABLE_BASE_ADDR = 0x4D7A2C
+WEAPON_TABLE_STRIDE_BYTES = 0x7C
+WEAPON_TABLE_FIRE_SFX_OFFSET = 0x58
+WEAPON_TABLE_RELOAD_SFX_OFFSET = 0x60
+
+
+def _parse_dat_ref(value: str) -> int | None:
+    raw = value.strip()
+    if raw.startswith("&"):
+        raw = raw[1:]
+    raw = raw.lstrip("_")
+    if not raw.startswith("DAT_"):
+        return None
+    try:
+        return int(raw.removeprefix("DAT_"), 16)
+    except ValueError:
+        return None
+
+
+def resolve_weapon_sfx_ref(value: str | None, *, max_depth: int = 16) -> str | None:
+    """
+    Resolve weapon-table references like `_DAT_004d93bc` into a concrete sfx key (e.g. `sfx_shotgun_reload`).
+    """
+
+    current = value
+    seen_addrs: set[int] = set()
+
+    for _ in range(max(1, int(max_depth))):
+        if current is None:
+            return None
+        if current.startswith("sfx_"):
+            return current
+
+        addr = _parse_dat_ref(current)
+        if addr is None:
+            return current
+        if addr in seen_addrs:
+            return current
+        seen_addrs.add(addr)
+
+        offset = addr - WEAPON_TABLE_BASE_ADDR
+        if offset < 0:
+            return current
+        entry_index, field_offset = divmod(offset, WEAPON_TABLE_STRIDE_BYTES)
+        weapon_id = entry_index
+        weapon = WEAPON_BY_ID.get(weapon_id)
+        if weapon is None:
+            return current
+
+        if field_offset == WEAPON_TABLE_FIRE_SFX_OFFSET:
+            current = weapon.fire_sound
+            continue
+        if field_offset == WEAPON_TABLE_RELOAD_SFX_OFFSET:
+            current = weapon.reload_sound
+            continue
+
+        return current
+
+    return current