overlord_event_system/behaviors/combat/

start_cast.rs

//! Native ports for the `start_cast_ability` category — ability `start_behavior`
//! (run via `run_start_cast_ability`, returns `Vec<StartCastAbilityResult>`).
//!
//! Unlike the data categories, these run combat logic that consumes the
//! authoritative RNG (`try_cast`'s multicast roll, attack rolls, ...), drawing
//! values from the game `Random` in order.
//!
//! The 27 shipped ability start_scripts are dominated by
//! `ctx.try_cast(CasterEntity, "<self ability id>")` — one parameterised native
//! fn ([`try_cast_self`]) covers them; the small attack-based tail gets its own
//! fns.

use configs::abilities::ProjectileId;
use configs::game_config::GameConfig;
use essences::abilities::AbilityId;
use essences::combat_origin::CombatEventOrigin;
use essences::entity::Entity;
use essences::entity::{ActionWithDeadline, Coordinates, EntityAction, EntityId};
use essences::fighting::ActiveFight;
use event_system::event::EventPluginized;
use event_system::script::random::GameRng;
use serde::Serialize;

use crate::event::{CustomEventData, OverlordEvent};
use crate::game_config_helpers::GameConfigLookup;
use crate::state::OverlordState;
use uuid::Uuid;

use crate::behaviors::{BehaviorKind, BehaviorMeta, BehaviorRegistry};
use crate::mechanics::content_lookups::ContentLookups;
use crate::mechanics::fight::{self, NativeSink};

/// `start_behavior` sees (`CasterEntity`, `Fight`, `Random`) plus the cast ability
/// id and config/lookups the combat API needs.
pub struct StartCastAbilityCtx<'a> {
    pub caster: &'a Entity,
    pub fight: &'a ActiveFight,
    /// RNG snapshot (a clone of the authoritative stream at the same state) so
    pub rng: &'a GameRng,
    /// The ability being cast (its template id) — the dominant
    /// `try_cast(CasterEntity, "<self>")` pattern casts the caster's own ability.
    pub ability_template_id: Uuid,
    pub config: &'a GameConfig,
    pub lookups: &'a ContentLookups,
}

/// Signature of a `start_cast_ability` native fn.
pub type StartCastAbilityFn =
    fn(&StartCastAbilityCtx) -> anyhow::Result<Vec<StartCastAbilityResult>>;

/// Port of `ctx.try_cast(CasterEntity, "<self ability id>")` — the dominant
/// wrapper does (casts=1 default; identical RNG consumption: multicast roll,
/// valid-target filtering, per-cast rolls), then classifies the pushed results.
pub fn try_cast_self(ctx: &StartCastAbilityCtx) -> anyhow::Result<Vec<StartCastAbilityResult>> {
    let mut sink = NativeSink::default();
    fight::try_cast(
        &mut sink,
        ctx.rng,
        ctx.config,
        ctx.lookups,
        ctx.fight,
        ctx.caster,
        ctx.ability_template_id,
        1,
    )
    .map_err(|e| anyhow::anyhow!("try_cast: {e}"))?;
    StartCastAbilityResult::vec_from_script_results(&sink.casts)
}

/// Port of `Result.push_attack(unsigned(0), unsigned(400), CasterEntity.id)` — a
/// single self-targeting attack (delay 0, anim 400 ticks). No RNG. Used by the
/// one non-`try_cast` ability start_behavior (01955be6).
pub fn self_attack_400(ctx: &StartCastAbilityCtx) -> anyhow::Result<Vec<StartCastAbilityResult>> {
    Ok(vec![StartCastAbilityResult::Attack {
        delay_ticks: 0,
        animation_duration_ticks: 400,
        target_entity_id: ctx.caster.id,
        origin: CombatEventOrigin::Core,
    }])
}

/// Port of the shared test `start_behavior` (`generate_start_ability_script`):
/// Attacks the first entity on the opposing team (anim 500). RNG-free.
pub fn attack_first_enemy(
    ctx: &StartCastAbilityCtx,
) -> anyhow::Result<Vec<StartCastAbilityResult>> {
    let Some(target) = ctx
        .fight
        .entities
        .iter()
        .find(|e| e.team != ctx.caster.team)
    else {
        return Ok(vec![]);
    };
    Ok(vec![StartCastAbilityResult::Attack {
        delay_ticks: 0,
        animation_duration_ticks: 500,
        target_entity_id: target.id,
        origin: CombatEventOrigin::Core,
    }])
}

/// Port of `Result.push_attack(unsigned(0), unsigned(500), CasterEntity.id);`
/// (the `41ee5532-...` test ability `start_behavior`) — a single self-targeting
/// attack (delay 0, anim 500 ticks). RNG-free.
pub fn self_attack_500(ctx: &StartCastAbilityCtx) -> anyhow::Result<Vec<StartCastAbilityResult>> {
    Ok(vec![StartCastAbilityResult::Attack {
        delay_ticks: 0,
        animation_duration_ticks: 500,
        target_entity_id: ctx.caster.id,
        origin: CombatEventOrigin::Core,
    }])
}

/// Register this category's native fns.
fn register_ability_fns(registry: &mut BehaviorRegistry) {
    registry.register_start_cast_ability(
        BehaviorMeta {
            name: "try_cast_self".to_string(),
            category: BehaviorKind::StartCastAbility,
            title: "Авто-каст своей абилки".to_string(),
            description: "Порт start_behavior `ctx.try_cast(CasterEntity, <self ability id>)` — \
                кастует абилку кастера через try_cast (casts=1)."
                .to_string(),
        },
        try_cast_self,
    );
    registry.register_start_cast_ability(
        BehaviorMeta {
            name: "self_attack_400".to_string(),
            category: BehaviorKind::StartCastAbility,
            title: "Само-атака (anim 400)".to_string(),
            description: "Порт `Result.push_attack(0, 400, CasterEntity.id)` — одиночная \
                атака по себе, без RNG."
                .to_string(),
        },
        self_attack_400,
    );
    registry.register_start_cast_ability(
        BehaviorMeta {
            name: "attack_first_enemy".to_string(),
            category: BehaviorKind::StartCastAbility,
            title: "Атака по первому врагу (anim 500)".to_string(),
            description: "Порт общего test start_behavior: атака по первой сущности \
                вражеской команды, anim 500."
                .to_string(),
        },
        attack_first_enemy,
    );
    registry.register_start_cast_ability(
        BehaviorMeta {
            name: "self_attack_500".to_string(),
            category: BehaviorKind::StartCastAbility,
            title: "Само-атака (anim 500)".to_string(),
            description: "Порт `Result.push_attack(0, 500, CasterEntity.id)` \
                (test ability 41ee5532)."
                .to_string(),
        },
        self_attack_500,
    );
}
// Native functions for the `start_cast_projectile` category — the projectile
// `start_behavior` slot (`run_start_cast_projectile` in `script.rs`, called from
// `handle_start_cast_projectile`).
//
// Despite the rollout's "needs_fight_context" hint, the scripts this slot
// actually runs (`projectile.start_behavior`) are **pure geometry** — they never
// `import "fight_context"`, never call `ctx.attack/on_cast`, and never touch
// `Result.projectile_data`. (The `fight_context` logic lives in the sibling
// `projectile.script` slot — the `CastProjectile` event handler — which is a
// *different* category, not this one.) Every shipped `start_behavior` is one of
// exactly two shapes:
//
//
// Each distinct shape/constant is a separately-named native fn (config
// references the one matching the projectile), exactly as `power.rs` keeps one
// `fn` per behavior. `Result.projectile_data` is left at its default (empty)
// map in every case, matching the scripts.
//
// ## Marshalling fidelity
// * `(xc - xt) ** 2` is `INT ** INT` → stays `INT` (integer power).
//   so `distance` is `((x2 + y2) as f64).powf(0.5)` (i.e. `sqrt`).
// * `distance * M` is `FLOAT * INT` → `FLOAT`.
// * `floor(FLOAT)` → `INT` (`f64::floor` then `as i64`, per the engine's
//   `register_fn("floor", |val: f64| val.floor() as i64)`).
// * `unsigned(INT)` → `u64` (`x as u64`, per `register_fn("unsigned", ...)`).
//
// The native port performs the squares in `i64`, the `sqrt`/scale in `f64`,
// then `floor`→`i64`→`as u64`, reproducing the engine ops bit-for-bit.

/// Inputs available to a `start_cast_projectile` native fn — the subset of the
/// scope (`run_start_cast_projectile` via `handle_start_cast_projectile`) also
/// binds `CasterEntity`, `Fight`, `ProjectileLevel`, `CurrentTick`,
/// `FightDurationTicks` and the event, but no shipped `start_behavior` reads
/// anything beyond the caster/target coordinates; add fields here if a future
/// script does.
pub struct StartCastProjectileCtx<'a> {
    pub caster_entity: &'a Entity,
    pub target_entity: &'a Entity,
}

/// Signature of a `start_cast_projectile` native fn. Free `fn` (no captured
/// state) so it is `Copy` and trivially stored in the registry; runtime context
/// arrives via [`StartCastProjectileCtx`].
pub type StartCastProjectileFn =
    fn(&StartCastProjectileCtx) -> anyhow::Result<StartCastProjectileResult>;

/// squares in `i64` (`INT ** INT`), then `((x2 + y2) as f64).powf(0.5)`
/// (`INT ** FLOAT` promotes the base to `FLOAT`).
fn caster_target_distance(ctx: &StartCastProjectileCtx) -> f64 {
    let dx = ctx.caster_entity.coordinates.x - ctx.target_entity.coordinates.x;
    let dy = ctx.caster_entity.coordinates.y - ctx.target_entity.coordinates.y;
    // `(xc - xt) ** 2` / `(yc - yt) ** 2` — integer power, kept in i64.
    let x2 = dx * dx;
    let y2 = dy * dy;
    // exponent, i.e. powf(0.5) == sqrt.
    ((x2 + y2) as f64).powf(0.5)
}

/// Shared distance-based body: `unsigned(floor(distance * multiplier))`, leaving
/// `projectile_data` at its default (empty) — matching the shipped scripts.
fn distance_animation(
    ctx: &StartCastProjectileCtx,
    multiplier: f64,
) -> anyhow::Result<StartCastProjectileResult> {
    let distance = caster_target_distance(ctx);
    // `distance * M` is FLOAT; `floor(FLOAT)` → i64 (engine `floor`); then
    // `unsigned(i64)` → u64 (engine `unsigned`, `x as u64`).
    let ticks = (distance * multiplier).floor() as i64 as u64;
    Ok(StartCastProjectileResult {
        projectile_data: Default::default(),
        animation_duration_ticks: ticks,
    })
}

/// Native port of the distance×100 `start_behavior` (the common case).
pub fn distance_x100(ctx: &StartCastProjectileCtx) -> anyhow::Result<StartCastProjectileResult> {
    distance_animation(ctx, 100.0)
}

/// Native port of the distance×380 `start_behavior`
/// (projectile `0196a6b3-f885-7fdc-af8c-92a1ffb79ceb`).
pub fn distance_x380(ctx: &StartCastProjectileCtx) -> anyhow::Result<StartCastProjectileResult> {
    distance_animation(ctx, 380.0)
}

/// Native port of the fixed `Result.animation_duration_ticks = unsigned(200)`
/// `start_behavior` (projectile `019aeeed-5bcc-7dcc-a74f-589031a6b8f2`).
pub fn fixed_200(_ctx: &StartCastProjectileCtx) -> anyhow::Result<StartCastProjectileResult> {
    Ok(StartCastProjectileResult {
        projectile_data: Default::default(),
        animation_duration_ticks: 200,
    })
}

/// Port of the test projectile `start_behavior`
/// `Result.animation_duration_ticks = unsigned(500); Result.projectile_data.add("damage", 300);`
/// — fixed 500-tick anim with a `damage=300` entry in `projectile_data`. Used by
/// `test_fighting_abilities`.
pub fn fixed_500_damage_300(
    _ctx: &StartCastProjectileCtx,
) -> anyhow::Result<StartCastProjectileResult> {
    let mut projectile_data = crate::event::CustomEventData::default();
    projectile_data.add("damage", 300);
    Ok(StartCastProjectileResult {
        projectile_data,
        animation_duration_ticks: 500,
    })
}

/// Register this category's native fns into the registry.
fn register_projectile_fns(registry: &mut BehaviorRegistry) {
    registry.register_start_cast_projectile(
        BehaviorMeta {
            name: "projectile_fixed_500_damage_300".to_string(),
            category: BehaviorKind::StartCastProjectile,
            title: "Снаряд: 500 тиков + damage=300 (тест)".to_string(),
            description: "Фиксированные 500 тиков анимации; projectile_data = {damage: 300} \
                (порт test projectile start_behavior)."
                .to_string(),
        },
        fixed_500_damage_300,
    );
    registry.register_start_cast_projectile(
        BehaviorMeta {
            name: "projectile_distance_x100".to_string(),
            category: BehaviorKind::StartCastProjectile,
            title: "Снаряд: длительность по дистанции (×100)".to_string(),
            description: "unsigned(floor(дистанция_кастер_цель * 100)) тиков анимации; \
                projectile_data пустой (порт projectile start_behavior ×100)."
                .to_string(),
        },
        distance_x100,
    );
    registry.register_start_cast_projectile(
        BehaviorMeta {
            name: "projectile_distance_x380".to_string(),
            category: BehaviorKind::StartCastProjectile,
            title: "Снаряд: длительность по дистанции (×380)".to_string(),
            description: "unsigned(floor(дистанция_кастер_цель * 380)) тиков анимации; \
                projectile_data пустой (порт projectile start_behavior ×380)."
                .to_string(),
        },
        distance_x380,
    );
    registry.register_start_cast_projectile(
        BehaviorMeta {
            name: "projectile_fixed_200".to_string(),
            category: BehaviorKind::StartCastProjectile,
            title: "Снаряд: фиксированная длительность 200".to_string(),
            description: "Фиксированные 200 тиков анимации; projectile_data пустой \
                (порт projectile start_behavior unsigned(200))."
                .to_string(),
        },
        fixed_200,
    );
}

/// Register both start-cast scopes (ability wind-up + projectile wind-up).
pub fn register(registry: &mut BehaviorRegistry) {
    register_ability_fns(registry);
    register_projectile_fns(registry);
}

/// One pushed result from an ability `start_behavior` — either an attack or a run.
/// The native start-cast-ability port fills a `Vec` of these, which
/// [`StartCastAbilityResult::vec_from_script_results`] classifies into typed
/// [`StartCastAbilityResult`]s.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct StartCastAbilityScriptResult {
    pub delay_ticks: Option<u64>,
    pub animation_duration_ticks: Option<u64>,
    pub target_entity_id: Option<Uuid>,

    pub coordinates: Option<Coordinates>,
    pub run_duration_ticks: Option<u64>,

    /// Provenance of the scope that pushed this cast — `Core` for the fight
    /// engine itself, non-Core when a modifier queued the swing through an
    /// [`crate::mechanics::fight::OriginSink`]. It reaches the queued
    /// [`ActionWithDeadline`] so the damage the cast eventually lands cannot
    /// surface as Core.
    pub origin: CombatEventOrigin,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize)]
pub enum StartCastAbilityResult {
    Run {
        coordinates: Coordinates,
        run_duration_ticks: u64,
        /// See [`StartCastAbilityScriptResult::origin`].
        origin: CombatEventOrigin,
    },
    Attack {
        delay_ticks: u64,
        animation_duration_ticks: u64,
        target_entity_id: Uuid,
        /// See [`StartCastAbilityScriptResult::origin`].
        origin: CombatEventOrigin,
    },
    None,
}

impl StartCastAbilityResult {
    /// Convert the raw pushed results (`StartCastAbilityScriptResult`) into typed
    /// `StartCastAbilityResult`s, applying Run/Attack/None classification +
    /// validation.
    pub fn vec_from_script_results(
        results: &[StartCastAbilityScriptResult],
    ) -> anyhow::Result<Vec<StartCastAbilityResult>> {
        let mut converted_results = Vec::new();
        let mut running = false;
        for result in results.iter().cloned() {
            if result.run_duration_ticks.is_some() && result.animation_duration_ticks.is_some() {
                anyhow::bail!(
                    "Attack and run provided in one singular result {:?}",
                    result
                )
            }
            let converted_result = if let (Some(run_duration_ticks), Some(coordinates)) =
                (result.run_duration_ticks, result.coordinates)
            {
                running = true;
                StartCastAbilityResult::Run {
                    coordinates,
                    run_duration_ticks,
                    origin: result.origin,
                }
            } else if let (
                Some(animation_duration_ticks),
                Some(target_entity_id),
                Some(delay_ticks),
            ) = (
                result.animation_duration_ticks,
                result.target_entity_id,
                result.delay_ticks,
            ) {
                StartCastAbilityResult::Attack {
                    delay_ticks,
                    animation_duration_ticks,
                    target_entity_id,
                    origin: result.origin,
                }
            } else {
                StartCastAbilityResult::None
            };
            converted_results.push(converted_result);
        }
        if running && converted_results.len() > 1 {
            anyhow::bail!("More than 1 result in start_cast_ability with running {results:?}")
        }
        Ok(converted_results)
    }

    /// `dispatch_origin` is the provenance of the dispatch that ran the
    /// `start_behavior`; the result's own origin is the scope that pushed the
    /// cast. Marking only upgrades, so the queued action carries whichever of
    /// the two is non-Core.
    pub fn into_entity_action_with_deadline(
        &self,
        class_id: Uuid,
        game_config: &GameConfig,
        ability_id: AbilityId,
        current_tick: u64,
        dispatch_origin: CombatEventOrigin,
    ) -> anyhow::Result<ActionWithDeadline> {
        match self {
            StartCastAbilityResult::Run { .. } => {
                anyhow::bail!("Got Run for StartCastAbilityResult into_entity_action")
            }
            StartCastAbilityResult::Attack {
                delay_ticks,
                animation_duration_ticks,
                target_entity_id,
                origin,
            } => {
                let Some(class) = game_config.class(class_id) else {
                    anyhow::bail!("Failed to get class with id: {}", class_id);
                };

                let action = if !class.basic_abilities.contains(&ability_id) {
                    EntityAction::CastAbility {
                        ability_id,
                        target_entity_id: *target_entity_id,
                    }
                } else {
                    EntityAction::CastBasicAbility {
                        ability_id,
                        target_entity_id: *target_entity_id,
                    }
                };

                Ok(ActionWithDeadline {
                    action,
                    deadline_tick: current_tick + *delay_ticks + *animation_duration_ticks,
                    origin: origin.merge(dispatch_origin),
                })
            }
            StartCastAbilityResult::None => {
                anyhow::bail!("Got NONE for StartCastAbilityResult into_entity_action")
            }
        }
    }

    pub fn into_event(
        &self,
        ability_id: AbilityId,
        by_entity_id: EntityId,
        dispatch_origin: CombatEventOrigin,
    ) -> Option<EventPluginized<OverlordEvent, OverlordState>> {
        match self {
            StartCastAbilityResult::Run {
                coordinates,
                run_duration_ticks,
                ..
            } => Some(EventPluginized::now(OverlordEvent::StartMove {
                entity_id: by_entity_id,
                to: coordinates.clone(),
                duration_ticks: *run_duration_ticks,
            })),
            StartCastAbilityResult::Attack {
                delay_ticks,
                animation_duration_ticks,
                origin,
                ..
            } => Some(EventPluginized::delayed(
                OverlordEvent::StartedCastAbility {
                    by_entity_id,
                    ability_id,
                    duration_ticks: *animation_duration_ticks,
                    origin: origin.merge(dispatch_origin),
                },
                *delay_ticks,
            )),
            StartCastAbilityResult::None => None,
        }
    }

    #[allow(clippy::type_complexity)]
    pub fn vec_into_actions_with_deadlines_and_events(
        results: &Vec<StartCastAbilityResult>,
        class_id: Uuid,
        game_config: &GameConfig,
        ability_id: AbilityId,
        entity_id: EntityId,
        current_tick: u64,
        dispatch_origin: CombatEventOrigin,
    ) -> anyhow::Result<(
        Vec<ActionWithDeadline>,
        Vec<EventPluginized<OverlordEvent, OverlordState>>,
    )> {
        let mut actions = vec![];
        let mut events = vec![];

        for result in results {
            if matches!(result, StartCastAbilityResult::Attack { .. }) {
                actions.push(result.into_entity_action_with_deadline(
                    class_id,
                    game_config,
                    ability_id,
                    current_tick,
                    dispatch_origin,
                )?);
            }

            if let Some(event) = result.into_event(ability_id, entity_id, dispatch_origin) {
                events.push(event);
            }
        }

        Ok((actions, events))
    }
}

#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct StartCastProjectileResult {
    pub projectile_data: CustomEventData,
    pub animation_duration_ticks: u64,
}

impl StartCastProjectileResult {
    pub fn into_frontend_event(
        &self,
        by_entity_id: EntityId,
        to_entity_id: EntityId,
        projectile_id: ProjectileId,
        source: essences::fight_breakdown::CombatSource,
    ) -> EventPluginized<OverlordEvent, OverlordState> {
        EventPluginized::now(OverlordEvent::StartedCastProjectile {
            by_entity_id,
            to_entity_id,
            projectile_id,
            duration_ticks: self.animation_duration_ticks,
            origin: CombatEventOrigin::Core,
            source,
        })
    }
}