crimsonland 0.1.0.dev14__py3-none-any.whl → 0.1.0.dev16__py3-none-any.whl

crimson/cli.py

@@ -211,6 +211,7 @@ def cmd_game(
     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"),
+    debug: bool = typer.Option(False, "--debug", help="enable debug cheats and overlays"),
     base_dir: Path = typer.Option(
         default_runtime_dir(),
         "--base-dir",
@@ -236,6 +237,7 @@ def cmd_game(
         seed=seed,
         demo_enabled=demo,
         no_intro=no_intro,
+        debug=debug,
     )
     run_game(config)
 
@@ -372,6 +374,67 @@ def cmd_spawn_plan(
             typer.echo(f"burst x={fx.x:.1f} y={fx.y:.1f} count={fx.count}")
 
 
+@app.command("oracle")
+def cmd_oracle(
+    seed: int = typer.Option(0xBEEF, help="RNG seed for deterministic runs"),
+    input_file: Path | None = typer.Option(None, "--input-file", "-i", help="JSON file with input sequence"),
+    max_frames: int = typer.Option(36000, help="Maximum frames to run (default: 10 min at 60fps)"),
+    frame_rate: int = typer.Option(60, help="Frame rate for simulation"),
+    sample_rate: int = typer.Option(60, "--sample-rate", "-s", help="Emit state every N frames (1=every frame, 60=1/sec)"),
+    output_mode: str = typer.Option(
+        "summary",
+        "--output", "-o",
+        help="Output mode: full (all entities), summary (fast), hash (ultra-fast), checkpoints (on events only)",
+    ),
+) -> None:
+    """Run headless oracle mode for differential testing.
+
+    Emits JSON game state to stdout. Use with --seed for deterministic runs
+    and --input-file for replaying specific input sequences.
+
+    Output modes:
+      - summary: Score, kills, player pos/health (default, fast)
+      - full: All entities including creatures, projectiles, bonuses
+      - hash: SHA256 hash of full state (ultra-fast comparison)
+      - checkpoints: Emit only when score/kills/level/weapon changes
+
+    Examples:
+        # Fast validation at 1 Hz sampling
+        crimson oracle --seed 12345 -i replay.json -s 60 -o summary
+
+        # Full frame-by-frame for debugging divergence
+        crimson oracle --seed 12345 -i replay.json -s 1 -o full
+
+        # Ultra-fast hash comparison
+        crimson oracle --seed 12345 -i replay.json -o hash
+
+        # Event-driven checkpoints only
+        crimson oracle --seed 12345 -i replay.json -o checkpoints
+    """
+    from .oracle import OracleConfig, OutputMode, run_headless
+
+    # Validate output mode
+    mode_map = {
+        "full": OutputMode.FULL,
+        "summary": OutputMode.SUMMARY,
+        "hash": OutputMode.HASH,
+        "checkpoints": OutputMode.CHECKPOINTS,
+    }
+    if output_mode not in mode_map:
+        typer.echo(f"Invalid output mode: {output_mode!r}. Choose from: {', '.join(mode_map)}", err=True)
+        raise typer.Exit(code=1)
+
+    config = OracleConfig(
+        seed=seed,
+        input_file=input_file,
+        max_frames=max_frames,
+        frame_rate=frame_rate,
+        sample_rate=sample_rate,
+        output_mode=mode_map[output_mode],
+    )
+    run_headless(config)
+
+
 def main(argv: list[str] | None = None) -> None:
     app(prog_name="crimson", args=argv)
 

crimson/creatures/damage.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 import math
 from typing import Callable
 
@@ -17,6 +18,94 @@ def _owner_id_to_player_index(owner_id: int) -> int | None:
     return None
 
 
+@dataclass(slots=True)
+class _CreatureDamageCtx:
+    creature: CreatureState
+    damage: float
+    damage_type: int
+    impulse_x: float
+    impulse_y: float
+    owner_id: int
+    dt: float
+    players: list[PlayerState]
+    rand: Callable[[], int]
+    attacker: PlayerState | None
+
+
+_CreatureDamageStep = Callable[[_CreatureDamageCtx], None]
+
+
+def _damage_type1_uranium_filled_bullets(ctx: _CreatureDamageCtx) -> None:
+    if ctx.attacker is None or not perk_active(ctx.attacker, PerkId.URANIUM_FILLED_BULLETS):
+        return
+    ctx.damage *= 2.0
+
+
+def _damage_type1_living_fortress(ctx: _CreatureDamageCtx) -> None:
+    attacker = ctx.attacker
+    if attacker is None or not perk_active(attacker, PerkId.LIVING_FORTRESS):
+        return
+    for player in ctx.players:
+        if float(player.health) <= 0.0:
+            continue
+        timer = float(player.living_fortress_timer)
+        if timer > 0.0:
+            ctx.damage *= timer * 0.05 + 1.0
+
+
+def _damage_type1_barrel_greaser(ctx: _CreatureDamageCtx) -> None:
+    if ctx.attacker is None or not perk_active(ctx.attacker, PerkId.BARREL_GREASER):
+        return
+    ctx.damage *= 1.4
+
+
+def _damage_type1_doctor(ctx: _CreatureDamageCtx) -> None:
+    if ctx.attacker is None or not perk_active(ctx.attacker, PerkId.DOCTOR):
+        return
+    ctx.damage *= 1.2
+
+
+def _damage_type1_heading_jitter(ctx: _CreatureDamageCtx) -> None:
+    creature = ctx.creature
+    if (creature.flags & CreatureFlags.ANIM_PING_PONG) != 0:
+        return
+    jitter = float((int(ctx.rand()) & 0x7F) - 0x40) * 0.002
+    size = max(1e-6, float(creature.size))
+    turn = jitter / (size * 0.025)
+    turn = max(-math.pi / 2.0, min(math.pi / 2.0, turn))
+    creature.heading += turn
+
+
+def _damage_type7_ion_gun_master(ctx: _CreatureDamageCtx) -> None:
+    if ctx.attacker is None or not perk_active(ctx.attacker, PerkId.ION_GUN_MASTER):
+        return
+    ctx.damage *= 1.2
+
+
+def _damage_type4_pyromaniac(ctx: _CreatureDamageCtx) -> None:
+    if ctx.attacker is None or not perk_active(ctx.attacker, PerkId.PYROMANIAC):
+        return
+    ctx.damage *= 1.5
+    ctx.rand()
+
+
+_CREATURE_DAMAGE_ATTACKER_PRE_STEPS: dict[int, tuple[_CreatureDamageStep, ...]] = {
+    1: (
+        _damage_type1_uranium_filled_bullets,
+        _damage_type1_living_fortress,
+        _damage_type1_barrel_greaser,
+        _damage_type1_doctor,
+        _damage_type1_heading_jitter,
+    ),
+    7: (_damage_type7_ion_gun_master,),
+}
+
+
+_CREATURE_DAMAGE_ATTACKER_ALIVE_STEPS: dict[int, tuple[_CreatureDamageStep, ...]] = {
+    4: (_damage_type4_pyromaniac,),
+}
+
+
 def creature_apply_damage(
     creature: CreatureState,
     *,
@@ -44,49 +133,35 @@ def creature_apply_damage(
     player_index = _owner_id_to_player_index(owner_id)
     attacker = players[player_index] if player_index is not None and 0 <= player_index < len(players) else None
 
-    damage = float(damage_amount)
-
-    if int(damage_type) == 1 and attacker is not None:
-        if perk_active(attacker, PerkId.URANIUM_FILLED_BULLETS):
-            damage *= 2.0
-
-        if perk_active(attacker, PerkId.LIVING_FORTRESS):
-            for player in players:
-                if float(player.health) <= 0.0:
-                    continue
-                timer = float(player.living_fortress_timer)
-                if timer > 0.0:
-                    damage *= timer * 0.05 + 1.0
-
-        if perk_active(attacker, PerkId.BARREL_GREASER):
-            damage *= 1.4
-        if perk_active(attacker, PerkId.DOCTOR):
-            damage *= 1.2
-
-        if (creature.flags & CreatureFlags.ANIM_PING_PONG) == 0:
-            jitter = float((int(rand()) & 0x7F) - 0x40) * 0.002
-            size = max(1e-6, float(creature.size))
-            turn = jitter / (size * 0.025)
-            turn = max(-math.pi / 2.0, min(math.pi / 2.0, turn))
-            creature.heading += turn
-
-    if int(damage_type) == 7 and attacker is not None:
-        if perk_active(attacker, PerkId.ION_GUN_MASTER):
-            damage *= 1.2
+    ctx = _CreatureDamageCtx(
+        creature=creature,
+        damage=float(damage_amount),
+        damage_type=int(damage_type),
+        impulse_x=float(impulse_x),
+        impulse_y=float(impulse_y),
+        owner_id=int(owner_id),
+        dt=float(dt),
+        players=players,
+        rand=rand,
+        attacker=attacker,
+    )
+
+    if attacker is not None:
+        for step in _CREATURE_DAMAGE_ATTACKER_PRE_STEPS.get(ctx.damage_type, ()):
+            step(ctx)
 
     if creature.hp <= 0.0:
         if dt > 0.0:
             creature.hitbox_size -= float(dt) * 15.0
         return True
 
-    if int(damage_type) == 4 and attacker is not None:
-        if perk_active(attacker, PerkId.PYROMANIAC):
-            damage *= 1.5
-            rand()
+    if attacker is not None:
+        for step in _CREATURE_DAMAGE_ATTACKER_ALIVE_STEPS.get(ctx.damage_type, ()):
+            step(ctx)
 
-    creature.hp -= damage
-    creature.vel_x -= float(impulse_x)
-    creature.vel_y -= float(impulse_y)
+    creature.hp -= float(ctx.damage)
+    creature.vel_x -= float(ctx.impulse_x)
+    creature.vel_y -= float(ctx.impulse_y)
 
     if creature.hp <= 0.0:
         if dt > 0.0: