From 62ce8d20c4634d4a893744e43e5310a6d61700fd Mon Sep 17 00:00:00 2001 From: Ren Kararou Date: Mon, 14 Aug 2023 15:50:27 -0500 Subject: [PATCH] barely functional --- .gitignore | 2 + Cargo.toml | 9 ++ src/equipment/comp.rs | 133 +++++++++++++++++++++++++ src/equipment/gun.rs | 66 +++++++++++++ src/equipment/hat.rs | 18 ++++ src/equipment/mod.rs | 107 +++++++++++++++++++++ src/equipment/pants.rs | 18 ++++ src/equipment/shirt.rs | 18 ++++ src/equipment/shoes.rs | 18 ++++ src/equipment/sword.rs | 84 ++++++++++++++++ src/inventory.rs | 16 ++++ src/lib.rs | 6 ++ src/magic.rs | 1 + src/statistics.rs | 148 ++++++++++++++++++++++++++++ src/status.rs | 11 +++ src/unit.rs | 213 +++++++++++++++++++++++++++++++++++++++++ 16 files changed, 868 insertions(+) create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 src/equipment/comp.rs create mode 100644 src/equipment/gun.rs create mode 100644 src/equipment/hat.rs create mode 100644 src/equipment/mod.rs create mode 100644 src/equipment/pants.rs create mode 100644 src/equipment/shirt.rs create mode 100644 src/equipment/shoes.rs create mode 100644 src/equipment/sword.rs create mode 100644 src/inventory.rs create mode 100644 src/lib.rs create mode 100644 src/magic.rs create mode 100644 src/statistics.rs create mode 100644 src/status.rs create mode 100644 src/unit.rs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fffb2f --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/target +/Cargo.lock diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..8c71f7d --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "broken-data" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +rand = "0.8.5" diff --git a/src/equipment/comp.rs b/src/equipment/comp.rs new file mode 100644 index 0000000..4e80750 --- /dev/null +++ b/src/equipment/comp.rs @@ -0,0 +1,133 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Comp { + id: String, // Unique Item ID + name: String, // Display Name + slots: u8, // Spell slots, between 1 and 10 + mstorage: u8, // Spell storage, powers of 2, 16-128 (MiB) + gstorage: u8, // Program storage, powers of 2, 8-32 (GiB) + stat_mods: StatBlock, // Bufs/debufs + flavor: String, // Flavortext + description: String, // Description text +} +impl Comp { + pub fn new() -> Self { + Self { + id: String::from("COMP_BLANK"), + name: String::from("Basic DMD"), + slots: 1, + mstorage: 16, + gstorage: 8, + stat_mods: StatBlock::new_zero(), + flavor: String::from("A basic bitch digital magick device"), + description: String::from( + "One spell slot, 16MiB of spell storage, and 8GiB of program storage", + ), + } + } + pub fn id(self) -> String { + self.id + } + pub fn name(self) -> String { + self.name + } + pub fn slots(self) -> u8 { + self.slots + } + pub fn spell_storage(self) -> u8 { + self.mstorage + } + pub fn program_storage(self) -> u8 { + self.gstorage + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } + pub fn description(self) -> String { + self.description + } + pub fn flavor(self) -> String { + self.flavor + } + + // Low teir gear + pub fn cef_8080() -> Self { + Self { + id: String::from("COMP_CEF_8080"), + name: String::from("CEF 8080"), + slots: 1, + mstorage: 16, + gstorage: 8, + stat_mods: StatBlock::new_zero(), + flavor: String::from("Mass produced garbage."), + description: String::from( + "One spell slot, 16MiB of spell storage, and 8GiB of program storage.", + ), + } + } + pub fn chiba_e3() -> Self { + let mut stat_mods = StatBlock::new_zero(); + stat_mods.set_intellect(1); + Self { + id: String::from("COMP_CHIBA_E3"), + name: String::from("Chiba E3"), + slots: 1, + mstorage: 16, + gstorage: 8, + stat_mods, + flavor: String::from("Handmade with love by Gideon Chiba, good luck out there trainee!"), + description: String::from("+1 Intellect, 1 spell slot, 16MiB of spell storage, 8GiB of program storage."), + } + } + pub fn spiceworks_v3() -> Self { + let mut stat_mods = StatBlock::new_zero(); + stat_mods.set_magick(1); + Self { + id: String::from("COMP_SPICE_V3"), + name: String::from("Spiceworks V3"), + slots: 2, + mstorage: 16, + gstorage: 8, + stat_mods, + flavor: String::from("A heart is scratched into the side."), + description: String::from("+1 Magick, 2 spell slots, 16MiB of spell storage, 8GiB of program storage."), + } + } + + // Mid teir gear + pub fn chiba_d35() -> Self { + let mut mods = StatBlock::new_zero(); + mods.set_intellect(3); + Self { + id: String::from("COMP_CHIBA_D35"), + name: String::from("Chiba D35"), + slots: 6, + mstorage: 64, + gstorage: 16, + stat_mods: mods, + flavor: String::from("The hottest new offering from Gideon Chiba's handcrafted digital magick devices"), + description: String::from("+3 Intellect, six spell slots, 64MiB of spell storage, and 16GiB of program storage"), + } + } + pub fn cef_8081() -> Self { + Self { + id: String::from("COMP_CEF_8081"), + name: String::from("CEF 8081"), + slots: 5, + mstorage: 128, + gstorage: 16, + stat_mods: StatBlock::new_zero(), + flavor: String::from("Mass produced garbage."), + description: String::from("Five spell slots, 128MiB of spell storage, and 16GiB of program storage."), + } + } + + // Gear Sets for AI unit generation + pub fn low_level_opts() -> [Self; 3] { + [Self::cef_8080(), Self::chiba_e3(), Self::spiceworks_v3()] + } + pub fn mid_level_opts() -> [Self; 2] { + [Self::chiba_d35(), Self::cef_8081()] + } +} diff --git a/src/equipment/gun.rs b/src/equipment/gun.rs new file mode 100644 index 0000000..b88a348 --- /dev/null +++ b/src/equipment/gun.rs @@ -0,0 +1,66 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Bullet { + id: String, + name: String, + attack: u8, +} +impl Bullet { + pub fn new() -> Self { + Self { + id: "BULLET_BLANK", + name: "BLANK", + attack: 0, + } + } + pub fn id(self) -> String { + self.id + } + pub fn name(self) -> String { + self.name + } + pub fn attack(self) -> u8 { + self.attack + } + + pub fn normal() -> Self { + Self { + id: "BULLET_NORMAL", + name: "Normal Bullet", + attack: 5, + } + } +} + +#[derive(Debug, Clone)] +pub struct Gun { + id: String, + name: String, + stat_mods: StatBlock, + attack: u8, + bullets: Option, + mag_size: u8, + description: String, + flavor: String, +} +impl Gun { + pub fn new() -> Self { + Self { + id: String::from("GUN_WATER"), + name: String::from("Water Gun"), + stat_mods: StatBlock::new_zero(), + attack: 0, + bullets: None, + mag_size: 0, + description: String::from("A cheap toy."), + flavor: String::from("Don't walk into a gun fight with this."), + } + } + pub fn attack(self) -> u8 { + self.attack + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } +} diff --git a/src/equipment/hat.rs b/src/equipment/hat.rs new file mode 100644 index 0000000..7e7f6da --- /dev/null +++ b/src/equipment/hat.rs @@ -0,0 +1,18 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Hat { + name: String, + stat_mods: StatBlock, +} +impl Hat { + pub fn new() -> Hat { + Hat { + name: String::from("Basic Hat"), + stat_mods: StatBlock::new_zero(), + } + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } +} diff --git a/src/equipment/mod.rs b/src/equipment/mod.rs new file mode 100644 index 0000000..663cc2e --- /dev/null +++ b/src/equipment/mod.rs @@ -0,0 +1,107 @@ +mod comp; +mod gun; +mod hat; +mod pants; +mod shirt; +mod shoes; +mod sword; + +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct EquipmentBlock { + sword: Option, + gun: Option, + comp: Option, + head: Option, + chest: Option, + leg: Option, + foot: Option, +} +impl EquipmentBlock { + pub fn new() -> EquipmentBlock { + EquipmentBlock { + sword: None, + gun: None, + comp: None, + head: None, + chest: None, + leg: None, + foot: None, + } + } + pub fn sword(self) -> Option { + self.sword + } + pub fn gun(self) -> Option { + self.gun + } + pub fn comp(self) -> Option { + self.comp + } + pub fn hat(self) -> Option { + self.head + } + pub fn shirt(self) -> Option { + self.chest + } + pub fn pants(self) -> Option { + self.leg + } + pub fn shoes(self) -> Option { + self.foot + } + pub fn equip_sword(mut self, sword: sword::Sword) { + self.sword = Some(sword); + } + pub fn equip_gun(mut self, gun: gun::Gun) { + self.gun = Some(gun); + } + pub fn equip_comp(mut self, comp: comp::Comp) { + self.comp = Some(comp); + } + pub fn equip_hat(mut self, hat: hat::Hat) { + self.head = Some(hat); + } + pub fn equip_chest(mut self, shirt: shirt::Shirt) { + self.chest = Some(shirt); + } + pub fn equip_pants(mut self, pants: pants::Pants) { + self.leg = Some(pants); + } + pub fn equip_shoes(mut self, shoes: shoes::Shoes) { + self.foot = Some(shoes); + } + pub fn unequip_sword(mut self) { + self.sword = None; + } + pub fn unequip_gun(mut self) { + self.gun = None; + } + pub fn unequip_comp(mut self) { + self.comp = None; + } + pub fn unequip_hat(mut self) { + self.head = None; + } + pub fn unequip_shirt(mut self) { + self.chest = None; + } + pub fn unequip_pants(mut self) { + self.leg = None; + } + pub fn unequip_shoes(mut self) { + self.foot = None; + } + pub fn bonuses(self) -> StatBlock { + let mut stats = StatBlock::new_zero(); + stats += self.sword.unwrap_or(sword::Sword::new()).stat_mods(); + stats += self.gun.uwrap_or(gun::Gun::new()).stat_mods(); + stats += self.comp.unwrap_or(comp::Comp::new()).stat_mods(); + stats += self.head.unwrap_or(hat::Hat::new()).stat_mods(); + stats += self.chest.unwrap_or(shirt::Shirt::new()).stat_mods(); + stats += self.leg.unwrap_or(pants::Pants::new()).stat_mods(); + stats += self.foot.unwrap_or(shoes::Shoes::new()).stat_mods(); + stats + } +} diff --git a/src/equipment/pants.rs b/src/equipment/pants.rs new file mode 100644 index 0000000..d3d72a5 --- /dev/null +++ b/src/equipment/pants.rs @@ -0,0 +1,18 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Pants { + name: String, + stat_mods: StatBlock, +} +impl Pants { + pub fn new() -> Pants { + Pants { + name: String::from("Basic Pants"), + stat_mods: StatBlock::new_zero(), + } + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } +} diff --git a/src/equipment/shirt.rs b/src/equipment/shirt.rs new file mode 100644 index 0000000..e9ca756 --- /dev/null +++ b/src/equipment/shirt.rs @@ -0,0 +1,18 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Shirt { + name: String, + stat_mods: StatBlock, +} +impl Shirt { + pub fn new() -> Shirt { + Shirt { + name: String::from("Basic Shirt"), + stat_mods: StatBlock::new_zero(), + } + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } +} diff --git a/src/equipment/shoes.rs b/src/equipment/shoes.rs new file mode 100644 index 0000000..be18886 --- /dev/null +++ b/src/equipment/shoes.rs @@ -0,0 +1,18 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Shoes { + name: String, + stat_mods: StatBlock, +} +impl Shoes { + pub fn new() -> Shoes { + Shoes { + name: String::from("Basic Shoes"), + stat_mods: StatBlock::new_zero(), + } + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } +} diff --git a/src/equipment/sword.rs b/src/equipment/sword.rs new file mode 100644 index 0000000..a22eb3a --- /dev/null +++ b/src/equipment/sword.rs @@ -0,0 +1,84 @@ +use crate::statistics::StatBlock; + +#[derive(Debug, Clone)] +pub struct Sword { + id: String, + name: String, + damage: u8, + stat_mods: StatBlock, + flavor: String, + description: String, +} +impl Sword { + pub fn new() -> Self { + Self { + id: String::from("SWORD_BLANK"), + name: String::from("Basic Sword"), + damage: 1u8, + stat_mods: StatBlock::new_zero(), + flavor: String::from("A basic bitch sword. It is completely useless."), + description: String::from("1 Attack Strength Sword. Literally the cheapest you can get."), + } + } + pub fn id(self) -> String { + self.id + } + pub fn name(self) -> String { + self.name + } + pub fn damage(self) -> u8 { + self.damage + } + pub fn stat_mods(self) -> StatBlock { + self.stat_mods + } + pub fn flavor(self) -> String { + self.flavor + } + pub fn description(self) -> String { + self.description + } + pub fn set_id(&mut self, id: String) { + self.id = id; + } + pub fn set_name(&mut self, name: String) { + self.name = name; + } + pub fn set_damage(&mut self, damage: u8) { + self.damage = damage; + } + pub fn set_stat_mods(&mut self, stat_mods: StatBlock) { + self.stat_mods = stat_mods; + } + pub fn set_flavor(&mut self, flavor: String) { + self.flavor = flavor; + } + pub fn set_description(&mut self, description: String) { + self.description = description; + } + + pub fn sacred_blade() -> Self { + let mut buf = StatBlock::new_zero(); + buf.set_strength(5); + Self { + id: String::from("SWORD_SACRED_BLADE"), + name: String::from("Sacred Blade"), + damage: 58u8, + stat_mods: buf, + flavor: String::from("Forged eons ago by master smiths and imbued with the magic of gods."), + description: String::from("+5 Strength. 58 Attack. The sacred sword of a religious cult."), + } + } + pub fn ceremonial_knife() -> Self { + let mut buf = StatBlock::new_zero(); + buf.set_intellect(2); + Self { + id: String::from("SWORD_CEREMONIAL_KNIFE"), + name: String::from("Ceremonial Knife"), + damage: 27u8, + stat_mods: buf, + flavor: String::from("Used for sex parties, mostly."), + description: String::from("+2 Intellect. 27 Attack. Used by wiccans during rites."), + } + } +} diff --git a/src/inventory.rs b/src/inventory.rs new file mode 100644 index 0000000..ad52a20 --- /dev/null +++ b/src/inventory.rs @@ -0,0 +1,16 @@ +use crate::equipment::{sword::Sword, gun::Gun, comp::Comp, hat::Hat, shirt::Shirt, pants::Pants, shoes::Shoes}; + +struct BagEquipment { + swords: Option>, + guns: Option>, + comps: Option>, + hats: Option>, + shirts: Option>, + pants: Option>, + shoes: Option>, +} + +struct Inventory { + equipment: Option, + +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..8115822 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,6 @@ +pub mod equipment; +pub mod magic; +pub mod statistics; +pub mod unit; +pub mod inventory; +pub mod status; diff --git a/src/magic.rs b/src/magic.rs new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/magic.rs @@ -0,0 +1 @@ + diff --git a/src/statistics.rs b/src/statistics.rs new file mode 100644 index 0000000..cfab117 --- /dev/null +++ b/src/statistics.rs @@ -0,0 +1,148 @@ +#[derive(Debug, Copy, Clone)] +pub struct StatBlock { + strength: i8, // determines physical attack power + magick: i8, // determines magick attack power + defense: i8, // determines damage reduction + intellect: i8, // determines magick hit chance and evasion chance + dexterity: i8, // determines physical hit chance and evasion chance + agility: i8, // determines turn order + vitality: i8, // determines HP/level +} + +impl std::ops::Add for StatBlock { + type Output = Self; + fn add(self, other: Self) -> Self { + Self { + strength: self.strength + other.strength, + magick: self.magick + other.magick, + defense: self.defense + other.defense, + intellect: self.intellect + other.intellect, + dexterity: self.dexterity + other.dexterity, + agility: self.agility + other.agility, + vitality: self.vitality + other.vitality, + } + } +} + +impl std::ops::AddAssign for StatBlock { + fn add_assign(&mut self, other: Self) { + *self = Self { + strength: self.strength + other.strength, + magick: self.magick + other.magick, + defense: self.defense + other.defense, + intellect: self.intellect + other.intellect, + dexterity: self.dexterity + other.dexterity, + agility: self.agility + other.agility, + vitality: self.vitality + other.vitality, + }; + } +} + +impl std::ops::Sub for StatBlock { + type Output = Self; + fn sub(self, other: Self) -> Self { + Self { + strength: self.strength - other.strength, + magick: self.magick - other.magick, + defense: self.defense - other.defense, + intellect: self.intellect - other.intellect, + dexterity: self.dexterity - other.dexterity, + agility: self.agility - other.agility, + vitality: self.vitality - other.vitality, + } + } +} + +impl StatBlock { + /// Generates a level 1 stat block + pub fn new() -> StatBlock { + StatBlock { + strength: 3, + magick: 3, + defense: 3, + intellect: 3, + dexterity: 3, + agility: 3, + vitality: 3, + } + } + /// Generates a null stat block + pub fn new_zero() -> StatBlock { + StatBlock { + strength: 0, + magick: 0, + defense: 0, + intellect: 0, + dexterity: 0, + agility: 0, + vitality: 0, + } + } + /// Generates a null stat block for use as the bonus_stat block + pub fn new_bonus() -> StatBlock { + StatBlock::new_zero() + } + pub fn strength(self) -> i8 { + self.strength + } + pub fn magick(self) -> i8 { + self.magick + } + pub fn defense(self) -> i8 { + self.defense + } + pub fn intellect(self) -> i8 { + self.intellect + } + pub fn dexterity(self) -> i8 { + self.dexterity + } + pub fn agility(self) -> i8 { + self.agility + } + pub fn vitality(self) -> i8 { + self.vitality + } + pub fn set_strength(&mut self, strength: i8) { + self.strength = strength; + } + pub fn set_magick(&mut self, magick: i8) { + self.magick = magick; + } + pub fn set_defense(&mut self, defense: i8) { + self.defense = defense; + } + pub fn set_intellect(&mut self, intellect: i8) { + self.intellect = intellect; + } + pub fn set_dexterity(&mut self, dexterity: i8) { + self.dexterity = dexterity; + } + pub fn set_agility(&mut self, agility: i8) { + self.agility = agility; + } + pub fn set_vitality(&mut self, vitality: i8) { + self.vitality = vitality; + } + pub fn add_strength(&mut self, count: i8) { + self.strength = self.strength.saturating_add(count); + } + pub fn add_magick(&mut self, count: i8) { + self.magick = self.magick.saturating_add(count); + } + pub fn add_defense(&mut self, count: i8) { + self.defense = self.defense.saturating_add(count); + } + pub fn add_intellect(&mut self, count: i8) { + self.intellect = self.intellect.saturating_add(count); + } + pub fn add_dexterity(&mut self, count: i8) { + self.dexterity = self.dexterity.saturating_add(count); + } + pub fn add_agility(&mut self, count: i8) { + self.agility = self.agility.saturating_add(count); + } + pub fn add_vitality(&mut self, count: i8) { + self.vitality = self.vitality.saturating_add(count); + } +} diff --git a/src/status.rs b/src/status.rs new file mode 100644 index 0000000..199db50 --- /dev/null +++ b/src/status.rs @@ -0,0 +1,11 @@ +#[derive(Debug, Copy, Clone)] +pub enum Status { + Poison, // hp slowly decreases + Static, // chance to miss turn + Freeze, // hp slowly decreases and chance to miss turn + Burn, // hp slowly decreases and unable to cast magic + Slow, // speed is halved + Confuse, // chance to hit random target (self included) + Stop, // miss turn + Haste, // speed is doubled +} diff --git a/src/unit.rs b/src/unit.rs new file mode 100644 index 0000000..84a4075 --- /dev/null +++ b/src/unit.rs @@ -0,0 +1,213 @@ +use crate::equipment::EquipmentBlock; +use crate::statistics::StatBlock; +use crate::status::Status; +use rand::seq::SliceRandom; +use rand::Rng; + +const MASC_NAMES: &'static [&'static str] = &["Antonio", "Brandon", "Charles", "Denzel", "Edgar"]; +const FEMME_NAMES: &'static [&'static str] = &["Alice", "Bethany", "Cynthia", "Dawn", "Elizabeth"]; +const NEUTR_NAMES: &'static [&'static str] = &["Aspen", "Blake", "Charlie", "Dekota", "Emery"]; + +#[derive(Debug, Copy, Clone)] +pub enum Gender { + Man, + Woman, + Nonbinary, + DemiGirl, + DemiBoy, + NoGender, +} + +#[derive(Debug, Clone)] +pub struct Unit { + name: String, + level: u8, + exp: u32, + status: Option<(Option,Option)>, + gender: Gender, + base_stats: StatBlock, + hp: u16, + jel: u8, + jel_total: u8, + is_monster: bool, + equipment: Option, +} + +impl Unit { + pub fn new() -> Unit { + let mut rng = rand::thread_rng(); + let j = rng.gen_range(10..26); + Unit { + name: String::from("Basic Unit"), + level: 1, + exp: 0, + status: None, + gender: Gender::NoGender, + base_stats: StatBlock::new(), + hp: 18, + jel: j, + jel_total: j, + is_monster: true, + equipment: None, + } + } + pub fn name(self) -> String { + self.name + } + pub fn level(self) -> u8 { + self.level + } + pub fn gender(self) -> Gender { + self.gender + } + pub fn stats(self) -> StatBlock { + self.base_stats + self.stat_bonus() + } + pub fn base_stats(self) -> StatBlock { + self.base_stats + } + pub fn stat_bonus(self) -> StatBlock { + match self.equipment() { + Some(e) => e.bonuses(), + None => StatBlock::new_zero(), + } + } + pub fn hp(self) -> u16 { + self.hp + } + pub fn hp_max(self) -> u16 { + u16::from( + 18u16 + + (u16::from(self.level) + * u16::from(0u8.wrapping_add_signed(self.stats().vitality()))), + ) + } + pub fn jel(self) -> u8 { + self.jel + } + pub fn jel_total(self) -> u8 { + self.jel_total + } + pub fn is_monster(self) -> bool { + self.is_monster + } + pub fn equipment(self) -> Option { + if self.is_monster { + return None; + } + self.equipment + } + + pub fn generate_gender() -> Gender { + let gender_variants = [ + Gender::Man, + Gender::Woman, + Gender::Nonbinary, + Gender::DemiGirl, + Gender::DemiBoy, + ]; + match gender_variants.choose(&mut rand::thread_rng()) { + Some(g) => g.to_owned(), + None => Gender::NoGender, + } + } + pub fn generate_name(g: &Gender) -> String { + let names = match g { + Gender::Man => MASC_NAMES.to_vec(), + Gender::Woman => FEMME_NAMES.to_vec(), + Gender::Nonbinary => NEUTR_NAMES.to_vec(), + Gender::DemiGirl => [FEMME_NAMES, NEUTR_NAMES].concat(), + Gender::DemiBoy => [MASC_NAMES, NEUTR_NAMES].concat(), + Gender::NoGender => [MASC_NAMES, FEMME_NAMES, NEUTR_NAMES].concat(), + _ => return String::from("MISSINGNO"), + }; + match names.choose(&mut rand::thread_rng()) { + Some(n) => String::from(n.clone()), + None => String::from("MISSINGNO"), + } + } + + pub fn human_battle_maniac(lv: u8) -> Unit { + let mut rng = rand::thread_rng(); + let mut j = rng.gen_range(10..26); + if lv > 20 { + j += rng.gen_range(10..26); + } + let g = Unit::generate_gender(); + let n = format!("Battle Maniac {}", Unit::generate_name(&g)); // Excuse me, but may I + // borrow your gender for a + // moment? + let mut sb = StatBlock::new(); + for _i in 0..lv { + match rng.gen_range(0..4) { + 0 => sb.add_strength(1), + 1 => sb.add_defense(1), + 2 => sb.add_vitality(1), + 3 => sb.add_intellect(1), + _ => { + eprintln!("ERROR! human_battle_maniac() stat assign out of bounds!"); + sb.add_vitality(1); + }, + }; + } + let mut equip = EquipmentBlock::new(); + + //TODO: create equipment and equipment allocation algorithm + Unit { + name: n, + level: lv, + exp: 0, //TODO!! Fix this + status: None, + gender: g, + base_stats: sb.clone(), + hp: u16::from( + 18u16 + (u16::from(lv) * u16::from(0u8.wrapping_add_signed(sb.vitality()))), + ), + jel: j, + jel_total: j, + is_monster: false, + equipment: Some(equip), + } + } + pub fn human_street_samurai(lv: u8) -> Unit { + let mut rng = rand::thread_rng(); + let mut j = rng.gen_range(10..26); + if rng.gen_range(0..100) < 25 && lv > 20 { + j += rng.gen_range(10..26); + } + let g = Unit::generate_gender(); + let n = format!("Street Samurai {}", Unit::generate_name(&g)); + + let mut sb = StatBlock::new(); + for _i in 0..lv { + match rng.gen_range(0..4) { + 0 => sb.add_strength(1), + 1 => sb.add_defense(1), + 2 => sb.add_vitality(1), + 3 => sb.add_agility(1), + _ => { + eprintln!("ERROR! human_street_samurai() stat assign out of bounds!"); + sb.add_vitality(1); + }, + }; + } + let mut equip = EquipmentBlock::new(); + //TODO: create equipment and equipment allocation algorithm + + Unit { + name: n, + level: lv, + exp: 0, //TODO!! fix this + status: None, + gender: g, + base_stats: sb.clone(), + hp: u16::from( + 18u16 + (u16::from(lv) * u16::from(0u8.wrapping_add_signed(sb.vitality()))), + ), + jel: j, + jel_total: j, + is_monster: false, + equipment: Some(equip), + } + } +}