|
|
use std::collections::HashMap;
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use std::convert::TryInto;
use std::cmp::Ordering;
use serde::Deserialize;
use rand::{Rng, SeedableRng};
use rand::distributions::{WeightedIndex, Distribution};
use rand::seq::{SliceRandom, IteratorRandom};
use entity::character::SectionID;
use maps::room::Difficulty;
use entity::item::ItemDetail;
use entity::item::weapon::{Weapon, WeaponType, WeaponSpecial, Attribute, WeaponAttribute};
use crate::ShopItem;
use stats::items::WEAPON_STATS;
const TIER1_SPECIAL: [WeaponSpecial; 8] = [WeaponSpecial::Draw, WeaponSpecial::Heart, WeaponSpecial::Ice, WeaponSpecial::Bind,
WeaponSpecial::Heat, WeaponSpecial::Shock, WeaponSpecial::Dim, WeaponSpecial::Panic];
const TIER2_SPECIAL: [WeaponSpecial; 10] = [WeaponSpecial::Drain, WeaponSpecial::Mind, WeaponSpecial::Masters, WeaponSpecial::Charge, WeaponSpecial::Frost,
WeaponSpecial::Hold, WeaponSpecial::Fire, WeaponSpecial::Thunder, WeaponSpecial::Shadow, WeaponSpecial::Riot];
#[derive(Debug)]
pub struct WeaponShopItem {
weapon: WeaponType,
special: Option<WeaponSpecial>,
grind: usize,
attributes: [Option<WeaponAttribute>; 3],
}
impl PartialEq for WeaponShopItem {
fn eq(&self, other: &Self) -> bool {
self.weapon == other.weapon &&
self.special == other.special &&
self.grind == other.grind &&
self.attributes == other.attributes
}
}
impl Eq for WeaponShopItem {}
impl Ord for WeaponShopItem {
fn cmp(&self, other: &Self) -> Ordering {
self.weapon.value().cmp(&other.weapon.value())
}
}
impl PartialOrd for WeaponShopItem {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl From<&Weapon> for WeaponShopItem {
fn from(weapon: &Weapon) -> WeaponShopItem {
WeaponShopItem {
weapon: weapon.weapon,
special: weapon.special,
grind: weapon.grind as usize,
attributes: weapon.attrs,
}
}
}
fn special_stars(special: &WeaponSpecial) -> usize {
match special {
WeaponSpecial::Draw => 1,
WeaponSpecial::Drain => 2,
WeaponSpecial::Fill => 3,
WeaponSpecial::Gush => 4,
WeaponSpecial::Heart => 1,
WeaponSpecial::Mind => 2,
WeaponSpecial::Soul => 3,
WeaponSpecial::Geist => 4,
WeaponSpecial::Masters => 2,
WeaponSpecial::Lords => 3,
WeaponSpecial::Kings => 4,
WeaponSpecial::Charge => 2,
WeaponSpecial::Spirit => 3,
WeaponSpecial::Berserk => 4,
WeaponSpecial::Ice => 1,
WeaponSpecial::Frost => 2,
WeaponSpecial::Freeze => 3,
WeaponSpecial::Blizzard => 4,
WeaponSpecial::Bind => 1,
WeaponSpecial::Hold => 2,
WeaponSpecial::Seize => 3,
WeaponSpecial::Arrest => 4,
WeaponSpecial::Heat => 1,
WeaponSpecial::Fire => 2,
WeaponSpecial::Flame => 3,
WeaponSpecial::Burning => 4,
WeaponSpecial::Shock => 1,
WeaponSpecial::Thunder => 2,
WeaponSpecial::Storm => 3,
WeaponSpecial::Tempest => 4,
WeaponSpecial::Dim => 1,
WeaponSpecial::Shadow => 2,
WeaponSpecial::Dark => 3,
WeaponSpecial::Hell => 4,
WeaponSpecial::Panic => 1,
WeaponSpecial::Riot => 2,
WeaponSpecial::Havoc => 3,
WeaponSpecial::Chaos => 4,
WeaponSpecial::Devils => 3,
WeaponSpecial::Demons => 4,
}
}
impl ShopItem for WeaponShopItem {
fn price(&self) -> usize {
WEAPON_STATS.get(&self.weapon)
.map(|weapon_stat| {
let mut price = weapon_stat.atp_max as f32;
price += self.grind as f32;
price = (price * (price * 3.0)) / weapon_stat.shop_multiplier;
let percent = self.attributes.iter()
.fold(0.0, |acc, attr| {
acc + attr.map(|a| a.value).unwrap_or(0) as f32
});
price = price + ((price / 300.0) * percent);
let special = self.special.map(|special| {
special_stars(&special) as f32
}).unwrap_or(0.0);
price += special * special * 1000.0;
price as usize
})
.unwrap_or(0xFFFF)
}
fn as_bytes(&self) -> [u8; 12] {
self.as_item().as_client_bytes()[0..12].try_into().unwrap()
}
fn as_item(&self) -> ItemDetail {
ItemDetail::Weapon(
Weapon {
weapon: self.weapon,
special: self.special,
grind: self.grind as u8,
attrs: [self.attributes[0], self.attributes[1], None],
tekked: true,
}
)
}
}
impl WeaponShopItem {
pub fn weapon_from_item(w: &Weapon) -> WeaponShopItem {
WeaponShopItem {
weapon: w.weapon,
special: w.special,
grind: w.grind as usize,
attributes: w.attrs,
}
}
}
#[derive(Debug, Deserialize)]
struct WeaponTableTierEntry {
weapon: WeaponType,
probability: usize,
}
#[derive(Debug, Deserialize)]
struct WeaponTableTier {
level: usize,
weapons: Vec<WeaponTableTierEntry>,
}
#[derive(Debug)]
struct WeaponTable(Vec<WeaponTableTier>);
#[derive(Debug, Deserialize)]
struct GrindTier {
level: usize,
min: usize,
max: usize,
}
#[derive(Debug)]
struct GrindTable(Vec<GrindTier>);
#[derive(Debug, Deserialize)]
struct AttributeTier {
level: usize,
percent_min: isize,
percent_max: isize,
none: usize,
native: usize,
abeast: usize,
machine: usize,
dark: usize,
hit: usize,
}
#[derive(Debug)]
struct AttributeTable(Vec<AttributeTier>);
#[derive(Debug, Deserialize)]
struct SpecialTierEntry {
tier: usize,
probability: usize,
}
#[derive(Debug, Deserialize)]
struct SpecialTier {
level: usize,
special: Vec<SpecialTierEntry>,
}
#[derive(Debug)]
struct SpecialTable(Vec<SpecialTier>);
/*
trait WeaponTableLoader {
fn load(difficulty: Difficulty, section_id: SectionID) -> WeaponTable where Self::Sized;
}
struct WeaponTableLoaderImpl;
impl WeaponTableLoader for WeaponTableLoaderImpl {
fn load(difficulty: Difficulty, section_id: SectionID) -> WeaponTable {
let mut path = PathBuf::from("data/shops/");
path.push(difficulty.to_string().to_lowercase());
path.push(section_id.to_string().to_lowercase());
path.push("weapon.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s);
let table: Vec<WeaponTableTier> = toml::from_str(s.as_str()).unwrap();
println!("table {:?}", table);
WeaponTable {
}
}
}
*/
fn load_weapon_table(difficulty: Difficulty, section_id: SectionID) -> WeaponTable {
let mut path = PathBuf::from("data/shops/");
path.push(difficulty.to_string().to_lowercase());
path.push(section_id.to_string().to_lowercase());
path.push("weapon.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<WeaponTableTier>> = toml::from_str(s.as_str()).unwrap();
WeaponTable(table.remove("weapon_tier").unwrap())
}
fn load_special_table() -> SpecialTable {
let path = PathBuf::from("data/shops/special.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<SpecialTier>> = toml::from_str(s.as_str()).unwrap();
SpecialTable(table.remove("specials").unwrap())
}
fn load_grind_table() -> GrindTable {
let path = PathBuf::from("data/shops/grind.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<GrindTier>> = toml::from_str(s.as_str()).unwrap();
GrindTable(table.remove("grind").unwrap())
}
fn load_alt_grind_table() -> GrindTable {
let path = PathBuf::from("data/shops/alt_grind.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<GrindTier>> = toml::from_str(s.as_str()).unwrap();
GrindTable(table.remove("grind").unwrap())
}
fn load_attribute1_table() -> AttributeTable {
let path = PathBuf::from("data/shops/attribute1.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<AttributeTier>> = toml::from_str(s.as_str()).unwrap();
AttributeTable(table.remove("attributes").unwrap())
}
fn load_attribute2_table() -> AttributeTable {
let path = PathBuf::from("data/shops/attribute2.toml");
let mut f = File::open(path).unwrap();
let mut s = String::new();
f.read_to_string(&mut s).unwrap();
let mut table: HashMap<String, Vec<AttributeTier>> = toml::from_str(s.as_str()).unwrap();
AttributeTable(table.remove("attributes").unwrap())
}
fn number_of_weapons_to_generate(character_level: usize) -> usize {
if character_level <= 10 {
10
}
else if character_level <= 42 {
12
}
else {
16
}
}
#[derive(Debug)]
pub struct WeaponShop<R: Rng + SeedableRng> {
_difficulty: Difficulty,
section_id: SectionID,
weapon: WeaponTable,
special: SpecialTable,
grind: GrindTable,
alt_grind: GrindTable,
attr1: AttributeTable,
attr2: AttributeTable,
rng: R,
}
impl<R: Rng + SeedableRng> WeaponShop<R> {
pub fn new(difficulty: Difficulty, section_id: SectionID) -> WeaponShop<R> {
WeaponShop {
_difficulty: difficulty,
section_id,
weapon: load_weapon_table(difficulty, section_id),
special: load_special_table(),
grind: load_grind_table(),
alt_grind: load_alt_grind_table(),
attr1: load_attribute1_table(),
attr2: load_attribute2_table(),
rng: R::from_entropy(),
}
}
fn generate_type(&mut self, level: usize) -> WeaponType {
let tier = self.weapon.0.iter()
.filter(|t| t.level <= level)
.last()
.unwrap();
let weapon_choice = WeightedIndex::new(tier.weapons.iter().map(|t| t.probability)).unwrap();
tier.weapons.get(weapon_choice.sample(&mut self.rng)).unwrap().weapon
}
fn generate_special(&mut self, level: usize) -> Option<WeaponSpecial> {
let tier = self.special.0.iter()
.filter(|t| t.level <= level)
.last()
.unwrap();
let special_tier_choice = WeightedIndex::new(tier.special.iter().map(|t| t.probability)).unwrap();
let special_tier_index = special_tier_choice.sample(&mut self.rng);
let special_tier = tier.special.get(special_tier_index)?;
match special_tier.tier {
1 => TIER1_SPECIAL.choose(&mut self.rng).cloned(),
2 => TIER2_SPECIAL.choose(&mut self.rng).cloned(),
_ => None
}
}
fn generate_grind(&mut self, level: usize) -> usize {
let tier = self.grind.0.iter()
.filter(|t| t.level <= level)
.last()
.unwrap();
self.rng.gen_range(tier.min, tier.max+1)
}
fn generate_alt_grind(&mut self, level: usize) -> usize {
let tier = self.alt_grind.0.iter()
.find(|t| t.level <= level)
.unwrap();
self.rng.gen_range(tier.min, tier.max+1)
}
fn generate_attribute1(&mut self, level: usize) -> Option<WeaponAttribute> {
let tier = self.attr1.0.iter()
.filter(|t| t.level <= level)
.last()
.unwrap();
let attr_choice = WeightedIndex::new([tier.none, tier.native, tier.abeast, tier.machine, tier.dark, tier.hit]).unwrap();
let attr = match attr_choice.sample(&mut self.rng) {
0 => return None,
1 => Attribute::Native,
2 => Attribute::ABeast,
3 => Attribute::Machine,
4 => Attribute::Dark,
5 => Attribute::Hit,
_ => panic!()
};
let percent = (tier.percent_min..tier.percent_max+1)
.filter(|p| p % 5 == 0)
.choose(&mut self.rng)?;
Some(WeaponAttribute {
attr,
value: percent as i8,
})
}
fn generate_attribute2(&mut self, level: usize) -> Option<WeaponAttribute> {
let tier = self.attr2.0.iter()
.filter(|t| t.level <= level)
.last()
.unwrap();
let attr_choice = WeightedIndex::new([tier.none, tier.native, tier.abeast, tier.machine, tier.dark, tier.hit]).unwrap();
let attr = match attr_choice.sample(&mut self.rng) {
0 => return None,
1 => Attribute::Native,
2 => Attribute::ABeast,
3 => Attribute::Machine,
4 => Attribute::Dark,
5 => Attribute::Hit,
_ => panic!()
};
let percent = (tier.percent_min..tier.percent_max+1)
.filter(|p| p % 5 == 0)
.choose(&mut self.rng)?;
Some(WeaponAttribute {
attr,
value: percent as i8,
})
}
fn is_alt_grind(&self, weapon: &WeaponType) -> bool {
matches!((self.section_id, weapon),
(SectionID::Viridia, WeaponType::Shot) |
(SectionID::Viridia, WeaponType::Spread) |
(SectionID::Viridia, WeaponType::Cannon) |
(SectionID::Viridia, WeaponType::Launcher) |
(SectionID::Viridia, WeaponType::Arms) |
(SectionID::Greenill, WeaponType::Rifle) |
(SectionID::Greenill, WeaponType::Sniper) |
(SectionID::Greenill, WeaponType::Blaster) |
(SectionID::Greenill, WeaponType::Beam) |
(SectionID::Greenill, WeaponType::Laser) |
(SectionID::Skyly, WeaponType::Sword) |
(SectionID::Skyly, WeaponType::Gigush) |
(SectionID::Skyly, WeaponType::Breaker) |
(SectionID::Skyly, WeaponType::Claymore) |
(SectionID::Skyly, WeaponType::Calibur) |
(SectionID::Bluefull, WeaponType::Partisan) |
(SectionID::Bluefull, WeaponType::Halbert) |
(SectionID::Bluefull, WeaponType::Glaive) |
(SectionID::Bluefull, WeaponType::Berdys) |
(SectionID::Bluefull, WeaponType::Gungnir) |
(SectionID::Purplenum, WeaponType::Mechgun) |
(SectionID::Purplenum, WeaponType::Assault) |
(SectionID::Purplenum, WeaponType::Repeater) |
(SectionID::Purplenum, WeaponType::Gatling) |
(SectionID::Purplenum, WeaponType::Vulcan) |
(SectionID::Pinkal, WeaponType::Cane) |
(SectionID::Pinkal, WeaponType::Stick) |
(SectionID::Pinkal, WeaponType::Mace) |
(SectionID::Pinkal, WeaponType::Club) |
(SectionID::Oran, WeaponType::Dagger) |
(SectionID::Oran, WeaponType::Knife) |
(SectionID::Oran, WeaponType::Blade) |
(SectionID::Oran, WeaponType::Edge) |
(SectionID::Oran, WeaponType::Ripper) |
(SectionID::Whitill, WeaponType::Slicer) |
(SectionID::Whitill, WeaponType::Spinner) |
(SectionID::Whitill, WeaponType::Cutter) |
(SectionID::Whitill, WeaponType::Sawcer) |
(SectionID::Whitill, WeaponType::Diska))
}
fn generate_weapon(&mut self, level: usize) -> WeaponShopItem {
let weapon = self.generate_type(level);
let grind = if self.is_alt_grind(&weapon) {
self.generate_alt_grind(level)
} else {
self.generate_grind(level)
};
let special = self.generate_special(level);
let (attr1, attr2) = {
match self.generate_attribute1(level) {
Some(a1) => {
let a2 = loop {
let attr = self.generate_attribute2(level);
match attr {
Some(a2) => {
if a2.attr != a1.attr {
break Some(a2);
}
},
None => break None,
}
};
(Some(a1), a2)
},
None => {
let a2 = self.generate_attribute2(level);
(a2, None)
}
}
};
WeaponShopItem {
weapon,
grind,
special,
attributes: [attr1, attr2, None],
}
}
pub fn generate_weapon_list(&mut self, level: usize) -> Vec<WeaponShopItem> {
let mut x = (0..number_of_weapons_to_generate(level))
.map(|_| {
self.generate_weapon(level)
})
.collect::<Vec<WeaponShopItem>>();
x.sort();
x
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_loading_weapon_shop() {
WeaponShop::<rand_chacha::ChaCha20Rng>::new(Difficulty::Ultimate, SectionID::Pinkal);
}
#[test]
fn test_generating_some_weapons() {
let mut ws = WeaponShop::<rand_chacha::ChaCha20Rng>::new(Difficulty::Ultimate, SectionID::Pinkal);
for i in 0..200 {
ws.generate_weapon_list(i);
}
}
}
|
