crimsonland 0.1.0.dev5__py3-none-any.whl

grim/sfx.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import random
+from typing import Iterable
+
+import pyray as rl
+
+from .console import ConsoleState
+from . import paq
+from . import sfx_map
+
+
+SFX_PAK_NAME = "sfx.paq"
+DEFAULT_VOICE_COUNT = 4
+
+
+@dataclass(slots=True)
+class SfxSample:
+    entry_name: str
+    source: rl.Sound
+    aliases: list[rl.Sound]
+    next_voice: int = 0
+
+    def voices(self) -> Iterable[rl.Sound]:
+        yield self.source
+        yield from self.aliases
+
+    def acquire_voice(self) -> rl.Sound:
+        for voice in self.voices():
+            if not rl.is_sound_playing(voice):
+                return voice
+        voices = [self.source, *self.aliases]
+        idx = self.next_voice % len(voices)
+        self.next_voice += 1
+        return voices[idx]
+
+
+@dataclass(slots=True)
+class SfxState:
+    ready: bool
+    enabled: bool
+    volume: float
+    voice_count: int
+    entries: dict[str, bytes]
+    directory: Path | None
+    key_to_entry: dict[str, str]
+    variants: dict[str, tuple[str, ...]]
+    samples: dict[str, SfxSample]
+    missing_keys: set[str]
+
+
+def init_sfx_state(
+    *,
+    ready: bool,
+    enabled: bool,
+    volume: float,
+    voice_count: int = DEFAULT_VOICE_COUNT,
+) -> SfxState:
+    return SfxState(
+        ready=ready,
+        enabled=enabled,
+        volume=float(volume),
+        voice_count=max(1, int(voice_count)),
+        entries={},
+        directory=None,
+        key_to_entry={},
+        variants={},
+        samples={},
+        missing_keys=set(),
+    )
+
+
+def _derive_sfx_key(entry_name: str) -> str:
+    return "sfx_" + Path(entry_name).stem.lower()
+
+
+def _derive_sfx_base(key: str) -> str | None:
+    if not key.startswith("sfx_"):
+        return None
+    stem = key[4:]
+    if len(stem) < 3:
+        return None
+    if "_" not in stem:
+        return None
+    base, suffix = stem.rsplit("_", 1)
+    if not suffix.isdigit():
+        return None
+    return "sfx_" + base
+
+
+def _build_variants(keys: Iterable[str]) -> dict[str, tuple[str, ...]]:
+    base_to_keys: dict[str, list[str]] = {}
+    for key in keys:
+        base = _derive_sfx_base(key)
+        if base is None:
+            continue
+        base_to_keys.setdefault(base, []).append(key)
+    return {base: tuple(sorted(values)) for base, values in base_to_keys.items()}
+
+
+def load_sfx_index(state: SfxState, assets_dir: Path, console: ConsoleState) -> None:
+    if not state.ready or not state.enabled:
+        return
+
+    sfx_dir = assets_dir / "sfx"
+    if sfx_dir.exists() and sfx_dir.is_dir():
+        entry_names: list[str] = []
+        for path in sorted(sfx_dir.iterdir()):
+            if not path.is_file():
+                continue
+            if path.suffix.lower() not in {".ogg", ".wav"}:
+                continue
+            entry_names.append(path.name)
+
+        state.directory = sfx_dir
+        state.entries.clear()
+        available = set(entry_names)
+        state.key_to_entry = {_derive_sfx_key(name): name for name in entry_names}
+        for key, name in sfx_map.SFX_ENTRY_BY_KEY.items():
+            if name in available:
+                state.key_to_entry[key] = name
+        state.variants = _build_variants(state.key_to_entry.keys())
+        console.log.log(f"audio: sfx indexed {len(entry_names)} files from {sfx_dir}")
+        console.log.flush()
+        return
+
+    paq_path = assets_dir / SFX_PAK_NAME
+    if not paq_path.exists():
+        raise FileNotFoundError(f"audio: missing {SFX_PAK_NAME} in {assets_dir}")
+    entries: dict[str, bytes] = {}
+    for name, data in paq.iter_entries(paq_path):
+        entries[name.replace("\\", "/")] = data
+    state.directory = None
+    state.entries = entries
+    available = set(entries.keys())
+    state.key_to_entry = {_derive_sfx_key(name): name for name in entries.keys()}
+    for key, name in sfx_map.SFX_ENTRY_BY_KEY.items():
+        if name in available:
+            state.key_to_entry[key] = name
+    state.variants = _build_variants(state.key_to_entry.keys())
+    console.log.log(f"audio: sfx indexed {len(entries)} entries from {SFX_PAK_NAME}")
+    console.log.flush()
+
+
+def _normalize_sfx_key(state: SfxState, key: str) -> str | None:
+    key = key.strip().lstrip("_")
+    if not key:
+        return None
+    key = sfx_map.SFX_KEY_ALIASES.get(key, key)
+    if "_alias_" in key:
+        key = key.split("_alias_", 1)[0]
+    if key in state.key_to_entry:
+        return key
+    if key.endswith("_alt"):
+        cand = key[: -len("_alt")]
+        if cand in state.key_to_entry:
+            return cand
+    return None
+
+
+def _load_sample(state: SfxState, key: str) -> SfxSample | None:
+    resolved = _normalize_sfx_key(state, key)
+    if resolved is None:
+        return None
+    existing = state.samples.get(resolved)
+    if existing is not None:
+        return existing
+
+    entry_name = state.key_to_entry.get(resolved)
+    if entry_name is None:
+        return None
+
+    if state.directory is not None:
+        path = state.directory / entry_name
+        source = rl.load_sound(str(path))
+    else:
+        data = state.entries.get(entry_name)
+        if data is None:
+            return None
+        file_type = Path(entry_name).suffix.lower()
+        wave = rl.load_wave_from_memory(file_type, data, len(data))
+        source = rl.load_sound_from_wave(wave)
+        rl.unload_wave(wave)
+
+    aliases = [rl.load_sound_alias(source) for _ in range(max(1, state.voice_count) - 1)]
+
+    sample = SfxSample(entry_name=entry_name, source=source, aliases=aliases)
+    for voice in sample.voices():
+        rl.set_sound_volume(voice, state.volume)
+    state.samples[resolved] = sample
+    return sample
+
+
+def play_sfx(
+    state: SfxState | None,
+    key: str | None,
+    *,
+    rng: random.Random | None = None,
+    allow_variants: bool = True,
+) -> None:
+    if state is None or not state.ready or not state.enabled:
+        return
+    if not key:
+        return
+
+    resolved = _normalize_sfx_key(state, key)
+    if resolved is None:
+        state.missing_keys.add(key)
+        return
+
+    if allow_variants:
+        base = _derive_sfx_base(resolved) or resolved
+        variants = state.variants.get(base)
+        if variants:
+            rng = rng or random
+            resolved = rng.choice(variants)
+
+    sample = _load_sample(state, resolved)
+    if sample is None:
+        state.missing_keys.add(resolved)
+        return
+    rl.play_sound(sample.acquire_voice())
+
+
+def sfx_key_for_id(sfx_id: int) -> str | None:
+    if sfx_id < 0:
+        return None
+    if sfx_id >= len(sfx_map.SFX_KEY_BY_ID):
+        return None
+    return sfx_map.SFX_KEY_BY_ID[sfx_id]
+
+
+def play_sfx_id(state: SfxState | None, sfx_id: int, *, rng: random.Random | None = None) -> None:
+    key = sfx_key_for_id(int(sfx_id))
+    if key is None:
+        return
+    play_sfx(state, key, rng=rng, allow_variants=False)
+
+
+def set_sfx_volume(state: SfxState | None, volume: float) -> None:
+    if state is None:
+        return
+    volume = float(volume)
+    if volume < 0.0:
+        volume = 0.0
+    if volume > 1.0:
+        volume = 1.0
+    state.volume = volume
+    for sample in state.samples.values():
+        for voice in sample.voices():
+            rl.set_sound_volume(voice, state.volume)
+
+
+def shutdown_sfx(state: SfxState) -> None:
+    if not state.ready:
+        return
+    for sample in state.samples.values():
+        for alias in sample.aliases:
+            try:
+                rl.stop_sound(alias)
+                rl.unload_sound_alias(alias)
+            except Exception:
+                pass
+        try:
+            rl.stop_sound(sample.source)
+            rl.unload_sound(sample.source)
+        except Exception:
+            pass
+    state.samples.clear()
+    state.entries.clear()
+    state.key_to_entry.clear()
+    state.variants.clear()
+    state.missing_keys.clear()
+    state.directory = None

grim/sfx_map.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Final
+
+# Extracted from `audio_init_sfx` (FUN_0043caa0) in `crimsonland.exe`.
+# `sfx_load_sample()` allocates the first free slot, so the load order defines stable ids.
+
+SFX_LOAD_ORDER: Final[tuple[tuple[str, str], ...]] = (
+    ("sfx_trooper_inpain_01", "trooper_inPain_01.ogg"),
+    ("sfx_trooper_inpain_02", "trooper_inPain_02.ogg"),
+    ("sfx_trooper_inpain_03", "trooper_inPain_03.ogg"),
+    ("sfx_trooper_die_01", "trooper_die_01.ogg"),
+    ("sfx_trooper_die_02", "trooper_die_02.ogg"),
+    ("sfx_trooper_die_03", "trooper_die_03.ogg"),
+    ("sfx_zombie_die_01", "zombie_die_01.ogg"),
+    ("sfx_zombie_die_02", "zombie_die_02.ogg"),
+    ("sfx_zombie_die_03", "zombie_die_03.ogg"),
+    ("sfx_zombie_die_04", "zombie_die_04.ogg"),
+    ("sfx_zombie_attack_01", "zombie_attack_01.ogg"),
+    ("sfx_zombie_attack_02", "zombie_attack_02.ogg"),
+    ("sfx_alien_die_01", "alien_die_01.ogg"),
+    ("sfx_alien_die_02", "alien_die_02.ogg"),
+    ("sfx_alien_die_03", "alien_die_03.ogg"),
+    ("sfx_alien_die_04", "alien_die_04.ogg"),
+    ("sfx_alien_attack_01", "alien_attack_01.ogg"),
+    ("sfx_alien_attack_02", "alien_attack_02.ogg"),
+    ("sfx_lizard_die_01", "lizard_die_01.ogg"),
+    ("sfx_lizard_die_02", "lizard_die_02.ogg"),
+    ("sfx_lizard_die_03", "lizard_die_03.ogg"),
+    ("sfx_lizard_die_04", "lizard_die_04.ogg"),
+    ("sfx_lizard_attack_01", "lizard_attack_01.ogg"),
+    ("sfx_lizard_attack_02", "lizard_attack_02.ogg"),
+    ("sfx_spider_die_01", "spider_die_01.ogg"),
+    ("sfx_spider_die_02", "spider_die_02.ogg"),
+    ("sfx_spider_die_03", "spider_die_03.ogg"),
+    ("sfx_spider_die_04", "spider_die_04.ogg"),
+    ("sfx_spider_attack_01", "spider_attack_01.ogg"),
+    ("sfx_spider_attack_02", "spider_attack_02.ogg"),
+    ("sfx_pistol_fire", "pistol_fire.ogg"),
+    ("sfx_pistol_reload", "pistol_reload.ogg"),
+    ("sfx_shotgun_fire", "shotgun_fire.ogg"),
+    ("sfx_shotgun_reload", "shotgun_reload.ogg"),
+    ("sfx_autorifle_fire", "autorifle_fire.ogg"),
+    ("sfx_autorifle_reload", "autorifle_reload.ogg"),
+    ("sfx_gauss_fire", "gauss_fire.ogg"),
+    ("sfx_hrpm_fire", "hrpm_fire.ogg"),
+    ("sfx_shock_fire", "shock_fire.ogg"),
+    ("sfx_plasmaminigun_fire", "plasmaMinigun_fire.ogg"),
+    ("sfx_plasmashotgun_fire", "plasmaShotgun_fire.ogg"),
+    ("sfx_pulse_fire", "pulse_fire.ogg"),
+    ("sfx_flamer_fire_01", "flamer_fire_01.ogg"),
+    ("sfx_flamer_fire_02", "flamer_fire_02.ogg"),
+    ("sfx_shock_reload", "shock_reload.ogg"),
+    ("sfx_shock_fire_alt", "shock_fire.ogg"),
+    ("sfx_shockminigun_fire", "shockMinigun_fire.ogg"),
+    ("sfx_rocket_fire", "rocket_fire.ogg"),
+    ("sfx_rocketmini_fire", "rocketmini_fire.ogg"),
+    ("sfx_autorifle_reload_alt", "autorifle_reload.ogg"),
+    ("sfx_bullet_hit_01", "bullet_hit_01.ogg"),
+    ("sfx_bullet_hit_02", "bullet_hit_02.ogg"),
+    ("sfx_bullet_hit_03", "bullet_hit_03.ogg"),
+    ("sfx_bullet_hit_04", "bullet_hit_04.ogg"),
+    ("sfx_bullet_hit_05", "bullet_hit_05.ogg"),
+    ("sfx_bullet_hit_06", "bullet_hit_06.ogg"),
+    ("sfx_shock_hit_01", "shock_hit_01.ogg"),
+    ("sfx_explosion_small", "explosion_small.ogg"),
+    ("sfx_explosion_medium", "explosion_medium.ogg"),
+    ("sfx_explosion_large", "explosion_large.ogg"),
+    ("sfx_shockwave", "shockwave.ogg"),
+    ("sfx_questhit", "questHit.ogg"),
+    ("sfx_ui_bonus", "ui_bonus.ogg"),
+    ("sfx_ui_buttonclick", "ui_buttonClick.ogg"),
+    ("sfx_ui_panelclick", "ui_panelClick.ogg"),
+    ("sfx_ui_levelup", "ui_levelUp.ogg"),
+    ("sfx_ui_typeclick_01", "ui_typeClick_01.ogg"),
+    ("sfx_ui_typeclick_02", "ui_typeClick_02.ogg"),
+    ("sfx_ui_typeenter", "ui_typeEnter.ogg"),
+    ("sfx_ui_clink_01", "ui_clink_01.ogg"),
+    ("sfx_bloodspill_01", "bloodSpill_01.ogg"),
+    ("sfx_bloodspill_02", "bloodSpill_02.ogg"),
+)
+
+SFX_KEY_ALIASES: Final[dict[str, str]] = {
+    "sfx_trooper_inpain_01_alias_0": "sfx_trooper_inpain_01",
+    "sfx_trooper_inpain_01_alias_1": "sfx_trooper_inpain_01",
+    "sfx_trooper_inpain_01_alias_2": "sfx_trooper_inpain_01",
+}
+
+# Present in `sfx.paq`, but not loaded by `audio_init_sfx` in 1.9.93 (unused or runtime-loaded).
+SFX_UNREFERENCED: Final[tuple[tuple[str, str], ...]] = (
+    ("sfx_trooper_inpain_04", "trooper_inPain_04.ogg"),
+    ("sfx_trooper_die_04", "trooper_die_04.ogg"),
+    ("sfx_flamer_fire_start", "flamer_fire_start.ogg"),
+)
+
+SFX_KEY_BY_ID: Final[tuple[str, ...]] = tuple(key for key, _entry in SFX_LOAD_ORDER)
+SFX_ID_BY_KEY: Final[dict[str, int]] = {key: idx for idx, (key, _entry) in enumerate(SFX_LOAD_ORDER)}
+
+SFX_ENTRY_BY_KEY: Final[dict[str, str]] = {
+    **{key: entry for key, entry in SFX_LOAD_ORDER},
+    **{key: entry for key, entry in SFX_UNREFERENCED},
+}
+