overlord_event_system/logic/

laws.rs

//! Laws v0.2 — the combat runtime of `condition → effect + Resonance`.
//!
//! A law is no longer a stat block that happens to be side-gated: it watches
//! for one Core occurrence, runs one action, and drops its Resonance into its
//! bridge. This module is the whole of that behaviour; the arithmetic (charge
//! capacity, amplification, upgrade scaling) lives in
//! [`crate::mechanics::cores`] and the shapes in [`essences::cores`].
//!
//! Three entry points, because the three condition families need three
//! different moments:
//!
//! * [`OverlordLogic::apply_law_pre_cast`] runs from `handle_cast_ability`
//!   BEFORE the cast resolves. `RL-01` reads "every 5th Basic Attack: THIS
//!   strike deals +100%", which is only expressible if the law fires before its
//!   own strike computes damage.
//! * [`OverlordLogic::apply_law_reactions`] hangs off `apply_success_hooks`, so
//!   it sees the world an outcome actually produced — crits, dodges, hits
//!   taken, kills, HP thresholds, AoE target counts.
//! * [`OverlordLogic::apply_flip_to_laws`] runs on a completed flip: it
//!   delivers the bridge charge, re-folds attributes, and only THEN fires the
//!   "phase started" laws (`RL-12`, `FL-11`). That order is acceptance #9 —
//!   reversed, those two would be the only laws in the catalog a bridge can
//!   never reach, since their single fire happens exactly at that moment.
//!
//! **Anti-loop.** Every condition is gated on
//! [`essences::combat_origin::CombatEventOrigin::is_core`] and every combat
//! outcome a law produces is emitted `Proc`. `FL-09` ("a Core action killed an
//! enemy → 150% Attack to every enemy") therefore cannot chain on the kills its
//! own blast makes: those arrive on `Proc` damage, which is not a condition at
//! all. A genuine Basic Attack or original Skill stays Core even when a law
//! changed its magnitude — a law arms an attribute, it never re-emits the
//! action.
//!
//! **All per-fight law state lives in the entity's `attributes`,** the same
//! idiom the stones runtime uses (`stone.*`). Keys are namespaced `law.*` and
//! tagged by `side + slot index` rather than by law id, so they stay short and
//! are stable for a whole fight. Mid-fight build edits update the durable Core
//! state only; the entity-local snapshot continues driving this fight.
//!
//! **Known edge — the event that crosses the gauge belongs to the INCOMING
//! phase.** A producer advances the entity's own `flip_state` while it resolves
//! and emits `GlobalFlip` as a follow-up event, so by the time the law hook runs
//! the outgoing side is already down: the flipping event is evaluated against
//! the incoming side's laws, and against them at their PRE-delivery
//! amplification. One action per flip is affected. It is not a loop and not a
//! leak (the phase-start laws are still fired exactly once, by the flip handler,
//! after delivery); moving it would mean deferring the side change out of the
//! producers, which is flip machinery rather than law machinery.
//!
//! There is ONE producer:
//!
//! * `logic::stones::accumulate_trigger_gauge` — a Trigger Stone fire. This one
//!   is structural rather than incidental: `apply_success_hooks` runs the stones
//!   hook immediately before the laws hook, so a fire that crosses the gauge
//!   always hands the rest of that event to the incoming side. Pinned by
//!   `test_cores::a_stone_driven_flip_hands_the_same_event_to_the_incoming_sides_laws`.

use std::collections::BTreeSet;

use essences::abilities::{AbilityId, AbilityTag};
use essences::combat_origin::CombatEventOrigin;
use essences::cores::{LawCondition, LawEffect, LawTemplate, LawTemplateId};
use essences::entity::{Entity, EntityAttributes, EntityId};
use essences::fight_breakdown::CombatSource;
use essences::flip::WorldSide;

use crate::game_config_helpers::GameConfigLookup;
use crate::logic::combat_facts::{self, CastKind, CombatFact};
use crate::mechanics::{
    artifacts as artifact_mech, balance, cores as mech, fight::get_entity_stat,
    pet_facets as pet_mech,
};
use crate::{
    event::OverlordEvent,
    logic::{EventPluginized, handler::OverlordLogic},
    state::OverlordState,
};

/// Damage bonus armed for the owner's next BASIC attack, permyriad. Defined in
/// [`crate::mechanics::cores`], where `mechanics::fight::attack` reads it.
pub use crate::mechanics::cores::{ARM_BASIC, ARM_SKILL, ARM_THIS};

/// Splash armed for the owner's next Basic Attack, permyriad of Attack. Spent
/// at that attack's pre-cast hook against every OTHER living enemy.
pub const ARM_SPLASH: &str = "law.arm_splash";

/// Echo armed for the owner's next original Skill, permyriad of Attack.
pub const ARM_ECHO: &str = "law.arm_echo";

/// Sequence number of the cast whose distinct targets are being counted.
const CAST_SEQ: &str = "law.cast_seq";

/// Tick that cast was dispatched on. Only hits on the same tick count.
const CAST_TICK: &str = "law.cast_tick";

/// Lowest HP the owner has been at this fight, in permyriad of max HP, so a
/// threshold law fires on the CROSSING and not on every hit below it.
const HP_WATERMARK: &str = "law.hp_watermark";

const COUNTER_PREFIX: &str = "law.n.";
const ONCE_PREFIX: &str = "law.once.";
const TARGET_PREFIX: &str = "law.tgt.";
const SKILL_SEEN_PREFIX: &str = "law.sk.";

/// `VL-05 First Article`'s per-law, per-phase latch. Lives under
/// [`ONCE_PREFIX`] so the flip's own sweep clears it — "once per phase" and not
/// once per fight comes free.
const FIRST_ARTICLE_PREFIX: &str = "fa.";

/// `HL-04 Single Lesson`'s latch. One per phase for the whole stone, not per
/// law: the stone "switches off until the Flip" once it has spent its wake.
const SINGLE_LESSON_TAG: &str = "hl4";

/// Per-law counter ("every N-th ..."), keyed by side + slot.
fn counter_key(tag: &str) -> String {
    format!("{COUNTER_PREFIX}{tag}")
}

/// Per-law "already fired this phase" latch, keyed by side + slot.
fn once_key(tag: &str) -> String {
    format!("{ONCE_PREFIX}{tag}")
}

/// Marks one victim of the cast identified by [`CAST_SEQ`].
fn target_key(victim: EntityId) -> String {
    format!("{TARGET_PREFIX}{victim}")
}

/// Tick at which `ability_id` last resolved as a Core original Skill.
fn skill_seen_key(ability_id: AbilityId) -> String {
    format!("{SKILL_SEEN_PREFIX}{ability_id}")
}

/// Short, stable per-law bookkeeping tag: `R2` = Real core, slot 2.
fn slot_tag(side: WorldSide, slot_index: i64) -> String {
    let side = match side {
        WorldSide::Real => 'R',
        WorldSide::Fantasy => 'F',
    };
    format!("{side}{slot_index}")
}

fn attr(attributes: &EntityAttributes, key: &str) -> i64 {
    attributes.0.get(key).copied().unwrap_or(0)
}

/// One slotted, enabled law with everything the runtime needs about it,
/// resolved once so the config borrow can end.
struct LiveLaw {
    template: LawTemplate,
    level: i64,
    tag: String,
    /// Every multiplier that lands on the effect's NUMBERS, already combined:
    /// bridge amplification, the artifact's Visible Law socket, and — for a law
    /// woken while its side is down — the share the waking source offers.
    ///
    /// Resonance deliberately does not pass through here (acceptance #8), and
    /// neither does any condition parameter.
    amplification: f64,
    /// `true` when this law is running while its side is DOWN. A hidden run
    /// banks no Resonance, fills no bridge and feeds no gauge (design §3.4);
    /// carrying the fact on the law is what keeps every fire site from having
    /// to remember it.
    hidden: bool,
}

impl LiveLaw {
    fn id(&self) -> LawTemplateId {
        self.template.id
    }

    /// The effect's number after the law's own upgrade scaling and every
    /// multiplier in [`Self::amplification`] — the single place any of them is
    /// applied to an effect.
    fn effect_value(&self) -> i64 {
        mech::law_effect_number(self.template.effect_value, self.level, self.amplification)
    }

    /// Duration is one of the effect's numbers for AMPLIFICATION — bridge
    /// amplification stretches it ("усиливаются урон, лечение, длительность,
    /// снижение кулдауна", §3) — but NOT for rank: law rank scales the
    /// magnitude only, and duration never grows with level (BAL-029).
    fn duration_ticks(&self) -> u64 {
        ((self.template.effect_duration_ticks as f64 * self.amplification).round() as i64).max(0)
            as u64
    }
}

/// The Core occurrences a law can react to after the fact.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum Reaction {
    Crit,
    Dodge,
    HitTaken,
    Kill,
    HpDropped,
    /// Distinct targets the owner's current cast has now damaged.
    CastTargets(i64),
}

/// Everything an effect may need, read once before any mutation.
struct LawCtx {
    attack: f64,
    max_hp: u64,
    speed: i64,
    /// Living opponents of the law owner, nearest first.
    enemies: Vec<EntityId>,
    /// Remaining skill cooldowns as `(ability_id, deadline_tick)`, class Basic
    /// Attacks excluded — a law that "returns a Skill cooldown" must never hand
    /// back the auto-attack.
    skill_cooldowns: Vec<(AbilityId, u64)>,
    now: u64,
}

/// One law that passed its condition, plus the counter writes its evaluation
/// implies. Counters are written for EVERY law that watches the occurrence, not
/// only for the ones that fired, or "every 5th" could never reach five.
struct Evaluation {
    fired: Vec<LiveLaw>,
    counters: Vec<(String, i64)>,
}

impl OverlordLogic {
    /// Whether `ability_id` is one of `entity`'s class Basic Attacks. This —
    /// not `AbilityCastType`, which is presentation — is the server's notion of
    /// "Basic Attack vs original Skill"; it is the same predicate
    /// `StartCastAbilityResult::into_entity_action` uses to choose between
    /// `CastAbility` and `CastBasicAbility`.
    fn is_basic_ability(
        game_config: &configs::game_config::GameConfig,
        entity: &Entity,
        ability_id: AbilityId,
    ) -> bool {
        combat_facts::cast_kind(game_config, entity, ability_id) == CastKind::Basic
    }

    /// The active-side, slotted, enabled laws of one combatant, with their
    /// current bridge amplification.
    ///
    /// Empty for a mob, an arena filler bot and anyone below the cores unlock
    /// chapter (all carry an empty `law_cores`), and it skips every law whose
    /// side is currently down — which is what makes "a hidden law's condition
    /// is not even evaluated" (acceptance #3) structural rather than a rule at
    /// each call site.
    fn live_laws(
        game_config: &configs::game_config::GameConfig,
        entity: &Entity,
        mods: &artifact_mech::LawColumnMods,
    ) -> Vec<LiveLaw> {
        let Some(active_side) = entity.flip_state.map(|flip| flip.active_side) else {
            return Vec::new();
        };
        Self::laws_of_side(game_config, entity, active_side, mods)
    }

    /// The slotted, enabled laws of ONE side, with every effect multiplier that
    /// applies to them resolved.
    ///
    /// Called twice: with the active side, which is the ordinary law runtime,
    /// and — only when the artifact offers a wake — with the hidden side, whose
    /// laws are ordinarily not evaluated at all. The share a hidden law runs at
    /// is applied by the caller, because it is decided per law by the
    /// intersection rule.
    fn laws_of_side(
        game_config: &configs::game_config::GameConfig,
        entity: &Entity,
        side: WorldSide,
        mods: &artifact_mech::LawColumnMods,
    ) -> Vec<LiveLaw> {
        if entity.law_cores.laws.is_empty() {
            return Vec::new();
        }
        let hidden = entity
            .flip_state
            .is_some_and(|flip| flip.active_side != side);

        let mut laws = Vec::new();
        for owned in entity.law_cores.slotted_laws() {
            let Some(template) = mech::law_template(game_config, owned.template_id) else {
                continue;
            };
            if template.side != side || !template.is_active {
                continue;
            }
            let Some(slot_index) = owned.slot_index else {
                continue;
            };
            // Bridge amplification and the Visible Law socket are two separate
            // multipliers on the same numbers, so they compose rather than
            // override: a `VL-02` law on a full bridge is worth both.
            let amplification = mech::law_power_multiplier(&entity.law_bridges, owned.template_id)
                * mods.effect_multiplier(
                    owned.template_id,
                    &entity.law_bridges,
                    entity.law_bridges.capacity_hundredths,
                );
            laws.push(LiveLaw {
                template: template.clone(),
                level: owned.level.max(1),
                tag: slot_tag(template.side, slot_index),
                amplification,
                hidden,
            });
        }
        laws
    }

    /// The artifact's right column for the OWNER of the laws being evaluated,
    /// read once per hook — the same shape `live_aspect_in_socket` gives the
    /// left column. Resolved per combatant, so a party ally's or a human PvP
    /// opponent's own artifacts modify their laws and the local hero's never
    /// leak onto someone else's build. Mods degrade to `NONE` for combatants
    /// with no `CharacterState` (arena filler bots).
    fn law_column_mods(
        &self,
        state: &OverlordState,
        owner_id: EntityId,
    ) -> artifact_mech::LawColumnMods {
        let Some(build) = state.active_fight.as_ref().and_then(|fight| {
            crate::entities::combatant_character_state(
                &state.character_state,
                &state.party,
                &state.pvp_state,
                fight,
                owner_id,
            )
        }) else {
            return artifact_mech::LawColumnMods::NONE;
        };
        artifact_mech::law_column_mods(&self.game_config.get(), &build.artifacts)
    }

    fn law_ctx(
        &self,
        game_config: &configs::game_config::GameConfig,
        entities: &[Entity],
        owner: &Entity,
    ) -> LawCtx {
        let mut enemies: Vec<&Entity> = entities
            .iter()
            .filter(|e| e.team != owner.team && e.hp > 0)
            .collect();
        enemies.sort_by_key(|e| {
            (e.coordinates.x - owner.coordinates.x).abs()
                + (e.coordinates.y - owner.coordinates.y).abs()
        });

        let skill_cooldowns = owner
            .actions_queue
            .start_cast_entries()
            .into_iter()
            .filter(|(ability_id, _)| !Self::is_basic_ability(game_config, owner, *ability_id))
            .collect();

        LawCtx {
            attack: get_entity_stat(self.behaviors.lookups(), owner, "attack"),
            max_hp: owner.max_hp,
            speed: owner
                .attributes
                .speed_or_baseline(game_config.game_settings.baseline_speed),
            enemies: enemies.into_iter().map(|e| e.id).collect(),
            skill_cooldowns,
            now: self.fight_clock.now(),
        }
    }

    /// Laws whose condition is decided by the cast itself, evaluated BEFORE the
    /// cast resolves so an effect can change the very action that triggered it.
    ///
    /// Returns the events the laws produced; the caller prepends them to the
    /// cast's own output. Attribute arms are written straight onto the entity
    /// instead of going through an event, because `mechanics::fight::attack`
    /// reads them off the caster snapshot the ability script is about to be
    /// handed — an event would land one action too late.
    ///
    /// A non-Core cast (a derived repeat, anything a modifier produced) returns
    /// immediately: that is the anti-loop boundary for the pre-cast conditions.
    pub fn apply_law_pre_cast(
        &mut self,
        state: &mut OverlordState,
        caster_id: EntityId,
        ability_id: AbilityId,
        target_id: EntityId,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let mut events = Vec::new();
        if !self.dispatch_origin().is_core() {
            return events;
        }
        let game_config = self.game_config.get();

        // Snapshot everything the evaluation needs, then drop the fight borrow:
        // claiming a once-per-phase latch and writing counters both need `&mut
        // state`, and an effect may dispatch work that re-enters this module.
        let Some(fight) = state.active_fight.as_ref() else {
            return events;
        };
        if fight.fight_ended || fight.fight_stopped {
            return events;
        }
        let Some(owner) = fight.entities.iter().find(|e| e.id == caster_id) else {
            return events;
        };
        if owner.law_cores.laws.is_empty() {
            return events;
        }
        let is_basic = Self::is_basic_ability(&game_config, owner, ability_id);
        let ctx = self.law_ctx(&game_config, &fight.entities, owner);
        let mods = self.law_column_mods(state, caster_id);
        let mut laws = Self::live_laws(&game_config, owner, &mods);
        self.apply_wild_reading(state, owner, &mut laws);
        let hidden_laws = self.hidden_laws(&game_config, owner, &mods);
        let attributes = owner.attributes.clone();
        let paid_mana_x100 = crate::logic::combat_facts::paid_mana_x100(owner);
        let charges = owner.law_bridges.clone();
        let ability_tags: Vec<AbilityTag> = game_config
            .ability_template(ability_id)
            .map(|template| template.tags.clone())
            .unwrap_or_default();

        // The distinct-skill window (`FL-12`) is measured from the per-ability
        // record, which is written for every Core original Skill whether or not
        // a law is watching — so a law slotted between fights never sees a
        // half-filled window from the previous one.
        let distinct_skills = if is_basic {
            0
        } else {
            laws.iter()
                .chain(hidden_laws.iter())
                .filter(|law| law.template.condition == LawCondition::DistinctSkillsWithin)
                .map(|law| law.template.condition_window_ticks.max(0) as u64)
                .max()
                .map_or(0, |window| {
                    count_distinct_skills(&attributes, ctx.now, window, ability_id)
                })
        };

        // "THIS attack" belongs to the cast about to resolve and to no other.
        // The arm is only spent past the evasion gate, so a dodged trigger
        // strike strands it; `run_law_effect` arms with `add`, so a later fire
        // landing on a stranded value puts the sum of both on one swing.
        // Clearing it here — before any law can arm it — bounds it to one cast.
        self.clear_arm(state, caster_id, ARM_THIS);

        let cast = PreCast {
            is_basic,
            ability_tags,
            distinct_skills,
            paid_mana_x100,
        };
        let mut evaluation = evaluate_pre_cast(laws, &attributes, &cast);
        let hidden_evaluation = evaluate_pre_cast(hidden_laws, &attributes, &cast);
        evaluation.counters.extend(hidden_evaluation.counters);

        // Bookkeeping BEFORE the effects, exactly like the stones hook: an
        // effect may dispatch work that comes back through here, and it must
        // find the counters already advanced and the latches already taken.
        self.write_counters(state, caster_id, &evaluation.counters);
        if !is_basic {
            self.open_cast_window(state, caster_id, ability_id, ctx.now);
        }
        let fired = self.claim_phase_latches(state, caster_id, evaluation.fired);
        let woken = self.claim_hidden_wakes(state, caster_id, hidden_evaluation.fired, &mods);

        // A basic attack spends what was armed for a basic attack; a skill
        // spends the skill arm. `mechanics::fight::attack` picks between the
        // two keys by the cast kind recorded on the caster before this cast
        // resolves, so nothing has to be moved between subsystems and put back.
        if is_basic {
            events.extend(self.spend_arm_as_damage(
                state,
                caster_id,
                ARM_SPLASH,
                &ctx,
                SplashShape::EveryOtherEnemy(target_id),
            ));
        } else {
            events.extend(self.spend_arm_as_damage(
                state,
                caster_id,
                ARM_ECHO,
                &ctx,
                SplashShape::SingleTarget(target_id),
            ));
        }

        let fired = self.claim_first_article(state, caster_id, fired, &mods);
        events.extend(self.fire_all(state, caster_id, fired, &ctx, &mods, &charges));
        events.extend(self.fire_all(state, caster_id, woken, &ctx, &mods, &charges));
        events
    }

    /// Runs a batch of laws that passed their conditions: the effect, the
    /// Resonance it banks, and `HL-02 Linked Echo` where the artifact asks for
    /// it.
    ///
    /// The Resonance step is skipped for a law running while its side is down —
    /// design §3.4, the clause that keeps `ART-02` from doubling every bridge
    /// and the flip tempo. It is read off [`LiveLaw::hidden`] rather than
    /// re-derived here so there is exactly one place that decides it.
    fn fire_all(
        &mut self,
        state: &mut OverlordState,
        owner_id: EntityId,
        fired: Vec<LiveLaw>,
        ctx: &LawCtx,
        mods: &artifact_mech::LawColumnMods,
        charges: &essences::cores::LawBridgeCharges,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let mut events = Vec::new();
        for law in &fired {
            events.extend(self.run_law_effect(state, owner_id, law, ctx));
            // BAL-029 `Three Spell Rule`: the combo window is fully consumed
            // by its own proc — the next one needs three fresh distinct
            // Skills, the proccing cast included.
            if law.template.condition == LawCondition::DistinctSkillsWithin {
                self.clear_skill_seen_marks(state, owner_id);
            }
            if !law.hidden {
                self.bank_resonance(state, owner_id, law, mods);
            }
            // `HL-02` is the one wake that never checks the woken law's own
            // condition: the chosen law firing IS the condition. It hangs off
            // an ACTIVE fire, so it cannot chain off another hidden run.
            if !law.hidden
                && let Some((partner, share)) = mods.linked_echo(law.id(), charges)
                && let Some(echo) = self.hidden_partner(state, owner_id, partner, share)
            {
                events.extend(self.run_law_effect(state, owner_id, &echo, ctx));
            }
        }
        events
    }

    /// Builds the `LiveLaw` for a law woken by `HL-02`, at `share` of its
    /// strength, or `None` when it is not slotted, not enabled, or its side is
    /// currently UP (in which case it is running on its own already).
    fn hidden_partner(
        &self,
        state: &OverlordState,
        owner_id: EntityId,
        partner: LawTemplateId,
        share: f64,
    ) -> Option<LiveLaw> {
        if share <= 0.0 {
            return None;
        }
        let game_config = self.game_config.get();
        let owner = state
            .active_fight
            .as_ref()?
            .entities
            .iter()
            .find(|e| e.id == owner_id)?;
        let active_side = owner.flip_state?.active_side;
        let owned = owner.law_cores.law(partner)?;
        let slot_index = owned.slot_index?;
        let template = mech::law_template(&game_config, partner)?;
        if template.side == active_side || !template.is_active {
            return None;
        }
        Some(LiveLaw {
            template: template.clone(),
            level: owned.level.max(1),
            tag: slot_tag(template.side, slot_index),
            amplification: mech::law_power_multiplier(&owner.law_bridges, partner) * share,
            hidden: true,
        })
    }

    /// The laws of the side that is currently DOWN — empty unless the artifact
    /// offers a way to wake one.
    ///
    /// The gate matters beyond performance: evaluating hidden laws advances
    /// their counters, so a player with no wake source would silently build up
    /// "every 5th Basic Attack" progress on a side that cannot fire. Gating here
    /// is what makes a player without the right column byte-identical to one
    /// before this feature.
    fn hidden_laws(
        &self,
        game_config: &configs::game_config::GameConfig,
        owner: &Entity,
        mods: &artifact_mech::LawColumnMods,
    ) -> Vec<LiveLaw> {
        if !mods.wakes_hidden_laws() {
            return Vec::new();
        }
        let Some(active_side) = owner.flip_state.map(|flip| flip.active_side) else {
            return Vec::new();
        };
        Self::laws_of_side(game_config, owner, active_side.flipped(), mods)
    }

    /// `VL-05 First Article`: the FIRST activation of every active-side law in a
    /// phase applies its effect at the stone's share.
    ///
    /// A latch per law per phase, under the `law.once.` namespace so the flip's
    /// own sweep clears it — that is the whole of "per phase, not per fight".
    /// Resonance is deliberately left alone, which is what keeps the stone a
    /// different shape from its socket neighbours rather than a bigger one; the
    /// scaling therefore happens here, on the effect multiplier, and never
    /// touches [`Self::bank_resonance`].
    ///
    /// Hidden runs are skipped: `VL-05` is a Visible Law stone and speaks for
    /// the side that is up.
    fn claim_first_article(
        &self,
        state: &mut OverlordState,
        owner_id: EntityId,
        candidates: Vec<LiveLaw>,
        mods: &artifact_mech::LawColumnMods,
    ) -> Vec<LiveLaw> {
        let Some(share) = mods.first_activation_multiplier() else {
            return candidates;
        };
        if candidates.is_empty() {
            return candidates;
        }
        let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        else {
            return Vec::new();
        };
        candidates
            .into_iter()
            .map(|mut law| {
                if law.hidden {
                    return law;
                }
                let key = once_key(&format!("{FIRST_ARTICLE_PREFIX}{}", law.tag));
                if attr(&owner.attributes, &key) == 0 {
                    owner.attributes.set(&key, 1);
                    law.amplification *= share;
                }
                law
            })
            .collect()
    }

    /// Resolves the intersection rule (design §3) for every hidden law that
    /// passed its condition, and scales the survivors by the share they were
    /// woken at.
    ///
    /// Three of the four clauses live here:
    ///
    /// * §3.1 — each hidden law keeps its OWN counters and once-per-phase
    ///   latches; they are keyed by side + slot, so they never collide with the
    ///   active side's;
    /// * §3.2 — one law takes at most ONE activation per Core event: the
    ///   candidate list holds each law once and this pass emits each at most
    ///   once;
    /// * §3.3 — several sources may name one law and the LARGEST share wins,
    ///   never the sum. `HL-04`'s once-per-phase share is only taken when it
    ///   beats every free source AND its latch is still up; otherwise the law
    ///   falls back to the free source rather than falling silent.
    ///
    /// The fourth clause (no Resonance, no charge, no gauge, not a Core event)
    /// is enforced downstream — see [`Self::fire_all`] and `run_law_effect`'s
    /// `Proc` provenance.
    fn claim_hidden_wakes(
        &self,
        state: &mut OverlordState,
        owner_id: EntityId,
        candidates: Vec<LiveLaw>,
        mods: &artifact_mech::LawColumnMods,
    ) -> Vec<LiveLaw> {
        if candidates.is_empty() {
            return candidates;
        }
        let game_config = self.game_config.get();
        let threshold = crate::entities::combatant_flip_threshold(state, owner_id, &game_config);
        let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        else {
            return Vec::new();
        };
        let progress = owner.flip_state.map_or(0.0, |flip| flip.progress);
        let gauge_fill = artifact_mech::gauge_fill(progress, threshold);
        let charges = owner.law_bridges.clone();
        let capacity = charges.capacity_hundredths;

        let mut woken = Vec::new();
        for mut law in candidates {
            let wake = mods.hidden_wake(law.id(), gauge_fill, &charges, capacity);
            if wake.is_silent() {
                continue;
            }
            let mut share = wake.free_share;
            if wake.once_share > share {
                let key = once_key(SINGLE_LESSON_TAG);
                if attr(&owner.attributes, &key) == 0 {
                    owner.attributes.set(&key, 1);
                    share = wake.once_share;
                }
            }
            if share <= 0.0 {
                continue;
            }
            law.amplification *= share;
            woken.push(law);
        }
        woken
    }

    /// Laws whose condition is an outcome. Runs from `apply_success_hooks`, so
    /// the state it reads is the one the outcome actually produced.
    pub fn apply_law_reactions(
        &mut self,
        state: &mut OverlordState,
        events: &mut Vec<EventPluginized<OverlordEvent, OverlordState>>,
        event: &OverlordEvent,
    ) {
        // Cheap gates first: this hook runs on every successfully handled event
        // of the session, most of which are not combat at all. A player with no
        // laws leaves here having touched no state, which is what makes
        // acceptance #14 true by construction rather than by measurement.
        let Some(fight) = state.active_fight.as_ref() else {
            return;
        };
        if fight.fight_ended || fight.fight_stopped {
            return;
        }
        if fight.entities.iter().all(|e| e.law_cores.laws.is_empty()) {
            return;
        }

        let game_config = self.game_config.get();
        let classified = self.classify_reactions(&game_config, state, event);
        for (owner_id, reactions, cast_mark) in classified {
            if let Some((victim_id, seq)) = cast_mark {
                self.mark_cast_target(state, owner_id, victim_id, seq);
            }
            let produced = self.run_reactions(state, owner_id, &reactions);
            events.extend(produced);
        }
    }

    /// Which combatants this event implicates, how, and (for the attacker) the
    /// cast-target mark to write.
    ///
    /// The combat meaning of the event is not read here: it comes from
    /// [`crate::logic::combat_facts`], the one place either system defines
    /// "hit", "kill" or "dodge". What is left is the law-specific layer —
    /// translating those facts into [`Reaction`]s and counting the distinct
    /// targets of the owner's current cast, which needs the `law.*` attributes
    /// and so cannot live in the shared classifier.
    #[allow(clippy::type_complexity)]
    fn classify_reactions(
        &self,
        game_config: &configs::game_config::GameConfig,
        state: &OverlordState,
        event: &OverlordEvent,
    ) -> Vec<(EntityId, Vec<Reaction>, Option<(EntityId, i64)>)> {
        let Some(fight) = state.active_fight.as_ref() else {
            return Vec::new();
        };

        let mut out = Vec::new();
        for (owner_id, facts) in combat_facts::classify(game_config, fight, event) {
            let mut reactions = Vec::new();
            let mut cast_mark = None;
            for fact in facts {
                match fact {
                    CombatFact::HitLanded { crit, victim, .. } => {
                        if crit {
                            reactions.push(Reaction::Crit);
                        }
                        if let Some((count, seq)) = self.count_cast_target(fight, owner_id, victim)
                        {
                            reactions.push(Reaction::CastTargets(count));
                            cast_mark = Some((victim, seq));
                        }
                    }
                    CombatFact::Kill { .. } => reactions.push(Reaction::Kill),
                    CombatFact::HitTaken { .. } => {
                        reactions.push(Reaction::HitTaken);
                        reactions.push(Reaction::HpDropped);
                    }
                    CombatFact::Dodged => reactions.push(Reaction::Dodge),
                    // The cast conditions are decided before the cast resolves
                    // (`apply_law_pre_cast`), not from this hook.
                    CombatFact::Cast { .. } => {}
                }
            }
            if !reactions.is_empty() || cast_mark.is_some() {
                out.push((owner_id, reactions, cast_mark));
            }
        }
        out
    }

    /// How many DISTINCT targets the caster's current cast has damaged once
    /// this victim is counted, plus the cast's sequence number. `None` when the
    /// hit does not belong to a cast being counted.
    ///
    /// Only the cast's own tick counts. Direct AoE (`cone_strike`, Holy Nova,
    /// War Cry) resolves inside `handle_cast_ability`, so the count is exact
    /// for it; a projectile-delivered AoE lands on a later tick and is not
    /// counted, which errs towards not firing rather than towards firing on the
    /// wrong cast.
    fn count_cast_target(
        &self,
        fight: &essences::fighting::ActiveFight,
        caster_id: EntityId,
        victim_id: EntityId,
    ) -> Option<(i64, i64)> {
        let caster = fight.entities.iter().find(|e| e.id == caster_id)?;
        let seq = attr(&caster.attributes, CAST_SEQ);
        if seq == 0 || attr(&caster.attributes, CAST_TICK) != self.fight_clock.now() as i64 {
            return None;
        }
        if attr(&caster.attributes, &target_key(victim_id)) == seq {
            return None;
        }
        let already = caster
            .attributes
            .0
            .iter()
            .filter(|(key, value)| key.starts_with(TARGET_PREFIX) && **value == seq)
            .count() as i64;
        Some((already + 1, seq))
    }

    /// Evaluates one combatant's active laws against the reactions the event
    /// produced and runs whatever fires.
    fn run_reactions(
        &mut self,
        state: &mut OverlordState,
        owner_id: EntityId,
        reactions: &[Reaction],
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let mut events = Vec::new();
        let game_config = self.game_config.get();

        let Some(fight) = state.active_fight.as_ref() else {
            return events;
        };
        let Some(owner) = fight.entities.iter().find(|e| e.id == owner_id) else {
            return events;
        };
        if owner.law_cores.laws.is_empty() {
            return events;
        }
        let ctx = self.law_ctx(&game_config, &fight.entities, owner);
        let mods = self.law_column_mods(state, owner_id);
        let mut laws = Self::live_laws(&game_config, owner, &mods);
        self.apply_wild_reading(state, owner, &mut laws);
        let hidden_laws = self.hidden_laws(&game_config, owner, &mods);
        let attributes = owner.attributes.clone();
        let charges = owner.law_bridges.clone();
        let hp_permyriad = if owner.max_hp == 0 {
            10_000
        } else {
            (owner.hp as i128 * 10_000 / owner.max_hp as i128) as i64
        };
        let watermark = attr(&attributes, HP_WATERMARK);

        let outcome = Outcome {
            reactions,
            hp_permyriad,
            watermark,
        };
        let mut evaluation = evaluate_reactions(laws, &attributes, &outcome);
        let hidden_evaluation = evaluate_reactions(hidden_laws, &attributes, &outcome);
        evaluation.counters.extend(hidden_evaluation.counters);

        self.write_counters(state, owner_id, &evaluation.counters);
        if reactions.contains(&Reaction::HpDropped) {
            self.lower_hp_watermark(state, owner_id, hp_permyriad);
        }
        let fired = self.claim_phase_latches(state, owner_id, evaluation.fired);
        let woken = self.claim_hidden_wakes(state, owner_id, hidden_evaluation.fired, &mods);

        // `PET-10 Dream Reader`: the next SUITABLE Core event — one whose own
        // condition the chosen hidden law is watching for — wakes it once.
        let dream = self.claim_dream_reader(state, owner_id, &outcome, &attributes);

        let fired = self.claim_first_article(state, owner_id, fired, &mods);
        events.extend(self.fire_all(state, owner_id, fired, &ctx, &mods, &charges));
        events.extend(self.fire_all(state, owner_id, woken, &ctx, &mods, &charges));
        events.extend(self.fire_all(state, owner_id, dream, &ctx, &mods, &charges));
        events
    }

    /// The chosen hidden Law, if `PET-10 Dream Reader` is armed AND this event
    /// satisfies that law's own condition.
    ///
    /// Marked `hidden`, which is what makes "no Resonance is created" structural:
    /// [`Self::fire_all`] banks Resonance for non-hidden fires only. It also
    /// fills no bridge and feeds no gauge, exactly like every other hidden run —
    /// so the facet MODIFIES the hidden-law flow that already exists rather than
    /// inventing a payout of its own.
    fn claim_dream_reader(
        &self,
        state: &mut OverlordState,
        owner_id: EntityId,
        outcome: &Outcome<'_>,
        attributes: &EntityAttributes,
    ) -> Vec<LiveLaw> {
        let Some(owner) = state
            .active_fight
            .as_ref()
            .and_then(|fight| fight.entities.iter().find(|e| e.id == owner_id))
        else {
            return Vec::new();
        };
        let Some(share) = pet_mech::armed(
            owner,
            pet_mech::DREAM_READER,
            pet_mech::DREAM_READER_CHARGES,
        ) else {
            return Vec::new();
        };
        let Some(chosen) = self.pet_facet_law(
            state,
            owner_id,
            essences::pet_facets::PetFacetLawRole::DreamReader,
        ) else {
            return Vec::new();
        };
        let Some(candidate) = self.hidden_partner(state, owner_id, chosen, share as f64 / 10_000.0)
        else {
            return Vec::new();
        };
        // "Suitable" is the woken law's OWN condition being met by this event —
        // the charge is not spent on an event the law would have ignored.
        let evaluation = evaluate_reactions(vec![candidate], attributes, outcome);
        if evaluation.fired.is_empty() {
            return Vec::new();
        }
        if let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        {
            pet_mech::spend_charge(
                owner,
                pet_mech::DREAM_READER,
                pet_mech::DREAM_READER_CHARGES,
            );
        }
        evaluation.fired
    }

    /// One completed flip, in the order plan §3 prescribes:
    ///
    /// 1. the charge is delivered to the receiving law and starts amplifying it;
    /// 2. the charge is zeroed;
    /// 3. the "phase started" laws (`RL-12`, `FL-11`) fire — already amplified.
    ///
    /// Entity-local: any combatant that flips gets its own laws re-folded, so a
    /// PvP opponent's inactive half stops contributing on their flip exactly as
    /// the hero's does.
    pub fn apply_flip_to_laws(
        &mut self,
        state: &mut OverlordState,
        entity_id: EntityId,
        from_side: WorldSide,
        to_side: WorldSide,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let mut events = Vec::new();
        let game_config = self.game_config.get();

        // Steps 1 and 2, plus the phase-local bookkeeping reset. Deliberately
        // NOT gated on the entity having bridges: a slotted law with no bridge
        // still has to stop contributing the moment its side goes down, which
        // is the common case before a player owns two levelled cores.
        {
            let Some(entity) = state
                .active_fight
                .as_mut()
                .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == entity_id))
            else {
                return events;
            };
            let previous = entity.law_bridges.clone();
            entity.law_bridges.deliver();
            entity
                .attributes
                .0
                .retain(|key, _| !key.starts_with(ONCE_PREFIX) && !key.starts_with(COUNTER_PREFIX));
            crate::entities::refresh_law_attributes(
                entity,
                from_side,
                to_side,
                &previous,
                &game_config,
            );
        }

        // Step 3.
        let Some(fight) = state.active_fight.as_ref() else {
            return events;
        };
        let Some(owner) = fight.entities.iter().find(|e| e.id == entity_id) else {
            return events;
        };
        if owner.law_cores.laws.is_empty() {
            return events;
        }
        let ctx = self.law_ctx(&game_config, &fight.entities, owner);
        let mods = self.law_column_mods(state, entity_id);
        let charges = owner.law_bridges.clone();
        let mut opening: Vec<LiveLaw> = Self::live_laws(&game_config, owner, &mods)
            .into_iter()
            .filter(|law| law.template.condition == LawCondition::PhaseStarted)
            .collect();
        self.apply_wild_reading(state, owner, &mut opening);
        let fired = self.claim_phase_latches(state, entity_id, opening);
        let fired = self.claim_first_article(state, entity_id, fired, &mods);

        events.extend(self.fire_all(state, entity_id, fired, &ctx, &mods, &charges));
        events
    }

    /// Keeps the laws that may fire now, latching every `once_per_phase` one it
    /// keeps. The latch is cleared by the flip, so "once per phase" means once
    /// per phase and not once per fight.
    fn claim_phase_latches(
        &self,
        state: &mut OverlordState,
        owner_id: EntityId,
        candidates: Vec<LiveLaw>,
    ) -> Vec<LiveLaw> {
        if candidates.is_empty() {
            return candidates;
        }
        let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        else {
            return Vec::new();
        };
        candidates
            .into_iter()
            .filter(|law| {
                if !law.template.once_per_phase {
                    return true;
                }
                let key = once_key(&law.tag);
                if attr(&owner.attributes, &key) != 0 {
                    return false;
                }
                owner.attributes.set(&key, 1);
                true
            })
            .collect()
    }

    /// Drops the law's Resonance into its bridge.
    ///
    /// Never touched by bridge amplification — that is the half of acceptance #8
    /// which stops a law from feeding its own amplifier. It IS touched by the
    /// artifact's right column, which is a different multiplier from a different
    /// source: `VL-01` and `VL-03` buy Resonance with Effect, `VL-02` sells it,
    /// and `BL-05` pays both directions of one bridge.
    ///
    /// The product is banked in hundredths, so a `+25%` on a Resonance of 2
    /// really is 2.5 and not a rounding decision (post-merge plan §8).
    fn bank_resonance(
        &self,
        state: &mut OverlordState,
        owner_id: EntityId,
        law: &LiveLaw,
        mods: &artifact_mech::LawColumnMods,
    ) {
        // Read before the fight is borrowed mutably: the selection lives in
        // durable character state, the charge on the entity.
        let lead_reading = self.pet_facet_law(
            state,
            owner_id,
            essences::pet_facets::PetFacetLawRole::LeadReading,
        );
        let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        else {
            return;
        };
        let multiplier = mods.resonance_multiplier(law.id(), &owner.law_bridges);
        // `PET-06 Lead Reading` MODIFIES this banking rather than opening a
        // second one — a Pet Facet may never CREATE Resonance. It pays only the
        // chosen law's own bridge, because that is the bridge this call feeds.
        let pet_bonus = if lead_reading == Some(law.id()) {
            let bonus = pet_mech::attr(owner, pet_mech::LEAD_READING_BONUS);
            if bonus != 0 && pet_mech::attr(owner, pet_mech::LEAD_READING_CHARGES) > 0 {
                pet_mech::spend_charge(
                    owner,
                    pet_mech::LEAD_READING_BONUS,
                    pet_mech::LEAD_READING_CHARGES,
                );
                1.0 + bonus as f64 / 10_000.0
            } else {
                1.0
            }
        } else {
            1.0
        };
        let amount = (law.template.resonance as f64
            * essences::cores::CHARGE_SCALE as f64
            * multiplier
            * pet_bonus)
            .round() as i64;
        owner.law_bridges.add_resonance(law.id(), amount);
    }

    /// `PET-06 Wild Reading`: while its window is open, the chosen ACTIVE law's
    /// Effect is stronger.
    ///
    /// Applied to `amplification`, which is the effect multiplier only —
    /// [`Self::bank_resonance`] reads the template's own Resonance and the
    /// artifact mods, never this, so "its Resonance is NOT boosted" holds
    /// structurally rather than by a rule at the banking site.
    ///
    /// Hidden runs are skipped: the facet names an *active* Law.
    fn apply_wild_reading(&self, state: &OverlordState, owner: &Entity, laws: &mut [LiveLaw]) {
        let bonus = pet_mech::attr(owner, pet_mech::WILD_READING_BONUS);
        let until = pet_mech::attr(owner, pet_mech::WILD_READING_UNTIL);
        if bonus == 0 || until == 0 || self.fight_clock.now() as i64 >= until {
            return;
        }
        let Some(chosen) = self.pet_facet_law(
            state,
            owner.id,
            essences::pet_facets::PetFacetLawRole::WildReading,
        ) else {
            return;
        };
        let multiplier = 1.0 + bonus as f64 / 10_000.0;
        for law in laws.iter_mut() {
            if !law.hidden && law.id() == chosen {
                law.amplification *= multiplier;
            }
        }
    }

    fn write_counters(
        &self,
        state: &mut OverlordState,
        owner_id: EntityId,
        counters: &[(String, i64)],
    ) {
        if counters.is_empty() {
            return;
        }
        let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        else {
            return;
        };
        for (key, value) in counters {
            owner.attributes.set(key, *value);
        }
    }

    fn lower_hp_watermark(&self, state: &mut OverlordState, owner_id: EntityId, permyriad: i64) {
        let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        else {
            return;
        };
        let watermark = attr(&owner.attributes, HP_WATERMARK);
        if watermark == 0 || permyriad < watermark {
            // Floored at 1 so a dead combatant's watermark stays a written
            // value: `EntityAttributes::set` erases a zero.
            owner.attributes.set(HP_WATERMARK, permyriad.max(1));
        }
    }

    /// Opens a new target-counting window for an original Skill and records the
    /// cast for the distinct-skill window. Forgetting the previous cast's
    /// victims keeps the `law.tgt.*` keys bounded by one cast's target count.
    fn open_cast_window(
        &self,
        state: &mut OverlordState,
        caster_id: EntityId,
        ability_id: AbilityId,
        now: u64,
    ) {
        let Some(caster) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == caster_id))
        else {
            return;
        };
        caster
            .attributes
            .set(&skill_seen_key(ability_id), now as i64);
        let seq = attr(&caster.attributes, CAST_SEQ) + 1;
        caster
            .attributes
            .0
            .retain(|key, _| !key.starts_with(TARGET_PREFIX));
        caster.attributes.set(CAST_SEQ, seq);
        caster.attributes.set(CAST_TICK, now as i64);
    }

    fn mark_cast_target(
        &self,
        state: &mut OverlordState,
        caster_id: EntityId,
        victim_id: EntityId,
        seq: i64,
    ) {
        if let Some(caster) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == caster_id))
        {
            caster.attributes.set(&target_key(victim_id), seq);
        }
    }

    /// Spends an armed derived-damage state (splash or echo) and returns the
    /// `Proc` damage it produces.
    fn spend_arm_as_damage(
        &self,
        state: &mut OverlordState,
        caster_id: EntityId,
        key: &str,
        ctx: &LawCtx,
        shape: SplashShape,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let armed = {
            let Some(owner) = state
                .active_fight
                .as_mut()
                .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == caster_id))
            else {
                return Vec::new();
            };
            let armed = attr(&owner.attributes, key);
            if armed > 0 {
                owner.attributes.set(key, 0);
            }
            armed
        };
        if armed <= 0 {
            return Vec::new();
        }
        let damage = derived_damage(ctx.attack, armed);
        if damage == 0 {
            return Vec::new();
        }
        match shape {
            SplashShape::EveryOtherEnemy(primary) => ctx
                .enemies
                .iter()
                .filter(|id| **id != primary)
                .map(|id| armed_bonus_damage(caster_id, *id, damage))
                .collect(),
            SplashShape::SingleTarget(target) => {
                vec![armed_bonus_damage(caster_id, target, damage)]
            }
        }
    }

    /// Runs ONE law effect. Everything that lands as a combat outcome is
    /// emitted `Proc`, so it can never satisfy a condition; everything that is
    /// bookkeeping (`EntityIncrAttribute`, `EntityAddAbilityCooldown`) carries
    /// no provenance and is not condition surface either way.
    fn run_law_effect(
        &mut self,
        state: &mut OverlordState,
        owner_id: EntityId,
        law: &LiveLaw,
        ctx: &LawCtx,
    ) -> Vec<EventPluginized<OverlordEvent, OverlordState>> {
        let mut events = Vec::new();
        let value = law.effect_value();
        let duration = law.duration_ticks();
        let fraction = value as f64 / 10_000.0;

        match law.template.effect {
            // Armed on the entity rather than emitted: the strike that armed it
            // is about to compute its damage from this very snapshot.
            LawEffect::ThisAttackDamageBonus => self.arm(state, owner_id, ARM_THIS, value),
            LawEffect::NextAttackDamageBonus => self.arm(state, owner_id, ARM_BASIC, value),
            LawEffect::NextSkillPayloadBonus => self.arm(state, owner_id, ARM_SKILL, value),
            LawEffect::NextAttackSplash => self.arm(state, owner_id, ARM_SPLASH, value),
            LawEffect::NextSkillEcho => self.arm(state, owner_id, ARM_ECHO, value),
            LawEffect::HealPercentMaxHp => {
                let heal = (ctx.max_hp as f64 * fraction).round() as u64;
                if heal > 0 {
                    events.push(EventPluginized::now(OverlordEvent::Heal {
                        by_entity_id: Some(owner_id),
                        entity_id: owner_id,
                        heal,
                        origin: CombatEventOrigin::Proc,
                        source: CombatSource::LawProc {
                            law_template_id: law.template.id,
                        },
                    }));
                }
            }
            LawEffect::AoeDerivedDamage => {
                let damage = derived_damage(ctx.attack, value);
                if damage > 0 {
                    events.extend(
                        ctx.enemies
                            .iter()
                            .map(|id| proc_damage(owner_id, *id, damage, law.template.id)),
                    );
                }
            }
            LawEffect::ReduceLongestCooldown => {
                if let Some((ability_id, _)) = ctx
                    .skill_cooldowns
                    .iter()
                    .max_by_key(|(_, deadline)| deadline.saturating_sub(ctx.now))
                {
                    events.push(cooldown_delta(owner_id, *ability_id, -value));
                }
            }
            LawEffect::ReduceAllCooldowns => {
                events.extend(
                    ctx.skill_cooldowns
                        .iter()
                        .map(|(ability_id, _)| cooldown_delta(owner_id, *ability_id, -value)),
                );
            }
            LawEffect::ReadyShortestCooldown => {
                if let Some((ability_id, deadline)) = ctx
                    .skill_cooldowns
                    .iter()
                    .min_by_key(|(_, deadline)| deadline.saturating_sub(ctx.now))
                {
                    // `adjust_ability_cooldown` clamps at the current tick, so
                    // handing it the whole remaining wait is exactly "ready
                    // now" and can never rewind past it.
                    let remaining = deadline.saturating_sub(ctx.now) as i64;
                    events.push(cooldown_delta(owner_id, *ability_id, -remaining.max(1)));
                }
            }
            // BAL-029 `Open with Magic`: a scalable cut instead of a full
            // ready. The same clamp caps it at ready.
            LawEffect::ReduceShortestCooldown => {
                if let Some((ability_id, _)) = ctx
                    .skill_cooldowns
                    .iter()
                    .min_by_key(|(_, deadline)| deadline.saturating_sub(ctx.now))
                {
                    events.push(cooldown_delta(owner_id, *ability_id, -value));
                }
            }
            LawEffect::DamageBuff => {
                self.apply_timed_attribute(&mut events, owner_id, "attack.mod", value, duration);
            }
            LawEffect::DamageReduction => {
                self.apply_timed_attribute(
                    &mut events,
                    owner_id,
                    "received_damage.mod",
                    -value,
                    duration,
                );
            }
            LawEffect::AttackSpeedBuff => {
                let delta = (ctx.speed as f64 * fraction).round() as i64;
                self.apply_timed_attribute(&mut events, owner_id, "speed", delta, duration);
            }
        }
        events
    }

    fn arm(&self, state: &mut OverlordState, owner_id: EntityId, key: &str, value: i64) {
        if value == 0 {
            return;
        }
        if let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        {
            owner.attributes.add(key, value);
        }
    }

    /// BAL-029 `Three Spell Rule`: forgets every recorded Skill sighting, so a
    /// proc fully consumes the combo window.
    fn clear_skill_seen_marks(&self, state: &mut OverlordState, owner_id: EntityId) {
        if let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
        {
            owner
                .attributes
                .0
                .retain(|key, _| !key.starts_with(SKILL_SEEN_PREFIX));
        }
    }

    /// Drops whatever is sitting in a single-cast arm, so nothing survives the
    /// cast it was armed for.
    fn clear_arm(&self, state: &mut OverlordState, owner_id: EntityId, key: &str) {
        if let Some(owner) = state
            .active_fight
            .as_mut()
            .and_then(|fight| fight.entities.iter_mut().find(|e| e.id == owner_id))
            && attr(&owner.attributes, key) != 0
        {
            owner.attributes.set(key, 0);
        }
    }
}

/// Everything the pre-cast conditions read about the cast about to resolve.
struct PreCast {
    is_basic: bool,
    ability_tags: Vec<AbilityTag>,
    distinct_skills: i64,
    /// Mana this cast paid at the gate, x100 fixed point — `None` for a cast
    /// that never went through the pool
    /// ([`crate::logic::combat_facts::paid_mana_x100`]).
    paid_mana_x100: Option<i64>,
}

/// Everything the outcome conditions read about the event that just resolved.
struct Outcome<'a> {
    reactions: &'a [Reaction],
    hp_permyriad: i64,
    watermark: i64,
}

/// Which of `laws` the cast satisfies, plus the counter writes the evaluation
/// implies.
///
/// A free function, and called once per SIDE: the active side's laws and — when
/// the artifact wakes them — the hidden side's run the exact same conditions.
/// Sharing the body is what makes "a hidden law checks its OWN Core conditions"
/// (design §3.1) true rather than a second, drifting copy of the ladder.
fn evaluate_pre_cast(
    laws: Vec<LiveLaw>,
    attributes: &EntityAttributes,
    cast: &PreCast,
) -> Evaluation {
    let mut evaluation = Evaluation {
        fired: Vec::new(),
        counters: Vec::new(),
    };
    for law in laws {
        let met = match law.template.condition {
            LawCondition::NthBasicAttack if cast.is_basic => {
                let count = attr(attributes, &counter_key(&law.tag)) + 1;
                let period = law.template.condition_value.max(1);
                let met = count >= period;
                evaluation
                    .counters
                    .push((counter_key(&law.tag), if met { 0 } else { count }));
                met
            }
            LawCondition::OriginalSkillCast => !cast.is_basic,
            LawCondition::SkillWithTag => {
                !cast.is_basic
                    && law
                        .template
                        .condition_tag
                        .is_some_and(|tag| cast.ability_tags.contains(&tag))
            }
            LawCondition::DistinctSkillsWithin => {
                !cast.is_basic && cast.distinct_skills >= law.template.condition_value.max(1)
            }
            // Priced off what the mana gate actually charged this cast
            // (`PreCast::paid_mana_x100`), so a stone discount or `Budget Plan`
            // changes the verdict exactly as it changed the bill. A cast that
            // never paid (no pool, a pet ult) satisfies neither bound.
            LawCondition::SkillManaAtMost => {
                !cast.is_basic
                    && cast.paid_mana_x100.is_some_and(|paid| {
                        paid <= law.template.condition_value.saturating_mul(100)
                    })
            }
            LawCondition::SkillManaAtLeast => {
                !cast.is_basic
                    && cast.paid_mana_x100.is_some_and(|paid| {
                        paid >= law.template.condition_value.saturating_mul(100)
                    })
            }
            _ => false,
        };
        if met {
            evaluation.fired.push(law);
        }
    }
    evaluation
}

/// Which of `laws` the outcome satisfies. Same contract as
/// [`evaluate_pre_cast`], for the conditions decided after the fact.
fn evaluate_reactions(
    laws: Vec<LiveLaw>,
    attributes: &EntityAttributes,
    outcome: &Outcome<'_>,
) -> Evaluation {
    let mut evaluation = Evaluation {
        fired: Vec::new(),
        counters: Vec::new(),
    };
    for law in laws {
        let met = match law.template.condition {
            LawCondition::CriticalHit => outcome.reactions.contains(&Reaction::Crit),
            LawCondition::Dodge => outcome.reactions.contains(&Reaction::Dodge),
            LawCondition::KilledEnemy => outcome.reactions.contains(&Reaction::Kill),
            LawCondition::NthHitTaken if outcome.reactions.contains(&Reaction::HitTaken) => {
                let count = attr(attributes, &counter_key(&law.tag)) + 1;
                let met = count >= law.template.condition_value.max(1);
                evaluation
                    .counters
                    .push((counter_key(&law.tag), if met { 0 } else { count }));
                met
            }
            LawCondition::HpFellBelow => {
                let threshold = law.template.condition_value;
                outcome.reactions.contains(&Reaction::HpDropped)
                    && outcome.hp_permyriad < threshold
                    && (outcome.watermark == 0 || outcome.watermark >= threshold)
            }
            LawCondition::SkillMinTargets => outcome.reactions.iter().any(|reaction| {
                matches!(reaction, Reaction::CastTargets(count)
                    if *count >= law.template.condition_value.max(1))
            }),
            _ => false,
        };
        if met {
            evaluation.fired.push(law);
        }
    }
    evaluation
}

/// Which enemies an armed derived-damage state hits when it is spent.
enum SplashShape {
    /// Every living enemy except the one the real attack already struck.
    EveryOtherEnemy(EntityId),
    /// The skill's own target.
    SingleTarget(EntityId),
}

/// Same scaling as one real swing of `power = fraction`, so a 150% law effect
/// is worth 1.5 attacks and not a second damage currency.
fn derived_damage(attack: f64, permyriad: i64) -> u64 {
    let fraction = permyriad as f64 / 10_000.0;
    (attack * fraction * balance::DMG_K).floor().max(0.0) as u64
}

/// A bonus armed by a law and spent by a later hit. The arming law is not
/// recorded on the entity — see [`CombatSource::ArmedBonus`].
fn armed_bonus_damage(
    by: EntityId,
    to: EntityId,
    damage: u64,
) -> EventPluginized<OverlordEvent, OverlordState> {
    EventPluginized::now(OverlordEvent::Damage {
        by_entity_id: Some(by),
        entity_id: to,
        damage,
        damage_data: Default::default(),
        origin: CombatEventOrigin::Proc,
        source: CombatSource::ArmedBonus,
    })
}

fn proc_damage(
    by: EntityId,
    to: EntityId,
    damage: u64,
    law_template_id: LawTemplateId,
) -> EventPluginized<OverlordEvent, OverlordState> {
    EventPluginized::now(OverlordEvent::Damage {
        by_entity_id: Some(by),
        entity_id: to,
        damage,
        damage_data: Default::default(),
        origin: CombatEventOrigin::Proc,
        source: CombatSource::LawProc { law_template_id },
    })
}

fn cooldown_delta(
    entity_id: EntityId,
    ability_id: AbilityId,
    delta_ticks: i64,
) -> EventPluginized<OverlordEvent, OverlordState> {
    EventPluginized::now(OverlordEvent::EntityAddAbilityCooldown {
        entity_id,
        ability_id,
        delta_ticks,
    })
}

/// How many DIFFERENT original Skills, including the one being cast, resolved
/// inside the last `window` ticks.
fn count_distinct_skills(
    attributes: &EntityAttributes,
    now: u64,
    window: u64,
    ability_id: AbilityId,
) -> i64 {
    let floor = now.saturating_sub(window) as i64;
    let current = skill_seen_key(ability_id);
    let mut seen: BTreeSet<&str> = BTreeSet::new();
    for (key, value) in attributes.0.iter() {
        if key.starts_with(SKILL_SEEN_PREFIX) && *value >= floor && *key != current {
            seen.insert(key.as_str());
        }
    }
    seen.len() as i64 + 1
}