elseware/src/ship/shops/armor.rs

use std::collections::HashMap;
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use serde::Deserialize;
use rand::{Rng, SeedableRng};
use rand::distributions::{WeightedIndex, Distribution};
use rand::seq::{SliceRandom, IteratorRandom};
use crate::entity::character::SectionID;
use crate::ship::room::Difficulty;
use crate::entity::item::armor::ArmorType;
use crate::entity::item::shield::ShieldType;
use crate::entity::item::unit::UnitType;


enum ShopArmor {
    Frame(ArmorType, usize),
    Barrier(ShieldType),
    Unit(UnitType),
}



#[derive(Debug, Deserialize, Clone)]
struct FrameTierItem {
    item: ArmorType,
    probability: usize,
}

#[derive(Debug, Deserialize, Clone)]
struct FrameTier {
    level: usize,
    item: Vec<FrameTierItem>,
}

#[derive(Debug, Deserialize)]
struct SlotRate {
    slot: usize,
    probability: usize,
}

#[derive(Debug, Deserialize)]
struct FrameTable {
    frame: Vec<FrameTier>,
    slot_rate: Vec<SlotRate>,
}


#[derive(Debug, Deserialize, Clone)]
struct BarrierTierItem {
    item: ShieldType,
    probability: usize,
}

#[derive(Debug, Deserialize, Clone)]
struct BarrierTier {
    level: usize,
    item: Vec<BarrierTierItem>,
}

#[derive(Debug, Deserialize)]
struct BarrierTable {
    barrier: Vec<BarrierTier>,
}

#[derive(Debug, Deserialize, Clone)]
struct UnitTierItem {
    item: UnitType,
    probability: usize,
}

#[derive(Debug, Deserialize, Clone)]
struct UnitTier {
    level: usize,
    item: Vec<UnitTierItem>,
}

#[derive(Debug, Deserialize)]
struct UnitTable {
    unit: Vec<UnitTier>,
}



fn load_frame_table() -> FrameTable {
    let path = PathBuf::from("data/shops/frame.toml");
    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();

    let table: FrameTable = toml::from_str(s.as_str()).unwrap();
    table
}

fn load_barrier_table() -> BarrierTable {
    let path = PathBuf::from("data/shops/barrier.toml");
    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();

    let table: BarrierTable = toml::from_str(s.as_str()).unwrap();
    table
}

fn load_unit_table() -> UnitTable {
    let path = PathBuf::from("data/shops/unit.toml");
    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();

    let table: UnitTable = toml::from_str(s.as_str()).unwrap();
    table
}


fn number_of_frames_to_generate(character_level: usize) -> usize {
    if character_level <= 10 {
        4
    }
    else if character_level <= 25 {
        6
    }
    else if character_level <= 42 {
        7
    }
    else {
        8
    }
}

fn number_of_barriers_to_generate(character_level: usize) -> usize {
    if character_level <= 10 {
        4
    }
    else if character_level <= 25 {
        5
    }
    else if character_level <= 42 {
        6
    }
    else {
        7
    }
}

fn number_of_units_to_generate(character_level: usize) -> usize {
    if character_level <= 10 {
        0
    }
    else if character_level <= 25 {
        3
    }
    else if character_level <= 42 {
        5
    }
    else {
        6
    }
}

#[derive(Debug)]
struct ArmorShop<R: Rng + SeedableRng> {
    frame: FrameTable,
    barrier: BarrierTable,
    unit: UnitTable,
    rng: R,
}

impl<R: Rng + SeedableRng> ArmorShop<R> {
    pub fn new() -> ArmorShop<R> {
        ArmorShop {
            frame: load_frame_table(),
            barrier: load_barrier_table(),
            unit: load_unit_table(),
            rng: R::from_entropy(),
        }
    }

    fn generate_frame_list(&mut self, character_level: usize) -> Vec<ShopArmor> {
        let tier = self.frame.frame.iter()
            .filter(|t| t.level <= character_level)
            .last()
            .cloned()
            .unwrap();

        let frame_choice = WeightedIndex::new(tier.item.iter().map(|f| f.probability)).unwrap();
        let slot_choice = WeightedIndex::new(self.frame.slot_rate.iter().map(|sr| sr.probability)).unwrap();
        (0..number_of_frames_to_generate(character_level))
            .map(|_| {
                let frame_detail = tier.item.get(frame_choice.sample(&mut self.rng)).unwrap();
                let slot = self.frame.slot_rate.get(slot_choice.sample(&mut self.rng)).unwrap();
                
                ShopArmor::Frame(frame_detail.item, slot.slot)
            })
            .collect()
    }

    fn generate_barrier_list(&mut self, character_level: usize) -> Vec<ShopArmor> {
        let tier = self.barrier.barrier.iter()
            .filter(|t| t.level <= character_level)
            .last()
            .cloned()
            .unwrap();

        let barrier_choice = WeightedIndex::new(tier.item.iter().map(|b| b.probability)).unwrap();
        (0..number_of_barriers_to_generate(character_level))
            .map(|_| {
                let barrier_detail = tier.item.get(barrier_choice.sample(&mut self.rng)).unwrap();
                
                ShopArmor::Barrier(barrier_detail.item)
            })
            .collect()
    }

    fn generate_unit_list(&mut self, character_level: usize) -> Vec<ShopArmor> {
        self.unit.unit.iter()
            .filter(|t| t.level <= character_level)
            .last()
            .cloned()
            .map(|tier| {
                let unit_choice = WeightedIndex::new(tier.item.iter().map(|u| u.probability)).unwrap();
                (0..number_of_units_to_generate(character_level))
                    .map(|_| {
                        let unit_detail = tier.item.get(unit_choice.sample(&mut self.rng)).unwrap();
                        
                ShopArmor::Unit(unit_detail.item)
                    })
                    .collect()
            })
            .unwrap_or(Vec::new())
    }

    pub fn generate_armor_list(&mut self, character_level: usize) -> Vec<ShopArmor> {
        self.generate_frame_list(character_level).into_iter()
            .chain(self.generate_barrier_list(character_level).into_iter())
            .chain(self.generate_unit_list(character_level).into_iter())
            .collect()
    }
}



#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_loading_tool_shop() {
        ArmorShop::<rand_chacha::ChaCha20Rng>::new();
    }

    #[test]
    fn test_generating_some_armor() {
        let mut fs = ArmorShop::<rand_chacha::ChaCha20Rng>::new();
        for i in 0..200 {
            fs.generate_armor_list(i);
        }
    }
}