crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/__init__.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from importlib.metadata import version
+
+__version__ = version("crimsonland")
+
+__all__ = [
+    "atlas",
+    "audio_router",
+    "bonuses",
+    "creatures",
+    "gameplay",
+    "effects",
+    "effects_atlas",
+    "modes",
+    "perks",
+    "persistence",
+    "quests",
+    "render",
+    "sim",
+    "ui",
+    "views",
+    "weapons",
+]

crimson/assets_fetch.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import shutil
+import urllib.request
+
+from grim.console import ConsoleState
+
+ASSET_BASE_URL = "https://paq.crimson.banteg.xyz/v1.9.93"
+DEFAULT_PAQ_FILES = ("crimson.paq", "music.paq", "sfx.paq")
+
+
+@dataclass(frozen=True, slots=True)
+class DownloadResult:
+    name: str
+    ok: bool
+    error: str | None = None
+
+
+def _download_file(url: str, dest: Path) -> None:
+    tmp = dest.with_suffix(dest.suffix + ".tmp")
+    if tmp.exists():
+        tmp.unlink()
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "crimsonland-decompile"})
+        with urllib.request.urlopen(req, timeout=30) as resp, tmp.open("wb") as handle:
+            shutil.copyfileobj(resp, handle)
+        tmp.replace(dest)
+    finally:
+        if tmp.exists():
+            tmp.unlink()
+
+
+def download_missing_paqs(
+    assets_dir: Path,
+    console: ConsoleState,
+    *,
+    base_url: str = ASSET_BASE_URL,
+    names: tuple[str, ...] = DEFAULT_PAQ_FILES,
+) -> tuple[DownloadResult, ...]:
+    assets_dir.mkdir(parents=True, exist_ok=True)
+    missing = [name for name in names if not (assets_dir / name).is_file()]
+    if not missing:
+        return ()
+    console.log.log(f"assets: missing {', '.join(missing)} (downloading)")
+    results: list[DownloadResult] = []
+    for name in missing:
+        url = f"{base_url}/{name}"
+        dest = assets_dir / name
+        try:
+            _download_file(url, dest)
+        except Exception as exc:
+            results.append(DownloadResult(name=name, ok=False, error=str(exc)))
+            console.log.log(f"assets: failed to download {name}: {exc}")
+            continue
+        results.append(DownloadResult(name=name, ok=True))
+        console.log.log(f"assets: downloaded {name}")
+    console.log.flush()
+    return tuple(results)

crimson/atlas.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+"""
+Atlas slicing used by the Crimsonland renderer.
+
+Findings from decompiled code:
+- FUN_0041fed0 precomputes UV grids for 2x2, 4x4, 8x8, 16x16 (steps 0.5/0.25/0.125/0.0625).
+- FUN_0042e0a0 reads a table at VA 0x004755F0 with pairs (cell_code, group_id).
+  cell_code maps to grid size: 0x80->2, 0x40->4, 0x20->8, 0x10->16.
+  group_id is passed to the renderer alongside the grid size; semantics unknown.
+- FUN_0042e120 uses the selected UV grid to build quad UVs by frame index.
+
+This module replicates the atlas cutting: given a grid size and frame index,
+compute UVs or crop subimages.
+"""
+
+from typing import Iterable
+
+from PIL import Image
+
+GRID_SIZE_BY_CODE = {
+    0x80: 2,
+    0x40: 4,
+    0x20: 8,
+    0x10: 16,
+}
+
+# DAT_004755f0 table (index -> (cell_code, group_id)) extracted from crimsonland.exe
+SPRITE_TABLE = [
+    (0x80, 0x2),
+    (0x80, 0x3),
+    (0x20, 0x0),
+    (0x20, 0x1),
+    (0x20, 0x2),
+    (0x20, 0x3),
+    (0x20, 0x4),
+    (0x20, 0x5),
+    (0x20, 0x8),
+    (0x20, 0x9),
+    (0x20, 0xA),
+    (0x20, 0xB),
+    (0x40, 0x5),
+    (0x40, 0x3),
+    (0x40, 0x4),
+    (0x40, 0x5),
+    (0x40, 0x6),
+]
+
+
+def grid_size_from_code(code: int) -> int:
+    return GRID_SIZE_BY_CODE[code]
+
+
+def grid_size_for_index(index: int) -> int:
+    code, _ = SPRITE_TABLE[index]
+    return grid_size_from_code(code)
+
+
+def uv_for_index(grid: int, index: int) -> tuple[float, float, float, float]:
+    row = index // grid
+    col = index % grid
+    step = 1.0 / grid
+    u0 = col * step
+    v0 = row * step
+    u1 = u0 + step
+    v1 = v0 + step
+    return u0, v0, u1, v1
+
+
+def rect_for_index(width: int, height: int, grid: int, index: int) -> tuple[int, int, int, int]:
+    row = index // grid
+    col = index % grid
+    cell_w = width // grid
+    cell_h = height // grid
+    x0 = col * cell_w
+    y0 = row * cell_h
+    return x0, y0, x0 + cell_w, y0 + cell_h
+
+
+def slice_index(image: Image.Image, grid: int, index: int) -> Image.Image:
+    return image.crop(rect_for_index(image.width, image.height, grid, index))
+
+
+def slice_grid(image: Image.Image, grid: int) -> list[Image.Image]:
+    frames = []
+    for idx in range(grid * grid):
+        frames.append(slice_index(image, grid, idx))
+    return frames
+
+
+def slice_by_indices(image: Image.Image, grid: int, indices: Iterable[int]) -> list[Image.Image]:
+    return [slice_index(image, grid, idx) for idx in indices]

crimson/audio_router.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import random
+from typing import Callable
+
+from grim.audio import AudioState, play_sfx, trigger_game_tune
+
+from .creatures.spawn import CreatureTypeId
+from .game_modes import GameMode
+from .weapon_sfx import resolve_weapon_sfx_ref
+from .weapons import WEAPON_BY_ID
+
+_MAX_HIT_SFX_PER_FRAME = 4
+_MAX_DEATH_SFX_PER_FRAME = 3
+
+_BULLET_HIT_SFX = (
+    "sfx_bullet_hit_01",
+    "sfx_bullet_hit_02",
+    "sfx_bullet_hit_03",
+    "sfx_bullet_hit_04",
+    "sfx_bullet_hit_05",
+    "sfx_bullet_hit_06",
+)
+
+_CREATURE_DEATH_SFX: dict[CreatureTypeId, tuple[str, ...]] = {
+    CreatureTypeId.ZOMBIE: (
+        "sfx_zombie_die_01",
+        "sfx_zombie_die_02",
+        "sfx_zombie_die_03",
+        "sfx_zombie_die_04",
+    ),
+    CreatureTypeId.LIZARD: (
+        "sfx_lizard_die_01",
+        "sfx_lizard_die_02",
+        "sfx_lizard_die_03",
+        "sfx_lizard_die_04",
+    ),
+    CreatureTypeId.ALIEN: (
+        "sfx_alien_die_01",
+        "sfx_alien_die_02",
+        "sfx_alien_die_03",
+        "sfx_alien_die_04",
+    ),
+    CreatureTypeId.SPIDER_SP1: (
+        "sfx_spider_die_01",
+        "sfx_spider_die_02",
+        "sfx_spider_die_03",
+        "sfx_spider_die_04",
+    ),
+    CreatureTypeId.SPIDER_SP2: (
+        "sfx_spider_die_01",
+        "sfx_spider_die_02",
+        "sfx_spider_die_03",
+        "sfx_spider_die_04",
+    ),
+    CreatureTypeId.TROOPER: (
+        "sfx_trooper_die_01",
+        "sfx_trooper_die_02",
+        "sfx_trooper_die_03",
+        "sfx_trooper_die_04",
+    ),
+}
+
+
+@dataclass(slots=True)
+class AudioRouter:
+    audio: AudioState | None = None
+    audio_rng: random.Random | None = None
+    demo_mode_active: bool = False
+
+    @staticmethod
+    def _rand_choice(rand: Callable[[], int], options: tuple[str, ...]) -> str | None:
+        if not options:
+            return None
+        idx = int(rand()) % len(options)
+        return options[idx]
+
+    def play_sfx(self, key: str | None) -> None:
+        if self.audio is None:
+            return
+        play_sfx(self.audio, key, rng=self.audio_rng)
+
+    def handle_player_audio(
+        self,
+        player: object,
+        *,
+        prev_shot_seq: int,
+        prev_reload_active: bool,
+        prev_reload_timer: float,
+    ) -> None:
+        if self.audio is None:
+            return
+        weapon = WEAPON_BY_ID.get(int(getattr(player, "weapon_id", 0)))
+        if weapon is None:
+            return
+
+        if int(getattr(player, "shot_seq", 0)) > int(prev_shot_seq):
+            self.play_sfx(resolve_weapon_sfx_ref(weapon.fire_sound))
+
+        reload_active = bool(getattr(player, "reload_active", False))
+        reload_timer = float(getattr(player, "reload_timer", 0.0))
+        reload_started = (not prev_reload_active and reload_active) or (reload_timer > prev_reload_timer + 1e-6)
+        if reload_started:
+            self.play_sfx(resolve_weapon_sfx_ref(weapon.reload_sound))
+
+    def _hit_sfx_for_type(
+        self,
+        type_id: int,
+        *,
+        beam_types: frozenset[int],
+        rand: Callable[[], int],
+    ) -> str | None:
+        weapon = WEAPON_BY_ID.get(int(type_id))
+        ammo_class = weapon.ammo_class if weapon is not None else None
+        if ammo_class == 4:
+            return "sfx_shock_hit_01"
+        return self._rand_choice(rand, _BULLET_HIT_SFX)
+
+    def play_hit_sfx(
+        self,
+        hits: list[tuple[int, float, float, float, float, float, float]],
+        *,
+        game_mode: int,
+        rand: Callable[[], int],
+        beam_types: frozenset[int],
+    ) -> None:
+        if self.audio is None or not hits:
+            return
+
+        start_idx = 0
+        if (not self.demo_mode_active) and int(game_mode) != int(GameMode.RUSH):
+            if trigger_game_tune(self.audio, rand=rand) is not None:
+                start_idx = 1
+
+        end = min(len(hits), start_idx + _MAX_HIT_SFX_PER_FRAME)
+        for idx in range(start_idx, end):
+            type_id = int(hits[idx][0])
+            self.play_sfx(self._hit_sfx_for_type(type_id, beam_types=beam_types, rand=rand))
+
+    def play_death_sfx(self, deaths: tuple[object, ...], *, rand: Callable[[], int]) -> None:
+        if self.audio is None or not deaths:
+            return
+        for idx in range(min(len(deaths), _MAX_DEATH_SFX_PER_FRAME)):
+            death = deaths[idx]
+            type_id = getattr(death, "type_id", None)
+            if type_id is None:
+                continue
+            try:
+                creature_type = CreatureTypeId(int(type_id))
+            except ValueError:
+                continue
+            options = _CREATURE_DEATH_SFX.get(creature_type)
+            if options:
+                self.play_sfx(self._rand_choice(rand, options))

crimson/bonuses.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+"""Bonus ids extracted from bonus_metadata_init (bonus_meta_label)."""
+
+from dataclasses import dataclass
+from enum import IntEnum
+
+
+class BonusId(IntEnum):
+    UNUSED = 0
+    POINTS = 1
+    ENERGIZER = 2
+    WEAPON = 3
+    WEAPON_POWER_UP = 4
+    NUKE = 5
+    DOUBLE_EXPERIENCE = 6
+    SHOCK_CHAIN = 7
+    FIREBLAST = 8
+    REFLEX_BOOST = 9
+    SHIELD = 10
+    FREEZE = 11
+    MEDIKIT = 12
+    SPEED = 13
+    FIRE_BULLETS = 14
+
+
+@dataclass(frozen=True, slots=True)
+class BonusMeta:
+    bonus_id: BonusId
+    name: str
+    description: str | None
+    icon_id: int | None
+    default_amount: int | None
+    notes: str | None = None
+
+
+BONUS_TABLE = [
+    BonusMeta(
+        bonus_id=BonusId.UNUSED,
+        name="(unused)",
+        description=None,
+        icon_id=None,
+        default_amount=None,
+        notes="`DAT_004853dc` is set to `0`, disabling this entry.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.POINTS,
+        name="Points",
+        description="You gain some experience points.",
+        icon_id=12,
+        default_amount=500,
+        notes="`bonus_apply` adds `default_amount` to score.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.ENERGIZER,
+        name="Energizer",
+        description="Suddenly monsters run away from you and you can eat them.",
+        icon_id=10,
+        default_amount=8,
+        notes="`bonus_apply` updates `bonus_energizer_timer`.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.WEAPON,
+        name="Weapon",
+        description="You get a new weapon.",
+        icon_id=-1,
+        default_amount=3,
+        notes="`bonus_apply` treats `default_amount` as weapon id; often overridden.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.WEAPON_POWER_UP,
+        name="Weapon Power Up",
+        description="Your firerate and load time increase for a short period.",
+        icon_id=7,
+        default_amount=10,
+        notes="`bonus_apply` updates `bonus_weapon_power_up_timer`.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.NUKE,
+        name="Nuke",
+        description="An amazing explosion of ATOMIC power.",
+        icon_id=1,
+        default_amount=0,
+        notes="`bonus_apply` performs the large explosion + shake sequence.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.DOUBLE_EXPERIENCE,
+        name="Double Experience",
+        description="Every experience point you get is doubled when this bonus is active.",
+        icon_id=4,
+        default_amount=6,
+        notes="`bonus_apply` updates `bonus_double_xp_timer`.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.SHOCK_CHAIN,
+        name="Shock Chain",
+        description="Chain of shocks shock the crowd.",
+        icon_id=3,
+        default_amount=0,
+        notes="`bonus_apply` spawns chained lightning via `projectile_spawn` type `0x15`; `shock_chain_links_left` / `shock_chain_projectile_id` track the active chain.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.FIREBLAST,
+        name="Fireblast",
+        description="Fireballs all over the place.",
+        icon_id=2,
+        default_amount=0,
+        notes="`bonus_apply` spawns a radial projectile burst (type `9`).",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.REFLEX_BOOST,
+        name="Reflex Boost",
+        description="You get more time to react as the game slows down.",
+        icon_id=5,
+        default_amount=3,
+        notes="`bonus_apply` updates `bonus_reflex_boost_timer`.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.SHIELD,
+        name="Shield",
+        description="Force field protects you for a while.",
+        icon_id=6,
+        default_amount=7,
+        notes="`bonus_apply` updates `player_shield_timer` (`DAT_00490bc8`).",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.FREEZE,
+        name="Freeze",
+        description="Monsters are frozen.",
+        icon_id=8,
+        default_amount=5,
+        notes="`bonus_apply` updates `bonus_freeze_timer`.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.MEDIKIT,
+        name="MediKit",
+        description="You regain some of your health.",
+        icon_id=14,
+        default_amount=10,
+        notes="`bonus_apply` restores health in 10-point increments.",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.SPEED,
+        name="Speed",
+        description="Your movement speed increases for a while.",
+        icon_id=9,
+        default_amount=8,
+        notes="`bonus_apply` updates `player_speed_bonus_timer` (`DAT_00490bc4`).",
+    ),
+    BonusMeta(
+        bonus_id=BonusId.FIRE_BULLETS,
+        name="Fire Bullets",
+        description="For few seconds -- make them count.",
+        icon_id=11,
+        default_amount=5,
+        notes="`bonus_apply` updates `player_fire_bullets_timer` (`DAT_00490bcc`). While active, `projectile_spawn` overrides player-owned projectiles to type `0x2d` (pellet count from `weapon_projectile_pellet_count[weapon_id]`).",
+    ),
+]
+
+BONUS_BY_ID = {int(entry.bonus_id): entry for entry in BONUS_TABLE}
+
+
+def bonus_label(bonus_id: int) -> str:
+    entry = BONUS_BY_ID.get(bonus_id)
+    if entry is None:
+        return "unknown"
+    return entry.name

crimson/camera.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+"""Camera helpers recovered from the original crimsonland.exe.
+
+This module currently models the `camera_update` screen shake logic, which is
+global state in the original game.
+"""
+
+from .gameplay import GameplayState
+
+
+def camera_shake_start(state: GameplayState, *, pulses: int, timer: float) -> None:
+    """Start a camera shake sequence.
+
+    Mirrors the nuke path in `bonus_apply`, which sets:
+      - `camera_shake_pulses = 0x14`
+      - `camera_shake_timer = 0.2`
+    """
+
+    state.camera_shake_pulses = int(pulses)
+    state.camera_shake_timer = float(timer)
+
+
+def camera_shake_update(state: GameplayState, dt: float) -> None:
+    """Update camera shake offsets and timers.
+
+    Port of `camera_update` (crimsonland.exe @ 0x00409500):
+      - timer decays at `dt * 3.0`
+      - when timer drops below 0, a "pulse" happens:
+        - pulses--
+        - timer resets to 0.1 (or 0.06 when time scaling is active)
+        - offsets jump to new RNG-derived values
+    """
+
+    if state.camera_shake_timer <= 0.0:
+        state.camera_shake_offset_x = 0.0
+        state.camera_shake_offset_y = 0.0
+        return
+
+    state.camera_shake_timer -= float(dt) * 3.0
+    if state.camera_shake_timer >= 0.0:
+        return
+
+    state.camera_shake_pulses -= 1
+    if state.camera_shake_pulses < 1:
+        state.camera_shake_timer = 0.0
+        return
+
+    time_scale_active = state.bonuses.reflex_boost > 0.0
+    state.camera_shake_timer = 0.06 if time_scale_active else 0.1
+
+    # Decompiled logic:
+    #   iVar4 = camera_shake_pulses * 0x3c;
+    #   iVar1 = rand() % (iVar4 / 0x14) + rand() % 10;
+    # ... where (pulses * 0x3c) / 0x14 == pulses * 3.
+    max_amp = int(state.camera_shake_pulses) * 3
+    if max_amp <= 0:
+        state.camera_shake_offset_x = 0.0
+        state.camera_shake_offset_y = 0.0
+        state.camera_shake_timer = 0.0
+        state.camera_shake_pulses = 0
+        return
+
+    rand = state.rng.rand
+
+    mag_x = (int(rand()) % max_amp) + (int(rand()) % 10)
+    if (int(rand()) & 1) == 0:
+        mag_x = -mag_x
+    state.camera_shake_offset_x = float(mag_x)
+
+    mag_y = (int(rand()) % max_amp) + (int(rand()) % 10)
+    if (int(rand()) & 1) == 0:
+        mag_y = -mag_y
+    state.camera_shake_offset_y = float(mag_y)
+