overlord_event_system/

entities.rs

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

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

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

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
}

pub fn create_player_entity(
    character_state: &character_state::CharacterState,
    entity_id: uuid::Uuid,
    game_config: &game_config::GameConfig,
    script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
) -> anyhow::Result<entity::Entity> {
    let entity_stats = calculate_player_entity_stats_without_zeroes(
        &EntityState::Character(character_state),
        game_config,
        script_runner,
    )?;

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

    // Add leader pet's active ability if present
    if let Some(leader_pet) = character_state.equipped_pets.leader()
        && let Some(ability_template) = leader_pet
            .active_ability_id
            .and_then(|id| game_config.ability_template(id))
    {
        let pet_ability = abilities::Ability::from_template(ability_template, None, None);
        entity_abilities.push(abilities::ActiveAbility {
            ability: pet_ability,
            deadline: None,
            slot_id: None,
        });
    }

    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: game_config.fight_settings.player_start_position.clone(),
        being_moved: false,
        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,
    })
}

pub fn create_party_entity(
    character_state: &character_state::CharacterState,
    entity_id: uuid::Uuid,
    game_config: &game_config::GameConfig,
    script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
) -> anyhow::Result<entity::Entity> {
    let mut entity = create_player_entity(character_state, entity_id, game_config, script_runner)?;
    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 mut max_hp = 0;
        let Some(config_max_hp_attribute) =
            game_config.attribute(game_config.game_settings.hp_attribute_id)
        else {
            anyhow::bail!(
                "Couldn't find max_hp attribute with id = {}",
                game_config.game_settings.hp_attribute_id
            );
        };

        for (code, value) in &attributes.0 {
            if *code == config_max_hp_attribute.code {
                max_hp += *value as u64
            }
        }
        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(),
        being_moved: false,
        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),
    })
}

pub fn create_pvp_entity(
    entity_state: &EntityState,
    fight_entity: &fighting::FightEntity,
    game_config: &game_config::GameConfig,
    script_runner: &ScriptRunner<OverlordEvent, OverlordState>,
) -> 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, script_runner)?;

    Ok(entity::Entity {
        id: entity_state.id(),
        max_hp: entity_stats.max_hp,
        hp: entity_stats.max_hp,
        abilities: make_active_abilities_from_equipped(
            entity_state.equipped_abilities(),
            game_config,
            false,
        ),
        actions_queue: EntityActionsQueue::new(entity_state.id()),
        attributes: entity_stats.attributes,
        effect_ids: Default::default(),
        coordinates: fight_entity.position.clone(),
        being_moved: false,
        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,
    })
}

pub fn event_from_entity_action(
    action: EntityAction,
    entity_id: EntityId,
) -> EventPluginized<OverlordEvent, OverlordState> {
    match action {
        EntityAction::CastEffect {
            entity_id,
            effect_id,
        } => EventPluginized::now(OverlordEvent::CastEffect {
            entity_id,
            effect_id,
        }),
        EntityAction::CastAbility {
            ability_id,
            target_entity_id,
        } => EventPluginized::now(OverlordEvent::CastAbility {
            by_entity_id: entity_id,
            to_entity_id: target_entity_id,
            ability_id,
        }),
        EntityAction::CastBasicAbility {
            ability_id,
            target_entity_id,
        } => EventPluginized::now(OverlordEvent::CastAbility {
            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 {
            by_entity_id,
            ability_id,
            pet_id,
        }),
    }
}