crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/quests/timeline.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from dataclasses import replace
+
+from ..creatures.spawn import SpawnTemplateCall
+
+from .types import SpawnEntry
+
+
+def tick_quest_spawn_timeline(
+    entries: tuple[SpawnEntry, ...],
+    quest_spawn_timeline_ms: float,
+    frame_dt_ms: float,
+    *,
+    terrain_width: float,
+    creatures_none_active: bool,
+    no_creatures_timer_ms: float,
+) -> tuple[tuple[SpawnEntry, ...], bool, float, tuple[SpawnTemplateCall, ...]]:
+    """Advance quest spawn-table firing (pure model of `quest_spawn_timeline_update` / 0x00434250).
+
+    Returns:
+      (updated_entries, creatures_none_active, no_creatures_timer_ms, spawn_calls)
+    """
+    timeline_ms = float(quest_spawn_timeline_ms)
+    dt_ms = float(frame_dt_ms)
+
+    if not creatures_none_active:
+        no_creatures_timer_ms = 0.0
+    else:
+        no_creatures_timer_ms += dt_ms
+
+    force_spawn = creatures_none_active and 3000.0 < no_creatures_timer_ms and 0x6A4 < timeline_ms
+
+    start_idx: int | None = None
+    for idx, entry in enumerate(entries):
+        if entry.count <= 0:
+            continue
+        if float(entry.trigger_ms) < timeline_ms or force_spawn:
+            start_idx = idx
+            break
+
+    if start_idx is None:
+        return entries, creatures_none_active, no_creatures_timer_ms, ()
+
+    spawns: list[SpawnTemplateCall] = []
+    updated_entries = list(entries)
+
+    trigger_ms = entries[start_idx].trigger_ms
+    for idx in range(start_idx, len(entries)):
+        entry = entries[idx]
+        if entry.trigger_ms != trigger_ms:
+            break
+
+        base_x = float(entry.x)
+        base_y = float(entry.y)
+        offscreen_x = base_x < 0.0 or float(terrain_width) < base_x
+
+        for spawn_idx in range(int(entry.count)):
+            magnitude = float(spawn_idx * 0x28)
+            offset = magnitude if (spawn_idx & 1) == 0 else -magnitude
+            if offscreen_x:
+                pos = (base_x, base_y + offset)
+            else:
+                pos = (base_x + offset, base_y)
+            spawns.append(SpawnTemplateCall(template_id=entry.spawn_id, pos=pos, heading=float(entry.heading)))
+
+        if entry.count != 0:
+            updated_entries[idx] = replace(entry, count=0)
+
+    # After spawning, the original forces the "none active" flag off.
+    creatures_none_active = False
+
+    return tuple(updated_entries), creatures_none_active, no_creatures_timer_ms, tuple(spawns)
+
+
+def quest_spawn_table_empty(entries: tuple[SpawnEntry, ...]) -> bool:
+    """Return True when all quest spawn entries are exhausted (count <= 0)."""
+    return all(entry.count <= 0 for entry in entries)
+
+
+def tick_quest_mode_spawns(
+    entries: tuple[SpawnEntry, ...],
+    quest_spawn_timeline_ms: float,
+    frame_dt_ms: float,
+    *,
+    terrain_width: float,
+    creatures_none_active: bool,
+    no_creatures_timer_ms: float,
+) -> tuple[tuple[SpawnEntry, ...], float, bool, float, tuple[SpawnTemplateCall, ...]]:
+    """Advance quest-mode spawning (spawn timeline + table firing).
+
+    Modeled after the spawning portion of `quest_mode_update` (0x004070e0), which:
+      - Advances `quest_spawn_timeline` unless the quest is idle-complete (no creatures active and
+        the spawn table is empty).
+      - Calls `quest_spawn_timeline_update` to fire spawn entries.
+
+    Returns:
+      (updated_entries, quest_spawn_timeline_ms, creatures_none_active, no_creatures_timer_ms, spawn_calls)
+    """
+    timeline_ms = float(quest_spawn_timeline_ms)
+    dt_ms = float(frame_dt_ms)
+
+    if (not creatures_none_active) or (not quest_spawn_table_empty(entries)):
+        timeline_ms += dt_ms
+
+    entries, creatures_none_active, no_creatures_timer_ms, spawns = tick_quest_spawn_timeline(
+        entries,
+        quest_spawn_timeline_ms=timeline_ms,
+        frame_dt_ms=dt_ms,
+        terrain_width=terrain_width,
+        creatures_none_active=creatures_none_active,
+        no_creatures_timer_ms=no_creatures_timer_ms,
+    )
+
+    return entries, timeline_ms, creatures_none_active, no_creatures_timer_ms, spawns

crimson/quests/types.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from ..creatures.spawn import SpawnId
+
+
+@dataclass(frozen=True, slots=True)
+class QuestContext:
+    width: int
+    height: int
+    player_count: int
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class SpawnEntry:
+    x: float
+    y: float
+    heading: float
+    spawn_id: SpawnId
+    trigger_ms: int
+    count: int
+
+
+QuestBuilder = Callable[..., list[SpawnEntry]]
+
+
+def terrain_ids_for(level: str) -> tuple[int, int, int]:
+    tier_text, quest_text = level.split(".", 1)
+    tier = int(tier_text)
+    quest = int(quest_text)
+    if tier <= 4:
+        base = (tier - 1) * 2
+        alt = base + 1
+        if quest < 6:
+            return base, alt, base
+        return base, base, alt
+    return quest & 0x3, 1, 3
+
+
+def terrain_id_for(level: str) -> int:
+    return terrain_ids_for(level)[0]
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class QuestDefinition:
+    level: str
+    title: str
+    builder: QuestBuilder
+    time_limit_ms: int
+    start_weapon_id: int
+    unlock_perk_id: int | None = None
+    unlock_weapon_id: int | None = None
+    terrain_id: int | None = None
+    terrain_ids: tuple[int, int, int] | None = None
+    builder_address: int | None = None
+
+    def __post_init__(self) -> None:
+        terrain_ids = self.terrain_ids
+        if terrain_ids is None:
+            terrain_ids = terrain_ids_for(self.level)
+            object.__setattr__(self, "terrain_ids", terrain_ids)
+        if self.terrain_id is None:
+            object.__setattr__(self, "terrain_id", terrain_ids[0])
+
+    @property
+    def level_key(self) -> tuple[int, int]:
+        tier_text, quest_text = self.level.split(".", 1)
+        return int(tier_text), int(quest_text)

crimson/render/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

crimson/render/terrain_fx.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+import pyray as rl
+
+from crimson.effects import FxQueue, FxQueueRotated
+from crimson.effects_atlas import effect_src_rect
+from grim.terrain_render import GroundCorpseDecal, GroundDecal, GroundRenderer
+
+__all__ = ["bake_fx_queues", "FxQueueTextures"]
+
+
+@dataclass(frozen=True, slots=True)
+class FxQueueTextures:
+    particles: rl.Texture
+    bodyset: rl.Texture
+
+
+def _clamp8(value: float) -> int:
+    if value <= 0.0:
+        return 0
+    if value >= 1.0:
+        return 255
+    return int(value * 255.0 + 0.5)
+
+
+def _rgba_to_color(rgba: tuple[float, float, float, float]) -> rl.Color:
+    return rl.Color(_clamp8(rgba[0]), _clamp8(rgba[1]), _clamp8(rgba[2]), _clamp8(rgba[3]))
+
+
+def bake_fx_queues(
+    ground: GroundRenderer,
+    *,
+    fx_queue: FxQueue,
+    fx_queue_rotated: FxQueueRotated,
+    textures: FxQueueTextures,
+    corpse_frame_for_type: Callable[[int], int],
+    corpse_shadow: bool = True,
+    clear: bool = True,
+) -> tuple[bool, bool]:
+    """Bake queued terrain FX into the ground render target (port of `fx_queue_render`)."""
+
+    decals: list[GroundDecal] = []
+    for entry in fx_queue.iter_active():
+        src = effect_src_rect(
+            entry.effect_id,
+            texture_width=float(textures.particles.width),
+            texture_height=float(textures.particles.height),
+        )
+        if src is None:
+            continue
+        decals.append(
+            GroundDecal(
+                texture=textures.particles,
+                src=rl.Rectangle(*src),
+                x=entry.pos_x,
+                y=entry.pos_y,
+                width=entry.width,
+                height=entry.height,
+                rotation_rad=entry.rotation,
+                tint=_rgba_to_color((entry.color_r, entry.color_g, entry.color_b, entry.color_a)),
+                centered=True,
+            )
+        )
+
+    corpse_decals: list[GroundCorpseDecal] = []
+    for entry in fx_queue_rotated.iter_active():
+        corpse_decals.append(
+            GroundCorpseDecal(
+                bodyset_frame=corpse_frame_for_type(entry.creature_type_id),
+                top_left_x=entry.top_left_x,
+                top_left_y=entry.top_left_y,
+                size=entry.scale,
+                rotation_rad=entry.rotation,
+                tint=_rgba_to_color((entry.color_r, entry.color_g, entry.color_b, entry.color_a)),
+            )
+        )
+
+    baked_fx = ground.bake_decals(decals)
+    baked_corpses = ground.bake_corpse_decals(textures.bodyset, corpse_decals, shadow=corpse_shadow)
+
+    if clear:
+        fx_queue.clear()
+        fx_queue_rotated.clear()
+
+    return baked_fx, baked_corpses