overlord_event_system/

entities.rs

use configs::game_config;
use essences::combat_origin::CombatEventOrigin;
use essences::{
    abilities, character_state,
    entity::{self, EntityAction, EntityActionsQueue, EntityAttributes, EntityId, EntityState},
    fighting,
    flip::FlipState,
};
use event_system::event::EventPluginized;

use std::collections::BTreeMap;

use crate::attributes::{
    AttributeDeltas, EntityStats, calculate_entity_stats,
    calculate_player_entity_stats_without_zeroes, compose_max_hp,
};
use crate::game_config_helpers::GameConfigLookup;

use super::{TICKER_UNIT_DURATION_MS, event::OverlordEvent, state::OverlordState};

/// A character combatant's fight-local pool at fight start: full, from config.
/// `updated_tick = 0` is safe — the pool is already full, so the first
/// `regen_to` only re-syncs the accrual clock.
fn full_mana_pool(game_config: &game_config::GameConfig) -> essences::mana::ManaPool {
    essences::mana::ManaPool::full(
        game_config.mana_settings.pool,
        game_config.mana_settings.regen_per_second,
        0,
    )
}

fn make_ability_deadline(cooldown: u64) -> chrono::DateTime<chrono::Utc> {
    ::time::utc_now()
        + chrono::TimeDelta::milliseconds((cooldown as u128 * TICKER_UNIT_DURATION_MS) as i64)
}

pub fn sort_active_abilities(abilities: &mut [abilities::ActiveAbility]) {
    abilities.sort_by(|a, b| {
        a.slot_id
            .cmp(&b.slot_id)
            .then(a.ability.template_id.cmp(&b.ability.template_id))
    });
}

pub fn make_active_abilities_from_equipped(
    equipped_abilities: &abilities::EquippedAbilities,
    game_config: &game_config::GameConfig,
    begin_in_cooldown: bool,
) -> Vec<abilities::ActiveAbility> {
    let deadline_for = |template_id| {
        if begin_in_cooldown {
            let cooldown = game_config
                .ability_template(template_id)
                .map(|t| t.cooldown)
                .unwrap_or(0);
            Some(make_ability_deadline(cooldown))
        } else {
            None
        }
    };

    let mut abilities: Vec<abilities::ActiveAbility> =
        equipped_abilities
            .unslotted
            .iter()
            .map(|a| abilities::ActiveAbility {
                deadline: deadline_for(a.template_id),
                ability: a.clone(),
                slot_id: None,
            })
            .chain(equipped_abilities.slotted.iter().map(|(&slot_id, a)| {
                abilities::ActiveAbility {
                    deadline: deadline_for(a.template_id),
                    ability: a.clone(),
                    slot_id: Some(slot_id),
                }
            }))
            .collect();

    sort_active_abilities(&mut abilities);

    abilities
}

/// Leader-pet combat payload of one combatant: the pet to render beside it, its
/// charge-driven ult state, and the ult entry for the entity's ability list.
///
pub fn create_player_entity(
    character_state: &character_state::CharacterState,
    flip_state: FlipState,
    entity_id: uuid::Uuid,
    game_config: &game_config::GameConfig,
) -> anyhow::Result<entity::Entity> {
    let entity_stats = calculate_player_entity_stats_without_zeroes(
        &EntityState::Character(character_state),
        game_config,
    )?;

    let entity_abilities = make_active_abilities_from_equipped(
        &character_state.equipped_abilities,
        game_config,
        false,
    );

    let mut entity = entity::Entity {
        id: entity_id,
        max_hp: entity_stats.max_hp,
        hp: entity_stats.max_hp,
        abilities: entity_abilities,
        actions_queue: EntityActionsQueue::new(entity_id),
        attributes: entity_stats.attributes,
        effect_ids: Default::default(),
        coordinates: game_config.fight_settings.player_start_position.clone(),
        move_target: None,
        width: 1, // TODO idk
        rewards: None,
        class_id: Some(character_state.character.class),
        team: fighting::EntityTeam::Ally,
        has_big_hp_bar: false,
        entity_template_id: None,
        // BAL-015: the gauge never carries between fights — every fight starts
        // at 0 (side and revision persist). The ch21 tutorial fight's 80% start
        // is BAL-024's fixture, not a seeding rule.
        flip_state: game_config
            .flip_settings
            .is_unlocked(character_state.character.current_chapter_level)
            .then_some(FlipState {
                progress: 0.0,
                ..flip_state
            }),
        // Every fight starts on a FULL pool and nothing carries over: the entity
        // is built fresh at `PrepareFight` and dropped with the fight.
        mana: Some(full_mana_pool(game_config)),
        proc_entropy: Default::default(),
        law_bridges: Default::default(),
        law_cores: Default::default(),
    };

    // Laws are side-dependent, so they cannot live in the shared attribute
    // aggregation the way the core multiplier does — they are folded into the
    // combat entity here, where the active side is known, and re-folded on
    // every flip and every rhythm change (`refresh_law_attributes`).
    seed_law_state(
        &mut entity,
        &character_state.cores,
        character_state.character.current_chapter_level,
        flip_state.active_side,
        game_config,
        &crate::mechanics::artifacts::law_column_mods(game_config, &character_state.artifacts),
    );
    seed_class_passive(
        &mut entity,
        game_config,
        character_state.character.class,
        &character_state.character_classes,
    );

    Ok(entity)
}

/// Bakes the combatant's class passive onto the entity: which rule they play
/// and how strong it is at their Class Level (BAL-033/BAL-034). Resolved per
/// combatant, so a party ally or a human PvP opponent plays THEIR class's rule,
/// never the session hero's.
fn seed_class_passive(
    entity: &mut entity::Entity,
    game_config: &game_config::GameConfig,
    class_id: essences::class::ClassId,
    character_classes: &[essences::class::CharacterClass],
) {
    let Some(class) = game_config.classes.iter().find(|c| c.id == class_id) else {
        return;
    };
    // Class Level is account-wide (BAL-034), so any row answers it; the rows
    // are kept in step by the level-up path.
    let class_level = character_classes
        .iter()
        .map(|row| row.level as i64)
        .max()
        .unwrap_or(1);
    crate::mechanics::class_passives::seed(entity, class, class_level);
}

/// Installs the combatant's whole law state on a freshly built combat entity —
/// the cores snapshot the fight runs on plus the bridge charges built from it —
/// and folds in the passive contribution of every law on the side that is
/// currently up. Charges always start empty and unamplified: a fight begins
/// with no Resonance banked and no law boosted.
///
/// This is the ONLY place the durable `CoresState` enters combat. Everything
/// afterwards (`law_attribute_snapshot`, `refresh_law_attributes`, the hooks in
/// `logic::laws`) reads `entity.law_cores`, which is what lets a PvP opponent
/// run on the same code path as the hero. It is also why the unlock gate is
/// checked here and nowhere downstream: a locked combatant keeps an empty
/// snapshot, and every law computation over an empty snapshot is already "no
/// contribution".
pub fn seed_law_state(
    entity: &mut entity::Entity,
    cores: &essences::cores::CoresState,
    chapter_level: i64,
    active_side: essences::flip::WorldSide,
    game_config: &game_config::GameConfig,
    mods: &crate::mechanics::artifacts::LawColumnMods,
) {
    if !game_config.cores_settings.is_unlocked(chapter_level) {
        return;
    }
    // The law contribution is folded in AFTER `max_hp` was composed from the
    // character alone, and the delta helper only ever clamps HP down. A
    // combatant built at full health must still be at full health once its HP
    // laws are in, or a fight with a max-HP law would start at a fraction of the
    // pool it displays.
    let was_full_hp = entity.hp >= entity.max_hp;

    entity.law_bridges =
        crate::mechanics::cores::build_law_bridge_charges(game_config, cores, mods);
    entity.law_cores = cores.clone();
    let next = law_attribute_snapshot(entity, active_side, game_config);
    apply_law_attribute_deltas(entity, &BTreeMap::new(), &next, game_config);

    if was_full_hp {
        entity.hp = entity.max_hp;
    }
}

/// The law contribution currently folded into `entity`'s attributes: the active
/// side's slotted laws at their current level, scaled by whatever their bridge
/// delivered at the last flip.
///
/// Callers that are about to overwrite the entity's attributes wholesale use
/// this to STRIP the contribution first and put it back afterwards — see
/// `logic::handler::compute_fields`. Stripping is not optional: the overwrite is
/// keyed by attribute code and only replaces codes the character itself carries
/// a non-zero value for, so a blind re-add would double-count every law that
/// moves a stat no other source touches.
///
/// Reads the entity's own cores snapshot, so what it reports is exactly what was
/// folded in — a strip can never subtract a contribution the entity never
/// received (which is what a live `CharacterState` lookup would do the moment a
/// player crossed the cores unlock chapter mid-fight).
pub fn law_attribute_snapshot(
    entity: &entity::Entity,
    active_side: essences::flip::WorldSide,
    game_config: &game_config::GameConfig,
) -> BTreeMap<String, i64> {
    crate::mechanics::cores::active_law_attribute_deltas(
        game_config,
        &entity.law_cores,
        active_side,
        &entity.law_bridges,
    )
}

/// Moves `entity`'s attributes from one law contribution to another. Passing an
/// empty `next` strips the contribution; passing an empty `previous` folds one
/// in.
pub fn apply_law_attribute_change(
    entity: &mut entity::Entity,
    previous: &BTreeMap<String, i64>,
    next: &BTreeMap<String, i64>,
    game_config: &game_config::GameConfig,
) {
    apply_law_attribute_deltas(entity, previous, next, game_config);
}

/// Recomputes the active side's law contribution and moves the entity's
/// attributes from the previous contribution to the new one. Called on a flip,
/// which changes both halves at once: which side is up AND how much charge each
/// law just received.
///
/// Entity-local from end to end: both the before and the after picture come out
/// of the combatant's own snapshot, which is what makes this correct for ANY
/// combatant — the hero, the party ally and a PvP opponent alike.
pub fn refresh_law_attributes(
    entity: &mut entity::Entity,
    previous_side: essences::flip::WorldSide,
    active_side: essences::flip::WorldSide,
    previous_charges: &essences::cores::LawBridgeCharges,
    game_config: &game_config::GameConfig,
) {
    let previous = crate::mechanics::cores::active_law_attribute_deltas(
        game_config,
        &entity.law_cores,
        previous_side,
        previous_charges,
    );
    let next = crate::mechanics::cores::active_law_attribute_deltas(
        game_config,
        &entity.law_cores,
        active_side,
        &entity.law_bridges,
    );
    apply_law_attribute_deltas(entity, &previous, &next, game_config);
}

/// Applies `next - previous` to the entity's attributes and re-derives `max_hp`
/// when an HP-shaped attribute moved, so a `hp`/`hp.mod` law is real in combat
/// rather than only on paper. Current HP is clamped, never raised: a law is a
/// stat change, not a heal.
fn apply_law_attribute_deltas(
    entity: &mut entity::Entity,
    previous: &BTreeMap<String, i64>,
    next: &BTreeMap<String, i64>,
    game_config: &game_config::GameConfig,
) {
    let mut touched_hp = false;
    let hp_code = game_config
        .attribute(game_config.game_settings.hp_attribute_id)
        .map(|attribute| attribute.code.clone())
        .unwrap_or_else(|| "hp".to_string());

    for code in previous
        .keys()
        .chain(next.keys())
        .cloned()
        .collect::<std::collections::BTreeSet<_>>()
    {
        let delta =
            next.get(&code).copied().unwrap_or(0) - previous.get(&code).copied().unwrap_or(0);
        if delta == 0 {
            continue;
        }
        if code == hp_code || code.starts_with(&format!("{hp_code}.")) {
            touched_hp = true;
        }
        entity.attributes.add(&code, delta);
    }

    if touched_hp && let Ok(max_hp) = compose_max_hp(&entity.attributes, game_config) {
        entity.max_hp = max_hp;
        entity.hp = entity.hp.min(max_hp);
    }
}

pub fn create_party_entity(
    character_state: &character_state::CharacterState,
    flip_state: FlipState,
    entity_id: uuid::Uuid,
    game_config: &game_config::GameConfig,
) -> anyhow::Result<entity::Entity> {
    let mut entity = create_player_entity(character_state, flip_state, entity_id, game_config)?;
    entity.coordinates = game_config.fight_settings.party_start_position.clone();
    Ok(entity)
}

pub fn create_pve_entity(
    entity_id: uuid::Uuid,
    fight_entity: &fighting::FightEntity,
    game_config: &game_config::GameConfig,
    entity_attributes: Option<EntityAttributes>,
) -> anyhow::Result<entity::Entity> {
    let entity_template_id = match fight_entity.entity_type {
        fighting::EntityType::PVEEntity { entity_template_id } => entity_template_id,
        fighting::EntityType::PVPEntity => {
            anyhow::bail!(
                "Wanted to create a PVE entity, but got a PVP entity = {:?}",
                fight_entity
            );
        }
    };

    let Some(entity) = game_config.entity_template(entity_template_id).cloned() else {
        anyhow::bail!(
            "Failed to find entity_template with id={}",
            entity_template_id
        )
    };

    let entity_abilities = entity
        .ability_ids
        .iter()
        .filter_map(|&ability_id| {
            let Some(entity_ability_template) = game_config.ability_template(ability_id) else {
                tracing::error!("Failed to get ability with ability_id={}", ability_id);
                return None;
            };

            let enemy_ability = abilities::Ability::from_template(
                entity_ability_template,
                /*level=*/ None,
                /*shards_amount=*/ None,
            );

            Some(abilities::ActiveAbility {
                ability: enemy_ability,
                deadline: None,
                slot_id: None,
            })
        })
        .collect();

    let entity_stats = if let Some(attributes) = entity_attributes {
        let max_hp = compose_max_hp(&attributes, game_config)?;
        EntityStats { attributes, max_hp }
    } else {
        let mut attributes_deltas = AttributeDeltas::new();
        for attribute in entity.attributes {
            *attributes_deltas.entry(attribute.attribute_id).or_insert(0) += attribute.value as i64;
        }

        calculate_entity_stats(game_config, attributes_deltas)?
    };

    Ok(entity::Entity {
        id: entity_id,
        max_hp: entity_stats.max_hp,
        hp: entity_stats.max_hp,
        abilities: entity_abilities,
        actions_queue: EntityActionsQueue::new(entity_id),
        attributes: entity_stats.attributes,
        effect_ids: Default::default(),
        coordinates: fight_entity.position.clone(),
        move_target: None,
        width: entity.width,
        rewards: Some(entity.rewards),
        class_id: None,
        team: fight_entity.team.clone(),
        has_big_hp_bar: fight_entity.has_big_hp_bar,
        entity_template_id: Some(entity_template_id),
        flip_state: None,
        // Mobs have no pool: their casts are never mana-gated.
        mana: None,
        proc_entropy: Default::default(),
        law_bridges: Default::default(),
        law_cores: Default::default(),
    })
}

pub fn create_pvp_entity(
    entity_state: &EntityState,
    flip_state: FlipState,
    fight_entity: &fighting::FightEntity,
    game_config: &game_config::GameConfig,
) -> anyhow::Result<entity::Entity> {
    if fight_entity.entity_type != fighting::EntityType::PVPEntity {
        anyhow::bail!(
            "Wanted to create a PVP entity, but got a PVE entity = {:?}",
            fight_entity
        );
    };

    let entity_stats = calculate_player_entity_stats_without_zeroes(entity_state, game_config)?;

    let abilities =
        make_active_abilities_from_equipped(entity_state.equipped_abilities(), game_config, false);

    let mut entity = entity::Entity {
        id: entity_state.id(),
        max_hp: entity_stats.max_hp,
        hp: entity_stats.max_hp,
        abilities,
        actions_queue: EntityActionsQueue::new(entity_state.id()),
        attributes: entity_stats.attributes,
        effect_ids: Default::default(),
        coordinates: fight_entity.position.clone(),
        move_target: None,
        width: 1, // TODO idk
        rewards: None,
        class_id: Some(entity_state.class()),
        team: fight_entity.team.clone(),
        has_big_hp_bar: fight_entity.has_big_hp_bar,
        entity_template_id: None,
        // BAL-015: same per-fight gauge reset as the hero — no combatant
        // starts a fight with carried-over progress.
        flip_state: game_config
            .flip_settings
            .is_unlocked(entity_state.current_chapter_level())
            .then_some(FlipState {
                progress: 0.0,
                ..flip_state
            }),
        // PvP is symmetric: the opponent fights on the same full pool.
        mana: Some(full_mana_pool(game_config)),
        proc_entropy: Default::default(),
        law_bridges: Default::default(),
        law_cores: Default::default(),
    };

    // A human PvP opponent carries their own laws AND their own bridge rhythms.
    // The whole law state is seeded onto the entity here and every mid-fight law
    // lookup reads it from the entity, so the opponent advances, enhances and
    // resets on exactly the same rules as the local hero — the fight is decided
    // by running both builds, not by privileging whoever owns the session.
    //
    // The opponent arrives as `EntityState::Opponent`, never as
    // `EntityState::Character`, so this has to go through `cores()`: an arena
    // filler bot has no `CharacterState` and gets `None`, fighting lawless.
    if let Some(cores) = entity_state.cores() {
        // A human opponent's snapshot carries their whole CharacterState, so
        // their own artifact right column modifies their bridges exactly as
        // the local hero's does; an arena filler bot has neither cores nor
        // artifacts and fights at the configured capacity and ceiling.
        let mods = entity_state
            .artifacts()
            .map(|artifacts| crate::mechanics::artifacts::law_column_mods(game_config, artifacts))
            .unwrap_or(crate::mechanics::artifacts::LawColumnMods::NONE);
        seed_law_state(
            &mut entity,
            cores,
            entity_state.current_chapter_level(),
            flip_state.active_side,
            game_config,
            &mods,
        );
    }
    // Same for the passive: an opponent plays their own class's rule at their
    // own Class Level, and a filler bot with no class rows plays none.
    seed_class_passive(
        &mut entity,
        game_config,
        entity_state.class(),
        entity_state.character_classes().unwrap_or_default(),
    );

    Ok(entity)
}

/// The durable `CharacterState` behind combatant `entity_id` in this session's
/// fight — the local hero's, the party ally's, or a human PvP opponent's.
/// `None` for mobs and for arena filler bots, which have no `CharacterState`.
///
/// Takes the sibling `OverlordState` fields separately so a caller can keep
/// borrowing `active_fight` mutably while the returned build is alive.
pub fn combatant_character_state<'a>(
    character_state: &'a character_state::CharacterState,
    party: &'a crate::party::Party,
    pvp_state: &'a Option<essences::pvp::PVPState>,
    fight: &fighting::ActiveFight,
    entity_id: EntityId,
) -> Option<&'a character_state::CharacterState> {
    if fight.player_id == entity_id {
        return Some(character_state);
    }
    if fight.party_player_id == Some(entity_id) {
        return party.party_state.as_ref();
    }
    if let Some(pvp) = pvp_state
        && pvp.opponent_state.id() == entity_id
    {
        return pvp.opponent_state.character_state();
    }
    None
}

/// [`combatant_character_state`] reading straight off one `&OverlordState`.
/// Use where no mutable borrow of the state is alive; hooks that interleave
/// mutable fight borrows call the field-split variant instead.
pub fn combatant_character_state_of(
    state: &OverlordState,
    entity_id: EntityId,
) -> Option<&character_state::CharacterState> {
    let fight = state.active_fight.as_ref()?;
    combatant_character_state(
        &state.character_state,
        &state.party,
        &state.pvp_state,
        fight,
        entity_id,
    )
}

/// Mirrors a combatant's fight-local `FlipState` into the matching durable
/// copy: the session's own for the hero, the party / PvP snapshots for the
/// others (those never persist past the viewer's fight).
pub fn mirror_combatant_flip_state(
    state: &mut OverlordState,
    entity_id: EntityId,
    snapshot: FlipState,
) {
    let Some(fight) = state.active_fight.as_ref() else {
        return;
    };
    if fight.player_id == entity_id {
        state.flip_state = snapshot;
    } else if fight.party_player_id == Some(entity_id) {
        state.party.party_flip_state = Some(snapshot);
    } else if let Some(pvp) = state.pvp_state.as_mut()
        && pvp.opponent_state.id() == entity_id
    {
        pvp.opponent_flip_state = snapshot;
    }
}

/// The flip bar combatant `entity_id` plays against: `ART-03 Halfway Bell`
/// lowers it for the combatant WEARING the bell, resolved from that
/// combatant's own artifacts. A combatant with no `CharacterState` plays at
/// the configured threshold.
pub fn combatant_flip_threshold(
    state: &OverlordState,
    entity_id: EntityId,
    game_config: &game_config::GameConfig,
) -> f64 {
    match combatant_character_state_of(state, entity_id) {
        Some(build) => crate::mechanics::artifacts::flip_threshold(game_config, &build.artifacts),
        None => game_config.flip_settings.progress_threshold,
    }
}

/// Rebuilds the event a drained queue entry stands for, carrying the
/// provenance the entry was queued with.
///
/// The queue is a real hop in a modifier's cascade — the work comes back one or
/// more ticks after the producing dispatch ended — so this is where the mark
/// would be lost if the entry did not carry it.
pub fn event_from_entity_action(
    action: EntityAction,
    entity_id: EntityId,
    origin: CombatEventOrigin,
) -> EventPluginized<OverlordEvent, OverlordState> {
    match action {
        EntityAction::CastEffect {
            entity_id,
            effect_id,
        } => EventPluginized::now(OverlordEvent::CastEffect {
            origin,
            entity_id,
            effect_id,
        }),
        EntityAction::CastAbility {
            ability_id,
            target_entity_id,
        } => EventPluginized::now(OverlordEvent::CastAbility {
            origin,
            by_entity_id: entity_id,
            to_entity_id: target_entity_id,
            ability_id,
        }),
        EntityAction::CastBasicAbility {
            ability_id,
            target_entity_id,
        } => EventPluginized::now(OverlordEvent::CastAbility {
            origin,
            by_entity_id: entity_id,
            to_entity_id: target_entity_id,
            ability_id,
        }),
        EntityAction::StartCastAbility {
            ability_id,
            by_entity_id,
            pet_id,
        } => EventPluginized::now(OverlordEvent::StartCastAbility {
            origin,
            by_entity_id,
            ability_id,
            pet_id,
        }),
    }
}

/// BAL-026: stamps each initial combatant's `gauge_hp_share` — its share of
/// its own team's max-HP budget at this roster snapshot. The outgoing damage
/// gauge multiplies by the VICTIM's share, so removing a whole roster is worth
/// the same gauge whatever its size. Deaths never re-normalize the stamped
/// denominator, and summons are skipped (`gauge_hp_share()` reads them as 0).
/// Wave mobs are stamped by `mechanics::fight::spawn_wave` instead — this
/// covers the roster built directly at fight start.
pub fn stamp_gauge_hp_shares(entities: &mut [entity::Entity]) {
    for team in [fighting::EntityTeam::Ally, fighting::EntityTeam::Enemy] {
        let total: u64 = entities
            .iter()
            .filter(|e| e.team == team && !e.attributes.is_summoned())
            .map(|e| e.max_hp)
            .sum();
        if total == 0 {
            // BAL-026: an eligible roster with no HP is an invalid fixture. It
            // must be worth ZERO outgoing gauge, so stamp explicit zeros —
            // leaving the entities unstamped would fall back to
            // `gauge_hp_share()`'s full-share default instead.
            let mut stamped_any = false;
            for entity in entities
                .iter_mut()
                .filter(|e| e.team == team && !e.attributes.is_summoned())
            {
                // -1 is the explicit zero-share marker: the attribute map
                // drops literal zeros, and absent reads as full share.
                entity.attributes.set("gauge_hp_share", -1);
                stamped_any = true;
            }
            if stamped_any {
                tracing::error!(
                    ?team,
                    "gauge_hp_share: eligible initial roster has zero total max_hp; \
                     outgoing gauge for this side is disabled"
                );
            }
            continue;
        }
        for entity in entities
            .iter_mut()
            .filter(|e| e.team == team && !e.attributes.is_summoned())
        {
            let share = (entity.max_hp as f64 / total as f64 * 10_000.0).round() as i64;
            entity.attributes.add("gauge_hp_share", share);
        }
    }
}