Further massive amounts of work

Cargo.toml

@@ -49,4 +49,6 @@ rand_pcg = "0.3.1"
 maplit = "1.0.2"
 failure = "0.1.8"
 failure_derive = "0.1.8"
-lazy_static = "1.4.0"
+lazy_static = "1.4.0"
+hashbrown = "0.12.1"
+indexmap = "1.8.2"

src/dynamic_data/event_hooks/event_hook.rs

@@ -33,4 +33,9 @@ pub enum Event<'a> {
         index: u8,
         pokemon: Option<Arc<RwLock<Pokemon<'a>>>>,
     },
+    Swap {
+        side_index: u8,
+        index_a: u8,
+        index_b: u8,
+    },
 }

src/dynamic_data/libraries/battle_stat_calculator.rs

@@ -1,3 +1,80 @@
-pub trait BattleStatCalculator {
-    //fn is_critical(attack: &ExecutingMove, target: &Pokemon, hit: u8);
+use crate::dynamic_data::models::pokemon::Pokemon;
+use crate::static_data::statistic_set::StatisticSet;
+use crate::static_data::statistics::Statistic;
+
+#[derive(Debug)]
+pub struct BattleStatCalculator {}
+
+impl BattleStatCalculator {
+    pub fn calculate_flat_stats(&self, pokemon: &Pokemon) -> StatisticSet<u32> {
+        StatisticSet::<u32>::new(
+            self.calculate_health_stat(pokemon),
+            self.calculate_other_stat(pokemon, Statistic::Attack),
+            self.calculate_other_stat(pokemon, Statistic::Defense),
+            self.calculate_other_stat(pokemon, Statistic::SpecialAttack),
+            self.calculate_other_stat(pokemon, Statistic::SpecialDefense),
+            self.calculate_other_stat(pokemon, Statistic::Speed),
+        )
+    }
+
+    pub fn calculate_flat_stat(&self, pokemon: &Pokemon, stat: Statistic) -> u32 {
+        if stat == Statistic::HP {
+            self.calculate_health_stat(pokemon)
+        } else {
+            self.calculate_other_stat(pokemon, stat)
+        }
+    }
+
+    pub fn calculate_boosted_stats(&self, pokemon: &Pokemon) -> StatisticSet<u32> {
+        StatisticSet::<u32>::new(
+            self.calculate_boosted_stat(pokemon, Statistic::HP),
+            self.calculate_boosted_stat(pokemon, Statistic::Attack),
+            self.calculate_boosted_stat(pokemon, Statistic::Defense),
+            self.calculate_boosted_stat(pokemon, Statistic::SpecialAttack),
+            self.calculate_boosted_stat(pokemon, Statistic::SpecialDefense),
+            self.calculate_boosted_stat(pokemon, Statistic::Speed),
+        )
+    }
+
+    pub fn calculate_boosted_stat(&self, pokemon: &Pokemon, stat: Statistic) -> u32 {
+        (self.calculate_flat_stat(pokemon, stat) as f32
+            * self.get_stat_boost_modifier(pokemon, stat)) as u32
+    }
+
+    fn calculate_health_stat(&self, pokemon: &Pokemon) -> u32 {
+        let base = pokemon.form().get_base_stat(Statistic::HP) as u32;
+        let iv = *pokemon.individual_values().hp() as u32;
+        let ev = *pokemon.effort_values().hp() as u32;
+        let level = *pokemon.level() as u32;
+        (((2 * base + iv + (ev / 4)) * level) / 100) + level + 10
+    }
+
+    fn calculate_other_stat(&self, pokemon: &Pokemon, stat: Statistic) -> u32 {
+        let base = pokemon.form().get_base_stat(stat) as u32;
+        let iv = pokemon.individual_values().get_stat(stat) as u32;
+        let ev = pokemon.effort_values().get_stat(stat) as u32;
+        let level = *pokemon.level() as u32;
+        let unmodified = (((2 * base + iv + (ev / 4)) * level) / 100) + 5;
+        return (unmodified as f32 * pokemon.nature().get_stat_modifier(stat)) as u32;
+    }
+
+    fn get_stat_boost_modifier(&self, pokemon: &Pokemon, stat: Statistic) -> f32 {
+        let boost = pokemon.stat_boost().get_stat(stat);
+        match boost {
+            -6 => 2.0 / 8.0,
+            -5 => 2.0 / 7.0,
+            -4 => 2.0 / 6.0,
+            -3 => 2.0 / 5.0,
+            -2 => 2.0 / 4.0,
+            -1 => 2.0 / 3.0,
+            0 => 1.0,
+            1 => 3.0 / 2.0,
+            2 => 4.0 / 2.0,
+            3 => 5.0 / 2.0,
+            4 => 6.0 / 2.0,
+            5 => 7.0 / 2.0,
+            6 => 8.0 / 2.0,
+            _ => panic!("Stat boost was out of expected range of -6 to 6"),
+        }
+    }
 }

src/dynamic_data/libraries/dynamic_library.rs

@@ -1,19 +1,42 @@
+use crate::dynamic_data::libraries::battle_stat_calculator::BattleStatCalculator;
+use crate::dynamic_data::libraries::script_resolver::ScriptCategory;
+use crate::dynamic_data::script_handling::script::Script;
 use crate::static_data::libraries::static_data::StaticData;
-use derive_getters::Getters;
+use crate::PkmnResult;
 
-#[derive(Getters, Debug)]
+#[derive(Debug)]
 pub struct DynamicLibrary<'a> {
     static_data: StaticData<'a>,
+    stat_calculator: BattleStatCalculator,
+}
+
+impl<'a> DynamicLibrary<'a> {
+    pub fn static_data(&self) -> &StaticData<'a> {
+        &self.static_data
+    }
+    pub fn stat_calculator(&self) -> &BattleStatCalculator {
+        &self.stat_calculator
+    }
+
+    pub fn load_script(
+        &self,
+        _category: ScriptCategory,
+        _key: &str,
+    ) -> PkmnResult<Box<dyn Script>> {
+        todo!()
+    }
 }
 
 #[cfg(test)]
 pub mod test {
+    use crate::dynamic_data::libraries::battle_stat_calculator::BattleStatCalculator;
     use crate::dynamic_data::libraries::dynamic_library::DynamicLibrary;
     use crate::static_data::libraries::static_data;
 
     pub fn build<'a>() -> DynamicLibrary<'a> {
         DynamicLibrary {
             static_data: static_data::test::build(),
+            stat_calculator: BattleStatCalculator {},
         }
     }
 }

src/dynamic_data/libraries/mod.rs

@@ -1,2 +1,3 @@
 pub mod battle_stat_calculator;
 pub mod dynamic_library;
+pub mod script_resolver;

src/dynamic_data/libraries/script_resolver.rs

@@ -0,0 +1,12 @@
+pub trait ScriptResolver {}
+
+#[derive(Debug, Clone)]
+pub enum ScriptCategory {
+    Move,
+    Ability,
+    Status,
+    Pokemon,
+    Battle,
+    Side,
+    ItemBattleTrigger,
+}

src/dynamic_data/models/battle.rs

@@ -12,8 +12,9 @@ use std::sync::{Arc, RwLock};
 
 #[derive(Getters, Debug)]
 pub struct Battle<'a> {
+    #[getter(skip)]
     library: &'a DynamicLibrary<'a>,
-    parties: Vec<BattleParty>,
+    parties: Vec<BattleParty<'a>>,
     can_flee: bool,
     number_of_sides: u8,
     pokemon_per_side: u8,
@@ -33,7 +34,7 @@ pub struct Battle<'a> {
 impl<'a> Battle<'a> {
     pub fn new(
         library: &'a DynamicLibrary<'a>,
-        parties: Vec<BattleParty>,
+        parties: Vec<BattleParty<'a>>,
         can_flee: bool,
         number_of_sides: u8,
         pokemon_per_side: u8,
@@ -59,7 +60,7 @@ impl<'a> Battle<'a> {
             event_hook: Default::default(),
             history_holder: Box::new(HistoryHolder {}),
             current_turn: 0,
-            volatile: ScriptSet {},
+            volatile: ScriptSet::default(),
             last_turn_time: 0,
         }));
 
@@ -77,4 +78,8 @@ impl<'a> Battle<'a> {
     pub fn can_slot_be_filled(&self) -> bool {
         todo!()
     }
+
+    pub fn library(&self) -> &'a DynamicLibrary<'a> {
+        self.library
+    }
 }

src/dynamic_data/models/battle_party.rs

@@ -1,2 +1,28 @@
+use crate::dynamic_data::models::pokemon_party::PokemonParty;
+
 #[derive(Debug)]
-pub struct BattleParty {}
+pub struct BattleParty<'a> {
+    party: &'a PokemonParty<'a>,
+    responsible_indices: Vec<(u8, u8)>,
+}
+
+impl<'a> BattleParty<'a> {
+    pub fn is_responsible_for_index(&self, side: u8, index: u8) -> bool {
+        for responsible_index in &self.responsible_indices {
+            if responsible_index.0 == side && responsible_index.1 == index {
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn has_pokemon_not_in_field(&self) -> bool {
+        for pokemon in self.party.pokemon().iter().flatten() {
+            let pokemon = pokemon.read().unwrap();
+            if pokemon.is_usable() && !pokemon.is_on_battlefield() {
+                return true;
+            }
+        }
+        false
+    }
+}

src/dynamic_data/models/battle_random.rs

@@ -17,6 +17,16 @@ impl BattleRandom {
     pub fn get_rng(&self) -> &Mutex<Random> {
         &self.random
     }
+
+    pub fn get(&self) -> i32 {
+        return self.get_rng().lock().unwrap().get();
+    }
+    pub fn get_max(&self, max: i32) -> i32 {
+        return self.get_rng().lock().unwrap().get_max(max);
+    }
+    pub fn get_between(&self, min: i32, max: i32) -> i32 {
+        return self.get_rng().lock().unwrap().get_between(min, max);
+    }
 }
 
 impl Debug for BattleRandom {

src/dynamic_data/models/battle_side.rs

@@ -1,9 +1,13 @@
 use crate::dynamic_data::choices::TurnChoice;
 use crate::dynamic_data::event_hooks::event_hook::Event;
 use crate::dynamic_data::models::battle::Battle;
+use crate::dynamic_data::models::battle_party::BattleParty;
 use crate::dynamic_data::models::pokemon::Pokemon;
+use crate::dynamic_data::script_handling::script::Script;
+use crate::dynamic_data::script_handling::script_set::ScriptSet;
+use crate::dynamic_data::script_handling::volatile_scripts::VolatileScripts;
 use crate::dynamic_data::script_handling::ScriptSource;
-use crate::script_hook;
+use crate::{script_hook, PkmnResult};
 use derive_getters::Getters;
 use std::sync::{Arc, RwLock, Weak};
 
@@ -16,7 +20,8 @@ pub struct BattleSide<'a> {
     fillable_slots: Vec<bool>,
     choices_set: u8,
     battle: Weak<RwLock<Battle<'a>>>,
-    has_fled: bool,
+    has_fled_battle: bool,
+    volatile_scripts: Arc<RwLock<ScriptSet>>,
 }
 
 impl<'a> BattleSide<'a> {
@@ -39,7 +44,8 @@ impl<'a> BattleSide<'a> {
             fillable_slots,
             choices_set: 0,
             battle,
-            has_fled: false,
+            has_fled_battle: false,
+            volatile_scripts: Default::default(),
         }
     }
 
@@ -136,6 +142,113 @@ impl<'a> BattleSide<'a> {
         }
         false
     }
+
+    pub fn mark_slot_as_unfillable(&mut self, pokemon: Arc<Pokemon<'a>>) {
+        for (i, slot) in self.pokemon.iter().enumerate() {
+            if let Some(p) = slot {
+                if p.read().unwrap().unique_identifier() == pokemon.unique_identifier() {
+                    self.fillable_slots[i] = false;
+                    return;
+                }
+            }
+        }
+    }
+
+    pub fn is_slot_unfillable(&self, pokemon: Arc<Pokemon<'a>>) -> bool {
+        for (i, slot) in self.pokemon.iter().enumerate() {
+            if let Some(p) = slot {
+                if p.read().unwrap().unique_identifier() == pokemon.unique_identifier() {
+                    return self.fillable_slots[i];
+                }
+            }
+        }
+        false
+    }
+
+    pub fn is_defeated(&self) -> bool {
+        for fillable_slot in &self.fillable_slots {
+            if *fillable_slot {
+                return false;
+            }
+        }
+        true
+    }
+
+    pub fn has_fled(&self) -> bool {
+        self.has_fled_battle
+    }
+
+    pub fn mark_as_fled(&mut self) {
+        self.has_fled_battle = true;
+    }
+
+    pub fn get_random_creature_index(&self) -> u8 {
+        // TODO: Consider adding parameter to only get index for available creatures.
+        self.battle
+            .upgrade()
+            .unwrap()
+            .read()
+            .unwrap()
+            .random()
+            .get_max(self.pokemon_per_side as i32) as u8
+    }
+
+    pub fn swap_positions(&mut self, a: u8, b: u8) -> bool {
+        // If out of range, don't allow swapping.
+        if a >= self.pokemon_per_side || b >= self.pokemon_per_side {
+            return false;
+        }
+        // If the two indices are the same, don't allow swapping.
+        if a == b {
+            return false;
+        }
+
+        let battle = self.battle.upgrade().unwrap();
+        let battle = battle.read().unwrap();
+        // Fetch parties for the two indices.
+        let mut party_a = None;
+        let mut party_b = None;
+        for party in battle.parties() {
+            if party.is_responsible_for_index(self.index, a) {
+                party_a = Some(party);
+            }
+            if party.is_responsible_for_index(self.index, b) {
+                party_b = Some(party);
+            }
+        }
+        // If either of the parties does not exist, fail.
+        if party_a.is_none() || party_b.is_none() {
+            return false;
+        }
+        // Don't allow swapping if different parties are responsible for the indices.
+        if party_a.unwrap() as *const BattleParty != party_b.unwrap() as *const BattleParty {
+            return false;
+        }
+
+        self.pokemon.swap(a as usize, b as usize);
+        battle.event_hook().trigger(Event::Swap {
+            side_index: self.index,
+            index_a: a,
+            index_b: b,
+        });
+        true
+    }
+}
+
+impl<'a> VolatileScripts<'a> for BattleSide<'a> {
+    fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
+        &self.volatile_scripts
+    }
+
+    fn load_volatile_script(&self, key: &str) -> PkmnResult<Box<dyn Script>> {
+        self.battle
+            .upgrade()
+            .unwrap()
+            .read()
+            .unwrap()
+            .library()
+            .load_script(crate::ScriptCategory::Side, key)
+    }
 }
 
 impl<'a> ScriptSource for BattleSide<'a> {

src/dynamic_data/models/mod.rs

@@ -5,3 +5,4 @@ pub mod battle_result;
 pub mod battle_side;
 pub mod learned_move;
 pub mod pokemon;
+pub mod pokemon_party;

src/dynamic_data/models/pokemon.rs

@@ -4,18 +4,21 @@ use crate::dynamic_data::models::battle::Battle;
 use crate::dynamic_data::models::learned_move::LearnedMove;
 use crate::dynamic_data::script_handling::script::Script;
 use crate::dynamic_data::script_handling::script_set::ScriptSet;
+use crate::dynamic_data::script_handling::volatile_scripts::VolatileScripts;
 use crate::dynamic_data::script_handling::ScriptSource;
 use crate::static_data::items::item::Item;
+use crate::static_data::natures::Nature;
 use crate::static_data::species_data::ability_index::AbilityIndex;
 use crate::static_data::species_data::form::Form;
 use crate::static_data::species_data::gender::Gender;
 use crate::static_data::species_data::species::Species;
-use crate::static_data::statistic_set::StatisticSet;
+use crate::static_data::statistic_set::{ClampedStatisticSet, StatisticSet};
 use crate::static_data::statistics::Statistic;
 use crate::utils::random::Random;
+use crate::{PkmnResult, ScriptCategory};
 use derive_getters::Getters;
 use std::collections::HashSet;
-use std::sync::{RwLock, Weak};
+use std::sync::{Arc, RwLock, Weak};
 
 #[derive(Debug)]
 pub struct PokemonBattleData<'a> {
@@ -45,6 +48,7 @@ impl<'a> PokemonBattleData<'a> {
 pub struct Pokemon<'a> {
     library: &'a DynamicLibrary<'a>,
     species: &'a Species<'a>,
+    #[getter(skip)]
     form: &'a Form<'a>,
 
     display_species: Option<&'a Species<'a>>,
@@ -56,14 +60,18 @@ pub struct Pokemon<'a> {
     gender: Gender,
     coloring: u8,
     held_item: Option<&'a Item>,
-    health: u32,
+    current_health: u32,
 
     weight: f32,
     height: f32,
 
-    stat_boost: StatisticSet<i8>,
-    flat_stats: StatisticSet<u16>,
-    boosted_stats: StatisticSet<u16>,
+    stat_boost: ClampedStatisticSet<i8, -6, 6>,
+    flat_stats: StatisticSet<u32>,
+    boosted_stats: StatisticSet<u32>,
+    individual_values: ClampedStatisticSet<u8, 0, 31>,
+    effort_values: ClampedStatisticSet<u8, 0, 252>,
+    #[getter(skip)]
+    nature: &'a Nature,
 
     nickname: Option<String>,
 
@@ -80,7 +88,7 @@ pub struct Pokemon<'a> {
 
     ability_script: Option<Box<dyn Script>>,
     status_script: Option<Box<dyn Script>>,
-    volatile: ScriptSet,
+    volatile: Arc<RwLock<ScriptSet>>,
 }
 
 impl<'a> Pokemon<'a> {
@@ -93,6 +101,7 @@ impl<'a> Pokemon<'a> {
         unique_identifier: u32,
         gender: Gender,
         coloring: u8,
+        nature: String,
     ) -> Pokemon<'a> {
         // Calculate experience from the level for the specified growth rate.
         let experience = library
@@ -102,7 +111,12 @@ impl<'a> Pokemon<'a> {
         let health = form.get_base_stat(Statistic::HP) as u32;
         let weight = *form.weight();
         let height = *form.height();
-        Pokemon {
+        let nature = library
+            .static_data()
+            .natures()
+            .get_nature(&nature)
+            .expect("Unknown nature name was given.");
+        let mut pokemon = Pokemon {
             library,
             species,
             form,
@@ -114,12 +128,15 @@ impl<'a> Pokemon<'a> {
             gender,
             coloring,
             held_item: None,
-            health,
+            current_health: health,
             weight,
             height,
             stat_boost: Default::default(),
-            flat_stats: *form.base_stats(),
-            boosted_stats: *form.base_stats(),
+            flat_stats: Default::default(),
+            boosted_stats: Default::default(),
+            individual_values: Default::default(),
+            effort_values: Default::default(),
+            nature,
             nickname: None,
             ability_index: ability,
             is_ability_overridden: false,
@@ -130,8 +147,26 @@ impl<'a> Pokemon<'a> {
             types: form.types().to_vec(),
             ability_script: None,
             status_script: None,
-            volatile: ScriptSet {},
-        }
+            volatile: Default::default(),
+        };
+        pokemon.recalculate_flat_stats();
+
+        pokemon
+    }
+
+    pub fn form(&self) -> &'a Form<'a> {
+        self.form
+    }
+    pub fn nature(&self) -> &'a Nature {
+        self.nature
+    }
+
+    pub fn recalculate_flat_stats(&mut self) {
+        self.flat_stats = self.library.stat_calculator().calculate_flat_stats(self);
+        self.recalculate_boosted_stats();
+    }
+    pub fn recalculate_boosted_stats(&mut self) {
+        self.boosted_stats = self.library.stat_calculator().calculate_boosted_stats(self);
     }
 
     pub fn change_species(&mut self, species: &'a Species, form: &'a Form) {
@@ -188,7 +223,7 @@ impl<'a> Pokemon<'a> {
         if let Some(data) = &mut self.battle_data {
             data.on_battle_field = value;
             if !value {
-                self.reset_active_scripts();
+                self.volatile.write().unwrap().clear();
                 self.weight = *self.form.weight();
                 self.height = *self.form.height();
             }
@@ -201,15 +236,19 @@ impl<'a> Pokemon<'a> {
         }
     }
 
+    pub fn is_on_battlefield(&self) -> bool {
+        if let Some(data) = &self.battle_data {
+            data.on_battle_field
+        } else {
+            false
+        }
+    }
+
     pub fn mark_opponent_as_seen(&mut self, unique_identifier: u32) {
         if let Some(battle_data) = &mut self.battle_data {
             battle_data.seen_opponents.insert(unique_identifier);
         }
     }
-
-    pub fn reset_active_scripts(&mut self) {
-        todo!()
-    }
 }
 
 impl<'a> ScriptSource for Pokemon<'a> {
@@ -218,6 +257,16 @@ impl<'a> ScriptSource for Pokemon<'a> {
     }
 }
 
+impl<'a> VolatileScripts<'a> for Pokemon<'a> {
+    fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
+        &self.volatile
+    }
+
+    fn load_volatile_script(&self, key: &str) -> PkmnResult<Box<dyn Script>> {
+        self.library.load_script(ScriptCategory::Pokemon, key)
+    }
+}
+
 #[cfg(test)]
 pub mod test {
     use crate::dynamic_data::libraries::dynamic_library;
@@ -244,6 +293,7 @@ pub mod test {
             0,
             Gender::Male,
             0,
+            "test_nature".to_string(),
         );
         assert_eq!(pokemon.species.name(), "foo");
         assert_eq!(pokemon.form.name(), "default");

src/dynamic_data/models/pokemon_party.rs

@@ -0,0 +1,80 @@
+use crate::dynamic_data::models::pokemon::Pokemon;
+use std::sync::{Arc, RwLock};
+
+#[derive(Debug)]
+pub struct PokemonParty<'a> {
+    pokemon: Vec<Option<Arc<RwLock<Pokemon<'a>>>>>,
+}
+
+impl<'a> PokemonParty<'a> {
+    pub fn new(size: usize) -> Self {
+        let mut pokemon = Vec::with_capacity(size);
+        for _i in 0..size {
+            pokemon.push(None);
+        }
+        Self { pokemon }
+    }
+
+    pub fn at(&self, index: usize) -> &Option<Arc<RwLock<Pokemon<'a>>>> {
+        let opt = self.pokemon.get(index);
+        if let Some(v) = opt {
+            v
+        } else {
+            &None
+        }
+    }
+
+    pub fn switch(&mut self, a: usize, b: usize) {
+        self.pokemon.swap(a, b);
+    }
+
+    pub fn swap_into(
+        &mut self,
+        index: usize,
+        pokemon: Option<Arc<RwLock<Pokemon<'a>>>>,
+    ) -> Option<Arc<RwLock<Pokemon<'a>>>> {
+        if index >= self.pokemon.len() {
+            return pokemon;
+        }
+        let old = self.pokemon[index].as_ref().cloned();
+        self.pokemon[index] = pokemon;
+        old
+    }
+
+    pub fn has_usable_pokemon(&self) -> bool {
+        for pokemon in self.pokemon.iter().flatten() {
+            if pokemon.read().unwrap().is_usable() {
+                return true;
+            }
+        }
+        false
+    }
+
+    pub fn length(&self) -> usize {
+        self.pokemon.len()
+    }
+
+    pub fn pokemon(&self) -> &Vec<Option<Arc<RwLock<Pokemon<'a>>>>> {
+        &self.pokemon
+    }
+
+    pub fn pack_party(&mut self) {
+        let mut first_empty = None;
+        let mut i = 0;
+        loop {
+            if self.pokemon[i].is_none() {
+                if first_empty.is_none() {
+                    first_empty = Some(i)
+                }
+            } else if first_empty.is_some() {
+                self.pokemon.swap(first_empty.unwrap(), i);
+                i = first_empty.unwrap();
+                first_empty = None;
+            }
+            i += 1;
+            if i >= self.pokemon.len() {
+                break;
+            }
+        }
+    }
+}

src/dynamic_data/script_handling/mod.rs

@@ -1,8 +1,10 @@
 use crate::dynamic_data::script_handling::script::Script;
 use crate::dynamic_data::script_handling::script_set::ScriptSet;
+use std::sync::Weak;
 
 pub mod script;
 pub mod script_set;
+pub mod volatile_scripts;
 
 #[macro_export]
 macro_rules! script_hook {
@@ -24,20 +26,20 @@ pub trait ScriptSource {
     fn get_script_count(&self);
 }
 
-pub enum ScriptWrapper<'a> {
-    Script(&'a Box<dyn Script>),
-    Set(&'a ScriptSet),
+pub enum ScriptWrapper {
+    Script(Weak<Box<dyn Script>>),
+    Set(Weak<ScriptSet>),
 }
 
-pub struct ScriptAggregator<'a> {
-    scripts: Vec<Option<ScriptWrapper<'a>>>,
+pub struct ScriptAggregator {
+    scripts: Vec<Option<ScriptWrapper>>,
     size: i32,
     index: i32,
     set_index: i32,
 }
 
-impl<'a> ScriptAggregator<'a> {
-    pub fn new(scripts: Vec<Option<ScriptWrapper<'a>>>) -> Self {
+impl ScriptAggregator {
+    pub fn new(scripts: Vec<Option<ScriptWrapper>>) -> Self {
         let len = scripts.len();
         Self {
             scripts,
@@ -51,11 +53,13 @@ impl<'a> ScriptAggregator<'a> {
         if self.index != -1 {
             if let Some(wrapper) = &self.scripts[self.index as usize] {
                 if let ScriptWrapper::Set(set) = wrapper {
-                    self.set_index += 1;
-                    if self.set_index as usize >= set.count() {
-                        self.set_index = -1;
-                    } else {
-                        return true;
+                    if let Some(set) = set.upgrade() {
+                        self.set_index += 1;
+                        if self.set_index as usize >= set.count() {
+                            self.set_index = -1;
+                        } else {
+                            return true;
+                        }
                     }
                 }
             }
@@ -64,10 +68,16 @@ impl<'a> ScriptAggregator<'a> {
         for index in self.index..self.size {
             self.index = index;
             if let Some(wrapper) = &self.scripts[index as usize] {
-                if let ScriptWrapper::Set(..) = wrapper {
-                    self.set_index = 0;
+                if let ScriptWrapper::Set(s) = wrapper {
+                    if let Some(..) = s.upgrade() {
+                        self.set_index = 0;
+                        return true;
+                    }
+                } else if let ScriptWrapper::Script(script) = wrapper {
+                    if let Some(..) = script.upgrade() {
+                        return true;
+                    }
                 }
-                return true;
             }
         }
 
@@ -79,8 +89,13 @@ impl<'a> ScriptAggregator<'a> {
             return None;
         }
         return match self.scripts[self.index as usize].as_ref().unwrap() {
-            ScriptWrapper::Script(script) => Some(script),
-            ScriptWrapper::Set(set) => Some(set.at(self.set_index as usize)),
+            // We can make this unsafe as we know there is a strong reference. This is validated in
+            // increment_to_next_value
+            ScriptWrapper::Script(script) => unsafe { Some(&*script.as_ptr()) },
+            ScriptWrapper::Set(set) => unsafe {
+                let r = (&*set.as_ptr()).at(self.set_index as usize);
+                Some(r.as_ref())
+            },
         };
     }
 }

src/dynamic_data/script_handling/script.rs

@@ -2,6 +2,8 @@ use crate::dynamic_data::models::pokemon::Pokemon;
 use std::fmt::{Debug, Formatter};
 
 pub trait Script {
+    fn name(&self) -> &str;
+
     fn is_suppressed(&self) -> bool {
         self.get_suppressed_count() > 0
     }

src/dynamic_data/script_handling/script_set.rs

@@ -1,14 +1,69 @@
 use crate::dynamic_data::script_handling::script::Script;
+use crate::PkmnResult;
+use indexmap::IndexMap;
+use std::sync::Arc;
 
-#[derive(Debug)]
-pub struct ScriptSet {}
+#[derive(Debug, Default)]
+pub struct ScriptSet {
+    scripts: IndexMap<String, Arc<Box<dyn Script>>>,
+}
 
 impl ScriptSet {
-    pub fn count(&self) -> usize {
-        todo!()
+    pub fn add(&mut self, script: Box<dyn Script>) -> Arc<Box<dyn Script>> {
+        if let Some(existing) = self.scripts.get(script.name()) {
+            existing.stack();
+            return existing.clone();
+        }
+        let arc = Arc::new(script);
+        self.scripts.insert(arc.name().to_string(), arc.clone());
+        self.scripts.last().unwrap().1.clone()
     }
 
-    pub fn at(&self, _index: usize) -> &Box<dyn Script> {
-        todo!()
+    pub fn stack_or_add<'b, F>(
+        &mut self,
+        key: &str,
+        instantiation: &'b F,
+    ) -> PkmnResult<Arc<Box<dyn Script>>>
+    where
+        F: Fn() -> PkmnResult<Box<dyn Script>>,
+    {
+        if let Some(existing) = self.scripts.get(key) {
+            existing.stack();
+            return Ok(existing.clone());
+        }
+        let script = instantiation()?;
+        let arc = Arc::new(script);
+        self.scripts.insert(arc.name().to_string(), arc.clone());
+        Ok(self.scripts.last().unwrap().1.clone())
+    }
+
+    pub fn get(&self, key: &str) -> Option<&Arc<Box<dyn Script>>> {
+        self.scripts.get(key)
+    }
+
+    pub fn remove(&mut self, key: &str) {
+        let value = self.scripts.shift_remove(key);
+        if let Some(script) = value {
+            script.on_remove();
+        }
+    }
+
+    pub fn clear(&mut self) {
+        for script in &self.scripts {
+            script.1.on_remove();
+        }
+        self.scripts.clear();
+    }
+
+    pub fn has(&self, key: &str) -> bool {
+        self.scripts.contains_key(key)
+    }
+
+    pub fn at(&self, index: usize) -> &Arc<Box<dyn Script>> {
+        &self.scripts[index]
+    }
+
+    pub fn count(&self) -> usize {
+        self.scripts.len()
     }
 }

src/dynamic_data/script_handling/volatile_scripts.rs

@@ -0,0 +1,30 @@
+use crate::dynamic_data::script_handling::script::Script;
+use crate::dynamic_data::script_handling::script_set::ScriptSet;
+use crate::PkmnResult;
+use std::sync::{Arc, RwLock};
+
+pub trait VolatileScripts<'a> {
+    fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>>;
+    fn load_volatile_script(&self, key: &str) -> PkmnResult<Box<dyn Script>>;
+
+    fn has_volatile_script(&self, key: &str) -> bool {
+        self.volatile_scripts().read().unwrap().has(key)
+    }
+
+    fn get_volatile_script(&self, key: &str) -> Option<Arc<Box<dyn Script>>> {
+        let scripts = self.volatile_scripts().read().unwrap();
+        let s = scripts.get(key);
+        s.cloned()
+    }
+
+    fn add_volatile_script(&mut self, key: &str) -> PkmnResult<Arc<Box<dyn Script>>> {
+        self.volatile_scripts()
+            .write()
+            .unwrap()
+            .stack_or_add(key, &|| self.load_volatile_script(key))
+    }
+
+    fn remove_volatile_script(&mut self, key: &str) {
+        self.volatile_scripts().write().unwrap().remove(key)
+    }
+}

src/lib.rs

@@ -4,16 +4,26 @@
 #![feature(bench_black_box)]
 #![feature(let_chains)]
 
-#[macro_use]
-extern crate maplit;
-
 #[cfg(feature = "c_interface")]
 #[macro_use]
 extern crate lazy_static;
 
+use crate::dynamic_data::libraries::script_resolver::ScriptCategory;
+
 mod c_interface;
 
 pub mod defines;
 pub mod dynamic_data;
 pub mod static_data;
 pub mod utils;
+
+#[derive(Debug, Clone)]
+pub enum PokemonError {
+    ScriptNotFound {
+        category: ScriptCategory,
+        name: String,
+    },
+    MiscError,
+}
+
+pub type PkmnResult<T> = std::result::Result<T, PokemonError>;

src/static_data/growth_rates/lookup_growth_rate.rs

@@ -22,6 +22,10 @@ impl GrowthRate for LookupGrowthRate {
     }
 
     fn calculate_experience(&self, level: LevelInt) -> u32 {
-        self.experience[(level - 1) as usize]
+        if level >= self.experience.len() as LevelInt {
+            *self.experience.last().unwrap()
+        } else {
+            self.experience[(level - 1) as usize]
+        }
     }
 }

src/static_data/libraries/data_library.rs

@@ -1,5 +1,5 @@
 use crate::utils::random::Random;
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 pub trait DataLibrary<'a, T: 'a> {
     fn map(&self) -> &HashMap<String, T>;

src/static_data/libraries/growth_rate_library.rs

@@ -1,6 +1,6 @@
 use crate::defines::LevelInt;
 use crate::static_data::growth_rates::growth_rate::GrowthRate;
-use std::collections::HashMap;
+use hashbrown::HashMap;
 use std::fmt;
 use std::fmt::{Debug, Formatter};
 
@@ -42,7 +42,10 @@ pub mod tests {
 
         // Borrow as mut so we can insert
         let w = &mut lib;
-        w.add_growth_rate("foo", Box::new(LookupGrowthRate::new(vec![0, 5, 10, 100])));
+        w.add_growth_rate(
+            "test_growthrate",
+            Box::new(LookupGrowthRate::new(vec![0, 5, 10, 100])),
+        );
         // Drops borrow as mut
 
         lib
@@ -51,14 +54,14 @@ pub mod tests {
     #[test]
     fn add_growth_rate_to_library_and_calculate_level() {
         let lib = build();
-        assert_eq!(lib.calculate_level("foo", 3), 1);
-        assert_eq!(lib.calculate_level("foo", 50), 3);
+        assert_eq!(lib.calculate_level("test_growthrate", 3), 1);
+        assert_eq!(lib.calculate_level("test_growthrate", 50), 3);
     }
 
     #[test]
     fn add_growth_rate_to_library_and_calculate_experience() {
         let lib = build();
-        assert_eq!(lib.calculate_experience("foo", 1), 0);
-        assert_eq!(lib.calculate_experience("foo", 3), 10);
+        assert_eq!(lib.calculate_experience("test_growthrate", 1), 0);
+        assert_eq!(lib.calculate_experience("test_growthrate", 3), 10);
     }
 }

src/static_data/libraries/item_library.rs

@@ -1,6 +1,6 @@
 use crate::static_data::items::item::Item;
 use crate::static_data::libraries::data_library::DataLibrary;
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 #[derive(Debug)]
 pub struct ItemLibrary {

src/static_data/libraries/move_library.rs

@@ -1,6 +1,6 @@
 use crate::static_data::libraries::data_library::DataLibrary;
 use crate::static_data::moves::move_data::MoveData;
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 #[derive(Debug)]
 pub struct MoveLibrary {

src/static_data/libraries/species_library.rs

@@ -1,6 +1,6 @@
 use crate::static_data::libraries::data_library::DataLibrary;
 use crate::static_data::species_data::species::Species;
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 #[derive(Debug)]
 pub struct SpeciesLibrary<'a> {
@@ -39,14 +39,14 @@ pub mod tests {
     use crate::static_data::species_data::learnable_moves::LearnableMoves;
     use crate::static_data::species_data::species::Species;
     use crate::static_data::statistic_set::StatisticSet;
-    use std::collections::HashSet;
+    use hashbrown::HashSet;
 
     fn build_species<'a>() -> Species<'a> {
         Species::new(
             0,
             "foo",
             0.5,
-            "",
+            "test_growthrate",
             0,
             Form::new(
                 "default",

src/static_data/libraries/static_data.rs

@@ -4,6 +4,7 @@ use crate::static_data::libraries::library_settings::LibrarySettings;
 use crate::static_data::libraries::move_library::MoveLibrary;
 use crate::static_data::libraries::species_library::SpeciesLibrary;
 use crate::static_data::libraries::type_library::TypeLibrary;
+use crate::static_data::natures::NatureLibrary;
 use derive_getters::Getters;
 
 #[derive(Getters, Debug)]
@@ -14,6 +15,7 @@ pub struct StaticData<'a> {
     items: ItemLibrary,
     growth_rates: GrowthRateLibrary,
     types: TypeLibrary,
+    natures: NatureLibrary,
 }
 
 #[cfg(test)]
@@ -23,6 +25,7 @@ pub mod test {
     use crate::static_data::libraries::{
         growth_rate_library, item_library, move_library, species_library, type_library,
     };
+    use crate::static_data::natures;
 
     pub fn build<'a>() -> StaticData<'a> {
         StaticData {
@@ -32,6 +35,7 @@ pub mod test {
             items: item_library::tests::build(),
             growth_rates: growth_rate_library::tests::build(),
             types: type_library::tests::build(),
+            natures: natures::tests::build(),
         }
     }
 }

src/static_data/libraries/type_library.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 #[derive(Debug)]
 pub struct TypeLibrary {

src/static_data/mod.rs

@@ -2,6 +2,7 @@ pub mod growth_rates;
 pub mod items;
 pub mod libraries;
 pub mod moves;
+pub mod natures;
 pub mod species_data;
 pub mod statistic_set;
 pub mod statistics;

src/static_data/natures.rs

@@ -0,0 +1,131 @@
+use crate::static_data::statistics::Statistic;
+use hashbrown::HashMap;
+
+#[derive(Debug)]
+pub struct Nature {
+    increase_stat: Statistic,
+    decrease_stat: Statistic,
+    increase_modifier: f32,
+    decrease_modifier: f32,
+}
+
+impl Nature {
+    pub fn new(
+        increase_stat: Statistic,
+        decrease_stat: Statistic,
+        increase_modifier: f32,
+        decrease_modifier: f32,
+    ) -> Self {
+        Self {
+            increase_stat,
+            decrease_stat,
+            increase_modifier,
+            decrease_modifier,
+        }
+    }
+
+    pub fn increased_stat(&self) -> Statistic {
+        self.increase_stat
+    }
+
+    pub fn decreased_stat(&self) -> Statistic {
+        self.decrease_stat
+    }
+
+    pub fn get_stat_modifier(&self, stat: Statistic) -> f32 {
+        if stat == self.increase_stat {
+            self.increase_modifier
+        } else if stat == self.decrease_stat {
+            self.decrease_modifier
+        } else {
+            1.0
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct NatureLibrary {
+    map: HashMap<String, Nature>,
+}
+
+impl NatureLibrary {
+    pub fn new(capacity: usize) -> Self {
+        NatureLibrary {
+            map: HashMap::with_capacity(capacity),
+        }
+    }
+
+    pub fn load_nature(&mut self, name: &str, nature: Nature) {
+        self.map.insert(name.to_string(), nature);
+    }
+
+    pub fn get_nature(&self, key: &str) -> Option<&Nature> {
+        self.map.get(key)
+    }
+
+    pub fn get_nature_name(&self, nature: &Nature) -> String {
+        for kv in &self.map {
+            // As natures can't be copied, and should always be the same reference as the value
+            // in the map, we just compare by reference.
+            if (kv.1 as *const Nature) == (nature as *const Nature) {
+                return kv.0.to_string();
+            }
+        }
+        panic!("No name was found for the given nature. This should never happen.");
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use crate::static_data::natures::{Nature, NatureLibrary};
+    use crate::static_data::statistics::Statistic;
+
+    pub fn build() -> NatureLibrary {
+        let mut lib = NatureLibrary::new(2);
+
+        lib.load_nature(
+            "test_nature",
+            Nature::new(Statistic::HP, Statistic::Attack, 1.1, 0.9),
+        );
+
+        lib
+    }
+
+    #[test]
+    fn create_nature_library_insert_and_retrieve() {
+        let mut lib = NatureLibrary::new(2);
+        lib.load_nature(
+            "foo",
+            Nature::new(Statistic::HP, Statistic::Attack, 1.1, 0.9),
+        );
+        lib.load_nature(
+            "bar",
+            Nature::new(Statistic::Attack, Statistic::Defense, 1.1, 0.9),
+        );
+        let n1 = lib.get_nature("foo").expect("Nature was not found");
+        assert_eq!(n1.increase_stat, Statistic::HP);
+        assert_eq!(n1.decrease_stat, Statistic::Attack);
+        assert_eq!(n1.increase_modifier, 1.1);
+        assert_eq!(n1.decrease_modifier, 0.9);
+    }
+
+    #[test]
+    fn create_nature_library_insert_and_get_name() {
+        let mut lib = NatureLibrary::new(2);
+        lib.load_nature(
+            "foo",
+            Nature::new(Statistic::HP, Statistic::Attack, 1.1, 0.9),
+        );
+        lib.load_nature(
+            "bar",
+            Nature::new(Statistic::Attack, Statistic::Defense, 1.1, 0.9),
+        );
+
+        let n1 = lib.get_nature("foo").expect("Nature was not found");
+        let name = lib.get_nature_name(n1);
+        assert_eq!(name, "foo");
+        let n2 = lib.get_nature("bar").expect("Nature was not found");
+        let name2 = lib.get_nature_name(n2);
+        assert_eq!(name2, "bar");
+    }
+}

src/static_data/species_data/form.rs

@@ -4,7 +4,7 @@ use crate::static_data::statistic_set::StatisticSet;
 use crate::static_data::statistics::Statistic;
 use crate::utils::random::Random;
 use derive_getters::Getters;
-use std::collections::HashSet;
+use hashbrown::HashSet;
 
 #[derive(Getters, Debug)]
 pub struct Form<'a> {

src/static_data/species_data/learnable_moves.rs

@@ -1,7 +1,7 @@
 use crate::defines::LevelInt;
 use crate::static_data::moves::move_data::MoveData;
-use std::collections::hash_map::Entry::{Occupied, Vacant};
-use std::collections::HashMap;
+use hashbrown::hash_map::Entry::{Occupied, Vacant};
+use hashbrown::HashMap;
 
 #[derive(Default, PartialEq, Debug)]
 pub struct LearnableMoves<'a> {
@@ -45,7 +45,6 @@ mod tests {
 
     #[test]
     fn adds_level_moves() {
-        let mut moves = LearnableMoves::new();
         let move1 = MoveData::new(
             "foo",
             0,
@@ -70,6 +69,8 @@ mod tests {
             SecondaryEffect::empty(),
             Default::default(),
         );
+
+        let mut moves = LearnableMoves::new();
         moves.add_level_move(1, &move1);
         moves.add_level_move(1, &move2);
 
@@ -81,7 +82,6 @@ mod tests {
 
     #[test]
     fn adds_two_same_moves_at_different_level() {
-        let mut moves = LearnableMoves::new();
         let move1 = MoveData::new(
             "foo",
             0,
@@ -94,6 +94,8 @@ mod tests {
             SecondaryEffect::empty(),
             Default::default(),
         );
+        let mut moves = LearnableMoves::new();
+
         moves.add_level_move(1, &move1);
         moves.add_level_move(5, &move1);
 

src/static_data/species_data/species.rs

@@ -2,7 +2,7 @@ use self::super::form::Form;
 use crate::static_data::species_data::gender::Gender;
 use crate::utils::random::Random;
 use derive_getters::Getters;
-use std::collections::{HashMap, HashSet};
+use hashbrown::{HashMap, HashSet};
 
 #[derive(Debug, Getters)]
 pub struct Species<'a> {
@@ -25,15 +25,15 @@ impl<'a> Species<'a> {
         default_form: Form<'a>,
         flags: HashSet<String>,
     ) -> Species<'a> {
+        let mut forms = HashMap::with_capacity(1);
+        forms.insert("default".to_string(), default_form);
         Species {
             id,
             name: name.to_string(),
             gender_rate,
             growth_rate: growth_rate.to_string(),
             capture_rate,
-            forms: hashmap! {
-                "default".to_string() => default_form,
-            },
+            forms,
             flags,
         }
     }

src/static_data/statistic_set.rs

@@ -19,6 +19,24 @@ impl<T> StatisticSet<T>
 where
     T: PrimInt,
 {
+    pub fn new(
+        hp: T,
+        attack: T,
+        defense: T,
+        special_attack: T,
+        special_defense: T,
+        speed: T,
+    ) -> Self {
+        Self {
+            hp,
+            attack,
+            defense,
+            special_attack,
+            special_defense,
+            speed,
+        }
+    }
+
     pub const fn get_stat(&self, stat: Statistic) -> T {
         match stat {
             Statistic::HP => self.hp,
@@ -63,3 +81,91 @@ where
         }
     }
 }
+
+#[derive(Default, Eq, PartialEq, Copy, Clone, Debug, Getters)]
+pub struct ClampedStatisticSet<T, const MIN: i64, const MAX: i64>
+where
+    T: PrimInt,
+{
+    hp: T,
+    attack: T,
+    defense: T,
+    special_attack: T,
+    special_defense: T,
+    speed: T,
+}
+
+impl<T, const MIN: i64, const MAX: i64> ClampedStatisticSet<T, MIN, MAX>
+where
+    T: PrimInt,
+{
+    pub const fn get_stat(&self, stat: Statistic) -> T {
+        match stat {
+            Statistic::HP => self.hp,
+            Statistic::Attack => self.attack,
+            Statistic::Defense => self.defense,
+            Statistic::SpecialAttack => self.special_attack,
+            Statistic::SpecialDefense => self.special_defense,
+            Statistic::Speed => self.speed,
+        }
+    }
+
+    pub fn set_stat(&mut self, stat: Statistic, mut value: T) {
+        if value < T::from(MIN).unwrap() {
+            value = T::from(MIN).unwrap();
+        } else if value > T::from(MAX).unwrap() {
+            value = T::from(MAX).unwrap();
+        }
+        match stat {
+            Statistic::HP => self.hp = value,
+            Statistic::Attack => self.attack = value,
+            Statistic::Defense => self.defense = value,
+            Statistic::SpecialAttack => self.special_attack = value,
+            Statistic::SpecialDefense => self.special_defense = value,
+            Statistic::Speed => self.speed = value,
+        }
+    }
+
+    fn change_stat(mut new_value: T, original_value: &mut T) -> bool {
+        if new_value < T::from(MIN).unwrap() {
+            new_value = T::from(MIN).unwrap();
+        } else if new_value > T::from(MAX).unwrap() {
+            new_value = T::from(MAX).unwrap();
+        }
+        if *original_value == new_value {
+            return false;
+        }
+        *original_value = new_value;
+        true
+    }
+
+    pub fn increase_stat(&mut self, stat: Statistic, value: T) -> bool {
+        match stat {
+            Statistic::HP => Self::change_stat(self.hp + value, &mut self.hp),
+            Statistic::Attack => Self::change_stat(self.attack + value, &mut self.attack),
+            Statistic::Defense => Self::change_stat(self.defense + value, &mut self.defense),
+            Statistic::SpecialAttack => {
+                Self::change_stat(self.special_attack + value, &mut self.special_attack)
+            }
+            Statistic::SpecialDefense => {
+                Self::change_stat(self.special_defense + value, &mut self.special_defense)
+            }
+            Statistic::Speed => Self::change_stat(self.speed + value, &mut self.speed),
+        }
+    }
+
+    pub fn decrease_stat(&mut self, stat: Statistic, value: T) -> bool {
+        match stat {
+            Statistic::HP => Self::change_stat(self.hp - value, &mut self.hp),
+            Statistic::Attack => Self::change_stat(self.attack - value, &mut self.attack),
+            Statistic::Defense => Self::change_stat(self.defense - value, &mut self.defense),
+            Statistic::SpecialAttack => {
+                Self::change_stat(self.special_attack - value, &mut self.special_attack)
+            }
+            Statistic::SpecialDefense => {
+                Self::change_stat(self.special_defense - value, &mut self.special_defense)
+            }
+            Statistic::Speed => Self::change_stat(self.speed - value, &mut self.speed),
+        }
+    }
+}

src/static_data/statistics.rs

@@ -1,4 +1,4 @@
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Copy, Clone)]
 pub enum Statistic {
     HP,
     Attack,