overlord_event_system/gacha/

ability_case.rs

use configs::abilities::AbilityCasesSettingsByLevel;
use configs::game_config::GameConfig;
use essences::abilities::{AbilityId, AbilityRarityId, AbilityTemplate};
use essences::character_state::CharacterState;

use rand::{Rng, rngs::StdRng};
use std::collections::HashSet;

use crate::game_config_helpers::GameConfigLookup;

pub fn open_ability_case(
    character_state: &CharacterState,
    config: &GameConfig,
    rng: &mut StdRng,
) -> anyhow::Result<AbilityId> {
    open_ability_case_with_wishlist(character_state, config, rng, &[])
}

pub fn open_ability_case_with_wishlist(
    character_state: &CharacterState,
    config: &GameConfig,
    rng: &mut StdRng,
    wishlist: &[AbilityId],
) -> anyhow::Result<AbilityId> {
    let ability_cases_settings = &config.ability_cases_settings;

    let Some(level_settings) = ability_cases_settings
        .iter()
        .find(|settings| settings.level == character_state.character.ability_case_level)
    else {
        anyhow::bail!(
            "Failed to get case settings for ability_case_level={}",
            character_state.character.ability_case_level
        );
    };

    let rarity_id = get_ability_rarity_id(rng, level_settings);

    for class in &config.classes {
        if rarity_id == class.ability_rarity_id {
            anyhow::bail!("Case ability can not be class rarity");
        }
    }

    let ability_id = open_ability_case_with_rarity_and_wishlist(config, rarity_id, rng, wishlist)?;

    Ok(ability_id)
}

pub fn open_ability_case_with_rarity_and_wishlist(
    config: &GameConfig,
    rarity_id: AbilityRarityId,
    rng: &mut StdRng,
    wishlist: &[AbilityId],
) -> anyhow::Result<AbilityId> {
    let wishlist: HashSet<_> = wishlist.iter().copied().collect();
    let wishlist_multiplier = config
        .game_settings
        .ability_gacha
        .wishlist_weight_multiplier
        .get();

    let abilities_pool: Vec<AbilityTemplate> = config
        .abilities
        .iter()
        .filter(|ability| ability.is_gacha_ability && ability.rarity_id == rarity_id)
        .cloned()
        .collect();

    if abilities_pool.is_empty() {
        anyhow::bail!("No gacha abilities found for rarity_id={rarity_id}");
    }

    let total_weight: f64 = abilities_pool
        .iter()
        .map(|ability| {
            if wishlist.contains(&ability.id) {
                wishlist_multiplier
            } else {
                1.0
            }
        })
        .sum();

    if total_weight <= 0.0 {
        anyhow::bail!("Failed to compute ability pool weights for rarity_id={rarity_id}");
    }

    let mut pick = rng.random_range(0.0..total_weight);

    for ability in &abilities_pool {
        let weight = if wishlist.contains(&ability.id) {
            wishlist_multiplier
        } else {
            1.0
        };
        if pick <= weight {
            return Ok(ability.id);
        }
        pick -= weight;
    }

    anyhow::bail!("Failed to pick ability for rarity_id={rarity_id}")
}

pub fn get_ability_rarity_id(
    rng: &mut StdRng,
    level_settings: &AbilityCasesSettingsByLevel,
) -> AbilityRarityId {
    let total_weight: f64 = level_settings
        .rarity_weights
        .iter()
        .map(|rarity_weight| rarity_weight.weight.get())
        .sum();

    if total_weight < 1e-10 {
        panic!("Sum of weights is too low: {total_weight}");
    }

    let rnd_weight = rng.random_range(0.0..total_weight);

    let mut cumulative_weight = 0.0;
    for rarity_weight in &level_settings.rarity_weights {
        cumulative_weight += rarity_weight.weight.get();
        if rnd_weight < cumulative_weight {
            return rarity_weight.rarity_id;
        }
    }

    panic!("Failed to get ability rarity id for weight {rnd_weight}");
}

/// Roll a rarity from the level's weights, but exclude rarities below `min_rarity_id`.
/// The "order" field on AbilityRarity determines the ordering (higher = rarer).
pub fn roll_rarity_with_minimum(
    config: &GameConfig,
    level_settings: &AbilityCasesSettingsByLevel,
    min_rarity_id: AbilityRarityId,
    rng: &mut StdRng,
) -> anyhow::Result<AbilityRarityId> {
    let min_order = config
        .ability_rarity(min_rarity_id)
        .map(|r| r.order)
        .unwrap_or(0);

    let filtered_weights: Vec<_> = level_settings
        .rarity_weights
        .iter()
        .filter(|rw| {
            config
                .ability_rarity(rw.rarity_id)
                .map(|r| r.order >= min_order)
                .unwrap_or(false)
        })
        .collect();

    if filtered_weights.is_empty() {
        anyhow::bail!(
            "No rarity weights found at or above min_rarity_id={min_rarity_id} for level={}",
            level_settings.level
        );
    }

    let total_weight: f64 = filtered_weights.iter().map(|rw| rw.weight.get()).sum();

    if total_weight < 1e-10 {
        anyhow::bail!("Sum of filtered rarity weights is too low: {total_weight}");
    }

    let rnd_weight = rng.random_range(0.0..total_weight);

    let mut cumulative_weight = 0.0;
    for rw in &filtered_weights {
        cumulative_weight += rw.weight.get();
        if rnd_weight < cumulative_weight {
            return Ok(rw.rarity_id);
        }
    }

    Ok(filtered_weights.last().unwrap().rarity_id)
}

pub fn maybe_get_ability_rarity_id_by_chance(
    rng: &mut StdRng,
    rarity_weights: &[configs::abilities::AbilityCaseRarityWeight],
) -> Option<AbilityRarityId> {
    if rarity_weights.is_empty() {
        return None;
    }

    let total_weight: f64 = rarity_weights
        .iter()
        .map(|rarity_weight| rarity_weight.weight.get())
        .sum();

    if total_weight <= 0.0 {
        return None;
    }

    let rnd_weight = rng.random_range(0.0..1.0);

    let mut cumulative_weight = 0.0;
    for rarity_weight in rarity_weights {
        cumulative_weight += rarity_weight.weight.get();
        if rnd_weight < cumulative_weight {
            return Some(rarity_weight.rarity_id);
        }
    }

    None
}

pub fn get_ability_rarity_id_by_weights(
    rng: &mut StdRng,
    rarity_weights: &[configs::abilities::AbilityCaseRarityWeight],
) -> anyhow::Result<AbilityRarityId> {
    if rarity_weights.is_empty() {
        anyhow::bail!("Rarity weights are empty");
    }

    let total_weight: f64 = rarity_weights
        .iter()
        .map(|rarity_weight| rarity_weight.weight.get())
        .sum();

    if total_weight < 1e-10 {
        anyhow::bail!("Sum of rarity weights is too low: {total_weight}");
    }

    let rnd_weight = rng.random_range(0.0..total_weight);

    let mut cumulative_weight = 0.0;
    for rarity_weight in rarity_weights {
        cumulative_weight += rarity_weight.weight.get();
        if rnd_weight < cumulative_weight {
            return Ok(rarity_weight.rarity_id);
        }
    }

    anyhow::bail!("Failed to pick rarity by weight")
}

#[cfg(test)]
mod tests {
    use super::*;
    use configs::abilities::AbilityCaseRarityWeight;
    use configs::tests_game_config::generate_game_config_for_tests;
    use rand::SeedableRng;
    use std::collections::HashMap;
    use uuid::uuid;

    // Test config rarity IDs:
    // common  = 33a0af72  (order 1, weight 256)
    // uncommon = 6f0f1099 (order 2, weight 128)
    // rare    = 81b082cc  (order 3, weight 64)
    const COMMON: AbilityRarityId = uuid!("33a0af72-2390-4df9-bd4f-f66b27ed7792");
    const UNCOMMON: AbilityRarityId = uuid!("6f0f1099-8ab1-4378-aea5-ac6bcbe6ec3e");
    const RARE: AbilityRarityId = uuid!("81b082cc-2736-4545-87d1-301f5de8951a");

    fn make_weights(pairs: &[(AbilityRarityId, f64)]) -> Vec<AbilityCaseRarityWeight> {
        pairs
            .iter()
            .map(|(id, w)| AbilityCaseRarityWeight {
                rarity_id: *id,
                weight: configs::validated_types::PositiveF64::new(*w),
            })
            .collect()
    }

    #[test]
    fn test_get_ability_rarity_id_respects_weights() {
        let config = generate_game_config_for_tests();
        let level_settings = config.ability_case_settings_by_level(1).unwrap();
        let mut rng = StdRng::seed_from_u64(42);

        let mut counts: HashMap<AbilityRarityId, usize> = HashMap::new();
        let n = 10_000;
        for _ in 0..n {
            let id = get_ability_rarity_id(&mut rng, level_settings);
            *counts.entry(id).or_default() += 1;
        }

        // weights: common 256, uncommon 128, rare 64 → total 448
        let common_ratio = *counts.get(&COMMON).unwrap_or(&0) as f64 / n as f64;
        let uncommon_ratio = *counts.get(&UNCOMMON).unwrap_or(&0) as f64 / n as f64;
        let rare_ratio = *counts.get(&RARE).unwrap_or(&0) as f64 / n as f64;

        approx::assert_abs_diff_eq!(common_ratio, 256.0 / 448.0, epsilon = 0.02);
        approx::assert_abs_diff_eq!(uncommon_ratio, 128.0 / 448.0, epsilon = 0.02);
        approx::assert_abs_diff_eq!(rare_ratio, 64.0 / 448.0, epsilon = 0.02);
    }

    #[test]
    fn test_roll_rarity_with_minimum_filters_lower_rarities() {
        let config = generate_game_config_for_tests();
        let level_settings = config.ability_case_settings_by_level(1).unwrap();
        let mut rng = StdRng::seed_from_u64(99);

        // min = uncommon (order 2) → should never return common (order 1)
        for _ in 0..1_000 {
            let id = roll_rarity_with_minimum(&config, level_settings, UNCOMMON, &mut rng).unwrap();
            assert_ne!(id, COMMON, "Should never roll below minimum rarity");
        }
    }

    #[test]
    fn test_roll_rarity_with_minimum_respects_weights() {
        let config = generate_game_config_for_tests();
        let level_settings = config.ability_case_settings_by_level(1).unwrap();
        let mut rng = StdRng::seed_from_u64(77);

        let mut counts: HashMap<AbilityRarityId, usize> = HashMap::new();
        let n = 10_000;
        for _ in 0..n {
            let id = roll_rarity_with_minimum(&config, level_settings, UNCOMMON, &mut rng).unwrap();
            *counts.entry(id).or_default() += 1;
        }

        // Only uncommon (128) and rare (64) → total 192
        assert!(!counts.contains_key(&COMMON));
        let uncommon_ratio = *counts.get(&UNCOMMON).unwrap_or(&0) as f64 / n as f64;
        approx::assert_abs_diff_eq!(uncommon_ratio, 128.0 / 192.0, epsilon = 0.02);
    }

    #[test]
    fn test_get_ability_rarity_id_by_weights_distribution() {
        let weights = make_weights(&[(COMMON, 3.0), (UNCOMMON, 1.0)]);
        let mut rng = StdRng::seed_from_u64(42);

        let mut counts: HashMap<AbilityRarityId, usize> = HashMap::new();
        let n = 10_000;
        for _ in 0..n {
            let id = get_ability_rarity_id_by_weights(&mut rng, &weights).unwrap();
            *counts.entry(id).or_default() += 1;
        }

        let common_ratio = *counts.get(&COMMON).unwrap_or(&0) as f64 / n as f64;
        approx::assert_abs_diff_eq!(common_ratio, 0.75, epsilon = 0.02);
    }

    #[test]
    fn test_get_ability_rarity_id_by_weights_empty_errors() {
        let mut rng = StdRng::seed_from_u64(1);
        assert!(get_ability_rarity_id_by_weights(&mut rng, &[]).is_err());
    }

    #[test]
    fn test_open_ability_case_with_rarity_and_wishlist_returns_correct_rarity() {
        let config = generate_game_config_for_tests();
        let mut rng = StdRng::seed_from_u64(42);

        for _ in 0..100 {
            let id =
                open_ability_case_with_rarity_and_wishlist(&config, COMMON, &mut rng, &[]).unwrap();
            let template = config.ability_template(id).unwrap();
            assert_eq!(template.rarity_id, COMMON);
        }
    }

    #[test]
    fn test_open_ability_case_with_rarity_and_wishlist_invalid_rarity_errors() {
        let config = generate_game_config_for_tests();
        let mut rng = StdRng::seed_from_u64(1);
        let fake_rarity = uuid!("00000000-0000-0000-0000-000000000001");

        assert!(
            open_ability_case_with_rarity_and_wishlist(&config, fake_rarity, &mut rng, &[])
                .is_err()
        );
    }
}