overlord_event_system/behaviors/combat/

cast_ability.rs

//! Native ports for the `cast_ability` category — ability `script`s (the
//! `CastAbility` event handler, run via `run_event` in
//! `logic::fighting::handle_cast_ability`, returning
//! `Vec<OverlordEvent>`).
//!
//! These are the combat effect of *casting* an ability: most call
//! `ctx.on_cast(CasterEntity)` then either launch a projectile
//! (`Result.push(OverlordEventStartCastProjectile(...))`) or apply combat
//! primitives (`ctx.attack`, `ctx.spell_heal`, `ctx.apply_entity_effect`).
//!
//! ## RNG
//! Ability `script`s consume the authoritative `Random` (via `on_cast`'s
//! `bravery` throw, `attack`'s evasion/counterattack/deceit/crit/block throws,
//! and `stat_throw`).
//!
//! ## Effect callbacks
//! `on_cast` / `apply_entity_effect` dispatch the applied effect's `on_apply`
//! reaction. For the shipped effects those reactions push `add_entity_stat_mod`
//! (`empower`/`weakness`/`protection`/`vulnerability`) events; the native path
//! must replicate them, so we pass [`OverlordEffectCb`] rather than
//! `NoopEffectCb`.
//!
//! ## Scope (per the `handle_cast_ability` `run_event` call site)
//! `CasterEntity`, `TargetEntity`, `Fight`, `Random`, `AbilityLevel`,
//! `AbilitySlotLevel`, `CurrentTick`, `FightDurationTicks`, and the event.

use configs::game_config::GameConfig;
use essences::combat_origin::CombatEventOrigin;
use essences::entity::Entity;
use essences::fight_breakdown::CombatSource;
use essences::fighting::ActiveFight;
use event_system::script::random::GameRng;
use uuid::Uuid;

use crate::behaviors::{BehaviorKind, BehaviorMeta, BehaviorRegistry};
use crate::event::OverlordEvent;
use crate::game_config_helpers::GameConfigLookup;
use crate::mechanics::content::ability_info;
use crate::mechanics::content_lookups::ContentLookups;
use crate::mechanics::effect_cb::OverlordEffectCb;
use crate::mechanics::fight::{
    self, AttackParams, NativeSink, SpellHealParams, on_cast, spell_heal, stat_throw,
};
use crate::mechanics::support_shapes::{SupportAttackCtx, attack_with_supports};
use essences::ability_stones::AbilityStoneMods;

/// ability `script` scope the shipped scripts read.
pub struct CastAbilityCtx<'a> {
    /// `CasterEntity` const.
    pub caster_entity: &'a Entity,
    /// `TargetEntity` const.
    pub target_entity: &'a Entity,
    /// `Fight` const (used by the cone/AoE ability for `Fight.entities`).
    pub fight: &'a ActiveFight,
    /// RNG snapshot (clone at the same state) so combat primitives draw
    pub rng: &'a GameRng,
    /// `AbilityLevel` const (passed to `get_ability_info` and projectile launches).
    pub ability_level: i64,
    /// The ability actually being cast. Ports that hardcode a donor ability id
    /// (pet-ult clones) still read their own numbers; this is what the socketed
    /// support stones are keyed by.
    pub ability_id: uuid::Uuid,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
    /// Ability stones active on the caster, already resolved against the
    /// current world side and the caster's mana. Identity for every combatant
    /// without socketed stones.
    pub stones: crate::mechanics::ability_stones::AbilityStoneResolver<'a>,
    /// Breakdown attribution of everything this cast produces: `Ability` for an
    /// ordinary cast, `PetUlt` when the charge-driven pet ult is what fired it.
    /// Set by the dispatcher, which is the only place that knows the difference.
    pub source: CombatSource,
}

/// Signature of a `cast_ability` native fn.
pub type CastAbilityFn = fn(&CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>>;

/// Run `ctx.on_cast(CasterEntity)` into a sink — the `on_cast` hook (bravery
/// throw → maybe apply protection/empower, dispatching the effect `on_apply`).
fn run_on_cast(ctx: &CastAbilityCtx, sink: &mut NativeSink) -> anyhow::Result<()> {
    let mut effects = OverlordEffectCb;
    on_cast(sink, ctx.rng, ctx.lookups, &mut effects, ctx.caster_entity)
        .map_err(|e| anyhow::anyhow!("on_cast: {e}"))
}

/// Run `ctx.attack(caster, target, params)` into a sink through the support
/// seam (crit bonus + Split/Chain/Pierce copies + Leech), returning the floored
/// damage of the PRIMARY hit.
fn run_attack(
    ctx: &CastAbilityCtx,
    sink: &mut NativeSink,
    mods: &AbilityStoneMods,
    target: &Entity,
    params: &AttackParams,
) -> anyhow::Result<Option<i64>> {
    attack_with_supports(
        sink,
        &SupportAttackCtx {
            rng: ctx.rng,
            lookups: ctx.lookups,
            fight: ctx.fight,
            player_id: ctx.fight.player_id,
            caster: ctx.caster_entity,
            mods,
            source: ctx.source,
        },
        target,
        params,
    )
}

/// `OverlordEventStartCastProjectile(caster.id, target.id, uuid(pid), level, delay)`).
fn start_cast_projectile(ctx: &CastAbilityCtx, projectile_id: &str, delay: u64) -> OverlordEvent {
    OverlordEvent::StartCastProjectile {
        by_entity_id: ctx.caster_entity.id,
        to_entity_id: ctx.target_entity.id,
        projectile_id: Uuid::parse_str(projectile_id).expect("valid projectile uuid literal"),
        level: ctx.ability_level,
        delay,
        origin: CombatEventOrigin::Core,
        source: ctx.source,
    }
}

/// `content::get_ability_info(id, AbilityLevel)` — resolves the per-ability info
/// closure for the given ability id at the current level, plus the ability-stone
/// modifiers that apply to it (already folded into the returned info).
fn info(
    ctx: &CastAbilityCtx,
    ability_id: &str,
) -> anyhow::Result<(crate::mechanics::content::AbilityInfo, AbilityStoneMods)> {
    let id = Uuid::parse_str(ability_id).expect("valid ability uuid literal");
    let mut info = ability_info(ctx.config, ctx.lookups, id, ctx.ability_level)?;
    let mods = ctx.stones.mods_for(ctx.config, id, ctx.ability_level);
    info.apply_stone_mods(&mods);
    Ok((info, mods))
}

/// §1 AoE cap: the band-eligible enemies of a forward 3-cell cone (`caster_x <
/// x ≤ caster_x+3`), capped to the first `max_targets` in the deterministic
/// `fight.entities` iteration order (`None` ⇒ unlimited, legacy behaviour). No
/// RNG, no sorting. Shared by `cone_strike` / Rewind / War Cry / Holy Nova so
/// the cap is byte-identical everywhere.
pub fn band_targets<'a>(
    fight: &'a ActiveFight,
    caster: &Entity,
    max_targets: Option<i64>,
) -> Vec<&'a Entity> {
    let caster_x = caster.coordinates.x;
    let mut out: Vec<&Entity> = Vec::new();
    for target in fight.entities.iter().filter(|e| e.team != caster.team) {
        let tx = target.coordinates.x;
        if tx > caster_x && tx <= caster_x + 3 {
            if max_targets.is_some_and(|cap| out.len() as i64 >= cap) {
                break;
            }
            out.push(target);
        }
    }
    out
}

// ---------------------------------------------------------------------------
// Shared parametrized bodies
// ---------------------------------------------------------------------------

/// `on_cast` + push a single `StartCastProjectile(projectile_id, delay=0)`.
/// Covers every "on_cast then launch one projectile" ability.
fn on_cast_then_projectile(
    ctx: &CastAbilityCtx,
    projectile_id: &str,
) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    sink.events
        .push(start_cast_projectile(ctx, projectile_id, 0));
    Ok(sink.events)
}

/// Bare `Result.push(StartCastProjectile(projectile_id, delay=0))` — no
/// `fight_context`, no `on_cast` (the four scripts that are a single push line).
fn bare_projectile(
    ctx: &CastAbilityCtx,
    projectile_id: &str,
) -> anyhow::Result<Vec<OverlordEvent>> {
    Ok(vec![start_cast_projectile(ctx, projectile_id, 0)])
}

/// `on_cast` + `attack(caster, target, #{ power: ability_info.damage })`.
fn on_cast_then_attack(
    ctx: &CastAbilityCtx,
    ability_id: &str,
) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, ability_id)?;
    let params = AttackParams {
        power: ability_info.damage,
        ..Default::default()
    };
    run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    Ok(sink.events)
}

// ---------------------------------------------------------------------------
// Distinct ability ports
// ---------------------------------------------------------------------------

/// `0194d64e-...` — on_cast + attack { power }.
pub fn melee_strike(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_attack(ctx, "0194d64e-20f2-75e5-89c8-4cb812672485")
}

/// `019bff40-...` — on_cast + attack { power }.
pub fn sword_slash(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_attack(ctx, "019bff40-af44-75b7-940c-6074097a2925")
}

/// `019cc464-...` — on_cast + attack { power }.
pub fn mob_melee_quick(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_attack(ctx, "019cc464-e752-71c1-a9dd-8fda9f212801")
}

/// `019cc465-14b8-...` — on_cast + attack { power }.
pub fn mob_melee_average(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_attack(ctx, "019cc465-14b8-7dbc-9799-4691b91805d3")
}

/// `019cc465-2f63-...` — on_cast + attack { power }.
pub fn mob_melee_slow(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_attack(ctx, "019cc465-2f63-7b54-8ddc-fcbcb483fe81")
}

/// `01955be6-...` — `ctx.apply_entity_effect(CasterEntity, "test_effect", 3)`.
/// No `on_cast`. `test_effect`'s `on_apply` is `print`-only (no events).
pub fn apply_test_effect(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let mut effects = OverlordEffectCb;
    fight::apply_entity_effect(
        &mut sink,
        ctx.lookups,
        &mut effects,
        ctx.caster_entity,
        "test_effect",
        3.0,
    )
    .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
    Ok(sink.events)
}

/// `019584aa-...` — on_cast + attack { power, crit_chance_bonus * 10000.0 }.
pub fn crit_strike(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019584aa-5bde-7ac2-8850-076dafdc4603")?;
    let params = AttackParams {
        power: ability_info.damage,
        crit_chance_bonus: ability_info.crit_chance_bonus.unwrap_or(0.0) * 10000.0,
        ..Default::default()
    };
    run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    Ok(sink.events)
}

/// `019584f4-...` — cone/AoE: on_cast, roll one shared crit, then attack every
/// enemy in a forward 3-cell x-band with `{ power, is_crit }`.
pub fn cone_strike(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019584f4-2c99-72bf-bcd3-bfc02fb33977")?;
    // `let is_crit = ctx.stat_throw(CasterEntity, "crit_chance");` — one draw.
    let is_crit = stat_throw(ctx.rng, ctx.lookups, ctx.caster_entity, "crit_chance", 0.0);
    // `CasterEntity.get_enemies(Fight.entities)` preserves `Fight.entities` order,
    // capped by §1 `max_targets`.
    for target in band_targets(ctx.fight, ctx.caster_entity, ability_info.max_targets) {
        let params = AttackParams {
            power: ability_info.damage,
            is_crit: Some(is_crit),
            ..Default::default()
        };
        run_attack(ctx, &mut sink, &mods, target, &params)?;
    }
    Ok(sink.events)
}

/// `019589e6-...` — on_cast + launch `ability_info.projectiles` projectiles,
/// each delayed `i * 150`.
pub fn multi_projectile(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    const PROJECTILE_DELAY: i64 = 150;
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, _mods) = info(ctx, "019589e6-f9dd-7b22-8d39-5350e95aaf69")?;
    let projectiles = ability_info.projectiles.unwrap_or(0);
    for i in 0..projectiles {
        let delay = (i * PROJECTILE_DELAY) as u64;
        sink.events.push(start_cast_projectile(
            ctx,
            "0196a6b3-f885-7fdc-af8c-92a1ffb79ceb",
            delay,
        ));
    }
    Ok(sink.events)
}

/// `01958a30-...` — on_cast + attack { power }; if damage dealt (`!= ()`),
/// apply `empower` for `ability_info.effect_duration`.
pub fn strike_then_empower(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "01958a30-8f18-745f-928a-75028cb3ee99")?;
    let params = AttackParams {
        power: ability_info.damage,
        ..Default::default()
    };
    let damage = run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    if damage.is_some() {
        let mut effects = OverlordEffectCb;
        fight::apply_entity_effect(
            &mut sink,
            ctx.lookups,
            &mut effects,
            ctx.caster_entity,
            "empower",
            ability_info.effect_duration.unwrap_or(0.0),
        )
        .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
    }
    Ok(sink.events)
}

/// `01958ef2-...` — on_cast + attack { power }; if damage dealt, apply
/// `vulnerability` on the TARGET for `ability_info.effect_duration`.
pub fn strike_then_vulnerability(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "01958ef2-dff5-76dd-89f1-d9c2707b2ffc")?;
    let params = AttackParams {
        power: ability_info.damage,
        ..Default::default()
    };
    let damage = run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    if damage.is_some() {
        let mut effects = OverlordEffectCb;
        fight::apply_entity_effect(
            &mut sink,
            ctx.lookups,
            &mut effects,
            ctx.target_entity,
            "vulnerability",
            ability_info.effect_duration.unwrap_or(0.0),
        )
        .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
    }
    Ok(sink.events)
}

/// Pet-ult deliveries: same combat math as the instant versions
/// (`crit_strike` / `cone_strike` / `dot_strike`), moved onto a projectile so
/// the pet's cast is readable in combat. The damage resolves in the paired
/// `projectile_pet_*` fn on arrival.
pub fn night_pounce_projectile_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_projectile(ctx, "79f90288-9ff4-46ee-9b11-8a0064913415")
}

pub fn rust_wave_projectile_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_projectile(ctx, "1ce4597d-dd7a-4c5c-834b-134ef532c0c2")
}

pub fn odd_flame_projectile_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_projectile(ctx, "432f231c-75eb-4753-acca-b6356ca8104c")
}

/// `01958efd-...` — on_cast + attack { dot_power: ability_info.damage } (no
/// instant power; pure DoT application).
pub fn dot_strike(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "01958efd-77f9-7dec-8444-c9d759549225")?;
    let params = AttackParams {
        dot_power: ability_info.damage,
        ..Default::default()
    };
    run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    Ok(sink.events)
}

/// `01958ed0-...` — on_cast + `spell_heal(caster, caster, #{ hot_power })`.
pub fn self_hot_heal(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, _mods) = info(ctx, "01958ed0-d45f-7cad-b086-8f11962d3859")?;
    let params = SpellHealParams {
        hot_power: ability_info.hot,
        ..Default::default()
    };
    spell_heal(
        &mut sink,
        ctx.rng,
        ctx.lookups,
        ctx.caster_entity,
        ctx.caster_entity,
        &params,
        ctx.source,
    )
    .map_err(|e| anyhow::anyhow!("spell_heal: {e}"))?;
    Ok(sink.events)
}

// ---------------------------------------------------------------------------
// Class kits — long-cooldown signature casts composed
// from the existing combat vocabulary (attack / spell_heal / effects), one fn
// per ability so each class plays differently. Budgets come from the matching
// `content::ability_info` closures.
// ---------------------------------------------------------------------------

/// Heal `share` of the RECIPIENT's own Max HP (BAL-033).
///
/// Class heals are authored as a share of the pool they are protecting, not as
/// a multiple of the caster's ATK — a Priest healing a tankier ally heals more,
/// and a caster with no gear still heals a meaningful amount. No crit roll:
/// the printed number is the number.
fn heal_max_hp_share(
    sink: &mut NativeSink,
    by_entity_id: Option<essences::entity::EntityId>,
    recipient: &essences::entity::Entity,
    share: f64,
    source: CombatSource,
) -> anyhow::Result<()> {
    if share <= 0.0 || recipient.max_hp == 0 {
        return Ok(());
    }
    fight::heal_entity(
        sink,
        by_entity_id,
        recipient,
        recipient.max_hp as f64 * share,
        source,
    )
    .map_err(|e| anyhow::anyhow!("heal_entity: {e}"))?;
    Ok(())
}

/// The ally with the lowest share of its Max HP, or the caster when nothing
/// else qualifies. Keyed on the SHARE rather than the raw number so a big ally
/// at half health outranks a small one a few points down.
fn lowest_hp_share_ally<'a>(
    fight: &'a essences::fighting::ActiveFight,
    caster: &'a essences::entity::Entity,
) -> &'a essences::entity::Entity {
    fight
        .entities
        .iter()
        .filter(|entity| entity.team == caster.team && entity.hp > 0 && entity.max_hp > 0)
        .min_by(|a, b| {
            let share = |e: &essences::entity::Entity| e.hp as f64 / e.max_hp as f64;
            share(a)
                .partial_cmp(&share(b))
                .unwrap_or(std::cmp::Ordering::Equal)
        })
        .unwrap_or(caster)
}

/// Backstab (Rogue, `019dfc4c`): heavy crit gamble — like `crit_strike` but
/// with the kit's own budget/crit split.
pub fn backstab_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    /// Below this share of HP the target is finishable (BAL-033).
    const EXECUTE_HP_SHARE: f64 = 0.30;
    /// What the strike is multiplied by once the target is that low.
    const EXECUTE_MULT: f64 = 1.70;

    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019dfc4c-75ea-716c-a453-801c968be604")?;

    // The kit's identity is a GUARANTEED crit, not a crit gamble: the rogue
    // knows the hit lands hard, and the build plans around it.
    let target = ctx.target_entity;
    let wounded = target.max_hp > 0 && (target.hp as f64 / target.max_hp as f64) < EXECUTE_HP_SHARE;
    let power = ability_info.damage.map(|damage| {
        if wounded {
            damage * EXECUTE_MULT
        } else {
            damage
        }
    });

    let params = AttackParams {
        power,
        is_crit: Some(true),
        ..Default::default()
    };
    run_attack(ctx, &mut sink, &mods, target, &params)?;
    Ok(sink.events)
}

/// Thousand Cuts (Rogue, `019dfc4f`): a flurry of `projectiles` direct cuts on
/// the target — each rolls its own crit/evasion, so the flurry FEELS like a
/// storm of numbers rather than one hit.
pub fn thousand_cuts_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019dfc4f-5c4f-7829-affa-11b21a735f78")?;
    let cuts = ability_info.projectiles.unwrap_or(1).max(1);
    for i in 0..cuts {
        let params = AttackParams {
            power: ability_info.damage,
            // Only the first cut can trigger the target's counterattack —
            // a 10-hit flurry must not roll ten counter procs.
            no_counterattack: i > 0,
            ..Default::default()
        };
        run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    }
    Ok(sink.events)
}

/// Arcane Blast (Mage, `019dfcfb`): the nuke lands on the target and washes
/// over every OTHER living enemy at a share of it — with no target cap
/// (BAL-034), which is what makes the Mage the wave-clear class rather than a
/// single-target one.
pub fn arcane_blast_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    /// The secondary's share of the primary hit (`200%` against `500%`).
    const SECONDARY_SHARE: f64 = 0.4;

    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019dfcfb-7b13-7cf2-b8e3-ab9546310c2b")?;

    let primary = AttackParams {
        power: ability_info.damage,
        ..Default::default()
    };
    run_attack(ctx, &mut sink, &mods, ctx.target_entity, &primary)?;

    // Every other enemy still standing, in deterministic fight order. `None`
    // as the cap is the whole point: the secondary is uncapped.
    let secondary_power = ability_info.damage.map(|damage| damage * SECONDARY_SHARE);
    for target in band_targets(ctx.fight, ctx.caster_entity, None) {
        if target.id == ctx.target_entity.id {
            continue;
        }
        let params = AttackParams {
            power: secondary_power,
            ..Default::default()
        };
        run_attack(ctx, &mut sink, &mods, target, &params)?;
    }
    Ok(sink.events)
}

/// Rewind (Mage, `019dfcfe`): AoE hit + Weakness (attack down) on every enemy
/// struck — «время тянет волну назад».
/// How much of every OTHER skill's remaining cooldown Rewind erases.
const REWIND_COOLDOWN_CUT_TICKS: i64 = 2_000;

/// Rewind's own template id — it is excluded from its own cooldown cut.
const REWIND_ABILITY_ID: uuid::Uuid = uuid::uuid!("019dfcfe-704c-73cf-b6e8-60f85e86799d");

pub fn rewind_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019dfcfe-704c-73cf-b6e8-60f85e86799d")?;
    let is_crit = stat_throw(ctx.rng, ctx.lookups, ctx.caster_entity, "crit_chance", 0.0);
    let duration = ability_info.effect_duration.unwrap_or(0.0);
    for target in band_targets(ctx.fight, ctx.caster_entity, ability_info.max_targets) {
        let params = AttackParams {
            power: ability_info.damage,
            is_crit: Some(is_crit),
            ..Default::default()
        };
        let dealt = run_attack(ctx, &mut sink, &mods, target, &params)?;
        if dealt.is_some() && duration > 0.0 {
            let mut effects = OverlordEffectCb;
            fight::apply_entity_effect(
                &mut sink,
                ctx.lookups,
                &mut effects,
                target,
                "weakness",
                duration,
            )
            .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
        }
    }

    // BAL-034: the rewind also pulls the caster's OTHER skills forward. Never
    // its own — a self-shortening Rewind would loop on itself, which is why
    // the exclusion is part of the ability rather than a tuning value.
    for ability in &ctx.caster_entity.abilities {
        if ability.ability.template_id == REWIND_ABILITY_ID {
            continue;
        }
        sink.events.push(OverlordEvent::EntityAddAbilityCooldown {
            entity_id: ctx.caster_entity.id,
            ability_id: ability.ability.template_id,
            delta_ticks: -REWIND_COOLDOWN_CUT_TICKS,
        });
    }
    Ok(sink.events)
}

/// Fortify (Warrior, `019dfd00`): Protection on self (received damage halved)
/// plus an instant self-heal from the rest of the budget.
pub fn fortify_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, _mods) = info(ctx, "019dfd00-594e-755f-8132-1c320fb2b5e9")?;
    if let Some(duration) = ability_info.effect_duration.filter(|d| *d > 0.0) {
        let mut effects = OverlordEffectCb;
        fight::apply_entity_effect(
            &mut sink,
            ctx.lookups,
            &mut effects,
            ctx.caster_entity,
            "protection",
            duration,
        )
        .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
    }
    // `hot` carries the Max-HP SHARE for class heals, not an ATK multiplier.
    heal_max_hp_share(
        &mut sink,
        Some(ctx.caster_entity.id),
        ctx.caster_entity,
        ability_info.hot.unwrap_or(0.0),
        ctx.source,
    )?;
    Ok(sink.events)
}

/// War Cry (Warrior, `019dfd01`): AoE shout + `+30%` outgoing damage on self
/// while any enemy was struck.
pub fn war_cry_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019dfd01-073e-7aee-a993-74e20b3c439c")?;
    let is_crit = stat_throw(ctx.rng, ctx.lookups, ctx.caster_entity, "crit_chance", 0.0);
    let mut any_hit = false;
    for target in band_targets(ctx.fight, ctx.caster_entity, ability_info.max_targets) {
        let params = AttackParams {
            power: ability_info.damage,
            is_crit: Some(is_crit),
            ..Default::default()
        };
        any_hit |= run_attack(ctx, &mut sink, &mods, target, &params)?.is_some();
    }
    if any_hit && let Some(duration) = ability_info.effect_duration.filter(|d| *d > 0.0) {
        let mut effects = OverlordEffectCb;
        fight::apply_entity_effect(
            &mut sink,
            ctx.lookups,
            &mut effects,
            ctx.caster_entity,
            "war_fury",
            duration,
        )
        .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
    }
    Ok(sink.events)
}

/// Battle Heal (Priest, `019dfd02-0c6a`): the WHOLE TEAM is healed and
/// empowered (BAL-033). In solo that is the Priest alone, so the ability never
/// reads as weaker than it did — it just stops being self-only the moment
/// there is somebody to heal.
pub fn battle_heal_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, _mods) = info(ctx, "019dfd02-0c6a-7f4d-bb45-4ec2a5fc231a")?;

    let allies: Vec<_> = ctx
        .fight
        .entities
        .iter()
        .filter(|entity| entity.team == ctx.caster_entity.team && entity.hp > 0)
        .cloned()
        .collect();

    for ally in &allies {
        // Each recipient's heal is a share of ITS OWN Max HP (BAL-033).
        heal_max_hp_share(
            &mut sink,
            Some(ctx.caster_entity.id),
            ally,
            ability_info.hot.unwrap_or(0.0),
            ctx.source,
        )?;

        // The buff half of the ability: `+15% ATK` and `+15% Armor`.
        // Re-casting refreshes it rather than stacking a second copy — one
        // source, one window.
        if let Some(duration) = ability_info.effect_duration.filter(|d| *d > 0.0) {
            let mut effects = OverlordEffectCb;
            fight::apply_entity_effect(
                &mut sink,
                ctx.lookups,
                &mut effects,
                ally,
                "battle_blessing",
                duration,
            )
            .map_err(|e| anyhow::anyhow!("apply_entity_effect: {e}"))?;
        }
    }
    Ok(sink.events)
}

/// Holy Nova (Priest, `019dfd02-add4`): AoE smite plus exactly ONE heal for a
/// share of the recipient's Max HP — the ally with the lowest HP share, which
/// in solo is the caster.
pub fn holy_nova_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    run_on_cast(ctx, &mut sink)?;
    let (ability_info, mods) = info(ctx, "019dfd02-add4-7373-912c-8483150fd341")?;
    let is_crit = stat_throw(ctx.rng, ctx.lookups, ctx.caster_entity, "crit_chance", 0.0);
    for target in band_targets(ctx.fight, ctx.caster_entity, ability_info.max_targets) {
        let params = AttackParams {
            power: ability_info.damage,
            is_crit: Some(is_crit),
            ..Default::default()
        };
        run_attack(ctx, &mut sink, &mods, target, &params)?;
    }
    // BAL-033: exactly ONE heal event, on the ally with the lowest HP share —
    // in solo that resolves to the caster. The amount is a share of THAT
    // entity's Max HP, not of the damage the nova dealt.
    let recipient = lowest_hp_share_ally(ctx.fight, ctx.caster_entity).clone();
    heal_max_hp_share(
        &mut sink,
        Some(ctx.caster_entity.id),
        &recipient,
        ability_info.hot.unwrap_or(0.0),
        ctx.source,
    )?;
    Ok(sink.events)
}

// --- on_cast + single projectile (projectile id 01966cbc, AbilityLevel) ---

/// `01958172-...` — on_cast + launch projectile `01966cbc`.
pub fn fireball_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_projectile(ctx, "01966cbc-879d-7b00-b1de-ad8ed932fb63")
}

/// `019dfc4c-...` / `019dfc4f` / `019dfcfb` / `019dfcfe` / `019dfd00` /
/// `019dfd01` / `019dfd02-0c6a` / `019dfd02-add4` — all identical: on_cast +
/// launch projectile `01966cbc`. (One shared native fn; config points all eight
/// ability `script_native` refs at it.)
pub fn fireball_projectile_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_projectile(ctx, "01966cbc-879d-7b00-b1de-ad8ed932fb63")
}

/// `019589f7-...` — on_cast + launch projectile `0196a6b4` (vampiric strike).
pub fn vampiric_touch_cast(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    on_cast_then_projectile(ctx, "0196a6b4-cb8c-7bcb-a99c-1f0189dd8d5f")
}

// --- bare projectile push (no fight_context, no on_cast) ---

/// `019a0245-ff0c-...` — bare push projectile `019a0244-4675`.
pub fn bare_projectile_mushroom(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    bare_projectile(ctx, "019a0244-4675-7e4b-868a-c9b8ef46a091")
}

/// `019a0246-5aaf-...` — bare push projectile `019a0244-7a0a`.
pub fn bare_projectile_chipmunk(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    bare_projectile(ctx, "019a0244-7a0a-7241-bdae-4541d9f972f6")
}

/// `019a0246-cf87-...` — bare push projectile `019a0244-aad4`.
pub fn bare_projectile_bat(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    bare_projectile(ctx, "019a0244-aad4-7ae3-ae11-25d5facadf17")
}

/// `019c00a4-...` — bare push projectile `019c009c`.
pub fn bare_projectile_shot(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    bare_projectile(ctx, "019c009c-22b2-7fa7-9599-97eb239b13b9")
}

// ---------------------------------------------------------------------------
// Test-config ability ports (tests_game_config.rs fixtures)
// ---------------------------------------------------------------------------

/// Port of the shared test ability `script` (`generate_ability_script`):
/// `Result.push(OverlordEventDamage(TargetEntity.id, unsigned(5), CustomEventData()));`
/// RNG-free; used by the test-config gacha/class abilities.
pub fn damage_target_5(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    Ok(vec![OverlordEvent::Damage {
        by_entity_id: Some(ctx.caster_entity.id),
        entity_id: ctx.target_entity.id,
        damage: 5,
        damage_data: crate::event::CustomEventData::default(),
        origin: CombatEventOrigin::Core,
        source: ctx.source,
    }])
}

/// A real swing for the test config: runs `mechanics::fight::attack` with a
/// fixed `power` and a forced non-crit.
///
/// Every other fixture ability emits a flat `Damage` event and so never touches
/// the damage primitives. That left the whole "armed for the next attack →
/// spent by that attack" half of the laws and stones untested — the arms were
/// only ever observed being *set*. `ThisAttackDamageBonus` shipped broken
/// through exactly that gap.
///
/// The crit roll is forced off and the power is a constant so two runs of the
/// same test differ only by what the test changed.
pub fn test_swing(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let params = AttackParams {
        power: Some(configs::tests_game_config::TEST_SWING_POWER),
        is_crit: Some(false),
        no_counterattack: true,
        ..Default::default()
    };
    let mods = ctx
        .stones
        .mods_for(ctx.config, ctx.ability_id, ctx.ability_level);
    run_attack(ctx, &mut sink, &mods, ctx.target_entity, &params)?;
    Ok(sink.events)
}

/// The AoE counterpart of [`test_swing`]: one cast, one swing per living enemy,
/// all inside the cast's own tick.
///
/// `SkillMinTargets` counts the distinct targets of a single cast on the tick
/// that cast was dispatched, so a multi-target condition is only reachable from
/// a genuinely multi-target ability — hits dispatched on later ticks belong to
/// no cast and are not counted.
pub fn test_swing_aoe(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let params = AttackParams {
        power: Some(configs::tests_game_config::TEST_SWING_POWER),
        is_crit: Some(false),
        no_counterattack: true,
        ..Default::default()
    };
    let targets: Vec<&Entity> = ctx
        .fight
        .entities
        .iter()
        .filter(|entity| entity.team != ctx.caster_entity.team && entity.hp > 0)
        .collect();
    let mods = ctx
        .stones
        .mods_for(ctx.config, ctx.ability_id, ctx.ability_level);
    for target in targets {
        run_attack(ctx, &mut sink, &mods, target, &params)?;
    }
    Ok(sink.events)
}

/// Port of the `50260b1c-...` test ability `script`:
/// RNG-free; used by `test_effects::test_effect_with_interval`.
pub fn apply_bloodleak_effect(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    Ok(vec![
        OverlordEvent::EntityIncrAttribute {
            entity_id: ctx.target_entity.id,
            attribute: "bloodleak".to_string(),
            delta: 10,
        },
        OverlordEvent::EntityApplyEffect {
            entity_id: ctx.target_entity.id,
            effect_id: Uuid::parse_str("ccc47912-61c0-4efa-88f9-7911fa1b074f")?,
            origin: CombatEventOrigin::Core,
        },
    ])
}

/// Test-config only: an AoE strike whose payload, coverage and support stones
/// all come from the CAST ability's own template, so the fixture can exercise
/// the coverage and shape supports end to end without a bespoke
/// `content::ability_info` closure.
pub fn test_band_strike(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    /// Payload for a fixture ability that has no `ability_info` closure.
    const FALLBACK_POWER: f64 = 5.0;
    let mut sink = NativeSink::default();
    let mods = ctx
        .stones
        .mods_for(ctx.config, ctx.ability_id, ctx.ability_level);
    // Same numbers the derived-copy path resolves, so a support's original hit
    // and its copies are directly comparable.
    let mut info = ability_info(ctx.config, ctx.lookups, ctx.ability_id, ctx.ability_level)
        .unwrap_or_else(|_| crate::mechanics::content::AbilityInfo {
            damage: Some(FALLBACK_POWER),
            ..crate::mechanics::content::AbilityInfo::none()
        });

    if info.damage.is_none() {
        info.damage = Some(FALLBACK_POWER);
    }
    info.max_targets = ctx
        .config
        .ability_template(ctx.ability_id)
        .and_then(|template| template.max_targets);
    info.apply_stone_mods(&mods);
    for target in band_targets(ctx.fight, ctx.caster_entity, info.max_targets) {
        let params = AttackParams {
            power: info.damage,
            ..Default::default()
        };
        run_attack(ctx, &mut sink, &mods, target, &params)?;
    }
    Ok(sink.events)
}

/// Port of the `41ee5532-...` test ability `script`:
/// `Result.push(OverlordEventEntityApplyEffect(Event.by_entity_id, uuid("3b136901-...")));`
/// `Event.by_entity_id` is the caster, so the effect is applied to the caster.
/// RNG-free; used by `test_effects::test_effect_with_subscribe`.
pub fn apply_low_hp_heal_effect(ctx: &CastAbilityCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    Ok(vec![OverlordEvent::EntityApplyEffect {
        entity_id: ctx.caster_entity.id,
        effect_id: Uuid::parse_str("3b136901-137c-47cc-8c7e-bc0ce387eb1c")?,
        origin: CombatEventOrigin::Core,
    }])
}

/// Register this category's native fns.
pub fn register(registry: &mut BehaviorRegistry) {
    let mut reg = |name: &str, title: &str, desc: &str, f: CastAbilityFn| {
        registry.register_cast_ability(
            BehaviorMeta {
                name: name.to_string(),
                category: BehaviorKind::CastAbility,
                title: title.to_string(),
                description: desc.to_string(),
            },
            f,
        );
    };

    reg(
        "ability_melee_strike",
        "Способность: удар по цели (0194d64e)",
        "on_cast + attack{power} (порт ability script 0194d64e).",
        melee_strike,
    );
    reg(
        "ability_sword_slash",
        "Способность: удар по цели (019bff40)",
        "on_cast + attack{power} (порт ability script 019bff40).",
        sword_slash,
    );
    reg(
        "ability_mob_melee_quick",
        "Способность: удар по цели (019cc464)",
        "on_cast + attack{power} (порт ability script 019cc464).",
        mob_melee_quick,
    );
    reg(
        "ability_mob_melee_average",
        "Способность: удар по цели (019cc465-14b8)",
        "on_cast + attack{power} (порт ability script 019cc465-14b8).",
        mob_melee_average,
    );
    reg(
        "ability_mob_melee_slow",
        "Способность: удар по цели (019cc465-2f63)",
        "on_cast + attack{power} (порт ability script 019cc465-2f63).",
        mob_melee_slow,
    );
    reg(
        "ability_apply_test_effect",
        "Способность: наложить test_effect",
        "apply_entity_effect(Caster, test_effect, 3) (порт ability script 01955be6).",
        apply_test_effect,
    );
    reg(
        "ability_damage_target_5",
        "Способность: урон 5 по цели (тест)",
        "Damage(TargetEntity, 5) — порт общего test ability script.",
        damage_target_5,
    );
    reg(
        "ability_apply_bloodleak_effect",
        "Способность: bloodleak +10 + эффект (тест 50260b1c)",
        "IncrAttribute(Target, bloodleak, 10) + ApplyEffect(Target, ccc47912).",
        apply_bloodleak_effect,
    );
    reg(
        "ability_test_band_strike",
        "Способность: тестовый удар по зоне (фикстура)",
        "attack по врагам в 3-клеточной зоне; охват и payload берутся из шаблона \
         кастуемой способности и её камней поддержки (только для тестового конфига).",
        test_band_strike,
    );
    reg(
        "ability_test_swing_aoe",
        "Способность: настоящий замах по всем врагам (тест)",
        "attack по каждому живому врагу в тике самого каста — для условий на число целей.",
        test_swing_aoe,
    );
    reg(
        "ability_test_swing",
        "Способность: настоящий замах (тест)",
        "attack{power: TEST_SWING_POWER, is_crit: false} — единственная тестовая \
         способность, которая доходит до примитивов урона.",
        test_swing,
    );
    reg(
        "ability_apply_low_hp_heal_effect",
        "Способность: наложить heal-эффект на кастера (тест 41ee5532)",
        "ApplyEffect(Caster, 3b136901).",
        apply_low_hp_heal_effect,
    );
    reg(
        "ability_crit_strike",
        "Способность: удар с бонусом крита (019584aa)",
        "on_cast + attack{power, crit_chance_bonus} (порт ability script 019584aa).",
        crit_strike,
    );
    reg(
        "ability_cone_strike",
        "Способность: конус по фронтальным врагам (019584f4)",
        "on_cast, один общий crit-бросок, attack по врагам в 3-клеточной зоне по x \
         (порт ability script 019584f4).",
        cone_strike,
    );
    reg(
        "ability_multi_projectile",
        "Способность: серия снарядов (019589e6)",
        "on_cast + N снарядов 0196a6b3 с задержкой i*150 (порт ability script 019589e6).",
        multi_projectile,
    );
    reg(
        "ability_strike_then_empower",
        "Способность: удар + empower (01958a30)",
        "on_cast + attack{power}; при уроне накладывает empower (порт ability script 01958a30).",
        strike_then_empower,
    );
    reg(
        "ability_strike_then_vulnerability",
        "Способность: удар + vulnerability (01958ef2)",
        "on_cast + attack{power}; при уроне накладывает vulnerability на цель \
         (порт ability script 01958ef2).",
        strike_then_vulnerability,
    );
    reg(
        "ability_night_pounce_projectile",
        "Способность: ульта питомца Nyx снарядом (79f90288)",
        "on_cast + StartCastProjectile(79f90288); урон ability_crit_strike \
         переносится на прилёт снаряда.",
        night_pounce_projectile_cast,
    );
    reg(
        "ability_rust_wave_projectile",
        "Способность: ульта питомца Rusty снарядом (1ce4597d)",
        "on_cast + StartCastProjectile(1ce4597d); конус ability_cone_strike \
         переносится на прилёт снаряда.",
        rust_wave_projectile_cast,
    );
    reg(
        "ability_odd_flame_projectile",
        "Способность: ульта питомца Thingy снарядом (432f231c)",
        "on_cast + StartCastProjectile(432f231c); DoT ability_dot_strike \
         переносится на прилёт снаряда.",
        odd_flame_projectile_cast,
    );
    reg(
        "ability_dot_strike",
        "Способность: чистый DoT-удар (01958efd)",
        "on_cast + attack{dot_power} (порт ability script 01958efd).",
        dot_strike,
    );
    reg(
        "ability_self_hot_heal",
        "Способность: HoT-лечение себя (01958ed0)",
        "on_cast + spell_heal(Caster, Caster, {hot_power}) (порт ability script 01958ed0).",
        self_hot_heal,
    );
    reg(
        "ability_fireball",
        "Способность: запуск снаряда 01966cbc (01958172)",
        "on_cast + StartCastProjectile(01966cbc) (порт ability script 01958172).",
        fireball_cast,
    );
    reg(
        "ability_fireball_projectile_shared",
        "Способность: запуск снаряда 01966cbc (общий)",
        "on_cast + StartCastProjectile(01966cbc); общий для 8 идентичных ability script \
         (019dfc4c/019dfc4f/019dfcfb/019dfcfe/019dfd00/019dfd01/019dfd02-0c6a/019dfd02-add4).",
        fireball_projectile_cast,
    );
    reg(
        "ability_vampiric_touch",
        "Способность: запуск снаряда 0196a6b4 (019589f7)",
        "on_cast + StartCastProjectile(0196a6b4) (порт ability script 019589f7).",
        vampiric_touch_cast,
    );
    reg(
        "ability_bare_projectile_mushroom",
        "Способность: голый запуск снаряда 019a0244-4675 (019a0245)",
        "StartCastProjectile(019a0244-4675) без on_cast (порт ability script 019a0245-ff0c).",
        bare_projectile_mushroom,
    );
    reg(
        "ability_bare_projectile_chipmunk",
        "Способность: голый запуск снаряда 019a0244-7a0a (019a0246-5aaf)",
        "StartCastProjectile(019a0244-7a0a) без on_cast (порт ability script 019a0246-5aaf).",
        bare_projectile_chipmunk,
    );
    reg(
        "ability_bare_projectile_bat",
        "Способность: голый запуск снаряда 019a0244-aad4 (019a0246-cf87)",
        "StartCastProjectile(019a0244-aad4) без on_cast (порт ability script 019a0246-cf87).",
        bare_projectile_bat,
    );
    reg(
        "ability_bare_projectile_shot",
        "Способность: голый запуск снаряда 019c009c (019c00a4)",
        "StartCastProjectile(019c009c) без on_cast (порт ability script 019c00a4).",
        bare_projectile_shot,
    );

    // --- Class kits ---
    reg(
        "ability_backstab",
        "Класс-кит Rogue: Backstab (019dfc4c)",
        "on_cast + attack{power, +50% crit} — крит-гэмбл кита.",
        backstab_cast,
    );
    reg(
        "ability_thousand_cuts",
        "Класс-кит Rogue: Thousand Cuts (019dfc4f)",
        "on_cast + 5 прямых ударов по цели (контратака возможна только с первого).",
        thousand_cuts_cast,
    );
    reg(
        "ability_arcane_blast",
        "Класс-кит Mage: Arcane Blast (019dfcfb)",
        "on_cast + attack{power} — весь бюджет одним нюком.",
        arcane_blast_cast,
    );
    reg(
        "ability_rewind",
        "Класс-кит Mage: Rewind (019dfcfe)",
        "on_cast + конус-удар + Weakness на поражённых врагов.",
        rewind_cast,
    );
    reg(
        "ability_fortify",
        "Класс-кит Warrior: Fortify (019dfd00)",
        "on_cast + Protection на себя + инстант-хил остатком бюджета.",
        fortify_cast,
    );
    reg(
        "ability_war_cry",
        "Класс-кит Warrior: War Cry (019dfd01)",
        "on_cast + конус-удар + Empower на себя при попадании.",
        war_cry_cast,
    );
    reg(
        "ability_battle_heal",
        "Класс-кит Priest: Battle heal (019dfd02-0c6a)",
        "on_cast + spell_heal(Caster, Caster, {power}) — инстант-хил всем бюджетом.",
        battle_heal_cast,
    );
    reg(
        "ability_holy_nova",
        "Класс-кит Priest: Holy Nova (019dfd02-add4)",
        "on_cast + конус-удар; кастер лечится за долю нанесённого урона.",
        holy_nova_cast,
    );
}

#[cfg(test)]
mod band_targets_tests {
    use super::band_targets;
    use essences::entity::{Coordinates, Entity};
    use essences::fighting::{ActiveFight, EntityTeam};

    fn enemy_at(id: u128, x: i64) -> Entity {
        Entity {
            id: uuid::Uuid::from_u128(id),
            team: EntityTeam::Enemy,
            coordinates: Coordinates { x, y: 0 },
            ..Default::default()
        }
    }

    /// §1: the AoE cap takes the FIRST `max_targets` band-eligible enemies in
    /// the deterministic `fight.entities` order (no RNG, no sorting); `None` is
    /// unlimited (legacy geometry-only behaviour).
    #[test]
    fn caps_first_n_in_fight_order() {
        let caster = Entity {
            team: EntityTeam::Ally,
            coordinates: Coordinates { x: 0, y: 0 },
            ..Default::default()
        };
        let fight = ActiveFight {
            entities: vec![
                enemy_at(1, 1),
                enemy_at(2, 2),
                enemy_at(3, 3),
                enemy_at(4, 3),
                enemy_at(5, 2),
            ],
            ..Default::default()
        };
        let ids = |cap| -> Vec<uuid::Uuid> {
            band_targets(&fight, &caster, cap)
                .iter()
                .map(|e| e.id)
                .collect()
        };
        // Unlimited: all five in-band enemies, in fight order.
        assert_eq!(ids(None).len(), 5);
        // Cap 3: the first three by fight.entities order.
        assert_eq!(
            ids(Some(3)),
            vec![
                uuid::Uuid::from_u128(1),
                uuid::Uuid::from_u128(2),
                uuid::Uuid::from_u128(3)
            ]
        );
    }

    /// The band excludes out-of-band enemies, allies, and units behind the
    /// caster — the cap only counts genuinely eligible targets.
    #[test]
    fn excludes_out_of_band_and_allies() {
        let caster = Entity {
            team: EntityTeam::Ally,
            coordinates: Coordinates { x: 0, y: 0 },
            ..Default::default()
        };
        let ally_in_band = Entity {
            id: uuid::Uuid::from_u128(3),
            team: EntityTeam::Ally,
            coordinates: Coordinates { x: 2, y: 0 },
            ..Default::default()
        };
        let fight = ActiveFight {
            entities: vec![
                enemy_at(1, 1), // in band
                enemy_at(2, 4), // out of band (x > caster_x + 3)
                ally_in_band,   // ally in band, excluded
                enemy_at(4, 0), // not ahead of caster (x <= caster_x), excluded
            ],
            ..Default::default()
        };
        let got: Vec<uuid::Uuid> = band_targets(&fight, &caster, Some(10))
            .iter()
            .map(|e| e.id)
            .collect();
        assert_eq!(got, vec![uuid::Uuid::from_u128(1)]);
    }
}