#![allow(dead_code, unused_variables)]
use rand::{Rng};
use rand::distributions::{WeightedIndex, Distribution};
use serde::{Serialize, Deserialize};
use entity::character::SectionID;
use maps::room::{Difficulty, Episode};
use maps::area::MapArea;
use crate::{ItemDropType, load_data_file};
use maps::object::{MapObject, MapObjectType, FixedBoxDropType};
use crate::rare_drop_table::{RareDropTable, RareDropItem};
use crate::generic_weapon::GenericWeaponTable;
use crate::generic_armor::GenericArmorTable;
use crate::generic_shield::GenericShieldTable;
use crate::generic_unit::GenericUnitTable;
use crate::tool_table::ToolTable;
#[derive(Debug, Serialize, Deserialize)]
struct BoxDropRate {
weapon_rate: u32,
armor_rate: u32,
shield_rate: u32,
unit_rate: u32,
tool_rate: u32,
meseta_rate: u32,
nothing_rate: u32,
min_meseta: u32,
max_meseta: u32,
}
#[derive(Debug, Serialize, Deserialize)]
struct BoxDropRates {
area1: BoxDropRate,
area2: BoxDropRate,
area3: BoxDropRate,
area4: BoxDropRate,
area5: BoxDropRate,
area6: BoxDropRate,
area7: BoxDropRate,
area8: BoxDropRate,
area9: BoxDropRate,
area10: BoxDropRate,
}
impl BoxDropRates {
fn rates_by_area(&self, map_area: &MapArea) -> &BoxDropRate {
match map_area.drop_area_value().unwrap() {
0 => &self.area1,
1 => &self.area2,
2 => &self.area3,
3 => &self.area1,
4 => &self.area1,
5 => &self.area6,
6 => &self.area7,
7 => &self.area8,
8 => &self.area9,
9 => &self.area10,
_ => panic!()
}
}
}
#[derive(Debug, Serialize, Deserialize)]
struct BoxRareRateRaw {
item: String,
rate: f32,
}
#[derive(Debug, Serialize, Deserialize)]
struct BoxRareRatesRaw {
area1: Vec<BoxRareRateRaw>,
area2: Vec<BoxRareRateRaw>,
area3: Vec<BoxRareRateRaw>,
area4: Vec<BoxRareRateRaw>,
area5: Vec<BoxRareRateRaw>,
area6: Vec<BoxRareRateRaw>,
area7: Vec<BoxRareRateRaw>,
area8: Vec<BoxRareRateRaw>,
area9: Vec<BoxRareRateRaw>,
area10: Vec<BoxRareRateRaw>,
}
struct BoxRareRate {
item: RareDropItem,
rate: f32,
}
struct BoxRareRates {
area1: Vec<BoxRareRate>,
area2: Vec<BoxRareRate>,
area3: Vec<BoxRareRate>,
area4: Vec<BoxRareRate>,
area5: Vec<BoxRareRate>,
area6: Vec<BoxRareRate>,
area7: Vec<BoxRareRate>,
area8: Vec<BoxRareRate>,
area9: Vec<BoxRareRate>,
area10: Vec<BoxRareRate>,
}
impl BoxRareRates {
fn new(raw: BoxRareRatesRaw) -> BoxRareRates {
BoxRareRates {
area1: raw.area1.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area2: raw.area2.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area3: raw.area3.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area4: raw.area4.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area5: raw.area5.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area6: raw.area6.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area7: raw.area7.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area8: raw.area8.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area9: raw.area9.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
area10: raw.area10.into_iter().map(|i| { BoxRareRate {item: RareDropItem::from_string(i.item), rate: i.rate} }).collect(),
}
}
fn rates_by_area(&self, map_area: &MapArea) -> &Vec<BoxRareRate> {
match map_area.drop_area_value().unwrap() {
0 => &self.area1,
1 => &self.area2,
2 => &self.area3,
3 => &self.area1,
4 => &self.area1,
5 => &self.area6,
6 => &self.area7,
7 => &self.area8,
8 => &self.area9,
9 => &self.area10,
_ => panic!()
}
}
}
pub struct BoxDropTable {
box_rates: BoxDropRates,
rare_rates: BoxRareRates,
rare_stats: RareDropTable,
weapon_table: GenericWeaponTable,
armor_table: GenericArmorTable,
shield_table: GenericShieldTable,
unit_table: GenericUnitTable,
tool_table: ToolTable,
}
impl BoxDropTable {
pub fn new(episode: Episode, difficulty: Difficulty, section_id: SectionID) -> BoxDropTable {
let rates = load_data_file(episode, difficulty, section_id, "box_rare_rate.toml");
BoxDropTable {
box_rates: load_data_file(episode, difficulty, section_id, "box_drop_rate.toml"),
rare_rates: BoxRareRates::new(rates),
rare_stats: RareDropTable::new(episode, difficulty, section_id),
weapon_table: GenericWeaponTable::new(episode, difficulty, section_id),
armor_table: GenericArmorTable::new(episode, difficulty, section_id),
shield_table: GenericShieldTable::new(episode, difficulty, section_id),
unit_table: GenericUnitTable::new(episode, difficulty, section_id),
tool_table: ToolTable::new(episode, difficulty, section_id),
}
}
fn rare_drop<R: Rng>(&self, map_area: &MapArea, rng: &mut R) -> Option<ItemDropType> {
self.rare_rates.rates_by_area(map_area).iter()
.filter_map(|rate| {
let rand: f32 = rng.gen();
if rand < rate.rate {
Some(self.rare_stats.apply_item_stats(map_area, rate.item, rng))
}
else {
None
}
}).next()
}
fn random_box_drop<R: Rng>(&self, map_area: &MapArea, rng: &mut R) -> Option<ItemDropType> {
self.rare_drop(map_area, rng).or_else(|| {
let rate = self.box_rates.rates_by_area(map_area);
let type_weights = WeightedIndex::new([rate.weapon_rate, rate.armor_rate, rate.shield_rate, rate.unit_rate,
rate.tool_rate, rate.meseta_rate, rate.nothing_rate]).unwrap();
let btype = type_weights.sample(rng);
match btype {
0 => self.weapon_table.get_drop(map_area, rng),
1 => self.armor_table.get_drop(map_area, rng),
2 => self.shield_table.get_drop(map_area, rng),
3 => self.unit_table.get_drop(map_area, rng),
4 => self.tool_table.get_drop(map_area, rng),
5 => Some(ItemDropType::Meseta(rng.gen_range(rate.min_meseta, rate.max_meseta))),
_ => None,
}
})
}
fn fixed_box_drop<R: Rng>(&self, fixed_drop: FixedBoxDropType, map_area: &MapArea, rng: &mut R) -> Option<ItemDropType> {
match fixed_drop {
FixedBoxDropType::Weapon => self.weapon_table.get_drop(map_area, rng),
FixedBoxDropType::Armor => self.armor_table.get_drop(map_area, rng), // TODO: should this drop shield?
FixedBoxDropType::Tool => self.tool_table.get_drop(map_area, rng),
FixedBoxDropType::Meseta => {
let rate = self.box_rates.rates_by_area(map_area);
Some(ItemDropType::Meseta(rng.gen_range(rate.min_meseta, rate.max_meseta)))
},
FixedBoxDropType::Random => self.random_box_drop(map_area, rng),
FixedBoxDropType::Specific(value) => {
let mut buf: [u8; 16] = [0; 16];
buf[0..4].copy_from_slice(&u32::to_be_bytes(value));
ItemDropType::parse_item_from_bytes(buf)
},
}
}
pub fn get_drop<R: Rng>(&self, map_area: &MapArea, object: &MapObject, rng: &mut R) -> Option<ItemDropType> {
match object.object {
MapObjectType::Box | MapObjectType::EnemyBox | MapObjectType::RuinsBox| MapObjectType::RuinsEnemyBox
| MapObjectType::CcaBox => {
self.random_box_drop(map_area, rng)
},
MapObjectType::FixedBox(f) | MapObjectType::EnemyFixedBox(f) | MapObjectType::RuinsFixedBox(f)
| MapObjectType::RuinsEnemyFixedBox(f) | MapObjectType::CcaFixedBox(f) => {
self.fixed_box_drop(f, map_area, rng)
},
_ => None,
}
}
}
#[cfg(test)]
mod test {
use super::*;
use rand::{SeedableRng};
#[test]
fn test_box_drops() {
let mut rng = rand_chacha::ChaCha20Rng::from_seed([23;32]);
let bdt = BoxDropTable::new(Episode::One, Difficulty::Ultimate, SectionID::Skyly);
println!("{:?}", bdt.get_drop(&MapArea::Forest1, &MapObject {object: MapObjectType::Box, map: MapArea::Forest1, dropped_item: false}, &mut rng));
}
}