crimsonland 0.1.0.dev5__py3-none-any.whl

crimson/quests/__init__.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from .types import QuestContext, QuestDefinition, SpawnEntry
+from .registry import all_quests, quest_by_level
+from . import tier1, tier2, tier3, tier4, tier5
+
+__all__ = [
+    "QuestContext",
+    "QuestDefinition",
+    "SpawnEntry",
+    "all_quests",
+    "quest_by_level",
+    "tier1",
+    "tier2",
+    "tier3",
+    "tier4",
+    "tier5",
+]

crimson/quests/helpers.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+import random
+from typing import Iterator
+
+from ..creatures.spawn import SpawnId
+from .types import SpawnEntry
+
+
+@dataclass(frozen=True, slots=True)
+class EdgePoints:
+    left: tuple[float, float]
+    right: tuple[float, float]
+    top: tuple[float, float]
+    bottom: tuple[float, float]
+
+
+def center_point(width: float, height: float | None = None) -> tuple[float, float]:
+    if height is None:
+        height = width
+    return float(width) / 2.0, float(height) / 2.0
+
+
+def edge_midpoints(width: float, height: float | None = None, offset: float = 64.0) -> EdgePoints:
+    if height is None:
+        height = width
+    cx, cy = center_point(width, height)
+    return EdgePoints(
+        left=(-offset, cy),
+        right=(float(width) + offset, cy),
+        top=(cx, -offset),
+        bottom=(cx, float(height) + offset),
+    )
+
+
+def corner_points(width: float, height: float | None = None, offset: float = 64.0) -> tuple[tuple[float, float], ...]:
+    if height is None:
+        height = width
+    return (
+        (-offset, -offset),
+        (float(width) + offset, -offset),
+        (-offset, float(height) + offset),
+        (float(width) + offset, float(height) + offset),
+    )
+
+
+def iter_angles(count: int, *, step: float | None = None, start: float = 0.0) -> Iterator[float]:
+    if count <= 0:
+        return iter(())
+    if step is None:
+        step = math.tau / float(count)
+    for idx in range(count):
+        yield start + float(idx) * step
+
+
+def ring_points(
+    center_x: float,
+    center_y: float,
+    radius: float,
+    count: int,
+    *,
+    step: float | None = None,
+    start: float = 0.0,
+) -> Iterator[tuple[float, float, float]]:
+    for angle in iter_angles(count, step=step, start=start):
+        yield (
+            math.cos(angle) * radius + center_x,
+            math.sin(angle) * radius + center_y,
+            angle,
+        )
+
+
+def random_angle(rng: random.Random) -> float:
+    return float(rng.randrange(0x264)) * 0.01
+
+
+def radial_points(
+    center_x: float,
+    center_y: float,
+    angle: float,
+    radius_start: float,
+    radius_end: float,
+    radius_step: float,
+) -> Iterator[tuple[float, float]]:
+    cos_a = math.cos(angle)
+    sin_a = math.sin(angle)
+    radius = radius_start
+    while radius < radius_end:
+        yield (
+            cos_a * radius + center_x,
+            sin_a * radius + center_y,
+        )
+        radius += radius_step
+
+
+def heading_from_center(x: float, y: float, center_x: float, center_y: float) -> float:
+    return math.atan2(y - center_y, x - center_x) - (math.pi / 2.0)
+
+
+def line_points_x(start: float, step: float, count: int, y: float) -> Iterator[tuple[float, float]]:
+    for idx in range(count):
+        yield start + float(idx) * step, y
+
+
+def line_points_y(start: float, step: float, count: int, x: float) -> Iterator[tuple[float, float]]:
+    for idx in range(count):
+        yield x, start + float(idx) * step
+
+
+def spawn(
+    *,
+    x: float,
+    y: float,
+    heading: float = 0.0,
+    spawn_id: SpawnId,
+    trigger_ms: int,
+    count: int,
+) -> SpawnEntry:
+    return SpawnEntry(
+        x=x,
+        y=y,
+        heading=heading,
+        spawn_id=spawn_id,
+        trigger_ms=trigger_ms,
+        count=count,
+    )
+
+
+def spawn_at(
+    point: tuple[float, float],
+    *,
+    heading: float = 0.0,
+    spawn_id: SpawnId,
+    trigger_ms: int,
+    count: int,
+) -> SpawnEntry:
+    x, y = point
+    return spawn(
+        x=x,
+        y=y,
+        heading=heading,
+        spawn_id=spawn_id,
+        trigger_ms=trigger_ms,
+        count=count,
+    )

crimson/quests/registry.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from .types import QuestBuilder, QuestDefinition
+
+_QUESTS: dict[str, QuestDefinition] = {}
+
+
+def register_quest(
+    *,
+    level: str,
+    title: str,
+    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,
+) -> Callable[[QuestBuilder], QuestBuilder]:
+    def decorator(builder: QuestBuilder) -> QuestBuilder:
+        quest = QuestDefinition(
+            level=level,
+            title=title,
+            builder=builder,
+            time_limit_ms=time_limit_ms,
+            start_weapon_id=start_weapon_id,
+            unlock_perk_id=unlock_perk_id,
+            unlock_weapon_id=unlock_weapon_id,
+            terrain_id=terrain_id,
+            terrain_ids=terrain_ids,
+            builder_address=builder_address,
+        )
+        existing = _QUESTS.get(quest.level)
+        if existing is not None:
+            raise ValueError(f"duplicate quest level {quest.level}: {existing.builder.__name__} vs {builder.__name__}")
+        _QUESTS[quest.level] = quest
+        return builder
+
+    return decorator
+
+
+def all_quests() -> list[QuestDefinition]:
+    return sorted(_QUESTS.values(), key=lambda quest: quest.level_key)
+
+
+def quest_by_level(level: str) -> QuestDefinition | None:
+    return _QUESTS.get(level)

crimson/quests/results.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class QuestFinalTime:
+    base_time_ms: int
+    life_bonus_ms: int
+    unpicked_perk_bonus_ms: int
+    final_time_ms: int
+
+
+@dataclass(slots=True)
+class QuestResultsBreakdownAnim:
+    """Phase-based breakdown animation modeled after `quest_results_screen_update`.
+
+    The native flow animates the breakdown in four steps:
+      0) base time counts up to `base_time_ms`
+      1) life bonus counts up to `life_bonus_ms`
+      2) perk bonus counts up (in 1s steps) to `unpicked_perk_bonus_ms`
+      3) final-time highlight blink then completes
+    """
+
+    step: int = 0  # 0=base,1=life,2=perk,3=final blink,4=done
+    step_timer_ms: int = 700
+
+    base_time_ms: int = 0
+    life_bonus_ms: int = 0
+    unpicked_perk_bonus_s: int = 0
+    final_time_ms: int = 0
+
+    blink_ticks: int = 0
+    done: bool = False
+
+    @classmethod
+    def start(cls) -> "QuestResultsBreakdownAnim":
+        return cls()
+
+    def set_final(self, target: QuestFinalTime) -> None:
+        self.step = 4
+        self.done = True
+        self.step_timer_ms = 0
+        self.base_time_ms = int(target.base_time_ms)
+        self.life_bonus_ms = int(target.life_bonus_ms)
+        self.unpicked_perk_bonus_s = max(0, int(target.unpicked_perk_bonus_ms) // 1000)
+        self.final_time_ms = int(target.final_time_ms)
+        self.blink_ticks = 0
+
+    def highlight_alpha(self) -> float:
+        if self.step != 3:
+            return 1.0
+        return max(0.0, min(1.0, 1.0 - float(self.blink_ticks) * 0.1))
+
+
+def compute_quest_final_time(
+    *,
+    base_time_ms: int,
+    player_health: float,
+    pending_perk_count: int,
+    player2_health: float | None = None,
+) -> QuestFinalTime:
+    """Compute quest final time (ms) and breakdown.
+
+    Modeled after `quest_results_screen_update`:
+      final_time_ms = base_time_ms - round(player_health) - (pending_perk_count * 1000)
+      clamped to at least 1ms.
+    """
+
+    base_ms = int(base_time_ms)
+    life_bonus_ms = int(round(float(player_health)))
+    if player2_health is not None:
+        life_bonus_ms += int(round(float(player2_health)))
+
+    unpicked_perk_bonus_ms = max(0, int(pending_perk_count)) * 1000
+    final_ms = base_ms - int(life_bonus_ms) - int(unpicked_perk_bonus_ms)
+    if final_ms < 1:
+        final_ms = 1
+
+    return QuestFinalTime(
+        base_time_ms=base_ms,
+        life_bonus_ms=int(life_bonus_ms),
+        unpicked_perk_bonus_ms=int(unpicked_perk_bonus_ms),
+        final_time_ms=int(final_ms),
+    )
+
+
+def tick_quest_results_breakdown_anim(
+    anim: QuestResultsBreakdownAnim,
+    *,
+    frame_dt_ms: int,
+    target: QuestFinalTime,
+) -> int:
+    """Advance quest results breakdown animation.
+
+    Returns the number of "clink" ticks to play this frame.
+    """
+
+    if anim.done:
+        return 0
+
+    clinks = 0
+    remaining = max(0, int(frame_dt_ms))
+    if remaining <= 0:
+        return 0
+
+    base_target_ms = max(0, int(target.base_time_ms))
+    life_target_ms = max(0, int(target.life_bonus_ms))
+    perk_target_s = max(0, int(target.unpicked_perk_bonus_ms) // 1000)
+
+    while remaining > 0 and not anim.done:
+        step_timer = int(anim.step_timer_ms)
+        take = remaining if step_timer <= 0 else min(remaining, step_timer)
+        anim.step_timer_ms = int(anim.step_timer_ms) - int(take)
+        remaining -= int(take)
+
+        while anim.step_timer_ms <= 0 and not anim.done:
+            step = int(anim.step)
+            if step == 0:
+                anim.base_time_ms = min(base_target_ms, int(anim.base_time_ms) + 2000)
+                anim.final_time_ms = int(anim.base_time_ms)
+                anim.step_timer_ms += 40
+                clinks += 1
+                if int(anim.base_time_ms) >= base_target_ms:
+                    anim.step = 1
+                continue
+
+            if step == 1:
+                anim.life_bonus_ms = min(life_target_ms, int(anim.life_bonus_ms) + 1000)
+                anim.final_time_ms = max(
+                    1,
+                    base_target_ms - int(anim.life_bonus_ms) - int(anim.unpicked_perk_bonus_s) * 1000,
+                )
+                anim.step_timer_ms += 150
+                clinks += 1
+                if int(anim.life_bonus_ms) >= life_target_ms:
+                    anim.step = 2
+                continue
+
+            if step == 2:
+                anim.unpicked_perk_bonus_s = min(perk_target_s, int(anim.unpicked_perk_bonus_s) + 1)
+                anim.final_time_ms = max(
+                    1,
+                    base_target_ms - int(anim.life_bonus_ms) - int(anim.unpicked_perk_bonus_s) * 1000,
+                )
+                clinks += 1
+                if int(anim.unpicked_perk_bonus_s) >= perk_target_s:
+                    anim.final_time_ms = int(target.final_time_ms)
+                    anim.step_timer_ms += 1000
+                    anim.step = 3
+                else:
+                    anim.step_timer_ms += 300
+                continue
+
+            if step == 3:
+                anim.blink_ticks += 1
+                anim.step_timer_ms += 50
+                if int(anim.blink_ticks) > 10:
+                    anim.set_final(target)
+                continue
+
+            anim.set_final(target)
+
+    return int(clinks)

crimson/quests/runtime.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from dataclasses import replace
+import inspect
+import random
+
+from .types import QuestContext, QuestDefinition, SpawnEntry
+
+QUEST_COMPLETION_TRANSITION_MS = 1000.0
+
+
+def _call_builder(
+    builder,
+    ctx: QuestContext,
+    *,
+    rng: random.Random | None,
+    full_version: bool,
+) -> list[SpawnEntry]:
+    params = inspect.signature(builder).parameters
+    kwargs: dict[str, object] = {}
+    if "rng" in params:
+        kwargs["rng"] = rng
+    if "full_version" in params:
+        kwargs["full_version"] = bool(full_version)
+    return builder(ctx, **kwargs)
+
+
+def apply_hardcore_spawn_table_adjustment(entries: list[SpawnEntry]) -> list[SpawnEntry]:
+    """Apply quest hardcore spawn-table count adjustment.
+
+    Modeled after the quest start logic in the classic game, which bumps `SpawnEntry.count`
+    for most multi-spawn entries in hardcore mode.
+    """
+
+    adjusted: list[SpawnEntry] = []
+    for entry in entries:
+        spawn_id = int(entry.spawn_id)
+        count = int(entry.count)
+        if count > 1 and spawn_id != 0x3C:
+            if spawn_id == 0x2B:
+                count += 2
+            else:
+                count += 8
+        adjusted.append(entry if count == entry.count else replace(entry, count=count))
+    return adjusted
+
+
+def build_quest_spawn_table(
+    quest: QuestDefinition,
+    ctx: QuestContext,
+    *,
+    seed: int | None = None,
+    hardcore: bool = False,
+    full_version: bool = True,
+) -> tuple[SpawnEntry, ...]:
+    """Build the quest spawn script (with optional hardcore modifications)."""
+
+    rng = random.Random(seed) if seed is not None else random.Random()
+    entries = _call_builder(quest.builder, ctx, rng=rng, full_version=full_version)
+    if hardcore:
+        entries = apply_hardcore_spawn_table_adjustment(list(entries))
+    return tuple(entries)
+
+
+def tick_quest_completion_transition(
+    completion_transition_ms: float,
+    frame_dt_ms: float,
+    *,
+    creatures_none_active: bool,
+    spawn_table_empty: bool,
+) -> tuple[float, bool]:
+    """Advance quest completion transition timer.
+
+    The quest-mode update loop waits for a short delay after the quest is "idle complete"
+    (no active creatures + no remaining spawn table entries) before transitioning to the
+    results screen.
+
+    Returns:
+      (completion_transition_ms, completed)
+    """
+
+    dt_ms = float(frame_dt_ms)
+    timer_ms = float(completion_transition_ms)
+
+    if creatures_none_active and spawn_table_empty:
+        if timer_ms < 0.0:
+            timer_ms = 0.0
+        timer_ms += dt_ms
+        return timer_ms, bool(timer_ms >= QUEST_COMPLETION_TRANSITION_MS)
+
+    return -1.0, False