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::{RngExt, 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)
}

/// One roll with the BAL-032 first-copy pity applied, advancing the counter.
///
/// The pity is a safety net over the ordinary weights, not a replacement for
/// them: the rarity roll and the wishlist `×2` multiplier are untouched. Only
/// when `first_copy_pity_pulls` consecutive rolls have produced no NEW template
/// does the next roll get forced onto one the player does not own.
///
/// The counter resets on ANY first copy — including one that arrived by luck
/// rather than by pity — so a lucky streak legitimately postpones the guarantee
/// instead of banking toward a double reward.
pub fn open_pet_case_with_pity(
    character_state: &mut CharacterState,
    config: &GameConfig,
    rng: &mut StdRng,
    wishlist: &[PetId],
) -> anyhow::Result<PetId> {
    let threshold = config.game_settings.pet_gacha.first_copy_pity_pulls;
    let owned: HashSet<PetId> = character_state
        .all_pets
        .iter()
        .map(|pet| pet.template_id)
        .collect();

    let pity_due = threshold > 0 && character_state.character.pet_gacha_pity_pulls >= threshold;
    let forced = if pity_due {
        // The pity is bounded by the same content gates as the ordinary roll:
        // only rarities the CURRENT case level actually rolls (its authored
        // `rarity_weights`) are eligible, so pity can never hand out a Rare
        // ahead of the L5 unlock.
        let unlocked_rarities: HashSet<_> = config
            .pet_cases_settings
            .iter()
            .find(|settings| settings.level == character_state.character.pet_case_level)
            .map(|settings| {
                settings
                    .rarity_weights
                    .iter()
                    .map(|row| row.rarity_id)
                    .collect()
            })
            .unwrap_or_default();
        let mut unowned: Vec<PetId> = config
            .pet_templates
            .iter()
            .filter(|pet| {
                pet.is_gacha_pet
                    && !owned.contains(&pet.id)
                    && unlocked_rarities.contains(&pet.rarity_id)
            })
            .map(|pet| pet.id)
            .collect();
        // Owning the whole catalog is a real state, not an error: fall through
        // to the ordinary roll and let the counter keep climbing harmlessly.
        if unowned.is_empty() {
            None
        } else {
            unowned.sort();
            // A2-BAL-003 §3.6: the pity pays the WISHLIST first.
            //
            // It used to pick uniformly among every unowned eligible pet, so
            // the one guarantee a player is given for choosing a target ignored
            // that choice — with a large catalog the odds of the pity landing
            // on the wishlisted pet were no better than chance. The signed
            // contract is that 30 pulls guarantee the first copy of the pet the
            // player selected, which only holds if the wishlist is preferred
            // here. Falling back to the full unowned pool keeps an empty or
            // fully-owned wishlist working exactly as before.
            let wishlisted: Vec<PetId> = unowned
                .iter()
                .copied()
                .filter(|id| wishlist.contains(id))
                .collect();
            let pool = if wishlisted.is_empty() {
                &unowned
            } else {
                &wishlisted
            };
            let index = RngExt::random_range(rng, 0..pool.len());
            pool.get(index).copied()
        }
    } else {
        None
    };

    let pet_id = match forced {
        Some(id) => id,
        None => open_pet_case_with_wishlist(character_state, config, rng, wishlist)?,
    };

    if owned.contains(&pet_id) {
        character_state.character.pet_gacha_pity_pulls += 1;
    } else {
        character_state.character.pet_gacha_pity_pulls = 0;
    }
    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"
            );
        }
    }
}