overlord_event_system/gacha/

pet_case.rs

use configs::game_config::GameConfig;
use configs::pets::PetCasesSettingsByLevel;
use essences::character_state::CharacterState;
use essences::pets::{PetId, PetRarityId, PetTemplate};

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

use crate::game_config_helpers::GameConfigLookup;

pub fn open_pet_case(
    character_state: &CharacterState,
    config: &GameConfig,
    rng: &mut StdRng,
) -> anyhow::Result<PetId> {
    open_pet_case_with_wishlist(character_state, config, rng, &[])
}

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

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

    let rarity_id = get_pet_rarity_id(rng, level_settings);

    let pet_id = open_pet_case_with_rarity_and_wishlist(config, rarity_id, rng, wishlist)?;

    Ok(pet_id)
}

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

    let mut pets_pool: Vec<PetTemplate> = config
        .pet_templates
        .iter()
        .filter(|pet| pet.is_gacha_pet && pet.rarity_id == rarity_id)
        .cloned()
        .collect();

    if pets_pool.is_empty() {
        // A valid rarity was rolled but has no gacha pets (a content gap — e.g.
        // the case weights still include Rare while no Rare gacha pet exists).
        // Roll DOWN to the nearest populated rarity (by `order`) at or below the
        // requested one rather than failing the player's paid pull. An UNKNOWN
        // rarity id still errors (genuine misconfig, not a content gap).
        let requested_order = config
            .pet_rarity(rarity_id)
            .ok_or_else(|| anyhow::anyhow!("Unknown pet rarity_id={rarity_id}"))?
            .order;
        let fallback_rarity = config
            .pet_templates
            .iter()
            .filter(|pet| pet.is_gacha_pet)
            .filter_map(|pet| {
                config
                    .pet_rarity(pet.rarity_id)
                    .map(|r| (r.order, pet.rarity_id))
            })
            .filter(|(order, _)| *order <= requested_order)
            .max_by_key(|(order, _)| *order)
            .map(|(_, rid)| rid);
        let Some(fallback_rarity) = fallback_rarity else {
            anyhow::bail!("No gacha pets at or below rarity_id={rarity_id}");
        };
        pets_pool = config
            .pet_templates
            .iter()
            .filter(|pet| pet.is_gacha_pet && pet.rarity_id == fallback_rarity)
            .cloned()
            .collect();
    }

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

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

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

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

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

pub fn get_pet_rarity_id(
    rng: &mut StdRng,
    level_settings: &PetCasesSettingsByLevel,
) -> PetRarityId {
    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 pet 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 PetRarity determines the ordering (higher = rarer).
pub fn roll_rarity_with_minimum(
    config: &GameConfig,
    level_settings: &PetCasesSettingsByLevel,
    min_rarity_id: PetRarityId,
    rng: &mut StdRng,
) -> anyhow::Result<PetRarityId> {
    let min_order = config
        .pet_rarity(min_rarity_id)
        .map(|r| r.order)
        .unwrap_or(0);

    let filtered_weights: Vec<_> = level_settings
        .rarity_weights
        .iter()
        .filter(|rw| {
            config
                .pet_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 get_pet_rarity_id_by_weights(
    rng: &mut StdRng,
    rarity_weights: &[configs::pets::PetCaseRarityWeight],
) -> anyhow::Result<PetRarityId> {
    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::pets::PetCaseRarityWeight;
    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   = a0000000-...-000000000001 (order 1, weight 256)
    // uncommon = a0000000-...-000000000002 (order 2, weight 128)
    const COMMON: PetRarityId = uuid!("a0000000-0000-0000-0000-000000000001");
    const UNCOMMON: PetRarityId = uuid!("a0000000-0000-0000-0000-000000000002");

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

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

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

        // weights: common 256, uncommon 128 → total 384
        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;

        approx::assert_abs_diff_eq!(common_ratio, 256.0 / 384.0, epsilon = 0.02);
        approx::assert_abs_diff_eq!(uncommon_ratio, 128.0 / 384.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.pet_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.pet_case_settings_by_level(1).unwrap();
        let mut rng = StdRng::seed_from_u64(77);

        let mut counts: HashMap<PetRarityId, 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) → all should be uncommon since it's the only rarity at or above
        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, 1.0, epsilon = 0.001);
    }

    #[test]
    fn test_get_pet_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<PetRarityId, usize> = HashMap::new();
        let n = 10_000;
        for _ in 0..n {
            let id = get_pet_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_pet_rarity_id_by_weights_empty_errors() {
        let mut rng = StdRng::seed_from_u64(1);
        assert!(get_pet_rarity_id_by_weights(&mut rng, &[]).is_err());
    }

    #[test]
    fn test_open_pet_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_pet_case_with_rarity_and_wishlist(&config, COMMON, &mut rng, &[]).unwrap();
            let template = config.pet_template(id).unwrap();
            assert_eq!(template.rarity_id, COMMON);
        }
    }

    #[test]
    fn test_open_pet_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_pet_case_with_rarity_and_wishlist(&config, fake_rarity, &mut rng, &[]).is_err()
        );
    }

    /// A VALID rarity whose gacha-pet pool is empty (a content gap, e.g. Rare
    /// weight present but no Rare pets) must NOT fail the pull — it rolls down to
    /// the nearest populated lower rarity. (Regression: the live pet gacha rolled
    /// Rare ~9% with no Rare pets and every such pull `bail!`ed.)
    #[test]
    fn test_empty_rarity_pool_rolls_down_instead_of_erroring() {
        let mut config = generate_game_config_for_tests();
        // Drain the UNCOMMON gacha pool so requesting UNCOMMON has no pets.
        config
            .pet_templates
            .retain(|p| !(p.is_gacha_pet && p.rarity_id == UNCOMMON));
        let mut rng = StdRng::seed_from_u64(7);
        for _ in 0..100 {
            let id = open_pet_case_with_rarity_and_wishlist(&config, UNCOMMON, &mut rng, &[])
                .expect("empty pool must roll down, not error");
            let tpl = config.pet_template(id).unwrap();
            assert_eq!(
                tpl.rarity_id, COMMON,
                "empty UNCOMMON pool must roll down to COMMON"
            );
        }
    }
}