Major amounts of progress

src/dynamic_data/models/pokemon.rs

@@ -1,10 +1,10 @@
 use crate::defines::{LevelInt, MAX_MOVES};
 use crate::dynamic_data::libraries::dynamic_library::DynamicLibrary;
 use crate::dynamic_data::models::battle::Battle;
-use crate::dynamic_data::models::battle_side::BattleSide;
 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::ScriptSource;
 use crate::static_data::items::item::Item;
 use crate::static_data::species_data::ability_index::AbilityIndex;
 use crate::static_data::species_data::form::Form;
@@ -12,18 +12,36 @@ 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::statistics::Statistic;
+use crate::utils::random::Random;
 use derive_getters::Getters;
 use std::collections::HashSet;
+use std::sync::{Mutex, Weak};
 
-#[derive(Getters)]
+#[derive(Debug)]
 pub struct PokemonBattleData<'a> {
-    battle: &'a Battle,
-    battle_side: &'a BattleSide,
+    battle: Weak<Mutex<Battle<'a>>>,
+    battle_side_index: u8,
+    index: u8,
     on_battle_field: bool,
-    seen_opponents: HashSet<Pokemon<'a>>,
+    seen_opponents: HashSet<u32>,
 }
 
-#[derive(Getters)]
+impl<'a> PokemonBattleData<'a> {
+    pub fn battle(&'a mut self) -> &'a mut Weak<Mutex<Battle<'a>>> {
+        &mut self.battle
+    }
+    pub fn battle_side_index(&self) -> u8 {
+        self.battle_side_index
+    }
+    pub fn on_battle_field(&'a mut self) -> &mut bool {
+        &mut self.on_battle_field
+    }
+    pub fn seen_opponents(&'a mut self) -> &'a mut HashSet<u32> {
+        &mut self.seen_opponents
+    }
+}
+
+#[derive(Getters, Debug)]
 pub struct Pokemon<'a> {
     library: &'a DynamicLibrary<'a>,
     species: &'a Species<'a>,
@@ -40,6 +58,9 @@ pub struct Pokemon<'a> {
     held_item: Option<&'a Item>,
     health: u32,
 
+    weight: f32,
+    height: f32,
+
     stat_boost: StatisticSet<i8>,
     flat_stats: StatisticSet<u16>,
     boosted_stats: StatisticSet<u16>,
@@ -79,6 +100,8 @@ impl<'a> Pokemon<'a> {
             .growth_rates()
             .calculate_experience(species.growth_rate(), level);
         let health = form.get_base_stat(Statistic::HP) as u32;
+        let weight = *form.weight();
+        let height = *form.height();
         Pokemon {
             library,
             species,
@@ -92,6 +115,8 @@ impl<'a> Pokemon<'a> {
             coloring,
             held_item: None,
             health,
+            weight,
+            height,
             stat_boost: Default::default(),
             flat_stats: *form.base_stats(),
             boosted_stats: *form.base_stats(),
@@ -108,6 +133,87 @@ impl<'a> Pokemon<'a> {
             volatile: ScriptSet {},
         }
     }
+
+    pub fn change_species(&mut self, species: &'a Species, form: &'a Form) {
+        self.species = species;
+        self.form = form;
+
+        // If the pokemon is genderless, but it's new species is not, we want to set its gender
+        if self.gender != Gender::Genderless && *species.gender_rate() < 0.0 {
+            if self.battle_data.is_some() {
+                let battle = self.battle_data.as_mut().unwrap();
+                self.gender = species.get_random_gender(
+                    battle
+                        .battle
+                        .upgrade()
+                        .unwrap()
+                        .lock()
+                        .unwrap()
+                        .random()
+                        .get_rng(),
+                );
+            } else {
+                self.gender = species.get_random_gender(&mut Random::default());
+            }
+        }
+        // Else if the new species is genderless, but the pokemon has a gender, make the creature genderless.
+        else if *species.gender_rate() < 0.0 && self.gender != Gender::Genderless {
+            self.gender = Gender::Genderless;
+        }
+        // TODO: Battle Event trigger
+    }
+
+    pub fn is_usable(&self) -> bool {
+        todo!()
+    }
+
+    pub fn set_battle_data(&mut self, battle: Weak<Mutex<Battle<'a>>>, battle_side_index: u8) {
+        if let Some(battle_data) = &mut self.battle_data {
+            battle_data.battle = battle;
+            battle_data.battle_side_index = battle_side_index;
+        } else {
+            self.battle_data = Some(PokemonBattleData {
+                battle,
+                battle_side_index,
+                index: 0,
+                on_battle_field: false,
+                seen_opponents: Default::default(),
+            })
+        }
+    }
+
+    pub fn set_on_battlefield(&mut self, value: bool) {
+        if let Some(data) = &mut self.battle_data {
+            data.on_battle_field = value;
+            if !value {
+                self.reset_active_scripts();
+                self.weight = *self.form.weight();
+                self.height = *self.form.height();
+            }
+        }
+    }
+
+    pub fn set_battle_index(&mut self, index: u8) {
+        if let Some(data) = &mut self.battle_data {
+            data.index = index;
+        }
+    }
+
+    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> {
+    fn get_script_count(&self) {
+        todo!()
+    }
 }
 
 #[cfg(test)]