//! SDL-independent fixed-step simulation and checked mod command application.
use crate::{
    content::{ContentId, Registry, Target, WeaponBehavior},
    modding::{Command, ScriptRuntime},
    persistence::Pilot,
};
use anyhow::{Context, Result, ensure};
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

pub const TICK_NUMERATOR: u64 = 3;
pub const TICK_DENOMINATOR: u64 = 70;
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub struct LegacyRng {
    pub seed: i32,
}
impl LegacyRng {
    pub fn new(seed: i32) -> Self {
        Self { seed }
    }
    pub fn next_value(&mut self) -> i32 {
        self.seed = self.seed.wrapping_mul(1103515245).wrapping_add(12345);
        (self.seed >> 16) & 0x7fff
    }
}
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
pub struct Input {
    pub dx: i32,
    pub dy: i32,
    pub fire: bool,
    pub special: bool,
    pub cycle: bool,
    pub bomb: bool,
    pub absolute: Option<[i32; 2]>,
    pub demo_bank: Option<i32>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LineMove {
    pub x: i32,
    pub y: i32,
    pub tx: i32,
    pub ty: i32,
    pub dx: i32,
    pub dy: i32,
    pub ax: i32,
    pub ay: i32,
    pub error: i32,
    pub remaining: i32,
    pub done: bool,
}
impl LineMove {
    pub fn new(x: i32, y: i32, tx: i32, ty: i32) -> Self {
        let dx = (tx - x).abs();
        let dy = (ty - y).abs();
        let mut m = Self {
            x,
            y,
            tx,
            ty,
            dx,
            dy,
            ax: if tx < x { -1 } else { 1 },
            ay: if ty < y { -1 } else { 1 },
            error: if dx >= dy { -(dy >> 1) } else { dx >> 1 },
            remaining: dx.max(dy) + 1,
            done: false,
        };
        if dx == 0 && dy == 0 {
            m.done = true;
        }
        m
    }
    pub fn initial(&mut self) {
        if self.remaining == 0 {
            self.done = true;
            return;
        }
        self.point();
        self.remaining -= 1;
    }
    fn point(&mut self) {
        if self.dx >= self.dy {
            self.x += self.ax;
            self.error += self.dy;
            if self.error > 0 {
                self.y += self.ay;
                self.error -= self.dx;
            }
        } else {
            self.y += self.ay;
            self.error += self.dx;
            if self.error > 0 {
                self.x += self.ax;
                self.error -= self.dy;
            }
        }
    }
    pub fn advance_shot(&mut self, speed: i32) {
        // MoveSobj crosses the endpoint before marking done; enemies instead stop at it.
        for _ in 0..speed.max(0) {
            self.remaining -= 1;
            self.point();
        }
        if self.remaining < 1 {
            self.done = true;
        }
    }
    pub fn advance(&mut self, speed: i32) -> i32 {
        if self.done {
            return speed;
        }
        let mut left = speed;
        while left > 0 {
            left -= 1;
            self.remaining -= 1;
            if self.remaining == 0 {
                self.done = true;
                return left;
            }
            if self.dx >= self.dy {
                self.x += self.ax;
                self.error += self.dy;
                if self.error > 0 {
                    self.y += self.ay;
                    self.error -= self.dx;
                }
            } else {
                self.y += self.ay;
                self.error += self.dx;
                if self.error > 0 {
                    self.x += self.ax;
                    self.error -= self.dy;
                }
            }
        }
        left
    }
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Player {
    pub x: i32,
    pub y: i32,
    pub px: i32,
    pub py: i32,
    pub bank: i32,
    pub shield: i32,
    pub super_shield: i32,
    #[serde(default)]
    pub super_shield_reserves: Vec<u32>,
    pub credits: u32,
    pub inventory: BTreeMap<ContentId, u32>,
    pub selected: Option<ContentId>,
    pub vx: i32,
    pub vy: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Enemy {
    pub entity: u64,
    pub definition: ContentId,
    pub x: i32,
    pub y: i32,
    pub px: i32,
    pub py: i32,
    pub sx: i32,
    pub sy: i32,
    pub width: i32,
    pub height: i32,
    pub health: i32,
    pub age: u32,
    pub cooldown: u32,
    pub path_index: usize,
    pub reversed: bool,
    pub movement: LineMove,
    pub frame: u32,
    pub art_frame: u32,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub pinned_art_frame: Option<u32>,
    pub animation_on: bool,
    pub animation_frames: u32,
    pub multi: u32,
    pub frame_timer: i32,
    pub countdown: i32,
    pub shoot_on: bool,
    pub shootagain: i32,
    pub shootcount: i32,
    pub shootflag: i32,
    #[serde(default)]
    pub energy_resistance: i32,
    #[serde(default)]
    pub shoot_disabled: bool,
    pub kami: u32,
    pub vx: i32,
    pub vy: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LegacyProjectile {
    pub movement: LineMove,
    pub speed: i32,
    pub frame: u32,
    pub art_frame: u32,
    pub delay: bool,
    pub hit: bool,
    pub start: [i32; 2],
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EnemyProjectile {
    pub movement: LineMove,
    pub kind: i16,
    pub asset: u32,
    pub frames: u32,
    pub frame: u32,
    pub art_frame: u32,
    pub speed: i32,
    pub maximum_speed: i32,
    pub damage: i32,
    pub position: usize,
    pub enemy: u64,
    pub gun: usize,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Projectile {
    pub entity: u64,
    pub weapon: ContentId,
    pub x: i32,
    pub y: i32,
    pub px: i32,
    pub py: i32,
    pub vx: i32,
    pub vy: i32,
    pub hostile: bool,
    pub age: u32,
    pub legacy: Option<LegacyProjectile>,
    pub legacy_enemy: Option<EnemyProjectile>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Pickup {
    pub entity: u64,
    pub item: ContentId,
    pub x: i32,
    pub y: i32,
    pub legacy: Option<LegacyPickup>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LegacyPickup {
    pub x: i32,
    pub y: i32,
    pub position: usize,
    pub frame: u32,
    pub art_frame: u32,
    pub countdown: Option<u32>,
    #[serde(skip)]
    pub glow_frame: u32,
    #[serde(skip)]
    pub previous_art_position: Option<[i32; 2]>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Effect {
    pub x: i32,
    pub y: i32,
    pub px: i32,
    pub py: i32,
    pub age: u32,
    pub kind: EffectKind,
    pub ground: bool,
}
/// Secondary native animations are presentation only. Keeping their queue out
/// of saved/replayed gameplay state also prevents render rates affecting RNG.
#[derive(Debug, Clone)]
pub struct VisualEffect {
    pub x: i32,
    pub y: i32,
    pub px: i32,
    pub py: i32,
    pub age: u32,
    pub kind: VisualEffectKind,
    pub anchor: Option<u64>,
    pub offset: [i32; 2],
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VisualEffectKind {
    LaserImpact,
    SmallAir,
    SmallGround,
    GroundBlueSpark,
    GroundOrangeSpark,
    GroundSparkle,
    GroundFlare,
    SmokeDown,
    SmokeTrail,
    BlueSpark,
    OrangeSpark,
    EnergyGrab,
    Muzzle,
    Casing,
    Shield,
}
impl VisualEffectKind {
    pub fn artwork(self) -> (u32, u32) {
        match self {
            Self::LaserImpact => (0x10229, 4),
            Self::SmallAir => (0x101fc, 14),
            Self::SmallGround => (0x1027d, 35),
            Self::GroundBlueSpark => (0x1019c, 9),
            Self::GroundOrangeSpark => (0x101a5, 9),
            Self::GroundSparkle => (0x1026c, 17),
            Self::GroundFlare => (0x10252, 26),
            Self::SmokeDown => (0x1020e, 5),
            Self::SmokeTrail => (0x1022d, 4),
            Self::BlueSpark => (0x1019c, 9),
            Self::OrangeSpark => (0x101a5, 9),
            Self::EnergyGrab => (0x1018e, 14),
            Self::Muzzle | Self::Casing => (0x101c7, 4),
            Self::Shield => (0x10249, 4),
        }
    }
    /// ANIMS_DisplayGround, ANIMS_DisplaySky, ANIMS_DisplayHigh order.
    pub fn layer(self) -> u8 {
        match self {
            Self::Casing
            | Self::SmallGround
            | Self::GroundBlueSpark
            | Self::GroundOrangeSpark
            | Self::GroundSparkle
            | Self::GroundFlare => 0,
            Self::SmokeDown | Self::BlueSpark | Self::OrangeSpark | Self::Muzzle => 1,
            Self::LaserImpact
            | Self::SmallAir
            | Self::SmokeTrail
            | Self::EnergyGrab
            | Self::Shield => 2,
        }
    }
    pub fn lighting_mask(self) -> bool {
        matches!(self, Self::SmokeDown | Self::SmokeTrail | Self::Shield)
    }
    pub fn top_left(self) -> bool {
        matches!(self, Self::GroundBlueSpark | Self::GroundOrangeSpark)
    }
}
impl VisualEffect {
    pub fn new(kind: VisualEffectKind, x: i32, y: i32) -> Self {
        Self {
            x,
            y,
            px: x,
            py: y,
            age: 0,
            kind,
            anchor: None,
            offset: [x, y],
        }
    }
    fn attached(mut self, entity: u64) -> Self {
        self.anchor = Some(entity);
        self
    }
}
fn visual_effect(existing: usize, effects: &mut Vec<VisualEffect>, effect: VisualEffect) {
    if effects.len() + existing < 100 {
        effects.push(effect);
    }
}
/// Presentation-only lightning, with a lifetime measured in simulation ticks.
/// The queue is excluded from saved gameplay state and the deterministic digest.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LightningArc {
    pub x: i32,
    pub y: i32,
    pub to_x: i32,
    pub to_y: i32,
    pub ticks: u32,
    pub age: u32,
    /// Cosmetic variation between discharges, without advancing gameplay RNG.
    pub seed: u32,
    pub anchor: Option<LightningAnchor>,
    pub to_anchor: Option<LightningAnchor>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct LightningAnchor {
    pub entity: u64,
    /// Endpoint displacement from the entity's top-left origin at creation.
    pub offset: [i32; 2],
}
pub const MAX_LIGHTNING_ARCS: usize = 256;
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum EffectKind {
    GroundBlast,
    SmallGround,
    LargeAir,
    MediumAir,
    SmallAir,
    AirBlast,
    Energy,
    Person,
    Platoon,
    Flare,
    Sparkle,
}
impl EffectKind {
    pub fn artwork(self) -> (u32, u32) {
        match self {
            Self::GroundBlast => (0x10164, 42),
            Self::SmallGround => (0x1027d, 35),
            Self::LargeAir => (0x101e5, 12),
            Self::MediumAir => (0x101d8, 13),
            Self::SmallAir => (0x101fc, 14),
            Self::AirBlast => (0x102a0, 16),
            Self::Energy => (0x101ae, 12),
            Self::Person => (0x101f5, 7),
            Self::Platoon => (0x10213, 10),
            Self::Flare => (0x10252, 26),
            Self::Sparkle => (0x1026c, 17),
        }
    }
}
impl Effect {
    fn new(kind: EffectKind, x: i32, y: i32) -> Self {
        Self {
            x,
            y,
            px: x,
            py: y,
            age: 0,
            kind,
            ground: matches!(
                kind,
                EffectKind::GroundBlast
                    | EffectKind::SmallGround
                    | EffectKind::MediumAir
                    | EffectKind::Person
                    | EffectKind::Platoon
                    | EffectKind::Flare
                    | EffectKind::Sparkle
            ),
        }
    }
    fn airborne(mut self) -> Self {
        self.ground = false;
        self
    }
}
fn original_effect(existing: usize, effects: &mut Vec<Effect>, effect: Effect) {
    if effects.len() + existing < 100 {
        effects.push(effect);
    }
}
fn death_effects(
    visual_count: usize,
    effects: &mut Vec<Effect>,
    rng: &mut LegacyRng,
    enemy: &Enemy,
    explosion: i32,
) {
    use EffectKind::*;
    let cx = enemy.x + enemy.width / 2;
    let cy = enemy.y + enemy.height / 2;
    let main = match explosion {
        0 => MediumAir,
        1 | 2 | 6 => LargeAir,
        3 => SmallGround,
        4 | 5 => GroundBlast,
        7 => Person,
        8 => Energy,
        9 => Platoon,
        _ => AirBlast,
    };
    if explosion == 4 {
        let x = enemy.x + rng.next_value() % enemy.width.max(1);
        let y = enemy.y + rng.next_value() % enemy.height.max(1);
        let kind = if rng.next_value() % 2 == 0 {
            Sparkle
        } else {
            Flare
        };
        original_effect(visual_count, effects, Effect::new(kind, x, y));
    }
    original_effect(visual_count, effects, Effect::new(main, cx, cy));
    if matches!(explosion, 2 | 5 | 6) {
        let area = (enemy.width >> 4) * (enemy.height >> 4);
        for n in 0..area {
            let x = enemy.x + rng.next_value() % enemy.width.max(1);
            let y = enemy.y + rng.next_value() % enemy.height.max(1);
            if explosion == 5 {
                let kind = if rng.next_value() % 2 == 0 {
                    Flare
                } else {
                    Sparkle
                };
                original_effect(visual_count, effects, Effect::new(kind, x, y));
                original_effect(visual_count, effects, Effect::new(SmallGround, x, y));
            } else if explosion == 6 {
                original_effect(visual_count, effects, Effect::new(Flare, x, y).airborne());
                original_effect(
                    visual_count,
                    effects,
                    Effect::new(if n & 1 != 0 { LargeAir } else { AirBlast }, x, y),
                );
            } else {
                let effect = if n & 1 != 0 {
                    Effect::new(MediumAir, x, y)
                } else {
                    Effect::new(AirBlast, x, y).airborne()
                };
                original_effect(visual_count, effects, effect);
            }
        }
    }
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum Outcome {
    Playing,
    Complete,
    Failed,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SoundEvent {
    pub asset: u32,
    pub pan: i32,
    pub pitch: i32,
    pub volume: i32,
    pub priority: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TerrainDelay {
    pub position: usize,
    pub frames: i32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct World {
    pub tick: u64,
    pub mission: ContentId,
    pub player: Player,
    pub enemies: Vec<Enemy>,
    pub projectiles: Vec<Projectile>,
    pub pickups: Vec<Pickup>,
    pub effects: Vec<Effect>,
    #[serde(skip)]
    pub visual_effects: Vec<VisualEffect>,
    #[serde(skip)]
    pub lightning_arcs: Vec<LightningArc>,
    #[serde(skip)]
    terrain_spark_delay: u32,
    #[serde(skip)]
    terrain_flare_delay: u32,
    pub terrain_health: Vec<i32>,
    pub terrain_dead: Vec<bool>,
    pub terrain_settled: Vec<bool>,
    pub terrain_delays: Vec<TerrainDelay>,
    pub rng: LegacyRng,
    pub difficulty: u32,
    pub outcome: Outcome,
    pub end_timer: Option<u32>,
    #[serde(default)]
    pub legacy_transition: bool,
    #[serde(default = "visible_player")]
    pub draw_player: bool,
    #[serde(default)]
    pub control_paused: bool,
    #[serde(default)]
    pub departure_delta: [i32; 2],
    pub scroll: i32,
    pub objectives: BTreeMap<String, i32>,
    pub sounds: Vec<u32>,
    pub sound_events: Vec<SoundEvent>,
    pub mod_sounds: Vec<ContentId>,
    pub cooldowns: BTreeMap<ContentId, u32>,
    pub next_entity: u64,
    pub spawn_cursor: usize,
    pub cycle_held: bool,
    pub bomb_held: bool,
    pub palette_blue: bool,
    pub special_held: bool,
    pub player_flash: bool,
    #[serde(default = "initial_shield_latch")]
    pub previous_shield: i32,
    #[serde(default)]
    pub shield_recharge_ticks: u32,
    /// Charge retained from a save whose equipment capacity changed. It does
    /// not increase the original 100-point combat shield.
    #[serde(default, skip_serializing_if = "is_zero")]
    pub energy_overflow: u32,
    #[serde(default, skip_serializing_if = "is_zero")]
    pub super_shield_overflow: u32,
    #[serde(skip)]
    pub events: Vec<HookEvent>,
}
#[derive(Debug, Clone)]
pub struct HookEvent {
    pub content: ContentId,
    pub hook: &'static str,
    pub event: serde_json::Value,
}
impl World {
    pub fn new(mission: &ContentId, pilot: &Pilot, registry: &Registry) -> Result<Self> {
        let m = registry.missions.get(mission).context("unknown mission")?;
        let energy = pilot
            .inventory
            .get(&ContentId::from("base:energy"))
            .copied()
            .unwrap_or(100) as i32;
        let super_shield = pilot
            .inventory
            .get(&ContentId::from("base:super_shield"))
            .copied()
            .unwrap_or(0);
        let wave = mission
            .0
            .rsplit('_')
            .next()
            .and_then(|s| s.parse::<i32>().ok())
            .unwrap_or(1)
            - 1;
        let mut out = Self {
            tick: 0,
            mission: mission.clone(),
            player: Player {
                x: 144,
                y: 160,
                px: 144,
                py: 160,
                bank: 3,
                shield: energy.clamp(1, 100),
                super_shield: super_shield.min(100) as i32,
                super_shield_reserves: pilot.super_shield_reserves.clone(),
                credits: pilot.credits,
                inventory: pilot.inventory.clone(),
                selected: pilot.selected.clone(),
                vx: 0,
                vy: 0,
            },
            enemies: vec![],
            projectiles: vec![],
            pickups: vec![],
            effects: vec![],
            visual_effects: vec![],
            lightning_arcs: vec![],
            terrain_spark_delay: 0,
            terrain_flare_delay: 0,
            terrain_health: m.layout.iter().map(|i| m.tiles[*i].health).collect(),
            terrain_dead: vec![false; m.layout.len()],
            terrain_settled: vec![false; m.layout.len()],
            terrain_delays: vec![],
            rng: LegacyRng::new(wave << 10),
            difficulty: pilot.difficulty,
            outcome: Outcome::Playing,
            end_timer: None,
            legacy_transition: m.legacy_map.is_some(),
            draw_player: true,
            control_paused: false,
            departure_delta: [0, 0],
            scroll: 0,
            objectives: BTreeMap::new(),
            sounds: vec![],
            sound_events: vec![],
            mod_sounds: vec![],
            cooldowns: BTreeMap::new(),
            next_entity: 1,
            spawn_cursor: 0,
            cycle_held: false,
            bomb_held: false,
            palette_blue: false,
            special_held: false,
            player_flash: false,
            previous_shield: initial_shield_latch(),
            shield_recharge_ticks: pilot.shield_recharge_ticks,
            energy_overflow: (energy.max(0) as u32).saturating_sub(100),
            super_shield_overflow: super_shield.saturating_sub(100),
            events: vec![],
        };
        out.event(
            mission.clone(),
            "on_mission_start",
            serde_json::json!({"tick":0}),
        );
        Ok(out)
    }
    pub fn pilot(&self, prior: &Pilot) -> Pilot {
        let mut p = prior.clone();
        p.credits = self.player.credits;
        p.inventory = self.player.inventory.clone();
        p.super_shield_reserves = self.player.super_shield_reserves.clone();
        p.shield_recharge_ticks = self.shield_recharge_ticks;
        p.inventory.insert(
            "base:energy".into(),
            (self.player.shield.max(0) as u32)
                .saturating_add(self.energy_overflow)
                .max(1),
        );
        if p.inventory
            .contains_key(&ContentId::from("base:super_shield"))
        {
            p.inventory.insert(
                "base:super_shield".into(),
                (self.player.super_shield.max(0) as u32).saturating_add(self.super_shield_overflow),
            );
        }
        p.selected = self.player.selected.clone();
        p.mission = self.mission.clone();
        p
    }
    fn sync_retained_inventory(&mut self) {
        if self.energy_overflow > 0 {
            if let Some(charge) = self
                .player
                .inventory
                .get_mut(&ContentId::from("base:energy"))
            {
                *charge = (self.player.shield.max(0) as u32).saturating_add(self.energy_overflow);
            }
        }
        if self.super_shield_overflow > 0 {
            if let Some(charge) = self
                .player
                .inventory
                .get_mut(&ContentId::from("base:super_shield"))
            {
                *charge = (self.player.super_shield.max(0) as u32)
                    .saturating_add(self.super_shield_overflow);
            } else {
                self.super_shield_overflow = 0;
            }
        }
    }
    fn entity(&mut self) -> u64 {
        let n = self.next_entity;
        self.next_entity += 1;
        n
    }
    fn event(&mut self, content: ContentId, hook: &'static str, event: serde_json::Value) {
        self.events.push(HookEvent {
            content,
            hook,
            event,
        });
    }
    pub fn spawn(&mut self, id: &ContentId, x: i32, y: i32, registry: &Registry) -> Result<u64> {
        let e = registry.enemies.get(id).context("unknown enemy")?;
        ensure!(self.enemies.len() < 4096, "enemy capacity exceeded");
        let entity = self.entity();
        let (w, h) = e
            .art
            .as_ref()
            .map(|a| (a.logical_width as i32, a.logical_height as i32))
            .unwrap_or((32, 32));
        let f = e.legacy.as_ref().map(|l| &l.fields);
        let x = match f.map(|f| f[21]) {
            Some(4) => x + w,
            Some(5) => x - w,
            _ => x,
        };
        let sx = x;
        let sy = if f.is_some() { 100 - h / 2 } else { y };
        let first = e.path.first().copied().unwrap_or([0, 300]);
        let mut movement = LineMove::new(x, y, sx + first[0], sy + first[1]);
        if f.is_some() && !e.ground {
            movement.initial();
        }
        let health = if e.boss && self.difficulty <= 1 {
            e.health - (e.health >> 1)
        } else {
            e.health
        };
        self.enemies.push(Enemy {
            entity,
            definition: id.clone(),
            x,
            y,
            px: x,
            py: y,
            sx,
            sy,
            width: w,
            height: h,
            health,
            age: 0,
            cooldown: 0,
            path_index: 1,
            reversed: false,
            movement,
            frame: 0,
            art_frame: 0,
            pinned_art_frame: None,
            animation_on: f.is_none_or(|f| f[10] != 1),
            animation_frames: f.map_or(1, |f| if f[10] == 2 { f[9] } else { f[7] }.max(1) as u32),
            multi: 0,
            frame_timer: f.map_or(0, |f| f[6]),
            countdown: f.map_or(0, |f| f[8] - y),
            shoot_on: false,
            shootagain: -1,
            shootcount: f.map_or(1, |f| {
                if e.boss && self.difficulty <= 1 {
                    f[16] - (f[16] >> 2)
                } else {
                    f[16]
                }
            }),
            shootflag: f.map_or(0, |f| f[15]),
            energy_resistance: f.map_or(0, |f| f[13] >> 4),
            shoot_disabled: false,
            kami: 0,
            vx: 0,
            vy: 0,
        });
        self.event(
            id.clone(),
            "on_spawn",
            serde_json::json!({"entity":entity,"x":x,"y":y}),
        );
        Ok(entity)
    }
    fn projectile(
        &mut self,
        id: &ContentId,
        x: i32,
        y: i32,
        vx: i32,
        vy: i32,
        hostile: bool,
    ) -> Result<()> {
        ensure!(
            self.projectiles.len() < 8192,
            "projectile capacity exceeded"
        );
        let entity = self.entity();
        self.projectiles.push(Projectile {
            entity,
            weapon: id.clone(),
            x,
            y,
            px: x,
            py: y,
            vx,
            vy,
            hostile,
            age: 0,
            legacy: None,
            legacy_enemy: None,
        });
        Ok(())
    }
    pub fn step(
        &mut self,
        input: Input,
        registry: &Registry,
        scripts: &mut ScriptRuntime,
    ) -> Result<()> {
        if self.outcome != Outcome::Playing {
            return Ok(());
        }
        scripts.begin_tick();
        let checkpoint = self.clone();
        let script_checkpoint = scripts.checkpoints();
        let result = self
            .advance(input, registry)
            .and_then(|_| self.dispatch(registry, scripts));
        if let Err(err) = result {
            *self = checkpoint;
            scripts.restore(script_checkpoint);
            return Err(err);
        }
        Ok(())
    }
    fn advance(&mut self, input: Input, registry: &Registry) -> Result<()> {
        self.sounds.clear();
        self.sound_events.clear();
        self.mod_sounds.clear();
        self.player_flash = false;
        self.player.px = self.player.x;
        self.player.py = self.player.y;
        let input = if self.legacy_transition && self.control_paused && input.demo_bank.is_none() {
            Input::default()
        } else {
            input
        };
        let ending = self.legacy_transition && self.end_timer.is_some();
        if self.legacy_transition && self.control_paused && input.demo_bank.is_none() {
            self.player.x += self.departure_delta[0];
            self.player.y += self.departure_delta[1];
        } else if let Some([x, y]) = input.absolute {
            // Legacy demo playback writes recorded positions directly; the
            // normal input boundary correction is bypassed by DEMO_GetNext.
            self.player.x = if input.demo_bank.is_some() || ending {
                x
            } else {
                x.clamp(5, 282)
            };
            self.player.y = if input.demo_bank.is_some() || ending {
                y
            } else {
                y.clamp(0, 160)
            };
        } else {
            self.player.vx = accelerate(self.player.vx, input.dx, 10);
            self.player.vy = accelerate(self.player.vy, input.dy, 8);
            self.player.x += self.player.vx;
            self.player.y += self.player.vy;
            if !ending {
                self.player.x = self.player.x.clamp(5, 282);
                self.player.y = self.player.y.clamp(0, 160);
            }
        }
        let delta = ((self.player.x - self.player.px).abs() >> 2).min(3);
        if let Some(bank) = input.demo_bank {
            self.player.bank = bank.clamp(0, 6);
        } else if self.player.x < self.player.px {
            if self.player.bank < 3 + delta {
                self.player.bank += 1;
            }
        } else if self.player.x > self.player.px {
            if self.player.bank > 3 - delta {
                self.player.bank -= 1;
            }
        } else {
            self.player.bank += (3 - self.player.bank).signum();
        }
        let mut equipment_used = false;
        if input.fire {
            let mut weapons: Vec<_> = self
                .player
                .inventory
                .iter()
                .filter_map(|(id, n)| {
                    if *n > 0 {
                        registry
                            .items
                            .get(id)
                            .filter(|i| !i.special && i.legacy != Some(11))
                            .and_then(|i| i.weapon.clone())
                    } else {
                        None
                    }
                })
                .chain(
                    self.player
                        .selected
                        .as_ref()
                        .and_then(|id| registry.items.get(id))
                        .and_then(|i| i.weapon.clone()),
                )
                .collect();
            weapons.sort_by_key(|id| (registry.weapons[id].legacy.unwrap_or(u32::MAX), id.clone()));
            // Original primary weapons fire in numeric order, followed by the selected special.
            if let Some(selected) = self
                .player
                .selected
                .as_ref()
                .and_then(|id| registry.items.get(id))
                .and_then(|i| i.weapon.as_ref())
            {
                weapons.retain(|id| id != selected);
                weapons.push(selected.clone());
            }
            equipment_used |= !weapons.is_empty();
            for id in weapons {
                self.fire(&id, registry)?;
            }
        }
        if input.special {
            if let Some(id) = self.player.selected.clone() {
                if let Some(item) = registry.items.get(&id) {
                    equipment_used |= self.player.inventory.get(&id).is_some_and(|n| *n > 0);
                    if let Some(weapon) = item.weapon.as_ref() {
                        self.fire(weapon, registry)?;
                    } else if !self.special_held
                        && self.player.inventory.get(&id).copied().unwrap_or(0) > 0
                    {
                        if item.consumable {
                            *self.player.inventory.get_mut(&id).unwrap() -= 1;
                            if self.player.inventory[&id] == 0 {
                                self.player.selected = None;
                            }
                        }
                        self.player.shield = (self.player.shield + item.shield).clamp(0, 100);
                        self.player.credits = self.player.credits.saturating_add(item.credits);
                        self.event(id,"on_use",serde_json::json!({"entity":0,"x":self.player.x,"y":self.player.y,"tick":self.tick}));
                    }
                }
            }
        }
        self.special_held = input.special;
        if input.cycle && !self.cycle_held {
            play_legacy_sound(
                &mut self.rng,
                &mut self.sounds,
                &mut self.sound_events,
                "FX_SWEP",
            );
            self.player.selected = next_special(&self.player, registry);
        }
        self.cycle_held = input.cycle;
        if input.bomb && !self.bomb_held {
            let id = ContentId::from("base:mega_bomb");
            if self.player.inventory.get(&id).copied().unwrap_or(0) > 0 {
                equipment_used = true;
                if let Some(weapon) = registry.items.get(&id).and_then(|i| i.weapon.clone()) {
                    let before = self.projectiles.len();
                    self.fire(&weapon, registry)?;
                    if self.projectiles.len() > before {
                        *self.player.inventory.get_mut(&id).unwrap() -= 1;
                    }
                }
            }
        }
        self.bomb_held = input.bomb;
        // Do_Game decrements startendwave after input, before world updates.
        // At zero it still performs one final simulation/statistics pass.
        let transition_finished = self.legacy_transition && self.end_timer == Some(0);
        if self.legacy_transition {
            self.end_timer = self.end_timer.and_then(|timer| timer.checked_sub(1));
        }
        let mission = &registry.missions[&self.mission];
        let previous_scroll = self.scroll;
        self.scroll += 1;
        if mission.legacy_map.is_some() {
            let rows = mission.layout.len() / mission.columns.max(1) as usize;
            self.scroll = self.scroll.min(rows.saturating_sub(8) as i32 * 32 + 56);
        }
        self.think_legacy_terrain(registry);
        while self.spawn_cursor < mission.spawns.len()
            && mission.spawns[self.spawn_cursor].tick <= self.tick
        {
            let spawn = &mission.spawns[self.spawn_cursor];
            let enabled = if mission.legacy_map.is_some() {
                match spawn.difficulty {
                    3 => true,
                    4 => self.difficulty >= 2,
                    5 => self.difficulty >= 3,
                    _ => false,
                }
            } else {
                self.difficulty >= spawn.difficulty
            };
            if enabled {
                let (x, y) = if mission.legacy_map.is_some() {
                    let art = registry.enemies[&spawn.enemy].art.as_ref().unwrap();
                    (
                        spawn.x + 16 - art.logical_width as i32 / 2,
                        spawn.y - art.logical_height as i32 / 2,
                    )
                } else {
                    (spawn.x, spawn.y)
                };
                self.spawn(&spawn.enemy, x, y, registry)?;
            }
            self.spawn_cursor += 1;
        }
        // Ground/air enemy updates precede hostile shots, bonuses and player shots.
        let mut shots = Vec::new();
        let mut retired = Vec::new();
        let mut events = Vec::new();
        for enemy in &mut self.enemies {
            let def = &registry.enemies[&enemy.definition];
            enemy.px = enemy.x;
            enemy.py = enemy.y;
            enemy.age += 1;
            if enemy.vx != 0 || enemy.vy != 0 {
                enemy.x += enemy.vx;
                enemy.y += enemy.vy;
            } else if def.ground {
                enemy.y += 1;
                if let Some(l) = &def.legacy {
                    match l.fields[21] {
                        4 if enemy.y >= 0 => enemy.x -= def.speed,
                        5 if enemy.y >= 0 => enemy.x += def.speed,
                        _ => {}
                    }
                }
            } else {
                enemy.x = enemy.movement.x;
                enemy.y = enemy.movement.y;
                let kamikaze = def.legacy.as_ref().is_some_and(|l| l.fields[21] == 2);
                let terminal_kami = kamikaze && enemy.kami == 2;
                // MoveEobj keeps a terminal kamikaze moving past its target
                // on subsequent steps; ordinary paths stop and retarget.
                let left = if terminal_kami && enemy.movement.done {
                    enemy.movement.advance_shot(def.speed);
                    0
                } else {
                    enemy.movement.advance(def.speed)
                };
                if terminal_kami {
                    if enemy.movement.y > 201
                        || enemy.movement.x > 320 + enemy.width / 2
                        || enemy.movement.y + enemy.width < 0
                        || enemy.movement.x + enemy.width < 0
                    {
                        retired.push(enemy.entity);
                    }
                } else if enemy.movement.done && !def.path.is_empty() {
                    let count = def.path.len();
                    if kamikaze {
                        if enemy.kami == 1 {
                            enemy.kami = 2;
                        }
                    } else if enemy.path_index >= count {
                        if def.repeat {
                            enemy.reversed = true;
                            enemy.path_index = count.saturating_sub(1);
                        } else {
                            retired.push(enemy.entity);
                        }
                    }
                    let target = if enemy.kami == 2 {
                        [self.player.x + 16 - enemy.sx, self.player.y + 16 - enemy.sy]
                    } else {
                        def.path[enemy.path_index.min(count - 1)]
                    };
                    enemy.movement = LineMove::new(
                        enemy.movement.tx,
                        enemy.movement.ty,
                        enemy.sx + target[0],
                        enemy.sy + target[1],
                    );
                    if def.legacy.is_some() {
                        enemy.movement.initial();
                    }
                    enemy.movement.advance(left);
                    if kamikaze {
                        // F_KAMI arms the chase when the last authored leg
                        // starts, then aims at the player when that leg ends.
                        if enemy.path_index < count - 1 {
                            enemy.path_index += 1;
                        } else if enemy.kami == 0 {
                            enemy.kami = 1;
                        }
                    } else if enemy.reversed {
                        enemy.path_index = enemy.path_index.saturating_sub(1);
                        let min = def
                            .legacy
                            .as_ref()
                            .map_or(0, |l| l.fields[20].max(0) as usize);
                        if enemy.path_index <= min {
                            enemy.reversed = false;
                        }
                    } else {
                        enemy.path_index += 1;
                    }
                } else if def.path.is_empty() {
                    enemy.y += def.speed;
                }
            }
            if let Some(l) = &def.legacy {
                update_legacy_animation(enemy, l);
            } else {
                enemy.frame = enemy.age / 3;
                enemy.art_frame = enemy.frame;
                enemy.shoot_on = true;
            }
            if let Some(frame) = enemy.pinned_art_frame {
                enemy.art_frame = frame;
            }
            if enemy.shoot_on
                && (def.legacy.is_some()
                    || (enemy.health > 0 && enemy.y > -enemy.height && enemy.y < 200))
            {
                if let Some(weapon) = &def.weapon {
                    if let Some(l) = &def.legacy {
                        match enemy.shootagain {
                            -1 => {
                                enemy.shootflag -= 1;
                                if enemy.shootflag < 0 {
                                    enemy.shootflag = l.fields[3];
                                    for gun in 0..if enemy.shoot_disabled {
                                        0
                                    } else {
                                        l.fields[22].max(0) as usize
                                    } {
                                        shots.push((
                                            weapon.clone(),
                                            enemy.x + l.gun_x[gun] as i32,
                                            enemy.y + l.gun_y[gun] as i32,
                                            Some((l.shoot_type[gun], enemy.entity, def.speed, gun)),
                                        ));
                                        let sx = enemy.x + l.gun_x[gun] as i32;
                                        let sy = enemy.y + l.gun_y[gun] as i32;
                                        if (0..320).contains(&sx) && (0..200).contains(&sy) {
                                            play_legacy_sound(
                                                &mut self.rng,
                                                &mut self.sounds,
                                                &mut self.sound_events,
                                                match l.shoot_type[gun] {
                                                    4 => "FX_ENEMYMISSLE",
                                                    5 => "FX_ENEMYLASER",
                                                    7 => "FX_ENEMYPLASMA",
                                                    _ => "FX_ENEMYSHOT",
                                                },
                                            );
                                            position_sound(
                                                &mut self.sound_events,
                                                sx,
                                                sy,
                                                self.player.x + 16,
                                                self.player.y + 16,
                                            );
                                        }
                                    }
                                    enemy.shootcount -= 1;
                                    if enemy.shootcount < 1 {
                                        enemy.shootagain = l.fields[17];
                                    }
                                }
                            }
                            0 => {
                                enemy.shootagain = -1;
                                enemy.shootcount = l.fields[16];
                                enemy.shootflag = l.fields[3];
                            }
                            _ => enemy.shootagain -= 1,
                        }
                    } else if enemy.cooldown == 0 {
                        shots.push((
                            weapon.clone(),
                            enemy.x + enemy.width / 2,
                            enemy.y + enemy.height,
                            Some((-1, enemy.entity, def.speed, 0)),
                        ));
                        enemy.cooldown = def.cooldown;
                    } else {
                        enemy.cooldown -= 1;
                    }
                }
            }
            if def.ground
                && def.legacy.as_ref().is_some_and(|l| {
                    enemy.y > 211
                        || (l.fields[21] == 4 && enemy.x < -enemy.width / 2)
                        || (l.fields[21] == 5 && enemy.x > 335)
                })
            {
                retired.push(enemy.entity);
                continue;
            }
            if def.boss && enemy.health < 50 && (self.tick + 1) & 2 != 0 && def.legacy.is_some() {
                let x = enemy.x + self.rng.next_value() % enemy.width.max(1);
                let y = enemy.y + self.rng.next_value() % enemy.height.max(1);
                original_effect(
                    self.visual_effects.len(),
                    &mut self.effects,
                    Effect::new(EffectKind::SmallAir, x, y),
                );
            }
            if !def.ground && contains(enemy, self.player.x + 16, self.player.y + 16) {
                enemy.health -= 16;
                damage_player(
                    &mut self.player,
                    self.energy_overflow,
                    &mut self.super_shield_overflow,
                    enemy.width.max(enemy.height) >> 2,
                    self.difficulty,
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    &mut self.visual_effects,
                    self.effects.len(),
                    self.legacy_transition && self.end_timer.is_some(),
                );
                if def.legacy.is_some() {
                    let x = self.player.x + 16 + self.rng.next_value() % 8 - 4;
                    let y = self.player.y + 16 + self.rng.next_value() % 8 - 4;
                    original_effect(
                        self.visual_effects.len(),
                        &mut self.effects,
                        Effect::new(EffectKind::SmallAir, x, y),
                    );
                    play_legacy_sound(
                        &mut self.rng,
                        &mut self.sounds,
                        &mut self.sound_events,
                        "FX_CRASH",
                    );
                }
            }
            if enemy.health <= 0 {
                if let Some(legacy) = &def.legacy {
                    play_legacy_sound(
                        &mut self.rng,
                        &mut self.sounds,
                        &mut self.sound_events,
                        "FX_AIREXPLO",
                    );
                    position_sound(
                        &mut self.sound_events,
                        enemy.x + enemy.width / 2,
                        enemy.x + enemy.width / 2,
                        self.player.x + 16,
                        self.player.y + 16,
                    );
                    death_effects(
                        self.visual_effects.len(),
                        &mut self.effects,
                        &mut self.rng,
                        enemy,
                        legacy.fields[2],
                    );
                } else {
                    original_effect(
                        self.visual_effects.len(),
                        &mut self.effects,
                        Effect::new(
                            if def.ground {
                                EffectKind::GroundBlast
                            } else {
                                EffectKind::AirBlast
                            },
                            enemy.x + enemy.width / 2,
                            enemy.y + enemy.height / 2,
                        ),
                    );
                }
                self.player.credits = self.player.credits.saturating_add(def.reward);
                events.push(HookEvent {
                    content: enemy.definition.clone(),
                    hook: "on_death",
                    event: serde_json::json!({"entity":enemy.entity,"x":enemy.x,"y":enemy.y}),
                });
                let mut drops: Vec<_> = def.drop.iter().cloned().collect();
                if def.legacy.as_ref().is_some_and(|l| l.fields[2] == 8) {
                    drops.insert(0, ContentId::from("base:itembuy6"));
                }
                for drop in drops {
                    let legacy = if def.legacy.is_some() {
                        if self.pickups.len() >= 12
                            || (drop == ContentId::from("base:itembuy6")
                                && self.pickups.iter().filter(|p| p.item == drop).count() > 9)
                        {
                            continue;
                        }
                        let position = self.rng.next_value() as usize % 16;
                        Some(LegacyPickup {
                            x: enemy.x + 16,
                            y: enemy.y,
                            position,
                            frame: 0,
                            art_frame: 0,
                            countdown: None,
                            glow_frame: 0,
                            previous_art_position: None,
                        })
                    } else {
                        None
                    };
                    let id = self.next_entity;
                    self.next_entity += 1;
                    self.pickups.push(Pickup {
                        entity: id,
                        item: drop,
                        x: enemy.x,
                        y: enemy.y,
                        legacy,
                    });
                }
                retired.push(enemy.entity);
            } else if enemy.y > 240 || enemy.x < -enemy.width - 40 || enemy.x > 360 {
                retired.push(enemy.entity);
            }
            if !retired.contains(&enemy.entity) {
                events.push(HookEvent{content:enemy.definition.clone(),hook:"on_tick",event:serde_json::json!({"entity":enemy.entity,"x":enemy.x,"y":enemy.y,"health":enemy.health,"tick":self.tick,"player_x":self.player.x,"player_y":self.player.y})});
            }
        }
        self.events.extend(events);
        // Capture the final position before retiring an anchor's enemy.
        self.update_lightning_arcs();
        self.enemies.retain(|e| !retired.contains(&e.entity));
        if self.legacy_transition
            && mission.auto_complete
            && !retired.is_empty()
            && self.spawn_cursor == mission.spawns.len()
            && self.enemies.is_empty()
        {
            // ENEMY_Remove arms departure before ESHOT_Think, so hostile
            // shots on the final removal step cannot subtract energy.
            self.end_timer = Some(60);
        }
        for (id, x, y, legacy) in shots {
            if legacy.is_none_or(|(kind, _, _, _)| kind < 0)
                || ((0..320).contains(&x) && (0..200).contains(&y))
            {
                let entity = legacy.map_or(0, |(_, entity, _, _)| entity);
                self.event(id.clone(),"on_fire",serde_json::json!({"entity":entity,"x":x,"y":y,"hostile":true,"tick":self.tick}));
                if let Some(enemy) = self.enemies.iter().find(|e| e.entity == entity) {
                    let definition = enemy.definition.clone();
                    self.event(definition,"on_fire",serde_json::json!({"entity":entity,"weapon":id,"x":x,"y":y,"hostile":true,"tick":self.tick}));
                }
            }
            if matches!(registry.weapons[&id].behavior, WeaponBehavior::Scripted) {
                continue;
            }
            if let Some((kind, entity, speed, gun)) = legacy.filter(|(kind, _, _, _)| *kind >= 0) {
                self.enemy_projectile(&id, x, y, kind, entity, speed, gun)?;
                continue;
            }
            let speed = registry.weapons[&id].speed;
            let dx = self.player.x + 16 - x;
            let dy = self.player.y + 16 - y;
            let norm = dx.abs().max(dy.abs()).max(1);
            self.projectile(&id, x, y, dx * speed / norm, dy * speed / norm, true)?;
        }
        for cooldown in self.cooldowns.values_mut() {
            *cooldown = cooldown.saturating_sub(1);
        }
        let mut dead_shots = Vec::new();
        let mut hit_events = Vec::new();
        self.think_enemy_projectiles(registry)?;
        for p in self
            .projectiles
            .iter_mut()
            .filter(|p| p.hostile && p.legacy_enemy.is_none())
        {
            p.px = p.x;
            p.py = p.y;
            p.x += p.vx;
            p.y += p.vy;
            p.age += 1;
            if (p.x - (self.player.x + 16)).abs() < 10 && (p.y - (self.player.y + 16)).abs() < 10 {
                damage_player(
                    &mut self.player,
                    self.energy_overflow,
                    &mut self.super_shield_overflow,
                    registry.weapons[&p.weapon].damage,
                    self.difficulty,
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    &mut self.visual_effects,
                    self.effects.len(),
                    self.legacy_transition && self.end_timer.is_some(),
                );
                dead_shots.push(p.entity);
            }
        }
        let mut picked = Vec::new();
        for pickup in &mut self.pickups {
            let collision = if let Some(legacy) = &mut pickup.legacy {
                const X: [i32; 16] = [-1, 0, 1, 2, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -2];
                const Y: [i32; 16] = [-3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 2, 1, 0, -1, -2];
                legacy.art_frame = legacy.frame;
                if legacy.previous_art_position.is_some() {
                    legacy.previous_art_position = Some([pickup.x, pickup.y]);
                }
                pickup.x = legacy.x - 8 + X[legacy.position];
                pickup.y = legacy.y - 8 + Y[legacy.position];
                if legacy.previous_art_position.is_none() {
                    legacy.previous_art_position = Some([pickup.x, pickup.y]);
                }
                legacy.glow_frame = (legacy.glow_frame + 1) % 4;
                legacy.y += 1;
                if self.tick & 1 != 0 {
                    legacy.position = (legacy.position + 1) % 16;
                    legacy.frame = (legacy.frame + 1)
                        % registry.items[&pickup.item]
                            .art
                            .as_ref()
                            .map_or(1, |a| a.frames.max(1));
                }
                legacy.countdown.is_none()
                    && self.player.shield > 0
                    && legacy.x > self.player.x
                    && legacy.x < self.player.x + 32
                    && legacy.y > self.player.y
                    && legacy.y < self.player.y + 32
            } else {
                pickup.y += 1;
                (pickup.x - self.player.x).abs() < 24 && (pickup.y - self.player.y).abs() < 24
            };
            if collision {
                let item = &registry.items[&pickup.item];
                if pickup.item.0 == "base:super_shield" {
                    if inventory_slots(&self.player) < 20 {
                        if self.player.inventory.contains_key(&pickup.item) {
                            self.player.super_shield_reserves.push(item.initial_count);
                        } else {
                            self.player.super_shield = item.initial_count.min(100) as i32;
                            self.super_shield_overflow = item.initial_count.saturating_sub(100);
                            self.player
                                .inventory
                                .insert(pickup.item.clone(), item.initial_count);
                        }
                    }
                } else if pickup.item.0 == "base:energy" && item.legacy == Some(16) {
                    add_energy(
                        &mut self.player,
                        item.initial_count as i32,
                        self.energy_overflow,
                        self.super_shield_overflow,
                    );
                } else if item.credits == 0
                    && (self.player.inventory.contains_key(&pickup.item)
                        || inventory_slots(&self.player) < 20)
                {
                    let amount = self
                        .player
                        .inventory
                        .entry(pickup.item.clone())
                        .or_default();
                    *amount = add_with_capacity(*amount, item.initial_count, item.max_count);
                    if item.special && self.player.selected.is_none() {
                        self.player.selected = Some(pickup.item.clone());
                    }
                }
                if pickup.item.0 != "base:super_shield"
                    && !(pickup.item.0 == "base:energy" && item.legacy == Some(16))
                {
                    self.player.shield = (self.player.shield + item.shield).min(100);
                }
                self.player.credits = self.player.credits.saturating_add(item.credits);
                if pickup.legacy.is_some() {
                    play_legacy_sound(
                        &mut self.rng,
                        &mut self.sounds,
                        &mut self.sound_events,
                        "FX_BONUS",
                    );
                }
                if item.credits > 0 && pickup.legacy.is_some() {
                    pickup.legacy.as_mut().unwrap().countdown = Some(50);
                } else {
                    picked.push(pickup.entity);
                }
                hit_events.push(HookEvent {
                    content: pickup.item.clone(),
                    hook: "on_pickup",
                    event: serde_json::json!({"entity":pickup.entity}),
                });
            }
            if let Some(legacy) = &mut pickup.legacy {
                if let Some(countdown) = &mut legacy.countdown {
                    *countdown = countdown.saturating_sub(1);
                    if *countdown == 0 {
                        picked.push(pickup.entity);
                    }
                }
                if legacy.y - 8 > 200 {
                    picked.push(pickup.entity);
                }
            }
        }
        self.pickups
            .retain(|p| p.y < 220 && !picked.contains(&p.entity));
        self.think_legacy_projectiles(registry)?;
        for p in self
            .projectiles
            .iter_mut()
            .filter(|p| !p.hostile && p.legacy.is_none())
        {
            p.px = p.x;
            p.py = p.y;
            p.age += 1;
            let weapon = &registry.weapons[&p.weapon];
            if matches!(weapon.behavior, WeaponBehavior::Homing) {
                if let Some(target) = self.enemies.iter().find(|e| {
                    e.health > 0
                        && target_matches(&weapon.target, registry.enemies[&e.definition].ground)
                }) {
                    p.vx = (target.x + target.width / 2 - p.x)
                        .clamp(-weapon.speed.abs(), weapon.speed.abs());
                }
            }
            p.x += p.vx;
            p.y += p.vy;
            if matches!(weapon.behavior, WeaponBehavior::Beam) {
                p.x = self.player.x + 16;
                for e in &mut self.enemies {
                    if target_matches(&weapon.target, registry.enemies[&e.definition].ground)
                        && p.x > e.x
                        && p.x < e.x + e.width
                        && e.y < self.player.y
                    {
                        e.health -= weapon.damage;
                        hit_events.push(HookEvent{content:e.definition.clone(),hook:"on_hit",event:serde_json::json!({"entity":e.entity,"projectile":p.entity,"weapon":p.weapon,"damage":weapon.damage,"x":p.x,"y":e.y,"health":e.health})});
                        hit_events.push(HookEvent{content:p.weapon.clone(),hook:"on_hit",event:serde_json::json!({"entity":e.entity,"projectile":p.entity,"damage":weapon.damage,"x":p.x,"y":e.y})});
                    }
                }
                if p.age > 1 {
                    dead_shots.push(p.entity);
                }
            } else if let Some(e) = self.enemies.iter_mut().find(|e| {
                e.health > 0
                    && target_matches(&weapon.target, registry.enemies[&e.definition].ground)
                    && contains(e, p.x, p.y)
            }) {
                e.health -= weapon.damage;
                hit_events.push(HookEvent{content:e.definition.clone(),hook:"on_hit",event:serde_json::json!({"entity":e.entity,"projectile":p.entity,"weapon":p.weapon,"damage":weapon.damage,"x":p.x,"y":p.y,"health":e.health})});
                hit_events.push(HookEvent{content:p.weapon.clone(),hook:"on_hit",event:serde_json::json!({"entity":e.entity,"projectile":p.entity,"damage":weapon.damage,"x":p.x,"y":p.y})});
                dead_shots.push(p.entity);
            } else if !matches!(weapon.target, Target::Air) {
                let col = (p.x - 16) / 32;
                let row = (p.y + mission.layout.len() as i32 / mission.columns.max(1) as i32 * 32
                    - 200
                    - self.scroll)
                    / 32;
                if col >= 0 && col < mission.columns as i32 && row >= 0 {
                    let pos = row as usize * mission.columns as usize + col as usize;
                    if pos < self.terrain_health.len()
                        && self.terrain_health[pos] > 0
                        && !self.terrain_dead[pos]
                    {
                        self.terrain_health[pos] -= weapon.damage;
                        dead_shots.push(p.entity);
                        if self.terrain_health[pos] <= 0 {
                            self.terrain_dead[pos] = true;
                            self.player.credits = self
                                .player
                                .credits
                                .saturating_add(mission.tiles[mission.layout[pos]].reward);
                            original_effect(
                                self.visual_effects.len(),
                                &mut self.effects,
                                Effect::new(EffectKind::GroundBlast, p.x, p.y),
                            );
                        }
                    }
                }
            }
        }
        self.events.extend(hit_events);
        self.projectiles.retain(|p| {
            !dead_shots.contains(&p.entity)
                && (p.legacy.is_some()
                    || (p.x >= -32 && p.x <= 352 && p.y >= -64 && p.y <= 240 && p.age < 300))
        });
        for e in &mut self.effects {
            e.px = e.x;
            e.py = e.y;
            e.age += 1;
            if e.ground && self.scroll != previous_scroll && e.age > 1 {
                e.y += 1;
            }
        }
        self.effects.retain(|e| e.age <= e.kind.artwork().1);
        for effect in &mut self.visual_effects {
            effect.px = effect.x;
            effect.py = effect.y;
            match effect.anchor {
                Some(0) => {
                    effect.x = self.player.x + 16 + effect.offset[0];
                    effect.y = self.player.y + 16 + effect.offset[1];
                }
                Some(entity) => {
                    if let Some(enemy) = self.enemies.iter().find(|e| e.entity == entity) {
                        effect.x = enemy.movement.x + effect.offset[0];
                        effect.y = enemy.movement.y + effect.offset[1];
                    }
                }
                None => {
                    effect.x = effect.offset[0];
                    effect.y = effect.offset[1];
                }
            }
            if effect.age == 0 {
                effect.px = effect.x;
                effect.py = effect.y;
            }
            effect.age += 1;
            // ANIMS_Think adjusts both the direction switch and adir table.
            effect.offset[1] += match effect.kind {
                VisualEffectKind::SmokeDown => 2,
                VisualEffectKind::SmokeTrail => -2,
                kind if kind.layer() == 0 && self.scroll != previous_scroll => 1,
                _ => 0,
            };
        }
        self.visual_effects
            .retain(|effect| effect.age <= effect.kind.artwork().1);
        for arc in &mut self.lightning_arcs {
            arc.age += 1;
        }
        self.lightning_arcs.retain(|arc| arc.age < arc.ticks);
        if self.difficulty < 3 {
            if equipment_used {
                self.shield_recharge_ticks = 0;
            } else {
                self.shield_recharge_ticks += 1;
                if self.shield_recharge_ticks > 96 {
                    if self.end_timer.is_none()
                        && registry
                            .items
                            .get(&ContentId::from("base:energy"))
                            .is_some_and(|item| item.legacy == Some(16))
                    {
                        add_energy(
                            &mut self.player,
                            1,
                            self.energy_overflow,
                            self.super_shield_overflow,
                        );
                    }
                    self.shield_recharge_ticks = 0;
                }
            }
        }
        self.tick += 1;
        if self.legacy_transition {
            if mission.auto_complete
                && self.spawn_cursor == mission.spawns.len()
                && self.enemies.is_empty()
                && self.end_timer.is_none()
                && !transition_finished
            {
                self.end_timer = Some(60);
            }
        } else if self.player.shield <= 0 {
            self.outcome = Outcome::Failed;
        } else if mission.auto_complete {
            if self.tick >= mission.duration
                && self.spawn_cursor == mission.spawns.len()
                && self
                    .enemies
                    .iter()
                    .all(|e| !registry.enemies[&e.definition].boss)
            {
                self.outcome = Outcome::Complete;
            }
        }
        if mission.legacy_map.is_some() && self.tick >= 3 && self.tick % 2 == 1 {
            // Palette index 254 consumes the original shared RNG, even when no frame is rendered.
            self.palette_blue = self.rng.next_value() % 3 == 0;
        }
        if self.legacy_transition {
            self.think_legacy_transition(transition_finished, input.demo_bank.is_some());
        }
        // RAP_ThinkStats follows palette simulation. A new hit at low energy
        // destroys the equipped special, or the highest-numbered losable item.
        // OBJS_LoseObj reports success even when no eligible item remains.
        if self.player.shield <= 10
            && self.player.shield < self.previous_shield
            && self.player.super_shield < 1
        {
            let lost = self
                .player
                .selected
                .clone()
                .filter(|id| registry.items.contains_key(id))
                .or_else(|| {
                    self.player
                        .inventory
                        .keys()
                        .filter_map(|id| {
                            registry
                                .items
                                .get(id)
                                .and_then(|item| item.legacy)
                                .filter(|legacy| matches!(legacy, 1..=14 | 18..=23))
                                .map(|legacy| (legacy, id.clone()))
                        })
                        .max()
                        .map(|(_, id)| id)
                });
            if let Some(id) = lost {
                let removed = self.player.inventory.remove(&id).is_some();
                if removed && self.player.selected.as_ref() == Some(&id) {
                    self.player.selected = next_special(&self.player, registry);
                }
            }
            play_legacy_sound(
                &mut self.rng,
                &mut self.sounds,
                &mut self.sound_events,
                "FX_CRASH",
            );
        }
        self.previous_shield = self.player.shield;
        self.sync_retained_inventory();
        self.update_lightning_arcs();
        self.event(self.mission.clone(),"on_tick",serde_json::json!({"tick":self.tick,"player_x":self.player.x,"player_y":self.player.y,"enemies":self.enemies.len()}));
        if self.outcome != Outcome::Playing {
            self.event(
                self.mission.clone(),
                "on_mission_end",
                serde_json::json!({"success":self.outcome==Outcome::Complete,"tick":self.tick}),
            );
        }
        Ok(())
    }
    fn think_legacy_transition(&mut self, finished: bool, demo: bool) {
        if self.player.shield <= 0 {
            // GCC evaluates the original ANIMS_StartAnim position arguments
            // right-to-left: y consumes the first shared random value.
            let y = self.player.y + self.rng.next_value() % 32;
            let x = self.player.x + self.rng.next_value() % 32;
            original_effect(
                self.visual_effects.len(),
                &mut self.effects,
                Effect::new(EffectKind::MediumAir, x, y),
            );
            let y = self.player.y + self.rng.next_value() % 32;
            let x = self.player.x + self.rng.next_value() % 32;
            original_effect(
                self.visual_effects.len(),
                &mut self.effects,
                Effect::new(EffectKind::SmallAir, x, y),
            );
            if self.end_timer.is_some_and(|timer| timer > 24) {
                let pan = if self.rng.next_value() % 2 == 0 {
                    30
                } else {
                    225
                };
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_AIREXPLO",
                );
                if let Some(event) = self.sound_events.last_mut() {
                    event.pan = pan;
                }
            }
            if self.end_timer.is_none() {
                self.end_timer = Some(60);
            }
            if self.end_timer == Some(24) {
                self.draw_player = false;
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_AIREXPLO",
                );
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_AIREXPLO2",
                );
                original_effect(
                    self.visual_effects.len(),
                    &mut self.effects,
                    Effect::new(EffectKind::LargeAir, self.player.x + 16, self.player.y + 16),
                );
                // Random positions are evaluated even after the animation pool
                // fills, exactly as the original 512-effect request burst.
                for index in 0..512 {
                    let x = self.player.x - 16 + self.rng.next_value() % 32 * 2;
                    let y = self.player.y - 16 + self.rng.next_value() % 32 * 2;
                    let kind = if index & 1 != 0 {
                        EffectKind::LargeAir
                    } else {
                        EffectKind::AirBlast
                    };
                    original_effect(
                        self.visual_effects.len(),
                        &mut self.effects,
                        Effect::new(kind, x, y).airborne(),
                    );
                }
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_AIREXPLO2",
                );
            }
        } else if let Some(timer) = self.end_timer {
            if timer == 40 {
                self.control_paused = true;
                self.departure_delta = [
                    self.player.x - self.player.px,
                    self.player.y - self.player.py,
                ];
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_FLYBY",
                );
            }
            if timer < 40 {
                let dx = if self.player.x < 152 {
                    8
                } else if self.player.x > 168 {
                    -8
                } else {
                    0
                };
                self.departure_delta = [dx, -4];
                if !demo {
                    let old_x = self.player.x;
                    self.player.x += dx;
                    self.player.y -= 4;
                    bank_player(&mut self.player, old_x);
                }
            }
        }
        if finished {
            self.outcome = if self.player.shield > 0 {
                Outcome::Complete
            } else {
                Outcome::Failed
            };
        }
    }
    fn fire(&mut self, id: &ContentId, registry: &Registry) -> Result<()> {
        let Some(w) = registry.weapons.get(id) else {
            return Ok(());
        };
        if self.cooldowns.get(id).copied().unwrap_or(0) > 0 {
            return Ok(());
        }
        self.cooldowns.insert(id.clone(), w.cooldown);
        if matches!(w.behavior, WeaponBehavior::Scripted) {
            self.event(
                id.clone(),
                "on_fire",
                serde_json::json!({"entity":0,"hostile":false,"x":self.player.x+16,"y":self.player.y,"tick":self.tick}),
            );
            return Ok(());
        }
        if let Some(index) = w.legacy {
            if let Some(legacy) = crate::legacy_tables::weapons()
                .into_iter()
                .find(|w| w.index == index)
            {
                self.fire_legacy(id, &legacy, registry)?;
                return Ok(());
            }
        }
        let offsets = if w.offsets.is_empty() {
            vec![[0, 0]]
        } else {
            w.offsets.clone()
        };
        for [x, y] in offsets {
            self.projectile(
                id,
                self.player.x + 16 + x,
                self.player.y + y,
                0,
                -w.speed.max(1),
                false,
            )?;
        }
        self.event(
            id.clone(),
            "on_fire",
            serde_json::json!({"entity":0,"hostile":false,"x":self.player.x+16,"y":self.player.y,"tick":self.tick}),
        );
        Ok(())
    }
    fn enemy_projectile(
        &mut self,
        id: &ContentId,
        x: i32,
        y: i32,
        kind: i16,
        enemy: u64,
        enemy_speed: i32,
        gun: usize,
    ) -> Result<()> {
        if !(0..320).contains(&x)
            || !(0..200).contains(&y)
            || self
                .projectiles
                .iter()
                .filter(|p| p.legacy_enemy.is_some())
                .count()
                >= 80
        {
            return Ok(());
        }
        let (asset, frames, maximum_speed, damage, offset_y) = match kind {
            0 => (0x101d6, 2, 6, 1, 4),
            1..=3 => (0x101d6, 2, 6, 2, 4),
            4 => (0x101d4, 2, 10, 4, 0),
            5 => (0x10241, 4, 6, 12, 0),
            6 => (0x101d1, 2, 0, 16, 0),
            7 => (0x10251, 1, 10, 15, 0),
            8 => (0x1024d, 4, 6, 1, 4),
            _ => {
                return Err(anyhow::anyhow!(
                    "unknown original enemy projectile type {kind}"
                ));
            }
        };
        let start = [x - if kind == 6 { 0 } else { 4 }, y - offset_y];
        let mut target = [start[0], 200];
        let speed = match kind {
            0 | 8 => 1,
            1..=3 => 3,
            4 => enemy_speed + 1,
            5 => enemy_speed,
            6 => 150,
            7 => 8,
            _ => 1,
        };
        match kind {
            0 | 8 => target = [self.player.x + 16, self.player.y + 16],
            2 => target = [start[0] - 32, start[1] + 32],
            3 => target = [start[0] + 32, start[1] + 32],
            6 => target = [320, 200],
            _ => {}
        }
        let mut movement = LineMove::new(start[0], start[1], target[0], target[1]);
        movement.advance_shot(1);
        if !(0..320).contains(&movement.x) || !(0..200).contains(&movement.y) {
            return Ok(());
        }
        self.projectile(id, movement.x, movement.y, 0, 0, true)?;
        self.projectiles.last_mut().unwrap().legacy_enemy = Some(EnemyProjectile {
            movement,
            kind,
            asset,
            frames,
            frame: 0,
            art_frame: 0,
            speed,
            maximum_speed,
            damage,
            position: if kind == 6 {
                self.rng.next_value() as usize % 16
            } else {
                0
            },
            enemy,
            gun,
        });
        Ok(())
    }
    fn think_enemy_projectiles(&mut self, registry: &Registry) -> Result<()> {
        const X: [i32; 16] = [-1, 0, 1, 2, 3, 3, 3, 2, 1, 0, -1, -2, -3, -3, -3, -2];
        const Y: [i32; 16] = [-3, -3, -3, -2, -1, 0, 1, 2, 3, 3, 3, 2, 1, 0, -1, -2];
        let mut retired = Vec::new();
        for p in &mut self.projectiles {
            let Some(state) = p.legacy_enemy.as_mut() else {
                continue;
            };
            p.px = p.x;
            p.py = p.y;
            p.age += 1;
            state.art_frame = state.frame;
            state.frame += 1;
            if state.kind == 5 {
                if let Some(enemy) = self
                    .enemies
                    .iter()
                    .find(|e| e.entity == state.enemy)
                    .filter(|_| state.frame < state.frames)
                {
                    let legacy = registry.enemies[&enemy.definition].legacy.as_ref().unwrap();
                    p.x = enemy.x + legacy.gun_x[state.gun] as i32 - 4;
                    p.y = enemy.y + legacy.gun_y[state.gun] as i32;
                    state.movement.ty = 200;
                    if (p.x - self.player.x - 16).abs() < 16 && p.y < self.player.y + 16 {
                        state.movement.ty = self.player.y + 16 + self.rng.next_value() % 4 - 2;
                        damage_player(
                            &mut self.player,
                            self.energy_overflow,
                            &mut self.super_shield_overflow,
                            state.damage,
                            self.difficulty,
                            &mut self.rng,
                            &mut self.sounds,
                            &mut self.sound_events,
                            &mut self.visual_effects,
                            self.effects.len(),
                            self.legacy_transition && self.end_timer.is_some(),
                        );
                    }
                } else {
                    retired.push(p.entity);
                }
            } else {
                state.frame %= state.frames;
                if state.maximum_speed != 0 {
                    p.x = state.movement.x;
                    p.y = state.movement.y;
                    state.movement.advance_shot(state.speed);
                    if state.speed < state.maximum_speed {
                        state.speed += 1;
                    }
                } else {
                    state.speed -= 1;
                    if state.speed > 0 {
                        p.x = state.movement.x + X[state.position];
                        p.y = state.movement.y + Y[state.position];
                        state.movement.y += 1;
                        state.position = (state.position + 1) % 16;
                    } else {
                        visual_effect(
                            self.effects.len(),
                            &mut self.visual_effects,
                            VisualEffect::new(VisualEffectKind::SmallAir, p.x + 4, p.y + 4),
                        );
                        retired.push(p.entity);
                    }
                }
                if !(0..320).contains(&p.x) || !(0..200).contains(&p.y) {
                    retired.push(p.entity);
                }
                if (p.x - self.player.x - 16).abs() < 16 && (p.y - self.player.y - 16).abs() < 16 {
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(VisualEffectKind::SmallAir, p.x, p.y),
                    );
                    damage_player(
                        &mut self.player,
                        self.energy_overflow,
                        &mut self.super_shield_overflow,
                        state.damage,
                        self.difficulty,
                        &mut self.rng,
                        &mut self.sounds,
                        &mut self.sound_events,
                        &mut self.visual_effects,
                        self.effects.len(),
                        self.legacy_transition && self.end_timer.is_some(),
                    );
                    retired.push(p.entity);
                }
                // Native enemy missiles trail smoke on odd surviving updates.
                if state.kind == 4 && p.age & 1 != 0 && !retired.contains(&p.entity) {
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(VisualEffectKind::SmokeTrail, p.x + 4, p.y),
                    );
                }
            }
        }
        self.projectiles.retain(|p| !retired.contains(&p.entity));
        Ok(())
    }
    fn terrain_window(&self, registry: &Registry) -> (usize, i32) {
        let mission = &registry.missions[&self.mission];
        let rows = mission.layout.len() / mission.columns.max(1) as usize;
        let initial = rows.saturating_sub(8);
        let wraps = if self.scroll <= 56 {
            0
        } else {
            1 + (self.scroll - 57) / 32
        };
        (
            initial.saturating_sub(wraps as usize),
            -56 + self.scroll - wraps * 32,
        )
    }
    fn terrain_damage_neighbors(&mut self, position: usize, damage: i32, registry: &Registry) {
        let mission = &registry.missions[&self.mission];
        let columns = mission.columns.max(1) as usize;
        let column = position % columns;
        let neighbors = [
            if column > 0 {
                position.checked_sub(1)
            } else {
                None
            },
            position.checked_sub(columns),
            if column + 1 < columns {
                Some(position + 1)
            } else {
                None
            },
        ];
        for position in neighbors.into_iter().flatten() {
            if position < mission.layout.len()
                && (mission.legacy_map.is_none()
                    || mission.tiles[mission.layout[position]].destroyed.is_some())
                && !self.terrain_dead[position]
            {
                self.damage_terrain(position, damage, registry);
            }
        }
    }
    fn damage_terrain(&mut self, position: usize, damage: i32, registry: &Registry) {
        let mission = &registry.missions[&self.mission];
        if self.terrain_dead[position]
            || (mission.legacy_map.is_none() && self.terrain_health[position] <= 0)
        {
            return;
        }
        self.terrain_health[position] -= damage;
        // Native maps defer explosions to TILE_Think's following pass. JSON
        // maps use immediate destruction, including shots from original guns.
        if mission.legacy_map.is_none() && self.terrain_health[position] <= 0 {
            self.terrain_dead[position] = true;
            self.terrain_settled[position] = true;
            self.player.credits = self
                .player
                .credits
                .saturating_add(mission.tiles[mission.layout[position]].reward);
            let columns = mission.columns.max(1) as usize;
            let rows = mission.layout.len() / columns;
            let x = 32 + (position % columns) as i32 * 32;
            let y = 216 - rows as i32 * 32 + self.scroll + (position / columns) as i32 * 32;
            original_effect(
                self.visual_effects.len(),
                &mut self.effects,
                Effect::new(EffectKind::GroundBlast, x, y),
            );
            play_legacy_sound(
                &mut self.rng,
                &mut self.sounds,
                &mut self.sound_events,
                "FX_GEXPLO",
            );
            position_sound(
                &mut self.sound_events,
                x,
                y,
                self.player.x + 16,
                self.player.y + 16,
            );
        }
    }
    fn think_legacy_terrain(&mut self, registry: &Registry) {
        let mission = &registry.missions[&self.mission];
        if mission.legacy_map.is_none() || mission.layout.is_empty() {
            return;
        }
        let columns = mission.columns.max(1) as usize;
        let (row, y) = self.terrain_window(registry);
        let start = row * columns;
        let end = (start + 8 * columns).min(mission.layout.len());
        for position in start..end {
            if self.terrain_health[position] < 0 && !self.terrain_dead[position] {
                let x = 16 + (position % columns) as i32 * 32;
                let y = y + ((position - start) / columns) as i32 * 32;
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_GEXPLO",
                );
                position_sound(
                    &mut self.sound_events,
                    x + 16,
                    y + 16,
                    self.player.x + 16,
                    self.player.y + 16,
                );
                self.terrain_damage_neighbors(position, 5, registry);
                self.player.credits = self
                    .player
                    .credits
                    .saturating_add(mission.tiles[mission.layout[position]].reward);
                self.terrain_delays.push(TerrainDelay {
                    position,
                    frames: 10,
                });
                original_effect(
                    self.visual_effects.len(),
                    &mut self.effects,
                    Effect::new(EffectKind::GroundBlast, x + 16, y + 16),
                );
                // TILE_Explode changes its collision item immediately. Artwork waits
                // for the delayed explosion and its second chain-damage pass.
                self.terrain_dead[position] = true;
            }
        }
        let delays = std::mem::take(&mut self.terrain_delays);
        for mut delay in delays {
            if delay.position.saturating_sub(start) > 8 * columns {
                continue;
            }
            if delay.frames < 0 {
                let random = self.rng.next_value(); // Ground sparkle horizontal offset.
                let x = 16 + (delay.position % columns) as i32 * 32 + 8 + random % 8;
                let y = y + (delay.position as i32 - start as i32) / columns as i32 * 32 + 26;
                self.terrain_spark_delay += 1;
                self.terrain_flare_delay += 1;
                if self.terrain_spark_delay > 2 {
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(VisualEffectKind::GroundSparkle, x, y),
                    );
                    self.terrain_spark_delay = 0;
                }
                if self.terrain_flare_delay > 4 {
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(VisualEffectKind::GroundFlare, x, y),
                    );
                    self.terrain_flare_delay = 0;
                }
                self.terrain_damage_neighbors(delay.position, 20, registry);
                self.terrain_settled[delay.position] = true;
            } else {
                delay.frames -= 1;
                self.terrain_delays.push(delay);
            }
        }
    }
    fn think_legacy_projectiles(&mut self, registry: &Registry) -> Result<()> {
        let mut retired = Vec::new();
        let libs = crate::legacy_tables::weapons();
        for n in 0..self.projectiles.len() {
            let mut p = self.projectiles[n].clone();
            let Some(mut state) = p.legacy.take() else {
                continue;
            };
            if p.hostile {
                continue;
            }
            let weapon = &registry.weapons[&p.weapon];
            let Some(lib) = libs.iter().find(|l| Some(l.index) == weapon.legacy) else {
                continue;
            };
            p.px = p.x;
            p.py = p.y;
            p.age += 1;
            state.art_frame = state.frame;
            if lib.beam == 1 && p.age > 1 {
                retired.push(p.entity);
                continue;
            }
            let (half_width, half_height) = weapon
                .art
                .as_ref()
                .map(|a| (a.logical_width as i32 / 2, a.logical_height as i32 / 2))
                .unwrap_or((0, 0));
            p.x = state.movement.x - if lib.beam == 1 { 0 } else { half_width };
            p.y = state.movement.y
                - if lib.beam == 0 && lib.moving {
                    half_height
                } else {
                    0
                };
            if matches!(lib.index, 6..=8) {
                visual_effect(
                    self.effects.len(),
                    &mut self.visual_effects,
                    VisualEffect::new(
                        VisualEffectKind::SmokeDown,
                        p.x + half_width,
                        p.y + half_height * 2,
                    ),
                );
            }
            // The original S_BEAM damage pass tests the uncorrected launch
            // column, then applies player-follow offsets to presentation.
            if lib.beam == 2 {
                for enemy in &mut self.enemies {
                    if p.x > enemy.x
                        && p.x < enemy.x + enemy.width - 1
                        && enemy.y < self.player.y + 16
                        && enemy.y > -30
                    {
                        enemy.health -= weapon.damage;
                        if enemy.health != -1 {
                            state.movement.ty = enemy.y + enemy.height / 2;
                            break;
                        }
                    }
                }
            }
            if lib.follow_x {
                p.x += self.player.x + 16 - state.start[0];
            }
            if lib.follow_y {
                p.y += self.player.y + 16 - state.start[1];
            }
            let mut skip_collision = false;
            if lib.moving && (p.y + 16 < 0 || p.x < 0 || p.x > 320 || p.y > 200) {
                state.movement.done = true;
                skip_collision = true;
            }
            if !skip_collision && !state.delay {
                if state.speed < lib.maxspeed {
                    state.speed += 1;
                }
                state.frame += 1;
                if state.frame >= lib.frames {
                    if lib.moving {
                        state.frame = lib.startframe;
                    } else {
                        state.movement.done = true;
                        skip_collision = true;
                    }
                }
            }
            if state.hit {
                state.movement.done = true;
                skip_collision = true;
            }
            // A plotted shot tests its endpoint before retiring, even if MoveSobj
            // marked it done in the preceding step.
            if !skip_collision && !lib.effect {
                // TILE_Bomb runs before ENEMY_DamageGround and affects both
                // the hit tile and the original left/up/right neighbors.
                if lib.target == 4 {
                    if let Some(position) = self.legacy_tile_hit(p.x, p.y, registry) {
                        self.damage_terrain(position, weapon.damage, registry);
                        self.terrain_damage_neighbors(position, weapon.damage, registry);
                        let columns = registry.missions[&self.mission].columns.max(1) as usize;
                        if position > columns {
                            self.terrain_damage_neighbors(
                                position - columns,
                                weapon.damage >> 1,
                                registry,
                            );
                        }
                        state.movement.done = true;
                    }
                }
                let enemy = self
                    .enemies
                    .iter_mut()
                    .filter(|e| visible(e))
                    .take(30)
                    .find(|e| {
                        let ground = registry.enemies[&e.definition].ground;
                        contains(e, p.x, p.y)
                            && match lib.target {
                                1 | 5 => !ground,
                                2 | 4 => ground,
                                _ => true,
                            }
                    });
                if let Some(enemy) = enemy {
                    let damage = match lib.target {
                        4 => 5,
                        5 => 1,
                        _ => weapon.damage,
                    };
                    enemy.health -= damage;
                    if self.difficulty == 0 && matches!(lib.target, 1 | 2) {
                        enemy.health -= damage;
                    }
                    state.hit = true;
                    let spark = match lib.target {
                        0 | 1 | 3 => {
                            if self.rng.next_value() % 2 != 0 {
                                VisualEffectKind::BlueSpark
                            } else {
                                VisualEffectKind::OrangeSpark
                            }
                        }
                        2 => VisualEffectKind::OrangeSpark,
                        4 => VisualEffectKind::SmallGround,
                        _ => VisualEffectKind::BlueSpark,
                    };
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(spark, p.x, p.y),
                    );
                    if lib.target == 5 {
                        visual_effect(
                            self.effects.len(),
                            &mut self.visual_effects,
                            VisualEffect::new(
                                VisualEffectKind::EnergyGrab,
                                enemy.width / 2,
                                enemy.height / 2,
                            )
                            .attached(enemy.entity),
                        );
                    }
                    if lib.target == 5
                        && registry.enemies[&enemy.definition]
                            .legacy
                            .as_ref()
                            .is_some_and(|l| l.fields[5] != 0)
                    {
                        if enemy.energy_resistance > 0 {
                            enemy.energy_resistance -= weapon.damage;
                        } else {
                            enemy.shoot_on = false;
                            enemy.shoot_disabled = true;
                            enemy.shootagain = -1;
                            play_legacy_sound(
                                &mut self.rng,
                                &mut self.sounds,
                                &mut self.sound_events,
                                "FX_EGRAB",
                            );
                            position_sound(
                                &mut self.sound_events,
                                enemy.x + enemy.width / 2,
                                enemy.y + enemy.width / 2,
                                self.player.x + 16,
                                self.player.y + 16,
                            );
                        }
                    }
                    let entity = enemy.entity;
                    let enemy_id = enemy.definition.clone();
                    let health = enemy.health;
                    self.event(enemy_id,"on_hit",serde_json::json!({"entity":entity,"projectile":p.entity,"weapon":p.weapon,"damage":damage,"x":p.x,"y":p.y,"health":health}));
                    self.event(p.weapon.clone(),"on_hit",serde_json::json!({"entity":entity,"projectile":p.entity,"damage":damage,"x":p.x,"y":p.y}));
                } else if matches!(lib.target, 0 | 2) {
                    if let Some(position) = self.legacy_tile_hit(p.x, p.y, registry) {
                        self.damage_terrain(position, weapon.damage, registry);
                        let kind = if self.rng.next_value() % 2 == 0 {
                            VisualEffectKind::GroundBlueSpark
                        } else {
                            VisualEffectKind::GroundOrangeSpark
                        };
                        visual_effect(
                            self.effects.len(),
                            &mut self.visual_effects,
                            VisualEffect::new(kind, p.x, p.y),
                        );
                        state.movement.done = true;
                    }
                }
            }
            if state.movement.done {
                if state.delay {
                    state.delay = false;
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(
                            VisualEffectKind::SmokeDown,
                            state.movement.x,
                            state.movement.y,
                        ),
                    );
                    state.movement = LineMove::new(
                        state.movement.x,
                        state.movement.y,
                        state.movement.x + self.rng.next_value() % 32 - 16,
                        0,
                    );
                } else if lib.index == 11 {
                    visual_effect(
                        self.effects.len(),
                        &mut self.visual_effects,
                        VisualEffect::new(VisualEffectKind::Shield, 0, 0).attached(0),
                    );
                    for enemy in &mut self.enemies {
                        enemy.health -= weapon.damage;
                    }
                    let mission = &registry.missions[&self.mission];
                    let columns = mission.columns.max(1) as usize;
                    let (row, _) = self.terrain_window(registry);
                    let start = row * columns;
                    let end = (start + 8 * columns).min(mission.layout.len());
                    // TILE_DamageAll uses a fixed 20 terrain damage and
                    // includes the final visible tile, unlike TILE_IsHit.
                    for position in start..end {
                        if mission.tiles[mission.layout[position]].destroyed.is_some()
                            && !self.terrain_dead[position]
                        {
                            self.damage_terrain(position, 20, registry);
                        }
                    }
                    retired.extend(
                        self.projectiles
                            .iter()
                            .filter(|p| p.hostile)
                            .map(|p| p.entity),
                    );
                    retired.push(p.entity);
                    continue;
                } else if lib.index != 5 {
                    retired.push(p.entity);
                    continue;
                }
            }
            if lib.moving {
                if lib.plot {
                    state.movement.advance_shot(state.speed);
                } else {
                    state.movement.y -= state.speed;
                    if state.movement.y < 0 {
                        state.movement.done = true;
                        state.hit = true;
                    }
                }
            }
            p.legacy = Some(state);
            self.projectiles[n] = p;
        }
        self.projectiles.retain(|p| !retired.contains(&p.entity));
        Ok(())
    }
    fn legacy_tile_hit(&self, x: i32, y: i32, registry: &Registry) -> Option<usize> {
        let mission = &registry.missions[&self.mission];
        let columns = mission.columns.max(1) as usize;
        if mission.legacy_map.is_none() {
            // JSON terrain keeps scrolling past the last row. Use exactly its
            // presentation coordinates instead of the native clamped window.
            let rows = mission.layout.len() / columns;
            let column = (x - 16).div_euclid(32);
            let row = (y - (200 - rows as i32 * 32 + self.scroll)).div_euclid(32);
            if column < 0 || column >= columns as i32 || row < 0 || row >= rows as i32 {
                return None;
            }
            let position = row as usize * columns + column as usize;
            return (self.terrain_health[position] > 0 && !self.terrain_dead[position])
                .then_some(position);
        }
        let (row, y_offset) = self.terrain_window(registry);
        let column = (x - 16).div_euclid(32);
        let local_row = (y - y_offset).div_euclid(32);
        if column < 0 || column >= columns as i32 || !(0..8).contains(&local_row) {
            return None;
        }
        let slot = local_row as usize * columns + column as usize;
        // The original TILE_IsHit/TILE_Bomb loop excludes lastspot itself.
        if slot >= 8 * columns - 1 {
            return None;
        }
        let position = row * columns + slot;
        (position < mission.layout.len()
            && mission.tiles[mission.layout[position]].destroyed.is_some()
            && !self.terrain_dead[position])
            .then_some(position)
    }
    fn fire_legacy(
        &mut self,
        id: &ContentId,
        lib: &crate::legacy_tables::LegacyWeapon,
        registry: &Registry,
    ) -> Result<()> {
        use crate::legacy_tables::{O_GUN1, O_GUN2, O_GUN3};
        if self
            .projectiles
            .iter()
            .filter(|p| !p.hostile && p.legacy.is_some())
            .count()
            >= 70
        {
            return Ok(());
        }
        let center = [self.player.x + 16, self.player.y + 16];
        let bank = self.player.bank.clamp(0, 6) as usize;
        let mut start = center;
        let mut offsets = vec![0];
        let mut target = [center[0], 0];
        let mut initial_frame = None;
        match lib.index {
            0 => {
                self.player_flash = true;
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_GUN",
                );
                offsets = vec![O_GUN1[bank], -O_GUN1[bank] - 1];
            }
            1 => play_legacy_sound(
                &mut self.rng,
                &mut self.sounds,
                &mut self.sound_events,
                "FX_GUN",
            ),
            2 => {
                self.player_flash = true;
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_GUN",
                );
                offsets = vec![O_GUN3[bank], -O_GUN3[bank]];
            }
            3 => {
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_MISSLE",
                );
                offsets = vec![0, 0];
            }
            4 | 5 => {
                let candidates: Vec<_> = self
                    .enemies
                    .iter()
                    .enumerate()
                    .filter(|(_, e)| {
                        visible(e) && (lib.index == 4 || !registry.enemies[&e.definition].ground)
                    })
                    .map(|(n, _)| n)
                    .collect();
                if candidates.is_empty() {
                    if lib.index == 5 {
                        play_legacy_sound(
                            &mut self.rng,
                            &mut self.sounds,
                            &mut self.sound_events,
                            "FX_NOSHOOT",
                        );
                    }
                    return Ok(());
                }
                let pos = candidates[self.rng.next_value() as usize % candidates.len()];
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    if lib.index == 5 {
                        "FX_TURRET"
                    } else {
                        "FX_GUN"
                    },
                );
                if lib.index == 4 {
                    initial_frame = Some(self.rng.next_value() as u32 % lib.frames);
                }
                let enemy = &mut self.enemies[pos];
                if lib.index == 4 {
                    target = [
                        self.rng.next_value() % enemy.width + enemy.x - 1,
                        self.rng.next_value() % enemy.height + enemy.height / 2 + enemy.y - 1,
                    ];
                } else {
                    enemy.health -= lib.damage;
                    start = [
                        self.rng.next_value() % enemy.width + enemy.movement.x - 1,
                        self.rng.next_value() % enemy.height + enemy.movement.y - 1,
                    ];
                    target = center;
                }
            }
            6..=8 => {
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    if lib.index == 6 {
                        "FX_GUN"
                    } else {
                        "FX_MISSLE"
                    },
                );
                offsets = vec![O_GUN2[bank], -O_GUN2[bank]];
            }
            9 => play_legacy_sound(
                &mut self.rng,
                &mut self.sounds,
                &mut self.sound_events,
                "FX_MISSLE",
            ),
            10 => {
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_GUN",
                );
                start[0] -= 4;
            }
            11 => {
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_GUN",
                );
                target = [160, 75];
            }
            12 => play_legacy_sound(
                &mut self.rng,
                &mut self.sounds,
                &mut self.sound_events,
                "FX_PULSE",
            ),
            13 => {
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_LASER",
                );
                offsets = vec![O_GUN3[bank], -O_GUN3[bank]];
                target[1] = -24;
            }
            14 => {
                play_legacy_sound(
                    &mut self.rng,
                    &mut self.sounds,
                    &mut self.sound_events,
                    "FX_LASER",
                );
                start[1] -= 24;
                target[1] = -24;
            }
            _ => {}
        }
        for (shot_number, offset) in offsets.into_iter().enumerate() {
            if self
                .projectiles
                .iter()
                .filter(|p| !p.hostile && p.legacy.is_some())
                .count()
                >= 70
            {
                break;
            }
            let x = start[0] + offset;
            let y = start[1];
            let frame = if lib.index <= 1 {
                self.rng.next_value() as u32 % lib.frames.max(1)
            } else {
                initial_frame.unwrap_or(0)
            };
            let mut target = target;
            if lib.index == 3 {
                target = [
                    x + if shot_number == 0 {
                        self.rng.next_value() % 16 + 10
                    } else {
                        -self.rng.next_value() % 16 - 10
                    },
                    y + 5,
                ];
            } else if lib.index != 4 && lib.index != 5 && lib.index != 11 {
                target[0] = x;
            }
            self.projectile(id, x, y, 0, -lib.speed, false)?;
            match lib.index {
                0 => visual_effect(
                    self.effects.len(),
                    &mut self.visual_effects,
                    VisualEffect::new(VisualEffectKind::Casing, x, y),
                ),
                5 => visual_effect(
                    self.effects.len(),
                    &mut self.visual_effects,
                    VisualEffect::new(VisualEffectKind::LaserImpact, x, y),
                ),
                6 => visual_effect(
                    self.effects.len(),
                    &mut self.visual_effects,
                    VisualEffect::new(
                        VisualEffectKind::Muzzle,
                        offset - i32::from(shot_number != 0),
                        1,
                    )
                    .attached(0),
                ),
                _ => (),
            }
            self.projectiles.last_mut().unwrap().legacy = Some(LegacyProjectile {
                movement: LineMove::new(x, y, target[0], target[1]),
                speed: lib.speed,
                frame,
                art_frame: frame,
                delay: lib.delay,
                hit: false,
                start: center,
            });
        }
        self.event(
            id.clone(),
            "on_fire",
            serde_json::json!({"entity":0,"hostile":false,"x":center[0],"y":center[1],"tick":self.tick}),
        );
        Ok(())
    }
    fn dispatch(&mut self, registry: &Registry, scripts: &mut ScriptRuntime) -> Result<()> {
        let mut processed = 0usize;
        while !self.events.is_empty() {
            let events = std::mem::take(&mut self.events);
            processed += events.len();
            ensure!(
                processed <= 8192,
                "too many cascading script events in one tick"
            );
            for event in events {
                let script = if matches!(event.hook, "on_use" | "on_pickup") {
                    registry
                        .items
                        .get(&event.content)
                        .and_then(|v| v.script.as_ref())
                } else {
                    registry
                        .weapons
                        .get(&event.content)
                        .and_then(|v| v.script.as_ref())
                        .or_else(|| {
                            registry
                                .enemies
                                .get(&event.content)
                                .and_then(|v| v.script.as_ref())
                        })
                        .or_else(|| {
                            registry
                                .missions
                                .get(&event.content)
                                .and_then(|v| v.script.as_ref())
                        })
                        .or_else(|| {
                            registry
                                .items
                                .get(&event.content)
                                .and_then(|v| v.script.as_ref())
                        })
                };
                if let Some(path) = script {
                    let owner = &registry.owners[&event.content];
                    let mut e = event.event;
                    e["entities"] = serde_json::to_value(&self.enemies)?;
                    for (snapshot, enemy) in e["entities"]
                        .as_array_mut()
                        .expect("enemy snapshot array")
                        .iter_mut()
                        .zip(&self.enemies)
                    {
                        snapshot["ground"] = registry.enemies[&enemy.definition].ground.into();
                    }
                    e["player"] = serde_json::to_value(&self.player)?;
                    e["objectives"] = serde_json::to_value(&self.objectives)?;
                    e["projectiles"] = serde_json::to_value(&self.projectiles)?;
                    e["pickups"] = serde_json::to_value(&self.pickups)?;
                    if e.get("tick").is_none() {
                        e["tick"] = self.tick.into();
                    }
                    let commands = scripts.invoke(owner, path, event.hook, &e, self.rng.seed)?;
                    self.apply_commands(&commands, registry).map_err(|error| {
                        let context = format!("{owner}/{path}::{}: {error}", event.hook);
                        error.context(context)
                    })?;
                }
            }
        }
        Ok(())
    }
    pub fn apply_commands(&mut self, commands: &[Command], registry: &Registry) -> Result<()> {
        let mut candidate = self.clone();
        for command in commands {
            candidate.command(command, registry)?;
            if matches!(command, Command::Move { .. } | Command::Despawn { .. }) {
                candidate.update_lightning_arcs();
            }
        }
        *self = candidate;
        Ok(())
    }
    fn lightning_anchor(
        &self,
        entity: Option<u64>,
        x: i32,
        y: i32,
    ) -> Result<Option<LightningAnchor>> {
        let Some(entity) = entity else {
            return Ok(None);
        };
        let [origin_x, origin_y] = if entity == 0 {
            [self.player.x, self.player.y]
        } else {
            let enemy = self
                .enemies
                .iter()
                .find(|enemy| enemy.entity == entity)
                .context("arc anchor does not exist")?;
            [enemy.x, enemy.y]
        };
        Ok(Some(LightningAnchor {
            entity,
            offset: [
                x.checked_sub(origin_x)
                    .context("arc anchor offset overflow")?,
                y.checked_sub(origin_y)
                    .context("arc anchor offset overflow")?,
            ],
        }))
    }
    fn update_lightning_arcs(&mut self) {
        let player = [self.player.x, self.player.y];
        let enemies = &self.enemies;
        for arc in &mut self.lightning_arcs {
            for (anchor, x, y) in [
                (&mut arc.anchor, &mut arc.x, &mut arc.y),
                (&mut arc.to_anchor, &mut arc.to_x, &mut arc.to_y),
            ] {
                let Some(attachment) = *anchor else {
                    continue;
                };
                let origin = if attachment.entity == 0 {
                    Some(player)
                } else {
                    enemies
                        .iter()
                        .find(|enemy| enemy.entity == attachment.entity)
                        .map(|enemy| [enemy.x, enemy.y])
                };
                if let Some([origin_x, origin_y]) = origin {
                    // An offscreen anchor cannot expand the cosmetic API's
                    // coordinate bounds or make movement fail gameplay.
                    *x = origin_x
                        .saturating_add(attachment.offset[0])
                        .clamp(-32768, 32768);
                    *y = origin_y
                        .saturating_add(attachment.offset[1])
                        .clamp(-32768, 32768);
                } else {
                    // Retain the last visible position when its ship disappears.
                    *anchor = None;
                }
            }
        }
    }
    fn command(&mut self, c: &Command, registry: &Registry) -> Result<()> {
        match c {
            Command::Spawn { enemy, x, y } => {
                ensure!(
                    x.unsigned_abs() <= 32768 && y.unsigned_abs() <= 32768,
                    "spawn position exceeds world bounds"
                );
                self.spawn(&ContentId::new(enemy)?, *x, *y, registry)?;
            }
            Command::Projectile {
                weapon,
                x,
                y,
                vx,
                vy,
                hostile,
            } => {
                let id = ContentId::new(weapon)?;
                ensure!(
                    registry.weapons.contains_key(&id)
                        && vx.unsigned_abs() <= 128
                        && vy.unsigned_abs() <= 128
                        && x.unsigned_abs() <= 32768
                        && y.unsigned_abs() <= 32768,
                    "invalid projectile command"
                );
                self.projectile(&id, *x, *y, *vx, *vy, *hostile)?;
            }
            Command::Damage { entity, amount } => {
                ensure!((0..=100000).contains(amount), "invalid damage");
                if *entity == 0 {
                    damage_player(
                        &mut self.player,
                        self.energy_overflow,
                        &mut self.super_shield_overflow,
                        *amount,
                        self.difficulty,
                        &mut self.rng,
                        &mut self.sounds,
                        &mut self.sound_events,
                        &mut self.visual_effects,
                        self.effects.len(),
                        self.legacy_transition && self.end_timer.is_some(),
                    );
                } else {
                    let e = self
                        .enemies
                        .iter_mut()
                        .find(|e| e.entity == *entity)
                        .context("damage target does not exist")?;
                    e.health -= amount;
                    let definition = e.definition.clone();
                    let health = e.health;
                    self.event(definition,"on_hit",serde_json::json!({"entity":entity,"damage":amount,"health":health,"scripted":true,"tick":self.tick}));
                }
            }
            Command::Despawn { entity } => {
                ensure!(
                    self.enemies.iter().any(|e| e.entity == *entity)
                        || self.projectiles.iter().any(|e| e.entity == *entity),
                    "despawn target does not exist"
                );
                self.enemies.retain(|e| e.entity != *entity);
                self.projectiles.retain(|e| e.entity != *entity);
            }
            Command::Move { entity, x, y } => {
                ensure!(
                    x.unsigned_abs() <= 32768 && y.unsigned_abs() <= 32768,
                    "invalid position"
                );
                let e = self
                    .enemies
                    .iter_mut()
                    .find(|e| e.entity == *entity)
                    .context("move target does not exist")?;
                let dx = *x - e.x;
                let dy = *y - e.y;
                e.x = *x;
                e.y = *y;
                e.sx += dx;
                e.sy += dy;
                e.movement = LineMove::new(*x, *y, e.movement.tx + dx, e.movement.ty + dy);
            }
            Command::Velocity { entity, vx, vy } => {
                ensure!(
                    vx.unsigned_abs() <= 128 && vy.unsigned_abs() <= 128,
                    "invalid velocity"
                );
                let e = self
                    .enemies
                    .iter_mut()
                    .find(|e| e.entity == *entity)
                    .context("velocity target does not exist")?;
                e.vx = *vx;
                e.vy = *vy;
            }
            Command::Animation { entity, frame } => {
                let e = self
                    .enemies
                    .iter_mut()
                    .find(|e| e.entity == *entity)
                    .context("animation target does not exist")?;
                let definition = &registry.enemies[&e.definition];
                ensure!(
                    definition.legacy.is_none(),
                    "scripted animation requires a nonlegacy enemy"
                );
                let art = definition
                    .art
                    .as_ref()
                    .context("animation target has no artwork")?;
                ensure!(
                    frame.is_none_or(|frame| frame < art.frames),
                    "animation frame exceeds declared artwork frames"
                );
                e.pinned_art_frame = *frame;
                e.art_frame = frame.unwrap_or(e.frame);
            }
            Command::GiveItem { item, count } => {
                let id = ContentId::new(item)?;
                let def = registry.items.get(&id).context("unknown item")?;
                ensure!(
                    self.player.inventory.contains_key(&id) || inventory_slots(&self.player) < 20,
                    "inventory capacity exceeded"
                );
                let amount = self.player.inventory.entry(id.clone()).or_default();
                let previous = *amount;
                *amount = add_with_capacity(previous, *count, def.max_count);
                if id.0 == "base:super_shield" {
                    if self.super_shield_overflow > 0 {
                        add_retained_charge(
                            &mut self.player.super_shield,
                            &mut self.super_shield_overflow,
                            amount.saturating_sub(previous),
                        );
                        *amount = (self.player.super_shield.max(0) as u32)
                            .saturating_add(self.super_shield_overflow);
                    } else if *amount > 100 {
                        self.player.super_shield = 100;
                        self.super_shield_overflow = amount.saturating_sub(100);
                    } else {
                        self.player.super_shield = *amount as i32;
                    }
                }
                if id.0 == "base:energy" {
                    if self.energy_overflow > 0 {
                        add_retained_charge(
                            &mut self.player.shield,
                            &mut self.energy_overflow,
                            amount.saturating_sub(previous),
                        );
                        *amount =
                            (self.player.shield.max(0) as u32).saturating_add(self.energy_overflow);
                    } else if *amount > 100 {
                        self.player.shield = 100;
                        self.energy_overflow = amount.saturating_sub(100);
                    } else {
                        self.player.shield = *amount as i32;
                    }
                }
            }
            Command::ConsumeItem { item, count } => {
                let id = ContentId::new(item)?;
                let amount = self
                    .player
                    .inventory
                    .get_mut(&id)
                    .context("item is not owned")?;
                ensure!(*amount >= *count, "insufficient item quantity");
                *amount -= count;
                if id.0 == "base:super_shield" {
                    if self.super_shield_overflow > 0 {
                        consume_retained_charge(
                            &mut self.player.super_shield,
                            &mut self.super_shield_overflow,
                            *count,
                        );
                    } else {
                        self.player.super_shield = *amount as i32;
                    }
                }
                if id.0 == "base:energy" {
                    if self.energy_overflow > 0 {
                        consume_retained_charge(
                            &mut self.player.shield,
                            &mut self.energy_overflow,
                            *count,
                        );
                    } else {
                        self.player.shield = *amount as i32;
                    }
                } else if id.0 != "base:super_shield" && *amount == 0 {
                    self.player.inventory.remove(&id);
                    if self.player.selected.as_ref() == Some(&id) {
                        self.player.selected = next_special(&self.player, registry);
                    }
                }
            }
            Command::Credits { amount } => {
                self.player.credits = self.player.credits.saturating_add_signed(*amount);
            }
            Command::Shield { amount } => {
                ensure!(amount.unsigned_abs() <= 100000, "invalid shield adjustment");
                self.player.shield = (self.player.shield + amount).clamp(0, 100);
                if self.energy_overflow > 0 {
                    if let Some(charge) = self
                        .player
                        .inventory
                        .get_mut(&ContentId::from("base:energy"))
                    {
                        *charge = (self.player.shield as u32).saturating_add(self.energy_overflow);
                    }
                }
            }
            Command::Effect { x, y, kind } => {
                ensure!(
                    x.unsigned_abs() <= 32768 && y.unsigned_abs() <= 32768,
                    "effect position exceeds world bounds"
                );
                ensure!(self.effects.len() < 4096, "too many effects");
                self.effects.push(Effect::new((*kind).into(), *x, *y));
            }
            Command::Arc {
                x,
                y,
                to_x,
                to_y,
                ticks,
                anchor,
                to_anchor,
            } => {
                ensure!(
                    [x, y, to_x, to_y].iter().all(|n| n.unsigned_abs() <= 32768),
                    "arc position exceeds world bounds"
                );
                ensure!((1..=12).contains(ticks), "arc lifetime must be 1–12 ticks");
                ensure!(
                    self.lightning_arcs.len() < MAX_LIGHTNING_ARCS,
                    "too many lightning arcs"
                );
                let anchor = self.lightning_anchor(*anchor, *x, *y)?;
                let to_anchor = self.lightning_anchor(*to_anchor, *to_x, *to_y)?;
                self.lightning_arcs.push(LightningArc {
                    x: *x,
                    y: *y,
                    to_x: *to_x,
                    to_y: *to_y,
                    ticks: *ticks,
                    age: 0,
                    seed: (self.tick as u32).wrapping_mul(0x1656_67b1)
                        ^ ((self.tick >> 32) as u32)
                        ^ (self.lightning_arcs.len() as u32).wrapping_mul(0x9e37_79b9),
                    anchor,
                    to_anchor,
                });
            }
            Command::Sound { asset } => {
                self.sounds.push(*asset);
                self.sound_events.push(SoundEvent {
                    asset: *asset,
                    pan: 127,
                    pitch: 128,
                    volume: 127,
                    priority: 1,
                });
            }
            Command::Objective { key, value } => {
                ensure!(
                    key.len() <= 128
                        && (self.objectives.contains_key(key) || self.objectives.len() < 1024),
                    "invalid objective key"
                );
                self.objectives.insert(key.clone(), *value);
            }
            Command::PlaySound { sound } => {
                let id = ContentId::new(sound)?;
                ensure!(
                    registry.sounds.contains_key(&id),
                    "sound {id} is unavailable"
                );
                ensure!(self.mod_sounds.len() < 1024, "too many sounds in one tick");
                self.mod_sounds.push(id);
            }
            Command::Complete => {
                if self.outcome == Outcome::Playing {
                    self.outcome = Outcome::Complete;
                    self.event(
                        self.mission.clone(),
                        "on_mission_end",
                        serde_json::json!({"success":true,"tick":self.tick}),
                    );
                }
            }
            Command::Fail => {
                if self.outcome == Outcome::Playing {
                    self.outcome = Outcome::Failed;
                    self.event(
                        self.mission.clone(),
                        "on_mission_end",
                        serde_json::json!({"success":false,"tick":self.tick}),
                    );
                }
            }
        }
        Ok(())
    }
    pub fn digest(&self) -> String {
        use sha2::{Digest, Sha256};
        format!(
            "{:x}",
            Sha256::digest(serde_json::to_vec(self).expect("world serialization"))
        )
    }
    pub fn projectile_asset(p: &Projectile, registry: &Registry) -> Option<u32> {
        p.legacy_enemy.as_ref().map(|s| s.asset).or_else(|| {
            registry.weapons[&p.weapon]
                .art
                .as_ref()
                .and_then(|a| a.asset)
        })
    }
    pub fn reference_state(&self, registry: &Registry) -> serde_json::Value {
        serde_json::json!({"tick":self.tick,"rng":self.rng.seed,"player":[self.player.x,self.player.y,self.player.bank,self.player.shield,self.player.super_shield,self.player.credits],"enemies":self.enemies.iter().map(|e|serde_json::json!([registry.enemies[&e.definition].art.as_ref().and_then(|a|a.asset).unwrap_or(0),e.x,e.y,e.health,e.frame,e.movement.x,e.movement.y])).collect::<Vec<_>>(),"projectiles":self.projectiles.iter().filter(|p|p.hostile).chain(self.projectiles.iter().filter(|p|!p.hostile)).map(|p|serde_json::json!([Self::projectile_asset(p,registry).map(i64::from).unwrap_or(-1),p.x,p.y,p.hostile as u32])).collect::<Vec<_>>()})
    }
}
fn initial_shield_latch() -> i32 {
    -1
}
fn visible_player() -> bool {
    true
}
fn bank_player(player: &mut Player, old_x: i32) {
    let delta = ((player.x - old_x).abs() >> 2).min(3);
    if player.x < old_x {
        if player.bank < 3 + delta {
            player.bank += 1;
        }
    } else if player.x > old_x {
        if player.bank > 3 - delta {
            player.bank -= 1;
        }
    } else {
        player.bank += (3 - player.bank).signum();
    }
}
fn next_special(player: &Player, registry: &Registry) -> Option<ContentId> {
    let mut specials: Vec<_> = player
        .inventory
        .iter()
        .filter_map(|(id, count)| {
            registry
                .items
                .get(id)
                .filter(|item| *count > 0 && item.special)
                .map(|item| ((item.legacy.unwrap_or(u32::MAX), id.clone()), id.clone()))
        })
        .collect();
    specials.sort_by(|a, b| a.0.cmp(&b.0));
    let after = player.selected.as_ref().map(|id| {
        (
            registry
                .items
                .get(id)
                .and_then(|item| item.legacy)
                .unwrap_or(u32::MAX),
            id.clone(),
        )
    });
    specials
        .iter()
        .find(|(key, _)| after.as_ref().is_none_or(|after| key > after))
        .or_else(|| specials.first())
        .map(|(_, id)| id.clone())
}
fn update_legacy_animation(enemy: &mut Enemy, lib: &crate::assets::LegacyEnemy) {
    let f = &lib.fields;
    enemy.art_frame = enemy.frame;
    if f[7] > 1 {
        if enemy.frame_timer < 1 {
            enemy.frame_timer = f[6];
            if enemy.animation_on {
                enemy.frame += 1;
                if enemy.frame >= enemy.animation_frames {
                    enemy.frame = enemy.frame.saturating_sub(f[9].max(0) as u32);
                    match f[10] {
                        1 => {
                            enemy.animation_on = false;
                            enemy.shoot_on = true;
                        }
                        2 => match enemy.multi {
                            1 => {
                                enemy.animation_frames = f[7].max(1) as u32;
                                enemy.multi = 2;
                            }
                            2 => enemy.shoot_on = true,
                            _ => {}
                        },
                        _ => {}
                    }
                }
            }
        } else {
            enemy.frame_timer -= 1;
        }
        if enemy.countdown < 1 {
            match f[10] {
                0 => enemy.shoot_on = true,
                1 => enemy.animation_on = true,
                2 if enemy.multi == 0 => enemy.multi = 1,
                _ => {}
            }
        } else {
            enemy.countdown -= f[18];
        }
    } else if enemy.countdown < 1 {
        enemy.countdown = -1;
        enemy.shoot_on = true;
    } else {
        enemy.countdown -= f[18];
    }
}
fn visible(e: &Enemy) -> bool {
    e.y + e.height > 0 && e.y < 200 && e.x + e.width > 0 && e.x < 320
}
fn play_legacy_sound(
    rng: &mut LegacyRng,
    sounds: &mut Vec<u32>,
    events: &mut Vec<SoundEvent>,
    name: &str,
) {
    if let Some(sound) = crate::legacy_tables::sounds()
        .into_iter()
        .find(|s| s.name == name)
    {
        let pitch = sound.pitch
            + if sound.random {
                rng.next_value() % 40 - 20
            } else {
                0
            };
        sounds.push(sound.asset);
        events.push(SoundEvent {
            asset: sound.asset,
            pan: 127,
            pitch,
            volume: sound.volume,
            priority: sound.priority,
        });
    }
}
fn position_sound(events: &mut [SoundEvent], x: i32, y: i32, player_x: i32, player_y: i32) {
    if let Some(event) = events.last_mut() {
        let dx = x - player_x;
        let dy = y - player_y;
        event.pan = (dx + 127).clamp(1, 255);
        let dx = dx.abs();
        let dy = dy.abs();
        let distance = dx + dy - dx.min(dy) / 2;
        let volume = if distance < 40 {
            127
        } else if distance > 500 {
            1
        } else {
            127 - (distance - 40) * 127 / 460
        };
        event.volume = event.volume * volume / 127;
    }
}
fn accelerate(v: i32, direction: i32, cap: i32) -> i32 {
    match direction.signum() {
        -1 => (if v >= 0 { -1 } else { v } - 1).max(-cap),
        1 => (if v <= 0 { 1 } else { v } + 1).min(cap),
        _ => v / 2,
    }
}
fn damage_player(
    p: &mut Player,
    energy_overflow: u32,
    super_shield_overflow: &mut u32,
    damage: i32,
    difficulty: u32,
    rng: &mut LegacyRng,
    sounds: &mut Vec<u32>,
    events: &mut Vec<SoundEvent>,
    visuals: &mut Vec<VisualEffect>,
    effect_count: usize,
    immune: bool,
) {
    if immune {
        return;
    }
    let damage = if difficulty == 0 && damage > 1 {
        damage >> 1
    } else {
        damage
    };
    let super_id = ContentId::from("base:super_shield");
    if p.inventory.contains_key(&super_id) {
        visual_effect(
            effect_count,
            visuals,
            VisualEffect::new(VisualEffectKind::Shield, 0, 0).attached(0),
        );
        // Original super shields absorb the whole hit, even when it exhausts them.
        // A zero-charge shield remains equipped until another hit removes it.
        p.super_shield -= damage;
        play_legacy_sound(rng, sounds, events, "FX_SHIT");
        if p.super_shield < 0 {
            // The exhausted module is actually destroyed. Its retained charge
            // must not migrate into a replacement module or revive this one.
            *super_shield_overflow = 0;
            if p.super_shield_reserves.is_empty() {
                p.super_shield = 0;
                p.inventory.remove(&super_id);
            } else {
                let charge = p.super_shield_reserves.remove(0);
                p.super_shield = charge.min(100) as i32;
                *super_shield_overflow = charge.saturating_sub(100);
                p.inventory.insert(super_id.clone(), charge);
            }
        } else {
            p.inventory.insert(
                super_id,
                (p.super_shield as u32).saturating_add(*super_shield_overflow),
            );
        }
    } else {
        p.shield = (p.shield - damage).max(0);
        if let Some(charge) = p.inventory.get_mut(&ContentId::from("base:energy")) {
            *charge = (p.shield as u32).saturating_add(energy_overflow);
        }
        play_legacy_sound(rng, sounds, events, "FX_HIT");
    }
}
fn add_energy(p: &mut Player, amount: i32, energy_overflow: u32, super_shield_overflow: u32) {
    if !p.inventory.contains_key(&ContentId::from("base:energy")) {
        return;
    }
    if p.shield < 100 {
        p.shield = (p.shield + amount).clamp(0, 100);
        p.inventory.insert(
            "base:energy".into(),
            (p.shield as u32).saturating_add(energy_overflow),
        );
    } else if p
        .inventory
        .contains_key(&ContentId::from("base:super_shield"))
        && p.super_shield > 0
    {
        p.super_shield = (p.super_shield + (amount >> 2)).min(100);
        p.inventory.insert(
            "base:super_shield".into(),
            (p.super_shield as u32).saturating_add(super_shield_overflow),
        );
    }
}
fn is_zero(value: &u32) -> bool {
    *value == 0
}
fn add_with_capacity(current: u32, additional: u32, capacity: u32) -> u32 {
    // A smaller replacement definition can prevent new acquisitions, but an
    // additive action cannot destroy quantities already accepted from a save.
    current.max(current.saturating_add(additional).min(capacity))
}
fn add_retained_charge(usable: &mut i32, overflow: &mut u32, additional: u32) {
    let before = (*usable).max(0) as u32;
    let after = before.saturating_add(additional).min(100);
    *usable = after as i32;
    *overflow = overflow.saturating_add(additional.saturating_sub(after.saturating_sub(before)));
}
fn consume_retained_charge(usable: &mut i32, overflow: &mut u32, count: u32) {
    let before = (*usable).max(0) as u32;
    *usable = before.saturating_sub(count) as i32;
    *overflow = overflow.saturating_sub(count.saturating_sub(before));
}
fn inventory_slots(p: &Player) -> usize {
    p.inventory.len() + p.super_shield_reserves.len()
}
fn target_matches(t: &Target, ground: bool) -> bool {
    match t {
        Target::All => true,
        Target::Air => !ground,
        Target::Ground => ground,
    }
}
fn contains(e: &Enemy, x: i32, y: i32) -> bool {
    x > e.x && x < e.x + e.width - 1 && y > e.y && y < e.y + e.height - 1
}
/// Accumulate exact rational time without rounding the original 3/70-second tick.
#[derive(Default)]
pub struct Clock {
    units: u128,
}
impl Clock {
    pub fn advance(&mut self, nanos: u64) -> usize {
        self.units += nanos as u128 * 70;
        let steps = self.units / 3_000_000_000;
        self.units %= 3_000_000_000;
        steps as usize
    }
    pub fn alpha(&self) -> f32 {
        self.units as f32 / 3_000_000_000.0
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn rng_wraps_like_legacy() {
        let mut r = LegacyRng::new(1);
        assert_eq!(
            (0..5).map(|_| r.next_value()).collect::<Vec<_>>(),
            vec![16838, 5758, 10113, 17515, 31051]
        );
    }
    #[test]
    fn clock_is_independent_of_frame_rate() {
        for hz in [30, 60, 144] {
            let mut c = Clock::default();
            let mut ticks = 0;
            let mut previous = 0;
            for frame in 1..=hz * 3 {
                let now = frame as u64 * 1_000_000_000 / hz as u64;
                ticks += c.advance(now - previous);
                previous = now;
            }
            assert_eq!(ticks, 70);
        }
    }
    #[test]
    fn line_reaches_target() {
        let mut m = LineMove::new(0, 0, 10, 7);
        for _ in 0..20 {
            m.advance(1);
        }
        assert_eq!((m.x, m.y), (10, 7));
    }
}