First chunk of battling is now fully working, along with integration tests! 🎉

tests/common/data_getter.rs

@@ -0,0 +1,22 @@
+use pkmn_lib::dynamic_data::models::battle::Battle;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TestDataGetter {
+    PokemonHealth { index: [u8; 2] },
+}
+
+impl TestDataGetter {
+    pub fn get(&self, battle: &Battle) -> String {
+        match self {
+            TestDataGetter::PokemonHealth { index } => battle
+                .get_pokemon(index[0], index[1])
+                .as_ref()
+                .unwrap()
+                .read()
+                .current_health()
+                .to_string(),
+        }
+    }
+}

tests/common/library_loader.rs

@@ -0,0 +1,400 @@
+use hashbrown::HashSet;
+use num_traits::PrimInt;
+use pkmn_lib::defines::LevelInt;
+use pkmn_lib::dynamic_data::libraries::battle_stat_calculator::BattleStatCalculator;
+use pkmn_lib::dynamic_data::libraries::damage_library::Gen7DamageLibrary;
+use pkmn_lib::dynamic_data::libraries::dynamic_library::DynamicLibrary;
+use pkmn_lib::dynamic_data::libraries::misc_library::Gen7MiscLibrary;
+use pkmn_lib::static_data::{
+    Ability, AbilityLibrary, BattleItemCategory, DataLibrary, EffectParameter, Form, GrowthRateLibrary, Item,
+    ItemLibrary, LearnableMoves, LibrarySettings, LookupGrowthRate, MoveData, MoveLibrary, Nature, NatureLibrary,
+    SecondaryEffect, Species, StaticData, Statistic, StatisticSet, TypeLibrary,
+};
+use pkmn_lib::StringKey;
+use project_root::get_project_root;
+use serde_json::Value;
+use std::convert::TryFrom;
+use std::fmt::Debug;
+use std::fs::File;
+use std::io::Read;
+
+pub fn load_library() -> DynamicLibrary {
+    let mut path = get_project_root().unwrap();
+    path.push("tests/data/");
+    let path = path.to_str().unwrap().to_string();
+    let mut data = StaticData::new(LibrarySettings::new(100));
+    load_types(&path, data.types_mut());
+    load_natures(&path, data.natures_mut());
+    load_items(&path, data.items_mut());
+    load_growth_rates(&path, data.growth_rates_mut());
+    load_abilities(&path, data.abilities_mut());
+    load_moves(&path, &mut data);
+    load_species(&path, &mut data);
+    let dynamic = DynamicLibrary::new(
+        data,
+        BattleStatCalculator {},
+        Box::new(Gen7DamageLibrary::new(false)),
+        Box::new(Gen7MiscLibrary::new()),
+    );
+    dynamic
+}
+
+pub fn load_types(path: &String, type_library: &mut TypeLibrary) {
+    let mut reader = csv::ReaderBuilder::new()
+        .delimiter(b'|')
+        .from_path(path.to_string() + "Types.csv")
+        .unwrap();
+    let headers = reader.headers().unwrap();
+    for header in headers.iter().skip(1) {
+        type_library.register_type(&StringKey::new(header.clone()));
+    }
+
+    for record in reader.records() {
+        let record = record.unwrap();
+        let offensive_type = record.get(0).unwrap();
+        let offensive_type_id = type_library.get_type_id(&StringKey::new(offensive_type.clone()));
+
+        for (i, v) in record.iter().skip(1).enumerate() {
+            let effectiveness = v.parse::<f32>().unwrap();
+            type_library.set_effectiveness(offensive_type_id, i as u8, effectiveness);
+        }
+    }
+}
+
+pub fn load_natures(path: &String, nature_library: &mut NatureLibrary) {
+    let mut reader = csv::ReaderBuilder::new()
+        .delimiter(b'|')
+        .from_path(path.to_string() + "Natures.csv")
+        .unwrap();
+
+    for record in reader.records() {
+        let record = record.unwrap();
+        let nature_name = StringKey::new(record.get(0).unwrap());
+        let increased_statistic_str = record.get(1).unwrap();
+        let decreased_statistic_str = record.get(2).unwrap();
+        if increased_statistic_str.is_empty() || decreased_statistic_str.is_empty() {
+            nature_library.load_nature(nature_name, Nature::new(Statistic::HP, Statistic::HP, 1.0, 1.0));
+        } else {
+            let increased_statistic = serde_plain::from_str(increased_statistic_str).unwrap();
+            let decreased_statistic = serde_plain::from_str(decreased_statistic_str).unwrap();
+            nature_library.load_nature(
+                nature_name,
+                Nature::new(increased_statistic, decreased_statistic, 1.1, 0.9),
+            );
+        }
+    }
+}
+
+pub fn load_items(path: &String, lib: &mut ItemLibrary) {
+    let mut file = File::open(path.to_string() + "Items.json").unwrap();
+    let mut data = String::new();
+    file.read_to_string(&mut data).unwrap();
+    let json: Value = serde_json::from_str(&data).unwrap();
+    let json_array = json.as_array().unwrap();
+
+    for v in json_array {
+        let name = StringKey::new(v["name"].as_str().unwrap());
+        let category = serde_json::from_value(v["itemType"].clone()).unwrap();
+        let mut battle_category = BattleItemCategory::None;
+        if let Some(c) = v.get("battleType") {
+            battle_category = serde_json::from_value(c.clone()).unwrap();
+        }
+        let price = v["price"].as_i64().unwrap();
+        let mut flags = HashSet::new();
+        if let Some(f) = v.get("flags") {
+            let a = f.as_array().unwrap();
+            for flag in a {
+                flags.insert(StringKey::new(flag.as_str().unwrap()));
+            }
+        }
+
+        lib.add(
+            &name,
+            Box::new(Item::new(&name, category, battle_category, price as i32, flags)),
+        );
+    }
+}
+
+pub fn load_growth_rates(path: &String, growth_rate_library: &mut GrowthRateLibrary) {
+    let mut file = File::open(path.to_string() + "GrowthRates.json").unwrap();
+    let mut data = String::new();
+    file.read_to_string(&mut data).unwrap();
+    let json: Value = serde_json::from_str(&data).unwrap();
+    let o = json.as_object().unwrap();
+
+    for (key, value) in o {
+        let name = StringKey::new(key);
+        let experience_required_json = value.as_array().unwrap();
+        let mut experience_required = Vec::with_capacity(experience_required_json.len());
+        for v in experience_required_json {
+            experience_required.push(v.as_i64().unwrap() as u32);
+        }
+
+        growth_rate_library.add_growth_rate(&name, Box::new(LookupGrowthRate::new(experience_required)));
+    }
+}
+
+pub fn load_abilities(path: &String, ability_library: &mut AbilityLibrary) {
+    let mut file = File::open(path.to_string() + "Abilities.json").unwrap();
+    let mut data = String::new();
+    file.read_to_string(&mut data).unwrap();
+    let json: Value = serde_json::from_str(&data).unwrap();
+    let o = json.as_object().unwrap();
+
+    for (key, value) in o {
+        let name = StringKey::new(key);
+        let mut effect = StringKey::empty();
+        if let Some(e) = value.get("effect") {
+            effect = StringKey::new(e.as_str().unwrap());
+        }
+        let mut parameters = Vec::new();
+        if let Some(p) = value.get("parameters") {
+            for par in p.as_array().unwrap() {
+                parameters.push(parse_effect_parameter(par));
+            }
+        }
+
+        ability_library.add(&name, Box::new(Ability::new(&name, &effect, parameters)));
+    }
+}
+
+pub fn load_moves(path: &String, lib: &mut StaticData) {
+    let mut file = File::open(path.to_string() + "Moves.json").unwrap();
+    let mut data = String::new();
+    file.read_to_string(&mut data).unwrap();
+    let json: Value = serde_json::from_str(&data).unwrap();
+    let data = json.as_object().unwrap().get("data").unwrap().as_array().unwrap();
+    for move_data in data {
+        let move_data = move_data.as_object().unwrap();
+        let move_name = StringKey::new(move_data["name"].as_str().unwrap().clone());
+        let move_type = StringKey::new(move_data["type"].as_str().unwrap());
+        let move_type_id = lib.types().get_type_id(&move_type);
+        let move_category = serde_json::from_value(move_data["category"].clone()).unwrap();
+        let base_power = move_data["power"].as_i64().unwrap() as u8;
+        let accuracy = move_data["accuracy"].as_i64().unwrap() as u8;
+        let pp = move_data["pp"].as_i64().unwrap() as u8;
+        let target = serde_json::from_value(move_data["target"].clone()).unwrap();
+        let priority = move_data["priority"].as_i64().unwrap() as i8;
+        let secondary_effect = if let Some(v) = move_data.get("effect") {
+            let mut chance = -1.0;
+            if let Some(chance_value) = v.get("chance") {
+                chance = chance_value.as_f64().unwrap() as f32;
+            }
+            let mut parameters = Vec::new();
+            if let Some(pars) = v.get("parameters") {
+                let pars = pars.as_array().unwrap();
+                for par in pars {
+                    parameters.push(parse_effect_parameter(par));
+                }
+            }
+
+            SecondaryEffect::new(chance, StringKey::new(v["name"].as_str().unwrap().clone()), parameters)
+        } else {
+            SecondaryEffect::empty()
+        };
+
+        let mut flags = HashSet::new();
+        if let Some(f) = move_data.get("flags") {
+            let f = f.as_array().unwrap();
+            for flag in f {
+                flags.insert(StringKey::new(flag.as_str().unwrap()));
+            }
+        }
+
+        lib.moves_mut().add(
+            &move_name,
+            MoveData::new(
+                &move_name.clone(),
+                move_type_id,
+                move_category,
+                base_power,
+                accuracy,
+                pp,
+                target,
+                priority,
+                secondary_effect,
+                flags,
+            ),
+        );
+    }
+}
+
+pub fn load_species(path: &String, library: &mut StaticData) {
+    let mut file = File::open(path.to_string() + "Pokemon.json").unwrap();
+    let mut data = String::new();
+    file.read_to_string(&mut data).unwrap();
+    let json: Value = serde_json::from_str(&data).unwrap();
+    let o = json.as_object().unwrap();
+
+    for (key, value) in o {
+        if key.starts_with("$") {
+            continue;
+        }
+        let name = StringKey::new(key);
+        let id = value["id"].as_i64().unwrap();
+        let gender_rate = value["genderRatio"].as_f64().unwrap();
+        let growth_rate_name = StringKey::new(value["growthRate"].as_str().unwrap());
+        let _base_happiness = value["baseHappiness"].as_i64().unwrap();
+        let catch_rate = value["catchRate"].as_i64().unwrap();
+        let _color = value["color"].as_str().unwrap();
+        // let egg_groups = value["eggGroups"]
+        //     .as_array()
+        //     .unwrap()
+        //     .iter()
+        //     .map(|&a| a.as_str().unwrap())
+        //     .collect();
+        let _egg_cycle = value["eggCycles"].as_i64().unwrap();
+        // TODO: tags
+        // TODO: evolutions
+
+        let forms = value["formes"].as_object().unwrap();
+        let default_form_value = &forms["default"];
+        let default_form = parse_form("default".into(), default_form_value, library);
+
+        let mut species = Box::new(Species::new(
+            id as u16,
+            &name,
+            gender_rate as f32,
+            &growth_rate_name,
+            catch_rate as u8,
+            default_form,
+            Default::default(),
+        ));
+        library.species_mut().add(&name, species);
+    }
+}
+
+fn parse_form(name: StringKey, value: &Value, library: &mut StaticData) -> Form {
+    let mut abilities = Vec::new();
+    for a in value["abilities"].as_array().unwrap() {
+        abilities.push(StringKey::new(a.as_str().unwrap()));
+    }
+    let mut hidden_abilities = Vec::new();
+    for a in value["hiddenAbilities"].as_array().unwrap() {
+        hidden_abilities.push(StringKey::new(a.as_str().unwrap()));
+    }
+    let base_stats = parse_statistics(&value["baseStats"]);
+    // TODO: ev reward
+    let height = value["height"].as_f64().unwrap();
+    let weight = value["weight"].as_f64().unwrap();
+    let base_experience = value["baseExp"].as_u64().unwrap();
+    let types = value["types"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .map(|a| library.types().get_type_id(&StringKey::new(a.as_str().unwrap())))
+        .collect();
+
+    let moves = parse_moves(&value["moves"], library.moves());
+
+    Form::new(
+        &name,
+        height as f32,
+        weight as f32,
+        base_experience as u32,
+        types,
+        base_stats,
+        abilities,
+        hidden_abilities,
+        moves,
+        Default::default(),
+    )
+}
+
+fn parse_statistics<T>(value: &Value) -> StatisticSet<T>
+where
+    T: PrimInt + TryFrom<u64>,
+    <T as TryFrom<u64>>::Error: Debug,
+{
+    StatisticSet::new(
+        <T as TryFrom<u64>>::try_from(value.get("hp").unwrap_or(&Value::Number(0.into())).as_u64().unwrap()).unwrap(),
+        <T as TryFrom<u64>>::try_from(
+            value
+                .get("attack")
+                .unwrap_or(&Value::Number(0.into()))
+                .as_u64()
+                .unwrap(),
+        )
+        .unwrap(),
+        <T as TryFrom<u64>>::try_from(
+            value
+                .get("defense")
+                .unwrap_or(&Value::Number(0.into()))
+                .as_u64()
+                .unwrap(),
+        )
+        .unwrap(),
+        <T as TryFrom<u64>>::try_from(
+            value
+                .get("specialAttack")
+                .unwrap_or(&Value::Number(0.into()))
+                .as_u64()
+                .unwrap(),
+        )
+        .unwrap(),
+        <T as TryFrom<u64>>::try_from(
+            value
+                .get("specialDefense")
+                .unwrap_or(&Value::Number(0.into()))
+                .as_u64()
+                .unwrap(),
+        )
+        .unwrap(),
+        <T as TryFrom<u64>>::try_from(value.get("speed").unwrap_or(&Value::Number(0.into())).as_u64().unwrap())
+            .unwrap(),
+    )
+}
+
+fn parse_moves(value: &Value, move_library: &MoveLibrary) -> LearnableMoves {
+    let mut moves = LearnableMoves::default();
+
+    let level_moves = value["levelMoves"].as_array().unwrap();
+    for level_move in level_moves {
+        let name = StringKey::new(level_move["name"].as_str().unwrap());
+        let level = level_move["level"].as_u64().unwrap() as LevelInt;
+        assert!(move_library.get(&name).is_some());
+        moves.add_level_move(level, &name);
+    }
+
+    moves
+}
+
+fn parse_effect_parameter(value: &Value) -> EffectParameter {
+    match value {
+        Value::Null => {
+            panic!("Unexpected type")
+        }
+        Value::Bool(b) => EffectParameter::Bool(*b),
+        Value::Number(n) => {
+            if n.is_f64() {
+                EffectParameter::Float(n.as_f64().unwrap() as f32)
+            } else {
+                EffectParameter::Int(n.as_i64().unwrap())
+            }
+        }
+        Value::String(s) => EffectParameter::String(s.clone()),
+        Value::Array(_) => {
+            panic!("Unexpected type")
+        }
+        Value::Object(_) => {
+            panic!("Unexpected type")
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_type_library_loaded() {
+    let mut path = get_project_root().unwrap();
+    path.push("tests/data/");
+    let mut lib = TypeLibrary::new(18);
+    load_types(&path.to_str().unwrap().to_string(), &mut lib);
+
+    assert_eq!(
+        lib.get_effectiveness(
+            lib.get_type_id(&StringKey::new("fire")),
+            &vec![lib.get_type_id(&StringKey::new("grass"))],
+        ),
+        2.0
+    );
+}

tests/common/mod.rs

@@ -0,0 +1,9 @@
+pub mod data_getter;
+pub mod library_loader;
+pub mod test_case;
+pub mod test_step;
+
+pub use data_getter::*;
+pub use library_loader::*;
+pub use test_case::*;
+pub use test_step::*;

tests/common/test_case.rs

@@ -0,0 +1,82 @@
+use super::test_step::TestStep;
+use parking_lot::RwLock;
+use pkmn_lib::defines::LevelInt;
+use pkmn_lib::dynamic_data::libraries::dynamic_library::DynamicLibrary;
+use pkmn_lib::dynamic_data::models::battle::Battle;
+use pkmn_lib::dynamic_data::models::battle_party::BattleParty;
+use pkmn_lib::dynamic_data::models::pokemon::Pokemon;
+use pkmn_lib::dynamic_data::models::pokemon_builder::PokemonBuilder;
+use pkmn_lib::dynamic_data::models::pokemon_party::PokemonParty;
+use pkmn_lib::StringKey;
+use serde::Deserialize;
+use std::sync::Arc;
+
+#[derive(Deserialize)]
+pub struct TestCase {
+    pub name: String,
+    battle_setup: TestBattleSetup,
+    actions: Vec<TestStep>,
+}
+
+#[derive(Deserialize)]
+struct TestBattleSetup {
+    seed: u128,
+    can_flee: bool,
+    number_of_sides: u8,
+    pokemon_per_side: u8,
+    parties: Vec<TestParty>,
+}
+
+#[derive(Deserialize)]
+struct TestParty {
+    indices: Vec<[u8; 2]>,
+    pokemon: Vec<TestPokemon>,
+}
+
+#[derive(Deserialize)]
+struct TestPokemon {
+    species: String,
+    level: LevelInt,
+    moves: Vec<String>,
+}
+
+impl TestCase {
+    pub fn run_test(&self, library: &DynamicLibrary) {
+        let mut parties = Vec::new();
+        for party in &self.battle_setup.parties {
+            let pokemon = party
+                .pokemon
+                .iter()
+                .map(|a| Some(Arc::new(RwLock::new(a.to_pokemon(library)))))
+                .collect();
+            let indices = party.indices.iter().map(|a| (a[0], a[1])).collect();
+            parties.push((Arc::new(PokemonParty::new_from_vec(pokemon)), indices));
+        }
+        let mut battle_parties = Vec::new();
+        for party in parties {
+            battle_parties.push(BattleParty::new(party.0.clone(), party.1));
+        }
+        let mut battle = Battle::new(
+            library,
+            battle_parties,
+            self.battle_setup.can_flee,
+            self.battle_setup.number_of_sides,
+            self.battle_setup.pokemon_per_side,
+            Some(self.battle_setup.seed),
+        );
+        for action in &self.actions {
+            action.execute(&mut battle);
+        }
+    }
+}
+
+impl TestPokemon {
+    fn to_pokemon<'a>(&'a self, library: &'a DynamicLibrary) -> Pokemon {
+        let mut builder = PokemonBuilder::new(library, StringKey::new(self.species.as_str()), self.level);
+        for move_name in &self.moves {
+            builder = builder.learn_move(StringKey::new(move_name));
+        }
+
+        builder.build()
+    }
+}

tests/common/test_step.rs

@@ -0,0 +1,82 @@
+use super::data_getter::TestDataGetter;
+use pkmn_lib::dynamic_data::choices::{MoveChoice, PassChoice, TurnChoice};
+use pkmn_lib::dynamic_data::models::battle::Battle;
+use pkmn_lib::StringKey;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum TestStep {
+    SetPokemon {
+        place: [u8; 2],
+        from_party: [u8; 2],
+    },
+    SetMoveChoice {
+        #[serde(rename = "for")]
+        for_pokemon: [u8; 2],
+        #[serde(rename = "move")]
+        use_move: String,
+        target: [u8; 2],
+    },
+    SetPassChoice {
+        #[serde(rename = "for")]
+        for_pokemon: [u8; 2],
+    },
+    Assert {
+        value: TestDataGetter,
+        expected: String,
+    },
+}
+
+impl TestStep {
+    pub fn execute(&self, battle: &mut Battle) {
+        match self {
+            TestStep::SetPokemon { place, from_party } => {
+                let p = battle.parties()[from_party[0] as usize]
+                    .get_pokemon(from_party[1] as usize)
+                    .clone();
+                battle.sides_mut()[place[0] as usize].set_pokemon(place[1], p);
+            }
+            TestStep::SetMoveChoice {
+                for_pokemon,
+                use_move,
+                target,
+            } => {
+                let p = battle.sides()[for_pokemon[0] as usize].pokemon()[for_pokemon[1] as usize]
+                    .as_ref()
+                    .unwrap()
+                    .clone();
+                let mut used_move = None;
+                let pokemon_guard = p.read();
+                for learned_move in pokemon_guard.learned_moves().iter().flatten() {
+                    if learned_move.read().move_data().name() == &StringKey::new(use_move) {
+                        used_move = Some(learned_move.clone());
+                        break;
+                    }
+                }
+                assert!(used_move.is_some());
+                drop(pokemon_guard);
+
+                assert!(battle
+                    .try_set_choice(TurnChoice::Move(MoveChoice::new(
+                        p,
+                        used_move.unwrap(),
+                        target[0],
+                        target[1],
+                    )))
+                    .unwrap());
+            }
+            TestStep::SetPassChoice { for_pokemon } => {
+                let p = battle.sides()[for_pokemon[0] as usize].pokemon()[for_pokemon[1] as usize]
+                    .as_ref()
+                    .unwrap()
+                    .clone();
+                assert!(battle.try_set_choice(TurnChoice::Pass(PassChoice::new(p))).unwrap());
+            }
+            TestStep::Assert { value, expected } => {
+                let v = value.get(battle);
+                assert_eq!(&v, expected)
+            }
+        }
+    }
+}

tests/library_loader.rs

@@ -1,136 +0,0 @@
-use hashbrown::HashSet;
-use pkmn_lib::static_data::{DataLibrary, EffectParameter, MoveData, MoveLibrary, SecondaryEffect, TypeLibrary};
-use pkmn_lib::StringKey;
-use project_root::get_project_root;
-use serde_json::Value;
-use std::fs::File;
-use std::io::Read;
-
-pub fn load_types(path: &String) -> TypeLibrary {
-    let mut type_library = TypeLibrary::new(18);
-
-    let mut reader = csv::ReaderBuilder::new()
-        .delimiter(b'|')
-        .from_path(path.to_string() + "Types.csv")
-        .unwrap();
-    let headers = reader.headers().unwrap();
-    for header in headers.iter().skip(1) {
-        type_library.register_type(&StringKey::new(header.clone()));
-    }
-
-    for record in reader.records() {
-        let record = record.unwrap();
-        let offensive_type = record.get(0).unwrap();
-        let offensive_type_id = type_library.get_type_id(&StringKey::new(offensive_type.clone()));
-
-        for (i, v) in record.iter().skip(1).enumerate() {
-            let effectiveness = v.parse::<f32>().unwrap();
-            type_library.set_effectiveness(offensive_type_id, i as u8, effectiveness);
-        }
-    }
-
-    type_library
-}
-
-pub fn load_moves(path: &String, type_library: &TypeLibrary) -> MoveLibrary {
-    let mut file = File::open(path.to_string() + "Moves.json").unwrap();
-    let mut data = String::new();
-    file.read_to_string(&mut data).unwrap();
-    let json: Value = serde_json::from_str(&data).unwrap();
-    let data = json.as_object().unwrap().get("data").unwrap().as_array().unwrap();
-    let mut move_library = MoveLibrary::new(data.len());
-    for move_data in data {
-        let move_data = move_data.as_object().unwrap();
-        let move_name = StringKey::new(move_data["name"].as_str().unwrap().clone());
-        let move_type = StringKey::new(move_data["type"].as_str().unwrap());
-        let move_type_id = type_library.get_type_id(&move_type);
-        let move_category = serde_json::from_value(move_data["category"].clone()).unwrap();
-        let base_power = move_data["power"].as_i64().unwrap() as u8;
-        let accuracy = move_data["accuracy"].as_i64().unwrap() as u8;
-        let pp = move_data["pp"].as_i64().unwrap() as u8;
-        let target = serde_json::from_value(move_data["target"].clone()).unwrap();
-        let priority = move_data["priority"].as_i64().unwrap() as i8;
-        let secondary_effect = if let Some(v) = move_data.get("effect") {
-            let mut chance = -1.0;
-            if let Some(chance_value) = v.get("chance") {
-                chance = chance_value.as_f64().unwrap() as f32;
-            }
-            let mut parameters = Vec::new();
-            if let Some(pars) = v.get("parameters") {
-                let pars = pars.as_array().unwrap();
-                for par in pars {
-                    match par {
-                        Value::Null => {
-                            panic!("Unexpected type")
-                        }
-                        Value::Bool(b) => {
-                            parameters.push(EffectParameter::Bool(*b));
-                        }
-                        Value::Number(n) => {
-                            if n.is_f64() {
-                                parameters.push(EffectParameter::Float(n.as_f64().unwrap() as f32));
-                            } else {
-                                parameters.push(EffectParameter::Int(n.as_i64().unwrap()));
-                            }
-                        }
-                        Value::String(s) => {
-                            parameters.push(EffectParameter::String(s.clone()));
-                        }
-                        Value::Array(_) => {
-                            panic!("Unexpected type")
-                        }
-                        Value::Object(_) => {
-                            panic!("Unexpected type")
-                        }
-                    }
-                }
-            }
-
-            SecondaryEffect::new(chance, StringKey::new(v["name"].as_str().unwrap().clone()), parameters)
-        } else {
-            SecondaryEffect::empty()
-        };
-
-        let mut flags = HashSet::new();
-        if let Some(f) = move_data.get("flags") {
-            let f = f.as_array().unwrap();
-            for flag in f {
-                flags.insert(StringKey::new(flag.as_str().unwrap()));
-            }
-        }
-
-        move_library.add(
-            &move_name,
-            MoveData::new(
-                &move_name.clone(),
-                move_type_id,
-                move_category,
-                base_power,
-                accuracy,
-                pp,
-                target,
-                priority,
-                secondary_effect,
-                flags,
-            ),
-        );
-    }
-
-    move_library
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn test_type_library_loaded() {
-    let mut path = get_project_root().unwrap();
-    path.push("tests/data/");
-    let lib = load_types(&path.to_str().unwrap().to_string());
-
-    assert_eq!(
-        lib.get_effectiveness(
-            lib.get_type_id(&StringKey::new("fire")),
-            &vec![lib.get_type_id(&StringKey::new("grass")),]
-        ),
-        2.0
-    );
-}

tests/main.rs

@@ -0,0 +1,38 @@
+#![feature(custom_test_frameworks)]
+#![feature(once_cell)]
+#![test_runner(datatest::runner)]
+
+use crate::common::{library_loader, TestCase};
+use pkmn_lib::dynamic_data::libraries::dynamic_library::DynamicLibrary;
+use std::fs::File;
+use std::io::Read;
+use std::lazy::SyncLazy;
+use std::path::Path;
+
+pub mod common;
+
+static LIBRARY: SyncLazy<DynamicLibrary> = SyncLazy::new(|| {
+    let start_time = chrono::Utc::now();
+    let lib = library_loader::load_library();
+    let end_time = chrono::Utc::now();
+    println!("Built library in {} ms", (end_time - start_time).num_milliseconds());
+    lib
+});
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn validate_library_load() {
+    SyncLazy::force(&LIBRARY);
+}
+
+#[datatest::files("tests/test_cases", {
+input in r"^(.*)\.yaml"
+})]
+fn integration_tests(input: &Path) {
+    let mut str: String = "".to_string();
+    let mut file = File::open(input).unwrap();
+    file.read_to_string(&mut str).unwrap();
+    let test_case = serde_yaml::from_str::<TestCase>(&*str).unwrap();
+    println!("\tRunning integration test {}", test_case.name);
+    test_case.run_test(&LIBRARY);
+}

tests/test_cases/basic_single_turn.yaml

@@ -0,0 +1,44 @@
+name: basic_single_turn
+battle_setup:
+  seed: 10
+  can_flee: false
+  number_of_sides: 2
+  pokemon_per_side: 1
+  parties:
+    - indices:
+        - [ 0, 0 ]
+      pokemon:
+        - species: charizard
+          level: 50
+          moves:
+            - ember
+    - indices:
+        - [ 1, 0 ]
+      pokemon:
+        - species: venusaur
+          level: 50
+          moves:
+            - vine_whip
+actions:
+  - set_pokemon:
+      place: [ 0, 0 ]
+      from_party: [ 0 ,0 ]
+  - set_pokemon:
+      place: [ 1, 0 ]
+      from_party: [ 1 ,0 ]
+  - assert:
+      value:
+        pokemon_health:
+          index: [ 1, 0 ]
+      expected: 140
+  - set_move_choice:
+      for: [ 0, 0 ]
+      move: ember
+      target: [ 1, 0 ]
+  - set_pass_choice:
+      for: [ 1, 0 ]
+  - assert:
+      value:
+        pokemon_health:
+          index: [ 1, 0 ]
+      expected: 78

tests/tests.rs

@@ -1,13 +0,0 @@
-use project_root::get_project_root;
-
-pub mod library_loader;
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn run_integration_tests() {
-    let mut path = get_project_root().unwrap();
-    path.push("tests/data/");
-    let path = path.to_str().unwrap().to_string();
-    let type_library = library_loader::load_types(&path);
-    let move_library = library_loader::load_moves(&path, &type_library);
-}