overlord_event_system/behaviors/combat/

cast_projectile.rs

//! Native ports for the `cast_projectile` category — projectile `script`s (the
//! `CastProjectile` event handler, run via `run_event` in
//! `logic::fighting::handle_cast_projectile`, returning
//! `Vec<OverlordEvent>`).
//!
//! Every shipped projectile `script` is `ctx.attack(CasterEntity, TargetEntity,
//! #{ ... })` with a per-projectile param map, resolved from a sibling ability's
//! `get_ability_info(<ability_id>, ProjectileLevel)`:
//!
//! * plain damage: `#{ power: ability_info.damage }`
//! * DoT split: `#{ power: ability_info.damage, dot_power: ability_info.dot }`
//! * vampiric: `attack{power}`, then `if (damage > 0) heal_entity(caster, damage * vampiric)`
//! * counterattack: `#{ power: balance::COUNTERATTACK_POWER, no_counterattack: true }`
//!
//! ## RNG
//! `attack` consumes the authoritative `Random` (evasion / counterattack /
//! deceit / crit / block throws).
//!
//! ## Scope
//! `CasterEntity`, `TargetEntity`, `Fight`, `Random`, `ProjectileLevel`,
//! `CustomEventData`, `CurrentTick`, `FightDurationTicks`, 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::mechanics::balance;
use crate::mechanics::content::{AbilityInfo, ability_info};
use crate::mechanics::content_lookups::ContentLookups;
use crate::mechanics::fight::{AttackParams, NativeSink, heal_entity, stat_throw};
use crate::mechanics::support_shapes::{SupportAttackCtx, attack_with_supports};
use essences::ability_stones::AbilityStoneMods;

use super::cast_ability::band_targets;

/// Inputs available to a `cast_projectile` native fn.
pub struct CastProjectileCtx<'a> {
    /// `CasterEntity` const.
    pub caster_entity: &'a Entity,
    /// `TargetEntity` const.
    pub target_entity: &'a Entity,
    /// `Fight` const (for `player_id` in the attack screen-shake branch).
    pub fight: &'a ActiveFight,
    /// RNG snapshot (clone at the same state).
    pub rng: &'a GameRng,
    /// `ProjectileLevel` const (passed to `get_ability_info`).
    pub projectile_level: i64,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
    /// Ability stones active on the caster (the projectile carries the parent
    /// ability's damage, so it carries the parent ability's stones too).
    pub stones: crate::mechanics::ability_stones::AbilityStoneResolver<'a>,
    /// Breakdown attribution of everything this projectile lands. Resolved by
    /// the dispatcher from the projectile id, so the counterattack reflex reads
    /// as a counterattack rather than as an anonymous projectile.
    pub source: CombatSource,
}

/// Signature of a `cast_projectile` native fn.
pub type CastProjectileFn = fn(&CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>>;

/// `content::get_ability_info(id, ProjectileLevel)` plus the ability-stone
/// modifiers of the ability this projectile carries (already folded into the
/// returned info).
fn info(
    ctx: &CastProjectileCtx,
    ability_id: &str,
) -> anyhow::Result<(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.projectile_level)?;
    let mods = ctx.stones.mods_for(ctx.config, id, ctx.projectile_level);
    info.apply_stone_mods(&mods);
    Ok((info, mods))
}

/// 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_on(
    ctx: &CastProjectileCtx,
    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,
    )
}

/// The common case: the projectile hits the entity it was aimed at.
fn run_attack(
    ctx: &CastProjectileCtx,
    sink: &mut NativeSink,
    mods: &AbilityStoneMods,
    params: &AttackParams,
) -> anyhow::Result<Option<i64>> {
    run_attack_on(ctx, sink, mods, ctx.target_entity, params)
}

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

/// `01966cbc-...` — `attack(#{ power: damage, dot_power: dot })`, info from
/// ability `01958172`.
pub fn attack_power_dot(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let (ability_info, mods) = info(ctx, "01958172-9e65-7061-9d15-56b2c33cc13e")?;
    let params = AttackParams {
        power: ability_info.damage,
        dot_power: ability_info.dot,
        ..Default::default()
    };
    run_attack(ctx, &mut sink, &mods, &params)?;
    Ok(sink.events)
}

/// `0196a6b3-...` — `attack(#{ power })`, info from ability `019589e6`.
pub fn arcane_missiles_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    attack_power(ctx, "019589e6-f9dd-7b22-8d39-5350e95aaf69")
}

/// `019a0244-4675-...` — `attack(#{ power })`, info from ability `019a0245`.
pub fn mushroom_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    attack_power(ctx, "019a0245-ff0c-7964-b345-ded525c71e74")
}

/// `019a0244-7a0a-...` — `attack(#{ power })`, info from ability `019a0246-5aaf`.
pub fn chipmunk_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    attack_power(ctx, "019a0246-5aaf-7c01-9a1a-3969e04129ec")
}

/// `019a0244-aad4-...` — `attack(#{ power })`, info from ability `019a0246-cf87`.
pub fn bat_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    attack_power(ctx, "019a0246-cf87-73b0-b701-f8788cf9cc08")
}

/// `019c009c-...` — `attack(#{ power })`, info from ability `019c00a4`.
pub fn shot_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    attack_power(ctx, "019c00a4-38c9-7859-a642-fd82c25ef285")
}

/// `0196a6b4-...` — vampiric: `attack(#{ power })`; if damage dealt (`> 0` in
///
/// Fidelity note: when `attack` returns nothing (evasion / no-damage), there is
/// no damage to read, so this slot must emit **zero** events. We return `Err`
/// (discarding the partial sink) on the `None` branch so the handler produces
/// no events.
pub fn attack_vampiric(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let (ability_info, mods) = info(ctx, "019589f7-f4a3-701c-bc0f-f60d980ae250")?;
    let params = AttackParams {
        power: ability_info.damage,
        ..Default::default()
    };
    let damage = run_attack(ctx, &mut sink, &mods, &params)?;
    let Some(damage) = damage else {
        anyhow::bail!("attack returned no damage; the `damage > 0` contract failed");
    };
    if damage > 0 {
        let vampiric = ability_info.vampiric.unwrap_or(0.0);
        heal_entity(
            &mut sink,
            Some(ctx.caster_entity.id),
            ctx.caster_entity,
            damage as f64 * vampiric,
            ctx.source,
        )
        .map_err(|e| anyhow::anyhow!("heal_entity: {e}"))?;
    }
    Ok(sink.events)
}

/// `019aeeed-...` — counterattack: `attack(#{ power: COUNTERATTACK_POWER,
/// no_counterattack: true })`. No `get_ability_info`.
pub fn counterattack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let params = AttackParams {
        power: Some(balance::COUNTERATTACK_POWER),
        no_counterattack: true,
        ..Default::default()
    };
    // A counterattack is the TARGET's reflex, not the caster's ability: it
    // carries no ability payload, so no support stone touches it.
    run_attack(ctx, &mut sink, &AbilityStoneMods::identity(), &params)?;
    Ok(sink.events)
}

/// `79f90288-...` — pet Night Pounce delivery: `attack(#{ power,
/// crit_chance_bonus })`, info from ability `019584aa` (the Strike the pet ult
/// clones). Same math as the instant `ability_crit_strike`, moved onto a
/// projectile so the cast is readable in combat.
pub fn pet_night_pounce_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    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, &params)?;
    Ok(sink.events)
}

/// `1ce4597d-...` — pet Rust Wave delivery: one shared crit throw, then attack
/// every enemy in the caster's forward 3-cell x-band with `{ power, is_crit }`,
/// info from ability `019584f4` (the Nova the pet ult clones). Same math as the
/// instant `ability_cone_strike`; the cone resolves on projectile arrival.
pub fn pet_rust_wave_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    let (ability_info, mods) = info(ctx, "019584f4-2c99-72bf-bcd3-bfc02fb33977")?;
    let is_crit = stat_throw(ctx.rng, ctx.lookups, ctx.caster_entity, "crit_chance", 0.0);
    let targets: Vec<uuid::Uuid> =
        band_targets(ctx.fight, ctx.caster_entity, ability_info.max_targets)
            .iter()
            .map(|e| e.id)
            .collect();
    for target_id in targets {
        let Some(target) = ctx.fight.entities.iter().find(|e| e.id == target_id) else {
            continue;
        };
        let params = AttackParams {
            power: ability_info.damage,
            is_crit: Some(is_crit),
            ..Default::default()
        };
        run_attack_on(ctx, &mut sink, &mods, target, &params)?;
    }
    Ok(sink.events)
}

/// `432f231c-...` — pet Odd Flame delivery: `attack(#{ dot_power })`, info from
/// ability `01958efd` (the Immolate the pet ult clones). Same math as the
/// instant `ability_dot_strike`, moved onto a projectile.
pub fn pet_odd_flame_attack(ctx: &CastProjectileCtx) -> anyhow::Result<Vec<OverlordEvent>> {
    let mut sink = NativeSink::default();
    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, &params)?;
    Ok(sink.events)
}

/// Port of the test projectile `script`
/// `Result.push(OverlordEventDamage(TargetEntity.id, unsigned(5), CustomEventData()));`
/// — raw 5 damage to the target. RNG-free; used by `test_fighting_abilities`.
pub fn damage_target_5(ctx: &CastProjectileCtx) -> 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,
    }])
}

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

    reg(
        "projectile_damage_target_5",
        "Снаряд: урон 5 по цели (тест)",
        "Damage(TargetEntity, 5) — порт test projectile script.",
        damage_target_5,
    );
    reg(
        "projectile_attack_power_dot",
        "Снаряд: attack{power,dot} (01966cbc)",
        "attack(#{power: ability_info.damage, dot_power: ability_info.dot}) \
         info из 01958172 (порт projectile script 01966cbc).",
        attack_power_dot,
    );
    reg(
        "projectile_arcane_missiles_attack",
        "Снаряд: attack{power} (0196a6b3)",
        "attack(#{power: ability_info.damage}) info из 019589e6 (порт projectile script 0196a6b3).",
        arcane_missiles_attack,
    );
    reg(
        "projectile_mushroom_attack",
        "Снаряд: attack{power} (019a0244-4675)",
        "attack(#{power: ability_info.damage}) info из 019a0245 (порт projectile script 019a0244-4675).",
        mushroom_attack,
    );
    reg(
        "projectile_chipmunk_attack",
        "Снаряд: attack{power} (019a0244-7a0a)",
        "attack(#{power: ability_info.damage}) info из 019a0246-5aaf (порт projectile script 019a0244-7a0a).",
        chipmunk_attack,
    );
    reg(
        "projectile_bat_attack",
        "Снаряд: attack{power} (019a0244-aad4)",
        "attack(#{power: ability_info.damage}) info из 019a0246-cf87 (порт projectile script 019a0244-aad4).",
        bat_attack,
    );
    reg(
        "projectile_shot_attack",
        "Снаряд: attack{power} (019c009c)",
        "attack(#{power: ability_info.damage}) info из 019c00a4 (порт projectile script 019c009c).",
        shot_attack,
    );
    reg(
        "projectile_attack_vampiric",
        "Снаряд: вампиризм (0196a6b4)",
        "attack(#{power}); при уроне>0 heal_entity(Caster, damage*vampiric) \
         info из 019589f7 (порт projectile script 0196a6b4).",
        attack_vampiric,
    );
    reg(
        "projectile_pet_night_pounce",
        "Снаряд: удар с бонусом крита (79f90288, ульта питомца Nyx)",
        "attack(#{power, crit_chance_bonus}) info из 019584aa — та же математика, \
         что у ability_crit_strike, но доставка снарядом.",
        pet_night_pounce_attack,
    );
    reg(
        "projectile_pet_rust_wave",
        "Снаряд: конус по фронтальным врагам (1ce4597d, ульта питомца Rusty)",
        "Один общий crit-бросок, attack по врагам в 3-клеточной зоне по x при \
         прилёте снаряда; info из 019584f4 — та же математика, что у ability_cone_strike.",
        pet_rust_wave_attack,
    );
    reg(
        "projectile_pet_odd_flame",
        "Снаряд: чистый DoT-удар (432f231c, ульта питомца Thingy)",
        "attack(#{dot_power}) info из 01958efd — та же математика, что у \
         ability_dot_strike, но доставка снарядом.",
        pet_odd_flame_attack,
    );
    reg(
        "projectile_counterattack",
        "Снаряд: контратака (019aeeed)",
        "attack(#{power: COUNTERATTACK_POWER, no_counterattack: true}) \
         (порт projectile script 019aeeed).",
        counterattack,
    );
}