crimsonland 0.1.0.dev1__py3-none-any.whl

crimson/cli.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import io
+import inspect
+import json
+import random
+import re
+from pathlib import Path
+from dataclasses import fields
+
+import typer
+from PIL import Image
+
+from grim import jaz, paq
+from grim.rand import Crand
+from .paths import default_runtime_dir
+from .creatures.spawn import SpawnEnv, build_spawn_plan, spawn_id_label
+from .quests import all_quests
+from .quests.types import QuestContext, QuestDefinition, SpawnEntry
+
+
+app = typer.Typer(add_completion=False)
+
+_QUEST_DEFS: dict[str, QuestDefinition] = {quest.level: quest for quest in all_quests()}
+_QUEST_BUILDERS = {level: quest.builder for level, quest in _QUEST_DEFS.items()}
+_QUEST_TITLES = {level: quest.title for level, quest in _QUEST_DEFS.items()}
+
+_SEP_RE = re.compile(r"[\\/]+")
+
+
+def _safe_relpath(name: str) -> Path:
+    parts = [p for p in _SEP_RE.split(name) if p]
+    if not parts:
+        raise ValueError("empty entry name")
+    for part in parts:
+        if part in (".", ".."):
+            raise ValueError(f"unsafe path part: {part!r}")
+    return Path(*parts)
+
+
+def _extract_one(paq_path: Path, assets_root: Path) -> int:
+    out_root = assets_root / paq_path.stem
+    out_root.mkdir(parents=True, exist_ok=True)
+    count = 0
+    for name, data in paq.iter_entries(paq_path):
+        rel = _safe_relpath(name)
+        dest = out_root / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        suffix = dest.suffix.lower()
+        if suffix == ".jaz":
+            jaz_image = jaz.decode_jaz_bytes(data)
+            base = dest.with_suffix("")
+            jaz_image.composite_image().save(base.with_suffix(".png"))
+        else:
+            if suffix == ".tga":
+                img = Image.open(io.BytesIO(data))
+                img.save(dest.with_suffix(".png"))
+            else:
+                dest.write_bytes(data)
+        count += 1
+    return count
+
+
+@app.command("extract")
+def cmd_extract(game_dir: Path, assets_dir: Path) -> None:
+    """Extract all .paq files into a flat asset directory."""
+    if not game_dir.is_dir():
+        typer.echo(f"game dir not found: {game_dir}", err=True)
+        raise typer.Exit(code=1)
+    assets_dir.mkdir(parents=True, exist_ok=True)
+    paqs = sorted(game_dir.rglob("*.paq"))
+    if not paqs:
+        typer.echo(f"no .paq files under {game_dir}", err=True)
+        raise typer.Exit(code=1)
+    total = 0
+    for paq_path in paqs:
+        total += _extract_one(paq_path, assets_dir)
+    typer.echo(f"extracted {total} files")
+
+
+def _call_builder(builder, ctx: QuestContext, rng: random.Random | None) -> list[SpawnEntry]:
+    params = inspect.signature(builder).parameters
+    if "rng" in params:
+        return builder(ctx, rng=rng)
+    return builder(ctx)
+
+
+def _format_entry(idx: int, entry: SpawnEntry, *, plan_info: tuple[int, int] | None) -> str:
+    creature = spawn_id_label(entry.spawn_id)
+    plan_text = ""
+    if plan_info is not None:
+        creatures_per_spawn, spawn_slots_per_spawn = plan_info
+        alloc = entry.count * creatures_per_spawn
+        plan_text = f"  alloc={alloc:3d} (x{creatures_per_spawn:2d})  slots={spawn_slots_per_spawn}"
+    return (
+        f"{idx:02d}  t={entry.trigger_ms:5d}  "
+        f"id=0x{entry.spawn_id:02x} ({entry.spawn_id:2d})  "
+        f"creature={creature:10s}  "
+        f"count={entry.count:2d}  "
+        f"x={entry.x:7.1f}  y={entry.y:7.1f}  heading={entry.heading:7.3f}{plan_text}"
+    )
+
+
+def _format_id(value: int | None) -> str:
+    if value is None:
+        return "none"
+    return f"0x{value:02x} ({value})"
+
+
+def _format_id_list(values: tuple[int, ...] | None) -> str:
+    if not values:
+        return "none"
+    return "[" + ", ".join(_format_id(value) for value in values) + "]"
+
+
+def _format_meta(quest: QuestDefinition) -> list[str]:
+    builder_addr = f"0x{quest.builder_address:08x}" if quest.builder_address is not None else "unknown"
+    terrain_ids = _format_id_list(quest.terrain_ids)
+    return [
+        f"time_limit_ms={quest.time_limit_ms}",
+        f"start_weapon_id={quest.start_weapon_id}",
+        f"unlock_perk_id={_format_id(quest.unlock_perk_id)}",
+        f"unlock_weapon_id={_format_id(quest.unlock_weapon_id)}",
+        f"builder_address={builder_addr}",
+        f"terrain_ids={terrain_ids}",
+    ]
+
+
+@app.command("quests")
+def cmd_quests(
+    level: str = typer.Argument(..., help="quest level, e.g. 1.1"),
+    width: int = typer.Option(1024, help="terrain width"),
+    height: int = typer.Option(1024, help="terrain height"),
+    player_count: int = typer.Option(1, help="player count"),
+    seed: int | None = typer.Option(None, help="seed for randomized quests"),
+    sort: bool = typer.Option(False, help="sort output by trigger time"),
+    show_plan: bool = typer.Option(False, help="include spawn-plan allocation summary"),
+) -> None:
+    """Print quest spawn scripts for a given level."""
+    quest = _QUEST_DEFS.get(level)
+    if quest is None:
+        available = ", ".join(sorted(_QUEST_BUILDERS))
+        typer.echo(f"unknown level {level!r}. Available: {available}", err=True)
+        raise typer.Exit(code=1)
+    builder = quest.builder
+    title = quest.title
+    ctx = QuestContext(width=width, height=height, player_count=player_count)
+    rng = random.Random(seed) if seed is not None else random.Random()
+    entries = _call_builder(builder, ctx, rng)
+    if sort:
+        entries = sorted(entries, key=lambda e: (e.trigger_ms, e.spawn_id, e.x, e.y))
+    typer.echo(f"Quest {level} {title} ({len(entries)} entries)")
+    typer.echo("Meta: " + "; ".join(_format_meta(quest)))
+
+    plan_cache: dict[int, tuple[int, int]] = {}
+    if show_plan:
+        env = SpawnEnv(
+            terrain_width=float(width),
+            terrain_height=float(height),
+            demo_mode_active=True,
+            hardcore=False,
+            difficulty_level=0,
+        )
+        for entry in entries:
+            if entry.spawn_id in plan_cache:
+                continue
+            plan = build_spawn_plan(entry.spawn_id, (512.0, 512.0), 0.0, Crand(0), env)
+            plan_cache[entry.spawn_id] = (len(plan.creatures), len(plan.spawn_slots))
+        total_alloc = sum(entry.count * plan_cache[entry.spawn_id][0] for entry in entries)
+        total_slots = sum(entry.count * plan_cache[entry.spawn_id][1] for entry in entries)
+        typer.echo(f"Plan: total_alloc={total_alloc} total_spawn_slots={total_slots}")
+
+    for idx, entry in enumerate(entries, start=1):
+        typer.echo(_format_entry(idx, entry, plan_info=plan_cache.get(entry.spawn_id)))
+
+
+@app.command("view")
+def cmd_view(
+    name: str = typer.Argument(..., help="view name (e.g. empty)"),
+    width: int = typer.Option(1024, help="window width"),
+    height: int = typer.Option(768, help="window height"),
+    fps: int = typer.Option(60, help="target fps"),
+    assets_dir: Path = typer.Option(Path("artifacts") / "assets", help="assets root (default: ./artifacts/assets)"),
+) -> None:
+    """Launch a Raylib debug view."""
+    from grim.app import run_view
+    from grim.view import ViewContext
+    from .views import all_views, view_by_name
+
+    view_def = view_by_name(name)
+    if view_def is None:
+        available = ", ".join(view.name for view in all_views())
+        typer.echo(f"unknown view {name!r}. Available: {available}", err=True)
+        raise typer.Exit(code=1)
+    ctx = ViewContext(assets_dir=assets_dir)
+    params = inspect.signature(view_def.factory).parameters
+    if "ctx" in params:
+        view = view_def.factory(ctx=ctx)
+    else:
+        view = view_def.factory()
+    title = f"{view_def.title} — Crimsonland"
+    run_view(view, width=width, height=height, title=title, fps=fps)
+
+
+@app.command("game")
+def cmd_game(
+    width: int | None = typer.Option(None, help="window width (default: use crimson.cfg)"),
+    height: int | None = typer.Option(None, help="window height (default: use crimson.cfg)"),
+    fps: int = typer.Option(60, help="target fps"),
+    seed: int | None = typer.Option(None, help="rng seed"),
+    demo: bool = typer.Option(False, "--demo", help="enable shareware demo mode"),
+    no_intro: bool = typer.Option(False, "--no-intro", help="skip company splashes and intro music"),
+    base_dir: Path = typer.Option(
+        default_runtime_dir(),
+        "--base-dir",
+        "--runtime-dir",
+        help="base path for runtime files (default: per-user OS data dir; override with CRIMSON_RUNTIME_DIR)",
+    ),
+    assets_dir: Path | None = typer.Option(
+        None,
+        help="assets root (default: base-dir; missing .paq files are downloaded)",
+    ),
+) -> None:
+    """Run the reimplementation game flow."""
+    from .game import GameConfig, run_game
+
+    config = GameConfig(
+        base_dir=base_dir,
+        assets_dir=assets_dir,
+        width=width,
+        height=height,
+        fps=fps,
+        seed=seed,
+        demo_enabled=demo,
+        no_intro=no_intro,
+    )
+    run_game(config)
+
+
+@app.command("config")
+def cmd_config(
+    path: Path | None = typer.Option(None, help="path to crimson.cfg (default: base-dir/crimson.cfg)"),
+    base_dir: Path = typer.Option(
+        default_runtime_dir(),
+        "--base-dir",
+        "--runtime-dir",
+        help="base path for runtime files (default: per-user OS data dir; override with CRIMSON_RUNTIME_DIR)",
+    ),
+) -> None:
+    """Inspect crimson.cfg configuration values."""
+    from grim.config import CRIMSON_CFG_NAME, CRIMSON_CFG_STRUCT, load_crimson_cfg
+
+    cfg_path = path if path is not None else base_dir / CRIMSON_CFG_NAME
+    config = load_crimson_cfg(cfg_path)
+    typer.echo(f"path: {config.path}")
+    typer.echo(f"screen: {config.screen_width}x{config.screen_height}")
+    typer.echo(f"windowed: {config.windowed_flag}")
+    typer.echo(f"bpp: {config.screen_bpp}")
+    typer.echo(f"texture_scale: {config.texture_scale}")
+    typer.echo("fields:")
+    for sub in CRIMSON_CFG_STRUCT.subcons:
+        name = sub.name
+        if not name:
+            continue
+        value = config.data[name]
+        typer.echo(f"{name}: {_format_cfg_value(value)}")
+
+
+def _format_cfg_value(value: object) -> str:
+    if isinstance(value, (bytes, bytearray)):
+        length = len(value)
+        prefix = value.split(b"\x00", 1)[0]
+        if prefix and all(32 <= b < 127 for b in prefix):
+            text = prefix.decode("ascii", errors="replace")
+            return f"{text!r} (len={length})"
+        return f"0x{bytes(value).hex()} (len={length})"
+    return str(value)
+
+
+def _parse_int_auto(text: str) -> int:
+    try:
+        return int(text, 0)
+    except ValueError as exc:
+        raise typer.BadParameter(f"invalid integer: {text!r}") from exc
+
+
+def _dc_to_dict(obj: object) -> dict[str, object]:
+    return {f.name: getattr(obj, f.name) for f in fields(obj)}
+
+
+@app.command("spawn-plan")
+def cmd_spawn_plan(
+    template: str = typer.Argument(..., help="spawn id (e.g. 0x12)"),
+    seed: str = typer.Option("0xBEEF", help="MSVCRT rand() seed (e.g. 0xBEEF)"),
+    x: float = typer.Option(512.0, help="spawn x"),
+    y: float = typer.Option(512.0, help="spawn y"),
+    heading: float = typer.Option(0.0, help="heading (radians)"),
+    terrain_w: float = typer.Option(1024.0, help="terrain width"),
+    terrain_h: float = typer.Option(1024.0, help="terrain height"),
+    demo_mode_active: bool = typer.Option(True, help="when true, burst effect is skipped"),
+    hardcore: bool = typer.Option(False, help="hardcore mode"),
+    difficulty: int = typer.Option(0, help="difficulty level"),
+    as_json: bool = typer.Option(False, "--json", help="print JSON"),
+) -> None:
+    """Build and print a spawn plan for a single template id."""
+    template_id = _parse_int_auto(template)
+    rng = Crand(_parse_int_auto(seed))
+    env = SpawnEnv(
+        terrain_width=terrain_w,
+        terrain_height=terrain_h,
+        demo_mode_active=demo_mode_active,
+        hardcore=hardcore,
+        difficulty_level=difficulty,
+    )
+    plan = build_spawn_plan(template_id, (x, y), heading, rng, env)
+    if as_json:
+        payload: dict[str, object] = {
+            "template_id": template_id,
+            "pos": [x, y],
+            "heading": heading,
+            "seed": _parse_int_auto(seed),
+            "env": {
+                "terrain_width": terrain_w,
+                "terrain_height": terrain_h,
+                "demo_mode_active": demo_mode_active,
+                "hardcore": hardcore,
+                "difficulty_level": difficulty,
+            },
+            "primary": plan.primary,
+            "creatures": [_dc_to_dict(c) for c in plan.creatures],
+            "spawn_slots": [_dc_to_dict(s) for s in plan.spawn_slots],
+            "effects": [_dc_to_dict(e) for e in plan.effects],
+            "rng_state": rng.state,
+        }
+        typer.echo(json.dumps(payload, indent=2, sort_keys=True))
+        return
+
+    typer.echo(f"template_id=0x{template_id:02x} ({template_id}) creature={spawn_id_label(template_id)}")
+    typer.echo(f"pos=({x:.1f},{y:.1f}) heading={heading:.6f} seed=0x{_parse_int_auto(seed):08x} rng_state=0x{rng.state:08x}")
+    typer.echo(
+        "env="
+        f"demo_mode_active={demo_mode_active} "
+        f"hardcore={hardcore} "
+        f"difficulty={difficulty} "
+        f"terrain={terrain_w:.0f}x{terrain_h:.0f}"
+    )
+    typer.echo(f"primary={plan.primary} creatures={len(plan.creatures)} slots={len(plan.spawn_slots)} effects={len(plan.effects)}")
+    typer.echo("")
+    typer.echo("creatures:")
+    for idx, c in enumerate(plan.creatures):
+        primary = "*" if idx == plan.primary else " "
+        typer.echo(
+            f"{primary}{idx:02d} type={c.type_id!s:14s} ai={c.ai_mode:2d} flags=0x{int(c.flags):03x} "
+            f"pos=({c.pos_x:7.1f},{c.pos_y:7.1f}) health={c.health!s:>6s} size={c.size!s:>6s} link={c.ai_link_parent!s:>3s} "
+            f"slot={c.spawn_slot!s:>3s}"
+        )
+    if plan.spawn_slots:
+        typer.echo("")
+        typer.echo("spawn_slots:")
+        for idx, slot in enumerate(plan.spawn_slots):
+            typer.echo(
+                f"{idx:02d} owner={slot.owner_creature:02d} timer={slot.timer:.2f} count={slot.count:3d} "
+                f"limit={slot.limit:3d} interval={slot.interval:.3f} child=0x{slot.child_template_id:02x}"
+            )
+    if plan.effects:
+        typer.echo("")
+        typer.echo("effects:")
+        for fx in plan.effects:
+            typer.echo(f"burst x={fx.x:.1f} y={fx.y:.1f} count={fx.count}")
+
+
+def main(argv: list[str] | None = None) -> None:
+    app(prog_name="crimson", args=argv)
+
+
+if __name__ == "__main__":
+    main()

crimson/creatures/__init__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+"""Creature simulation helpers (structs, spawning, animation, AI).
+
+This package will grow as we port `creature_*` logic from the original binary.
+"""
+
+__all__ = ["ai", "anim", "spawn", "runtime"]

crimson/creatures/ai.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+"""Creature AI helpers.
+
+Ported from `creature_update_all` (`FUN_00426220`).
+"""
+
+from dataclasses import dataclass
+import math
+from typing import Callable, Protocol, Sequence
+
+from .spawn import CreatureFlags
+
+__all__ = [
+    "CreatureAIUpdate",
+    "creature_ai7_tick_link_timer",
+    "creature_ai_update_target",
+]
+
+
+class PositionLike(Protocol):
+    x: float
+    y: float
+
+
+class CreatureLinkLike(PositionLike, Protocol):
+    hp: float
+
+
+class CreatureAIStateLike(CreatureLinkLike, Protocol):
+    flags: CreatureFlags
+    ai_mode: int
+    link_index: int
+    target_offset_x: float | None
+    target_offset_y: float | None
+    phase_seed: float
+    orbit_angle: float
+    orbit_radius: float
+    heading: float
+
+    target_x: float
+    target_y: float
+    target_heading: float
+    force_target: int
+
+
+@dataclass(frozen=True, slots=True)
+class CreatureAIUpdate:
+    move_scale: float
+    self_damage: float | None = None
+
+
+def creature_ai7_tick_link_timer(creature: CreatureAIStateLike, *, dt_ms: int, rand: Callable[[], int]) -> None:
+    """Update AI7's link-index timer behavior (flag 0x80).
+
+    In the original, this runs regardless of the current ai_mode; when the timer
+    flips from negative to non-negative, ai_mode is forced to 7 for a short hold.
+    """
+
+    if not (creature.flags & CreatureFlags.AI7_LINK_TIMER):
+        return
+
+    if creature.link_index < 0:
+        creature.link_index += dt_ms
+        if creature.link_index >= 0:
+            creature.ai_mode = 7
+            creature.link_index = (rand() & 0x1FF) + 500
+        return
+
+    creature.link_index -= dt_ms
+    if creature.link_index < 1:
+        creature.link_index = -700 - (rand() & 0x3FF)
+
+
+def resolve_live_link(creatures: Sequence[CreatureLinkLike], link_index: int) -> CreatureLinkLike | None:
+    if 0 <= link_index < len(creatures) and creatures[link_index].hp > 0.0:
+        return creatures[link_index]
+    return None
+
+
+def creature_ai_update_target(
+    creature: CreatureAIStateLike,
+    *,
+    player_x: float,
+    player_y: float,
+    creatures: Sequence[CreatureLinkLike],
+    dt: float,
+) -> CreatureAIUpdate:
+    """Compute the target position + heading for one creature.
+
+    Updates:
+    - `target_x/target_y`
+    - `target_heading`
+    - `force_target`
+    - `ai_mode` (may reset to 0 in some modes)
+    - `orbit_radius` (AI7 non-link timer uses it as a countdown)
+    """
+
+    dx = player_x - creature.x
+    dy = player_y - creature.y
+    dist_to_player = math.hypot(dx, dy)
+
+    orbit_phase = float(int(creature.phase_seed)) * 3.7 * math.pi
+    move_scale = 1.0
+    self_damage: float | None = None
+
+    creature.force_target = 0
+
+    ai_mode = creature.ai_mode
+    if ai_mode == 0:
+        if dist_to_player > 800.0:
+            creature.target_x = player_x
+            creature.target_y = player_y
+        else:
+            creature.target_x = player_x + math.cos(orbit_phase) * dist_to_player * 0.85
+            creature.target_y = player_y + math.sin(orbit_phase) * dist_to_player * 0.85
+    elif ai_mode == 8:
+        creature.target_x = player_x + math.cos(orbit_phase) * dist_to_player * 0.9
+        creature.target_y = player_y + math.sin(orbit_phase) * dist_to_player * 0.9
+    elif ai_mode == 1:
+        if dist_to_player > 800.0:
+            creature.target_x = player_x
+            creature.target_y = player_y
+        else:
+            creature.target_x = player_x + math.cos(orbit_phase) * dist_to_player * 0.55
+            creature.target_y = player_y + math.sin(orbit_phase) * dist_to_player * 0.55
+    elif ai_mode == 3:
+        link = resolve_live_link(creatures, creature.link_index)
+        if link is not None:
+            creature.target_x = link.x + float(creature.target_offset_x or 0.0)
+            creature.target_y = link.y + float(creature.target_offset_y or 0.0)
+        else:
+            creature.ai_mode = 0
+    elif ai_mode == 5:
+        link = resolve_live_link(creatures, creature.link_index)
+        if link is not None:
+            creature.target_x = link.x + float(creature.target_offset_x or 0.0)
+            creature.target_y = link.y + float(creature.target_offset_y or 0.0)
+            dist_to_target = math.hypot(creature.target_x - creature.x, creature.target_y - creature.y)
+            if dist_to_target <= 64.0:
+                move_scale = dist_to_target * 0.015625
+        else:
+            creature.ai_mode = 0
+            self_damage = 1000.0
+
+    ai_mode = creature.ai_mode
+    if ai_mode == 4:
+        link = resolve_live_link(creatures, creature.link_index)
+        if link is None:
+            creature.ai_mode = 0
+            self_damage = 1000.0
+        elif dist_to_player > 800.0:
+            creature.target_x = player_x
+            creature.target_y = player_y
+        else:
+            creature.target_x = player_x + math.cos(orbit_phase) * dist_to_player * 0.85
+            creature.target_y = player_y + math.sin(orbit_phase) * dist_to_player * 0.85
+    elif ai_mode == 7:
+        if (creature.flags & CreatureFlags.AI7_LINK_TIMER) and creature.link_index > 0:
+            creature.target_x = creature.x
+            creature.target_y = creature.y
+        elif not (creature.flags & CreatureFlags.AI7_LINK_TIMER) and creature.orbit_radius > 0.0:
+            creature.target_x = creature.x
+            creature.target_y = creature.y
+            creature.orbit_radius -= dt
+        else:
+            creature.ai_mode = 0
+    elif ai_mode == 6:
+        link = resolve_live_link(creatures, creature.link_index)
+        if link is None:
+            creature.ai_mode = 0
+        else:
+            angle = float(creature.orbit_angle) + float(creature.heading)
+            creature.target_x = link.x + math.cos(angle) * float(creature.orbit_radius)
+            creature.target_y = link.y + math.sin(angle) * float(creature.orbit_radius)
+
+    dist_to_target = math.hypot(creature.target_x - creature.x, creature.target_y - creature.y)
+    if dist_to_target < 40.0 or dist_to_target > 400.0:
+        creature.force_target = 1
+
+    if creature.force_target or creature.ai_mode == 2:
+        creature.target_x = player_x
+        creature.target_y = player_y
+
+    creature.target_heading = math.atan2(creature.target_y - creature.y, creature.target_x - creature.x) + math.pi / 2.0
+    return CreatureAIUpdate(move_scale=move_scale, self_damage=self_damage)