More work on switching battle data to interior mutability, instead of exterior mutability.

src/dynamic_data/models/executing_move.rs

@@ -5,57 +5,59 @@ use crate::dynamic_data::script_handling::script::ScriptContainer;
 use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
 use crate::static_data::MoveData;
 use crate::{PkmnResult, PokemonError};
+use atomic::Atomic;
 use parking_lot::RwLock;
 use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU8, Ordering};
 use std::sync::Arc;
 
 #[derive(Default, Debug)]
 pub struct HitData {
-    critical: bool,
-    base_power: u8,
-    effectiveness: f32,
-    damage: u32,
-    move_type: u8,
-    has_failed: bool,
+    critical: AtomicBool,
+    base_power: AtomicU8,
+    effectiveness: Atomic<f32>,
+    damage: AtomicU32,
+    move_type: AtomicU8,
+    has_failed: AtomicBool,
 }
 
 impl HitData {
     pub fn is_critical(&self) -> bool {
-        self.critical
+        self.critical.load(Ordering::Relaxed)
     }
     pub fn base_power(&self) -> u8 {
-        self.base_power
+        self.base_power.load(Ordering::Relaxed)
     }
     pub fn effectiveness(&self) -> f32 {
-        self.effectiveness
+        self.effectiveness.load(Ordering::Relaxed)
     }
     pub fn damage(&self) -> u32 {
-        self.damage
+        self.damage.load(Ordering::Relaxed)
     }
     pub fn move_type(&self) -> u8 {
-        self.move_type
+        self.move_type.load(Ordering::Relaxed)
     }
     pub fn has_failed(&self) -> bool {
-        self.has_failed
+        self.has_failed.load(Ordering::Relaxed)
     }
 
-    pub fn set_critical(&mut self, value: bool) {
-        self.critical = value;
+    pub fn set_critical(&self, value: bool) {
+        self.critical.store(value, Ordering::SeqCst);
     }
-    pub fn set_base_power(&mut self, value: u8) {
-        self.base_power = value;
+    pub fn set_base_power(&self, value: u8) {
+        self.base_power.store(value, Ordering::SeqCst);
     }
-    pub fn set_effectiveness(&mut self, value: f32) {
-        self.effectiveness = value;
+    pub fn set_effectiveness(&self, value: f32) {
+        self.effectiveness.store(value, Ordering::SeqCst);
     }
-    pub fn set_damage(&mut self, value: u32) {
-        self.damage = value;
+    pub fn set_damage(&self, value: u32) {
+        self.damage.store(value, Ordering::SeqCst);
     }
-    pub fn set_move_type(&mut self, value: u8) {
-        self.move_type = value;
+    pub fn set_move_type(&self, value: u8) {
+        self.move_type.store(value, Ordering::SeqCst);
     }
-    pub fn fail(&mut self) {
-        self.has_failed = true;
+    pub fn fail(&self) {
+        self.has_failed.store(true, Ordering::SeqCst);
     }
 }
 
@@ -156,9 +158,6 @@ impl<'own, 'battle, 'library> ExecutingMove<'own, 'battle, 'library> {
     pub(crate) fn get_hit_from_raw_index(&self, index: usize) -> &HitData {
         &self.hits[index]
     }
-    pub(crate) fn get_hit_from_raw_index_mut(&mut self, index: usize) -> &mut HitData {
-        &mut self.hits[index]
-    }
 }
 
 impl<'own, 'battle, 'library> ScriptSource<'own> for ExecutingMove<'own, 'battle, 'library> {