overlord_event_system/

bundles.rs

use configs::game_config::GameConfig;
use essences::{
    bundles::{BundleAbility, BundleElement, BundleRaw, BundleRawStep, BundleStepType},
    character_state::CharacterState,
    currency::from_es_currencies,
    items::Item,
};

use event_system::script::random::GameRng;

use crate::{
    BehaviorRegistry, cases::try_finalize_item, gacha::item_case::generate_item_from_template,
    game_config_helpers::GameConfigLookup,
};
use rand::SeedableRng;

/// Drops everything a stored bundle references that no longer exists in the
/// live config, and returns `None` when nothing claimable is left.
///
/// Config bundles are looked up by id and re-read from `GameConfig` on every
/// load, so they cannot go stale. Operator-composed gifts have no config entry
/// — they are snapshots persisted with the mail and with the character_bundles
/// row — so an item template, ability or currency removed from the config
/// after the gift was sent would otherwise be granted as a dangling id. Item
/// and ability steps already skip unknown ids when they are turned into
/// elements; currencies do not, and an emptied step would still produce an
/// empty reward popup. Both are handled here.
pub fn sanitize_bundle_for_config(
    bundle: &BundleRaw,
    game_config: &GameConfig,
) -> Option<BundleRaw> {
    let steps: Vec<BundleRawStep> = bundle
        .steps
        .iter()
        .filter_map(|step| sanitize_step_for_config(step, game_config))
        .collect();

    if steps.is_empty() {
        return None;
    }

    Some(BundleRaw {
        id: bundle.id,
        steps,
        claim_mode: bundle.claim_mode,
    })
}

/// One step of [`sanitize_bundle_for_config`]. `None` means the step lost all
/// of its content and must be dropped from the bundle.
fn sanitize_step_for_config(
    step: &BundleRawStep,
    game_config: &GameConfig,
) -> Option<BundleRawStep> {
    let mut step = step.clone();

    match step.item_type {
        BundleStepType::Currency => {
            let known = |unit: &essences::currency::CurrencyUnit| {
                game_config
                    .currencies
                    .iter()
                    .any(|currency| currency.id == unit.currency_id)
            };

            step.currencies.retain(known);
            if let Some(branch) = &mut step.currency_branch {
                for case in &mut branch.branches {
                    case.currencies.retain(known);
                }
                branch.branches.retain(|case| !case.currencies.is_empty());
                branch.default.retain(known);
            }

            let has_branch = step
                .currency_branch
                .as_ref()
                .is_some_and(|branch| !branch.branches.is_empty() || !branch.default.is_empty());

            if step.currencies.is_empty() && !has_branch && step.behavior.is_none() {
                return None;
            }
        }
        BundleStepType::Ability => {
            step.shards
                .retain(|shard| game_config.ability_template(shard.ability_id).is_some());
            if step.shards.is_empty() {
                return None;
            }
        }
        BundleStepType::Item => {
            step.item_template_ids.retain(|&item_id| {
                game_config
                    .item_template(item_id)
                    .is_some_and(|template| game_config.item_rarity(template.rarity_id).is_some())
            });
            if step.item_template_ids.is_empty() {
                return None;
            }
        }
        BundleStepType::Artifact => {
            step.artifact_template_ids.retain(|artifact_id| {
                game_config
                    .artifacts
                    .iter()
                    .any(|template| template.id == *artifact_id)
            });
            if step.artifact_template_ids.is_empty() {
                return None;
            }
        }
    }

    Some(step)
}

pub fn bundle_raw_step_to_element(
    raw_item: &BundleRawStep,
    character_state: &CharacterState,
    behaviors: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    match raw_item.item_type {
        BundleStepType::Currency => {
            process_currency(raw_item, character_state, behaviors, game_config)
        }
        BundleStepType::Ability => {
            process_ability(raw_item, character_state, behaviors, game_config)
        }
        BundleStepType::Item => process_item(raw_item, character_state, behaviors, game_config),
        BundleStepType::Artifact => process_artifact(raw_item, game_config),
    }
}

pub fn bundle_raw_afk_step_to_element(
    raw_item: &BundleRawStep,
    character_state: &CharacterState,
    now: chrono::DateTime<chrono::Utc>,
    apply_afk_boost: bool,
    behaviors: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    match raw_item.item_type {
        BundleStepType::Currency => process_afk_currency(
            raw_item,
            character_state,
            now,
            apply_afk_boost,
            behaviors,
            game_config,
        ),
        BundleStepType::Ability => {
            process_afk_ability(raw_item, character_state, now, behaviors, game_config)
        }
        BundleStepType::Item => {
            process_afk_item(raw_item, character_state, now, behaviors, game_config)
        }
        // No afk-specific variant: an artifact step is a fixed id list with no
        // roll, no rarity and no per-claim RNG, so the two paths cannot differ.
        BundleStepType::Artifact => process_artifact(raw_item, game_config),
    }
}

/// Bundle `artifact` step: the typed id list from the config, filtered to the
/// catalog.
///
/// Unknown ids are dropped with a log rather than granted: a dangling template
/// would reach `grant_artifact` and create a collection row pointing at nothing,
/// which every artifact read then has to tolerate forever.
fn process_artifact(raw_item: &BundleRawStep, game_config: &GameConfig) -> BundleElement {
    let artifacts = raw_item
        .artifact_template_ids
        .iter()
        .filter(|artifact_id| {
            let known = game_config
                .artifacts
                .iter()
                .any(|template| template.id == **artifact_id);
            if !known {
                tracing::error!("Bundle step references unknown artifact {artifact_id}");
            }
            known
        })
        .copied()
        .collect();

    BundleElement::Artifacts(artifacts)
}

/// Bundle `currencies` step: fixed list, custom-values branch, or the
/// config-named native fn, in that order. Empty result if none is set.
fn process_currency(
    raw_item: &BundleRawStep,
    character_state: &CharacterState,
    behaviors: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    // Fixed and branch rewards live in the config (single source of truth for
    // server + client); only non-fixed steps (afk accrual) fall back to a
    // native `currencies` fn.
    if !raw_item.currencies.is_empty() {
        return BundleElement::Currencies(raw_item.currencies.clone());
    }
    if let Some(branch) = &raw_item.currency_branch {
        return BundleElement::Currencies(branch.evaluate(character_state).clone());
    }

    let es_currencies = raw_item
        .behavior
        .as_deref()
        .and_then(|name| behaviors.currencies_fn(name))
        .map(|f| {
            f(&crate::behaviors::rewards::RewardCtx {
                character: Some(character_state),
                last_claim_at: None,
                now: None,
                rng: None,
                apply_afk_boost: false,
                config: game_config,
                lookups: behaviors.lookups(),
            })
        })
        .transpose()
        .unwrap_or_else(|e| {
            tracing::error!("Failed to run native currencies bundle step: {e}");
            None
        })
        .unwrap_or_default();

    BundleElement::Currencies(from_es_currencies(&es_currencies))
}

/// Native afk `currencies` step. The afk port draws against a `StdRng` seeded
/// from `afk_reward_seed` (via `util::rand_weight`) and reads the
/// `LastClaimAt`/`Now` constants.
fn process_afk_currency(
    raw_item: &BundleRawStep,
    character_state: &CharacterState,
    now: chrono::DateTime<chrono::Utc>,
    apply_afk_boost: bool,
    behaviors: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    let last_claim_at = character_state
        .character
        .last_afk_reward_claimed_at
        .timestamp()
        .max(0) as u64;
    let now_secs = now.timestamp().max(0) as u64;
    let afk_seed = character_state.character.afk_reward_seed;
    let rng = GameRng::new(rand::rngs::StdRng::seed_from_u64(afk_seed));

    let es_currencies = raw_item
        .behavior
        .as_deref()
        .and_then(|name| behaviors.currencies_fn(name))
        .map(|f| {
            f(&crate::behaviors::rewards::RewardCtx {
                character: Some(character_state),
                last_claim_at: Some(last_claim_at),
                now: Some(now_secs),
                rng: Some(&rng),
                apply_afk_boost,
                config: game_config,
                lookups: behaviors.lookups(),
            })
        })
        .transpose()
        .unwrap_or_else(|e| {
            tracing::error!("Failed to run native afk currencies bundle step: {e}");
            None
        })
        .unwrap_or_default();

    BundleElement::Currencies(from_es_currencies(&es_currencies))
}

/// Bundle `ability_shards` step: the typed `shards` list from the config.
fn process_ability(
    raw_item: &BundleRawStep,
    _character_state: &CharacterState,
    _script_runner: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    BundleElement::Abilities(build_abilities(&raw_item.shards, game_config))
}

/// Afk `ability_shards` step — same typed `shards` list as the regular path.
fn process_afk_ability(
    raw_item: &BundleRawStep,
    _character_state: &CharacterState,
    _now: chrono::DateTime<chrono::Utc>,
    _script_runner: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    BundleElement::Abilities(build_abilities(&raw_item.shards, game_config))
}

fn build_abilities(
    shards: &[essences::bundles::BundleShardAmount],
    game_config: &GameConfig,
) -> Vec<BundleAbility> {
    shards
        .iter()
        .filter_map(|shard| {
            let Some(template) = game_config.ability_template(shard.ability_id).cloned() else {
                tracing::error!("Failed to get ability with ability_id={}", shard.ability_id);
                return None;
            };

            Some(BundleAbility {
                template,
                shards_amount: shard.amount,
            })
        })
        .collect()
}

fn process_item(
    raw_item: &BundleRawStep,
    character_state: &CharacterState,
    behaviors: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    let items: Vec<Item> = raw_item
        .item_template_ids
        .iter()
        .filter_map(|&item_id| {
            let Some(template) = game_config.item_template(item_id) else {
                tracing::error!("Failed to get item template with item_id={}", item_id);
                return None;
            };

            let Some(rarity) = game_config.item_rarity(template.rarity_id).cloned() else {
                tracing::error!("Failed to get item rarity with id={}", template.rarity_id);
                return None;
            };

            Some(generate_item_from_template(
                template,
                rarity,
                character_state.character.character_level,
                // Not a chest roll: keep the template's own count.
                template.attributes_settings.optional_attributes_count,
                game_config,
                &mut rand::rngs::StdRng::try_from_rng(&mut rand::rngs::SysRng)
                    .expect("OS entropy unavailable"),
            ))
        })
        .collect();

    let expires_at = item_ttl_expires_at(raw_item, ::time::utc_now());
    let finalized_items = items
        .into_iter()
        .filter_map(|mut item| {
            match try_finalize_item(&mut item, game_config, behaviors, &GameRng::from_entropy()) {
                Ok(()) => {
                    item.expires_at = expires_at;
                    Some(item)
                }
                Err(e) => {
                    tracing::error!("Failed to finalize item: {}", e);
                    None
                }
            }
        })
        .collect();

    BundleElement::Items(finalized_items)
}

/// Момент истечения временных предметов шага: `now + item_ttl_seconds`.
/// `None`, если у шага нет TTL (предметы постоянные).
fn item_ttl_expires_at(
    raw_item: &BundleRawStep,
    now: chrono::DateTime<chrono::Utc>,
) -> Option<chrono::DateTime<chrono::Utc>> {
    raw_item
        .item_ttl_seconds
        .map(|secs| now + chrono::Duration::seconds(secs))
}

fn process_afk_item(
    raw_item: &BundleRawStep,
    character_state: &CharacterState,
    now: chrono::DateTime<chrono::Utc>,
    behaviors: &BehaviorRegistry,
    game_config: &GameConfig,
) -> BundleElement {
    let items: Vec<Item> = raw_item
        .item_template_ids
        .iter()
        .filter_map(|&item_id| {
            let Some(template) = game_config.item_template(item_id) else {
                tracing::error!("Failed to get item template with item_id={}", item_id);
                return None;
            };

            let Some(rarity) = game_config.item_rarity(template.rarity_id).cloned() else {
                tracing::error!("Failed to get item rarity with id={}", template.rarity_id);
                return None;
            };

            Some(generate_item_from_template(
                template,
                rarity,
                character_state.character.character_level,
                // Not a chest roll: keep the template's own count.
                template.attributes_settings.optional_attributes_count,
                game_config,
                &mut rand::rngs::StdRng::seed_from_u64(character_state.character.afk_reward_seed),
            ))
        })
        .collect();

    let expires_at = item_ttl_expires_at(raw_item, now);
    let finalized_items = items
        .into_iter()
        .filter_map(|mut item| {
            match try_finalize_item(&mut item, game_config, behaviors, &GameRng::from_entropy()) {
                Ok(()) => {
                    item.expires_at = expires_at;
                    Some(item)
                }
                Err(e) => {
                    tracing::error!("Failed to finalize item: {}", e);
                    None
                }
            }
        })
        .collect();

    BundleElement::Items(finalized_items)
}

#[cfg(test)]
mod tests {
    use super::*;
    use essences::bundles::{BundleClaimMode, BundleStepType};

    fn config() -> GameConfig {
        configs::tests_game_config::generate_game_config_for_tests()
    }

    fn artifact_step(ids: Vec<uuid::Uuid>) -> BundleRawStep {
        BundleRawStep {
            item_type: BundleStepType::Artifact,
            currencies: vec![],
            currency_branch: None,
            behavior: None,
            shards: vec![],
            item_template_ids: vec![],
            artifact_template_ids: ids,
            item_ttl_seconds: None,
            has_pop_up: true,
        }
    }

    fn behaviors(config: &GameConfig) -> BehaviorRegistry {
        BehaviorRegistry::new(config)
    }

    /// Sanitize keeps the ids the catalog still has. An operator gift or a
    /// stored mail is a SNAPSHOT — the artifact it names can be deleted from the
    /// config after it is sent, and a dangling id would reach `grant_artifact`
    /// and create a collection row pointing at nothing.
    #[test]
    fn sanitize_retains_only_catalog_artifacts() {
        let config = config();
        let known = config.artifacts[0].id;
        let unknown = uuid::Uuid::from_u128(0xDEAD);

        let step = sanitize_step_for_config(&artifact_step(vec![known, unknown]), &config)
            .expect("a step keeping one known artifact must survive");
        assert_eq!(step.artifact_template_ids, vec![known]);
    }

    /// ...and a step that loses every id is dropped whole, so the claim does not
    /// produce an empty reward popup.
    #[test]
    fn sanitize_drops_a_step_with_no_known_artifact() {
        let config = config();
        let unknown = uuid::Uuid::from_u128(0xDEAD);
        assert!(sanitize_step_for_config(&artifact_step(vec![unknown]), &config).is_none());
        assert!(sanitize_step_for_config(&artifact_step(vec![]), &config).is_none());
    }

    /// A bundle whose only step is an all-unknown artifact step has nothing left
    /// to claim, so the whole bundle goes.
    #[test]
    fn sanitize_drops_a_bundle_left_with_nothing() {
        let config = config();
        let bundle = BundleRaw {
            id: uuid::Uuid::from_u128(1),
            steps: vec![artifact_step(vec![uuid::Uuid::from_u128(0xDEAD)])],
            claim_mode: BundleClaimMode::AllAtOnce,
        };
        assert!(sanitize_bundle_for_config(&bundle, &config).is_none());
    }

    /// The element conversion carries the ids through untouched.
    #[test]
    fn an_artifact_step_becomes_an_artifacts_element() {
        let config = config();
        let behaviors = behaviors(&config);
        let character = CharacterState::default();
        let ids: Vec<_> = config.artifacts.iter().map(|a| a.id).collect();
        assert!(
            ids.len() > 1,
            "the fixture must ship more than one artifact"
        );

        let element = bundle_raw_step_to_element(
            &artifact_step(ids.clone()),
            &character,
            &behaviors,
            &config,
        );
        assert_eq!(element, BundleElement::Artifacts(ids));
    }

    /// The afk path must agree with the regular one: an artifact step has no
    /// roll, no rarity and no per-claim RNG, so the two cannot legitimately
    /// differ — and a divergence would mean an afk-claimed artifact behaved
    /// differently from a quest-claimed one.
    #[test]
    fn the_afk_path_converts_an_artifact_step_identically() {
        let config = config();
        let behaviors = behaviors(&config);
        let character = CharacterState::default();
        let step = artifact_step(vec![config.artifacts[0].id]);

        let regular = bundle_raw_step_to_element(&step, &character, &behaviors, &config);
        let afk = bundle_raw_afk_step_to_element(
            &step,
            &character,
            ::time::utc_now(),
            true,
            &behaviors,
            &config,
        );
        assert_eq!(regular, afk);
    }

    /// An unknown id is dropped at conversion time too, not just by sanitize —
    /// config bundles are re-read from `GameConfig` on every load and never pass
    /// through sanitize at all.
    #[test]
    fn conversion_drops_an_unknown_artifact_id() {
        let config = config();
        let behaviors = behaviors(&config);
        let character = CharacterState::default();
        let known = config.artifacts[0].id;

        let element = bundle_raw_step_to_element(
            &artifact_step(vec![known, uuid::Uuid::from_u128(0xDEAD)]),
            &character,
            &behaviors,
            &config,
        );
        assert_eq!(element, BundleElement::Artifacts(vec![known]));
    }
}