crimsonland 0.1.0.dev5__py3-none-any.whl

grim/fonts/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+__all__ = [
+    "grim_mono",
+    "small",
+]
+

grim/fonts/grim_mono.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import pyray as rl
+
+from grim.assets import PaqTextureCache, find_paq_path, load_paq_entries_from_path
+
+GRIM_MONO_ADVANCE = 16.0
+GRIM_MONO_DRAW_SIZE = 32.0
+GRIM_MONO_LINE_HEIGHT = 28.0
+GRIM_MONO_TEXTURE_FILTER = rl.TEXTURE_FILTER_BILINEAR
+
+
+@dataclass(frozen=True, slots=True)
+class GrimMonoFont:
+    texture: rl.Texture
+    grid: int = 16
+    cell_width: float = 16.0
+    cell_height: float = 16.0
+    advance: float = GRIM_MONO_ADVANCE
+
+
+def load_grim_mono_font(assets_root: Path, missing_assets: list[str]) -> GrimMonoFont:
+    # Prefer crimson.paq (runtime source-of-truth), but fall back to extracted
+    # assets when present for development convenience.
+    paq_path = find_paq_path(assets_root)
+
+    atlas_png = assets_root / "crimson" / "load" / "default_font_courier.png"
+    atlas_tga = assets_root / "crimson" / "load" / "default_font_courier.tga"
+
+    texture: rl.Texture | None = None
+    if paq_path is not None:
+        try:
+            entries = load_paq_entries_from_path(paq_path)
+            cache = PaqTextureCache(entries=entries, textures={})
+            texture_asset = cache.get_or_load("default_font_courier", "load/default_font_courier.tga")
+            texture = texture_asset.texture
+        except Exception:
+            texture = None
+
+    if texture is None:
+        if atlas_png.is_file():
+            texture = rl.load_texture(str(atlas_png))
+        elif atlas_tga.is_file():
+            texture = rl.load_texture(str(atlas_tga))
+        else:
+            missing_assets.append("load/default_font_courier.tga")
+            raise FileNotFoundError(
+                "Missing grim mono font (expected load/default_font_courier.tga in crimson.paq "
+                "or extracted crimson/load/default_font_courier.(png|tga))"
+            )
+
+    rl.set_texture_filter(texture, GRIM_MONO_TEXTURE_FILTER)
+    grid = 16
+    cell_width = texture.width / grid
+    cell_height = texture.height / grid
+    return GrimMonoFont(
+        texture=texture,
+        grid=grid,
+        cell_width=cell_width,
+        cell_height=cell_height,
+        advance=GRIM_MONO_ADVANCE,
+    )
+
+
+def draw_grim_mono_text(font: GrimMonoFont, text: str, x: float, y: float, scale: float, color: rl.Color) -> None:
+    x_pos = x
+    y_pos = y
+    advance = font.advance * scale
+    draw_size = GRIM_MONO_DRAW_SIZE * scale
+    line_height = GRIM_MONO_LINE_HEIGHT * scale
+    origin = rl.Vector2(0.0, 0.0)
+    skip_advance = False
+    for value in text.encode("latin-1", errors="replace"):
+        if value == 0x0A:
+            x_pos = x
+            y_pos += line_height
+            continue
+        if value == 0x0D:
+            continue
+        if value == 0xA7:
+            skip_advance = True
+            continue
+
+        if skip_advance:
+            skip_advance = False
+        else:
+            x_pos += advance
+
+        col = value % font.grid
+        row = value // font.grid
+        src = rl.Rectangle(
+            float(col * font.cell_width),
+            float(row * font.cell_height),
+            float(font.cell_width),
+            float(font.cell_height),
+        )
+        dst = rl.Rectangle(
+            float(x_pos),
+            float(y_pos + 1.0),
+            float(draw_size),
+            float(draw_size),
+        )
+        rl.draw_texture_pro(font.texture, src, dst, origin, 0.0, color)
+
+
+def measure_grim_mono_text_height(font: GrimMonoFont, text: str, scale: float) -> float:
+    line_count = text.count("\n") + 1
+    return GRIM_MONO_LINE_HEIGHT * scale * line_count

grim/fonts/small.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import pyray as rl
+
+from grim.assets import PaqTextureCache, find_paq_path, load_paq_entries_from_path
+
+
+@dataclass(frozen=True, slots=True)
+class SmallFontData:
+    widths: list[int]
+    texture: rl.Texture
+    cell_size: int = 16
+    grid: int = 16
+
+
+SMALL_FONT_UV_BIAS_PX = 0.5
+SMALL_FONT_FILTER = rl.TEXTURE_FILTER_POINT
+SMALL_FONT_RENDER_SCALE = 1.0
+
+
+def load_small_font(assets_root: Path, missing_assets: list[str]) -> SmallFontData:
+    # Prefer crimson.paq (runtime source-of-truth), but fall back to extracted
+    # assets when present for development convenience.
+    paq_path = find_paq_path(assets_root)
+    if paq_path is not None:
+        try:
+            entries = load_paq_entries_from_path(paq_path)
+            widths_data = entries.get("load/smallFnt.dat")
+            if widths_data is not None:
+                cache = PaqTextureCache(entries=entries, textures={})
+                texture_asset = cache.get_or_load("smallWhite", "load/smallWhite.tga")
+                if texture_asset.texture is not None:
+                    rl.set_texture_filter(texture_asset.texture, SMALL_FONT_FILTER)
+                    return SmallFontData(widths=list(widths_data), texture=texture_asset.texture)
+        except Exception:
+            pass
+
+    widths_path = assets_root / "crimson" / "load" / "smallFnt.dat"
+    atlas_png = assets_root / "crimson" / "load" / "smallWhite.png"
+    atlas_tga = assets_root / "crimson" / "load" / "smallWhite.tga"
+    if not widths_path.is_file() or (not atlas_png.is_file() and not atlas_tga.is_file()):
+        missing_assets.append("small font assets")
+        raise FileNotFoundError(f"Missing small font assets: {widths_path} and {atlas_png} or {atlas_tga}")
+    widths = list(widths_path.read_bytes())
+    texture = rl.load_texture(str(atlas_png if atlas_png.is_file() else atlas_tga))
+    rl.set_texture_filter(texture, SMALL_FONT_FILTER)
+    return SmallFontData(widths=widths, texture=texture)
+
+
+def draw_small_text(font: SmallFontData, text: str, x: float, y: float, scale: float, color: rl.Color) -> None:
+    x_pos = x
+    y_pos = y
+    scale_px = scale * SMALL_FONT_RENDER_SCALE
+    line_height = font.cell_size * scale_px
+    snap = abs(scale_px - round(scale_px)) < 0.001
+    if snap:
+        scale_px = float(round(scale_px))
+    origin = rl.Vector2(0.0, 0.0)
+    bias = 0.0 if SMALL_FONT_FILTER == rl.TEXTURE_FILTER_POINT else SMALL_FONT_UV_BIAS_PX
+    for value in text.encode("latin-1", errors="replace"):
+        if value == 0x0A:
+            x_pos = x
+            y_pos += line_height
+            continue
+        if value == 0x0D:
+            continue
+        width = font.widths[value]
+        if width <= 0:
+            continue
+        col = value % font.grid
+        row = value // font.grid
+        src_w = max(float(width) - bias, 0.5)
+        src_h = max(float(font.cell_size) - bias, 0.5)
+        src = rl.Rectangle(
+            float(col * font.cell_size) + bias,
+            float(row * font.cell_size) + bias,
+            src_w,
+            src_h,
+        )
+        dst_x = float(round(x_pos)) if snap else float(x_pos)
+        dst_y = float(round(y_pos)) if snap else float(y_pos)
+        dst_w = float(round(width * scale_px)) if snap else float(width * scale_px)
+        dst_h = float(round(font.cell_size * scale_px)) if snap else float(font.cell_size * scale_px)
+        dst = rl.Rectangle(
+            dst_x,
+            dst_y,
+            dst_w,
+            dst_h,
+        )
+        rl.draw_texture_pro(font.texture, src, dst, origin, 0.0, color)
+        x_pos += width * scale_px
+
+
+def measure_small_text_height(font: SmallFontData, text: str, scale: float) -> float:
+    line_count = text.count("\n") + 1
+    scale_px = scale * SMALL_FONT_RENDER_SCALE
+    return font.cell_size * scale_px * line_count
+
+
+def measure_small_text_width(font: SmallFontData, text: str, scale: float) -> float:
+    """Return the maximum line width for `text` when rendered with `draw_small_text`."""
+    scale_px = scale * SMALL_FONT_RENDER_SCALE
+    x = 0.0
+    best = 0.0
+    for value in text.encode("latin-1", errors="replace"):
+        if value == 0x0A:
+            best = max(best, x)
+            x = 0.0
+            continue
+        if value == 0x0D:
+            continue
+        width = font.widths[value]
+        if width <= 0:
+            continue
+        x += float(width) * scale_px
+    best = max(best, x)
+    return best

grim/input.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import pyray as rl
+
+
+@dataclass(slots=True)
+class ActionMap:
+    bindings: dict[str, tuple[int, ...]] = field(default_factory=dict)
+
+    def bind(self, action: str, *keys: int) -> None:
+        if not keys:
+            raise ValueError("bind requires at least one key")
+        self.bindings[action] = tuple(int(key) for key in keys)
+
+    def is_down(self, action: str) -> bool:
+        keys = self.bindings.get(action, ())
+        return any(rl.is_key_down(key) for key in keys)
+
+    def was_pressed(self, action: str) -> bool:
+        keys = self.bindings.get(action, ())
+        return any(rl.is_key_pressed(key) for key in keys)
+
+
+def is_key_down(key: int) -> bool:
+    return rl.is_key_down(key)
+
+
+def was_key_pressed(key: int) -> bool:
+    return rl.is_key_pressed(key)
+
+
+def is_mouse_button_down(button: int) -> bool:
+    return rl.is_mouse_button_down(button)
+
+
+def was_mouse_button_pressed(button: int) -> bool:
+    return rl.is_mouse_button_pressed(button)
+
+
+def mouse_position() -> tuple[int, int]:
+    pos = rl.get_mouse_position()
+    return int(pos.x), int(pos.y)

grim/jaz.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+"""
+JAZ texture format (Crimsonland).
+
+File layout:
+  - u8  method: compression method (1 = zlib)
+  - u32 comp_size: compressed payload size (bytes)
+  - u32 raw_size: uncompressed payload size (bytes)
+  - zlib stream (length = comp_size)
+
+Decompressed payload:
+  - u32 jpeg_len
+  - jpeg bytes (length = jpeg_len)
+  - alpha_rle: (count, value) byte pairs for alpha channel
+
+Notes from assets:
+  - alpha runs expand to width*height for most files; one file is short by 1 pixel.
+    We pad any remaining pixels with 0 (transparent).
+"""
+
+import io
+import zlib
+from pathlib import Path
+
+from PIL import Image
+from construct import Bytes, Int8ul, Int32ul, Struct, this
+
+
+JAZ_HEADER = Struct(
+    "method" / Int8ul,
+    "comp_size" / Int32ul,
+    "raw_size" / Int32ul,
+)
+
+JAZ_FILE = Struct(
+    "header" / JAZ_HEADER,
+    "compressed" / Bytes(this.header.comp_size),
+)
+
+
+def jaz_payload(raw_size: int) -> Struct:
+    return Struct(
+        "jpeg_len" / Int32ul,
+        "jpeg" / Bytes(this.jpeg_len),
+        "alpha_rle" / Bytes(raw_size - 4 - this.jpeg_len),
+    )
+
+
+class JazImage:
+    def __init__(self, width: int, height: int, jpeg: bytes, alpha: bytes) -> None:
+        self.width = width
+        self.height = height
+        self.jpeg = jpeg
+        self.alpha = alpha
+
+    def rgb_image(self) -> Image.Image:
+        img = Image.open(io.BytesIO(self.jpeg))
+        return img.convert("RGB")
+
+    def alpha_image(self) -> Image.Image:
+        return Image.frombytes("L", (self.width, self.height), self.alpha)
+
+    def composite_image(self) -> Image.Image:
+        rgb = self.rgb_image()
+        alpha = self.alpha_image()
+        rgb.putalpha(alpha)
+        return rgb
+
+
+def decode_alpha_rle(data: bytes, expected: int) -> bytes:
+    out = bytearray(expected)
+    filled = 0
+    for i in range(0, len(data) - 1, 2):
+        count = data[i]
+        value = data[i + 1]
+        if count == 0:
+            continue
+        if filled >= expected:
+            break
+        end = min(filled + count, expected)
+        out[filled:end] = bytes([value]) * (end - filled)
+        filled = end
+    return bytes(out)
+
+
+def decode_jaz_bytes(data: bytes) -> JazImage:
+    parsed = JAZ_FILE.parse(data)
+    header = parsed.header
+    if header.method != 1:
+        raise ValueError(f"unsupported compression method: {header.method}")
+    raw = zlib.decompress(parsed.compressed)
+    if len(raw) != header.raw_size:
+        raise ValueError(f"raw size mismatch: {len(raw)} != {header.raw_size}")
+    payload = jaz_payload(header.raw_size).parse(raw)
+    img = Image.open(io.BytesIO(payload.jpeg))
+    width, height = img.size
+    alpha = decode_alpha_rle(payload.alpha_rle, width * height)
+    return JazImage(width, height, payload.jpeg, alpha)
+
+
+def decode_jaz(path: str | Path) -> JazImage:
+    return decode_jaz_bytes(Path(path).read_bytes())

grim/math.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+def clamp(value: float, low: float, high: float) -> float:
+    if value < low:
+        return low
+    if value > high:
+        return high
+    return value
+
+
+def clamp01(value: float) -> float:
+    return clamp(value, 0.0, 1.0)
+
+
+def lerp(a: float, b: float, t: float) -> float:
+    return a + (b - a) * t