overlord_event_system/logic/

fighting.rs

use crate::{
    TICKER_UNIT_DURATION_MS,
    behaviors::combat::start_cast::StartCastAbilityResult,
    entities::{create_pve_entity, event_from_entity_action},
    event::CustomEventData,
    event::OverlordEvent,
    game_config_helpers::GameConfigLookup,
    logic::handler::OverlordLogic,
    state::OverlordState,
};

use essences::{
    abilities::{AbilityId, AbilitySlotId},
    combat_origin::CombatEventOrigin,
    currency::{CurrencySource, CurrencyUnit},
    entity::{ActionWithDeadline, Coordinates, Entity, EntityAttributes, EntityId},
    fight_breakdown::CombatSource,
    fighting::{ActiveFight, EntityTeam, EntityType, FightEntity, FightType},
    game::EntityTemplateId,
};
use event_system::{event::EventPluginized, script::random::GameRng, system::EventHandleResult};

use rand::RngExt;
use uuid::Uuid;

const GAMBLING_INSURANCE_CHARGES_ATTR: &str = "gambling.insurance_charges";

fn consume_insurance_on_lethal_hit(entity: &mut Entity, damage: u64) -> bool {
    if damage == 0
        || entity.hp == 0
        || damage < entity.hp
        || entity
            .attributes
            .0
            .get(GAMBLING_INSURANCE_CHARGES_ATTR)
            .copied()
            .unwrap_or(0)
            <= 0
    {
        return false;
    }

    entity.attributes.add(GAMBLING_INSURANCE_CHARGES_ATTR, -1);
    true
}

/// The breakdown actor `by_entity_id` names, or the unowned row when the amount
/// carries no dealer (a DoT tick, a fight-start script) or its dealer has
/// already left the field.
fn breakdown_actor(
    active_fight: &ActiveFight,
    by_entity_id: Option<EntityId>,
) -> crate::fight::BreakdownActor {
    by_entity_id
        .and_then(|id| active_fight.entities.iter().find(|entity| entity.id == id))
        .map(crate::fight::BreakdownActor::from_entity)
        .unwrap_or_else(crate::fight::BreakdownActor::unowned)
}

fn remove_hp_with_insurance(entity: &mut Entity, damage: u64) -> (u64, bool) {
    let insurance_consumed = consume_insurance_on_lethal_hit(entity, damage);
    let max_hp_removed = if insurance_consumed {
        entity.hp.saturating_sub(1)
    } else {
        entity.hp
    };
    let actual_hp_removed = damage.min(max_hp_removed);
    entity.hp -= actual_hp_removed;
    (actual_hp_removed, insurance_consumed)
}

pub(super) struct FlipProgressMetrics {
    pub(super) gains: opentelemetry::metrics::Counter<u64>,
    pub(super) amount: opentelemetry::metrics::Histogram<f64>,
    pub(super) flips: opentelemetry::metrics::Counter<u64>,
}

/// Shared by every gauge producer. Each records with a `source` label — a
/// producer that skips these is simply invisible on the dashboard.
pub(super) fn flip_progress_metrics() -> &'static FlipProgressMetrics {
    static METRICS: std::sync::OnceLock<FlipProgressMetrics> = std::sync::OnceLock::new();
    METRICS.get_or_init(|| {
        let meter = opentelemetry::global::meter("flip_progress");
        FlipProgressMetrics {
            gains: meter.u64_counter("flip_progress_gains_total").build(),
            amount: meter
                .f64_histogram("flip_progress_amount")
                .with_boundaries(vec![0.001, 0.01, 0.05, 0.1, 0.25, 0.5, 1.0])
                .build(),
            flips: meter.u64_counter("global_flips_total").build(),
        }
    })
}

/// Multiplier applied to a campaign-chapter boss's currency drop so that
/// deeper chapters pay out more ("pushing pays"). Grows geometrically as
/// `growth^chapter_level`, bounded by `cap` (and a hard sane ceiling so a
/// cheated/extreme chapter can never produce an infinite reward). Returns
/// `1.0` (no scaling) when growth is unset or `<= 1.0`.
fn boss_reward_chapter_multiplier(
    growth: Option<f64>,
    cap: Option<f64>,
    chapter_level: i64,
) -> f64 {
    let Some(growth) = growth else { return 1.0 };
    if growth <= 1.0 {
        return 1.0;
    }
    // `min(1e6)` guards against `f64::INFINITY` at extreme chapter levels even
    // when no config cap is set; `clamp(0, 1000)` keeps the `powi` exponent sane.
    let cap = cap.unwrap_or(f64::INFINITY).min(1.0e6);
    let exp = chapter_level.clamp(0, 1000) as i32;
    growth.powi(exp).clamp(1.0, cap)
}

impl OverlordLogic {
    fn compute_ability_slot_level(
        &self,
        slot_id: Option<AbilitySlotId>,
        state: &OverlordState,
    ) -> i64 {
        let Some(slot_id) = slot_id else {
            return 0;
        };

        let game_config = self.game_config.get();
        let slot_level = state
            .character_state
            .character
            .ability_slot_levels
            .get(slot_id)
            .copied()
            .unwrap_or(0)
            .max(0);
        game_config
            .game_settings
            .ability_gacha
            .slot_level_bonus_levels
            .get(slot_level as usize)
            .copied()
            .or_else(|| {
                game_config
                    .game_settings
                    .ability_gacha
                    .slot_level_bonus_levels
                    .last()
                    .copied()
            })
            .unwrap_or(0)
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_spawn_entity(
        &mut self,
        id: EntityId,
        entity_template_id: EntityTemplateId,
        position: Coordinates,
        team: EntityTeam,
        has_big_hp_bar: bool,
        entity_attributes: EntityAttributes,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // A delayed next-wave spawn (the 0.5 s between-wave pause schedules SpawnEntity events on
        // the fight clock) can be delivered after the fight already ended — e.g. the player died
        // or the max-duration EndFight fired inside the pause window. Drop it.
        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        if active_fight.entities.iter().any(|entity| entity.id == id) {
            tracing::error!("There is already an entity with id: {id}");
            return EventHandleResult::fail(state);
        }

        let fight_entity = FightEntity {
            entity_type: EntityType::PVEEntity { entity_template_id },
            position: position.clone(),
            has_big_hp_bar,
            team: team.clone(),
        };

        let mut created_entity =
            match create_pve_entity(id, &fight_entity, &game_config, Some(entity_attributes)) {
                Ok(entity) => entity,
                Err(err) => {
                    tracing::error!("Couldn't create entity: {}", err.to_string());
                    return EventHandleResult::fail(state);
                }
            };

        if active_fight.current_wave > 1 {
            created_entity.abilities.iter().for_each(|ability| {
                let cooldown = game_config
                    .ability_template(ability.ability.template_id)
                    .map(|t| t.cooldown)
                    .unwrap_or(0);
                // A spawned combatant fights with its own Core actions, whoever
                // spawned it — see `OverlordEvent::carried_origin`.
                created_entity.actions_queue.push(&ActionWithDeadline::core(
                    self.make_start_cast_ability_action(
                        created_entity.id,
                        ability.ability.template_id,
                    ),
                    current_tick + cooldown,
                ))
            });
        }

        // Wave entrance (combat-feel port): a wave mob spawns the configured
        // entrance offset beyond its battle cell (off-screen) and runs
        // onto it as a real scheduled server move, timed to land right at its
        // wake (an awake spawn — delay 0 or a streaming pool release — runs in
        // immediately). The client just renders the StartMove segment, so the
        // entrance is uniform-speed and desync-free by construction. Gated to
        // enemy mobs of wave fights: PvP opponents and summons spawn in place.
        let wave_fight_template = game_config
            .require_fight_template(active_fight.fight_id)
            .ok()
            .filter(|t| t.prepare_fight_waves.is_some());
        // Death-gated mobs (`exit_gated`, the revived streaming cap) park with
        // NO timer: `handle_entity_death` schedules their entrance when a kill
        // frees their queue position.
        let exit_gated = created_entity.attributes.0.contains_key("exit_gated");
        if team == EntityTeam::Enemy
            && !exit_gated
            && let Some(template) = wave_fight_template
        {
            // Opening echelon rushes (lab waveRushMult 2.5); later echelons and
            // streaming pool releases walk (waveRushMultLater 1.0).
            let ms_per_cell = if created_entity.attributes.0.contains_key("entrance_rush") {
                game_config.fight_settings.wave_entrance_rush_ms_per_cell
            } else {
                game_config.fight_settings.wave_entrance_walk_ms_per_cell
            };
            let entrance_offset_cells = game_config.fight_settings.wave_entrance_offset_cells;
            let run_ticks = entrance_offset_cells.max(0) as u64 * ms_per_cell;
            // Slot model (§2.6): the unit exits from behind the screen edge at
            // its config cooldown, counted from the wave's spawn batch. The
            // floor keeps every exit behind the ally side's own arrival: wave 1
            // waits for StartFight (the hero's client run-in lands exactly
            // then), later waves for the formation dash landing — dash and
            // exits count from the same batch tick, so cooldown-0 units step
            // out right as the formation plants.
            let cooldown_ticks = created_entity
                .attributes
                .0
                .get("exit_cooldown_ms")
                .copied()
                .unwrap_or(0)
                .max(0) as u64;
            let floor_ticks = if active_fight.current_wave == 1 {
                template
                    .start_fight_delay_ticks
                    .unwrap_or(game_config.fight_settings.start_fight_delay_ticks_default)
            } else {
                crate::mechanics::fight::later_wave_entrance_floor_ticks(&game_config, active_fight)
            };
            let start_ticks = cooldown_ticks.max(floor_ticks);
            let battle_cell = Coordinates {
                x: position.x - entrance_offset_cells,
                y: position.y,
            };
            self.fight_clock.schedule(
                OverlordEvent::StartMove {
                    entity_id: id,
                    to: battle_cell,
                    duration_ticks: run_ticks,
                },
                start_ticks.max(1),
            );
        }

        // Boss-summon: record reinforcement ids so kill quests can skip their
        // deaths (the entity is gone from `entities` by quest-tick time).
        if team == EntityTeam::Enemy && created_entity.attributes.is_summoned() {
            active_fight.summoned_entity_ids.push(id);
        }

        active_fight.entities.push(created_entity);

        EventHandleResult::ok(state)
    }
    pub fn handle_start_move(
        &mut self,
        entity_id: Uuid,
        to: Coordinates,
        duration_ticks: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to find entity in state with id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        // Marks the entity as moving and reserves the destination for the whole
        // run so a concurrently-planning opponent's `advance_entity` will not
        // commit a run onto (or through) it. Cleared by `handle_end_move`.
        entity.move_target = Some(to.clone());

        // Walk the coordinates cell-by-cell over the run instead of teleporting
        // to the destination: opponents must target the cell the runner is
        // actually passing — a multi-cell run would otherwise let them engage
        // him at the destination the moment he starts running.
        let steps = move_progress_steps(&entity.coordinates, &to, duration_ticks);
        if let Some((_, first)) = steps.first() {
            entity.coordinates = first.clone();
        }
        for (delay_ticks, cell) in steps.into_iter().skip(1) {
            self.fight_clock.schedule(
                OverlordEvent::MoveProgress {
                    entity_id,
                    to: cell,
                },
                delay_ticks,
            );
        }

        self.fight_clock
            .schedule(OverlordEvent::EndMove { entity_id }, duration_ticks);

        EventHandleResult::ok(state)
    }

    pub fn handle_move_progress(
        &self,
        entity_id: Uuid,
        to: Coordinates,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // The runner can die or the move can end before a scheduled waypoint
        // fires; a stale waypoint is normal, not an error.
        if let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
            && entity.move_target.is_some()
        {
            entity.coordinates = to;
        }

        EventHandleResult::ok(state)
    }

    /// Slot-model promotion (docs/combat-grid-migration-plan.md §2.2): when the
    /// near column has emptied while the far column holds a living enemy, the
    /// whole ally formation steps one column forward — the sliding window moves
    /// with the hero, so the old far column IS the new melee column. Fired on
    /// enemy deaths and enemy landings; gated to wave fights (PvP/summon
    /// opponents spawn in place and never promote).
    fn slot_promotion_events(
        &self,
        active_fight: &ActiveFight,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let game_config = self.game_config.get();
        let is_wave_fight = game_config
            .require_fight_template(active_fight.fight_id)
            .ok()
            .is_some_and(|t| t.prepare_fight_waves.is_some());
        if !is_wave_fight || !crate::mechanics::fight::slot_promotion_needed(active_fight) {
            return Vec::new();
        }
        let step_ticks =
            crate::mechanics::fight::formation_step_duration_ticks(self.behaviors.lookups(), 1.0);
        active_fight
            .entities
            .iter()
            .filter(|e| e.team == EntityTeam::Ally && e.hp > 0 && e.move_target.is_none())
            .map(|e| {
                EventPluginized::now(OverlordEvent::StartMove {
                    entity_id: e.id,
                    to: Coordinates {
                        x: e.coordinates.x + 1,
                        y: e.coordinates.y,
                    },
                    duration_ticks: step_ticks,
                })
            })
            .collect()
    }

    pub fn handle_end_move(
        &self,
        entity_id: Uuid,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to find entity in state with id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        // Arrived: release the cell reservation (also clears the moving state).
        entity.move_target = None;

        // EVERY landing re-checks promotion, not just enemy entrances filling
        // the far column: the HERO's own landing is the only re-check point for
        // a near-column death that happened while he was mid-move — the
        // death-side check declines while the player moves, and without this
        // the formation never steps and the hero busy-stands out of reach
        // until the timeout (the "hero just stands there" mid-wave deadlock).
        let mut events = vec![EventPluginized::now(OverlordEvent::FightProgress {})];
        events.extend(self.slot_promotion_events(active_fight));

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_entity_stun(
        &mut self,
        entity_id: Uuid,
        duration_ticks: u64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let baseline_speed = game_config.game_settings.baseline_speed;
        let player_id = state.active_fight.as_ref().map(|f| f.player_id);

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("EntityStun received with no active fight (entity_id = {entity_id})");
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::error!("EntityStun: entity_id = {entity_id} not found in active fight");
            return EventHandleResult::fail(state);
        };

        let entity_speed = entity.attributes.speed_or_baseline(baseline_speed);
        let ability_ids: Vec<AbilityId> = entity
            .abilities
            .iter()
            .map(|aa| aa.ability.template_id)
            .collect();
        // A StartCastAbility popped this same tick is already in flight as an event and can't be
        // frozen through the queue — record the stun window so its handler skips the cast.
        entity.attributes.set(
            crate::fight::STUN_UNTIL_TICK_ATTR,
            (current_tick + duration_ticks).min(i64::MAX as u64) as i64,
        );

        for ability_id in ability_ids {
            let base_cooldown = game_config
                .ability_template(ability_id)
                .map(|t| t.cooldown)
                .unwrap_or(0);
            let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                base_cooldown,
                entity_speed,
                baseline_speed,
            );
            entity.actions_queue.stun_ability(
                ability_id,
                duration_ticks,
                scaled_cooldown,
                current_tick,
            );
        }

        // Mirror the stun to the player's wall-clock ActiveAbility.deadline values so Unity's
        // cooldown bars freeze for the stun duration. For each ability:
        // - mid-cast (deadline was None or in the past) → set deadline = now + full + stun
        // - on cooldown → extend deadline by stun_duration_ms
        // - off cooldown (no deadline) → set deadline = now + stun_duration_ms
        if Some(entity.id) == player_id {
            let now = ::time::utc_now();
            let stun_ms = (duration_ticks as u128 * TICKER_UNIT_DURATION_MS) as i64;
            for active_ability in entity.abilities.iter_mut() {
                let base_cooldown = game_config
                    .ability_template(active_ability.ability.template_id)
                    .map(|t| t.cooldown)
                    .unwrap_or(0);
                let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                    base_cooldown,
                    entity_speed,
                    baseline_speed,
                );
                let cooldown_ms = (scaled_cooldown as u128 * TICKER_UNIT_DURATION_MS) as i64;

                let new_deadline = match active_ability.deadline {
                    Some(existing) if existing > now => {
                        // On cooldown — extend by stun duration.
                        existing + chrono::TimeDelta::milliseconds(stun_ms)
                    }
                    _ => {
                        // Off cooldown OR mid-cast (no current deadline tracked client-side).
                        // The queue's cancel-cast logic above already handled the in-flight case;
                        // here we just expose the resulting freeze duration to the client. Use
                        // full + stun to match the queue, falling back to stun-only when there is
                        // no full cooldown (e.g. ability_template missing).
                        let total_ms = if base_cooldown > 0 {
                            cooldown_ms + stun_ms
                        } else {
                            stun_ms
                        };
                        now + chrono::TimeDelta::milliseconds(total_ms)
                    }
                };
                active_ability.deadline = Some(new_deadline);
            }
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_cancel_cast_with_cooldown(
        &mut self,
        entity_id: Uuid,
        ability_id: Uuid,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!(
                "EntityCancelCastWithCooldown received with no active fight (entity_id = {entity_id})"
            );
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::error!(
                "EntityCancelCastWithCooldown: entity_id = {entity_id} not found in active fight"
            );
            return EventHandleResult::fail(state);
        };

        let Some(ability_template) = game_config.ability_template(ability_id) else {
            tracing::error!(
                "EntityCancelCastWithCooldown: ability_template not found for ability_id = {ability_id}"
            );
            return EventHandleResult::fail(state);
        };
        let cooldown = ability_template.cooldown;

        let cancelled = entity
            .actions_queue
            .cancel_cast_and_set_cooldown(ability_id, current_tick + cooldown);

        if !cancelled {
            tracing::error!(
                "EntityCancelCastWithCooldown: no in-flight cast for ability_id = {ability_id} on entity {entity_id}"
            );
            return EventHandleResult::fail(state);
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_add_ability_cooldown(
        &mut self,
        entity_id: Uuid,
        ability_id: Uuid,
        delta_ticks: i64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!(
                "EntityAddAbilityCooldown received with no active fight (entity_id = {entity_id})"
            );
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::error!(
                "EntityAddAbilityCooldown: entity_id = {entity_id} not found in active fight"
            );
            return EventHandleResult::fail(state);
        };

        if !entity
            .actions_queue
            .adjust_ability_cooldown(ability_id, delta_ticks, current_tick)
        {
            tracing::error!(
                "EntityAddAbilityCooldown: ability_id = {ability_id} not in cooldown queue for entity {entity_id}"
            );
            return EventHandleResult::fail(state);
        }

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_incr_attribute(
        &mut self,
        entity_id: Uuid,
        attribute: &str,
        delta: i64,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();
        let baseline_speed = game_config.game_settings.baseline_speed;
        let player_id = state.active_fight.as_ref().map(|f| f.player_id);

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::debug!("Couldn't find entity_id = {}", entity_id);
            return EventHandleResult::fail(state);
        };

        let old_speed = entity.attributes.speed_or_baseline(baseline_speed);
        entity.attributes.add(attribute, delta);
        // Consumable pools may never go negative.
        //
        // Each of these is spent by one code path and removed by another, and
        // the two race. A timed shield (Effect Stone) schedules the exact
        // inverse of what it granted; if `damage_entity` already spent the pool,
        // that inverse lands on an empty one. A negative `shield` then takes the
        // `dmg > shield` branch in `damage_entity`, where `dmg_hp = dmg - shield`
        // makes the victim take MORE damage than the hit, and
        // `custom_data.add("shield_damage", shield)` ships a negative absorb to
        // the client. The armed one-shots are the same shape: an over-consume
        // would sit negative and silently swallow the next arms instead of
        // applying them.
        //
        // Clamping at empty is the invariant both sides already assume.
        // (`set` drops zeros, so this removes the key outright.)
        const NON_NEGATIVE_POOLS: [&str; 3] = [
            "shield",
            crate::mechanics::stones::NEXT_ATTACK_BONUS,
            crate::mechanics::stones::NEXT_ATTACK_EXTRA_HITS,
        ];
        if NON_NEGATIVE_POOLS.contains(&attribute)
            && entity.attributes.0.get(attribute).is_some_and(|v| *v < 0)
        {
            entity.attributes.set(attribute, 0);
        }
        let new_speed = entity.attributes.speed_or_baseline(baseline_speed);

        if attribute == "speed" && old_speed != new_speed {
            entity.actions_queue.rescale_cooldowns(
                old_speed,
                new_speed,
                current_tick,
                baseline_speed,
            );

            if Some(entity.id) == player_id {
                let now = ::time::utc_now();
                let baseline = baseline_speed.max(1) as i128;
                let old_s = if old_speed <= 0 {
                    baseline
                } else {
                    old_speed as i128
                };
                let new_s = if new_speed <= 0 {
                    baseline
                } else {
                    new_speed as i128
                };
                for active_ability in entity.abilities.iter_mut() {
                    let Some(deadline) = active_ability.deadline else {
                        continue;
                    };
                    let remaining_ms = (deadline - now).num_milliseconds();
                    if remaining_ms <= 0 {
                        continue;
                    }
                    let scaled_ms = ((remaining_ms as i128) * old_s / new_s) as i64;
                    let scaled_ms = scaled_ms.max(1);
                    active_ability.deadline =
                        Some(now + chrono::TimeDelta::milliseconds(scaled_ms));
                }
            }
        }

        entity.effect_ids = entity
            .effect_ids
            .iter()
            .filter(|effect_id| {
                if let Some(effect) = game_config.effect(**effect_id) {
                    // tracing::error!("Found this effect: {effect:?}");
                    // tracing::error!("Got this attributes: {:?}", entity.attributes);
                    if effect.has_at_least_one_required_attribute(&entity.attributes) {
                        true
                    } else {
                        if effect.interval_ticks.is_some() {
                            entity.actions_queue.remove_cast_effect_action(effect.id);
                        }
                        false
                    }
                } else {
                    false
                }
            })
            .cloned()
            .collect();

        EventHandleResult::ok(state)
    }

    pub fn handle_entity_apply_effect(
        &mut self,
        entity_id: Uuid,
        effect_id: Uuid,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let dispatch_origin = self.dispatch_origin();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let game_config = self.game_config.get();

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::debug!("Couldn't find entity_id = {}", entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(effect) = game_config.require_effect(effect_id) else {
            tracing::debug!("Couldn't find effect_id = {}", effect_id);
            return EventHandleResult::fail(state);
        };

        if let Some(required_attributes) = &effect.required_attributes
            && !required_attributes
                .iter()
                .any(|attr| entity.attributes.0.contains_key(attr))
        {
            tracing::error!("Effect has required attributes, but they are not set");
            return EventHandleResult::fail(state);
        }

        for existing_effect_id in &entity.effect_ids {
            if *existing_effect_id == effect.id {
                tracing::error!("Effect is already set on entity");
                return EventHandleResult::fail(state);
            }
        }

        entity.effect_ids.push(effect.id);

        if let Some(interval_ticks) = &effect.interval_ticks {
            // A ticking effect armed by a modifier keeps that modifier's mark
            // on every tick it fires — the queue carries it across the hop.
            entity.actions_queue.push(&ActionWithDeadline {
                action: self.make_cast_effect_action(entity_id, effect.id),
                deadline_tick: current_tick + interval_ticks,
                origin: dispatch_origin,
            });
        }

        EventHandleResult::ok(state)
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_cast_effect(
        &mut self,
        entity_id: Uuid,
        effect_id: Uuid,
        caller_event: Option<Box<OverlordEvent>>,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let dispatch_origin = self.dispatch_origin();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let active_fight_cloned = active_fight.clone();

        let game_config = self.game_config.get();

        let Some(entity) = active_fight.entities.iter_mut().find(|e| e.id == entity_id) else {
            tracing::debug!("Couldn't find entity_id = {}", entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(effect) = game_config.require_effect(effect_id) else {
            tracing::debug!("Couldn't find effect_id = {}", effect_id);
            return EventHandleResult::fail(state);
        };

        if !entity.effect_ids.contains(&effect_id) {
            tracing::error!("entity_id = {} has no effect_id = {}", entity_id, effect_id);
            return EventHandleResult::fail(state);
        }

        let entity_cloned = entity.clone();

        // Native `event` (effect) port: look up the effect's `script` fn
        // and run it on the RNG snapshot.
        let Some(native_name) = effect.behavior.as_deref() else {
            tracing::error!("Effect {} has no script registered", effect_id);
            return EventHandleResult::fail(state);
        };
        let Some(native_fn) = self.behaviors.event_fn(native_name) else {
            tracing::error!("No native event fn registered for {native_name}");
            return EventHandleResult::fail(state);
        };

        let rng = GameRng::new(rand_gen);
        let events = match native_fn(&crate::behaviors::combat::effects::EventCtx {
            entity: &entity_cloned,
            fight: &active_fight_cloned,
            rng: &rng,
            current_tick,
            fight_duration_ticks: current_tick - self.start_fight_tick,
            caller_event: caller_event.as_deref(),
            config: &game_config,
            lookups: self.behaviors.lookups(),
        }) {
            Ok(events) => events,
            Err(err) => {
                tracing::error!("Effect script failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
        };

        if let Some(interval_ticks) = effect.interval_ticks {
            // Re-arm under the same mark the tick ran under — see
            // `handle_entity_apply_effect`.
            entity.actions_queue.push(&ActionWithDeadline {
                action: self.make_cast_effect_action(entity_id, effect.id),
                deadline_tick: current_tick + interval_ticks,
                origin: dispatch_origin,
            });
        }

        EventHandleResult::ok_events(
            state,
            events.into_iter().map(EventPluginized::now).collect(),
        )
    }

    pub fn handle_start_cast_ability(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        ability_id: AbilityId,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let dispatch_origin = self.dispatch_origin();

        let game_config = self.game_config.get();

        let state_cloned = state.clone();

        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active fight for start_cast_ability");
            return EventHandleResult::ok(state);
        };
        let active_fight_cloned = active_fight.clone();
        let Some(casted_by_entity) = active_fight
            .entities
            .iter_mut()
            .find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {}", by_entity_id);
            return EventHandleResult::fail(state);
        };
        let casted_by_entity_cloned = casted_by_entity.clone();
        let Some(active_ability) = casted_by_entity
            .abilities
            .iter()
            .find(|equipped_ability| equipped_ability.ability.template_id == ability_id)
            .cloned()
        else {
            tracing::error!(
                "Couldn't find ability_id = {} in caster entity {:?}",
                ability_id,
                casted_by_entity
            );
            return EventHandleResult::fail(state);
        };
        let ability = &active_ability.ability;
        let ability_template_id = ability.template_id;
        let ability_level = ability.level;

        let Some(ability_template) = game_config.ability_template(ability_template_id).cloned()
        else {
            tracing::error!(
                "Couldn't find template for ability_id = {}",
                ability_template_id
            );
            return EventHandleResult::fail(state);
        };
        let ability_cooldown = ability_template.cooldown;

        // Pets cast nothing, so every cast follows the cooldown metronome.
        let is_pet_ability = false;

        let _ability_slot_level =
            self.compute_ability_slot_level(active_ability.slot_id, &state_cloned);
        let _ = (ability_level, &state_cloned);

        // In-flight-pop stun race: this event was popped from the actions queue on the same
        // tick a stun landed, so the queue freeze couldn't reach it. Skip the cast and retry
        // once the stun ends (merges with the stun-placed cooldown entry).
        let stun_until = casted_by_entity_cloned
            .attributes
            .0
            .get(crate::fight::STUN_UNTIL_TICK_ATTR)
            .copied()
            .unwrap_or(0);
        if (current_tick as i64) < stun_until {
            if !is_pet_ability {
                casted_by_entity
                    .actions_queue
                    .push_start_cast_replacing(ability_template_id, stun_until as u64);
            }
            return EventHandleResult::ok(state);
        } else if stun_until != 0 {
            // Expired — drop the marker so it doesn't linger in synced state.
            casted_by_entity
                .attributes
                .0
                .remove(crate::fight::STUN_UNTIL_TICK_ATTR);
        }

        // Ability stones rescale this cast's cooldown, mana cost and cast time.
        // Nothing socketed (or a non-player caster) resolves to identity, so a
        // stoneless character casts on exactly the config numbers.
        let stone_mods = crate::mechanics::ability_stones::resolver_for_caster(
            &state_cloned,
            &casted_by_entity_cloned,
        )
        .mods_for(&game_config, ability_template_id, ability_level);
        let ability_cooldown = stone_mods.apply_cooldown(ability_cooldown);

        // Mana gate. A cast the pool cannot pay simply does not happen: the
        // ability waits for regen and retries at the tick regen will actually
        // cover the cost — ONE scheduled retry, not a 10 Hz poll of the actions
        // queue. `handle_fight_progress` pops a single action per entity per
        // heartbeat, so a per-heartbeat retry would also eat the slot of an
        // ability that CAN be paid for. The cooldown already served is NOT
        // restarted: the retry entry carries the refill tick, never a fresh
        // cooldown, and `push_start_cast_replacing` keeps the later deadline of
        // the two. Pet ults and mobs carry no pool and are never gated
        // (acceptance criterion 12).
        // The two Ledger Mimic facets, both of which price ONE original cast of
        // the player's: `Budget Plan` pays less for the next three, `Open Tab`
        // deliberately overpays for one and turns the surcharge into payload.
        // Both are inert for a mob, a pet ult, a Basic Attack and a derived
        // (non-Core) cast, so the ordinary mana gate below is unchanged for
        // everyone else. Read off the clone, because the pool is borrowed
        // mutably below.
        let pet_mana_facets_apply = !is_pet_ability
            && dispatch_origin.is_core()
            && by_entity_id == active_fight_cloned.player_id
            && crate::logic::combat_facts::cast_kind(
                &game_config,
                &casted_by_entity_cloned,
                ability_template_id,
            ) == crate::logic::combat_facts::CastKind::Skill;
        let pet_budget_multiplier = pet_mana_facets_apply
            .then(|| {
                crate::mechanics::pet_facets::armed(
                    &casted_by_entity_cloned,
                    crate::mechanics::pet_facets::BUDGET_MULT,
                    crate::mechanics::pet_facets::BUDGET_CASTS,
                )
            })
            .flatten();
        let pet_open_tab = pet_mana_facets_apply
            .then(|| {
                crate::mechanics::pet_facets::armed(
                    &casted_by_entity_cloned,
                    crate::mechanics::pet_facets::OPEN_TAB_SURCHARGE,
                    crate::mechanics::pet_facets::OPEN_TAB_CHARGES,
                )
            })
            .flatten()
            .map(|surcharge| {
                (
                    surcharge,
                    crate::mechanics::pet_facets::attr(
                        &casted_by_entity_cloned,
                        crate::mechanics::pet_facets::OPEN_TAB_PAYLOAD_SHARE,
                    ),
                )
            });
        // Written back after the pool is done with, so `Budget Plan`'s charge is
        // spent by the cast that actually got the discount and not by one the
        // pool refused.
        let mut pet_budget_spent = false;
        let mut pet_open_tab_payload: Option<i64> = None;
        let mut paid_mana_x100: Option<i64> = None;

        if !is_pet_ability && let Some(mana) = casted_by_entity.mana.as_mut() {
            let base_cost = stone_mods.apply_mana_cost(ability_template.mana_cost.max(0) as f64);
            // `Budget Plan`: "Mana Cost x0.75". Resonance is deliberately NOT
            // touched — in this codebase a law's Resonance is its template's own
            // number and was never priced off mana, so "Resonance equals the
            // price actually paid" is already true of a cheaper cast, and paying
            // any Resonance out here would break the rule that a facet creates
            // none.
            let mana_cost = match pet_budget_multiplier {
                Some(multiplier) => base_cost * (multiplier as f64 / 10_000.0),
                None => base_cost,
            };
            // BAL-015: the multipliers form one commutative product, rounded
            // mathematically exactly once after the last of them; there is no
            // minimum cost. The mana conditions then read this whole number.
            let mana_cost = mana_cost.round().max(0.0);
            mana.regen_to(current_tick);

            // `Open Tab`: overpay up to a share of the cost, but only out of
            // what is left AFTER the cast itself is paid for — "if mana is
            // available" is the whole gate, and a pool that cannot cover the
            // surcharge simply pays the ordinary price.
            let surcharge = match pet_open_tab {
                Some((surcharge_share, _)) if mana_cost > 0.0 => {
                    let wanted = mana_cost * (surcharge_share as f64 / 10_000.0);
                    (mana.current - mana_cost).max(0.0).min(wanted)
                }
                _ => 0.0,
            };

            if !mana.try_spend(mana_cost + surcharge) {
                // `None` = no regen at all, or a cost above the whole pool:
                // there is no refill tick to aim at, so fall back to the next
                // tick instead of parking the ability for the fight.
                let wait_ticks = mana.ms_until_affordable(mana_cost).unwrap_or(1).max(1);
                casted_by_entity
                    .actions_queue
                    .push_start_cast_replacing(ability_template_id, current_tick + wait_ticks);
                return EventHandleResult::ok(state);
            }

            // Paid: only now are the facet charges spent, so a cast the pool
            // refused keeps them for the next attempt.
            // The `Open Tab` surcharge is a deliberate overpay converted to
            // damage, not part of the Skill's price, so it is not recorded.
            paid_mana_x100 = Some((mana_cost * 100.0).round() as i64);
            pet_budget_spent = pet_budget_multiplier.is_some();
            if let Some((_, payload_share)) = pet_open_tab
                && surcharge > 0.0
                && mana_cost > 0.0
            {
                // The surcharge is mana and the payoff is damage, so the bonus
                // is the share OF THE RELATIVE overpay: paying the full 50%
                // surcharge at a 60% share arms +30%, and paying half of it
                // arms +15%.
                //
                // "+30%" here is +30% OF ATTACK, not of the cast's own payload —
                // `logic::pet_facets` spends this arm through the same
                // `Attack x share x DMG_K` conversion every other derived hit
                // uses. That is deliberate and NOT the `Second Spark`
                // convention (which repeats a share of what the Skill actually
                // landed): this facet converts MANA into damage, and mana has
                // no payload of its own to take a share of, so Attack is the
                // price. Read `open_tab_payload_share_percent`'s label the same
                // way — it is the share of the SURCHARGE that becomes a bonus,
                // not a share of the payload.
                pet_open_tab_payload =
                    Some(((payload_share as f64) * (surcharge / mana_cost)).round() as i64);
            }
        }

        // What the pool just charged, remembered for the mana conditions of
        // laws and trigger stones evaluated when this cast resolves. Guarded
        // like the cast-kind record (acceptance #14): written only when a law
        // or a socketed stone will read it. A cast that skipped the gate (a pet
        // ult, an entity with no pool) clears instead, so its resolution cannot
        // be priced at the previous cast's cost.
        let paid_mana_has_reader = !casted_by_entity.law_cores.laws.is_empty()
            || (by_entity_id == active_fight_cloned.player_id
                && state_cloned
                    .character_state
                    .stones
                    .all()
                    .any(|(_, stone)| stone.is_socketed()));
        match paid_mana_x100 {
            Some(paid) if paid_mana_has_reader => {
                crate::logic::combat_facts::record_paid_mana(casted_by_entity, paid);
            }
            _ => crate::logic::combat_facts::clear_paid_mana(casted_by_entity),
        }

        // Facet charges are spent on the entity itself, disjoint from the pool
        // borrow above.
        if pet_budget_spent {
            crate::mechanics::pet_facets::spend_charge(
                casted_by_entity,
                crate::mechanics::pet_facets::BUDGET_MULT,
                crate::mechanics::pet_facets::BUDGET_CASTS,
            );
        }
        if pet_open_tab.is_some() {
            crate::mechanics::pet_facets::spend_charge(
                casted_by_entity,
                crate::mechanics::pet_facets::OPEN_TAB_SURCHARGE,
                crate::mechanics::pet_facets::OPEN_TAB_CHARGES,
            );
            casted_by_entity
                .attributes
                .set(crate::mechanics::pet_facets::OPEN_TAB_PAYLOAD_SHARE, 0);
        }
        if let Some(bonus) = pet_open_tab_payload.filter(|bonus| *bonus != 0) {
            // Spent by the pet hook on this cast's own landed Core hit, as a
            // derived (`Proc`) hit beside the real one — the same shape every
            // other payload bonus in the game takes.
            casted_by_entity
                .attributes
                .set(crate::mechanics::pet_facets::NEXT_SKILL_BONUS, bonus);
            casted_by_entity
                .attributes
                .set(crate::mechanics::pet_facets::NEXT_SKILL_BONUS_CHARGES, 1);
        }

        // Native `start_cast_ability` port: look up the ability's
        // `start_behavior` fn and run it on the RNG snapshot.
        let native_result = (|| {
            let name = ability_template.start_behavior.as_deref()?;
            let f = self.behaviors.start_cast_ability_fn(name)?;
            Some(f(
                &crate::behaviors::combat::start_cast::StartCastAbilityCtx {
                    caster: &casted_by_entity_cloned,
                    fight: &active_fight_cloned,
                    rng: &GameRng::new(rand_gen),
                    ability_template_id,
                    config: &game_config,
                    lookups: self.behaviors.lookups(),
                },
            ))
        })();

        let results = match native_result {
            Some(Ok(v)) => v,
            other => {
                if !is_pet_ability
                    && let Some(e) = state
                        .active_fight
                        .as_mut()
                        .and_then(|af| af.entities.iter_mut().find(|e| e.id == by_entity_id))
                {
                    let baseline_speed = game_config.game_settings.baseline_speed;
                    let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                        ability_cooldown,
                        e.attributes.speed_or_baseline(baseline_speed),
                        baseline_speed,
                    );
                    e.actions_queue.push_start_cast_replacing(
                        ability_template_id,
                        current_tick + scaled_cooldown,
                    );
                }

                match other {
                    Some(Err(err)) => {
                        tracing::error!("Ability start cast script failed with error: {err:?}")
                    }
                    _ => tracing::error!(
                        "Ability {ability_template_id} has no start_behavior registered"
                    ),
                }
                return EventHandleResult::fail(state);
            }
        };

        // Quickcast (support stone): the cast occupies the caster for less time.
        // Everything downstream — the CastAbility deadline, the animation the
        // client plays, the action slot — reads these two numbers, so scaling
        // them here is the whole operation.
        let results: Vec<StartCastAbilityResult> = results
            .into_iter()
            .map(|result| match result {
                StartCastAbilityResult::Attack {
                    delay_ticks,
                    animation_duration_ticks,
                    target_entity_id,
                    origin,
                } => StartCastAbilityResult::Attack {
                    delay_ticks: stone_mods.apply_cast_time(delay_ticks),
                    animation_duration_ticks: stone_mods.apply_cast_time(animation_duration_ticks),
                    target_entity_id,
                    // Rescaling the cast time does not change the provenance of
                    // the dispatch.
                    origin,
                },
                other => other,
            })
            .collect();

        // Basic-vs-skill is decided by the CASTER's class — a party ally or a
        // PvP opponent may run a different class than the session character.
        // Classless entities (mobs) keep the historical session-class fallback.
        let caster_class = casted_by_entity_cloned
            .class_id
            .unwrap_or(state.character_state.character.class);
        let (actions, events) =
            match StartCastAbilityResult::vec_into_actions_with_deadlines_and_events(
                &results,
                caster_class,
                &game_config,
                ability_template_id,
                by_entity_id,
                current_tick,
                dispatch_origin,
            ) {
                Ok((actions, events)) => (actions, events),
                Err(err) => {
                    tracing::error!(
                        "Error converting StartCastAbilityResultVec = {:?} into EntityActionVec = {:?}",
                        results,
                        err
                    );
                    // The StartCastAbility action was already popped from the
                    // actions queue by `handle_fight_progress`; requeue it
                    // (like the script-failure path above) so a deterministic
                    // conversion error doesn't stall the entity for the rest
                    // of the fight.
                    if !is_pet_ability
                        && let Some(entity) = state
                            .active_fight
                            .as_mut()
                            .and_then(|af| af.entities.iter_mut().find(|e| e.id == by_entity_id))
                    {
                        let baseline_speed = game_config.game_settings.baseline_speed;
                        let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
                            ability_cooldown,
                            entity.attributes.speed_or_baseline(baseline_speed),
                            baseline_speed,
                        );
                        entity.actions_queue.push_start_cast_replacing(
                            ability_template_id,
                            current_tick + scaled_cooldown,
                        );
                    }
                    return EventHandleResult::fail(state);
                }
            };

        let baseline_speed = game_config.game_settings.baseline_speed;
        let scaled_cooldown = essences::entity::scale_cooldown_for_speed(
            ability_cooldown,
            casted_by_entity
                .attributes
                .speed_or_baseline(baseline_speed),
            baseline_speed,
        );
        if is_pet_ability {
            // Charge/one-shot cast: run the produced cast actions, but do NOT
            // schedule the next StartCastAbility — the pet charge system (or
            // fight start, for support passives) is the only trigger.
            for action in &actions {
                casted_by_entity.actions_queue.push(action);
            }
        } else {
            casted_by_entity
                .actions_queue
                .append_start_cast_ability_result_actions(
                    &actions,
                    current_tick,
                    ability_template_id,
                    scaled_cooldown,
                );
        }
        if casted_by_entity.id == active_fight.player_id
            && !actions.is_empty()
            && !is_pet_ability
            && let Some(active_ability) = casted_by_entity
                .abilities
                .iter_mut()
                .find(|a| a.ability.template_id == ability_template_id)
        {
            active_ability.deadline = Some(
                ::time::utc_now()
                    + chrono::TimeDelta::milliseconds(
                        (scaled_cooldown as u128 * TICKER_UNIT_DURATION_MS) as i64,
                    ),
            );
        }

        let now_events = self.route_delayed_to_clock(events);

        EventHandleResult::ok_events(state, now_events)
    }

    /// Route delayed-marked pluginized events (StartedCastAbility wind-ups)
    /// onto the combat clock; immediate ones flow out as regular events.
    fn route_delayed_to_clock(
        &mut self,
        events: Vec<EventPluginized<OverlordEvent, OverlordState>>,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        events
            .into_iter()
            .filter_map(|pluginized| {
                let (event, delayed, _cron) = pluginized.into_parts();
                if let Some(delayed) = delayed {
                    self.fight_clock.schedule(event, delayed.ticks);
                    None
                } else {
                    Some(EventPluginized::now(event))
                }
            })
            .collect()
    }

    /// Route `StartCastProjectile` script outputs onto the combat clock
    /// (clamped to at least one tick so the projectile fires on a later
    /// tick); everything else flows out as immediate events.
    ///
    /// The two support-stone timers ride the same clock: a derived strike
    /// (Repeat / Pulse) is scheduled with its delay stripped, so the copy that
    /// fires later resolves immediately instead of rescheduling itself, and a
    /// delayed attribute change (the Shelter window closing) is scheduled as the
    /// plain `EntityIncrAttribute` it becomes.
    fn route_projectiles_to_clock(
        &mut self,
        events: Vec<OverlordEvent>,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        events
            .into_iter()
            .filter_map(|x| match x {
                OverlordEvent::StartCastProjectile { delay, .. } => {
                    let delay = delay.max(1);
                    self.fight_clock.schedule(x, delay);
                    None
                }
                OverlordEvent::DerivedAbilityStrike {
                    by_entity_id,
                    to_entity_id,
                    ability_id,
                    level,
                    payload_permille,
                    source_paid_mana_x100,
                    delay,
                } => {
                    self.fight_clock.schedule(
                        OverlordEvent::DerivedAbilityStrike {
                            by_entity_id,
                            to_entity_id,
                            ability_id,
                            level,
                            payload_permille,
                            source_paid_mana_x100,
                            delay: 0,
                        },
                        delay.max(1),
                    );
                    None
                }
                OverlordEvent::EntityIncrAttributeDelayed {
                    entity_id,
                    attribute,
                    delta,
                    delay,
                } => {
                    self.fight_clock.schedule(
                        OverlordEvent::EntityIncrAttribute {
                            entity_id,
                            attribute,
                            delta,
                        },
                        delay.max(1),
                    );
                    None
                }
                other => Some(EventPluginized::now(other)),
            })
            .collect()
    }

    /// The support-stone operations that belong to the CAST, not to a single
    /// hit: the delayed derived copies (Repeat / Pulse) and the two defensive
    /// windows (Fortify's guard charge, Shelter's damage-reduction window).
    ///
    /// Derived copies are deliberately not casts — see
    /// [`OverlordEvent::DerivedAbilityStrike`].
    fn support_cast_events(
        mods: &essences::ability_stones::AbilityStoneMods,
        caster: &Entity,
        target_id: Uuid,
        ability_id: AbilityId,
        level: i64,
    ) -> Vec<OverlordEvent> {
        let mut events = Vec::new();

        // The price this cast finally paid, carried onto every copy so a
        // Mana-conditioned law or trigger prices the re-trigger by the SOURCE
        // cast, not by whatever the caster happened to cast in between
        // (BAL-019).
        let source_paid_mana_x100 =
            crate::logic::combat_facts::paid_mana_x100(caster).unwrap_or(-1);

        let mut derived = |copies: &essences::ability_stones::DerivedCopies| {
            if !copies.is_active() {
                return;
            }
            let step = copies.interval_ms.max(1);
            for index in 0..copies.count {
                events.push(OverlordEvent::DerivedAbilityStrike {
                    by_entity_id: caster.id,
                    to_entity_id: target_id,
                    ability_id,
                    level,
                    payload_permille: (copies.payload * 1000.0).round() as i64,
                    source_paid_mana_x100,
                    delay: step * (index as u64 + 1),
                });
            }
        };
        derived(&mods.repeat);
        derived(&mods.pulse);

        // Fortify: arm one guard charge that softens the next incoming hit.
        // `guard_reduction` is SET (delta to the current value), `guard_charges`
        // accumulates, so two casts before the enemy swings leave two charges.
        if mods.guard_next_hit > 0.0 {
            let target_reduction = (mods.guard_next_hit * 10000.0).round() as i64;
            let current = caster
                .attributes
                .0
                .get(crate::mechanics::fight::GUARD_REDUCTION_ATTR)
                .copied()
                .unwrap_or(0);
            if target_reduction != current {
                events.push(OverlordEvent::EntityIncrAttribute {
                    entity_id: caster.id,
                    attribute: crate::mechanics::fight::GUARD_REDUCTION_ATTR.to_string(),
                    delta: target_reduction - current,
                });
            }
            events.push(OverlordEvent::EntityIncrAttribute {
                entity_id: caster.id,
                attribute: crate::mechanics::fight::GUARD_CHARGES_ATTR.to_string(),
                delta: 1,
            });
        }

        // Shelter: a timed `received_damage` reduction. The fight clock owns the
        // window, so nothing is polled per tick and the exact reverse lands even
        // if the caster casts again meanwhile.
        if mods.incoming_damage_reduction > 0.0 && mods.incoming_damage_reduction_ms > 0 {
            let delta = (mods.incoming_damage_reduction * 10000.0).round() as i64;
            events.push(OverlordEvent::EntityIncrAttribute {
                entity_id: caster.id,
                attribute: "received_damage.mod".to_string(),
                delta: -delta,
            });
            events.push(OverlordEvent::EntityIncrAttributeDelayed {
                entity_id: caster.id,
                attribute: "received_damage.mod".to_string(),
                delta,
                delay: mods.incoming_damage_reduction_ms,
            });
        }

        events
    }

    /// A derived copy of an ability's payload (Repeat / Pulse). Re-resolves the
    /// ability's numbers with the caster's stones, scales them by the copy's
    /// share and lands them.
    ///
    /// It is NOT a cast: no `on_cast`, no mana, no cooldown, no pet charge and
    /// no further shape expansion — a copy never copies itself, which is the
    /// whole of the anti-recursion rule. What it IS, per BAL-019, is real
    /// combat output: the hit is Core, so the laws, equipment triggers and pet
    /// facets downstream of it react exactly as they would to the original,
    /// and it carries the source cast's final paid Mana price so a
    /// Mana-conditioned reaction judges it by that cast. The damage itself is
    /// tagged `derived`.
    #[allow(clippy::too_many_arguments)]
    pub fn handle_derived_ability_strike(
        &mut self,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        ability_id: AbilityId,
        level: i64,
        payload_permille: i64,
        source_paid_mana_x100: i64,
        rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        // Re-establish the source cast's price for the length of this
        // resolution. A delayed copy lands after other casts may have paid
        // their own, and the recorded fact is per-entity, not per-cast.
        if let Some(fight) = state.active_fight.as_mut()
            && let Some(caster) = fight.entities.iter_mut().find(|e| e.id == by_entity_id)
        {
            if source_paid_mana_x100 >= 0 {
                crate::logic::combat_facts::record_paid_mana(caster, source_paid_mana_x100);
            } else {
                crate::logic::combat_facts::clear_paid_mana(caster);
            }
        }

        let Some(active_fight) = &state.active_fight else {
            return EventHandleResult::ok(state);
        };
        let Some(caster) = active_fight.entities.iter().find(|e| e.id == by_entity_id) else {
            return EventHandleResult::ok(state);
        };
        let Some(target) = active_fight.entities.iter().find(|e| e.id == to_entity_id) else {
            // The original target died before the copy landed: a derived copy
            // does not re-target, it simply fizzles.
            return EventHandleResult::ok(state);
        };

        let payload = (payload_permille.max(0) as f64) / 1000.0;
        let mods = crate::mechanics::ability_stones::resolver_for_caster(&state, caster).mods_for(
            &game_config,
            ability_id,
            level,
        );

        let lookups = self.behaviors.lookups();
        let mut info =
            match crate::mechanics::content::ability_info(&game_config, lookups, ability_id, level)
            {
                Ok(info) => info,
                Err(err) => {
                    tracing::error!(
                        "DerivedAbilityStrike: no ability info for {ability_id}: {err:?}"
                    );
                    return EventHandleResult::fail(state);
                }
            };
        info.apply_stone_mods(&mods);

        let rng = GameRng::new(rand_gen);
        let mut sink = crate::mechanics::fight::NativeSink::default();

        // An AoE ability keeps its shape when it repeats; a single-target one
        // repeats on the target it was aimed at.
        let is_aoe = game_config
            .ability_template(ability_id)
            .is_some_and(|template| template.has_tag(essences::abilities::AbilityTag::Aoe));
        let targets: Vec<&Entity> = if is_aoe {
            crate::behaviors::combat::cast_ability::band_targets(
                active_fight,
                caster,
                info.max_targets,
            )
        } else {
            vec![target]
        };

        let mut effects = crate::mechanics::effect_cb::OverlordEffectCb;
        for target in targets {
            if info.damage.is_some() || info.dot.is_some() {
                let params = crate::mechanics::fight::AttackParams {
                    power: info.damage.map(|d| d * payload),
                    dot_power: info.dot.map(|d| d * payload),
                    no_counterattack: true,
                    derived: true,
                    ..Default::default()
                };
                if let Err(err) = crate::mechanics::fight::attack(
                    &mut sink,
                    &rng,
                    lookups,
                    &mut effects,
                    active_fight.player_id,
                    caster,
                    target,
                    &params,
                    CombatSource::AbilityDerived { ability_id },
                ) {
                    tracing::error!("DerivedAbilityStrike attack failed: {err:?}");
                    return EventHandleResult::fail(state);
                }
            } else if let Some(hot) = info.hot {
                // A healing ability's copy heals; the caster is its own target.
                let params = crate::mechanics::fight::SpellHealParams {
                    power: Some(hot * payload),
                    ..Default::default()
                };
                if let Err(err) = crate::mechanics::fight::spell_heal(
                    &mut sink,
                    &rng,
                    lookups,
                    caster,
                    caster,
                    &params,
                    CombatSource::AbilityDerived { ability_id },
                ) {
                    tracing::error!("DerivedAbilityStrike heal failed: {err:?}");
                    return EventHandleResult::fail(state);
                }
            }
        }

        let events = sink
            .events
            .into_iter()
            .map(EventPluginized::now)
            .collect::<Vec<_>>();
        EventHandleResult::ok_events(state, events)
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_cast_ability(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        ability_id: AbilityId,
        rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        // Which family this cast belongs to, recorded on the caster before
        // anything reads it: `mechanics::fight::attack` picks the law arm to
        // spend by it, and the stones runtime reads it from its own hook. A
        // derived cast is not one of the hero's own and leaves the last Core
        // answer standing.
        //
        // Written only when one of those two will read it, so a character with
        // no laws and nothing socketed still comes out of a fight with no
        // bookkeeping on it at all (acceptance #14).
        if self.dispatch_origin().is_core() {
            let has_stones = state
                .character_state
                .stones
                .all()
                .any(|(_, stone)| stone.is_socketed());
            let is_player = state
                .active_fight
                .as_ref()
                .is_some_and(|fight| fight.player_id == by_entity_id);
            if let Some(caster) = state
                .active_fight
                .as_mut()
                .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == by_entity_id))
                && (!caster.law_cores.laws.is_empty() || (is_player && has_stones))
            {
                let kind = crate::logic::combat_facts::cast_kind(&game_config, caster, ability_id);
                crate::logic::combat_facts::record_cast_kind(caster, kind);
            }
        }

        // BAL-033 Rogue passive: an original Basic Attack may repeat itself at
        // full damage. The repeat is a real Core cast — it moves attack
        // counters, can crit and drives laws, triggers and facets — but it may
        // not repeat ITSELF, which the one-shot latch below enforces: the
        // repeat consumes the mark and rolls nothing.
        //
        // A Skill gets the same treatment from Multicast (BAL-034): any
        // ORIGINAL skill — class abilities and heals included — may cast a
        // second time. The copy pays no Mana and sets no extra cooldown,
        // because both are charged by `StartCastAbility`, which the copy never
        // goes through; it inherits the original's recorded paid Mana, so the
        // Mana laws read the real cost rather than zero.
        let mut double_strike: Option<f64> = None;
        let mut multicast: Option<f64> = None;
        if self.dispatch_origin().is_core() {
            let is_basic = state
                .active_fight
                .as_ref()
                .and_then(|fight| fight.entities.iter().find(|e| e.id == by_entity_id))
                .map(|caster| {
                    crate::logic::combat_facts::cast_kind(&game_config, caster, ability_id)
                })
                == Some(crate::logic::combat_facts::CastKind::Basic);

            let multicast_chance = state
                .active_fight
                .as_ref()
                .and_then(|fight| fight.entities.iter().find(|e| e.id == by_entity_id))
                .map(|caster| {
                    crate::mechanics::fight::get_entity_stat(
                        self.behaviors.lookups(),
                        caster,
                        "multicast_chance",
                    ) / 10_000.0
                })
                .unwrap_or(0.0);

            if let Some(caster) = state
                .active_fight
                .as_mut()
                .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == by_entity_id))
            {
                let is_repeat = crate::mechanics::class_passives::take_repeat_mark(caster);
                let chance = crate::mechanics::class_passives::double_strike_chance(caster);
                if is_basic && !is_repeat && chance > 0.0 {
                    // Eligible; the roll itself happens below, on the RNG this
                    // dispatch already carries.
                    double_strike = Some(chance);
                }

                let is_copy = crate::mechanics::class_passives::take_multicast_mark(caster);
                // Basic attacks already multicast by doubling the swing list in
                // `fight::cast`, so rolling here too would pay them twice.
                if !is_basic && !is_copy && multicast_chance > 0.0 {
                    multicast = Some(multicast_chance.clamp(0.0, 1.0));
                }
            }
        }

        // Laws whose condition is the cast itself fire BEFORE it resolves, so
        // `RL-01` ("every 5th Basic Attack: THIS strike deals +100%") can arm
        // the strike that triggered it (`logic::laws`).
        let mut law_events =
            self.apply_law_pre_cast(&mut state, by_entity_id, ability_id, to_entity_id);

        let state_cloned = state.clone();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(target_entity) = active_fight
            .entities
            .iter()
            .find(|e| e.id == to_entity_id)
            .cloned()
        else {
            tracing::debug!("Couldn't find target entity_id = {to_entity_id}");
            return EventHandleResult::fail(state);
        };

        let active_fight_clone = active_fight.clone();

        let Some(casted_by_entity) = active_fight
            .entities
            .iter_mut()
            .find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {by_entity_id}");
            return EventHandleResult::fail(state);
        };

        let Some(active_ability) = casted_by_entity
            .abilities
            .iter()
            .find(|equipped_ability| equipped_ability.ability.template_id == ability_id)
            .cloned()
        else {
            tracing::error!(
                "Couldn't find ability_id = {} in caster entity {:?}",
                ability_id,
                casted_by_entity
            );
            return EventHandleResult::fail(state);
        };
        let ability = active_ability.ability;
        let ability_slot_level =
            self.compute_ability_slot_level(active_ability.slot_id, &state_cloned);

        let player_id = active_fight.player_id;

        let Some(ability_template) = game_config.ability_template(ability.template_id).cloned()
        else {
            tracing::error!(
                "Couldn't find template for ability_id = {}",
                ability.template_id
            );
            return EventHandleResult::fail(state);
        };

        let _ = (&state_cloned, ability_slot_level);

        // Support stones that act on the CAST rather than on a single hit:
        // the delayed derived copies (Repeat / Pulse) and the two defensive
        // windows (Fortify / Shelter). Resolved once, from the same resolver
        // the ability behaviors use.
        let cast_mods =
            crate::mechanics::ability_stones::resolver_for_caster(&state_cloned, casted_by_entity)
                .mods_for(&game_config, ability.template_id, ability.level);
        let support_events = Self::support_cast_events(
            &cast_mods,
            casted_by_entity,
            to_entity_id,
            ability.template_id,
            ability.level,
        );

        let rng = GameRng::new(rand_gen);

        // The Rogue's repeat, resolved on the same entropy accumulator crit,
        // dodge and block use: the expected rate is exactly the authored
        // chance, with none of the streaks an independent roll produces.
        let double_strike = double_strike.is_some_and(|chance| {
            crate::mechanics::fight::entropy_throw_p(
                &rng,
                casted_by_entity,
                crate::mechanics::class_passives::REPEAT_MARK,
                chance,
            )
        });
        if double_strike {
            crate::mechanics::class_passives::mark_repeat(casted_by_entity);
        }

        let multicast = multicast.is_some_and(|chance| {
            crate::mechanics::fight::entropy_throw_p(
                &rng,
                casted_by_entity,
                "multicast_chance",
                chance,
            )
        });
        if multicast {
            crate::mechanics::class_passives::mark_multicast(casted_by_entity);
        }

        // Native `cast_ability` port: look up the ability's `script` fn
        // and run it on the RNG snapshot.
        let native_result = (|| {
            let name = ability_template.behavior.as_deref()?;
            let f = self.behaviors.cast_ability_fn(name)?;
            Some(f(&crate::behaviors::combat::cast_ability::CastAbilityCtx {
                caster_entity: casted_by_entity,
                target_entity: &target_entity,
                fight: &active_fight_clone,
                rng: &rng,
                ability_level: ability.level,
                ability_id: ability.template_id,
                config: &game_config,
                lookups: self.behaviors.lookups(),
                stones: crate::mechanics::ability_stones::resolver_for_caster(
                    &state_cloned,
                    casted_by_entity,
                ),
                // Pets cast nothing in this build (`is_pet_ability` is a
                // hardcoded `false` above), so every cast that reaches here is
                // the combatant's own ability. When the pet ult casts again,
                // this is the one place that must answer `PetUlt`.
                source: CombatSource::AbilityCast {
                    ability_id: ability.template_id,
                },
            }))
        })();

        match native_result {
            Some(Ok(mut events)) => {
                let _ = player_id;

                events.extend(support_events);
                let mut now_events = self.route_projectiles_to_clock(events);
                // Law events go FIRST: an armed splash belongs to the swing
                // that spent it, not to whatever the script queued after.
                law_events.append(&mut now_events);
                // The Rogue's repeat swings after the strike that produced it,
                // and the Mage's copy follows the skill that produced it. Both
                // are ordinary Core casts — they drive laws, triggers and
                // facets — and both are latched against repeating themselves.
                if double_strike || multicast {
                    law_events.push(EventPluginized::now(OverlordEvent::CastAbility {
                        by_entity_id,
                        to_entity_id,
                        ability_id,
                        origin: essences::combat_origin::CombatEventOrigin::Core,
                    }));
                }
                EventHandleResult::ok_events(state, law_events)
            }
            Some(Err(err)) => {
                tracing::error!("Ability cast script failed with error: {err:?}");
                EventHandleResult::fail(state)
            }
            None => {
                tracing::error!("Ability {} has no script registered", ability.template_id);
                EventHandleResult::fail(state)
            }
        }
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_start_cast_projectile(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        level: i64,
        source: CombatSource,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(target_entity) = active_fight
            .entities
            .iter()
            .find(|e| e.id == to_entity_id)
            .cloned()
        else {
            tracing::debug!("Couldn't find entity_id = {}", to_entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(projectile) = game_config.require_projectile(projectile_id) else {
            tracing::error!("Couldn't find projectile_id = {} in config", projectile_id);
            return EventHandleResult::fail(state);
        };

        let active_fight_clone = active_fight.clone();

        let Some(casted_by_entity) = active_fight
            .entities
            .iter_mut()
            .find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {}", by_entity_id);
            return EventHandleResult::fail(state);
        };

        let _ = (&active_fight_clone, current_tick);

        // Native `start_cast_projectile` port: look up the projectile's
        // `start_behavior` fn and run it.
        let native_result = (|| {
            let name = projectile.start_behavior.as_deref()?;
            let f = self.behaviors.start_cast_projectile_fn(name)?;
            Some(f(
                &crate::behaviors::combat::start_cast::StartCastProjectileCtx {
                    caster_entity: casted_by_entity,
                    target_entity: &target_entity,
                },
            ))
        })();

        let result = match native_result {
            Some(Ok(v)) => v,
            Some(Err(err)) => {
                tracing::error!("Projectile start cast script failed with error: {err:?}");
                return EventHandleResult::fail(state);
            }
            None => {
                tracing::error!("Projectile {projectile_id} has no start_behavior registered");
                return EventHandleResult::fail(state);
            }
        };

        self.fight_clock.schedule(
            OverlordEvent::CastProjectile {
                by_entity_id,
                to_entity_id,
                projectile_id,
                level,
                projectile_data: result.projectile_data,
                origin: CombatEventOrigin::Core,
                source,
            },
            result.animation_duration_ticks as u64,
        );

        EventHandleResult::ok_events(
            state,
            vec![EventPluginized::now(OverlordEvent::StartedCastProjectile {
                by_entity_id,
                to_entity_id,
                projectile_id,
                duration_ticks: result.animation_duration_ticks as u64,
                origin: CombatEventOrigin::Core,
                source,
            })],
        )
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_cast_projectile(
        &mut self,
        _event: OverlordEvent,
        by_entity_id: Uuid,
        to_entity_id: Uuid,
        projectile_id: Uuid,
        level: i64,
        projectile_data: &CustomEventData,
        source: CombatSource,
        rand_gen: rand::rngs::StdRng,
        current_tick: u64,
        state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        let Some(active_fight) = &state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(casted_by_entity) = active_fight.entities.iter().find(|e| e.id == by_entity_id)
        else {
            tracing::debug!("Couldn't find caster entity_id = {}", by_entity_id);
            return EventHandleResult::fail(state);
        };

        let Some(target_entity) = active_fight
            .entities
            .iter()
            .find(|e| e.id == to_entity_id)
            .cloned()
        else {
            tracing::debug!("Couldn't find target entity_id = {}", to_entity_id);
            return EventHandleResult::fail(state);
        };

        let Ok(projectile) = game_config.require_projectile(projectile_id) else {
            tracing::error!("Couldn't find projectile_id = {} in config", projectile_id);
            return EventHandleResult::fail(state);
        };

        let _ = (projectile_data, current_tick);

        // Native `cast_projectile` port: look up the projectile's `script`
        // fn and run it on the RNG snapshot.
        let native_result = (|| {
            let name = projectile.behavior.as_deref()?;
            let f = self.behaviors.cast_projectile_fn(name)?;
            Some(f(
                &crate::behaviors::combat::cast_projectile::CastProjectileCtx {
                    caster_entity: casted_by_entity,
                    target_entity: &target_entity,
                    fight: active_fight,
                    rng: &GameRng::new(rand_gen),
                    projectile_level: level,
                    config: &game_config,
                    lookups: self.behaviors.lookups(),
                    stones: crate::mechanics::ability_stones::resolver_for_caster(
                        &state,
                        casted_by_entity,
                    ),
                    // The launcher's own source, carried down the chain: the
                    // hit belongs to the skill that fired it. `ProjectileHit`
                    // remains for a projectile with no launcher to name.
                    source: match source {
                        CombatSource::Other => CombatSource::ProjectileHit { projectile_id },
                        carried => carried,
                    },
                },
            ))
        })();

        match native_result {
            Some(Ok(events)) => {
                let now_events = self.route_projectiles_to_clock(events);
                EventHandleResult::ok_events(state, now_events)
            }
            Some(Err(err)) => {
                tracing::error!("Projectile cast script failed with error: {err:?}");
                EventHandleResult::fail(state)
            }
            None => {
                tracing::error!("Projectile {projectile_id} has no script registered");
                EventHandleResult::fail(state)
            }
        }
    }

    pub fn handle_player_death(
        &mut self,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // The fight already ended (e.g. max-duration timeout): an in-flight
        // combat event killed the player afterwards. Don't schedule a second
        // EndFight for the same fight.
        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        active_fight.entities = Vec::new();

        let fight_uuid = active_fight.id;
        active_fight.fight_ended = true;
        let end_fight_delay = self.get_end_fight_delay(active_fight.fight_id);

        self.fight_clock.schedule(
            OverlordEvent::EndFight {
                fight_id: fight_uuid,
                is_win: false,
                pvp_state: state.pvp_state.clone().map(Box::new),
            },
            end_fight_delay,
        );

        EventHandleResult::ok(state)
    }

    /// Death-gated exit (the revived streaming cap — docs/growing-enemy-waves-plan.md):
    /// mobs beyond a wave's `stream_active_count` spawn parked off-screen with an
    /// `exit_gated` queue position instead of an exit timer. Each enemy death
    /// releases exactly one: clear the attribute (a synchronous state mutation,
    /// so same-tick AoE deaths each release exactly one) and schedule its
    /// entrance run at the walk tempo, mirroring `handle_spawn_entity`'s timer
    /// path.
    ///
    /// Which one: the freed tile is in the DEAD mob's column (`dead_col_x`), so
    /// a parked mob landing in that same column goes first — a melee kill
    /// releases a melee, not the ranged queue head (owner 2026-07-13). Within
    /// the column (or when none matches) the lowest queue position wins.
    fn release_next_gated_exit(
        &mut self,
        active_fight: &mut ActiveFight,
        fight_settings: &configs::fighting::FightSettings,
        dead_col_x: i64,
    ) {
        let entrance_offset = fight_settings.wave_entrance_offset_cells.max(0);
        let gated: Vec<(usize, i64, i64)> = active_fight
            .entities
            .iter()
            .enumerate()
            .filter(|(_, e)| e.team == EntityTeam::Enemy && e.hp > 0)
            .filter_map(|(i, e)| {
                e.attributes
                    .0
                    .get("exit_gated")
                    .copied()
                    .map(|k| (i, k, e.coordinates.x - entrance_offset))
            })
            .collect();
        let Some(idx) = gated
            .iter()
            .filter(|&&(_, _, landing_x)| landing_x == dead_col_x)
            .min_by_key(|&&(_, k, _)| k)
            .or_else(|| gated.iter().min_by_key(|&&(_, k, _)| k))
            .map(|&(i, _, _)| i)
        else {
            return;
        };
        let run_ticks = entrance_offset as u64 * fight_settings.wave_entrance_walk_ms_per_cell;
        // Land on the least-occupied row of the mob's column — the space the
        // kill just freed — instead of the authored park row. Computed before
        // clearing the gate so the count excludes still-parked queue mates.
        let released_id = active_fight.entities[idx].id;
        let row =
            crate::mechanics::fight::gated_release_row(active_fight, released_id, entrance_offset);
        let entity = &mut active_fight.entities[idx];
        // `set` drops zeros — the attribute disappears, the mob is released.
        entity.attributes.set("exit_gated", 0);
        // Park row follows the landing row so a same-tick second release
        // counts this mob on its real tile (its entrance move is only
        // scheduled next tick).
        entity.coordinates.y = row;
        let battle_cell = Coordinates {
            x: entity.coordinates.x - entrance_offset,
            y: row,
        };
        self.fight_clock.schedule(
            OverlordEvent::StartMove {
                entity_id: entity.id,
                to: battle_cell,
                duration_ticks: run_ticks,
            },
            1,
        );
    }

    pub fn handle_entity_death(
        &mut self,
        entity_id: Uuid,
        reward: Vec<CurrencyUnit>,
        mut rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let game_config = self.game_config.get();

        // BAL-031: the law / equipment-stone / artifact-stone mob faucets are
        // scoped to the owner's own CAMPAIGN fight. Read before the mutable
        // borrow of `state.active_fight` below.
        let is_pvp = state.pvp_state.is_some();

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // The fight already ended (e.g. max-duration timeout): an in-flight
        // combat event killed an entity afterwards. Don't process the death —
        // it could schedule a second EndFight (or spawn a next wave) for a
        // fight that is already over.
        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        let Some(entity_idx) = active_fight
            .entities
            .iter()
            .position(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        let dead_team = active_fight.entities[entity_idx].team.clone();
        let dead_wave_share = active_fight.entities[entity_idx].attributes.wave_share();
        // BAL-031: dungeon enemies and PvP entities fund nothing on this path —
        // a dungeon clear pays its own separate leg instead. Retry kills stay
        // eligible (a retry is still a campaign fight), and boss-summoned adds
        // need no check here: `wave_share()` already returns 0 for them, which
        // zeroes every faucet below.
        // A2-BAL-003 §3.5: the check used to be `!is_pvp && dungeon.is_none()`,
        // which is a statement about what a fight is NOT. Anything that is
        // neither PvP nor a dungeon paid the faucets — including the
        // cheat-driven `SingleFight` path and any fight type added later.
        // Require the fight to positively be a campaign fight instead.
        let fight_type = game_config
            .require_fight_template(active_fight.fight_id)
            .map(|f| f.fight_type.clone())
            .unwrap_or(essences::fighting::FightType::SingleFight);
        let is_campaign_fight = matches!(
            fight_type,
            essences::fighting::FightType::CampaignFight
                | essences::fighting::FightType::CampaignBossFight
        );
        let is_campaign_kill = is_campaign_fight && !is_pvp && active_fight.dungeon.is_none();
        // BAL-008: direct Cookies come only from ORDINARY campaign mobs. Bosses,
        // their summoned adds and every other mode are excluded, and unlike the
        // other faucets the ticket chance does not scale by `wave_share` — the
        // five tickets are authored against raw eligible kills.
        let dead_is_summon = active_fight.entities[entity_idx].attributes.is_summoned();
        let is_boss_fight = fight_type == essences::fighting::FightType::CampaignBossFight;
        let is_ordinary_mob_kill = is_campaign_kill && !dead_is_summon && !is_boss_fight;
        // The dead mob's column (its reserved landing while mid-run): the tile a
        // gated release should refill (see `release_next_gated_exit`).
        let dead_col_x = {
            let e = &active_fight.entities[entity_idx];
            e.move_target
                .as_ref()
                .map(|t| t.x)
                .unwrap_or(e.coordinates.x)
        };
        active_fight.entities.swap_remove(entity_idx);

        let mut events = Vec::new();

        // BAL-038 removes the legacy repeatable Gold and Cookie entity-death
        // rewards: the `45% x 1 Cookie` (superseded by the five-ticket route
        // below) and the per-kill Gold, which was unbudgeted on top of the
        // signed funding split (`80% item sales + 10% dungeon + 5% AFK + 5%
        // quests` after the dungeon gate, `80/10/10` before it).
        //
        // ONLY those two families are removed. Every other authored entity
        // currency drop (boss Skill Crystals, Gems, ...) is outside BAL-038's
        // scope and keeps paying, as do the separately configured non-kill
        // clear / first-clear bundles.
        {
            // Gold's id is fixed content (the same literal the sale path in
            // `behaviors::items::item_price` pays with).
            const GOLD_CURRENCY_ID: Uuid = Uuid::from_u128(0x0194d64e_2386_7020_8b01_d6b3d5424506);
            let cookie_id = game_config.kill_faucet_settings.direct_cookie_currency_id;
            let kept: Vec<CurrencyUnit> = reward
                .iter()
                .filter(|unit| {
                    unit.currency_id != GOLD_CURRENCY_ID && unit.currency_id != cookie_id
                })
                .cloned()
                .collect();
            if !kept.is_empty() {
                events.push(Self::currency_increase(&kept, CurrencySource::EntityDeath));
            }
        }

        // BAL-010: the Core Essence faucet. Supply steps by REACHED CHAPTER, and
        // this is the second raw-kill exception beside direct Cookies —
        // `wave_share` deliberately does NOT apply, because the packet is already
        // authored per band against a canonical ~520 eligible kills per 60m.
        //
        // Every roll below runs through the BAL-038 daily contract: the band is
        // snapshotted on the first eligible roll after the reset, the chance
        // decays once the granted amount passes `D`, and the packet is clipped so
        // a large grant cannot step past `ceil(2D)`.
        let chapter = state.character_state.character.current_chapter_level;
        let now = ::time::utc_now();
        {
            if dead_team == EntityTeam::Enemy
                // Same population as direct Cookies: raw ordinary campaign-mob
                // deaths. Bosses, summons and dungeon kills are excluded — the
                // per-band packet is authored against the canonical ~520
                // eligible kills per 60m, which counts none of those.
                && is_ordinary_mob_kill
                && let Some(band) = game_config.cores_settings.essence_band(chapter)
            {
                let daily = essences::kill_faucets::band_for_today(
                    &mut state.character_state.kill_faucet_daily,
                    essences::kill_faucets::KillFaucetFamily::CoreEssence,
                    band.r_value,
                    now,
                );
                let chance = band.base_chance * daily.decay();
                if chance > 0.0
                    && rand::RngExt::random_range(&mut rand_gen, 0.0..1.0) < chance
                    && let paid = daily.take(band.packet.get())
                    && paid > 0
                {
                    events.push(Self::currency_increase(
                        &[CurrencyUnit {
                            currency_id: game_config.cores_settings.upgrade_currency_id,
                            amount: paid,
                        }],
                        CurrencySource::EntityDeath,
                    ));
                }
            }

            // Law COPIES — not law unlocks. Since the acquisition pass the
            // unlock is deterministic (`mechanics::cores::grant_unlocked_laws`
            // on a core upgrade) and this path funds LEVELLING only: one law
            // template per proc, banked as stock against `law_upgrade_ladder`.
            //
            // BAL-031: the pool is uniform over the laws the player's OWN core
            // levels have unlocked (and that are active) — a locked or inactive
            // template never drops, so the signed catalog timing is measured
            // against the deterministic unlock schedule, not the whole catalog.
            let law_chance = game_config.cores_settings.law_drop_chance;
            if dead_team == EntityTeam::Enemy && is_campaign_kill {
                let cores = &state.character_state.cores;
                let pool: Vec<essences::cores::LawTemplateId> =
                    crate::mechanics::cores::laws_unlocked_by_core_level(
                        &game_config,
                        essences::flip::WorldSide::Real,
                        cores.real_level,
                    )
                    .chain(crate::mechanics::cores::laws_unlocked_by_core_level(
                        &game_config,
                        essences::flip::WorldSide::Fantasy,
                        cores.fantasy_level,
                    ))
                    .filter(|id| {
                        game_config
                            .laws
                            .iter()
                            .any(|law| law.id == *id && law.is_active)
                    })
                    .collect();
                if !pool.is_empty() {
                    let daily = essences::kill_faucets::band_for_today(
                        &mut state.character_state.kill_faucet_daily,
                        essences::kill_faucets::KillFaucetFamily::LawCopies,
                        game_config.kill_faucet_settings.law_copies_d,
                        now,
                    );
                    let chance = law_chance * dead_wave_share * daily.decay();
                    if chance > 0.0
                        && rand::RngExt::random_range(&mut rand_gen, 0.0..1.0) < chance
                        && daily.take(1) > 0
                    {
                        let index = rand::RngExt::random_range(&mut rand_gen, 0..pool.len());
                        events.push(EventPluginized::now(OverlordEvent::NewLawCopies {
                            law_template_id: pool[index],
                            amount: 1,
                        }));
                    }
                }
            }
        }

        // Trigger/Effect stones. Their faucet moved here from the item-chest
        // open (`logic::items::open_item_case`): chests are a purchased channel,
        // so the old placement paid a whale opening ~26k chests a day two orders
        // of magnitude more stones than a player who fought for them. Same
        // `wave_share` scaling as every other per-kill payout.
        //
        // BAL-020 full-loop denial: no drops before the first socket milestone
        // (ch25) — a stone that cannot be socketed must not occupy inventory.
        let first_socket_chapter = game_config
            .stones_settings
            .socket_unlocks
            .iter()
            .map(|unlock| unlock.unlock_chapter)
            .min()
            .unwrap_or(i64::MAX);
        if dead_team == EntityTeam::Enemy && is_campaign_kill && chapter >= first_socket_chapter {
            // Trigger and Effect share ONE counter: the kind is decided by the
            // internal 50/50 roll after the drop is granted, so counting them
            // apart would let a build farm twice the authored budget.
            let equipment_decay = {
                let daily = essences::kill_faucets::band_for_today(
                    &mut state.character_state.kill_faucet_daily,
                    essences::kill_faucets::KillFaucetFamily::EquipmentStones,
                    game_config.kill_faucet_settings.equipment_stones_d,
                    now,
                );
                if daily.remaining() > 0 {
                    daily.decay()
                } else {
                    0.0
                }
            };
            let stone_event =
                self.roll_stone_kill_drop(&mut rand_gen, dead_wave_share * equipment_decay);
            if stone_event.is_some() {
                essences::kill_faucets::band_for_today(
                    &mut state.character_state.kill_faucet_daily,
                    essences::kill_faucets::KillFaucetFamily::EquipmentStones,
                    game_config.kill_faucet_settings.equipment_stones_d,
                    now,
                )
                .take(1);
            }
            events.extend(stone_event);

            // Artifact stones get a THIRD faucet here, alongside the chapter
            // boss and the cleared dungeon — deliberately a much smaller chance,
            // since the events it joins are per-chapter and per-run while this
            // one is per-mob.
            //
            // The BAL-038 counter covers the campaign mob AND boss legs, which is
            // why a campaign boss consumes it twice (once inside the weighted mob
            // pool, once through its own extra leg). The dungeon-clear leg is a
            // separate faucet and never touches this budget.
            let artifact_decay = {
                let daily = essences::kill_faucets::band_for_today(
                    &mut state.character_state.kill_faucet_daily,
                    essences::kill_faucets::KillFaucetFamily::ArtifactStones,
                    game_config.kill_faucet_settings.artifact_stones_d,
                    now,
                );
                if daily.remaining() > 0 {
                    daily.decay()
                } else {
                    0.0
                }
            };
            let artifact_stone_chance = game_config.artifacts_settings.stone_drop.mob_kill_chance
                * dead_wave_share
                * artifact_decay;
            let artifact_event =
                self.roll_artifact_stone_drop(&mut rand_gen, artifact_stone_chance, chapter);
            if artifact_event.is_some() {
                essences::kill_faucets::band_for_today(
                    &mut state.character_state.kill_faucet_daily,
                    essences::kill_faucets::KillFaucetFamily::ArtifactStones,
                    game_config.kill_faucet_settings.artifact_stones_d,
                    now,
                )
                .take(1);
            }
            events.extend(artifact_event);
        }

        // BAL-008: direct campaign Cookies. Five INDEPENDENT tickets per eligible
        // ordinary mob death, resolved in sequence; each success grants one
        // Cookie, immediately advances the daily `x`, and is surfaced separately.
        // This is the ONLY direct campaign Cookie route — the legacy 45%x1 entity
        // reward is gone, so a kill can no longer fund both.
        if dead_team == EntityTeam::Enemy && is_ordinary_mob_kill {
            let settings = &game_config.kill_faucet_settings;
            let tickets = settings.direct_cookie_tickets_per_kill;
            let mut paid = 0i64;
            {
                let daily = essences::kill_faucets::band_for_today(
                    &mut state.character_state.kill_faucet_daily,
                    essences::kill_faucets::KillFaucetFamily::DirectCookies,
                    settings.direct_cookies_d,
                    now,
                );
                for _ in 0..tickets {
                    if daily.remaining() <= 0 {
                        break;
                    }
                    // The chance is read fresh per ticket: a success inside this
                    // very kill lowers the next ticket's odds, which is what makes
                    // the five tickets a decaying sequence rather than five draws
                    // at one rate.
                    let chance = settings.direct_cookie_chance(daily.granted);
                    if chance > 0.0 && rand::RngExt::random_range(&mut rand_gen, 0.0..1.0) < chance
                    {
                        paid += daily.take(1);
                    }
                }
            }
            if paid > 0 {
                events.push(Self::currency_increase(
                    &[CurrencyUnit {
                        currency_id: settings.direct_cookie_currency_id,
                        amount: paid,
                    }],
                    CurrencySource::EntityDeath,
                ));
            }
        }

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Ok(fight) = game_config.require_fight_template(active_fight.fight_id) else {
            tracing::error!(
                "Failed to get fight_template with id {} ",
                active_fight.fight_id
            );
            return EventHandleResult::fail(state);
        };

        let has_any_ally = active_fight
            .entities
            .iter()
            .any(|e| e.team == EntityTeam::Ally);

        // Death-gated exit release (revived streaming cap): an ENEMY kill frees
        // exactly one parked mob — the lowest queue position. Gated mobs are
        // live entities, so this is race-free by construction: the attribute
        // clear below is a synchronous state mutation visible to the next
        // death handler in the same tick (no over-release on AoE), and the
        // wave-completion check further down needs no extra gate — a parked
        // mob keeps `get_enemies_amount() > 0` until it is released and dies.
        if dead_team == EntityTeam::Enemy {
            self.release_next_gated_exit(active_fight, &game_config.fight_settings, dead_col_x);
        }

        // Slot promotion on a mid-wave enemy death (§2.2): the near column may
        // have just emptied while the far one still fights.
        if dead_team == EntityTeam::Enemy && active_fight.get_enemies_amount() > 0 {
            let promotion = self.slot_promotion_events(active_fight);
            events.extend(promotion);
        }

        // A pending SUMMON wave never spawns on wave clear: it only fires from
        // the damage handler when the boss crosses its HP fraction. If the boss
        // died first, the last wave is skipped and the fight ends here.
        let pending_summon_skipped = fight
            .prepare_fight_waves
            .as_ref()
            .and_then(|w| w.summon_wave_at_hp_fraction)
            .is_some()
            && active_fight.current_wave == fight.waves_amount - 1;

        if active_fight.get_enemies_amount() == 0 && has_any_ally {
            if active_fight.current_wave == fight.waves_amount || pending_summon_skipped {
                let fight_uuid = active_fight.id;
                active_fight.fight_ended = true;
                let end_fight_delay = self.get_end_fight_delay(active_fight.fight_id);
                self.fight_clock.schedule(
                    OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: true,
                        pvp_state: state.pvp_state.clone().map(Box::new),
                    },
                    end_fight_delay,
                );
                if fight.fight_type == FightType::CampaignBossFight {
                    events.push(EventPluginized::now(OverlordEvent::StageCleared {}));
                }
            } else {
                let fight_uuid = active_fight.id;
                active_fight.current_wave += 1;
                let active_fight_cloned = active_fight.clone();
                let current_chapter = state.character_state.character.current_chapter_level;

                // Native `prepare_fight` interpreter: spawn the current wave from
                // the typed `prepare_fight_waves` config (the native data source),
                //
                // `base_power` was a literal argument of the legacy
                // `spawn_wave(...)` script, transpiled from the template's
                // TOP-LEVEL `power` field (`$.power`). Pass that — NOT
                // `wave_data.power` (the waves-blob's inner value, 4-26x
                // larger on live templates), which inflated campaign mob
                // stats 2-5x vs the legacy engine. See the matching fix in
                // `chapters_management.rs`.
                let prepare_fight_events = match fight.prepare_fight_waves.as_ref() {
                    Some(waves_cfg) => {
                        let wave_data = crate::mechanics::fight::wave_data_from_config(waves_cfg);
                        let fight_type_str = format!("{:?}", fight.fight_type);
                        let mut sink = crate::mechanics::fight::NativeSink::default();
                        let rng = GameRng::new(rand_gen);
                        match crate::mechanics::fight::spawn_wave(
                            &mut sink,
                            &rng,
                            &game_config,
                            self.behaviors.lookups(),
                            &active_fight_cloned,
                            &wave_data,
                            fight.power.map(|p| p as f64).unwrap_or(0.0),
                            current_chapter,
                            &fight_type_str,
                        ) {
                            Ok(()) => sink.events,
                            Err(err) => {
                                tracing::error!(
                                    "Prepare wave for new wave failed with error: {err:?}"
                                );
                                events.push(EventPluginized::now(OverlordEvent::EndFight {
                                    fight_id: fight_uuid,
                                    is_win: false,
                                    pvp_state: state.pvp_state.clone().map(Box::new),
                                }));
                                return EventHandleResult::ok_events(state, events);
                            }
                        }
                    }
                    None => {
                        tracing::error!(
                            "Fight {} has no prepare_fight_waves for next wave",
                            fight.id
                        );
                        events.push(EventPluginized::now(OverlordEvent::EndFight {
                            fight_id: fight_uuid,
                            is_win: false,
                            pvp_state: state.pvp_state.clone().map(Box::new),
                        }));
                        return EventHandleResult::ok_events(state, events);
                    }
                };

                if prepare_fight_events.is_empty() {
                    tracing::error!("Prepare wave script returned no events");
                    events.push(EventPluginized::now(OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: false,
                        pvp_state: state.pvp_state.clone().map(Box::new),
                    }));
                    return EventHandleResult::ok_events(state, events);
                }

                if !prepare_fight_events
                    .iter()
                    .any(|ev| matches!(ev, OverlordEvent::SpawnEntity { .. }))
                {
                    tracing::error!("Prepare wave script returned no SpawnEntity events");
                    events.push(EventPluginized::now(OverlordEvent::EndFight {
                        fight_id: fight_uuid,
                        is_win: false,
                        pvp_state: state.pvp_state.clone().map(Box::new),
                    }));
                    return EventHandleResult::ok_events(state, events);
                }

                // Between-wave pause (docs/combat-feel-porting-plan.md [3.3]): the next wave's
                // spawn batch — the EXISTING events spawn_wave produced (spawns + their sleep
                // effects, in original order) — is scheduled on the fight clock after the
                // per-dungeon override or the standard 0.5 s pause.
                // Deliberately NO new event variants (postcard is ordinal — old clients would
                // break on decode). WaveCleared still goes out immediately for the UI; delivery
                // races with EndFight are cut off by the fight_ended guard in handle_spawn_entity.
                // NB: fight-clock ticks are MILLISECONDS (cp. `end_fight_delay_ticks_default:
                // 500` = 0.5 s and cooldowns added to `current_tick` directly), not 100 ms
                // server frames.
                let between_wave_behavior = crate::mechanics::fight::between_wave_behavior(
                    &game_config,
                    &active_fight_cloned,
                );
                for ev in prepare_fight_events {
                    self.fight_clock
                        .schedule(ev, between_wave_behavior.spawn_delay_ticks);
                }

                // Formation dash (§2.7): advancing fights move the whole ally
                // side FORMATION_ADVANCE_CELLS to the new anchor after the pause.
                // Stationary dungeons omit the move entirely; their wave slots
                // use the current player column and their exits have no formation
                // floor.
                //
                // EVERY living ally dashes — including one mid-move at clear time
                // (e.g. a promotion step still in flight). Filtering on
                // `move_target.is_none()` HERE (clear time) dropped such an ally
                // from the scheduled dash, and the slot model has no catch-up: the
                // hero would strand 4 cells back and idle to a timeout loss (branch
                // review 4.1). Always emitting the formation move also preserves
                // reachability when a dungeon shortens the spawn pause below one
                // normal movement step.
                if between_wave_behavior.advance_formation {
                    let dash_ticks = game_config.fight_settings.formation_advance_ticks;
                    for ally in active_fight_cloned
                        .entities
                        .iter()
                        .filter(|e| e.team == EntityTeam::Ally && e.hp > 0)
                    {
                        self.fight_clock.schedule(
                            OverlordEvent::StartMove {
                                entity_id: ally.id,
                                to: Coordinates {
                                    x: ally.coordinates.x
                                        + crate::mechanics::fight::FORMATION_ADVANCE_CELLS,
                                    y: ally.coordinates.y,
                                },
                                duration_ticks: dash_ticks,
                            },
                            between_wave_behavior.spawn_delay_ticks,
                        );
                    }
                }

                events.push(EventPluginized::now(OverlordEvent::WaveCleared {}));
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_heal(
        &mut self,
        by_entity_id: Option<EntityId>,
        entity_id: Uuid,
        heal: u64,
        source: CombatSource,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // Read the healer before the healed entity is borrowed mutably; a
        // self-heal is the common case, so the two are usually the same row.
        let fight_instance_id = active_fight.id;
        let fight_template_id = active_fight.fight_id;
        let actor = breakdown_actor(active_fight, by_entity_id);

        let Some(healed_entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        let hp_before = healed_entity.hp;
        healed_entity.hp = healed_entity
            .hp
            .saturating_add(heal)
            .min(healed_entity.max_hp);
        // Applied heal, not requested heal: overheal above `max_hp` never
        // happened as far as the breakdown is concerned.
        let applied = healed_entity.hp - hp_before;

        self.record_fight_breakdown(
            fight_instance_id,
            fight_template_id,
            actor,
            source,
            0,
            applied,
            false,
        );

        EventHandleResult::ok(state)
    }

    #[allow(clippy::too_many_arguments)]
    pub fn handle_damage(
        &mut self,
        by_entity_id: Option<Uuid>,
        entity_id: Uuid,
        damage: u64,
        damage_data: &CustomEventData,
        source: CombatSource,
        mut rand_gen: rand::rngs::StdRng,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        // Read the dealer before the victim is borrowed mutably — it may be the
        // same entity (retaliation, reflected damage).
        let fight_instance_id = active_fight.id;
        let fight_template_id = active_fight.fight_id;
        let actor = breakdown_actor(active_fight, by_entity_id);

        let Some(damaged_entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        let (actual_hp_removed, insurance_consumed) =
            remove_hp_with_insurance(damaged_entity, damage);
        let new_hp = damaged_entity.hp;

        // Applied damage, so an insurance save or an overkill contributes only
        // the HP it actually took.
        self.record_fight_breakdown(
            fight_instance_id,
            fight_template_id,
            actor,
            source,
            actual_hp_removed,
            0,
            damage_data.0.get("crit").is_some_and(|crit| *crit > 0),
        );
        if insurance_consumed {
            tracing::debug!(
                %entity_id,
                damage,
                "Consumed gambling insurance lethal-save charge"
            );
        }
        // A2-BAL-001: ordinary damage no longer produces any control effect.
        // The automatic boss stagger that used to live here is gone, together
        // with the `spawn_wave` Attack compensation that paid for its downtime
        // — removing only one half would have changed real difficulty.
        //
        // `EntityStun` itself is deliberately kept: it is the substrate a future
        // explicitly-authored control effect would use. It simply has no
        // production source any more.
        let game_config = self.game_config.get();
        let damaged_is_boss = damaged_entity.has_big_hp_bar;
        let damaged_max_hp = damaged_entity.max_hp;
        let victim_gauge_share = damaged_entity.attributes.gauge_hp_share();

        // BAL-026: ACTUAL HP removed feeds the shared gauge, scale-independent
        // by construction. Received normalizes by the victim's own bar; dealt
        // additionally scales by the victim's wave share, so absolute stats
        // never speed the bar up. Overkill is already cut by the actual-loss
        // clamp; self-damage counts once, as received; ownerless damage grants
        // no dealt half. A combatant without a flip state accrues nothing —
        // `accumulate_flip_gauge` no-ops for them.
        let mut gauge_events = Vec::new();
        if actual_hp_removed > 0 && damaged_max_hp > 0 {
            let coefficient = game_config.flip_settings.damage_gauge_coefficient;
            let hp_share = actual_hp_removed as f64 / damaged_max_hp as f64;
            if let Some(flip) = crate::logic::stones::accumulate_flip_gauge(
                &mut state,
                entity_id,
                coefficient * hp_share,
                essences::flip::FlipProgressSource::DamageReceived,
                &game_config,
            ) {
                gauge_events.push(EventPluginized::now(flip));
            }
            if let Some(dealer) = by_entity_id
                && dealer != entity_id
                && let Some(flip) = crate::logic::stones::accumulate_flip_gauge(
                    &mut state,
                    dealer,
                    coefficient * hp_share * victim_gauge_share,
                    essences::flip::FlipProgressSource::DamageDealt,
                    &game_config,
                )
            {
                gauge_events.push(EventPluginized::now(flip));
            }
        }

        if new_hp > 0 {
            let mut events = Vec::new();
            events.extend(gauge_events);

            // Boss summon (owner 2026-07-10): dropping below the configured HP
            // fraction spawns the template's LAST wave immediately — anchored at
            // the player (spawn_wave detects the summon wave), entering via the
            // normal entrance runs. The latch is `current_wave` itself (set to
            // the last wave), so it persists in saves and can't re-trigger; a
            // boss killed before the trigger never spawns it (the death handler
            // skips a pending summon wave).
            let current_chapter = state.character_state.character.current_chapter_level;
            if damaged_is_boss
                && let Some(active_fight) = &mut state.active_fight
                && let Ok(template) = game_config.require_fight_template(active_fight.fight_id)
                && let Some(waves_cfg) = template.prepare_fight_waves.as_ref()
                && let Some(fraction) = waves_cfg.summon_wave_at_hp_fraction
                && active_fight.current_wave < template.waves_amount
                && (new_hp as f64) < fraction * damaged_max_hp as f64
            {
                active_fight.current_wave = template.waves_amount;
                let active_fight_cloned = active_fight.clone();
                let wave_data = crate::mechanics::fight::wave_data_from_config(waves_cfg);
                let fight_type_str = format!("{:?}", template.fight_type);
                let mut sink = crate::mechanics::fight::NativeSink::default();
                let rng = GameRng::new(rand_gen);
                match crate::mechanics::fight::spawn_wave(
                    &mut sink,
                    &rng,
                    &game_config,
                    self.behaviors.lookups(),
                    &active_fight_cloned,
                    &wave_data,
                    template.power.map(|p| p as f64).unwrap_or(0.0),
                    current_chapter,
                    &fight_type_str,
                ) {
                    Ok(()) => {
                        events.extend(sink.events.into_iter().map(EventPluginized::now));
                    }
                    Err(err) => {
                        tracing::error!("boss summon spawn_wave failed: {err}");
                    }
                }
            }

            return EventHandleResult::ok_events(state, events);
        }

        let Some(active_fight) = &mut state.active_fight else {
            return EventHandleResult::ok(state);
        };

        let Some(damaged_entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            return EventHandleResult::fail(state);
        };

        // Capture values before dropping the mutable borrow
        let damaged_id = damaged_entity.id;
        let damaged_team = damaged_entity.team.clone();
        let damaged_rewards = damaged_entity.rewards.clone();
        let damaged_template_id = damaged_entity.entity_template_id;
        // §2 consumer 1: per-kill drop CHANCE scales by the dying mob's
        // wave_share so the fight's total drop expectation is count-invariant.
        let damaged_wave_share = damaged_entity.attributes.wave_share();

        let has_remaining_allies = active_fight
            .entities
            .iter()
            .any(|e| e.team == EntityTeam::Ally && e.id != damaged_id);

        // The killing blow's gauge still counts (actual loss, no overkill);
        // the stun events die with the boss.
        let mut events = gauge_events;

        let mut artifact_stone_drop = None;
        if damaged_team == EntityTeam::Enemy {
            // Enemy death — compute and drop rewards
            let mut currencies = Vec::new();

            if state.pvp_state.is_none() {
                // "Pushing pays": a campaign-chapter boss drops more reward
                // currency the deeper the chapter, so clearing a fresh chapter
                // visibly pays out more from the boss (reusing the existing
                // fly-out drop VFX). Trash mobs and non-campaign fights (dungeon,
                // arena, single) are unaffected — only `is_boss` entities in a
                // campaign fight scale.
                let is_boss = damaged_template_id
                    .and_then(|tid| game_config.entity_template(tid))
                    .is_some_and(|t| t.is_boss);
                let is_campaign = game_config
                    .require_fight_template(active_fight.fight_id)
                    .map(|f| {
                        matches!(
                            f.fight_type,
                            FightType::CampaignFight | FightType::CampaignBossFight
                        )
                    })
                    .unwrap_or(false);
                let reward_multiplier = if is_boss && is_campaign {
                    boss_reward_chapter_multiplier(
                        game_config.game_settings.boss_reward_chapter_growth,
                        game_config.game_settings.boss_reward_max_multiplier,
                        state.character_state.character.current_chapter_level,
                    )
                } else {
                    1.0
                };

                // BAL-031: a campaign chapter boss rolls its own extra artifact
                // stone leg (signed 2%), separate from the currency drops and
                // from the artifacts themselves. The leg shares the BAL-038
                // ArtifactStones daily counter with the mob leg — the authored
                // `D = 2.585 mob + 0.940 boss = 3.525` covers both, so this roll
                // decays and consumes the same budget and cannot step past the
                // combined cap of 8.
                if is_boss && is_campaign {
                    let now = ::time::utc_now();
                    let boss_decay = {
                        let daily = essences::kill_faucets::band_for_today(
                            &mut state.character_state.kill_faucet_daily,
                            essences::kill_faucets::KillFaucetFamily::ArtifactStones,
                            game_config.kill_faucet_settings.artifact_stones_d,
                            now,
                        );
                        if daily.remaining() > 0 {
                            daily.decay()
                        } else {
                            0.0
                        }
                    };
                    let chance = game_config
                        .artifacts_settings
                        .stone_drop
                        .chapter_boss_chance
                        * boss_decay;
                    artifact_stone_drop = self.roll_artifact_stone_drop(
                        &mut rand_gen,
                        chance,
                        state.character_state.character.current_chapter_level,
                    );
                    if artifact_stone_drop.is_some() {
                        essences::kill_faucets::band_for_today(
                            &mut state.character_state.kill_faucet_daily,
                            essences::kill_faucets::KillFaucetFamily::ArtifactStones,
                            game_config.kill_faucet_settings.artifact_stones_d,
                            now,
                        )
                        .take(1);
                    }
                }

                if let Some(rewards) = damaged_rewards {
                    for reward in rewards {
                        // Scale the CHANCE (not the amount) by wave_share — the
                        // expectation scales exactly, no integer distortion.
                        let drop_chance = (reward.drop_chance.clamp(0.0, 100.0)
                            * damaged_wave_share)
                            .clamp(0.0, 100.0);
                        if rand_gen.random_range(0.0..100.0) < drop_chance {
                            let rolled = if reward.from <= reward.to {
                                rand_gen.random_range(reward.from..=reward.to)
                            } else {
                                tracing::error!(
                                    "Entity {} has a bad reward range: {:?}",
                                    damaged_id,
                                    reward
                                );
                                0
                            };
                            // A2-BAL-004 §4.2: progression currencies and the
                            // boss-only Gems budget do NOT ride the chapter
                            // growth multiplier.
                            //
                            // `boss_reward_chapter_growth` exists to make deeper
                            // chapters pay more of the currencies you SPEND on
                            // depth — Gold and the like. It was applied to every
                            // reward on the entity, so Skill Crystals rode it
                            // too: capped at x12, an ordinary boss is worth
                            // `0.30 x 8 x 12 = 28.8` Crystals by ch52, repeat
                            // kills included and no daily cap. That is what puts
                            // roughly 3,000 Crystals in a wallet by ch139 from
                            // boss kills alone, against a signed supply of tens.
                            //
                            // Gacha pull currency is a different economy: its
                            // supply is signed per game-day, not per chapter
                            // depth, so scaling it by depth has no target to
                            // land on.
                            let is_progression_currency = reward.currency_id
                                == game_config.game_settings.ability_gacha.currency_id
                                || reward.currency_id
                                    == game_config.game_settings.pet_gacha.currency_id
                                || reward.currency_id
                                    == game_config.kill_faucet_settings.boss_gems_currency_id;
                            let mut amount = if reward_multiplier > 1.0 && !is_progression_currency
                            {
                                ((rolled as f64) * reward_multiplier).round() as i64
                            } else {
                                rolled
                            };

                            // Resource addendum 3: chapter Skill income and
                            // Gems are boss-only exact-cap faucets. The packet
                            // remains authored on the entity for VFX/content
                            // inspection, while this persisted daily cap makes
                            // repeat farming finite and keeps the split stable
                            // as chapter speed changes.
                            let now = ::time::utc_now();
                            if reward.currency_id
                                == game_config.kill_faucet_settings.skill_chapter_currency_id
                            {
                                if is_boss && is_campaign {
                                    let pass_finished = !state.progress_pass.tiers.is_empty()
                                        && state
                                            .progress_pass
                                            .tiers
                                            .iter()
                                            .all(|tier| tier.is_unlocked);
                                    let cap = if pass_finished {
                                        game_config
                                            .kill_faucet_settings
                                            .skill_chapter_cap_after_pass
                                    } else {
                                        game_config.kill_faucet_settings.skill_chapter_cap_with_pass
                                    };
                                    amount = essences::kill_faucets::exact_cap_for_today(
                                        &mut state.character_state.kill_faucet_daily,
                                        essences::kill_faucets::KillFaucetFamily::SkillChapters,
                                        cap,
                                        now,
                                    )
                                    .take(amount);
                                } else {
                                    amount = 0;
                                }
                            } else if reward.currency_id
                                == game_config.kill_faucet_settings.boss_gems_currency_id
                            {
                                if is_boss && is_campaign {
                                    amount = essences::kill_faucets::exact_cap_for_today(
                                        &mut state.character_state.kill_faucet_daily,
                                        essences::kill_faucets::KillFaucetFamily::BossGems,
                                        game_config.kill_faucet_settings.boss_gems_daily_cap,
                                        now,
                                    )
                                    .take(amount);
                                } else {
                                    amount = 0;
                                }
                            }

                            if amount > 0 {
                                currencies.push(CurrencyUnit {
                                    currency_id: reward.currency_id,
                                    amount,
                                });
                            }
                        }
                    }
                } else {
                    tracing::error!(
                        "Failed to get reward from damaged_entity with entity_id={}",
                        entity_id
                    );
                };
            }

            events.push(EventPluginized::now(OverlordEvent::EntityDeath {
                entity_id: damaged_id,
                reward: currencies,
                origin: CombatEventOrigin::Core,
            }));
            events.extend(artifact_stone_drop);
        } else if has_remaining_allies {
            // An ally dies but other allies survive — remove from fight, continue
            events.push(EventPluginized::now(OverlordEvent::EntityDeath {
                entity_id: damaged_id,
                reward: Vec::new(),
                origin: CombatEventOrigin::Core,
            }));
        } else {
            // Last ally dies — fight lost
            events.push(EventPluginized::now(OverlordEvent::PlayerDeath {}));
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_fight_progress(
        &mut self,
        current_tick: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active_fight for fight_progress");
            return EventHandleResult::ok(state);
        };

        if active_fight.fight_ended {
            return EventHandleResult::ok(state);
        }

        if active_fight.fight_stopped {
            return EventHandleResult::ok(state);
        }

        if active_fight.entities.is_empty() {
            tracing::error!("No entities in fight");
            return EventHandleResult::ok(state);
        }

        if current_tick - self.start_fight_tick >= active_fight.max_duration_ticks {
            active_fight.fight_ended = true;
            tracing::debug!("Fight lasted too long, ending it");
            let fight_uuid = active_fight.id;
            let fight_id = active_fight.fight_id;
            let end_fight_delay = self.get_end_fight_delay(fight_id);
            let pvp_state = state.pvp_state.clone().map(Box::new);
            self.fight_clock.schedule(
                OverlordEvent::EndFight {
                    fight_id: fight_uuid,
                    is_win: false,
                    pvp_state,
                },
                end_fight_delay,
            );
            return EventHandleResult::ok(state);
        }

        let mut events = vec![];
        let game_config = self.game_config.get();

        // BAL-033 Priest passive: every period, heal the ally with the lowest
        // HP SHARE — in solo that is the Priest. The timer is fight-local and
        // rides the fight clock, so it neither drifts with heartbeat cadence
        // nor carries between fights.
        let periodic: Vec<(EntityId, f64, u64)> = active_fight
            .entities
            .iter()
            .filter(|entity| {
                crate::mechanics::class_passives::periodic_is_due(entity, current_tick)
            })
            .filter_map(|entity| {
                let share = crate::mechanics::class_passives::periodic_heal_share(entity)?;
                let period = game_config
                    .classes
                    .iter()
                    .find(|class| Some(class.id) == entity.class_id)
                    .map(|class| class.passive_period_ticks)
                    .unwrap_or(0);
                (share > 0.0 && period > 0).then_some((entity.id, share, period))
            })
            .collect();

        for (healer_id, share, period) in periodic {
            let team = active_fight
                .entities
                .iter()
                .find(|entity| entity.id == healer_id)
                .map(|entity| entity.team.clone());
            // Lowest HP SHARE, not lowest HP: a big ally at half health needs
            // the heal more than a small one two points down.
            let target = active_fight
                .entities
                .iter()
                .filter(|entity| Some(&entity.team) == team.as_ref() && entity.max_hp > 0)
                .min_by(|a, b| {
                    let share_of = |e: &essences::entity::Entity| e.hp as f64 / e.max_hp as f64;
                    share_of(a)
                        .partial_cmp(&share_of(b))
                        .unwrap_or(std::cmp::Ordering::Equal)
                })
                .map(|entity| (entity.id, entity.max_hp));

            if let Some(healer) = active_fight
                .entities
                .iter_mut()
                .find(|entity| entity.id == healer_id)
            {
                healer.attributes.set(
                    crate::mechanics::class_passives::PASSIVE_DUE,
                    crate::mechanics::class_passives::next_due(period, current_tick),
                );
            }

            if let Some((target_id, max_hp)) = target {
                let heal = (share * max_hp as f64).floor() as u64;
                if heal > 0 {
                    events.push(EventPluginized::now(OverlordEvent::Heal {
                        entity_id: target_id,
                        heal,
                        // Class-passive periodic heal — no catalog id to
                        // stamp, so it reads as passive regeneration.
                        by_entity_id: Some(healer_id),
                        origin: essences::combat_origin::CombatEventOrigin::Core,
                        source: CombatSource::Regeneration,
                    }));
                }
            }
        }

        for entity in &mut active_fight.entities {
            // Mana accrues on the fight clock, drift-free: the pool carries the
            // tick it was last accrued at, so the amount restored is exactly the
            // elapsed fight time regardless of heartbeat cadence.
            if let Some(mana) = entity.mana.as_mut() {
                mana.regen_to(current_tick);
            }

            if entity.move_target.is_none()
                && let Some(queued) = entity.actions_queue.pop(current_tick)
            {
                events.push(event_from_entity_action(
                    queued.action,
                    entity.id,
                    queued.origin,
                ));
            }
        }

        EventHandleResult::ok_events(state, events)
    }

    pub fn handle_set_max_hp(
        &mut self,
        entity_id: EntityId,
        new_max_hp: u64,
        new_hp: u64,
        mut state: OverlordState,
    ) -> EventHandleResult<OverlordEvent, OverlordState> {
        let Some(active_fight) = &mut state.active_fight else {
            tracing::error!("No active fight for end_fight");
            return EventHandleResult::fail(state);
        };

        let Some(entity) = active_fight
            .entities
            .iter_mut()
            .find(|entity| entity.id == entity_id)
        else {
            tracing::error!("Failed to get entity with entity_id={}", entity_id);
            return EventHandleResult::fail(state);
        };

        entity.max_hp = new_max_hp;
        entity.hp = new_hp.min(new_max_hp);

        EventHandleResult::ok(state)
    }
}

/// Per-cell waypoints of a run from `from` to `to`: `(delay_ticks, cell)` for
/// every cell entered, in traversal order. The runner "enters" a cell at the
/// start of its traversal — the first waypoint has delay 0 (applied
/// immediately by `handle_start_move`) and the destination cell is reached one
/// cell-time before `EndMove`, the same coordinate timeline the old
/// one-`StartMove`-per-cell movement produced.
fn move_progress_steps(
    from: &Coordinates,
    to: &Coordinates,
    duration_ticks: u64,
) -> Vec<(u64, Coordinates)> {
    let dx = to.x - from.x;
    let dy = to.y - from.y;
    let steps = dx.abs().max(dy.abs()).max(1);
    (1..=steps)
        .map(|k| {
            let cell = Coordinates {
                x: from.x + dx * k / steps,
                y: from.y + dy * k / steps,
            };
            (duration_ticks * (k as u64 - 1) / steps as u64, cell)
        })
        .collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn at(x: i64, y: i64) -> Coordinates {
        Coordinates { x, y }
    }

    /// The waypoints must reproduce the old one-StartMove-per-cell coordinate
    /// timeline: enter cell k at (k-1)/N of the run, destination entered one
    /// cell-time before EndMove.
    #[test]
    fn move_progress_steps_match_per_cell_timeline() {
        // straight 4-cell run, 500ms per cell
        assert_eq!(
            move_progress_steps(&at(0, 1), &at(4, 1), 2000),
            vec![
                (0, at(1, 1)),
                (500, at(2, 1)),
                (1000, at(3, 1)),
                (1500, at(4, 1)),
            ]
        );

        // single-cell diagonal sidestep: one immediate waypoint, like the old code
        assert_eq!(
            move_progress_steps(&at(2, 1), &at(3, 2), 707),
            vec![(0, at(3, 2))]
        );

        // degenerate zero-distance move still yields the destination
        assert_eq!(
            move_progress_steps(&at(2, 1), &at(2, 1), 0),
            vec![(0, at(2, 1))]
        );
    }
}