crimsonland 0.1.0.dev15__tar.gz → 0.1.0.dev16__tar.gz

{crimsonland-0.1.0.dev15 → crimsonland-0.1.0.dev16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: crimsonland
-Version: 0.1.0.dev15
+Version: 0.1.0.dev16
 Requires-Dist: construct>=2.10.70
 Requires-Dist: pillow>=12.1.0
 Requires-Dist: platformdirs>=4.5.1

{crimsonland-0.1.0.dev15 → crimsonland-0.1.0.dev16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crimsonland"
-version = "0.1.0.dev15"
+version = "0.1.0.dev16"
 readme = { file = "readme.md", content-type = "text/markdown" }
 requires-python = ">=3.13"
 dependencies = [

{crimsonland-0.1.0.dev15 → crimsonland-0.1.0.dev16}/src/crimson/cli.py

@@ -374,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)
 

crimsonland-0.1.0.dev16/src/crimson/creatures/damage.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+from typing import Callable
+
+from ..gameplay import PlayerState, perk_active
+from ..perks import PerkId
+from .runtime import CREATURE_HITBOX_ALIVE, CreatureState
+from .spawn import CreatureFlags
+
+
+def _owner_id_to_player_index(owner_id: int) -> int | None:
+    if owner_id == -100:
+        return 0
+    if owner_id < 0:
+        return -1 - owner_id
+    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,
+    *,
+    damage_amount: float,
+    damage_type: int,
+    impulse_x: float,
+    impulse_y: float,
+    owner_id: int,
+    dt: float,
+    players: list[PlayerState],
+    rand: Callable[[], int],
+) -> bool:
+    """Apply damage to a creature, returning True if the hit killed it.
+
+    This is a partial port of `creature_apply_damage` (FUN_004207c0).
+
+    Notes:
+    - Death side-effects are handled by the caller (see Phase 2 in `plan.md`).
+    - `damage_type` is a native integer category; call sites must supply it.
+    """
+
+    creature.last_hit_owner_id = int(owner_id)
+    creature.hit_flash_timer = 0.2
+
+    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
+
+    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 attacker is not None:
+        for step in _CREATURE_DAMAGE_ATTACKER_ALIVE_STEPS.get(ctx.damage_type, ()):
+            step(ctx)
+
+    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:
+            creature.hitbox_size = float(creature.hitbox_size) - float(dt)
+        else:
+            creature.hitbox_size = float(creature.hitbox_size) - 0.001
+        creature.vel_x -= float(impulse_x) * 2.0
+        creature.vel_y -= float(impulse_y) * 2.0
+        return True
+
+    if creature.hitbox_size != CREATURE_HITBOX_ALIVE and dt > 0.0:
+        creature.hitbox_size = CREATURE_HITBOX_ALIVE
+
+    return False