Major rework of extern ref system for WASM, fixes most possible panics in WASM handling

.cargo/config.toml

@@ -1,6 +1,2 @@
-[target.x86_64-unknown-linux-gnu]
-linker = "/usr/bin/clang"
-rustflags = ["-Clink-arg=-fuse-ld=/usr/bin/mold"]
-
 [rust]
 debuginfo-level = 1

src/dynamic_data/choices.rs

@@ -1,5 +1,5 @@
 use anyhow::{bail, Result};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU32, Ordering};
 use std::sync::Arc;
 
 use parking_lot::RwLock;
@@ -16,12 +16,12 @@ struct CommonChoiceData {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// The user of the turn choice
-    user: Arc<Pokemon>,
+    user: Pokemon,
     /// The speed of the user at the beginning of the turn.
-    speed: u32,
+    speed: AtomicU32,
     /// This random value is set at the beginning of the turn. It is used for tie breaking of the
     /// turn order in a predictable way, regardless of implementation and hardware.
-    random_value: u32,
+    random_value: AtomicU32,
     /// Whether or not the choice has failed. A failed choice will stop running, and execute special
     /// fail handling during turn execution.
     has_failed: AtomicBool,
@@ -57,32 +57,22 @@ impl TurnChoice {
             TurnChoice::Pass(data) => &data.choice_data,
         }
     }
-    /// The shared choice data between each of the different turn choices.
-    fn choice_data_mut(&mut self) -> &mut Box<CommonChoiceData> {
-        match self {
-            TurnChoice::Move(data) => &mut data.choice_data,
-            TurnChoice::Item(data) => &mut data.choice_data,
-            TurnChoice::Switch(data) => &mut data.choice_data,
-            TurnChoice::Flee(data) => &mut data.choice_data,
-            TurnChoice::Pass(data) => &mut data.choice_data,
-        }
-    }
 
     /// Get the user of the given choice.
-    pub fn user(&self) -> &Arc<Pokemon> {
+    pub fn user(&self) -> &Pokemon {
         &self.choice_data().user
     }
 
     /// Get the speed of the user for the choice. Note that this speed is the speed of the Pokemon
     /// at the start of the turn!
     pub fn speed(&self) -> u32 {
-        self.choice_data().speed
+        self.choice_data().speed.load(Ordering::Relaxed)
     }
 
-    /// Get the mutable speed of the user for the choice. Note that this speed is the speed of the Pokemon
+    /// Sets the speed of user for the choice. Note that this speed is the speed of the Pokemon at
-    /// at the start of the turn!
+    /// the start of the turn!
-    pub fn speed_mut(&mut self) -> &mut u32 {
+    pub fn set_speed(&self, value: u32) {
-        &mut self.choice_data_mut().speed
+        self.choice_data().speed.store(value, Ordering::Relaxed);
     }
 
     /// Gets whether or not the choice has failed. If we notice this when we execute the choice, we
@@ -101,12 +91,12 @@ impl TurnChoice {
     /// breaking of turn executions. This means that choices get executed with a predictable order,
     /// regardless of implementation details.
     pub(crate) fn random_value(&self) -> u32 {
-        self.choice_data().random_value
+        self.choice_data().random_value.load(Ordering::Relaxed)
     }
 
     /// This sets the above random value.
-    pub(crate) fn set_random_value(&mut self, val: u32) {
+    pub(crate) fn set_random_value(&self, val: u32) {
-        self.choice_data_mut().random_value = val;
+        self.choice_data().random_value.store(val, Ordering::Relaxed)
     }
 
     /// Helper function to get the move choice data from a turn. Note that this will panic if not
@@ -174,26 +164,26 @@ pub struct MoveChoice {
     /// The move script.
     script: ScriptContainer,
     /// The priority of the move choice at the beginning of the turn.
-    priority: i8,
+    priority: AtomicI8,
     /// The common turn choice data.
     choice_data: Box<CommonChoiceData>,
 }
 
 impl MoveChoice {
     /// Initializes the data for a new move choice.
-    pub fn new(user: Arc<Pokemon>, used_move: Arc<LearnedMove>, target_side: u8, target_index: u8) -> Self {
+    pub fn new(user: Pokemon, used_move: Arc<LearnedMove>, target_side: u8, target_index: u8) -> Self {
         let speed = user.boosted_stats().speed();
         Self {
             used_move,
             target_side,
             target_index,
             script: Default::default(),
-            priority: 0,
+            priority: AtomicI8::new(0),
             choice_data: Box::new(CommonChoiceData {
                 identifier: Default::default(),
                 user,
-                speed,
+                speed: AtomicU32::new(speed),
-                random_value: 0,
+                random_value: AtomicU32::new(0),
                 has_failed: Default::default(),
                 script_source_data: Default::default(),
             }),
@@ -215,14 +205,14 @@ impl MoveChoice {
     }
     /// The priority of the move choice at the beginning of the turn.
     pub fn priority(&self) -> i8 {
-        self.priority
+        self.priority.load(Ordering::Relaxed)
     }
     /// The priority of the move choice at the beginning of the turn.
-    pub fn priority_mut(&mut self) -> &mut i8 {
+    pub fn set_priority(&self, value: i8) {
-        &mut self.priority
+        self.priority.store(value, Ordering::Relaxed)
     }
     /// The user of the choice.
-    pub fn user(&self) -> &Arc<Pokemon> {
+    pub fn user(&self) -> &Pokemon {
         &self.choice_data.user
     }
     /// The move script of the choice.
@@ -259,14 +249,14 @@ pub struct ItemChoice {
 
 impl ItemChoice {
     /// Initialised a new item choice.
-    pub fn new(user: Arc<Pokemon>) -> Self {
+    pub fn new(user: Pokemon) -> Self {
         let speed = user.boosted_stats().speed();
         Self {
             choice_data: Box::new(CommonChoiceData {
                 identifier: Default::default(),
                 user,
-                speed,
+                speed: AtomicU32::new(speed),
-                random_value: 0,
+                random_value: AtomicU32::new(0),
                 has_failed: Default::default(),
                 script_source_data: Default::default(),
             }),
@@ -299,14 +289,14 @@ pub struct SwitchChoice {
 
 impl SwitchChoice {
     /// Initialise the turn choice data.
-    pub fn new(user: Arc<Pokemon>) -> Self {
+    pub fn new(user: Pokemon) -> Self {
         let speed = user.boosted_stats().speed();
         Self {
             choice_data: Box::new(CommonChoiceData {
                 identifier: Default::default(),
                 user,
-                speed,
+                speed: AtomicU32::new(speed),
-                random_value: 0,
+                random_value: AtomicU32::new(0),
                 has_failed: Default::default(),
                 script_source_data: Default::default(),
             }),
@@ -339,13 +329,13 @@ pub struct FleeChoice {
 
 impl FleeChoice {
     /// Initialises a new flee choice.
-    pub fn new(user: Arc<Pokemon>) -> Self {
+    pub fn new(user: Pokemon) -> Self {
         Self {
             choice_data: Box::new(CommonChoiceData {
                 identifier: Default::default(),
                 user,
-                speed: 0,
+                speed: AtomicU32::new(0),
-                random_value: 0,
+                random_value: AtomicU32::new(0),
                 has_failed: Default::default(),
                 script_source_data: Default::default(),
             }),
@@ -378,14 +368,14 @@ pub struct PassChoice {
 
 impl PassChoice {
     /// Initialised a new pass choice.
-    pub fn new(user: Arc<Pokemon>) -> Self {
+    pub fn new(user: Pokemon) -> Self {
         let speed = user.boosted_stats().speed();
         Self {
             choice_data: Box::new(CommonChoiceData {
                 identifier: Default::default(),
                 user,
-                speed,
+                speed: AtomicU32::new(speed),
-                random_value: 0,
+                random_value: AtomicU32::new(0),
                 has_failed: Default::default(),
                 script_source_data: Default::default(),
             }),
@@ -428,7 +418,10 @@ impl Ord for TurnChoice {
         match self {
             TurnChoice::Move(data) => {
                 if let TurnChoice::Move(other_data) = other {
-                    let priority_compare = data.priority.cmp(&other_data.priority);
+                    let priority_compare = data
+                        .priority
+                        .load(Ordering::Relaxed)
+                        .cmp(&other_data.priority.load(Ordering::Relaxed));
                     if priority_compare != std::cmp::Ordering::Equal {
                         return priority_compare;
                     }

src/dynamic_data/event_hooks.rs

@@ -29,6 +29,7 @@ impl EventHook {
     /// listeners can exist at the same time. Note that for these functions the event will be disposed
     /// of after the event is finished being sent.
     pub fn register_listener(&self, func: EvtHookFn) {
+        #[allow(clippy::unwrap_used)] // This should never fail.
         self.evt_hook_function.write().unwrap().push(func);
     }
 
@@ -36,6 +37,7 @@ impl EventHook {
     /// dispose of the event afterwards.
     pub fn trigger(&self, evt: Event) {
         let b = Box::new(&evt);
+        #[allow(clippy::unwrap_used)] // This should never fail.
         let read_lock = self.evt_hook_function.read().unwrap();
         for f in read_lock.iter() {
             f(&b);
@@ -59,7 +61,7 @@ pub enum Event<'own> {
         /// The index of the Pokemon that got switched in/out on its side
         index: u8,
         /// The new Pokemon that will be on the spot. If none, the spot will now be empty.
-        pokemon: Option<Arc<Pokemon>>,
+        pokemon: Option<Pokemon>,
     },
     /// A swap event happens when two Pokemon on a side swap positions. Note that this is rare.
     Swap {

src/dynamic_data/flow/choice_queue.rs

@@ -6,6 +6,8 @@ use anyhow::Result;
 use anyhow_ext::anyhow;
 use parking_lot::lock_api::MappedRwLockReadGuard;
 use parking_lot::{RawRwLock, RwLock, RwLockReadGuard};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
 
 /// The ChoiceQueue is used to run choices one by one.
 ///
@@ -14,51 +16,50 @@ use parking_lot::{RawRwLock, RwLock, RwLockReadGuard};
 /// helper functions to change the turn order while doing the execution. This is needed, as several
 /// moves in Pokemon actively mess with this order.
 #[derive(Debug)]
-
 pub struct ChoiceQueue {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// Our storage of turn choices. Starts out completely filled, then slowly empties as turns get
     /// executed.
-    queue: RwLock<Vec<Option<TurnChoice>>>,
+    queue: RwLock<Vec<Option<Arc<TurnChoice>>>>,
     /// The current index of the turn we need to execute next.
-    current: usize,
+    current: AtomicUsize,
 }
 
 impl ChoiceQueue {
     /// Initializes a ChoiceQueue, and sort the choices.
-    pub(crate) fn new(mut queue: Vec<Option<TurnChoice>>) -> Self {
+    pub(crate) fn new(mut queue: Vec<Option<Arc<TurnChoice>>>) -> Self {
         queue.sort_unstable_by(|a, b| b.cmp(a));
         Self {
             identifier: Default::default(),
             queue: RwLock::new(queue),
-            current: 0,
+            current: AtomicUsize::new(0),
         }
     }
 
     /// Dequeues the next turn choice to be executed. This gives ownership to the callee, and replaces
     /// our own reference to the turn choice with an empty spot. It also increments the current position
     /// by one.
-    pub fn dequeue(&mut self) -> Result<Option<TurnChoice>> {
+    pub fn dequeue(&self) -> Result<Option<Arc<TurnChoice>>> {
         let mut write_lock = self.queue.write();
-        if self.current >= write_lock.len() {
+        if self.current.load(Ordering::Relaxed) >= write_lock.len() {
             return Ok(None);
         }
         let c = write_lock
-            .get_mut(self.current)
+            .get_mut(self.current.load(Ordering::Relaxed))
             .ok_or(anyhow!("Unable to get current turn choice"))?
             .take();
-        self.current += 1;
+        self.current.fetch_add(1, Ordering::Relaxed);
         Ok(c)
     }
 
     /// This reads what the next choice to execute will be, without modifying state.
-    pub fn peek(&self) -> Result<Option<MappedRwLockReadGuard<'_, RawRwLock, TurnChoice>>> {
+    pub fn peek(&self) -> Result<Option<MappedRwLockReadGuard<'_, RawRwLock, Arc<TurnChoice>>>> {
         let read_lock = self.queue.read();
-        if self.current >= read_lock.len() {
+        if self.current.load(Ordering::Relaxed) >= read_lock.len() {
             Ok(None)
         } else {
-            let v = RwLockReadGuard::try_map(read_lock, |a| match a.get(self.current) {
+            let v = RwLockReadGuard::try_map(read_lock, |a| match a.get(self.current.load(Ordering::Relaxed)) {
                 Some(Some(v)) => Some(v),
                 _ => None,
             });
@@ -71,7 +72,7 @@ impl ChoiceQueue {
 
     /// Check if we have any choices remaining.
     pub fn has_next(&self) -> bool {
-        self.current < self.queue.read().len()
+        self.current.load(Ordering::Relaxed) < self.queue.read().len()
     }
 
     /// This resorts the yet to be executed choices. This can be useful for dealing with situations
@@ -80,19 +81,19 @@ impl ChoiceQueue {
     pub fn resort(&mut self) -> Result<()> {
         let len = self.queue.read().len();
         let mut write_lock = self.queue.write();
-        for index in self.current..len {
+        for index in self.current.load(Ordering::Relaxed)..len {
             let choice = &mut write_lock.get_mut_res(index)?;
             if let Some(choice) = choice {
                 let mut speed = choice.user().boosted_stats().speed();
                 script_hook!(change_speed, (*choice), choice, &mut speed);
-                *choice.speed_mut() = speed;
+                choice.set_speed(speed)
             }
         }
 
         write_lock
-            .get_mut(self.current..len)
+            .get_mut(self.current.load(Ordering::Relaxed)..len)
             .ok_or(PkmnError::IndexOutOfBounds {
-                index: self.current,
+                index: self.current.load(Ordering::Relaxed),
                 len,
             })?
             .sort_unstable_by(|a, b| b.cmp(a));
@@ -104,7 +105,7 @@ impl ChoiceQueue {
         let mut queue_lock = self.queue.write();
         let mut desired_index = None;
         // Find the index for the choice we want to move up.
-        for index in self.current..queue_lock.len() {
+        for index in self.current.load(Ordering::Relaxed)..queue_lock.len() {
             if let Some(Some(choice)) = &queue_lock.get(index) {
                 if pokemon.value_identifier() == choice.user().value_identifier() {
                     desired_index = Some(index);
@@ -115,7 +116,7 @@ impl ChoiceQueue {
         let result = match desired_index {
             Some(desired_index) => {
                 // If the choice we want to move up is already the next choice, just return.
-                if desired_index == self.current {
+                if desired_index == self.current.load(Ordering::Relaxed) {
                     return Ok(true);
                 }
 
@@ -126,11 +127,14 @@ impl ChoiceQueue {
                     .ok_or(anyhow!("Choice was already taken"))?;
                 // Iterate backwards from the spot before the choice we want to move up, push them all back
                 // by 1 spot.
-                for index in (self.current..desired_index).rev() {
+                let current = self.current.load(Ordering::Relaxed);
+                for index in (current..desired_index).rev() {
                     queue_lock.swap(index, index + 1);
                 }
                 // Place the choice that needs to be next in the next to be executed position.
-                let _ = queue_lock.get_mut_res(self.current)?.insert(choice);
+                let _ = queue_lock
+                    .get_mut_res(self.current.load(Ordering::Relaxed))?
+                    .insert(choice);
                 true
             }
             None => false,
@@ -139,12 +143,14 @@ impl ChoiceQueue {
     }
 
     /// Internal helper function to be easily able to iterate over the yet to be executed choices.
-    pub(crate) fn get_queue(&self) -> Result<MappedRwLockReadGuard<'_, RawRwLock, [Option<TurnChoice>]>> {
+    pub(crate) fn get_queue(&self) -> Result<MappedRwLockReadGuard<'_, RawRwLock, [Option<Arc<TurnChoice>>]>> {
         let read_lock = self.queue.read();
-        match RwLockReadGuard::try_map(read_lock, |a| a.get(self.current..self.queue.read().len())) {
+        match RwLockReadGuard::try_map(read_lock, |a| {
+            a.get(self.current.load(Ordering::Relaxed)..self.queue.read().len())
+        }) {
             Ok(v) => Ok(v),
             Err(_) => Err(PkmnError::IndexOutOfBounds {
-                index: self.current,
+                index: self.current.load(Ordering::Relaxed),
                 len: self.queue.read().len(),
             }
             .into()),
@@ -176,7 +182,7 @@ mod tests {
 
     #[test]
     fn dequeue_from_empty_queue() {
-        let mut queue = ChoiceQueue::new(Vec::new());
+        let queue = ChoiceQueue::new(Vec::new());
         assert!(queue.dequeue().unwrap().is_none());
     }
 
@@ -204,9 +210,9 @@ mod tests {
 
     #[test]
     fn create_queue_with_single_item() {
-        let user = Arc::new(get_user(10));
+        let user = get_user(10);
 
-        let queue = ChoiceQueue::new(vec![Some(TurnChoice::Pass(PassChoice::new(user)))]);
+        let queue = ChoiceQueue::new(vec![Some(Arc::new(TurnChoice::Pass(PassChoice::new(user))))]);
         assert!(queue.has_next());
         assert!(queue.peek().unwrap().is_some());
         assert_eq!(7, queue.peek().unwrap().unwrap().speed());
@@ -214,9 +220,9 @@ mod tests {
 
     #[test]
     fn dequeue_from_queue_with_single_item() {
-        let user = Arc::new(get_user(10));
+        let user = get_user(10);
 
-        let mut queue = ChoiceQueue::new(vec![Some(TurnChoice::Pass(PassChoice::new(user)))]);
+        let queue = ChoiceQueue::new(vec![Some(Arc::new(TurnChoice::Pass(PassChoice::new(user))))]);
         assert!(queue.has_next());
         assert_eq!(7, queue.dequeue().unwrap().unwrap().speed());
         assert!(!queue.has_next());
@@ -225,12 +231,12 @@ mod tests {
 
     #[test]
     fn create_queue_with_two_items_with_equal_order() {
-        let user1 = Arc::new(get_user(10));
+        let user1 = get_user(10);
-        let user2 = Arc::new(get_user(10));
+        let user2 = get_user(10);
 
         let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1)))),
-            Some(TurnChoice::Pass(PassChoice::new(user2))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2)))),
         ]);
         assert!(queue.has_next());
         assert!(queue.peek().unwrap().is_some());
@@ -239,12 +245,12 @@ mod tests {
 
     #[test]
     fn create_queue_with_two_items_get_queue() {
-        let user1 = Arc::new(get_user(10));
+        let user1 = get_user(10);
-        let user2 = Arc::new(get_user(5));
+        let user2 = get_user(5);
 
         let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1.clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(user2))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2)))),
         ]);
         let inner_queue = queue.get_queue().unwrap();
         assert_eq!(
@@ -255,12 +261,12 @@ mod tests {
 
     #[test]
     fn create_queue_with_two_items_in_wrong_order_sorts_correctly() {
-        let user1 = Arc::new(get_user(5));
+        let user1 = get_user(5);
-        let user2 = Arc::new(get_user(100));
+        let user2 = get_user(100);
 
-        let mut queue = ChoiceQueue::new(vec![
+        let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1)))),
-            Some(TurnChoice::Pass(PassChoice::new(user2))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2)))),
         ]);
         assert_eq!(25, queue.dequeue().unwrap().unwrap().speed());
         assert_eq!(6, queue.dequeue().unwrap().unwrap().speed());
@@ -268,12 +274,12 @@ mod tests {
 
     #[test]
     fn resort_with_two_choices() {
-        let user1 = Arc::new(get_user(50));
+        let user1 = get_user(50);
-        let user2 = Arc::new(get_user(1));
+        let user2 = get_user(1);
 
         let mut queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1.clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(user2.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2.clone())))),
         ]);
 
         user2.change_level_by(60).unwrap();
@@ -290,18 +296,18 @@ mod tests {
 
     #[test]
     fn move_pokemon_choice_first_with_two_choices() {
-        let user1 = Arc::new(get_user(100));
+        let user1 = get_user(100);
-        let user2 = Arc::new(get_user(1));
+        let user2 = get_user(1);
 
-        let mut queue = ChoiceQueue::new(vec![
+        let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1.clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(user2.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2.clone())))),
         ]);
         assert_eq!(
             user1.value_identifier(),
             queue.peek().unwrap().unwrap().user().value_identifier()
         );
-        assert!(queue.move_pokemon_choice_next(user2.as_ref()).unwrap());
+        assert!(queue.move_pokemon_choice_next(&user2).unwrap());
 
         assert_eq!(
             user2.value_identifier(),
@@ -315,18 +321,18 @@ mod tests {
 
     #[test]
     fn move_pokemon_choice_first_when_choice_has_already_been() {
-        let user1 = Arc::new(get_user(10));
+        let user1 = get_user(10);
-        let user2 = Arc::new(get_user(100));
+        let user2 = get_user(100);
 
-        let mut queue = ChoiceQueue::new(vec![
+        let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1.clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(user2.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2.clone())))),
         ]);
         assert_eq!(
             user2.value_identifier(),
             queue.dequeue().unwrap().unwrap().user().value_identifier()
         );
-        assert!(!queue.move_pokemon_choice_next(user2.as_ref()).unwrap());
+        assert!(!queue.move_pokemon_choice_next(&user2).unwrap());
 
         assert_eq!(
             user1.value_identifier(),
@@ -337,18 +343,18 @@ mod tests {
 
     #[test]
     fn move_pokemon_choice_first_when_choice_is_next() {
-        let user1 = Arc::new(get_user(100));
+        let user1 = get_user(100);
-        let user2 = Arc::new(get_user(10));
+        let user2 = get_user(10);
 
         let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(user1.clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user1.clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(user2))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(user2)))),
         ]);
         assert_eq!(
             user1.value_identifier(),
             queue.peek().unwrap().unwrap().user().value_identifier()
         );
-        assert!(queue.move_pokemon_choice_next(user1.as_ref()).unwrap());
+        assert!(queue.move_pokemon_choice_next(&user1).unwrap());
         assert_eq!(
             user1.value_identifier(),
             queue.peek().unwrap().unwrap().user().value_identifier()
@@ -358,29 +364,29 @@ mod tests {
     #[test]
     fn move_pokemon_choice_first_with_seven_choices() {
         let users = [
-            Arc::new(get_user(100)),
+            get_user(100),
-            Arc::new(get_user(90)),
+            get_user(90),
-            Arc::new(get_user(80)),
+            get_user(80),
-            Arc::new(get_user(70)),
+            get_user(70),
-            Arc::new(get_user(60)),
+            get_user(60),
-            Arc::new(get_user(50)),
+            get_user(50),
-            Arc::new(get_user(40)),
+            get_user(40),
         ];
 
-        let mut queue = ChoiceQueue::new(vec![
+        let queue = ChoiceQueue::new(vec![
-            Some(TurnChoice::Pass(PassChoice::new(users[0].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[0].clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(users[1].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[1].clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(users[2].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[2].clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(users[3].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[3].clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(users[4].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[4].clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(users[5].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[5].clone())))),
-            Some(TurnChoice::Pass(PassChoice::new(users[6].clone()))),
+            Some(Arc::new(TurnChoice::Pass(PassChoice::new(users[6].clone())))),
         ]);
         assert_eq!(
             users[0].value_identifier(),
             queue.peek().unwrap().unwrap().user().value_identifier()
         );
-        assert!(queue.move_pokemon_choice_next(users[4].as_ref()).unwrap());
+        assert!(queue.move_pokemon_choice_next(&users[4]).unwrap());
 
         assert_eq!(
             users[4].value_identifier(),

src/dynamic_data/flow/target_resolver.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
 use std::ops::Deref;
-use std::sync::Arc;
 
 use num_traits::abs;
 
@@ -10,7 +9,7 @@ use crate::static_data::MoveTarget;
 use crate::VecExt;
 
 /// Helper type for the vector of targ ets we will return.
-pub type TargetList = Vec<Option<Arc<Pokemon>>>;
+pub type TargetList = Vec<Option<Pokemon>>;
 
 /// This returns all Pokemon in the battle.
 fn get_all_targets(battle: &Battle) -> TargetList {

src/dynamic_data/flow/turn_runner.rs

@@ -77,9 +77,9 @@ impl Battle {
     }
 
     /// Executes a single choice.
-    fn execute_choice(&self, choice: &TurnChoice) -> Result<()> {
+    fn execute_choice(&self, choice: &Arc<TurnChoice>) -> Result<()> {
         // A pass turn choice means the user does not intend to do anything. As such, return.
-        if let TurnChoice::Pass(..) = choice {
+        if let TurnChoice::Pass(..) = choice.deref() {
             return Ok(());
         }
         if self.has_ended() {
@@ -95,7 +95,7 @@ impl Battle {
         if !self.can_use(choice) {
             return Ok(());
         }
-        match choice {
+        match choice.deref() {
             TurnChoice::Move(..) => self.execute_move_choice(choice)?,
             TurnChoice::Item(_) => {}
             TurnChoice::Switch(_) => {}
@@ -106,7 +106,7 @@ impl Battle {
     }
 
     /// Executes a move choice.
-    fn execute_move_choice<'func>(&'func self, choice: &'func TurnChoice) -> Result<()> {
+    fn execute_move_choice<'func>(&'func self, choice: &'func Arc<TurnChoice>) -> Result<()> {
         let move_choice = choice.get_move_turn_data()?;
         let used_move = move_choice.used_move();
         let move_data = {
@@ -129,14 +129,14 @@ impl Battle {
         if number_of_hits == 0 {
             return Ok(());
         }
-        let mut executing_move = ExecutingMove::new(
+        let executing_move = Arc::new(ExecutingMove::new(
             targets.clone(),
             number_of_hits,
             choice.user().clone(),
             used_move.clone(),
             move_data,
             move_choice.script().clone(),
-        );
+        ));
         let mut prevented = false;
         script_hook!(prevent_move, executing_move, &executing_move, &mut prevented);
         if prevented {
@@ -161,13 +161,13 @@ impl Battle {
         }
         script_hook!(on_before_move, executing_move, &executing_move);
         for target in targets.iter().flatten() {
-            self.handle_move_for_target(&mut executing_move, target)?;
+            self.handle_move_for_target(&executing_move, target)?;
         }
         Ok(())
     }
 
     /// Executes a move turn choice on a single target.
-    fn handle_move_for_target(&self, executing_move: &mut ExecutingMove, target: &Arc<Pokemon>) -> Result<()> {
+    fn handle_move_for_target(&self, executing_move: &Arc<ExecutingMove>, target: &Pokemon) -> Result<()> {
         {
             let mut fail = false;
             script_hook!(fail_incoming_move, target, executing_move, target, &mut fail);

src/dynamic_data/libraries/damage_library.rs

@@ -14,8 +14,8 @@ pub trait DamageLibrary: std::fmt::Debug + ValueIdentifiable {
     /// Calculate the damage for a given hit on a Pokemon.
     fn get_damage(
         &self,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
         hit_data: &HitData,
     ) -> Result<u32>;
@@ -23,8 +23,8 @@ pub trait DamageLibrary: std::fmt::Debug + ValueIdentifiable {
     /// Calculate the base power for a given hit on a Pokemon.
     fn get_base_power(
         &self,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
         hit_data: &HitData,
     ) -> Result<u8>;
@@ -33,8 +33,8 @@ pub trait DamageLibrary: std::fmt::Debug + ValueIdentifiable {
     fn is_critical(
         &self,
         battle: &Battle,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
     ) -> Result<bool>;
 }
@@ -61,8 +61,8 @@ impl Gen7DamageLibrary {
     /// Calculates the modifier applied to damage from the statistics of the relevant Pokemon.
     fn get_stat_modifier(
         &self,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
         hit_data: &HitData,
     ) -> Result<f32> {
@@ -151,8 +151,8 @@ impl Gen7DamageLibrary {
     /// to apply a raw modifier to the damage.
     fn get_damage_modifier(
         &self,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
         _hit_data: &HitData,
     ) -> Result<f32> {
@@ -172,8 +172,8 @@ impl Gen7DamageLibrary {
 impl DamageLibrary for Gen7DamageLibrary {
     fn get_damage(
         &self,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
         hit_data: &HitData,
     ) -> Result<u32> {
@@ -260,8 +260,8 @@ impl DamageLibrary for Gen7DamageLibrary {
 
     fn get_base_power(
         &self,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
         _hit_data: &HitData,
     ) -> Result<u8> {
@@ -284,8 +284,8 @@ impl DamageLibrary for Gen7DamageLibrary {
     fn is_critical(
         &self,
         battle: &Battle,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
     ) -> Result<bool> {
         // Status moves can't be critical.

src/dynamic_data/libraries/dynamic_library.rs

@@ -16,15 +16,15 @@ use crate::{StringKey, ValueIdentifiable, ValueIdentifier};
 /// calculators that might be customized between different generations and implementations.
 pub trait DynamicLibrary: Debug + ValueIdentifiable {
     /// The static data is the immutable storage data for this library.
-    fn static_data(&self) -> &Box<dyn StaticData>;
+    fn static_data(&self) -> &Arc<dyn StaticData>;
     /// The stat calculator deals with the calculation of flat and boosted stats, based on the
     /// Pokemons attributes.
-    fn stat_calculator(&self) -> &Box<dyn BattleStatCalculator>;
+    fn stat_calculator(&self) -> &Arc<dyn BattleStatCalculator>;
     /// The damage calculator deals with the calculation of things relating to damage.
-    fn damage_calculator(&self) -> &Box<dyn DamageLibrary>;
+    fn damage_calculator(&self) -> &Arc<dyn DamageLibrary>;
     /// The Misc Library holds minor functions that do not fall in any of the other libraries and
     /// calculators.
-    fn misc_library(&self) -> &Box<dyn MiscLibrary>;
+    fn misc_library(&self) -> &Arc<dyn MiscLibrary>;
 
     /// Loads a standard script with a given unique combination of category and key. If no script
     /// can be created with this combination, returns None.
@@ -47,15 +47,15 @@ pub struct DynamicLibraryImpl {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// The static data is the immutable storage data for this library.
-    static_data: Box<dyn StaticData>,
+    static_data: Arc<dyn StaticData>,
     /// The stat calculator deals with the calculation of flat and boosted stats, based on the
     /// Pokemons attributes.
-    stat_calculator: Box<dyn BattleStatCalculator>,
+    stat_calculator: Arc<dyn BattleStatCalculator>,
     /// The damage calculator deals with the calculation of things relating to damage.
-    damage_calculator: Box<dyn DamageLibrary>,
+    damage_calculator: Arc<dyn DamageLibrary>,
     /// The Misc Library holds minor functions that do not fall in any of the other libraries and
     /// calculators.
-    misc_library: Box<dyn MiscLibrary>,
+    misc_library: Arc<dyn MiscLibrary>,
 
     /// The script resolver deals with how to resolve the scripts from specific unique key combinations.
     script_resolver: Box<dyn ScriptResolver>,
@@ -64,10 +64,10 @@ pub struct DynamicLibraryImpl {
 impl DynamicLibraryImpl {
     /// Instantiates a new DynamicLibrary with given parameters.
     pub fn new(
-        static_data: Box<dyn StaticData>,
+        static_data: Arc<dyn StaticData>,
-        stat_calculator: Box<dyn BattleStatCalculator>,
+        stat_calculator: Arc<dyn BattleStatCalculator>,
-        damage_calculator: Box<dyn DamageLibrary>,
+        damage_calculator: Arc<dyn DamageLibrary>,
-        misc_library: Box<dyn MiscLibrary>,
+        misc_library: Arc<dyn MiscLibrary>,
         script_resolver: Box<dyn ScriptResolver>,
     ) -> Self {
         Self {
@@ -83,21 +83,21 @@ impl DynamicLibraryImpl {
 
 impl DynamicLibrary for DynamicLibraryImpl {
     /// The static data is the immutable storage data for this library.
-    fn static_data(&self) -> &Box<dyn StaticData> {
+    fn static_data(&self) -> &Arc<dyn StaticData> {
         &self.static_data
     }
     /// The stat calculator deals with the calculation of flat and boosted stats, based on the
     /// Pokemons attributes.
-    fn stat_calculator(&self) -> &Box<dyn BattleStatCalculator> {
+    fn stat_calculator(&self) -> &Arc<dyn BattleStatCalculator> {
         &self.stat_calculator
     }
     /// The damage calculator deals with the calculation of things relating to damage.
-    fn damage_calculator(&self) -> &Box<dyn DamageLibrary> {
+    fn damage_calculator(&self) -> &Arc<dyn DamageLibrary> {
         &self.damage_calculator
     }
     /// The Misc Library holds minor functions that do not fall in any of the other libraries and
     /// calculators.
-    fn misc_library(&self) -> &Box<dyn MiscLibrary> {
+    fn misc_library(&self) -> &Arc<dyn MiscLibrary> {
         &self.misc_library
     }
 
@@ -139,10 +139,10 @@ pub mod test {
         #[derive(Debug)]
         pub DynamicLibrary{}
         impl DynamicLibrary for DynamicLibrary {
-            fn static_data(&self) -> &Box<dyn StaticData>;
+            fn static_data(&self) -> &Arc<dyn StaticData>;
-            fn stat_calculator(&self) -> &Box<dyn BattleStatCalculator>;
+            fn stat_calculator(&self) -> &Arc<dyn BattleStatCalculator>;
-            fn damage_calculator(&self) -> &Box<dyn DamageLibrary>;
+            fn damage_calculator(&self) -> &Arc<dyn DamageLibrary>;
-            fn misc_library(&self) -> &Box<dyn MiscLibrary>;
+            fn misc_library(&self) -> &Arc<dyn MiscLibrary>;
             fn load_script(
                 &self,
                 owner: ScriptOwnerData,
@@ -161,10 +161,10 @@ pub mod test {
     pub fn build() -> DynamicLibraryImpl {
         DynamicLibraryImpl {
             identifier: Default::default(),
-            static_data: Box::new(crate::static_data::libraries::static_data::test::build()),
+            static_data: Arc::new(crate::static_data::libraries::static_data::test::build()),
-            stat_calculator: Box::new(Gen7BattleStatCalculator::new()),
+            stat_calculator: Arc::new(Gen7BattleStatCalculator::new()),
-            damage_calculator: Box::new(Gen7DamageLibrary::new(false)),
+            damage_calculator: Arc::new(Gen7DamageLibrary::new(false)),
-            misc_library: Box::new(Gen7MiscLibrary::new()),
+            misc_library: Arc::new(Gen7MiscLibrary::new()),
             script_resolver: Box::new(EmptyScriptResolver {
                 identifier: Default::default(),
             }),

src/dynamic_data/libraries/misc_library.rs

@@ -14,7 +14,7 @@ pub trait MiscLibrary: Debug + ValueIdentifiable {
     /// Returns whether or not a Pokemon is allowed to flee or switch out.
     fn can_flee(&self, choice: &TurnChoice) -> bool;
     /// Returns the move we need to use if we can't use another move. Typically Struggle.
-    fn replacement_move(&self, user: &Arc<Pokemon>, target_side: u8, target_index: u8) -> TurnChoice;
+    fn replacement_move(&self, user: &Pokemon, target_side: u8, target_index: u8) -> TurnChoice;
     // TODO: can evolve from level up?
     // TODO: get time
 }
@@ -66,7 +66,7 @@ impl MiscLibrary for Gen7MiscLibrary {
         todo!()
     }
 
-    fn replacement_move(&self, user: &Arc<Pokemon>, target_side: u8, target_index: u8) -> TurnChoice {
+    fn replacement_move(&self, user: &Pokemon, target_side: u8, target_index: u8) -> TurnChoice {
         self.struggle_learned_move.restore_all_uses();
         TurnChoice::Move(MoveChoice::new(
             user.clone(),

src/dynamic_data/models/battle.rs

@@ -1,6 +1,7 @@
+use std::ffi::c_void;
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Weak};
 
 use anyhow::Result;
 use anyhow_ext::anyhow;
@@ -22,15 +23,15 @@ use crate::dynamic_data::{ChoiceQueue, ScriptContainer};
 use crate::dynamic_data::{ScriptCategory, ScriptSource, ScriptSourceData};
 use crate::{script_hook, PkmnError, StringKey, ValueIdentifiable, ValueIdentifier, VecExt};
 
-/// A pokemon battle, with any amount of sides and pokemon per side.
+/// The data of a battle.
 #[derive(Debug)]
-pub struct Battle {
+struct BattleData {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// The library the battle uses for handling.
     library: Arc<dyn DynamicLibrary>,
     /// A list of all different parties in the battle.
-    parties: Vec<BattleParty>,
+    parties: Vec<Arc<BattleParty>>,
     /// Whether or not Pokemon can flee from the battle.
     can_flee: bool,
     /// The number of sides in the battle. Typically 2.
@@ -40,9 +41,9 @@ pub struct Battle {
     /// A list of all sides in the battle.
     sides: Vec<BattleSide>,
     /// The RNG used for the battle.
-    random: BattleRandom,
+    random: Arc<BattleRandom>,
     /// A queue of the yet to be executed choices in a turn.
-    current_turn_queue: RwLock<Option<ChoiceQueue>>,
+    current_turn_queue: RwLock<Option<Arc<ChoiceQueue>>>,
     /// Whether or not the battle has ended.
     has_ended: AtomicBool,
     /// The eventual result of the battle. Inconclusive until the battle is ended.
@@ -61,16 +62,30 @@ pub struct Battle {
     script_source_data: RwLock<ScriptSourceData>,
 }
 
+/// A pokemon battle, with any amount of sides and pokemon per side.
+#[derive(Clone, Debug)]
+pub struct Battle {
+    /// The actual data of the battle.
+    data: Arc<BattleData>,
+}
+
+/// A weak reference to a battle.
+#[derive(Clone, Debug, Default)]
+pub struct WeakBattleReference {
+    /// A weak reference to the actual data of the battle.
+    data: Weak<BattleData>,
+}
+
 impl Battle {
     /// Initializes a new battle.
     pub fn new(
         library: Arc<dyn DynamicLibrary>,
-        parties: Vec<BattleParty>,
+        parties: Vec<Arc<BattleParty>>,
         can_flee: bool,
         number_of_sides: u8,
         pokemon_per_side: u8,
         random_seed: Option<u128>,
-    ) -> Arc<Self> {
+    ) -> Self {
         // If no seed was passed, we use the current time as seed for the RNG, otherwise we use the
         // seed.
         let random = if let Some(seed) = random_seed {
@@ -83,7 +98,7 @@ impl Battle {
             sides.push(BattleSide::new(i, pokemon_per_side));
         }
 
-        let battle = Self {
+        let battle = BattleData {
             identifier: Default::default(),
             library,
             parties,
@@ -91,7 +106,7 @@ impl Battle {
             number_of_sides,
             pokemon_per_side,
             sides,
-            random,
+            random: Arc::new(random),
             current_turn_queue: RwLock::new(None),
             has_ended: AtomicBool::new(false),
             result: RwLock::new(BattleResult::Inconclusive),
@@ -104,73 +119,77 @@ impl Battle {
         };
 
         let battle_arc = Arc::new(battle);
-
+        let battle = Self { data: battle_arc };
-        let battle_ptr = Arc::as_ptr(&battle_arc) as *mut Battle;
+        for side in &battle.data.sides {
-        unsafe {
+            side.set_battle(battle.weak());
-            for side in &mut battle_ptr.as_mut().unwrap().sides {
-                side.set_battle(Arc::downgrade(&battle_arc));
-            }
         }
 
-        battle_arc
+        battle
+    }
+
+    /// Returns a weak reference to the battle.
+    pub fn weak(&self) -> WeakBattleReference {
+        WeakBattleReference {
+            data: Arc::downgrade(&self.data),
+        }
     }
 
     /// The library the battle uses for handling.
     pub fn library(&self) -> &Arc<dyn DynamicLibrary> {
-        &self.library
+        &self.data.library
     }
     /// A list of all different parties in the battle.
-    pub fn parties(&self) -> &Vec<BattleParty> {
+    pub fn parties(&self) -> &Vec<Arc<BattleParty>> {
-        &self.parties
+        &self.data.parties
     }
     /// Whether or not Pokemon can flee from the battle.
     pub fn can_flee(&self) -> bool {
-        self.can_flee
+        self.data.can_flee
     }
     /// The number of sides in the battle. Typically 2.
     pub fn number_of_sides(&self) -> u8 {
-        self.number_of_sides
+        self.data.number_of_sides
     }
     /// The number of Pokemon that can be on each side.
     pub fn pokemon_per_side(&self) -> u8 {
-        self.pokemon_per_side
+        self.data.pokemon_per_side
     }
     /// A list of all sides in the battle.
     pub fn sides(&self) -> &Vec<BattleSide> {
-        &self.sides
+        &self.data.sides
     }
     /// The RNG used for the battle.
-    pub fn random(&self) -> &BattleRandom {
+    pub fn random(&self) -> &Arc<BattleRandom> {
-        &self.random
+        &self.data.random
     }
     /// Whether or not the battle has ended.
     pub fn has_ended(&self) -> bool {
-        self.has_ended.load(Ordering::Relaxed)
+        self.data.has_ended.load(Ordering::Relaxed)
     }
     /// The eventual result of the battle. Inconclusive until the battle is ended.
     pub fn result(&self) -> BattleResult {
-        *self.result.read()
+        *self.data.result.read()
     }
     /// The handler to send all events to.
     pub fn event_hook(&self) -> &EventHook {
-        &self.event_hook
+        &self.data.event_hook
     }
     /// The index of the current turn. 0 until all choices
     pub fn current_turn(&self) -> u32 {
-        self.current_turn.load(Ordering::Relaxed)
+        self.data.current_turn.load(Ordering::Relaxed)
     }
     /// The time in nanoseconds the last turn took to run. Defaults to 0.
     pub fn last_turn_time(&self) -> u64 {
-        self.last_turn_time.load(Ordering::Relaxed)
+        self.data.last_turn_time.load(Ordering::Relaxed)
     }
     /// A queue of the yet to be executed choices in a turn.
-    pub fn current_turn_queue(&self) -> &RwLock<Option<ChoiceQueue>> {
+    pub fn current_turn_queue(&self) -> &RwLock<Option<Arc<ChoiceQueue>>> {
-        &self.current_turn_queue
+        &self.data.current_turn_queue
     }
 
     /// Get a Pokemon on the battlefield, on a specific side and an index on that side.
-    pub fn get_pokemon(&self, side: u8, index: u8) -> Option<Arc<Pokemon>> {
+    pub fn get_pokemon(&self, side: u8, index: u8) -> Option<Pokemon> {
-        let side = self.sides.get(side as usize);
+        let side = self.data.sides.get(side as usize);
         let pokemon_read_lock = side?.pokemon();
         let pokemon = pokemon_read_lock.get(index as usize);
         pokemon?.clone()
@@ -180,7 +199,7 @@ impl Battle {
     /// for that slot, or a party is responsible, but has no remaining Pokemon to throw out anymore,
     /// this returns false.
     pub fn can_slot_be_filled(&self, side: u8, index: u8) -> bool {
-        for party in &self.parties {
+        for party in &self.data.parties {
             if party.is_responsible_for_index(side, index) && party.has_pokemon_not_in_field() {
                 return true;
             }
@@ -197,12 +216,12 @@ impl Battle {
         }
         let mut surviving_side_exists = false;
         let mut winning_side = None;
-        for (side_index, side) in self.sides.iter().enumerate() {
+        for (side_index, side) in self.data.sides.iter().enumerate() {
             // If any side has fled, the battle end.
             if side.has_fled_battle() {
-                let mut w = self.result.write();
+                let mut w = self.data.result.write();
                 *w = BattleResult::Inconclusive;
-                self.has_ended.store(true, Ordering::SeqCst);
+                self.data.has_ended.store(true, Ordering::SeqCst);
                 return Ok(());
             }
             // If the side is not defeated
@@ -217,15 +236,15 @@ impl Battle {
         }
         // Everyone died :(
         if !surviving_side_exists {
-            let mut w = self.result.write();
+            let mut w = self.data.result.write();
             *w = BattleResult::Inconclusive;
         }
         // Someone survived, they won!
         else {
-            let mut w = self.result.write();
+            let mut w = self.data.result.write();
             *w = BattleResult::Conclusive(winning_side.ok_or(anyhow!("Winning side was not set"))?);
         }
-        self.has_ended.store(true, Ordering::SeqCst);
+        self.data.has_ended.store(true, Ordering::SeqCst);
         Ok(())
     }
 
@@ -263,7 +282,7 @@ impl Battle {
         let side = choice.user().get_battle_side_index();
         match side {
             Some(side) => {
-                self.sides.get_res(side as usize)?.set_choice(choice)?;
+                self.data.sides.get_res(side as usize)?.set_choice(choice)?;
                 self.check_choices_set_and_run()?;
                 Ok(true)
             }
@@ -274,7 +293,7 @@ impl Battle {
     /// Checks to see whether all Pokemon on the field have set their choices. If so, we then run
     /// the turn.
     fn check_choices_set_and_run(&self) -> Result<()> {
-        for side in &self.sides {
+        for side in &self.data.sides {
             if !side.all_choices_set() {
                 return Ok(());
             }
@@ -283,20 +302,19 @@ impl Battle {
             }
         }
         let start_time = chrono::Utc::now();
-        let mut choices = Vec::with_capacity(self.number_of_sides as usize * self.pokemon_per_side as usize);
+        let mut choices = Vec::with_capacity(self.data.number_of_sides as usize * self.data.pokemon_per_side as usize);
-        for side in &self.sides {
+        for side in &self.data.sides {
             let mut side_choices = side.choices().write();
             for choice_opt in side_choices.deref_mut() {
-                let mut choice = choice_opt
+                let choice = choice_opt
                     .as_mut()
                     .ok_or(anyhow!("Choice was none, but all choices were set? Logic error."))?;
-                let c = choice.deref();
+                if let TurnChoice::Move(data) = choice.clone().deref() {
-                if let TurnChoice::Move(data) = c {
                     let mut change_priority = data.priority();
-                    script_hook!(change_priority, c, c, &mut change_priority);
+                    script_hook!(change_priority, choice, choice, &mut change_priority);
                     if change_priority != data.priority() {
-                        if let TurnChoice::Move(data) = choice.deref_mut() {
+                        if let TurnChoice::Move(data) = choice.clone().deref() {
-                            *data.priority_mut() = change_priority;
+                            data.set_priority(change_priority);
                         }
                     }
                 }
@@ -304,31 +322,34 @@ impl Battle {
                 let mut speed = choice.user().boosted_stats().speed();
                 let c = choice.deref();
                 script_hook!(change_speed, c, c, &mut speed);
-                *choice.speed_mut() = speed;
+                choice.set_speed(speed);
 
-                choice.set_random_value(self.random.get()? as u32);
+                choice.set_random_value(self.data.random.get()? as u32);
                 choices.push(choice_opt.take());
             }
             // Drop the lock guard, as we need to write into it in reset_choices.
             drop(side_choices);
             side.reset_choices();
         }
-        self.current_turn.fetch_add(1, Ordering::SeqCst);
+        self.data.current_turn.fetch_add(1, Ordering::SeqCst);
 
-        self.current_turn_queue.write().replace(ChoiceQueue::new(choices));
+        self.data
+            .current_turn_queue
+            .write()
+            .replace(Arc::new(ChoiceQueue::new(choices)));
 
         {
             self.run_turn()?;
         }
 
-        self.current_turn_queue.write().take();
+        self.data.current_turn_queue.write().take();
-        self.event_hook.trigger(Event::EndTurn);
+        self.data.event_hook.trigger(Event::EndTurn);
         let end_time = chrono::Utc::now();
         let time = end_time - start_time;
         match time.num_nanoseconds() {
             None => {}
             Some(v) => {
-                self.last_turn_time.store(v as u64, Ordering::SeqCst);
+                self.data.last_turn_time.store(v as u64, Ordering::SeqCst);
             }
         }
         Ok(())
@@ -341,16 +362,16 @@ impl Battle {
                 .library()
                 .load_script(self.into(), ScriptCategory::Weather, &weather)?
                 .ok_or(anyhow!("Couldn't find weather script by name {}", weather))?;
-            self.weather.set(script);
+            self.data.weather.set(script);
         } else {
-            self.weather.clear();
+            self.data.weather.clear();
         }
         Ok(())
     }
 
     /// Gets the current weather of the battle. If no weather is present, this returns None.
     pub fn weather_name(&self) -> Result<Option<StringKey>> {
-        if let Some(script) = self.weather.get() {
+        if let Some(script) = self.data.weather.get() {
             let lock = script.read();
             Ok(Some(
                 lock.as_ref().ok_or(PkmnError::UnableToAcquireLock)?.name()?.clone(),
@@ -361,13 +382,38 @@ impl Battle {
     }
 }
 
+impl WeakBattleReference {
+    /// Attempts to upgrade the weak reference to a strong reference. If the strong reference has
+    /// been dropped, this returns None.
+    pub fn upgrade(&self) -> Option<Battle> {
+        self.data.upgrade().map(|battle| Battle { data: battle })
+    }
+
+    /// Gets the inner pointer to the reference counted data.
+    pub(crate) fn as_ptr(&self) -> *const c_void {
+        self.data.as_ptr() as *const c_void
+    }
+}
+
+unsafe impl Send for WeakBattleReference {}
+
+unsafe impl Sync for WeakBattleReference {}
+
+impl PartialEq for WeakBattleReference {
+    fn eq(&self, other: &Self) -> bool {
+        self.data.ptr_eq(&other.data)
+    }
+}
+
+impl Eq for WeakBattleReference {}
+
 impl VolatileScriptsOwner for Battle {
     fn volatile_scripts(&self) -> &Arc<ScriptSet> {
-        &self.volatile_scripts
+        &self.data.volatile_scripts
     }
 
     fn load_volatile_script(&self, key: &StringKey) -> Result<Option<Arc<dyn Script>>> {
-        self.library.load_script(self.into(), ScriptCategory::Battle, key)
+        self.data.library.load_script(self.into(), ScriptCategory::Battle, key)
     }
 }
 
@@ -377,12 +423,12 @@ impl ScriptSource for Battle {
     }
 
     fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
-        &self.script_source_data
+        &self.data.script_source_data
     }
 
     fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
-        scripts.push((&self.weather).into());
+        scripts.push((&self.data.weather).into());
-        scripts.push((&self.volatile_scripts).into());
+        scripts.push((&self.data.volatile_scripts).into());
     }
 
     fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) -> Result<()> {
@@ -393,7 +439,7 @@ impl ScriptSource for Battle {
 
 impl ValueIdentifiable for Battle {
     fn value_identifier(&self) -> ValueIdentifier {
-        self.identifier
+        self.data.identifier
     }
 }
 

src/dynamic_data/models/battle_party.rs

@@ -49,7 +49,7 @@ impl BattleParty {
     }
 
     /// Gets a Pokemon at an index.
-    pub fn get_pokemon(&self, index: usize) -> Option<Arc<Pokemon>> {
+    pub fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
         self.party.at(index)
     }
 

src/dynamic_data/models/battle_random.rs

@@ -60,8 +60,8 @@ impl BattleRandom {
     pub fn effect_chance(
         &self,
         mut chance: f32,
-        executing_move: &ExecutingMove,
+        executing_move: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit_number: u8,
     ) -> Result<bool> {
         script_hook!(

src/dynamic_data/models/battle_side.rs

@@ -1,3 +1,4 @@
+use std::ffi::c_void;
 use std::ops::Deref;
 use std::sync::atomic::{AtomicBool, AtomicU8, Ordering};
 use std::sync::{Arc, Weak};
@@ -11,14 +12,14 @@ use crate::dynamic_data::event_hooks::Event;
 use crate::dynamic_data::models::battle::Battle;
 use crate::dynamic_data::models::pokemon::Pokemon;
 use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
-use crate::dynamic_data::Script;
 use crate::dynamic_data::ScriptSet;
 use crate::dynamic_data::VolatileScriptsOwner;
+use crate::dynamic_data::{Script, WeakBattleReference};
 use crate::{script_hook, StringKey, ValueIdentifiable, ValueIdentifier, VecExt};
 
-/// A side on a battle.
+/// The data that is stored for a battle side.
 #[derive(Debug)]
-pub struct BattleSide {
+struct BattleSideData {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// The index of the side on the battle.
@@ -26,18 +27,18 @@ pub struct BattleSide {
     /// The number of Pokemon that can be on the side.
     pokemon_per_side: u8,
     /// A list of pokemon currently on the battlefield.
-    pokemon: RwLock<Vec<Option<Arc<Pokemon>>>>,
+    pokemon: RwLock<Vec<Option<Pokemon>>>,
     /// The currently set choices for all Pokemon on the battlefield. Cleared when the turn starts.
-    choices: RwLock<Vec<Option<TurnChoice>>>,
+    choices: RwLock<Vec<Option<Arc<TurnChoice>>>>,
     /// The slots on the side that can still be filled. Once all slots are set to false, this side
     /// has lost the battle.
     fillable_slots: Vec<AtomicBool>,
     /// The number of choices that are set.
     choices_set: AtomicU8,
     /// A reference to the battle we're part of.
-    battle: Weak<Battle>,
+    battle: WeakBattleReference,
     /// Whether or not this side has fled.
-    has_fled_battle: bool,
+    has_fled_battle: AtomicBool,
     /// The volatile scripts that are attached to the side.
     volatile_scripts: Arc<ScriptSet>,
 
@@ -45,6 +46,20 @@ pub struct BattleSide {
     script_source_data: RwLock<ScriptSourceData>,
 }
 
+/// A side on a battle.
+#[derive(Debug)]
+pub struct BattleSide {
+    /// The data that is stored for this side.
+    data: Arc<BattleSideData>,
+}
+
+/// A non owning reference to a battle side.
+#[derive(Debug, Clone)]
+pub struct WeakBattleSideReference {
+    /// A weak reference to the data of the battle side.
+    data: Weak<BattleSideData>,
+}
+
 impl BattleSide {
     /// Instantiates a battle side.
     pub fn new(index: u8, pokemon_per_side: u8) -> Self {
@@ -61,6 +76,7 @@ impl BattleSide {
         let pokemon = RwLock::new(pokemon);
 
         Self {
+            data: Arc::new(BattleSideData {
                 identifier: Default::default(),
                 index,
                 pokemon_per_side,
@@ -68,76 +84,84 @@ impl BattleSide {
                 choices,
                 fillable_slots,
                 choices_set: AtomicU8::new(0),
-            battle: Weak::new(),
+                battle: WeakBattleReference::default(),
-            has_fled_battle: false,
+                has_fled_battle: AtomicBool::new(false),
                 volatile_scripts: Default::default(),
                 script_source_data: Default::default(),
+            }),
         }
     }
 
     /// Set the battle this side belongs to.
-    pub(crate) fn set_battle(&mut self, battle: Weak<Battle>) {
+    pub(crate) fn set_battle(&self, battle: WeakBattleReference) {
-        self.battle = battle;
+        #[allow(clippy::unwrap_used)] // Can only be Some()
+        unsafe {
+            (self.data.deref() as *const BattleSideData as *mut BattleSideData)
+                .as_mut()
+                .unwrap()
+                .battle = battle;
+        }
     }
 
     /// The index of the side on the battle.
     pub fn index(&self) -> u8 {
-        self.index
+        self.data.index
     }
     /// The number of Pokemon that can be on the side.
     pub fn pokemon_per_side(&self) -> u8 {
-        self.pokemon_per_side
+        self.data.pokemon_per_side
     }
     /// A list of pokemon currently on the battlefield.
-    pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Arc<Pokemon>>>> {
+    pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Pokemon>>> {
-        self.pokemon.read()
+        self.data.pokemon.read()
     }
     /// The currently set choices for all Pokemon on the battlefield. Cleared when the turn starts.
-    pub fn choices(&self) -> &RwLock<Vec<Option<TurnChoice>>> {
+    pub fn choices(&self) -> &RwLock<Vec<Option<Arc<TurnChoice>>>> {
-        &self.choices
+        &self.data.choices
     }
     /// The slots on the side that can still be filled. Once all slots are set to false, this side
     /// has lost the battle.
     pub fn fillable_slots(&self) -> &Vec<AtomicBool> {
-        &self.fillable_slots
+        &self.data.fillable_slots
     }
     /// The number of choices that are set.
     pub fn choices_set(&self) -> u8 {
-        self.choices_set.load(Ordering::SeqCst)
+        self.data.choices_set.load(Ordering::SeqCst)
     }
     /// A reference to the battle we're part of.
-    pub fn battle(&self) -> Result<Arc<Battle>> {
+    pub fn battle(&self) -> Result<Battle> {
-        self.battle
+        self.data
+            .battle
             .upgrade()
             .ok_or(anyhow!("Battle was not set, but requested"))
     }
     /// Whether or not this side has fled.
     pub fn has_fled_battle(&self) -> bool {
-        self.has_fled_battle
+        self.data.has_fled_battle.load(Ordering::SeqCst)
     }
     /// The volatile scripts that are attached to the side.
     pub fn volatile_scripts(&self) -> &Arc<ScriptSet> {
-        &self.volatile_scripts
+        &self.data.volatile_scripts
     }
 
     /// Whether every Pokemon on this side has its choices  
     pub fn all_choices_set(&self) -> bool {
-        self.choices_set() == self.pokemon_per_side
+        self.choices_set() == self.data.pokemon_per_side
     }
 
     /// Returns true if there are slots that need to be filled with a new pokemon, that have parties
     /// responsible for them. Returns false if all slots are filled with usable pokemon, or slots are
     /// empty, but can't be filled by any party anymore.
     pub fn all_slots_filled(&self) -> Result<bool> {
-        for (i, pokemon) in self.pokemon.read().iter().enumerate() {
+        for (i, pokemon) in self.data.pokemon.read().iter().enumerate() {
             match pokemon {
                 Some(pokemon) => {
-                    if !pokemon.is_usable() && self.battle()?.can_slot_be_filled(self.index, i as u8) {
+                    if !pokemon.is_usable() && self.battle()?.can_slot_be_filled(self.data.index, i as u8) {
                         return Ok(false);
                     }
                 }
                 None => {
-                    if self.battle()?.can_slot_be_filled(self.index, i as u8) {
+                    if self.battle()?.can_slot_be_filled(self.data.index, i as u8) {
                         return Ok(false);
                     }
                 }
@@ -148,11 +172,11 @@ impl BattleSide {
 
     /// Sets a choice for a Pokemon on this side.
     pub(crate) fn set_choice(&self, choice: TurnChoice) -> Result<()> {
-        for (index, pokemon_slot) in self.pokemon.read().iter().enumerate() {
+        for (index, pokemon_slot) in self.data.pokemon.read().iter().enumerate() {
             if let Some(pokemon) = pokemon_slot {
-                if std::ptr::eq(pokemon.deref(), choice.user().deref()) {
+                if Pokemon::eq(pokemon, choice.user()) {
-                    self.choices.write().get_mut_res(index)?.replace(choice);
+                    self.data.choices.write().get_mut_res(index)?.replace(choice.into());
-                    self.choices_set.fetch_add(1, Ordering::SeqCst);
+                    self.data.choices_set.fetch_add(1, Ordering::SeqCst);
                     return Ok(());
                 }
             }
@@ -162,21 +186,21 @@ impl BattleSide {
 
     /// Resets all choices on this side.
     pub fn reset_choices(&self) {
-        let len = self.choices.read().len();
+        let len = self.data.choices.read().len();
         for i in 0..len {
-            self.choices.write().get_mut(i).take();
+            self.data.choices.write().get_mut(i).take();
         }
     }
 
     /// Forcibly removes a Pokemon from the field.
     pub fn force_clear_pokemon(&mut self, index: u8) {
-        self.pokemon.write().get_mut(index as usize).take();
+        self.data.pokemon.write().get_mut(index as usize).take();
     }
 
     /// Switches out a spot on the field for a different Pokemon.
-    pub fn set_pokemon(&self, index: u8, pokemon: Option<Arc<Pokemon>>) -> Result<()> {
+    pub fn set_pokemon(&self, index: u8, pokemon: Option<Pokemon>) -> Result<()> {
         {
-            let mut write_lock = self.pokemon.write();
+            let mut write_lock = self.data.pokemon.write();
             let old = write_lock.get_mut_res(index as usize)?;
             let old = match pokemon {
                 Some(pokemon) => old.replace(pokemon),
@@ -192,33 +216,33 @@ impl BattleSide {
         }
 
         let pokemon = {
-            let read_lock = self.pokemon.read();
+            let read_lock = self.data.pokemon.read();
             &read_lock.get_res(index as usize)?.clone()
         };
         if let Some(pokemon) = pokemon {
-            pokemon.set_battle_data(self.battle.clone(), self.index);
+            pokemon.set_battle_data(self.data.battle.clone(), self.data.index);
             pokemon.set_on_battlefield(true)?;
             pokemon.set_battle_index(index);
 
             let battle = self.battle()?;
             for side in battle.sides() {
-                if side.index() == self.index {
+                if side.index() == self.data.index {
                     continue;
                 }
                 for opponent in side.pokemon().iter().flatten() {
-                    opponent.mark_opponent_as_seen(Arc::downgrade(pokemon));
+                    opponent.mark_opponent_as_seen(pokemon.weak());
-                    pokemon.mark_opponent_as_seen(Arc::downgrade(opponent));
+                    pokemon.mark_opponent_as_seen(opponent.weak());
                 }
             }
             battle.event_hook().trigger(Event::Switch {
-                side_index: self.index,
+                side_index: self.data.index,
                 index,
                 pokemon: Some(pokemon.clone()),
             });
             script_hook!(on_switch_in, pokemon, pokemon);
         } else {
             self.battle()?.event_hook().trigger(Event::Switch {
-                side_index: self.index,
+                side_index: self.data.index,
                 index,
                 pokemon: None,
             });
@@ -227,9 +251,9 @@ impl BattleSide {
     }
 
     /// Checks whether a Pokemon is on the field in this side.
-    pub fn is_pokemon_on_side(&self, pokemon: Arc<Pokemon>) -> bool {
+    pub fn is_pokemon_on_side(&self, pokemon: Pokemon) -> bool {
-        for p in self.pokemon.read().iter().flatten() {
+        for p in self.data.pokemon.read().iter().flatten() {
-            if Arc::ptr_eq(p, &pokemon) {
+            if Pokemon::eq(p, &pokemon) {
                 return true;
             }
         }
@@ -239,18 +263,19 @@ impl BattleSide {
     /// Marks a slot as unfillable. This happens when no parties are able to fill the slot anymore.
     /// If this happens, the slot can not be used again.
     pub(crate) fn mark_slot_as_unfillable(&self, index: u8) -> Result<()> {
-        self.fillable_slots
+        self.data
+            .fillable_slots
             .get_res(index as usize)?
             .store(false, Ordering::SeqCst);
         Ok(())
     }
 
     /// Checks whether a slot is unfillable or not.
-    pub fn is_slot_unfillable(&self, pokemon: Arc<Pokemon>) -> Result<bool> {
+    pub fn is_slot_unfillable(&self, pokemon: Pokemon) -> Result<bool> {
-        for (i, slot) in self.pokemon.read().iter().enumerate() {
+        for (i, slot) in self.data.pokemon.read().iter().enumerate() {
             if let Some(p) = slot {
-                if Arc::ptr_eq(p, &pokemon) {
+                if Pokemon::eq(p, &pokemon) {
-                    return Ok(self.fillable_slots.get_res(i)?.load(Ordering::Relaxed));
+                    return Ok(self.data.fillable_slots.get_res(i)?.load(Ordering::Relaxed));
                 }
             }
         }
@@ -259,7 +284,7 @@ impl BattleSide {
 
     /// Checks whether the side has been defeated.
     pub fn is_defeated(&self) -> bool {
-        for fillable_slot in &self.fillable_slots {
+        for fillable_slot in &self.data.fillable_slots {
             if fillable_slot.load(Ordering::Relaxed) {
                 return false;
             }
@@ -269,19 +294,20 @@ impl BattleSide {
 
     /// Mark the side as fled.
     pub fn mark_as_fled(&mut self) {
-        self.has_fled_battle = true;
+        self.data.has_fled_battle.store(true, Ordering::SeqCst);
     }
 
     /// Gets a random Pokemon on the given side.
     pub fn get_random_creature_index(&self) -> Result<u8> {
         // TODO: Consider adding parameter to only get index for available creatures.
-        Ok(self.battle()?.random().get_max(self.pokemon_per_side as i32)? as u8)
+        Ok(self.battle()?.random().get_max(self.data.pokemon_per_side as i32)? as u8)
     }
 
     /// Swap two Pokemon on a single side around.
     pub fn swap_positions(&mut self, a: u8, b: u8) -> Result<bool> {
+        let data = &self.data;
         // If out of range, don't allow swapping.
-        if a >= self.pokemon_per_side || b >= self.pokemon_per_side {
+        if a >= data.pokemon_per_side || b >= data.pokemon_per_side {
             return Ok(false);
         }
         // If the two indices are the same, don't allow swapping.
@@ -294,10 +320,10 @@ impl BattleSide {
         let mut party_b = None;
         let battle = self.battle()?;
         for party in battle.parties() {
-            if party.is_responsible_for_index(self.index, a) {
+            if party.is_responsible_for_index(data.index, a) {
                 party_a = Some(party);
             }
-            if party.is_responsible_for_index(self.index, b) {
+            if party.is_responsible_for_index(data.index, b) {
                 party_b = Some(party);
             }
         }
@@ -315,19 +341,49 @@ impl BattleSide {
             return Ok(false);
         }
 
-        self.pokemon.write().swap(a as usize, b as usize);
+        data.pokemon.write().swap(a as usize, b as usize);
         self.battle()?.event_hook().trigger(Event::Swap {
-            side_index: self.index,
+            side_index: data.index,
             index_a: a,
             index_b: b,
         });
         Ok(true)
     }
+
+    /// Gets a weak reference to the side.
+    pub fn weak(&self) -> WeakBattleSideReference {
+        WeakBattleSideReference {
+            data: Arc::downgrade(&self.data),
+        }
+    }
+}
+
+impl WeakBattleSideReference {
+    /// Upgrades the weak reference to a strong reference, returning `None` if the side has been
+    /// dropped.
+    pub fn upgrade(&self) -> Option<BattleSide> {
+        self.data.upgrade().map(|data| BattleSide { data })
+    }
+
+    /// Gets the underlying pointer to the data of the side.
+    pub(crate) fn as_ptr(&self) -> *const c_void {
+        self.data.as_ptr() as *const c_void
+    }
+}
+
+unsafe impl Send for WeakBattleSideReference {}
+
+unsafe impl Sync for WeakBattleSideReference {}
+
+impl PartialEq for WeakBattleSideReference {
+    fn eq(&self, other: &Self) -> bool {
+        self.data.ptr_eq(&other.data)
+    }
 }
 
 impl VolatileScriptsOwner for BattleSide {
     fn volatile_scripts(&self) -> &Arc<ScriptSet> {
-        &self.volatile_scripts
+        &self.data.volatile_scripts
     }
 
     fn load_volatile_script(&self, key: &StringKey) -> Result<Option<Arc<dyn Script>>> {
@@ -343,11 +399,11 @@ impl ScriptSource for BattleSide {
     }
 
     fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
-        &self.script_source_data
+        &self.data.script_source_data
     }
 
     fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
-        scripts.push((&self.volatile_scripts).into());
+        scripts.push((&self.data.volatile_scripts).into());
     }
 
     fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) -> Result<()> {
@@ -358,6 +414,6 @@ impl ScriptSource for BattleSide {
 
 impl ValueIdentifiable for BattleSide {
     fn value_identifier(&self) -> ValueIdentifier {
-        self.identifier
+        self.data.identifier
     }
 }

src/dynamic_data/models/executing_move.rs

@@ -16,7 +16,6 @@ use crate::{PkmnError, ValueIdentifiable, ValueIdentifier};
 
 /// A hit data is the data for a single hit, on a single target.
 #[derive(Default, Debug)]
-
 pub struct HitData {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
@@ -96,9 +95,9 @@ pub struct ExecutingMove {
     number_of_hits: u8,
     /// A list of hits for this move. For multi target multi hit moves, this stores the hits linearly,
     /// for example: (target1, hit1), (target1, hit2), (target2, hit1), (target2, hit2), etc.
-    hits: Vec<HitData>,
+    hits: Vec<Arc<HitData>>,
     /// The user of the move.
-    user: Arc<Pokemon>,
+    user: Pokemon,
     /// The move the user has actually chosen to do.
     chosen_move: Arc<LearnedMove>,
     /// The move that the user is actually going to do.
@@ -116,7 +115,7 @@ impl ExecutingMove {
     pub fn new(
         targets: TargetList,
         number_of_hits: u8,
-        user: Arc<Pokemon>,
+        user: Pokemon,
         chosen_move: Arc<LearnedMove>,
         use_move: Arc<dyn MoveData>,
         script: ScriptContainer,
@@ -124,7 +123,7 @@ impl ExecutingMove {
         let total_hits = number_of_hits as usize * targets.len();
         let mut hits = Vec::with_capacity(total_hits);
         for _i in 0..total_hits {
-            hits.push(HitData::default())
+            hits.push(Arc::new(HitData::default()))
         }
         Self {
             identifier: Default::default(),
@@ -148,7 +147,7 @@ impl ExecutingMove {
         self.number_of_hits
     }
     /// The user of the move.
-    pub fn user(&self) -> &Arc<Pokemon> {
+    pub fn user(&self) -> &Pokemon {
         &self.user
     }
     /// The move the user has actually chosen to do.
@@ -165,10 +164,10 @@ impl ExecutingMove {
     }
 
     /// Gets a hit data for a target, with a specific index.
-    pub fn get_hit_data(&self, for_target: &Arc<Pokemon>, hit: u8) -> Result<&HitData> {
+    pub fn get_hit_data(&self, for_target: &Pokemon, hit: u8) -> Result<&Arc<HitData>> {
         for (index, target) in self.targets.iter().enumerate() {
             if let Some(target) = target {
-                if Arc::ptr_eq(target, for_target) {
+                if Pokemon::eq(target, for_target) {
                     let i = index * self.number_of_hits as usize + hit as usize;
                     return match self.hits.get(i) {
                         Some(hit) => Ok(hit),
@@ -185,9 +184,9 @@ impl ExecutingMove {
     }
 
     /// Checks whether a Pokemon is a target for this move.
-    pub fn is_pokemon_target(&self, pokemon: &Arc<Pokemon>) -> bool {
+    pub fn is_pokemon_target(&self, pokemon: &Pokemon) -> bool {
         for target in self.targets.iter().flatten() {
-            if Arc::ptr_eq(target, pokemon) {
+            if Pokemon::eq(target, pokemon) {
                 return true;
             }
         }
@@ -195,10 +194,10 @@ impl ExecutingMove {
     }
 
     /// Gets the index of the hits in this move where the hits for a specific target start.
-    pub(crate) fn get_index_of_target(&self, for_target: &Arc<Pokemon>) -> Result<usize> {
+    pub(crate) fn get_index_of_target(&self, for_target: &Pokemon) -> Result<usize> {
         for (index, target) in self.targets.iter().enumerate() {
             if let Some(target) = target {
-                if Arc::ptr_eq(target, for_target) {
+                if Pokemon::eq(target, for_target) {
                     let i = index * self.number_of_hits as usize;
                     return Ok(i);
                 }

src/dynamic_data/models/pokemon.rs

@@ -1,3 +1,4 @@
+use std::ffi::c_void;
 use std::fmt::{Debug, Formatter};
 use std::ops::{Deref, DerefMut};
 use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU8, Ordering};
@@ -12,7 +13,9 @@ use crate::dynamic_data::event_hooks::Event;
 use crate::dynamic_data::models::battle::Battle;
 use crate::dynamic_data::models::learned_move::{LearnedMove, MoveLearnMethod};
 use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
-use crate::dynamic_data::{DynamicLibrary, Script, ScriptCategory, ScriptContainer, ScriptSet, VolatileScriptsOwner};
+use crate::dynamic_data::{
+    DynamicLibrary, Script, ScriptCategory, ScriptContainer, ScriptSet, VolatileScriptsOwner, WeakBattleReference,
+};
 use crate::static_data::AbilityIndex;
 use crate::static_data::Form;
 use crate::static_data::Gender;
@@ -26,8 +29,8 @@ use crate::utils::Random;
 use crate::{script_hook, PkmnError, StringKey, ValueIdentifiable, ValueIdentifier, VecExt};
 use anyhow::{anyhow, bail, Result};
 
-/// An individual Pokemon as we know and love them.
+/// The data of a Pokemon.
-pub struct Pokemon {
+struct PokemonData {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// The library data of the Pokemon.
@@ -67,16 +70,16 @@ pub struct Pokemon {
     height: Atomic<f32>,
 
     /// The stats of the Pokemon when disregarding any stat boosts.
-    flat_stats: StatisticSet<u32>,
+    flat_stats: Arc<StatisticSet<u32>>,
     /// The statistics boosts of the Pokemon. Will prevent the value from going above 6, and below
     /// -6.
-    stat_boost: ClampedStatisticSet<i8, -6, 6>,
+    stat_boost: Arc<ClampedStatisticSet<i8, -6, 6>>,
     /// The stats of the Pokemon including the stat boosts
-    boosted_stats: StatisticSet<u32>,
+    boosted_stats: Arc<StatisticSet<u32>>,
     /// The [individual values](https://bulbapedia.bulbagarden.net/wiki/Individual_values) of the Pokemon.
-    individual_values: ClampedStatisticSet<u8, 0, 31>,
+    individual_values: Arc<ClampedStatisticSet<u8, 0, 31>>,
     /// The [effort values](https://bulbapedia.bulbagarden.net/wiki/Effort_values) of the Pokemon.
-    effort_values: ClampedStatisticSet<u8, 0, 252>,
+    effort_values: Arc<ClampedStatisticSet<u8, 0, 252>>,
     /// The [nature](https://bulbapedia.bulbagarden.net/wiki/Nature) of the Pokemon.
     nature: Arc<dyn Nature>,
 
@@ -118,6 +121,24 @@ pub struct Pokemon {
     script_source_data: RwLock<ScriptSourceData>,
 }
 
+/// An individual Pokemon.
+#[derive(Clone)]
+pub struct Pokemon {
+    /// The data of the Pokemon.
+    data: Arc<PokemonData>,
+}
+
+/// A non-owning reference to a Pokemon.
+#[derive(Debug, Clone)]
+pub struct WeakPokemonReference {
+    /// The weak reference to the data.
+    data: Weak<PokemonData>,
+}
+
+unsafe impl Send for WeakPokemonReference {}
+
+unsafe impl Sync for WeakPokemonReference {}
+
 impl Pokemon {
     /// Instantiates a new Pokemon.
     pub fn new(
@@ -143,7 +164,7 @@ impl Pokemon {
             .natures()
             .get_nature(nature)
             .ok_or(PkmnError::InvalidNatureName { nature: nature.clone() })?;
-        let mut pokemon = Self {
+        let pokemon_data = PokemonData {
             identifier: Default::default(),
             library,
             species: RwLock::new(species),
@@ -180,28 +201,32 @@ impl Pokemon {
             volatile: Default::default(),
             script_source_data: Default::default(),
         };
+
+        let pokemon = Self {
+            data: Arc::new(pokemon_data),
+        };
         pokemon.recalculate_flat_stats()?;
         let health = pokemon.flat_stats().hp();
-        pokemon.current_health = AtomicU32::new(health);
+        pokemon.data.current_health.store(health, Ordering::Relaxed);
 
         Ok(pokemon)
     }
 
     /// The library data of the Pokemon.
     pub fn library(&self) -> &Arc<dyn DynamicLibrary> {
-        &self.library
+        &self.data.library
     }
     /// The species of the Pokemon.
     pub fn species(&self) -> Arc<dyn Species> {
-        self.species.read().clone()
+        self.data.species.read().clone()
     }
     /// The form of the Pokemon.
     pub fn form(&self) -> Arc<dyn Form> {
-        self.form.read().clone()
+        self.data.form.read().clone()
     }
     /// The species that should be displayed to the user. This handles stuff like the Illusion ability.
     pub fn display_species(&self) -> Arc<dyn Species> {
-        if let Some(v) = &self.display_species {
+        if let Some(v) = &self.data.display_species {
             v.clone()
         } else {
             self.species()
@@ -209,7 +234,7 @@ impl Pokemon {
     }
     /// The form that should be displayed to the user. This handles stuff like the Illusion ability.
     pub fn display_form(&self) -> Arc<dyn Form> {
-        if let Some(v) = &self.display_form {
+        if let Some(v) = &self.data.display_form {
             v.clone()
         } else {
             self.form()
@@ -217,53 +242,57 @@ impl Pokemon {
     }
     /// The current level of the Pokemon.
     pub fn level(&self) -> LevelInt {
-        self.level.load(Ordering::Relaxed)
+        self.data.level.load(Ordering::Relaxed)
     }
     /// The amount of experience of the Pokemon.
     pub fn experience(&self) -> u32 {
-        self.experience.load(Ordering::Relaxed)
+        self.data.experience.load(Ordering::Relaxed)
     }
     /// A unique random number for this Pokemon.
     pub fn unique_identifier(&self) -> u32 {
-        self.unique_identifier
+        self.data.unique_identifier
     }
     /// The gender of the Pokemon.
     pub fn gender(&self) -> Gender {
-        *self.gender.read()
+        *self.data.gender.read()
     }
     /// The coloring of the Pokemon. Value 0 is the default, value 1 means shiny. Other values are
     /// currently not used, and can be used for other implementations.
     pub fn coloring(&self) -> u8 {
-        self.coloring
+        self.data.coloring
     }
     /// Gets the held item of a Pokemon
     pub fn held_item(&self) -> &RwLock<Option<Arc<dyn Item>>> {
-        &self.held_item
+        &self.data.held_item
     }
     /// Checks whether the Pokemon is holding a specific item.
     pub fn has_held_item(&self, name: &StringKey) -> bool {
         // Only true if we have an item, and the item name is the same as the requested item.
-        if let Some(v) = self.held_item.read().deref() {
+        if let Some(v) = self.data.held_item.read().deref() {
             return v.name() == name;
         }
         false
     }
     /// Changes the held item of the Pokemon. Returns the previously held item.
     pub fn set_held_item(&self, item: &Arc<dyn Item>) -> Option<Arc<dyn Item>> {
-        self.held_item.write().replace(item.clone())
+        self.data.held_item.write().replace(item.clone())
     }
     /// Removes the held item from the Pokemon. Returns the previously held item.
     pub fn remove_held_item(&self) -> Option<Arc<dyn Item>> {
-        self.held_item.write().take()
+        self.data.held_item.write().take()
     }
     /// Makes the Pokemon uses its held item.
     pub fn consume_held_item(&self) -> Result<bool> {
-        if self.held_item.read().is_none() {
+        if self.data.held_item.read().is_none() {
             return Ok(false);
         }
-        let script = self
+        let script = self.data.library.load_item_script(
-            .library
+            self.data
-            .load_item_script(self.held_item.read().as_ref().ok_or(PkmnError::UnableToAcquireLock)?)?;
+                .held_item
+                .read()
+                .as_ref()
+                .ok_or(PkmnError::UnableToAcquireLock)?,
+        )?;
         if script.is_none() {
             return Ok(false);
         }
@@ -274,60 +303,60 @@ impl Pokemon {
 
     /// The remaining health points of the Pokemon.
     pub fn current_health(&self) -> u32 {
-        self.current_health.load(Ordering::Relaxed)
+        self.data.current_health.load(Ordering::Relaxed)
     }
     /// The max health points of the Pokemon.
     pub fn max_health(&self) -> u32 {
-        self.boosted_stats.hp()
+        self.data.boosted_stats.hp()
     }
     /// The weight of the Pokemon in kilograms.
     pub fn weight(&self) -> f32 {
-        self.weight.load(Ordering::Relaxed)
+        self.data.weight.load(Ordering::Relaxed)
     }
     /// Sets the weight of the Pokemon in kilograms.
     pub fn set_weight(&self, weight: f32) {
-        self.weight.store(weight, Ordering::Relaxed)
+        self.data.weight.store(weight, Ordering::Relaxed)
     }
 
     /// The height of the Pokemon in meters.
     pub fn height(&self) -> f32 {
-        self.height.load(Ordering::Relaxed)
+        self.data.height.load(Ordering::Relaxed)
     }
     /// An optional nickname of the Pokemon.
     pub fn nickname(&self) -> &Option<String> {
-        &self.nickname
+        &self.data.nickname
     }
     /// An index of the ability to find the actual ability on the form.
     pub fn real_ability(&self) -> &AbilityIndex {
-        &self.ability_index
+        &self.data.ability_index
     }
     /// The current types of the Pokemon.
     pub fn types(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<TypeIdentifier>> {
-        self.types.read()
+        self.data.types.read()
     }
     /// The moves the Pokemon has learned. This is of a set length of [`MAX_MOVES`]. Empty move slots
     /// are defined by None.
     pub fn learned_moves(&self) -> &RwLock<[Option<Arc<LearnedMove>>; MAX_MOVES]> {
-        &self.moves
+        &self.data.moves
     }
 
     /// The stats of the Pokemon when disregarding any stat boosts.
-    pub fn flat_stats(&self) -> &StatisticSet<u32> {
+    pub fn flat_stats(&self) -> &Arc<StatisticSet<u32>> {
-        &self.flat_stats
+        &self.data.flat_stats
     }
 
     /// The amount of boosts on a specific stat.
-    pub fn stat_boosts(&self) -> &ClampedStatisticSet<i8, -6, 6> {
+    pub fn stat_boosts(&self) -> &Arc<ClampedStatisticSet<i8, -6, 6>> {
-        &self.stat_boost
+        &self.data.stat_boost
     }
 
     /// The stats of the Pokemon including the stat boosts
-    pub fn boosted_stats(&self) -> &StatisticSet<u32> {
+    pub fn boosted_stats(&self) -> &Arc<StatisticSet<u32>> {
-        &self.boosted_stats
+        &self.data.boosted_stats
     }
     /// Get the stat boosts for a specific stat.
     pub fn stat_boost(&self, stat: Statistic) -> i8 {
-        self.stat_boost.get_stat(stat)
+        self.data.stat_boost.get_stat(stat)
     }
     /// Change a boosted stat by a certain amount.
     pub fn change_stat_boost(&self, stat: Statistic, mut diff_amount: i8, self_inflicted: bool) -> Result<bool> {
@@ -357,13 +386,13 @@ impl Pokemon {
         }
 
         let mut changed = false;
-        let old_value = self.stat_boost.get_stat(stat);
+        let old_value = self.data.stat_boost.get_stat(stat);
         match diff_amount.cmp(&0_i8) {
             std::cmp::Ordering::Less => {
-                changed = self.stat_boost.decrease_stat(stat, -diff_amount);
+                changed = self.data.stat_boost.decrease_stat(stat, -diff_amount);
             }
             std::cmp::Ordering::Greater => {
-                changed = self.stat_boost.increase_stat(stat, -diff_amount);
+                changed = self.data.stat_boost.increase_stat(stat, -diff_amount);
             }
             _ => {}
         }
@@ -383,17 +412,17 @@ impl Pokemon {
     }
 
     /// The [individual values](https://bulbapedia.bulbagarden.net/wiki/Individual_values) of the Pokemon.
-    pub fn individual_values(&self) -> &ClampedStatisticSet<u8, 0, 31> {
+    pub fn individual_values(&self) -> &Arc<ClampedStatisticSet<u8, 0, 31>> {
-        &self.individual_values
+        &self.data.individual_values
     }
     /// The [effort values](https://bulbapedia.bulbagarden.net/wiki/Effort_values) of the Pokemon.
-    pub fn effort_values(&self) -> &ClampedStatisticSet<u8, 0, 252> {
+    pub fn effort_values(&self) -> &Arc<ClampedStatisticSet<u8, 0, 252>> {
-        &self.effort_values
+        &self.data.effort_values
     }
 
     /// Gets the battle the battle is currently in.
-    pub fn get_battle(&self) -> Option<Arc<Battle>> {
+    pub fn get_battle(&self) -> Option<Battle> {
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
         if let Some(data) = &r.deref() {
             data.battle.upgrade()
         } else {
@@ -403,26 +432,31 @@ impl Pokemon {
     /// Get the index of the side of the battle the Pokemon is in. Only returns a value if the Pokemon
     /// is on the battlefield.
     pub fn get_battle_side_index(&self) -> Option<u8> {
-        self.battle_data.read().as_ref().map(|data| data.battle_side_index())
+        self.data
+            .battle_data
+            .read()
+            .as_ref()
+            .map(|data| data.battle_side_index())
     }
     /// Get the index of the slot on the side of the battle the Pokemon is in. Only returns a value
     /// if the Pokemon is on the battlefield.
     pub fn get_battle_index(&self) -> Option<u8> {
-        self.battle_data.read().as_ref().map(|data| data.index())
+        self.data.battle_data.read().as_ref().map(|data| data.index())
     }
     /// Returns whether something overrides the ability.
     pub fn is_ability_overriden(&self) -> bool {
-        self.override_ability.is_some()
+        self.data.override_ability.is_some()
     }
     /// Returns the currently active ability.
     pub fn active_ability(&self) -> Result<Arc<dyn Ability>> {
-        if let Some(v) = &self.override_ability {
+        if let Some(v) = &self.data.override_ability {
             return Ok(v.clone());
         }
 
         let form = self.form();
-        let ability = form.get_ability(self.ability_index)?;
+        let ability = form.get_ability(self.data.ability_index)?;
         Ok(self
+            .data
             .library
             .static_data()
             .abilities()
@@ -434,68 +468,70 @@ impl Pokemon {
 
     /// The script for the status.
     pub fn status(&self) -> &ScriptContainer {
-        &self.status_script
+        &self.data.status_script
     }
 
     /// Returns the script for the currently active ability.
     pub fn ability_script(&self) -> &ScriptContainer {
-        &self.ability_script
+        &self.data.ability_script
     }
 
     /// Whether or not the Pokemon is allowed to gain experience.
     pub fn allowed_experience_gain(&self) -> bool {
-        self.allowed_experience
+        self.data.allowed_experience
     }
 
     /// The [nature](https://bulbapedia.bulbagarden.net/wiki/Nature) of the Pokemon.
     pub fn nature(&self) -> &Arc<dyn Nature> {
-        &self.nature
+        &self.data.nature
     }
 
     /// Calculates the flat stats on the Pokemon. This should be called when for example the base
     /// stats, level, nature, IV, or EV changes. This has a side effect of recalculating the boosted
     /// stats, as those depend on the flat stats.
     pub fn recalculate_flat_stats(&self) -> Result<()> {
-        self.library
+        self.data
+            .library
             .stat_calculator()
-            .calculate_flat_stats(self, &self.flat_stats)?;
+            .calculate_flat_stats(self, &self.data.flat_stats)?;
         self.recalculate_boosted_stats()?;
         Ok(())
     }
     /// Calculates the boosted stats on the Pokemon, _without_ recalculating the flat stats.
     /// This should be called when a stat boost changes.
     pub fn recalculate_boosted_stats(&self) -> Result<()> {
-        self.library
+        self.data
+            .library
             .stat_calculator()
-            .calculate_boosted_stats(self, &self.boosted_stats)
+            .calculate_boosted_stats(self, &self.data.boosted_stats)
     }
 
     /// Change the species of the Pokemon.
     pub fn change_species(&self, species: Arc<dyn Species>, form: Arc<dyn Form>) -> Result<()> {
-        *self.species.write() = species.clone();
+        *self.data.species.write() = species.clone();
-        *self.form.write() = form.clone();
+        *self.data.form.write() = form.clone();
 
         // 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 we're in battle, use the battle random for predictability
-            let r = self.battle_data.read();
+            let r = self.data.battle_data.read();
             if let Some(data) = r.deref() {
                 let battle = data.battle().ok_or(anyhow!("Battle not set"))?;
                 let mut random = match battle.random().get_rng().lock() {
                     Ok(v) => v,
                     Err(_) => return Err(PkmnError::UnableToAcquireLock.into()),
                 };
-                *self.gender.write() = species.get_random_gender(random.deref_mut());
+                *self.data.gender.write() = species.get_random_gender(random.deref_mut());
             } else {
                 // If we're not in battle, just use a new random.
-                *self.gender.write() = species.get_random_gender(&mut Random::default());
+                *self.data.gender.write() = 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.write() = Gender::Genderless;
+            *self.data.gender.write() = Gender::Genderless;
         }
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
         if let Some(battle_data) = &r.deref() {
             if let Some(battle) = battle_data.battle() {
                 battle.event_hook().trigger(Event::SpeciesChange {
@@ -513,29 +549,31 @@ impl Pokemon {
         if self.form().value_identifier() == form.value_identifier() {
             return Ok(());
         }
-        *self.form.write() = form.clone();
+        *self.data.form.write() = form.clone();
 
         {
-            let mut type_lock = self.types.write();
+            let mut type_lock = self.data.types.write();
             type_lock.clear();
             for t in form.types() {
                 type_lock.push(*t);
             }
         }
-        self.weight.store(form.weight(), Ordering::SeqCst);
+        self.data.weight.store(form.weight(), Ordering::SeqCst);
-        self.height.store(form.height(), Ordering::SeqCst);
+        self.data.height.store(form.height(), Ordering::SeqCst);
 
         let ability = self.active_ability()?;
         let ability_script = self
+            .data
             .library
             .load_script(self.into(), ScriptCategory::Ability, ability.name())?;
         if let Some(ability_script) = ability_script {
             let script_result = self
+                .data
                 .ability_script
                 .set(ability_script)
                 .as_ref()
                 // Ensure the ability script gets initialized with the parameters for the ability.
-                .on_initialize(&self.library, ability.parameters().to_vec());
+                .on_initialize(&self.data.library, ability.parameters().to_vec());
             match script_result {
                 Ok(_) => (),
                 Err(e) => {
@@ -543,21 +581,23 @@ impl Pokemon {
                 }
             }
         } else {
-            self.ability_script.clear();
+            self.data.ability_script.clear();
         }
         let old_health = self.max_health();
         self.recalculate_flat_stats()?;
         let diff_health = (self.max_health() - old_health) as i32;
         if self.current_health() == 0 && (self.current_health() as i32) < -diff_health {
-            self.current_health.store(0, Ordering::SeqCst);
+            self.data.current_health.store(0, Ordering::SeqCst);
         } else if diff_health < 0 {
-            self.current_health.fetch_sub(-diff_health as u32, Ordering::SeqCst);
+            self.data
+                .current_health
+                .fetch_sub(-diff_health as u32, Ordering::SeqCst);
         } else {
-            self.current_health.fetch_add(diff_health as u32, Ordering::SeqCst);
+            self.data.current_health.fetch_add(diff_health as u32, Ordering::SeqCst);
         }
         // TODO: consider form specific attacks?
 
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
         if let Some(battle_data) = r.deref() {
             if let Some(battle) = battle_data.battle() {
                 battle.event_hook().trigger(Event::FormChange {
@@ -571,7 +611,7 @@ impl Pokemon {
 
     /// Whether or not the Pokemon is useable in a battle.
     pub fn is_usable(&self) -> bool {
-        !self.is_caught && !self.is_egg && !self.is_fainted()
+        !self.data.is_caught && !self.data.is_egg && !self.is_fainted()
     }
 
     /// Returns whether the Pokemon is fainted.
@@ -580,8 +620,8 @@ impl Pokemon {
     }
 
     /// Sets the current battle the Pokemon is in.
-    pub fn set_battle_data(&self, battle: Weak<Battle>, battle_side_index: u8) {
+    pub fn set_battle_data(&self, battle: WeakBattleReference, battle_side_index: u8) {
-        let mut w = self.battle_data.write();
+        let mut w = self.data.battle_data.write();
         if let Some(battle_data) = w.deref_mut() {
             battle_data.battle = battle;
             battle_data.battle_side_index.store(battle_side_index, Ordering::SeqCst);
@@ -598,13 +638,13 @@ impl Pokemon {
 
     /// Sets whether or not the Pokemon is on the battlefield.
     pub fn set_on_battlefield(&self, value: bool) -> Result<()> {
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
         if let Some(data) = &mut r.deref() {
             data.on_battle_field.store(value, Ordering::SeqCst);
             if !value {
-                self.volatile.clear()?;
+                self.data.volatile.clear()?;
-                self.weight.store(self.form().weight(), Ordering::SeqCst);
+                self.data.weight.store(self.form().weight(), Ordering::SeqCst);
-                self.height.store(self.form().height(), Ordering::SeqCst);
+                self.data.height.store(self.form().height(), Ordering::SeqCst);
             }
         }
         Ok(())
@@ -612,7 +652,7 @@ impl Pokemon {
 
     /// Sets the index of the slot of the side the Pokemon is on.
     pub fn set_battle_index(&self, index: u8) {
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
         if let Some(data) = r.deref() {
             data.index.store(index, Ordering::SeqCst)
         }
@@ -620,16 +660,20 @@ impl Pokemon {
 
     /// Whether or not the Pokemon is on the battlefield.
     pub fn is_on_battlefield(&self) -> bool {
-        self.battle_data.read().as_ref().is_some_and(|a| a.on_battle_field())
+        self.data
+            .battle_data
+            .read()
+            .as_ref()
+            .is_some_and(|a| a.on_battle_field())
     }
 
     /// Marks an opponent as seen, for use in experience gain.
-    pub fn mark_opponent_as_seen(&self, pokemon: Weak<Pokemon>) {
+    pub fn mark_opponent_as_seen(&self, pokemon: WeakPokemonReference) {
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
-        if let Some(battle_data) = &r.deref() {
+        if let Some(battle_data) = r.deref() {
             let mut opponents = battle_data.seen_opponents().write();
             for seen_opponent in opponents.deref() {
-                if seen_opponent.ptr_eq(&pokemon) {
+                if seen_opponent.eq(&pokemon) {
                     return;
                 }
             }
@@ -646,7 +690,7 @@ impl Pokemon {
             return Ok(());
         }
         let new_health = self.current_health() - damage;
-        if let Some(battle_data) = &self.battle_data.read().deref() {
+        if let Some(battle_data) = &self.data.battle_data.read().deref() {
             if let Some(battle) = battle_data.battle() {
                 battle.event_hook().trigger(Event::Damage {
                     pokemon: self,
@@ -656,11 +700,17 @@ impl Pokemon {
                 });
             }
         }
-        if self.battle_data.read().as_ref().is_some_and(|a| a.on_battle_field()) {
+        if self
+            .data
+            .battle_data
+            .read()
+            .as_ref()
+            .is_some_and(|a| a.on_battle_field())
+        {
             script_hook!(on_damage, self, self, source, self.current_health(), new_health);
         }
 
-        self.current_health.store(new_health, Ordering::SeqCst);
+        self.data.current_health.store(new_health, Ordering::SeqCst);
         if self.is_fainted() && damage > 0 {
             self.on_faint(source)?;
         }
@@ -669,7 +719,7 @@ impl Pokemon {
 
     /// Triggers when the Pokemon faints.
     fn on_faint(&self, source: DamageSource) -> Result<()> {
-        let r = self.battle_data.read();
+        let r = self.data.battle_data.read();
         if let Some(battle_data) = r.deref() {
             if let Some(battle) = battle_data.battle() {
                 battle.event_hook().trigger(Event::Faint { pokemon: self });
@@ -703,7 +753,7 @@ impl Pokemon {
             return false;
         }
         let new_health = self.current_health() + max_amount;
-        if let Some(battle_data) = &self.battle_data.read().deref() {
+        if let Some(battle_data) = &self.data.battle_data.read().deref() {
             if let Some(battle) = battle_data.battle() {
                 battle.event_hook().trigger(Event::Heal {
                     pokemon: self,
@@ -712,7 +762,7 @@ impl Pokemon {
                 });
             }
         }
-        self.current_health.store(new_health, Ordering::SeqCst);
+        self.data.current_health.store(new_health, Ordering::SeqCst);
         true
     }
 
@@ -727,6 +777,7 @@ impl Pokemon {
             }
         };
         let move_data = self
+            .data
             .library
             .static_data()
             .moves()
@@ -742,12 +793,13 @@ impl Pokemon {
 
     /// Removes the current non-volatile status from the Pokemon.
     pub fn clear_status(&self) {
-        self.status_script.clear()
+        self.data.status_script.clear()
     }
 
     /// Increases the level by a certain amount
     pub fn change_level_by(&self, amount: LevelInt) -> Result<()> {
-        self.level
+        self.data
+            .level
             .fetch_update(Ordering::SeqCst, Ordering::Relaxed, |x| {
                 let max_level = self.library().static_data().settings().maximum_level();
                 if x + amount > max_level {
@@ -759,13 +811,50 @@ impl Pokemon {
             .ok();
         self.recalculate_flat_stats()
     }
+
+    /// Take a weak reference to the Pokemon.
+    pub fn weak(&self) -> WeakPokemonReference {
+        WeakPokemonReference {
+            data: Arc::downgrade(&self.data),
+        }
+    }
+}
+
+impl PartialEq for Pokemon {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.data, &other.data)
+    }
+}
+
+impl Eq for Pokemon {}
+
+impl PartialEq for WeakPokemonReference {
+    fn eq(&self, other: &Self) -> bool {
+        Weak::ptr_eq(&self.data, &other.data)
+    }
+}
+
+impl Eq for WeakPokemonReference {}
+
+impl WeakPokemonReference {
+    /// Attempts to upgrade the weak reference to a strong reference.
+    pub fn upgrade(&self) -> Option<Pokemon> {
+        Some(Pokemon {
+            data: self.data.upgrade()?,
+        })
+    }
+
+    /// Gets the pointer to the underlying data.
+    pub(crate) fn as_ptr(&self) -> *const c_void {
+        self.data.as_ptr() as *const c_void
+    }
 }
 
 /// The data of the Pokemon related to being in a battle.
 #[derive(Debug)]
 pub struct PokemonBattleData {
     /// The battle data of the Pokemon
-    battle: Weak<Battle>,
+    battle: WeakBattleReference,
     /// The index of the side of the Pokemon
     battle_side_index: AtomicU8,
     /// The index of the slot on the side of the Pokemon.
@@ -773,16 +862,12 @@ pub struct PokemonBattleData {
     /// Whether or not the Pokemon is on the battlefield.
     on_battle_field: AtomicBool,
     /// A list of opponents the Pokemon has seen this battle.
-    seen_opponents: RwLock<Vec<Weak<Pokemon>>>,
+    seen_opponents: RwLock<Vec<WeakPokemonReference>>,
 }
 
 impl PokemonBattleData {
     /// The battle data of the Pokemon
-    pub fn battle_mut(&mut self) -> Option<Arc<Battle>> {
+    pub fn battle(&self) -> Option<Battle> {
-        self.battle.upgrade()
-    }
-    /// The battle data of the Pokemon
-    pub fn battle(&self) -> Option<Arc<Battle>> {
         self.battle.upgrade()
     }
 
@@ -799,7 +884,7 @@ impl PokemonBattleData {
         self.on_battle_field.load(Ordering::Relaxed)
     }
     /// A list of opponents the Pokemon has seen this battle.
-    pub fn seen_opponents(&self) -> &RwLock<Vec<Weak<Pokemon>>> {
+    pub fn seen_opponents(&self) -> &RwLock<Vec<WeakPokemonReference>> {
         &self.seen_opponents
     }
 }
@@ -807,7 +892,7 @@ impl PokemonBattleData {
 impl ScriptSource for Pokemon {
     fn get_script_count(&self) -> Result<usize> {
         let mut c = 3;
-        if let Some(battle_data) = &self.battle_data.read().deref() {
+        if let Some(battle_data) = &self.data.battle_data.read().deref() {
             if let Some(battle) = battle_data.battle() {
                 c += battle
                     .sides()
@@ -819,19 +904,19 @@ impl ScriptSource for Pokemon {
     }
 
     fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
-        &self.script_source_data
+        &self.data.script_source_data
     }
 
     fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
-        scripts.push((&self.held_item_trigger_script).into());
+        scripts.push((&self.data.held_item_trigger_script).into());
-        scripts.push((&self.ability_script).into());
+        scripts.push((&self.data.ability_script).into());
-        scripts.push((&self.status_script).into());
+        scripts.push((&self.data.status_script).into());
-        scripts.push((&self.volatile).into());
+        scripts.push((&self.data.volatile).into());
     }
 
     fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) -> Result<()> {
         self.get_own_scripts(scripts);
-        if let Some(battle_data) = &self.battle_data.read().deref() {
+        if let Some(battle_data) = &self.data.battle_data.read().deref() {
             if let Some(battle) = battle_data.battle() {
                 battle
                     .sides()
@@ -845,17 +930,17 @@ impl ScriptSource for Pokemon {
 
 impl VolatileScriptsOwner for Pokemon {
     fn volatile_scripts(&self) -> &Arc<ScriptSet> {
-        &self.volatile
+        &self.data.volatile
     }
 
     fn load_volatile_script(&self, key: &StringKey) -> Result<Option<Arc<dyn Script>>> {
-        self.library.load_script(self.into(), ScriptCategory::Pokemon, key)
+        self.data.library.load_script(self.into(), ScriptCategory::Pokemon, key)
     }
 }
 
 impl ValueIdentifiable for Pokemon {
     fn value_identifier(&self) -> ValueIdentifier {
-        self.identifier
+        self.data.identifier
     }
 }
 
@@ -921,7 +1006,7 @@ pub mod test {
         });
 
         let mut static_lib = MockStaticData::new();
-        static_lib.expect_species().return_const(Box::new(species_lib));
+        static_lib.expect_species().return_const(Arc::new(species_lib));
 
         let mut growth_rate_lib = MockGrowthRateLibrary::new();
         growth_rate_lib
@@ -934,8 +1019,8 @@ pub mod test {
             Some(Arc::new(n))
         });
 
-        static_lib.expect_growth_rates().return_const(Box::new(growth_rate_lib));
+        static_lib.expect_growth_rates().return_const(Arc::new(growth_rate_lib));
-        static_lib.expect_natures().return_const(Box::new(nature_lib));
+        static_lib.expect_natures().return_const(Arc::new(nature_lib));
 
         let mut stat_calculator = MockBattleStatCalculator::new();
         stat_calculator.expect_calculate_flat_stats().returning(|_, _| Ok(()));
@@ -944,8 +1029,8 @@ pub mod test {
             .returning(|_, _| Ok(()));
 
         let mut lib = MockDynamicLibrary::new();
-        lib.expect_static_data().return_const(Box::new(static_lib));
+        lib.expect_static_data().return_const(Arc::new(static_lib));
-        lib.expect_stat_calculator().return_const(Box::new(stat_calculator));
+        lib.expect_stat_calculator().return_const(Arc::new(stat_calculator));
 
         Arc::new(lib)
     }

src/dynamic_data/models/pokemon_party.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
 use parking_lot::lock_api::RwLockReadGuard;
 use parking_lot::{RawRwLock, RwLock};
-use std::sync::Arc;
 
 use crate::dynamic_data::models::pokemon::Pokemon;
 use crate::{ValueIdentifiable, ValueIdentifier, VecExt};
@@ -12,7 +11,7 @@ pub struct PokemonParty {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// The underlying list of Pokemon.
-    pokemon: RwLock<Vec<Option<Arc<Pokemon>>>>,
+    pokemon: RwLock<Vec<Option<Pokemon>>>,
 }
 
 impl PokemonParty {
@@ -29,7 +28,7 @@ impl PokemonParty {
     }
 
     /// Instantiates a party with a list.
-    pub fn new_from_vec(pokemon: Vec<Option<Arc<Pokemon>>>) -> Self {
+    pub fn new_from_vec(pokemon: Vec<Option<Pokemon>>) -> Self {
         Self {
             identifier: Default::default(),
             pokemon: RwLock::new(pokemon),
@@ -37,7 +36,7 @@ impl PokemonParty {
     }
 
     /// Gets a Pokemon at an index in the party.
-    pub fn at(&self, index: usize) -> Option<Arc<Pokemon>> {
+    pub fn at(&self, index: usize) -> Option<Pokemon> {
         let read_lock = self.pokemon.read();
         let opt = read_lock.get(index);
         if let Some(v) = opt {
@@ -53,7 +52,7 @@ impl PokemonParty {
     }
 
     /// Sets the Pokemon at an index to a Pokemon, returning the old Pokemon.
-    pub fn swap_into(&self, index: usize, pokemon: Option<Arc<Pokemon>>) -> Result<Option<Arc<Pokemon>>> {
+    pub fn swap_into(&self, index: usize, pokemon: Option<Pokemon>) -> Result<Option<Pokemon>> {
         let mut party = self.pokemon.write();
         if index >= party.len() {
             return Ok(pokemon);
@@ -82,7 +81,7 @@ impl PokemonParty {
     }
 
     /// Gets the underlying list of Pokemon.
-    pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Arc<Pokemon>>>> {
+    pub fn pokemon(&self) -> RwLockReadGuard<'_, RawRwLock, Vec<Option<Pokemon>>> {
         self.pokemon.read()
     }
 
@@ -112,7 +111,7 @@ impl PokemonParty {
     /// Checks if the party contains a given pokemon.
     pub fn has_pokemon(&self, pokemon: &Pokemon) -> bool {
         for p in self.pokemon.read().iter().flatten() {
-            if std::ptr::eq(p.as_ref(), pokemon) {
+            if Pokemon::eq(p, pokemon) {
                 return true;
             }
         }

src/dynamic_data/script_handling/mod.rs

@@ -236,7 +236,7 @@ impl ScriptIterator {
                 }
             } else if let ScriptWrapper::Script(script) = wrapper {
                 if let Some(v) = script.upgrade() {
-                    if let Some(..) = v.read().as_ref() {
+                    if v.read().as_ref().is_some() {
                         return Ok(true);
                     }
                 }

src/dynamic_data/script_handling/script.rs

@@ -2,17 +2,17 @@ use anyhow::{anyhow, Result};
 use std::any::Any;
 use std::fmt::{Debug, Formatter};
 use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, AtomicPtr, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::thread::JoinHandle;
 
 use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard};
 
 use crate::dynamic_data::choices::TurnChoice;
-use crate::dynamic_data::ExecutingMove;
-use crate::dynamic_data::Pokemon;
 use crate::dynamic_data::{Battle, DynamicLibrary};
 use crate::dynamic_data::{BattleSide, DamageSource};
+use crate::dynamic_data::{ExecutingMove, WeakBattleReference, WeakPokemonReference};
+use crate::dynamic_data::{Pokemon, WeakBattleSideReference};
 use crate::static_data::{EffectParameter, TypeIdentifier};
 use crate::static_data::{Item, Statistic};
 use crate::StringKey;
@@ -69,77 +69,77 @@ pub trait Script: Send + Sync {
         Ok(())
     }
     /// This function is ran when this script starts being in effect.
-    fn on_initialize(&self, _library: &Arc<dyn DynamicLibrary>, _pars: Vec<EffectParameter>) -> Result<()> {
+    fn on_initialize(&self, _library: &Arc<dyn DynamicLibrary>, _pars: Vec<Arc<EffectParameter>>) -> Result<()> {
         Ok(())
     }
     /// This function is ran just before the start of the turn. Everyone has made its choices here,
     /// and the turn is about to start. This is a great place to initialize data if you need to know
     /// something has happened during a turn.
-    fn on_before_turn(&self, _choice: &TurnChoice) -> Result<()> {
+    fn on_before_turn(&self, _choice: &Arc<TurnChoice>) -> Result<()> {
         Ok(())
     }
     /// This function allows you to modify the effective speed of the Pokemon. This is ran before
     /// turn ordering, so overriding here will allow you to put certain Pokemon before others.
-    fn change_speed(&self, _choice: &TurnChoice, _speed: &mut u32) -> Result<()> {
+    fn change_speed(&self, _choice: &Arc<TurnChoice>, _speed: &mut u32) -> Result<()> {
         Ok(())
     }
     /// This function allows you to modify the effective priority of the Pokemon. This is ran before
     /// turn ordering, so overriding here will allow you to put certain Pokemon before others. Note
     /// that this is only relevant on move choices, as other turn choice types do not have a priority.
-    fn change_priority(&self, _choice: &TurnChoice, _priority: &mut i8) -> Result<()> {
+    fn change_priority(&self, _choice: &Arc<TurnChoice>, _priority: &mut i8) -> Result<()> {
         Ok(())
     }
 
     /// This function allows you to change the move that is used during execution. This is useful for
     /// moves such as metronome, where the move chosen actually differs from the move used.
-    fn change_move(&self, _choice: &TurnChoice, _move_name: &mut StringKey) -> Result<()> {
+    fn change_move(&self, _choice: &Arc<TurnChoice>, _move_name: &mut StringKey) -> Result<()> {
         Ok(())
     }
     /// This function allows you to change a move into a multi-hit move. The number of hits set here
     /// gets used as the number of hits. If set to 0, this will behave as if the move missed on its
     /// first hit.
-    fn change_number_of_hits(&self, _choice: &TurnChoice, _number_of_hits: &mut u8) -> Result<()> {
+    fn change_number_of_hits(&self, _choice: &Arc<TurnChoice>, _number_of_hits: &mut u8) -> Result<()> {
         Ok(())
     }
 
     /// This function allows you to prevent a move from running. If this gets set to true, the move
     /// ends execution here. No PP will be decreased in this case.
-    fn prevent_move(&self, _move: &ExecutingMove, _prevent: &mut bool) -> Result<()> {
+    fn prevent_move(&self, _move: &Arc<ExecutingMove>, _prevent: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function makes the move fail. If the fail field gets set to true, the move ends execution,
     /// and fail events get triggered.
-    fn fail_move(&self, _move: &ExecutingMove, _fail: &mut bool) -> Result<()> {
+    fn fail_move(&self, _move: &Arc<ExecutingMove>, _fail: &mut bool) -> Result<()> {
         Ok(())
     }
     /// Similar to [`Self::prevent_move`]. This function will also stop execution, but PP will be
     /// decreased.
-    fn stop_before_move(&self, _move: &ExecutingMove, _stop: &mut bool) -> Result<()> {
+    fn stop_before_move(&self, _move: &Arc<ExecutingMove>, _stop: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function runs just before the move starts its execution.
-    fn on_before_move(&self, _move: &ExecutingMove) -> Result<()> {
+    fn on_before_move(&self, _move: &Arc<ExecutingMove>) -> Result<()> {
         Ok(())
     }
     /// This function allows a script to prevent a move that is targeted at its owner. If set to true
     /// the move fails, and fail events get triggered.
-    fn fail_incoming_move(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>, _fail: &mut bool) -> Result<()> {
+    fn fail_incoming_move(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon, _fail: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function allows a script to make its owner invulnerable to an incoming move.
-    fn is_invulnerable(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>, _invulnerable: &mut bool) -> Result<()> {
+    fn is_invulnerable(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon, _invulnerable: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function occurs when a move gets missed. This runs on the scripts belonging to the executing
     /// move, which include the scripts that are attached to the owner of the script.
-    fn on_move_miss(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>) -> Result<()> {
+    fn on_move_miss(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon) -> Result<()> {
         Ok(())
     }
     /// This function allows the script to change the actual type that is used for the move on a target.
     fn change_move_type(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _move_type: &mut TypeIdentifier,
     ) -> Result<()> {
@@ -148,8 +148,8 @@ pub trait Script: Send + Sync {
     /// This function allows the script to change how effective a move is on a target.
     fn change_effectiveness(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _effectiveness: &mut f32,
     ) -> Result<()> {
@@ -158,8 +158,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to block an outgoing move from being critical.
     fn block_critical(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _block_critical: &mut bool,
     ) -> Result<()> {
@@ -168,8 +168,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to block an incoming move from being critical.
     fn block_incoming_critical(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _block_critical: &mut bool,
     ) -> Result<()> {
@@ -179,8 +179,8 @@ pub trait Script: Send + Sync {
     /// the percentage accuracy, so anything above 100% will make it always hit.
     fn change_accuracy(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _accuracy: &mut u8,
     ) -> Result<()> {
@@ -190,8 +190,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to change the critical stage of the move used.
     fn change_critical_stage(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _stage: &mut u8,
     ) -> Result<()> {
@@ -201,8 +201,8 @@ pub trait Script: Send + Sync {
     /// run when a hit is critical.
     fn change_critical_modifier(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _modifier: &mut f32,
     ) -> Result<()> {
@@ -212,8 +212,8 @@ pub trait Script: Send + Sync {
     /// occurs when the user has the move type as one of its own types.
     fn change_stab_modifier(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _modifier: &mut f32,
     ) -> Result<()> {
@@ -223,8 +223,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to change the effective base power of a move hit.
     fn change_base_power(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _base_power: &mut u8,
     ) -> Result<()> {
@@ -233,8 +233,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to bypass defensive stat boosts for a move hit.
     fn bypass_defensive_stat_boost(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _bypass: &mut bool,
     ) -> Result<()> {
@@ -243,8 +243,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to bypass offensive stat boosts for a move hit.
     fn bypass_offensive_stat_boost(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _bypass: &mut bool,
     ) -> Result<()> {
@@ -253,8 +253,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to change the actual offensive stat values used when calculating damage
     fn change_offensive_stat_value(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _amount: &mut u32,
     ) -> Result<()> {
@@ -263,8 +263,8 @@ pub trait Script: Send + Sync {
     /// This function allows a script to change the actual defensive stat values used when calculating damage.
     fn change_defensive_stat_value(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _amount: &mut u32,
     ) -> Result<()> {
@@ -275,8 +275,8 @@ pub trait Script: Send + Sync {
     /// defender and attacker.
     fn change_damage_stat_modifier(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _modifier: &mut f32,
     ) -> Result<()> {
@@ -285,22 +285,22 @@ pub trait Script: Send + Sync {
     /// This function allows a script to apply a raw multiplier to the damage done by a move.
     fn change_damage_modifier(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _modifier: &mut f32,
     ) -> Result<()> {
         Ok(())
     }
     /// This function allows a script to modify the outgoing damage done by a move.
-    fn change_damage(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>, _hit: u8, _damage: &mut u32) -> Result<()> {
+    fn change_damage(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon, _hit: u8, _damage: &mut u32) -> Result<()> {
         Ok(())
     }
     /// This function allows a script to modify the incoming damage done by a move.
     fn change_incoming_damage(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _damage: &mut u32,
     ) -> Result<()> {
@@ -308,11 +308,11 @@ pub trait Script: Send + Sync {
     }
     /// This function triggers when an incoming hit happens. This triggers after the damage is done,
     /// but before the secondary effect of the move happens.
-    fn on_incoming_hit(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>, _hit: u8) -> Result<()> {
+    fn on_incoming_hit(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon, _hit: u8) -> Result<()> {
         Ok(())
     }
     /// This function triggers when an opponent on the field faints.
-    fn on_opponent_faints(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>, _hit: u8) -> Result<()> {
+    fn on_opponent_faints(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon, _hit: u8) -> Result<()> {
         Ok(())
     }
     /// This function allows a script attached to a Pokemon or its parents to prevent stat boost
@@ -344,8 +344,8 @@ pub trait Script: Send + Sync {
     /// secondary effect. Note that this function is not called for status moves.
     fn prevent_secondary_effect(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _prevent: &mut bool,
     ) -> Result<()> {
@@ -357,8 +357,8 @@ pub trait Script: Send + Sync {
     /// below 0 will make it never hit.
     fn change_effect_chance(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _chance: &mut f32,
     ) -> Result<()> {
@@ -370,8 +370,8 @@ pub trait Script: Send + Sync {
     /// or below 0 will make it never hit.
     fn change_incoming_effect_chance(
         &self,
-        _move: &ExecutingMove,
+        _move: &Arc<ExecutingMove>,
-        _target: &Arc<Pokemon>,
+        _target: &Pokemon,
         _hit: u8,
         _chance: &mut f32,
     ) -> Result<()> {
@@ -380,19 +380,19 @@ pub trait Script: Send + Sync {
     /// This function triggers when the move uses its secondary effect. Moves should implement their
     /// secondary effects here. Status moves should implement their actual functionality in this
     /// function as well, as status moves effects are defined as secondary effects for simplicity.
-    fn on_secondary_effect(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>, _hit: u8) -> Result<()> {
+    fn on_secondary_effect(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon, _hit: u8) -> Result<()> {
         Ok(())
     }
     /// This function triggers on a move or its parents when all hits on a target are finished.
-    fn on_after_hits(&self, _move: &ExecutingMove, _target: &Arc<Pokemon>) -> Result<()> {
+    fn on_after_hits(&self, _move: &Arc<ExecutingMove>, _target: &Pokemon) -> Result<()> {
         Ok(())
     }
     /// This function prevents the Pokemon it is attached to from being able to switch out.
-    fn prevent_self_switch(&self, _choice: &TurnChoice, _prevent: &mut bool) -> Result<()> {
+    fn prevent_self_switch(&self, _choice: &Arc<TurnChoice>, _prevent: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function allows the prevention of switching for any opponent.
-    fn prevent_opponent_switch(&self, _choice: &TurnChoice, _prevent: &mut bool) -> Result<()> {
+    fn prevent_opponent_switch(&self, _choice: &Arc<TurnChoice>, _prevent: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function is called on a move and its parents when the move fails.
@@ -404,11 +404,11 @@ pub trait Script: Send + Sync {
         Ok(())
     }
     /// This function allows preventing the running away of the Pokemon its attached to
-    fn prevent_self_run_away(&self, _choice: &TurnChoice, _prevent: &mut bool) -> Result<()> {
+    fn prevent_self_run_away(&self, _choice: &Arc<TurnChoice>, _prevent: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function prevents a Pokemon on another side than where its attached to from running away.
-    fn prevent_opponent_run_away(&self, _choice: &TurnChoice, _prevent: &mut bool) -> Result<()> {
+    fn prevent_opponent_run_away(&self, _choice: &Arc<TurnChoice>, _prevent: &mut bool) -> Result<()> {
         Ok(())
     }
     /// This function id triggered on all scripts active in the battle after all choices have finished
@@ -432,7 +432,7 @@ pub trait Script: Send + Sync {
     }
     /// This function is triggered on a Pokemon and its parents when the given Pokemon consumes the
     /// held item it had.
-    fn on_after_held_item_consume(&self, _pokemon: &Pokemon, _item: &dyn Item) -> Result<()> {
+    fn on_after_held_item_consume(&self, _pokemon: &Pokemon, _item: &Arc<dyn Item>) -> Result<()> {
         Ok(())
     }
     /// This function is triggered on a Pokemon and its parents when the given Pokemon gains experience,
@@ -458,7 +458,12 @@ pub trait Script: Send + Sync {
     /// This function is called when a Pokeball is thrown at a Pokemon, and allows modifying the catch
     /// rate of this attempt. Pokeball modifier effects should be implemented here, as well as for
     /// example status effects that change capture rates.
-    fn change_capture_rate_bonus(&self, _target: &Pokemon, _pokeball: &dyn Item, _modifier: &mut u8) -> Result<()> {
+    fn change_capture_rate_bonus(
+        &self,
+        _target: &Pokemon,
+        _pokeball: &Arc<dyn Item>,
+        _modifier: &mut u8,
+    ) -> Result<()> {
         Ok(())
     }
 
@@ -778,29 +783,29 @@ mod tests {
 /// Data to store references to their owning objects on scripts.
 pub enum ScriptOwnerData {
     /// A script attached to a Pokemon has a reference to that Pokemon.
-    Pokemon(AtomicPtr<Pokemon>),
+    Pokemon(WeakPokemonReference),
     /// A script attached to a Battle Side has a reference to that Battle Side.
-    BattleSide(AtomicPtr<BattleSide>),
+    BattleSide(WeakBattleSideReference),
     /// A script attached to a Battle has a reference to that Battle.
-    Battle(AtomicPtr<Battle>),
+    Battle(WeakBattleReference),
     /// A script also can have no owner.
     None,
 }
 
 impl From<&Pokemon> for ScriptOwnerData {
     fn from(p: &Pokemon) -> Self {
-        ScriptOwnerData::Pokemon(AtomicPtr::new(p as *const Pokemon as *mut Pokemon))
+        ScriptOwnerData::Pokemon(p.weak())
     }
 }
 
 impl From<&BattleSide> for ScriptOwnerData {
     fn from(p: &BattleSide) -> Self {
-        ScriptOwnerData::BattleSide(AtomicPtr::new(p as *const BattleSide as *mut BattleSide))
+        ScriptOwnerData::BattleSide(p.weak())
     }
 }
 
 impl From<&Battle> for ScriptOwnerData {
     fn from(p: &Battle) -> Self {
-        ScriptOwnerData::Battle(AtomicPtr::new(p as *const Battle as *mut Battle))
+        ScriptOwnerData::Battle(p.weak())
     }
 }

src/ffi/dynamic_data/choices.rs

@@ -12,7 +12,7 @@ extern "C" fn turn_choice_drop(choice: OwnedPtr<TurnChoice>) {
 
 /// Get the user of the given choice.
 #[no_mangle]
-extern "C" fn turn_choice_user(choice: ExternPointer<TurnChoice>) -> IdentifiablePointer<Arc<Pokemon>> {
+extern "C" fn turn_choice_user(choice: ExternPointer<TurnChoice>) -> IdentifiablePointer<Pokemon> {
     choice.as_ref().user().clone().into()
 }
 
@@ -40,7 +40,7 @@ extern "C" fn turn_choice_fail(choice: ExternPointer<TurnChoice>) {
 /// Creates a new Turn Choice with a move to use.
 #[no_mangle]
 extern "C" fn turn_choice_move_new(
-    user: ExternPointer<Arc<Pokemon>>,
+    user: ExternPointer<Pokemon>,
     learned_move: ExternPointer<Arc<LearnedMove>>,
     target_side: u8,
     target_index: u8,
@@ -94,12 +94,12 @@ extern "C" fn turn_choice_move_priority(choice: ExternPointer<TurnChoice>) -> Na
 
 /// Creates a new Turn Choice for the user to flee.
 #[no_mangle]
-extern "C" fn turn_choice_flee_new(user: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<TurnChoice> {
+extern "C" fn turn_choice_flee_new(user: ExternPointer<Pokemon>) -> IdentifiablePointer<TurnChoice> {
     Box::new(TurnChoice::Flee(FleeChoice::new(user.as_ref().clone()))).into()
 }
 
 /// Creates a new Turn Choice for the user to pass the turn.
 #[no_mangle]
-extern "C" fn turn_choice_pass_new(user: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<TurnChoice> {
+extern "C" fn turn_choice_pass_new(user: ExternPointer<Pokemon>) -> IdentifiablePointer<TurnChoice> {
     Box::new(TurnChoice::Pass(PassChoice::new(user.as_ref().clone()))).into()
 }

src/ffi/dynamic_data/libraries/battle_stat_calculator.rs

@@ -2,7 +2,6 @@ use crate::dynamic_data::{BattleStatCalculator, Gen7BattleStatCalculator, Pokemo
 use crate::ffi::{ExternPointer, IdentifiablePointer, NativeResult, OwnedPtr};
 use crate::static_data::{Statistic, StatisticSet};
 use std::ptr::drop_in_place;
-use std::sync::Arc;
 
 /// Creates a new Gen 7 battle stat calculator
 #[no_mangle]
@@ -23,7 +22,7 @@ extern "C" fn battle_stat_calculator_drop(ptr: OwnedPtr<Box<dyn BattleStatCalcul
 #[no_mangle]
 extern "C" fn battle_stat_calculator_calculate_flat_stats(
     ptr: ExternPointer<Box<dyn BattleStatCalculator>>,
-    pokemon: ExternPointer<Arc<Pokemon>>,
+    pokemon: ExternPointer<Pokemon>,
     mut stats: ExternPointer<Box<StatisticSet<u32>>>,
 ) -> NativeResult<()> {
     ptr.as_ref()
@@ -35,7 +34,7 @@ extern "C" fn battle_stat_calculator_calculate_flat_stats(
 #[no_mangle]
 extern "C" fn battle_stat_calculator_calculate_flat_stat(
     ptr: ExternPointer<Box<dyn BattleStatCalculator>>,
-    pokemon: ExternPointer<Arc<Pokemon>>,
+    pokemon: ExternPointer<Pokemon>,
     stat: Statistic,
 ) -> NativeResult<u32> {
     ptr.as_ref().calculate_flat_stat(pokemon.as_ref(), stat).into()
@@ -45,7 +44,7 @@ extern "C" fn battle_stat_calculator_calculate_flat_stat(
 #[no_mangle]
 extern "C" fn battle_stat_calculator_calculate_boosted_stats(
     ptr: ExternPointer<Box<dyn BattleStatCalculator>>,
-    pokemon: ExternPointer<Arc<Pokemon>>,
+    pokemon: ExternPointer<Pokemon>,
     mut stats: ExternPointer<Box<StatisticSet<u32>>>,
 ) -> NativeResult<()> {
     ptr.as_ref()
@@ -57,7 +56,7 @@ extern "C" fn battle_stat_calculator_calculate_boosted_stats(
 #[no_mangle]
 extern "C" fn battle_stat_calculator_calculate_boosted_stat(
     ptr: ExternPointer<Box<dyn BattleStatCalculator>>,
-    pokemon: ExternPointer<Arc<Pokemon>>,
+    pokemon: ExternPointer<Pokemon>,
     stat: Statistic,
 ) -> NativeResult<u32> {
     ptr.as_ref().calculate_boosted_stat(pokemon.as_ref(), stat).into()

src/ffi/dynamic_data/libraries/dynamic_library.rs

@@ -9,18 +9,18 @@ use std::sync::Arc;
 /// Instantiates a new DynamicLibrary with given parameters.
 #[no_mangle]
 extern "C" fn dynamic_library_new(
-    static_data: OwnedPtr<Box<dyn StaticData>>,
+    static_data: OwnedPtr<Arc<dyn StaticData>>,
-    stat_calculator: OwnedPtr<Box<dyn BattleStatCalculator>>,
+    stat_calculator: OwnedPtr<Arc<dyn BattleStatCalculator>>,
-    damage_library: OwnedPtr<Box<dyn DamageLibrary>>,
+    damage_library: OwnedPtr<Arc<dyn DamageLibrary>>,
-    misc_library: OwnedPtr<Box<dyn MiscLibrary>>,
+    misc_library: OwnedPtr<Arc<dyn MiscLibrary>>,
     script_resolver: OwnedPtr<Box<dyn ScriptResolver>>,
 ) -> IdentifiablePointer<Arc<dyn DynamicLibrary>> {
     unsafe {
         let a: Arc<dyn DynamicLibrary> = Arc::new(DynamicLibraryImpl::new(
-            *Box::from_raw(static_data),
+            static_data.read(),
-            *Box::from_raw(stat_calculator),
+            stat_calculator.read(),
-            *Box::from_raw(damage_library),
+            damage_library.read(),
-            *Box::from_raw(misc_library),
+            misc_library.read(),
             *Box::from_raw(script_resolver),
         ));
         a.into()
@@ -37,8 +37,8 @@ extern "C" fn dynamic_library_drop(ptr: OwnedPtr<Arc<dyn DynamicLibrary>>) {
 #[no_mangle]
 extern "C" fn dynamic_library_get_static_data(
     ptr: ExternPointer<Arc<dyn DynamicLibrary>>,
-) -> IdentifiablePointer<Box<dyn StaticData>> {
+) -> IdentifiablePointer<Arc<dyn StaticData>> {
-    ptr.as_ref().static_data().into()
+    ptr.as_ref().static_data().clone().into()
 }
 
 /// The stat calculator deals with the calculation of flat and boosted stats, based on the
@@ -46,16 +46,16 @@ extern "C" fn dynamic_library_get_static_data(
 #[no_mangle]
 extern "C" fn dynamic_library_get_stat_calculator(
     ptr: ExternPointer<Arc<dyn DynamicLibrary>>,
-) -> IdentifiablePointer<Box<dyn BattleStatCalculator>> {
+) -> IdentifiablePointer<Arc<dyn BattleStatCalculator>> {
-    ptr.as_ref().stat_calculator().into()
+    ptr.as_ref().stat_calculator().clone().into()
 }
 
 /// The damage calculator deals with the calculation of things relating to damage.
 #[no_mangle]
 extern "C" fn dynamic_library_get_damage_calculator(
     ptr: ExternPointer<Arc<dyn DynamicLibrary>>,
-) -> IdentifiablePointer<Box<dyn DamageLibrary>> {
+) -> IdentifiablePointer<Arc<dyn DamageLibrary>> {
-    ptr.as_ref().damage_calculator().into()
+    ptr.as_ref().damage_calculator().clone().into()
 }
 
 /// The Misc Library holds minor functions that do not fall in any of the other libraries and
@@ -63,6 +63,6 @@ extern "C" fn dynamic_library_get_damage_calculator(
 #[no_mangle]
 extern "C" fn dynamic_library_get_misc_library(
     ptr: ExternPointer<Arc<dyn DynamicLibrary>>,
-) -> IdentifiablePointer<Box<dyn MiscLibrary>> {
+) -> IdentifiablePointer<Arc<dyn MiscLibrary>> {
-    ptr.as_ref().misc_library().into()
+    ptr.as_ref().misc_library().clone().into()
 }

src/ffi/dynamic_data/models/battle.rs

@@ -11,7 +11,7 @@ use std::sync::Arc;
 #[no_mangle]
 extern "C" fn battle_new(
     library: ExternPointer<Arc<dyn DynamicLibrary>>,
-    parties: *const OwnedPtr<BattleParty>,
+    parties: *const OwnedPtr<Arc<BattleParty>>,
     parties_length: usize,
     can_flee: u8,
     number_of_sides: u8,
@@ -19,7 +19,7 @@ extern "C" fn battle_new(
     // NOTE: Split into two due to u128 not being ABI safe: https://github.com/rust-lang/rust/issues/54341
     random_seed_1: u64,
     random_seed_2: u64,
-) -> IdentifiablePointer<Arc<Battle>> {
+) -> IdentifiablePointer<Battle> {
     let parties = unsafe {
         std::slice::from_raw_parts(parties, parties_length)
             .iter()
@@ -59,9 +59,12 @@ extern "C" fn battle_parties_length(ptr: ExternPointer<Arc<Battle>>) -> usize {
 
 /// Get a party in the battle.
 #[no_mangle]
-extern "C" fn battle_parties_get(ptr: ExternPointer<Arc<Battle>>, index: usize) -> IdentifiablePointer<BattleParty> {
+extern "C" fn battle_parties_get(
+    ptr: ExternPointer<Arc<Battle>>,
+    index: usize,
+) -> IdentifiablePointer<Arc<BattleParty>> {
     if let Some(v) = ptr.as_ref().parties().get(index) {
-        (v as *const BattleParty).into()
+        v.clone().into()
     } else {
         IdentifiablePointer::none()
     }
@@ -103,8 +106,8 @@ extern "C" fn battle_sides_get(ptr: ExternPointer<Arc<Battle>>, index: usize) ->
 
 /// The RNG used for the battle.
 #[no_mangle]
-extern "C" fn battle_random(ptr: ExternPointer<Arc<Battle>>) -> IdentifiablePointer<BattleRandom> {
+extern "C" fn battle_random(ptr: ExternPointer<Arc<Battle>>) -> IdentifiablePointer<Arc<BattleRandom>> {
-    (ptr.as_ref().random() as *const BattleRandom).into()
+    ptr.as_ref().random().clone().into()
 }
 
 /// Whether or not the battle has ended.
@@ -150,11 +153,7 @@ extern "C" fn battle_last_turn_time(ptr: ExternPointer<Arc<Battle>>) -> u64 {
 
 /// Get a Pokemon on the battlefield, on a specific side and an index on that side.
 #[no_mangle]
-extern "C" fn battle_get_pokemon(
+extern "C" fn battle_get_pokemon(ptr: ExternPointer<Arc<Battle>>, side: u8, index: u8) -> IdentifiablePointer<Pokemon> {
-    ptr: ExternPointer<Arc<Battle>>,
-    side: u8,
-    index: u8,
-) -> IdentifiablePointer<Arc<Pokemon>> {
     if let Some(v) = ptr.as_ref().get_pokemon(side, index) {
         v.into()
     } else {

src/ffi/dynamic_data/models/battle_party.rs

@@ -58,7 +58,7 @@ extern "C" fn battle_party_has_pokemon_not_in_field(ptr: ExternPointer<Arc<Battl
 extern "C" fn battle_party_get_pokemon(
     ptr: ExternPointer<Arc<BattleParty>>,
     index: usize,
-) -> IdentifiablePointer<Arc<Pokemon>> {
+) -> IdentifiablePointer<Pokemon> {
     if let Some(v) = ptr.as_ref().get_pokemon(index) {
         v.into()
     } else {

src/ffi/dynamic_data/models/event.rs

@@ -1,6 +1,5 @@
 use crate::dynamic_data::{Event, Pokemon};
 use crate::ffi::{ExternPointer, IdentifiablePointer};
-use std::sync::Arc;
 
 /// The kind of the event.
 #[no_mangle]
@@ -67,7 +66,7 @@ event_ffi!(
         /// The index of the Pokemon that got switched in/out on its side
         index: u8,
         /// The new Pokemon that will be on the spot. If none, the spot will be null.
-        pokemon: IdentifiablePointer<Arc<Pokemon>>,
+        pokemon: IdentifiablePointer<Pokemon>,
     },
     {
         return SwitchData{

src/ffi/dynamic_data/models/learned_move.rs

@@ -61,5 +61,6 @@ extern "C" fn learned_move_restore_all_uses(learned_move: ExternPointer<Arc<Lear
 /// Restore the remaining PP by a certain amount. Will prevent it from going above max PP.
 #[no_mangle]
 extern "C" fn learned_move_restore_uses(learned_move: ExternPointer<Arc<LearnedMove>>, amount: u8) -> NativeResult<()> {
-    learned_move.as_ref().restore_uses(amount).into()
+    learned_move.as_ref().restore_uses(amount);
+    NativeResult::ok(())
 }

src/ffi/dynamic_data/models/pokemon.rs

@@ -22,7 +22,7 @@ extern "C" fn pokemon_new(
     gender: Gender,
     coloring: u8,
     nature: *const c_char,
-) -> NativeResult<IdentifiablePointer<Arc<Pokemon>>> {
+) -> NativeResult<IdentifiablePointer<Pokemon>> {
     let nature = unsafe { CStr::from_ptr(nature) }.into();
     let pokemon = Pokemon::new(
         library.as_ref().clone(),
@@ -39,44 +39,44 @@ extern "C" fn pokemon_new(
         &nature,
     );
     match pokemon {
-        Ok(pokemon) => NativeResult::ok(Arc::new(pokemon).into()),
+        Ok(pokemon) => NativeResult::ok(pokemon.into()),
         Err(err) => NativeResult::err(err),
     }
 }
 
 /// Drops an Arc reference held by the FFI.
 #[no_mangle]
-unsafe extern "C" fn pokemon_drop(ptr: OwnedPtr<Arc<Pokemon>>) {
+unsafe extern "C" fn pokemon_drop(ptr: OwnedPtr<Pokemon>) {
     drop_in_place(ptr);
 }
 
 /// The library data of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_library(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn DynamicLibrary>> {
+extern "C" fn pokemon_library(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn DynamicLibrary>> {
     ptr.as_ref().library().clone().into()
 }
 
 /// The species of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_species(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Species>> {
+extern "C" fn pokemon_species(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Species>> {
     ptr.as_ref().species().into()
 }
 
 /// The form of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_form(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Form>> {
+extern "C" fn pokemon_form(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Form>> {
     ptr.as_ref().form().into()
 }
 
 /// The species that should be displayed to the user. This handles stuff like the Illusion ability.
 #[no_mangle]
-extern "C" fn pokemon_display_species(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Species>> {
+extern "C" fn pokemon_display_species(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Species>> {
     ptr.as_ref().display_species().into()
 }
 
 /// The form that should be displayed to the user. This handles stuff like the Illusion ability.
 #[no_mangle]
-extern "C" fn pokemon_display_form(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Form>> {
+extern "C" fn pokemon_display_form(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Form>> {
     ptr.as_ref().display_form().into()
 }
 
@@ -88,7 +88,7 @@ ffi_arc_getter!(Pokemon, coloring, u8);
 
 /// Gets the held item of a Pokemon
 #[no_mangle]
-extern "C" fn pokemon_held_item(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Item>> {
+extern "C" fn pokemon_held_item(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Item>> {
     if let Some(v) = ptr.as_ref().held_item().read().as_ref() {
         v.clone().into()
     } else {
@@ -98,7 +98,7 @@ extern "C" fn pokemon_held_item(ptr: ExternPointer<Arc<Pokemon>>) -> Identifiabl
 
 /// Checks whether the Pokemon is holding a specific item.
 #[no_mangle]
-extern "C" fn pokemon_has_held_item(ptr: ExternPointer<Arc<Pokemon>>, name: *const c_char) -> u8 {
+extern "C" fn pokemon_has_held_item(ptr: ExternPointer<Pokemon>, name: *const c_char) -> u8 {
     let name = unsafe { CStr::from_ptr(name) }.into();
     u8::from(ptr.as_ref().has_held_item(&name))
 }
@@ -106,7 +106,7 @@ extern "C" fn pokemon_has_held_item(ptr: ExternPointer<Arc<Pokemon>>, name: *con
 /// Changes the held item of the Pokemon. Returns the previously held item.
 #[no_mangle]
 extern "C" fn pokemon_set_held_item(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
     item: ExternPointer<Arc<dyn Item>>,
 ) -> IdentifiablePointer<Arc<dyn Item>> {
     if let Some(v) = ptr.as_ref().set_held_item(item.as_ref()) {
@@ -118,7 +118,7 @@ extern "C" fn pokemon_set_held_item(
 
 /// Removes the held item from the Pokemon. Returns the previously held item.
 #[no_mangle]
-extern "C" fn pokemon_remove_held_item(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Item>> {
+extern "C" fn pokemon_remove_held_item(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Item>> {
     if let Some(v) = ptr.as_ref().remove_held_item() {
         v.into()
     } else {
@@ -128,7 +128,7 @@ extern "C" fn pokemon_remove_held_item(ptr: ExternPointer<Arc<Pokemon>>) -> Iden
 
 /// Makes the Pokemon uses its held item.
 #[no_mangle]
-extern "C" fn pokemon_consume_held_item(ptr: ExternPointer<Arc<Pokemon>>) -> NativeResult<u8> {
+extern "C" fn pokemon_consume_held_item(ptr: ExternPointer<Pokemon>) -> NativeResult<u8> {
     match ptr.as_ref().consume_held_item() {
         Ok(v) => NativeResult::ok(u8::from(v)),
         Err(err) => NativeResult::err(err),
@@ -142,7 +142,7 @@ ffi_arc_getter!(Pokemon, height, f32);
 
 /// An optional nickname of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_nickname(ptr: ExternPointer<Arc<Pokemon>>) -> NativeResult<*mut c_char> {
+extern "C" fn pokemon_nickname(ptr: ExternPointer<Pokemon>) -> NativeResult<*mut c_char> {
     let name = ptr.as_ref().nickname();
     if let Some(v) = name {
         match CString::new(v.as_str()) {
@@ -156,13 +156,13 @@ extern "C" fn pokemon_nickname(ptr: ExternPointer<Arc<Pokemon>>) -> NativeResult
 
 /// Whether the actual ability on the form is a hidden ability.
 #[no_mangle]
-extern "C" fn pokemon_real_ability_is_hidden(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_real_ability_is_hidden(ptr: ExternPointer<Pokemon>) -> u8 {
     u8::from(ptr.as_ref().real_ability().hidden)
 }
 
 /// The index of the actual ability on the form.
 #[no_mangle]
-extern "C" fn pokemon_real_ability_index(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_real_ability_index(ptr: ExternPointer<Pokemon>) -> u8 {
     ptr.as_ref().real_ability().index
 }
 
@@ -172,7 +172,7 @@ ffi_vec_value_getters!(Pokemon, Pokemon, types, TypeIdentifier);
 /// a null pointer otherwise.
 #[no_mangle]
 extern "C" fn pokemon_learned_move_get(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
     index: usize,
 ) -> IdentifiablePointer<Arc<LearnedMove>> {
     if let Some(Some(v)) = ptr.as_ref().learned_moves().read().get(index) {
@@ -184,26 +184,26 @@ extern "C" fn pokemon_learned_move_get(
 
 /// The stats of the Pokemon when disregarding any stat boosts.
 #[no_mangle]
-extern "C" fn pokemon_flat_stats(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<StatisticSet<u32>> {
+extern "C" fn pokemon_flat_stats(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<StatisticSet<u32>>> {
-    (ptr.as_ref().flat_stats() as *const StatisticSet<u32>).into()
+    ptr.as_ref().flat_stats().clone().into()
 }
 
 /// The stats of the Pokemon including the stat boosts.
 #[no_mangle]
-extern "C" fn pokemon_boosted_stats(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<StatisticSet<u32>> {
+extern "C" fn pokemon_boosted_stats(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<StatisticSet<u32>>> {
-    (ptr.as_ref().boosted_stats() as *const StatisticSet<u32>).into()
+    ptr.as_ref().boosted_stats().clone().into()
 }
 
 /// Get the stat boosts for a specific stat.
 #[no_mangle]
-extern "C" fn pokemon_get_stat_boost(ptr: ExternPointer<Arc<Pokemon>>, statistic: Statistic) -> i8 {
+extern "C" fn pokemon_get_stat_boost(ptr: ExternPointer<Pokemon>, statistic: Statistic) -> i8 {
     ptr.as_ref().stat_boost(statistic)
 }
 
 /// Change a boosted stat by a certain amount.
 #[no_mangle]
 extern "C" fn pokemon_change_stat_boost(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
     stat: Statistic,
     diff_amount: i8,
     self_inflicted: u8,
@@ -216,14 +216,14 @@ extern "C" fn pokemon_change_stat_boost(
 
 /// Gets a [individual value](https://bulbapedia.bulbagarden.net/wiki/Individual_values) of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_get_individual_value(ptr: ExternPointer<Arc<Pokemon>>, stat: Statistic) -> u8 {
+extern "C" fn pokemon_get_individual_value(ptr: ExternPointer<Pokemon>, stat: Statistic) -> u8 {
     ptr.as_ref().individual_values().get_stat(stat)
 }
 
 /// Modifies a [individual value](https://bulbapedia.bulbagarden.net/wiki/Individual_values) of the Pokemon.
 #[no_mangle]
 extern "C" fn pokemon_set_individual_value(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
     stat: Statistic,
     value: u8,
 ) -> NativeResult<()> {
@@ -233,17 +233,13 @@ extern "C" fn pokemon_set_individual_value(
 
 /// Gets a [effort value](https://bulbapedia.bulbagarden.net/wiki/Effort_values) of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_get_effort_value(ptr: ExternPointer<Arc<Pokemon>>, stat: Statistic) -> u8 {
+extern "C" fn pokemon_get_effort_value(ptr: ExternPointer<Pokemon>, stat: Statistic) -> u8 {
     ptr.as_ref().effort_values().get_stat(stat)
 }
 
 /// Modifies a [effort value](https://bulbapedia.bulbagarden.net/wiki/Effort_values) of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_set_effort_value(
+extern "C" fn pokemon_set_effort_value(ptr: ExternPointer<Pokemon>, stat: Statistic, value: u8) -> NativeResult<()> {
-    ptr: ExternPointer<Arc<Pokemon>>,
-    stat: Statistic,
-    value: u8,
-) -> NativeResult<()> {
     ptr.as_ref().effort_values().set_stat(stat, value);
     ptr.as_ref().recalculate_flat_stats().into()
 }
@@ -251,7 +247,7 @@ extern "C" fn pokemon_set_effort_value(
 /// Gets the data for the battle the Pokemon is currently in. If the Pokemon is not in a battle, this
 /// returns null.
 #[no_mangle]
-extern "C" fn pokemon_get_battle(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<Battle>> {
+extern "C" fn pokemon_get_battle(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Battle> {
     if let Some(v) = ptr.as_ref().get_battle() {
         v.into()
     } else {
@@ -262,27 +258,27 @@ extern "C" fn pokemon_get_battle(ptr: ExternPointer<Arc<Pokemon>>) -> Identifiab
 /// Get the index of the side of the battle the Pokemon is in. If the Pokemon
 /// is not on the battlefield, this always returns 0.
 #[no_mangle]
-extern "C" fn pokemon_get_battle_side_index(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_get_battle_side_index(ptr: ExternPointer<Pokemon>) -> u8 {
     ptr.as_ref().get_battle_side_index().unwrap_or_default()
 }
 
 /// Get the index of the slot on the side of the battle the Pokemon is in. If the Pokemon
 /// is not on the battlefield, this always returns 0.
 #[no_mangle]
-extern "C" fn pokemon_get_battle_index(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_get_battle_index(ptr: ExternPointer<Pokemon>) -> u8 {
     ptr.as_ref().get_battle_index().unwrap_or_default()
 }
 
 /// Returns whether something overrides the ability.
 #[no_mangle]
-extern "C" fn pokemon_is_ability_overriden(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_is_ability_overriden(ptr: ExternPointer<Pokemon>) -> u8 {
     u8::from(ptr.as_ref().is_ability_overriden())
 }
 
 /// Returns the currently active ability.
 #[no_mangle]
 extern "C" fn pokemon_active_ability(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
 ) -> NativeResult<IdentifiablePointer<Arc<dyn Ability>>> {
     match ptr.as_ref().active_ability() {
         Ok(v) => NativeResult::ok(v.clone().into()),
@@ -292,13 +288,13 @@ extern "C" fn pokemon_active_ability(
 
 /// Whether or not the Pokemon is allowed to gain experience.
 #[no_mangle]
-extern "C" fn pokemon_allowed_experience_gain(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_allowed_experience_gain(ptr: ExternPointer<Pokemon>) -> u8 {
     u8::from(ptr.as_ref().allowed_experience_gain())
 }
 
 /// The [nature](https://bulbapedia.bulbagarden.net/wiki/Nature) of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_nature(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePointer<Arc<dyn Nature>> {
+extern "C" fn pokemon_nature(ptr: ExternPointer<Pokemon>) -> IdentifiablePointer<Arc<dyn Nature>> {
     ptr.as_ref().nature().clone().into()
 }
 
@@ -306,20 +302,20 @@ extern "C" fn pokemon_nature(ptr: ExternPointer<Arc<Pokemon>>) -> IdentifiablePo
 /// stats, level, nature, IV, or EV changes. This has a side effect of recalculating the boosted
 /// stats, as those depend on the flat stats.
 #[no_mangle]
-extern "C" fn pokemon_recalculate_flat_stats(ptr: ExternPointer<Arc<Pokemon>>) -> NativeResult<()> {
+extern "C" fn pokemon_recalculate_flat_stats(ptr: ExternPointer<Pokemon>) -> NativeResult<()> {
     ptr.as_ref().recalculate_flat_stats().into()
 }
 
 /// Calculates the boosted stats on the Pokemon. This should be called when a stat boost changes.
 #[no_mangle]
-extern "C" fn pokemon_recalculate_boosted_stats(ptr: ExternPointer<Arc<Pokemon>>) -> NativeResult<()> {
+extern "C" fn pokemon_recalculate_boosted_stats(ptr: ExternPointer<Pokemon>) -> NativeResult<()> {
     ptr.as_ref().recalculate_boosted_stats().into()
 }
 
 /// Change the species of the Pokemon.
 #[no_mangle]
 extern "C" fn pokemon_change_species(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
     species: ExternPointer<Arc<dyn Species>>,
     form: ExternPointer<Arc<dyn Form>>,
 ) -> NativeResult<()> {
@@ -330,48 +326,45 @@ extern "C" fn pokemon_change_species(
 
 /// Change the form of the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_change_form(
+extern "C" fn pokemon_change_form(ptr: ExternPointer<Pokemon>, form: ExternPointer<Arc<dyn Form>>) -> NativeResult<()> {
-    ptr: ExternPointer<Arc<Pokemon>>,
-    form: ExternPointer<Arc<dyn Form>>,
-) -> NativeResult<()> {
     ptr.as_ref().change_form(form.as_ref()).into()
 }
 
 /// Whether or not the Pokemon is useable in a battle.
 #[no_mangle]
-extern "C" fn pokemon_is_usable(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_is_usable(ptr: ExternPointer<Pokemon>) -> u8 {
     u8::from(ptr.as_ref().is_usable())
 }
 
 /// Returns whether the Pokemon is fainted.
 #[no_mangle]
-extern "C" fn pokemon_is_fainted(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_is_fainted(ptr: ExternPointer<Pokemon>) -> u8 {
     u8::from(ptr.as_ref().is_fainted())
 }
 
 /// Whether or not the Pokemon is on the battlefield.
 #[no_mangle]
-extern "C" fn pokemon_is_on_battlefield(ptr: ExternPointer<Arc<Pokemon>>) -> u8 {
+extern "C" fn pokemon_is_on_battlefield(ptr: ExternPointer<Pokemon>) -> u8 {
     u8::from(ptr.as_ref().is_on_battlefield())
 }
 
 /// Damages the Pokemon by a certain amount of damage, from a damage source.
 #[no_mangle]
-extern "C" fn pokemon_damage(ptr: ExternPointer<Arc<Pokemon>>, damage: u32, source: DamageSource) -> NativeResult<()> {
+extern "C" fn pokemon_damage(ptr: ExternPointer<Pokemon>, damage: u32, source: DamageSource) -> NativeResult<()> {
     ptr.as_ref().damage(damage, source).into()
 }
 
 /// Heals the Pokemon by a specific amount. Unless allow_revive is set to true, this will not
 /// heal if the Pokemon has 0 health. If the amount healed is 0, this will return false.
 #[no_mangle]
-extern "C" fn pokemon_heal(ptr: ExternPointer<Arc<Pokemon>>, amount: u32, allow_revive: u8) -> bool {
+extern "C" fn pokemon_heal(ptr: ExternPointer<Pokemon>, amount: u32, allow_revive: u8) -> bool {
     ptr.as_ref().heal(amount, allow_revive == 1)
 }
 
 /// Learn a move.
 #[no_mangle]
 extern "C" fn pokemon_learn_move(
-    ptr: ExternPointer<Arc<Pokemon>>,
+    ptr: ExternPointer<Pokemon>,
     move_name: *const c_char,
     learn_method: MoveLearnMethod,
 ) -> NativeResult<()> {
@@ -384,6 +377,6 @@ extern "C" fn pokemon_learn_move(
 
 /// Removes the current non-volatile status from the Pokemon.
 #[no_mangle]
-extern "C" fn pokemon_clear_status(ptr: ExternPointer<Arc<Pokemon>>) {
+extern "C" fn pokemon_clear_status(ptr: ExternPointer<Pokemon>) {
     ptr.as_ref().clear_status()
 }

src/ffi/dynamic_data/models/pokemon_party.rs

@@ -10,10 +10,7 @@ extern "C" fn pokemon_party_new(capacity: usize) -> IdentifiablePointer<Arc<Poke
 
 /// Gets a Pokemon at an index in the party.
 #[no_mangle]
-extern "C" fn pokemon_party_at(
+extern "C" fn pokemon_party_at(ptr: ExternPointer<Arc<PokemonParty>>, index: usize) -> IdentifiablePointer<Pokemon> {
-    ptr: ExternPointer<Arc<PokemonParty>>,
-    index: usize,
-) -> IdentifiablePointer<Arc<Pokemon>> {
     if let Some(v) = ptr.as_ref().at(index) {
         v.into()
     } else {
@@ -32,8 +29,8 @@ extern "C" fn pokemon_party_switch(ptr: ExternPointer<Arc<PokemonParty>>, a: usi
 extern "C" fn pokemon_party_swap_into(
     ptr: ExternPointer<Arc<PokemonParty>>,
     index: usize,
-    pokemon: ExternPointer<Arc<Pokemon>>,
+    pokemon: ExternPointer<Pokemon>,
-) -> NativeResult<IdentifiablePointer<Arc<Pokemon>>> {
+) -> NativeResult<IdentifiablePointer<Pokemon>> {
     let pokemon = if pokemon.ptr.is_null() {
         None
     } else {
@@ -66,9 +63,6 @@ extern "C" fn pokemon_party_pack_party(ptr: ExternPointer<Arc<PokemonParty>>) ->
 
 /// Checks if the party contains a given pokemon.
 #[no_mangle]
-extern "C" fn pokemon_party_has_pokemon(
+extern "C" fn pokemon_party_has_pokemon(ptr: ExternPointer<Arc<PokemonParty>>, pokemon: ExternPointer<Pokemon>) -> u8 {
-    ptr: ExternPointer<Arc<PokemonParty>>,
-    pokemon: ExternPointer<Arc<Pokemon>>,
-) -> u8 {
     u8::from(ptr.as_ref().has_pokemon(pokemon.as_ref()))
 }

src/ffi/mod.rs

@@ -87,6 +87,7 @@ macro_rules! ffi_vec_stringkey_getters {
     };
 }
 
+use crate::dynamic_data::{Battle, Pokemon};
 use crate::{ValueIdentifiable, ValueIdentifier};
 pub(self) use ffi_arc_dyn_getter;
 pub(self) use ffi_arc_getter;
@@ -250,6 +251,40 @@ impl<T: ValueIdentifiable> From<*const T> for IdentifiablePointer<T> {
     }
 }
 
+impl From<Pokemon> for IdentifiablePointer<Pokemon> {
+    fn from(v: Pokemon) -> Self {
+        let id = v.value_identifier().value();
+        Self {
+            ptr: Box::into_raw(Box::new(v)),
+            id,
+        }
+    }
+}
+
+impl From<Option<Pokemon>> for IdentifiablePointer<Pokemon> {
+    fn from(v: Option<Pokemon>) -> Self {
+        if let Some(v) = v {
+            let id = unsafe { transmute(v.value_identifier()) };
+            Self {
+                ptr: Box::into_raw(Box::new(v)),
+                id,
+            }
+        } else {
+            IdentifiablePointer::none()
+        }
+    }
+}
+
+impl From<Battle> for IdentifiablePointer<Battle> {
+    fn from(v: Battle) -> Self {
+        let id = v.value_identifier().value();
+        Self {
+            ptr: Box::into_raw(Box::new(v)),
+            id,
+        }
+    }
+}
+
 impl<T> IdentifiablePointer<T> {
     /// Returns an identifiable pointer with null as pointer, and 0 as identifier.
     pub fn none() -> Self {

src/ffi/static_data/ability.rs

@@ -11,13 +11,13 @@ use std::sync::Arc;
 unsafe extern "C" fn ability_new(
     name: *const c_char,
     effect: *const c_char,
-    parameters: *const OwnedPtr<EffectParameter>,
+    parameters: *const OwnedPtr<Arc<EffectParameter>>,
     parameters_length: usize,
 ) -> NativeResult<IdentifiablePointer<Arc<dyn Ability>>> {
     let parameters = std::slice::from_raw_parts(parameters, parameters_length);
-    let mut parameters_vec: Vec<EffectParameter> = Vec::with_capacity(parameters_length);
+    let mut parameters_vec: Vec<Arc<EffectParameter>> = Vec::with_capacity(parameters_length);
     for parameter in parameters {
-        parameters_vec.push(*Box::from_raw(*parameter));
+        parameters_vec.push(parameter.read());
     }
 
     let name: StringKey = match CStr::from_ptr(name).to_str() {
@@ -68,9 +68,9 @@ unsafe extern "C" fn ability_parameter_length(ptr: ExternPointer<Arc<dyn Ability
 unsafe extern "C" fn ability_parameter_get(
     ptr: ExternPointer<Arc<dyn Ability>>,
     index: usize,
-) -> IdentifiablePointer<EffectParameter> {
+) -> IdentifiablePointer<Arc<EffectParameter>> {
     if let Some(p) = ptr.as_ref().parameters().get(index) {
-        (p as *const EffectParameter).into()
+        p.clone().into()
     } else {
         IdentifiablePointer::none()
     }

src/ffi/static_data/form.rs

@@ -95,8 +95,8 @@ ffi_vec_value_getters!(Form, dyn Form, types, TypeIdentifier);
 #[no_mangle]
 unsafe extern "C" fn form_base_stats(
     ptr: ExternPointer<Arc<dyn Form>>,
-) -> IdentifiablePointer<StaticStatisticSet<u16>> {
+) -> IdentifiablePointer<Arc<StaticStatisticSet<u16>>> {
-    (ptr.as_ref().base_stats() as *const StaticStatisticSet<u16>).into()
+    ptr.as_ref().base_stats().clone().into()
 }
 
 ffi_vec_stringkey_getters!(Form, abilities);

src/ffi/static_data/libraries/static_data.rs

@@ -4,28 +4,29 @@ use crate::static_data::{
     StaticData, StaticDataImpl, TypeLibrary,
 };
 use std::ptr::drop_in_place;
+use std::sync::Arc;
 
 /// Instantiates a new data collection.
 #[no_mangle]
 unsafe extern "C" fn static_data_new(
-    settings: OwnedPtr<Box<dyn LibrarySettings>>,
+    settings: OwnedPtr<Arc<dyn LibrarySettings>>,
-    species: OwnedPtr<Box<dyn SpeciesLibrary>>,
+    species: OwnedPtr<Arc<dyn SpeciesLibrary>>,
-    moves: OwnedPtr<Box<dyn MoveLibrary>>,
+    moves: OwnedPtr<Arc<dyn MoveLibrary>>,
-    items: OwnedPtr<Box<dyn ItemLibrary>>,
+    items: OwnedPtr<Arc<dyn ItemLibrary>>,
-    growth_rates: OwnedPtr<Box<dyn GrowthRateLibrary>>,
+    growth_rates: OwnedPtr<Arc<dyn GrowthRateLibrary>>,
-    types: OwnedPtr<Box<dyn TypeLibrary>>,
+    types: OwnedPtr<Arc<dyn TypeLibrary>>,
-    natures: OwnedPtr<Box<dyn NatureLibrary>>,
+    natures: OwnedPtr<Arc<dyn NatureLibrary>>,
-    abilities: OwnedPtr<Box<dyn AbilityLibrary>>,
+    abilities: OwnedPtr<Arc<dyn AbilityLibrary>>,
-) -> IdentifiablePointer<Box<dyn StaticData>> {
+) -> IdentifiablePointer<Arc<dyn StaticData>> {
-    let b: Box<dyn StaticData> = Box::new(StaticDataImpl::new(
+    let b: Arc<dyn StaticData> = Arc::new(StaticDataImpl::new(
-        *Box::from_raw(settings),
+        settings.read(),
-        *Box::from_raw(species),
+        species.read(),
-        *Box::from_raw(moves),
+        moves.read(),
-        *Box::from_raw(items),
+        items.read(),
-        *Box::from_raw(growth_rates),
+        growth_rates.read(),
-        *Box::from_raw(types),
+        types.read(),
-        *Box::from_raw(natures),
+        natures.read(),
-        *Box::from_raw(abilities),
+        abilities.read(),
     ));
     b.into()
 }
@@ -39,63 +40,63 @@ unsafe extern "C" fn static_data_drop(ptr: OwnedPtr<Box<dyn StaticData>>) {
 /// Several misc settings for the library.
 #[no_mangle]
 unsafe extern "C" fn static_data_settings(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn LibrarySettings>> {
+) -> IdentifiablePointer<Arc<dyn LibrarySettings>> {
-    data.as_mut().settings().into()
+    data.as_mut().settings().clone().into()
 }
 
 /// All data for Pokemon species.
 #[no_mangle]
 unsafe extern "C" fn static_data_species(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn SpeciesLibrary>> {
+) -> IdentifiablePointer<Arc<dyn SpeciesLibrary>> {
-    data.as_mut().species().into()
+    data.as_mut().species().clone().into()
 }
 
 /// All data for the moves.
 #[no_mangle]
 unsafe extern "C" fn static_data_moves(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn MoveLibrary>> {
+) -> IdentifiablePointer<Arc<dyn MoveLibrary>> {
-    data.as_mut().moves().into()
+    data.as_mut().moves().clone().into()
 }
 
 /// All data for the items.
 #[no_mangle]
 unsafe extern "C" fn static_data_items(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn ItemLibrary>> {
+) -> IdentifiablePointer<Arc<dyn ItemLibrary>> {
-    (data.as_mut().items()).into()
+    (data.as_mut().items()).clone().into()
 }
 
 /// All data for growth rates.
 #[no_mangle]
 unsafe extern "C" fn static_data_growth_rates(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn GrowthRateLibrary>> {
+) -> IdentifiablePointer<Arc<dyn GrowthRateLibrary>> {
-    data.as_mut().growth_rates().into()
+    data.as_mut().growth_rates().clone().into()
 }
 
 /// All data related to types and type effectiveness.
 #[no_mangle]
 unsafe extern "C" fn static_data_types(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn TypeLibrary>> {
+) -> IdentifiablePointer<Arc<dyn TypeLibrary>> {
-    data.as_mut().types().into()
+    data.as_mut().types().clone().into()
 }
 
 /// All data related to natures.
 #[no_mangle]
 unsafe extern "C" fn static_data_natures(
-    data: ExternPointer<Box<dyn StaticData>>,
+    data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn NatureLibrary>> {
+) -> IdentifiablePointer<Arc<dyn NatureLibrary>> {
-    data.as_ref().natures().into()
+    data.as_ref().natures().clone().into()
 }
 
 /// All data related to abilities.
 #[no_mangle]
 unsafe extern "C" fn static_data_abilities(
-    mut data: ExternPointer<Box<dyn StaticData>>,
+    mut data: ExternPointer<Arc<dyn StaticData>>,
-) -> IdentifiablePointer<Box<dyn AbilityLibrary>> {
+) -> IdentifiablePointer<Arc<dyn AbilityLibrary>> {
-    (data.as_mut().abilities()).into()
+    (data.as_mut().abilities()).clone().into()
 }

src/ffi/static_data/move_data.rs

@@ -102,7 +102,7 @@ unsafe extern "C" fn move_data_has_flag(ptr: ExternPointer<Arc<dyn MoveData>>, f
 unsafe extern "C" fn secondary_effect_new(
     chance: f32,
     effect_name: BorrowedPtr<c_char>,
-    parameters: *mut OwnedPtr<EffectParameter>,
+    parameters: *mut OwnedPtr<Arc<EffectParameter>>,
     parameters_length: usize,
 ) -> IdentifiablePointer<Box<dyn SecondaryEffect>> {
     let parameter_slice = std::slice::from_raw_parts(parameters, parameters_length);
@@ -156,9 +156,9 @@ unsafe extern "C" fn secondary_effect_parameter_length(ptr: ExternPointer<Box<dy
 unsafe extern "C" fn secondary_effect_parameter_get(
     ptr: ExternPointer<Box<dyn SecondaryEffect>>,
     index: usize,
-) -> IdentifiablePointer<EffectParameter> {
+) -> IdentifiablePointer<Arc<EffectParameter>> {
     if let Some(v) = ptr.as_ref().parameters().get(index) {
-        (v as *const EffectParameter).into()
+        v.clone().into()
     } else {
         IdentifiablePointer::none()
     }

src/script_implementations/wasm/export_registry/dynamic_data/battle.rs

@@ -5,10 +5,9 @@ use crate::script_implementations::wasm::export_registry::wasm_result::{
     get_value, get_value_arc, get_value_call_getter, try_wasm,
 };
 use crate::script_implementations::wasm::export_registry::{register, wasm_ok, WasmResult};
-use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
+use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::StringKey;
-use anyhow_ext::Context;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -23,19 +22,27 @@ register! {
     fn battle_get_parties(
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle: ExternRef<Battle>,
-    ) -> WasmResult<VecExternRef<BattleParty>> {
+    ) -> WasmResult<u64> {
-        let parties = get_value_call_getter!(battle.parties(), env);
+        let battle = get_value!(battle, env);
-        wasm_ok(VecExternRef::new(env.data().data().as_ref(), parties))
+        let parties = battle.parties();
+        let mut vec : Vec<u32> = Vec::with_capacity(parties.len());
+        for party in parties {
+            vec.push(ExternRef::<BattleParty>::func_new(&env, party.into()).index() as u32);
+        }
+        let wasm_ptr = try_wasm!(env.data().data().copy_value_vec_to_wasm(&vec), env);
+        let r: u64 = unsafe { std::mem::transmute((wasm_ptr, vec.len() as u32)) };
+        wasm_ok(r)
     }
 
     fn battle_get_choice_queue(
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle: ExternRef<Battle>,
     ) -> WasmResult<ExternRef<ChoiceQueue>> {
-        let value = get_value_call_getter!(battle.current_turn_queue(), env);
+        let battle = get_value!(battle, env);
+        let value = battle.current_turn_queue();
         let queue = value.read();
         wasm_ok(if let Some(queue) = queue.as_ref() {
-            ExternRef::<ChoiceQueue>::func_new(&env, queue)
+            ExternRef::<ChoiceQueue>::func_new(&env, queue.into())
         } else {
             ExternRef::null()
         })
@@ -45,24 +52,34 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle: ExternRef<Battle>,
     ) -> WasmResult<ExternRef<dyn DynamicLibrary>> {
-        let value = get_value_call_getter!(battle.library(), env);
+        let battle = get_value!(battle, env);
-        wasm_ok(ExternRef::<dyn DynamicLibrary>::func_new(&env, &value.clone()))
+        let value = battle.library();
+        wasm_ok(ExternRef::func_new(&env, value.into()))
     }
 
     fn battle_get_sides(
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle: ExternRef<Battle>,
-    ) -> WasmResult<VecExternRef<BattleSide>> {
+    ) -> WasmResult<u64> {
-        let value = get_value_arc!(battle, env);
+        let value = get_value!(battle, env);
-        wasm_ok(VecExternRef::new(env.data().data().as_ref(), value.sides()))
+        let sides = value.sides();
+        let mut vec : Vec<u32> = Vec::with_capacity(sides.len());
+        for side in sides {
+            vec.push(ExternRef::<BattleSide>::func_new(&env, side.into()).index() as u32);
+        }
+        let wasm_ptr = try_wasm!(env.data().data().copy_value_vec_to_wasm(&vec), env);
+        let r: u64 = unsafe { std::mem::transmute((wasm_ptr, vec.len() as u32)) };
+        wasm_ok(r)
+
     }
 
     fn battle_get_random(
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle: ExternRef<Battle>,
     ) -> WasmResult<ExternRef<BattleRandom>> {
-        let random = get_value_call_getter!(battle.random(), env);
+        let battle = get_value!(battle, env);
-        wasm_ok(ExternRef::<BattleRandom>::func_new(&env, random))
+        let random = battle.random();
+        wasm_ok(ExternRef::<BattleRandom>::func_new(&env, random.into()))
     }
 
     fn battle_get_weather_name(
@@ -72,7 +89,7 @@ register! {
         let weather = get_value_call_getter!(battle.weather_name(), env);
         let weather = try_wasm!(weather, env);
         wasm_ok(if let Some(weather) = weather {
-            ExternRef::<StringKey>::func_new(&env, &weather)
+            ExternRef::<StringKey>::func_new(&env, weather.into())
         } else {
             ExternRef::null()
         })
@@ -86,8 +103,8 @@ register! {
         let battle = get_value!(battle, env);
         let pokemon = get_value!(pokemon, env);
         for party in battle.parties() {
-            if party.party().has_pokemon(pokemon) {
+            if party.party().has_pokemon(&pokemon) {
-                return wasm_ok(ExternRef::<BattleParty>::func_new(&env, party));
+                return wasm_ok(ExternRef::<BattleParty>::func_new(&env, party.into()));
             }
         }
         wasm_ok(ExternRef::<BattleParty>::null())
@@ -101,7 +118,7 @@ register! {
         let battle = get_value!(battle, env);
         let pokemon = battle.get_pokemon(side, index);
         wasm_ok(if let Some(pokemon) = pokemon {
-            ExternRef::<Pokemon>::func_new(&env, &pokemon)
+            ExternRef::<Pokemon>::func_new(&env, (&pokemon).into())
         } else {
             ExternRef::null()
         })
@@ -159,7 +176,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle_party: ExternRef<BattleParty>,
     ) -> WasmResult<ExternRef<PokemonParty>> {
-        let value = get_value_call_getter!(battle_party.party(), env);
+        let battle_party = get_value_arc!(battle_party, env);
-        wasm_ok(ExternRef::<PokemonParty>::func_new(&env, value.as_ref()))
+        wasm_ok(ExternRef::<PokemonParty>::func_new(&env, battle_party.party().into()))
     }
 }

src/script_implementations/wasm/export_registry/dynamic_data/battle_random.rs

@@ -1,21 +1,18 @@
 use crate::dynamic_data::BattleRandom;
-use crate::script_implementations::wasm::export_registry::wasm_result::{
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value_arc, try_wasm, wasm_ok};
-    get_value, get_value_call_getter, try_wasm, wasm_ok,
-};
 use crate::script_implementations::wasm::export_registry::{register, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use wasmer::FunctionEnvMut;
 
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
-use anyhow_ext::Context;
 
 register! {
     fn battle_random_get(
         env: FunctionEnvMut<WebAssemblyEnv>,
         battle_random: ExternRef<BattleRandom>,
     ) -> WasmResult<i32> {
-        let v = get_value_call_getter!(battle_random.get(), env);
+        let v = get_value_arc!(battle_random, env);
-        let v = try_wasm!(v, env);
+        let v = try_wasm!(v.get(), env);
         wasm_ok(v)
     }
     fn battle_random_get_max(
@@ -23,7 +20,7 @@ register! {
         battle_random: ExternRef<BattleRandom>,
         max: i32
     ) -> WasmResult<i32> {
-        let battle_random = get_value!(battle_random, env);
+        let battle_random = get_value_arc!(battle_random, env);
         let v = try_wasm!(battle_random.get_max(max), env);
         wasm_ok(v)
     }
@@ -33,7 +30,7 @@ register! {
         min: i32,
         max: i32
     ) -> WasmResult<i32> {
-        let battle_random = get_value!(battle_random, env);
+        let battle_random = get_value_arc!(battle_random, env);
         let v = try_wasm!(battle_random.get_between(min, max), env);
         wasm_ok(v)
     }

src/script_implementations/wasm/export_registry/dynamic_data/battle_side.rs

@@ -7,7 +7,6 @@ use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use anyhow::anyhow;
-use anyhow_ext::Context;
 use std::ffi::CStr;
 use wasmer::FunctionEnvMut;
 
@@ -46,7 +45,7 @@ register! {
     ) -> WasmResult<ExternRef<Battle>> {
         let value = get_value_call_getter!(side.battle(), env);
         let value = try_wasm!(value, env);
-        wasm_ok(ExternRef::func_new(&env, &value))
+        wasm_ok(ExternRef::func_new(&env, (&value).into()))
     }
 
     fn battleside_get_pokemon(
@@ -55,11 +54,11 @@ register! {
         index: u32
     ) -> WasmResult<ExternRef<Pokemon>> {
         let side = get_value!(side, env);
-        wasm_ok(if let Some(Some(p)) = side.pokemon().get(index as usize) {
+        let x = wasm_ok(if let Some(Some(p)) = side.pokemon().get(index as usize) {
-            ExternRef::<Pokemon>::func_new(&env, p.as_ref())
+            ExternRef::<Pokemon>::func_new(&env, p.into())
         } else {
             ExternRef::null()
-        })
+        }); x
     }
 
     fn battle_side_get_has_fled_battle(
@@ -99,13 +98,13 @@ register! {
         side: ExternRef<BattleSide>,
         script_ptr: u32
     ) -> WasmResult<u32> {
-        let side : &BattleSide = get_value!(side, env);
+        let side = get_value!(side, env);
         unsafe {
             let e = env.data().data();
             let name_func = try_wasm!(e.script_function_cache().script_get_name(&e), env);
             let name_ptr = try_wasm!(name_func.call(&mut e.store_mut(), script_ptr), env);
             let c_name: &CStr = CStr::from_ptr(e.get_raw_pointer(name_ptr));
-            let script = try_wasm!(e.setup_script(script_ptr, ScriptCategory::Side, &c_name.as_ref().into(), side.into()), env);
+            let script = try_wasm!(e.setup_script(script_ptr, ScriptCategory::Side, &c_name.as_ref().into(), (&side).into()), env);
             try_wasm!(e.script_function_cache().dealloc_cstring(&e, name_ptr), env);
 
             if let Some(script) = script {

src/script_implementations/wasm/export_registry/dynamic_data/choice_queue.rs

@@ -1,8 +1,8 @@
 use crate::dynamic_data::{ChoiceQueue, Pokemon};
+use crate::script_implementations::wasm::export_registry::wasm_result::get_value_arc;
 use crate::script_implementations::wasm::export_registry::{get_value, register, try_wasm, wasm_ok, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
-use anyhow_ext::Context;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -11,9 +11,9 @@ register! {
         battle_random: ExternRef<ChoiceQueue>,
         pokemon: ExternRef<Pokemon>
     ) -> WasmResult<u8> {
-        let battle_random = get_value!(battle_random, env);
+        let battle_random = get_value_arc!(battle_random, env);
         let pokemon = get_value!(pokemon, env);
-        let res = try_wasm!(battle_random.move_pokemon_choice_next(pokemon), env);
+        let res = try_wasm!(battle_random.move_pokemon_choice_next(&pokemon), env);
         wasm_ok(u8::from(res))
     }
 }

src/script_implementations/wasm/export_registry/dynamic_data/executing_move.rs

@@ -1,13 +1,10 @@
 use crate::dynamic_data::{ExecutingMove, HitData, LearnedMove, Pokemon};
 use crate::script_implementations::wasm::export_registry::wasm_result::get_value_arc;
-use crate::script_implementations::wasm::export_registry::{
+use crate::script_implementations::wasm::export_registry::{get_value, register, try_wasm, wasm_ok, WasmResult};
-    get_value, get_value_call_getter, register, try_wasm, wasm_ok, WasmResult,
-};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::MoveData;
-use anyhow_ext::Context;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -15,31 +12,32 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         executing_move: ExternRef<ExecutingMove>,
     ) -> WasmResult<ExternRef<Pokemon>> {
-        let user = get_value_call_getter!(executing_move.user(), env);
+        let executing_move = get_value_arc!(executing_move, env);
-        wasm_ok(ExternRef::<Pokemon>::func_new(&env, user.as_ref()))
+        wasm_ok(ExternRef::<Pokemon>::func_new(&env, executing_move.user().into()))
     }
 
     fn executing_move_get_use_move(
         env: FunctionEnvMut<WebAssemblyEnv>,
         executing_move: ExternRef<ExecutingMove>,
     ) -> WasmResult<ExternRef<dyn MoveData>> {
-        let use_move = get_value_call_getter!(executing_move.use_move(), env);
+        let executing_move = get_value_arc!(executing_move, env);
-        wasm_ok(ExternRef::<dyn MoveData>::func_new(&env, use_move))
+        wasm_ok(ExternRef::<dyn MoveData>::func_new(&env, executing_move.use_move().into()))
     }
 
     fn executing_move_get_chosen_move(
         env: FunctionEnvMut<WebAssemblyEnv>,
         executing_move: ExternRef<ExecutingMove>,
     ) -> WasmResult<ExternRef<LearnedMove>> {
-        let chosen_move = get_value_call_getter!(executing_move.chosen_move(), env);
+        let executing_move = get_value_arc!(executing_move, env);
-        wasm_ok(ExternRef::<LearnedMove>::func_new(&env, chosen_move.as_ref()))
+        wasm_ok(ExternRef::<LearnedMove>::func_new(&env, executing_move.chosen_move().into()))
     }
 
     fn executing_move_get_number_of_hits(
         env: FunctionEnvMut<WebAssemblyEnv>,
         executing_move: ExternRef<ExecutingMove>,
     ) -> WasmResult<u8> {
-        wasm_ok(get_value_call_getter!(executing_move.number_of_hits(), env))
+        let executing_move = get_value_arc!(executing_move, env);
+        wasm_ok(executing_move.number_of_hits())
     }
 
     fn executing_move_get_hit_data(
@@ -48,17 +46,18 @@ register! {
         target: ExternRef<Pokemon>,
         hit: u8
     ) -> WasmResult<ExternRef<HitData>> {
-        let executing_move = get_value!(executing_move, env);
+        let executing_move = get_value_arc!(executing_move, env);
-        let target = get_value_arc!(target, env);
+        let target = get_value!(target, env);
         let hit_data = try_wasm!(executing_move.get_hit_data(&target, hit), env);
-        wasm_ok(ExternRef::<HitData>::func_new(&env, hit_data))
+        wasm_ok(ExternRef::<HitData>::func_new(&env, hit_data.into()))
     }
 
     fn executing_move_get_number_of_targets(
         env: FunctionEnvMut<WebAssemblyEnv>,
         executing_move: ExternRef<ExecutingMove>,
     ) -> WasmResult<u32> {
-        wasm_ok(get_value_call_getter!(executing_move.target_count(), env) as u32)
+        let executing_move = get_value_arc!(executing_move, env);
+        wasm_ok(executing_move.target_count() as u32)
     }
 
     fn executing_move_is_pokemon_target(
@@ -66,8 +65,8 @@ register! {
         executing_move: ExternRef<ExecutingMove>,
         pokemon: ExternRef<Pokemon>
     ) -> WasmResult<u8> {
-        let executing_move = get_value!(executing_move, env);
+        let executing_move = get_value_arc!(executing_move, env);
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if executing_move.is_pokemon_target(&pokemon) { 1 } else { 0 })
     }
 
@@ -77,7 +76,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         executing_move: ExternRef<ExecutingMove>,
     ) -> WasmResult<u32> {
-        let executing_move = get_value!(executing_move, env);
+        let executing_move = get_value_arc!(executing_move, env);
         let script = executing_move.script();
         if script.is_any() {
             let script = try_wasm!(script.get_as::<WebAssemblyScript>(), env);

src/script_implementations/wasm/export_registry/dynamic_data/hit_data.rs

@@ -1,11 +1,10 @@
 use crate::dynamic_data::HitData;
 use crate::script_implementations::wasm::export_registry::wasm_result::{
-    get_value_call_getter, get_value_void, wasm_ok, WasmVoidResultExtension,
+    get_value_arc, get_value_arc_void, wasm_ok, WasmVoidResultExtension,
 };
 use crate::script_implementations::wasm::export_registry::{register, WasmResult, WasmVoidResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
-use anyhow_ext::Context;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -13,22 +12,23 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         hit: ExternRef<HitData>,
     ) -> WasmResult<u32> {
-        wasm_ok(get_value_call_getter!(hit.damage(), env))
+        let hit = get_value_arc!(hit, env);
+        wasm_ok(hit.damage())
     }
 
     fn hit_data_is_critical(
         env: FunctionEnvMut<WebAssemblyEnv>,
         hit: ExternRef<HitData>,
     ) -> WasmResult<u8> {
-        let is_critical = get_value_call_getter!(hit.is_critical(), env);
+        let hit = get_value_arc!(hit, env);
-        wasm_ok(u8::from(is_critical))
+        wasm_ok(u8::from(hit.is_critical()))
     }
 
     fn hit_data_fail(
         env: FunctionEnvMut<WebAssemblyEnv>,
         hit: ExternRef<HitData>,
     ) -> WasmVoidResult {
-        let hit = get_value_void!(hit, env);
+        let hit = get_value_arc_void!(hit, env);
         hit.fail();
         WasmVoidResult::ok()
     }
@@ -37,21 +37,24 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         hit: ExternRef<HitData>,
     ) -> WasmResult<u8> {
-        wasm_ok(get_value_call_getter!(hit.base_power(), env))
+        let hit = get_value_arc!(hit, env);
+        wasm_ok(hit.base_power())
     }
 
     fn hit_data_get_effectiveness(
         env: FunctionEnvMut<WebAssemblyEnv>,
         hit: ExternRef<HitData>,
     ) -> WasmResult<f32> {
-        wasm_ok(get_value_call_getter!(hit.effectiveness(), env))
+        let hit = get_value_arc!(hit, env);
+        wasm_ok(hit.effectiveness())
     }
 
     fn hit_data_get_move_type(
         env: FunctionEnvMut<WebAssemblyEnv>,
         hit: ExternRef<HitData>,
     ) -> WasmResult<u8> {
-        wasm_ok(get_value_call_getter!(hit.move_type(), env).into())
+        let hit = get_value_arc!(hit, env);
+        wasm_ok(hit.move_type().into())
     }
 
     fn hit_data_set_critical(
@@ -59,7 +62,7 @@ register! {
         hit: ExternRef<HitData>,
         value: u8
     ) -> WasmVoidResult {
-        let hit = get_value_void!(hit, env);
+        let hit = get_value_arc_void!(hit, env);
         hit.set_critical(value == 1);
         WasmVoidResult::ok()
     }
@@ -69,7 +72,7 @@ register! {
         hit: ExternRef<HitData>,
         effectiveness: f32
     ) -> WasmVoidResult {
-        let hit = get_value_void!(hit, env);
+        let hit = get_value_arc_void!(hit, env);
         hit.set_effectiveness(effectiveness);
         WasmVoidResult::ok()
     }
@@ -79,7 +82,7 @@ register! {
         hit: ExternRef<HitData>,
         damage: u32
     ) -> WasmVoidResult {
-        let hit = get_value_void!(hit, env);
+        let hit = get_value_arc_void!(hit, env);
         hit.set_damage(damage);
         WasmVoidResult::ok()
     }
@@ -89,7 +92,7 @@ register! {
         hit: ExternRef<HitData>,
         move_type: u8
     ) -> WasmVoidResult {
-        let hit = get_value_void!(hit, env);
+        let hit = get_value_arc_void!(hit, env);
         hit.set_move_type(move_type.into());
         WasmVoidResult::ok()
     }

src/script_implementations/wasm/export_registry/dynamic_data/learned_move.rs

@@ -2,13 +2,12 @@ use std::intrinsics::transmute;
 
 use crate::dynamic_data::{LearnedMove, MoveLearnMethod};
 use crate::script_implementations::wasm::export_registry::wasm_result::{
-    get_value_call_getter, get_value_void, wasm_ok, WasmVoidResult, WasmVoidResultExtension,
+    get_value_arc, get_value_arc_void, wasm_ok, WasmVoidResult, WasmVoidResultExtension,
 };
 use crate::script_implementations::wasm::export_registry::{register, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::MoveData;
-use anyhow_ext::Context;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -17,8 +16,8 @@ register! {
         turn_choice: ExternRef<LearnedMove>,
     ) -> WasmResult<u8> {
         unsafe {
-            let learn_method = get_value_call_getter!(turn_choice.learn_method(), &env);
+            let learned_move = get_value_arc!(turn_choice, env);
-            wasm_ok(transmute::<MoveLearnMethod, u8>(learn_method))
+            wasm_ok(transmute::<MoveLearnMethod, u8>(learned_move.learn_method()))
         }
     }
 
@@ -26,15 +25,15 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<LearnedMove>,
     ) -> WasmResult<ExternRef<dyn MoveData>> {
-        let move_data = get_value_call_getter!(turn_choice.move_data(), &env);
+        let turn_choice = get_value_arc!(turn_choice, env);
-        wasm_ok(ExternRef::<dyn MoveData>::func_new(&env, move_data))
+        wasm_ok(ExternRef::func_new(&env, turn_choice.move_data().into()))
     }
 
     fn learned_move_restore_all_uses(
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<LearnedMove>,
     ) -> WasmVoidResult {
-        let turn_choice = get_value_void!(turn_choice, env);
+        let turn_choice = get_value_arc_void!(turn_choice, env);
         turn_choice.restore_all_uses();
         WasmVoidResult::ok()
     }
@@ -44,7 +43,7 @@ register! {
         turn_choice: ExternRef<LearnedMove>,
         amount: u8,
     ) -> WasmVoidResult {
-        let turn_choice = get_value_void!(turn_choice, env);
+        let turn_choice = get_value_arc_void!(turn_choice, env);
         turn_choice.restore_uses(amount);
         WasmVoidResult::ok()
     }

src/script_implementations/wasm/export_registry/dynamic_data/mod.rs

@@ -2,12 +2,10 @@ use crate::dynamic_data::{DynamicLibrary, ScriptOwnerData};
 use crate::script_implementations::wasm::export_registry::register;
 use crate::script_implementations::wasm::export_registry::wasm_result::{try_wasm, wasm_ok, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
-use std::sync::atomic::Ordering;
 use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};
 
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::StaticData;
-use anyhow_ext::Context;
 
 /// The battle registration
 mod battle;
@@ -37,27 +35,25 @@ register! {
     ) -> WasmResult<ExternRef<dyn StaticData>> {
         let dynamic_lib = try_wasm!(dynamic_lib.value_func_arc(&env), env);
         let static_data = dynamic_lib.static_data();
-        wasm_ok(ExternRef::<dyn StaticData>::func_new(&env, static_data))
+        wasm_ok(ExternRef::<dyn StaticData>::func_new(&env, static_data.into()))
     }
 
     fn script_get_owner(
         env: FunctionEnvMut<WebAssemblyEnv>,
         script: u32,
     ) -> u32 {
-        unsafe {
         let script = env.data().data().get_loaded_script(script);
         if let Some(script) = script {
             match script.get_owner() {
-                    ScriptOwnerData::Pokemon(p) => env.data().data().get_extern_ref_index::<crate::dynamic_data::Pokemon>(p.load(Ordering::Relaxed).as_ref().unwrap()) as u32,
+                ScriptOwnerData::Pokemon(p) => env.data().data().get_extern_ref_index(p.into()) as u32,
-                    ScriptOwnerData::BattleSide(p) => env.data().data().get_extern_ref_index::<crate::dynamic_data::BattleSide>(p.load(Ordering::Relaxed).as_ref().unwrap()) as u32,
+                ScriptOwnerData::BattleSide(p) => env.data().data().get_extern_ref_index(p.into()) as u32,
-                    ScriptOwnerData::Battle(p) => env.data().data().get_extern_ref_index::<crate::dynamic_data::Battle>(p.load(Ordering::Relaxed).as_ref().unwrap()) as u32,
+                ScriptOwnerData::Battle(p) => env.data().data().get_extern_ref_index(p.into()) as u32,
                 ScriptOwnerData::None => 0,
             }
         } else {
             0
         }
     }
-    }
 
     fn script_get_owner_kind(
         env: FunctionEnvMut<WebAssemblyEnv>,

src/script_implementations/wasm/export_registry/dynamic_data/party.rs

@@ -1,9 +1,8 @@
 use crate::dynamic_data::{Pokemon, PokemonParty};
 use crate::script_implementations::wasm::export_registry::register;
-use crate::script_implementations::wasm::export_registry::wasm_result::{get_value, wasm_ok, WasmResult};
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value_arc, wasm_ok, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
-use anyhow_ext::Context;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -12,20 +11,20 @@ register! {
         party: ExternRef<PokemonParty>,
         index: u32
     ) -> WasmResult<ExternRef<Pokemon>> {
-        let party = get_value!(party, env);
+        let party = get_value_arc!(party, env);
-        wasm_ok(
+        let x = wasm_ok(
         if let Some(Some(v)) = &party.pokemon().get(index as usize) {
-            ExternRef::func_new(&env, v.as_ref())
+            ExternRef::func_new(&env, v.into())
         } else {
             ExternRef::null()
-        })
+        }); x
     }
 
     fn party_get_length(
         env: FunctionEnvMut<WebAssemblyEnv>,
         party: ExternRef<PokemonParty>,
     ) -> WasmResult<u32> {
-        let party = get_value!(party, env);
+        let party = get_value_arc!(party, env);
         wasm_ok(party.length() as u32)
     }
 }

src/script_implementations/wasm/export_registry/dynamic_data/pokemon.rs

@@ -3,8 +3,8 @@ use std::mem::transmute;
 use crate::defines::LevelInt;
 use crate::dynamic_data::{Battle, DynamicLibrary, LearnedMove, Pokemon, VolatileScriptsOwner};
 use crate::script_implementations::wasm::export_registry::{
-    get_value_arc, get_value_arc_void, get_value_call_getter, get_value_void, register, try_wasm, wasm_err, wasm_ok,
+    get_value, get_value_arc, get_value_arc_void, get_value_call_getter, get_value_void, register, try_wasm, wasm_err,
-    WasmResult, WasmVoidResult, WasmVoidResultExtension,
+    wasm_ok, WasmResult, WasmVoidResult, WasmVoidResultExtension,
 };
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script::WebAssemblyScript;
@@ -13,7 +13,6 @@ use crate::static_data::{Ability, ClampedStatisticSet, Form, Nature, Species};
 use crate::static_data::{Item, StatisticSet};
 use crate::{ScriptCategory, VecExt};
 use anyhow::anyhow;
-use anyhow_ext::Context;
 use std::ffi::{c_char, CStr, CString};
 use wasmer::FunctionEnvMut;
 
@@ -22,56 +21,62 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn DynamicLibrary>> {
-        let lib = get_value_call_getter!(pokemon.library(), env).clone();
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<dyn DynamicLibrary>::func_new(&env, &lib))
+        let lib = pokemon.library();
+        wasm_ok(ExternRef::<dyn DynamicLibrary>::func_new(&env, lib.into()))
     }
 
     fn pokemon_get_boosted_stats(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<StatisticSet<u32>>> {
-        let statistic_set = get_value_call_getter!(pokemon.boosted_stats(), env).clone();
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<StatisticSet<u32>>::func_new(&env, statistic_set))
+        let statistic_set = pokemon.boosted_stats();
+        wasm_ok(ExternRef::<StatisticSet<u32>>::func_new(&env, statistic_set.into()))
     }
 
     fn pokemon_get_flat_stats(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<StatisticSet<u32>>> {
-        let statistic_set = get_value_call_getter!(pokemon.flat_stats(), env).clone();
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<StatisticSet<u32>>::func_new(&env, statistic_set))
+        let statistic_set = pokemon.flat_stats();
+        wasm_ok(ExternRef::<StatisticSet<u32>>::func_new(&env, statistic_set.into()))
     }
 
     fn pokemon_get_stat_boosts(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<ClampedStatisticSet<i8, -6, 6>>> {
-        let statistic_set = get_value_call_getter!(pokemon.stat_boosts(), env).clone();
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<ClampedStatisticSet<i8, -6, 6>>::func_new(&env, statistic_set))
+        let statistic_set = pokemon.stat_boosts();
+        wasm_ok(ExternRef::<ClampedStatisticSet<i8, -6, 6>>::func_new(&env, statistic_set.into()))
     }
 
     fn pokemon_get_individual_values(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<ClampedStatisticSet<u8, 0, 31>>> {
-        let statistic_set = get_value_call_getter!(pokemon.individual_values(), env).clone();
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<ClampedStatisticSet<u8, 0, 31>>::func_new(&env, statistic_set))
+        let statistic_set = pokemon.individual_values();
+        wasm_ok(ExternRef::<ClampedStatisticSet<u8, 0, 31>>::func_new(&env, statistic_set.into()))
     }
 
     fn pokemon_get_effort_values(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<ClampedStatisticSet<u8, 0, 252>>> {
-        let statistic_set = get_value_call_getter!(pokemon.effort_values(), env).clone();
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<ClampedStatisticSet<u8, 0, 252>>::func_new(&env, statistic_set))
+        let statistic_set = pokemon.effort_values();
+        wasm_ok(ExternRef::<ClampedStatisticSet<u8, 0, 252>>::func_new(&env, statistic_set.into()))
     }
 
     fn pokemon_get_species(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Species>> {
-        let species = get_value_call_getter!(pokemon.species(), env).clone();
+        let species = get_value_call_getter!(pokemon.species(), env);
-        wasm_ok(ExternRef::<dyn Species>::func_new(&env, &species))
+        wasm_ok(ExternRef::<dyn Species>::func_new(&env, (&species).into()))
     }
 
     fn pokemon_get_weight(
@@ -134,11 +139,11 @@ register! {
         pokemon: ExternRef<Pokemon>,
         index: u32
     ) -> WasmResult<ExternRef<LearnedMove>> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let read_lock = pokemon.learned_moves().read();
         let mv = read_lock.get(index as usize);
         wasm_ok(if let Some(Some(mv)) = mv {
-            ExternRef::<LearnedMove>::func_new(&env, mv)
+            ExternRef::<LearnedMove>::func_new(&env, mv.into())
         }
         else{
             ExternRef::<LearnedMove>::null()
@@ -153,7 +158,7 @@ register! {
         self_inflicted: u8
     ) -> WasmResult<u8> {
         unsafe{
-            let pokemon = get_value_arc!(pokemon, env);
+            let pokemon = get_value!(pokemon, env);
             let res = try_wasm!(pokemon.change_stat_boost(transmute(stat), amount, self_inflicted == 1), env);
             wasm_ok(u8::from(res))
         }
@@ -163,11 +168,9 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<Battle>> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if let Some(battle) = pokemon.get_battle() {
-            let r = ExternRef::func_new(&env, &battle);
+            ExternRef::func_new(&env, (&battle).into())
-            std::mem::forget(battle);
-            r
         } else {
             ExternRef::null()
         })
@@ -177,7 +180,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if let Some(i) = pokemon.get_battle_index() {
             i
         } else {
@@ -189,7 +192,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if let Some(i) = pokemon.get_battle_side_index() {
             i
         } else {
@@ -201,10 +204,10 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Item>> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let read_lock = pokemon.held_item().read();
         wasm_ok(if let Some(item) = read_lock.as_ref() {
-            ExternRef::<dyn Item>::func_new(&env, item.as_ref())
+            ExternRef::<dyn Item>::func_new(&env, item.into())
         } else {
             ExternRef::<dyn Item>::null()
         })
@@ -217,7 +220,7 @@ register! {
     ) -> WasmResult<u8> {
         let name : *mut c_char = env.data().data().get_raw_pointer(name);
         let name = unsafe { CStr::from_ptr(name) };
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(u8::from(pokemon.has_held_item(&name.into())))
     }
 
@@ -227,7 +230,7 @@ register! {
         amount: u32,
         allow_revive: u8
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(u8::from(pokemon.heal(amount, allow_revive == 1)))
     }
 
@@ -248,14 +251,16 @@ register! {
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Ability>> {
         let active_ability = get_value_call_getter!(pokemon.active_ability(), env);
-        wasm_ok(ExternRef::<dyn Ability>::func_new(&env, &active_ability))
+        let active_ability = try_wasm!(active_ability, env);
+        wasm_ok(ExternRef::<dyn Ability>::func_new(&env, (&active_ability).into()))
     }
 
     fn pokemon_get_real_ability(
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u16> {
-        let index = get_value_call_getter!(pokemon.real_ability(), env);
+        let pokemon = get_value!(pokemon, env);
+        let index = pokemon.real_ability();
         let t: (u8, u8) = (if index.hidden { 1 } else { 0 }, index.index);
         let r: u16 = unsafe { transmute(t) };
         wasm_ok(r)
@@ -265,7 +270,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if pokemon.is_ability_overriden() { 1 } else { 0 })
     }
 
@@ -273,7 +278,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if pokemon.allowed_experience_gain() { 1 } else { 0 })
     }
 
@@ -281,7 +286,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if pokemon.is_usable() { 1 } else { 0 })
     }
 
@@ -292,10 +297,10 @@ register! {
         item: ExternRef<dyn Item>
     ) -> WasmResult<ExternRef<dyn Item>> {
         let item = get_value_arc!(item, env);
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let old_item = pokemon.set_held_item(&item);
         wasm_ok(if let Some(old_item) = old_item {
-            ExternRef::<dyn Item>::func_new(&env, &old_item)
+            ExternRef::<dyn Item>::func_new(&env, (&old_item).into())
         } else {
             ExternRef::null()
         })
@@ -305,10 +310,10 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Item>> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let old_item = pokemon.remove_held_item();
         wasm_ok(if let Some(old_item) = old_item {
-            ExternRef::<dyn Item>::func_new(&env, &old_item)
+            ExternRef::<dyn Item>::func_new(&env, (&old_item).into())
         } else {
             ExternRef::<dyn Item>::null()
         })
@@ -318,7 +323,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let res = try_wasm!(pokemon.consume_held_item(), env);
         wasm_ok(if res { 1 } else { 0 })
     }
@@ -327,7 +332,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>
     ) -> WasmResult<u32> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let len = pokemon.types().len();
         wasm_ok(len as u32)
     }
@@ -337,7 +342,7 @@ register! {
         pokemon: ExternRef<Pokemon>,
         index: u32
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let types = pokemon.types();
         let type_v = types.get_res(index as usize);
         match type_v {
@@ -351,7 +356,7 @@ register! {
         pokemon: ExternRef<Pokemon>,
         t: u8
     ) -> WasmResult<u8> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         wasm_ok(if pokemon.types().contains(&t.into()) { 1 } else { 0 })
     }
 
@@ -398,8 +403,9 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Nature>> {
-        let nature = get_value_call_getter!(pokemon.nature(), env);
+        let pokemon = get_value!(pokemon, env);
-        wasm_ok(ExternRef::<dyn Nature>::func_new(&env, nature))
+        let nature = pokemon.nature();
+        wasm_ok(ExternRef::<dyn Nature>::func_new(&env, nature.into()))
     }
 
     fn pokemon_get_form(
@@ -407,7 +413,7 @@ register! {
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Form>> {
         let form = get_value_call_getter!(pokemon.form(), env);
-        wasm_ok(ExternRef::<dyn Form>::func_new(&env, &form))
+        wasm_ok(ExternRef::<dyn Form>::func_new(&env, (&form).into()))
     }
 
     fn pokemon_get_display_species(
@@ -415,7 +421,7 @@ register! {
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Species>> {
         let display_species = get_value_call_getter!(pokemon.display_species(), env);
-        wasm_ok(ExternRef::<dyn Species>::func_new(&env, &display_species))
+        wasm_ok(ExternRef::<dyn Species>::func_new(&env, (&display_species).into()))
     }
 
     fn pokemon_get_display_form(
@@ -423,7 +429,7 @@ register! {
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<ExternRef<dyn Form>> {
         let display_form = get_value_call_getter!(pokemon.display_form(), env);
-        wasm_ok(ExternRef::<dyn Form>::func_new(&env, &display_form))
+        wasm_ok(ExternRef::<dyn Form>::func_new(&env, (&display_form).into()))
     }
 
     fn pokemon_get_level(
@@ -458,7 +464,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u32> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let nickname = pokemon.nickname();
         if let Some(nickname) = nickname {
             let nickname: CString =  match CString::new(nickname.as_str()) {
@@ -482,7 +488,7 @@ register! {
         name_ptr: u32
     ) -> WasmResult<u32> {
         unsafe {
-            let pokemon = get_value_arc!(pokemon, env);
+            let pokemon = get_value!(pokemon, env);
             let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
             let script = try_wasm!(pokemon.add_volatile_script(&c_name.as_ref().into()), env);
             if let Some(script) = script {
@@ -499,7 +505,7 @@ register! {
         pokemon: ExternRef<Pokemon>,
         script_ptr: u32
     ) -> WasmResult<u32> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         unsafe{
             let env_data = env.data().data();
             let name_ptr = match try_wasm!(env_data.script_function_cache().script_get_name(&env_data), env).call(&mut env_data.store_mut(), script_ptr){
@@ -507,14 +513,14 @@ register! {
                 Err(e) => return wasm_err::<u32>(e.into(), &env)
             };
             let c_name: &CStr = CStr::from_ptr(env_data.get_raw_pointer(name_ptr));
-            let script = try_wasm!(env_data.setup_script(script_ptr, ScriptCategory::Pokemon, &c_name.as_ref().into(), pokemon.as_ref().into()), env);
+            let script = try_wasm!(env_data.setup_script(script_ptr, ScriptCategory::Pokemon, &c_name.as_ref().into(), (&pokemon).into()), env);
             try_wasm!(env_data.script_function_cache().dealloc_cstring(&env_data, name_ptr), env);
 
             if let Some(script) = script {
                 let script = try_wasm!(pokemon.add_volatile_script_with_script(script), env);
                 let s = match script.as_ref() {
                     Some(s) => s,
-                    None => return wasm_err::<u32>(anyhow!("Unable to get script").into(), &env)
+                    None => return wasm_err::<u32>(anyhow!("Unable to get script"), &env)
                 };
                 let s = try_wasm!(s.get_as::<WebAssemblyScript>(), env);
                 wasm_ok(s.get_wasm_pointer())
@@ -531,7 +537,7 @@ register! {
     ) -> WasmResult<u8> {
         unsafe {
             let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
-            let pokemon = get_value_arc!(pokemon, env);
+            let pokemon = get_value!(pokemon, env);
             wasm_ok(u8::from(pokemon.has_volatile_script(&c_name.as_ref().into())))
         }
     }
@@ -543,7 +549,7 @@ register! {
     ) -> WasmResult<u32> {
         unsafe {
             let c_name = CStr::from_ptr(env.data().data().get_raw_pointer(name_ptr));
-            let pokemon = get_value_arc!(pokemon, env);
+            let pokemon = get_value!(pokemon, env);
             let script = pokemon.get_volatile_script(&c_name.as_ref().into());
             wasm_ok(if let Some(script) = script {
                 let script = try_wasm!(script.get_as::<WebAssemblyScript>(), env);
@@ -564,7 +570,7 @@ register! {
             let pokemon = get_value_void!(pokemon, env);
             match pokemon.remove_volatile_script(&c_name.as_ref().into()) {
                 Ok(_) => WasmVoidResult::ok(),
-                Err(e) => WasmVoidResult::err(e.into(), &env)
+                Err(e) => WasmVoidResult::err(e, &env)
             }
         }
     }
@@ -573,7 +579,7 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         pokemon: ExternRef<Pokemon>,
     ) -> WasmResult<u32> {
-        let pokemon = get_value_arc!(pokemon, env);
+        let pokemon = get_value!(pokemon, env);
         let script = pokemon.ability_script();
         if script.is_any() {
             let script = try_wasm!(script.get_as::<WebAssemblyScript>(), env);

src/script_implementations/wasm/export_registry/dynamic_data/turn_choice.rs

@@ -1,14 +1,12 @@
 use crate::dynamic_data::{LearnedMove, Pokemon, TurnChoice};
-use crate::script_implementations::wasm::export_registry::wasm_result::{
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value_arc, get_value_arc_void, wasm_err};
-    get_value, get_value_call_getter, get_value_void, wasm_err,
-};
 use crate::script_implementations::wasm::export_registry::{
     register, wasm_ok, WasmResult, WasmVoidResult, WasmVoidResultExtension,
 };
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
-use anyhow_ext::Context;
+use std::ops::Deref;
 use wasmer::FunctionEnvMut;
 
 register! {
@@ -17,16 +15,16 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<ExternRef<Pokemon>> {
-        let user = get_value_call_getter!(turn_choice.user(), &env);
+        let turn_choice = get_value_arc!(turn_choice, env);
-        wasm_ok(ExternRef::func_new(&env, user))
+        wasm_ok(ExternRef::func_new(&env, turn_choice.user().into()))
     }
 
     fn turn_choice_get_kind(
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<u8> {
-        let turn_choice = get_value!(turn_choice, env);
+        let turn_choice = get_value_arc!(turn_choice, env);
-        wasm_ok(match turn_choice {
+        wasm_ok(match turn_choice.deref() {
             TurnChoice::Move(_) => 0,
             TurnChoice::Item(_) => 1,
             TurnChoice::Switch(_) => 2,
@@ -39,21 +37,23 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<u32> {
-        wasm_ok(get_value_call_getter!(turn_choice.speed(), &env))
+        let turn_choice = get_value_arc!(turn_choice, env);
+        wasm_ok(turn_choice.speed())
     }
 
     fn turn_choice_has_failed(
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<u8> {
-        wasm_ok(if get_value_call_getter!(turn_choice.has_failed(), &env) { 1 } else { 0 })
+        let turn_choice = get_value_arc!(turn_choice, env);
+        wasm_ok(if turn_choice.has_failed() { 1 } else { 0 })
     }
 
     fn turn_choice_fail(
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmVoidResult {
-        let turn_choice = get_value_void!(turn_choice, env);
+        let turn_choice = get_value_arc_void!(turn_choice, env);
         turn_choice.fail();
         WasmVoidResult::ok()
     }
@@ -63,9 +63,9 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<i8> {
-        return match turn_choice.value_func(&env) {
+        return match turn_choice.value_func_arc(&env) {
             Ok(v) => {
-                match v {
+                match v.deref() {
                     TurnChoice::Move(m) => wasm_ok(m.priority()),
                     _ => wasm_err::<i8>(anyhow_ext::anyhow!("Invalid turn choice"), &env)
                 }
@@ -78,10 +78,10 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<ExternRef<LearnedMove>> {
-        return match turn_choice.value_func(&env) {
+        return match turn_choice.value_func_arc(&env) {
             Ok(v) => {
-                match v {
+                match v.deref() {
-                    TurnChoice::Move(m) => wasm_ok(ExternRef::<LearnedMove>::func_new(&env, m.used_move())),
+                    TurnChoice::Move(m) => wasm_ok(ExternRef::func_new(&env, m.used_move().into())),
                     _ => wasm_err::<ExternRef<LearnedMove>>(anyhow_ext::anyhow!("Invalid turn choice"), &env)
                 }
             },
@@ -93,9 +93,9 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<u8> {
-        return match turn_choice.value_func(&env) {
+        return match turn_choice.value_func_arc(&env) {
             Ok(v) => {
-                match v {
+                match v.deref() {
                     TurnChoice::Move(m) => wasm_ok(m.target_side()),
                     _ => wasm_err::<u8>(anyhow_ext::anyhow!("Invalid turn choice"), &env)
                 }
@@ -108,9 +108,9 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<u8> {
-        return match turn_choice.value_func(&env) {
+        return match turn_choice.value_func_arc(&env) {
             Ok(v) => {
-                match v {
+                match v.deref() {
                     TurnChoice::Move(m) => wasm_ok(m.target_index()),
                     _ => wasm_err::<u8>(anyhow_ext::anyhow!("Invalid turn choice"), &env)
                 }
@@ -123,9 +123,9 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         turn_choice: ExternRef<TurnChoice>,
     ) -> WasmResult<u32> {
-        return match turn_choice.value_func(&env) {
+        return match turn_choice.value_func_arc(&env) {
             Ok(v) => {
-                match v {
+                match v.deref() {
                     TurnChoice::Move(d) => {
                         if let Some(script) = d.script().get() {
                             let read_lock = script.read();

src/script_implementations/wasm/export_registry/mod.rs

@@ -1,21 +1,25 @@
 use anyhow_ext::anyhow;
 use std::ffi::{c_char, CStr, CString};
 use std::mem::{align_of, forget};
+use std::ops::Deref;
 use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};
 
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::EffectParameter;
 use crate::StringKey;
-use anyhow_ext::Context;
 
 /// Dynamic data registration
 mod dynamic_data;
 /// Static data registration
 mod static_data;
+/// Handling for opaque handles passed to WASM
 mod wasm_object;
+/// Result types for WASM
 mod wasm_result;
 
+#[doc(inline)]
+pub(super) use wasm_object::*;
 #[doc(inline)]
 pub use wasm_result::*;
 
@@ -71,7 +75,6 @@ pub(crate) fn register_webassembly_funcs(
 ) {
     register_func_with_env!(imports, store, _print, env);
     register_func_with_env!(imports, store, _error, env);
-    register_func_with_env!(imports, store, _vec_extern_ref_get_value, env);
 
     static_data::register(imports, store, env);
     dynamic_data::register(imports, store, env);
@@ -90,7 +93,9 @@ fn _print(env: FunctionEnvMut<WebAssemblyEnv>, p: u32) {
     unsafe {
         let mem: *mut c_char = env.data().data().get_raw_pointer(p);
         let s = CStr::from_ptr(mem);
-        println!("{}", s.to_str().unwrap());
+        if let Ok(v) = s.to_str() {
+            println!("{}", v);
+        }
     }
 }
 
@@ -100,19 +105,11 @@ fn _error(env: FunctionEnvMut<WebAssemblyEnv>, message: u32) {
     unsafe {
         let mem: *const c_char = env.data().data().get_raw_pointer(message);
         let message_str = CStr::from_ptr(mem);
-        panic!("WASM Error: {}", message_str.to_str().unwrap());
+        #[allow(clippy::panic)]
+        if let Ok(v) = message_str.to_str() {
+            panic!("WASM Error: {}", v);
         }
     }
-
-/// Get a single item from an earlier passed VecExternRef
-fn _vec_extern_ref_get_value(env: FunctionEnvMut<WebAssemblyEnv>, reference: u32, index: u32) -> WasmResult<u32> {
-    let res = try_wasm!(
-        env.data()
-            .data()
-            .get_extern_vec_ref_extern_ref(reference as usize, index as usize),
-        env
-    );
-    wasm_ok(res as u32)
 }
 
 /// Gets the hash value of a StringKey.
@@ -123,7 +120,7 @@ fn string_key_get_hash(env: FunctionEnvMut<WebAssemblyEnv>, string_key: ExternRe
 
 /// Get a null-terminated C string from a StringKey. Note that this involves a copy into WASM
 /// memory, so this is relatively heavy.
-fn string_key_get_str(env: FunctionEnvMut<WebAssemblyEnv>, string_key: ExternRef<StringKey>) -> (u32, u32) {
+fn string_key_get_str(env: FunctionEnvMut<WebAssemblyEnv>, string_key: ExternRef<StringKey>) -> WasmResult<u32> {
     let value = get_value!(string_key, env);
     let string_key = value.str();
     let wasm_string_ptr = try_wasm!(
@@ -147,8 +144,8 @@ fn effect_parameter_get_type(
     env: FunctionEnvMut<WebAssemblyEnv>,
     parameter: ExternRef<EffectParameter>,
 ) -> WasmResult<u8> {
-    let value = get_value!(parameter, env);
+    let value = get_value_arc!(parameter, env);
-    wasm_ok(match value {
+    wasm_ok(match value.deref() {
         EffectParameter::Bool(_, _) => 1,
         EffectParameter::Int(_, _) => 2,
         EffectParameter::Float(_, _) => 3,
@@ -161,8 +158,8 @@ fn effect_parameter_as_bool(
     env: FunctionEnvMut<WebAssemblyEnv>,
     parameter: ExternRef<EffectParameter>,
 ) -> WasmResult<u8> {
-    let value = get_value!(parameter, env);
+    let value = get_value_arc!(parameter, env);
-    match value {
+    match value.deref() {
         EffectParameter::Bool(_, b) => wasm_ok(<u8 as From<bool>>::from(*b)),
         _ => wasm_err::<u8>(anyhow!("Unexpected parameter type. Expected bool, got {}", value), &env),
     }
@@ -173,8 +170,8 @@ fn effect_parameter_as_int(
     env: FunctionEnvMut<WebAssemblyEnv>,
     parameter: ExternRef<EffectParameter>,
 ) -> WasmResult<i64> {
-    let value = get_value!(parameter, env);
+    let value = get_value_arc!(parameter, env);
-    match value {
+    match value.deref() {
         EffectParameter::Int(_, i) => wasm_ok(*i),
         _ => wasm_err::<i64>(anyhow!("Unexpected parameter type. Expected int, got {}", value), &env),
     }
@@ -185,8 +182,8 @@ fn effect_parameter_as_float(
     env: FunctionEnvMut<WebAssemblyEnv>,
     parameter: ExternRef<EffectParameter>,
 ) -> WasmResult<f32> {
-    let value = get_value!(parameter, env);
+    let value = get_value_arc!(parameter, env);
-    match value {
+    match value.deref() {
         EffectParameter::Float(_, f) => wasm_ok(*f),
         _ => wasm_err::<f32>(
             anyhow!("Unexpected parameter type. Expected float, got {}", value),
@@ -200,9 +197,9 @@ fn effect_parameter_as_string(
     env: FunctionEnvMut<WebAssemblyEnv>,
     parameter: ExternRef<EffectParameter>,
 ) -> WasmResult<ExternRef<StringKey>> {
-    let value = get_value!(parameter, env);
+    let value = get_value_arc!(parameter, env);
-    match value {
+    match value.deref() {
-        EffectParameter::Float(_, s) => wasm_ok(ExternRef::<StringKey>::func_new(&env, s)),
+        EffectParameter::String(_, s) => wasm_ok(ExternRef::<StringKey>::func_new(&env, s.clone().into())),
         _ => wasm_err::<ExternRef<StringKey>>(
             anyhow!("Unexpected parameter type. Expected string, got {}", value),
             &env,

src/script_implementations/wasm/export_registry/static_data/ability.rs

@@ -1,6 +1,7 @@
-use crate::script_implementations::wasm::export_registry::register;
+use crate::script_implementations::wasm::export_registry::wasm_result::get_value_arc;
 use crate::script_implementations::wasm::export_registry::FunctionEnvMut;
-use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
+use crate::script_implementations::wasm::export_registry::{register, try_wasm, wasm_ok, WasmResult};
+use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::{Ability, EffectParameter};
 use crate::StringKey;
@@ -10,25 +11,32 @@ register! {
 fn ability_get_name(
     env: FunctionEnvMut<WebAssemblyEnv>,
     ability: ExternRef<dyn Ability>
-) -> ExternRef<StringKey> {
+) -> WasmResult<ExternRef<StringKey>> {
-        let ability = ability.value_func_arc(&env).unwrap();
+    let ability = get_value_arc!(ability, env);
-        ExternRef::func_new(&env, ability.name())
+    wasm_ok(ExternRef::func_new(&env, ability.name().clone().into()))
 }
 
 fn ability_get_effect(
     env: FunctionEnvMut<WebAssemblyEnv>,
     ability: ExternRef<dyn Ability>
-) -> ExternRef<StringKey> {
+) -> WasmResult<ExternRef<StringKey>> {
-        let ability = ability.value_func_arc(&env).unwrap();
+    let ability = get_value_arc!(ability, env);
-        ExternRef::func_new(&env, ability.effect())
+    wasm_ok(ExternRef::func_new(&env, ability.effect().clone().into()))
 }
 
 fn ability_get_parameters(
     env: FunctionEnvMut<WebAssemblyEnv>,
     ability: ExternRef<dyn Ability>
-) -> VecExternRef<EffectParameter> {
+) -> WasmResult<u64> {
-        let ability = ability.value_func_arc(&env).unwrap();
+    let ability = get_value_arc!(ability, env);
-        VecExternRef::new(env.data().data().as_ref(), ability.parameters())
+    let parameters = ability.parameters();
+    let mut vec : Vec<u32> = Vec::with_capacity(parameters.len());
+    for parameter in parameters {
+        vec.push(ExternRef::<EffectParameter>::func_new(&env, parameter.into()).index() as u32);
+    }
+    let wasm_ptr = try_wasm!(env.data().data().copy_value_vec_to_wasm(&vec), env);
+    let r: u64 = unsafe { std::mem::transmute((wasm_ptr, vec.len() as u32)) };
+    wasm_ok(r)
 }
 
 }

src/script_implementations/wasm/export_registry/static_data/form.rs

@@ -1,26 +1,25 @@
-use crate::script_implementations::wasm::export_registry::wasm_result::try_wasm;
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value_arc, try_wasm};
 use crate::script_implementations::wasm::export_registry::{register, wasm_ok, FunctionEnvMut, WasmResult};
-use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
+use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::{Form, StatisticSet};
 use crate::StringKey;
-use anyhow_ext::Context;
 
 register! {
 
 fn form_get_name(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> ExternRef<StringKey> {
+) -> WasmResult<ExternRef<StringKey>> {
-        let form = form.value_func_arc(&env).unwrap();
+        let form = get_value_arc!(form, env);
-        ExternRef::func_new(&env, form.name())
+        wasm_ok(ExternRef::func_new(&env, form.name().clone().into()))
 }
 
 fn form_get_types(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
 ) -> WasmResult<u64> {
-        let form = form.value_func_arc(&env).unwrap();
+        let form = get_value_arc!(form, env);
         let vec = form.types();
         let wasm_ptr = try_wasm!(env.data().data().copy_value_vec_to_wasm(vec), env);
         let r: u64 = unsafe { std::mem::transmute((wasm_ptr, vec.len() as u32)) };
@@ -30,54 +29,69 @@ fn form_get_types(
 fn form_get_height(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> f32 {
+) -> WasmResult<f32> {
-        form.value_func_arc(&env).unwrap().height()
+        wasm_ok(get_value_arc!(form, env).height())
 }
 
 fn form_get_weight(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> f32 {
+) -> WasmResult<f32> {
-        form.value_func_arc(&env).unwrap().weight()
+        wasm_ok(get_value_arc!(form, env).weight())
 }
 
 fn form_get_base_experience(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> u32 {
+) -> WasmResult<u32> {
-        form.value_func_arc(&env).unwrap().base_experience()
+        wasm_ok(get_value_arc!(form, env).base_experience())
 }
 
 fn form_get_base_stats(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> ExternRef<StatisticSet<u16>> {
+) -> WasmResult<ExternRef<StatisticSet<u16>>> {
-        let form = form.value_func_arc(&env).unwrap();
+        let form = get_value_arc!(form, env);
-        ExternRef::func_new(&env, form.base_stats())
+        wasm_ok(ExternRef::func_new(&env, form.base_stats().into()))
 }
 
 fn form_get_abilities(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> VecExternRef<StringKey> {
+) -> WasmResult<u64> {
-        let form = form.value_func_arc(&env).unwrap();
+        let form = get_value_arc!(form, env);
-        VecExternRef::new(env.data().data().as_ref(), form.abilities())
+        let abilities = form.abilities();
+        let mut ability_refs : Vec<u32> = Vec::with_capacity(abilities.len());
+        for ability in abilities {
+            ability_refs.push(ExternRef::<StringKey>::func_new(&env, ability.clone().into()).index() as u32);
+        }
+        let wasm_ptr = try_wasm!(env.data().data().copy_value_vec_to_wasm(&ability_refs), env);
+        let r: u64 = unsafe { std::mem::transmute((wasm_ptr, ability_refs.len() as u32)) };
+        wasm_ok(r)
 }
 
 fn form_get_hidden_abilities(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>
-) -> VecExternRef<StringKey> {
+) -> WasmResult<u64> {
-        let form = form.value_func_arc(&env).unwrap();
+        let form = get_value_arc!(form, env);
-        VecExternRef::new(env.data().data().as_ref(), form.hidden_abilities())
+        let abilities = form.hidden_abilities();
+        let mut ability_refs : Vec<u32> = Vec::with_capacity(abilities.len());
+        for ability in abilities {
+            ability_refs.push(ExternRef::<StringKey>::func_new(&env, ability.clone().into()).index() as u32);
+        }
+        let wasm_ptr = try_wasm!(env.data().data().copy_value_vec_to_wasm(&ability_refs), env);
+        let r: u64 = unsafe { std::mem::transmute((wasm_ptr, ability_refs.len() as u32)) };
+        wasm_ok(r)
 }
 
 fn form_has_flag_by_hash(
     env: FunctionEnvMut<WebAssemblyEnv>,
     form: ExternRef<dyn Form>,
     flag_hash: u32,
-) -> u8 {
+) -> WasmResult<u8> {
-        if form.value_func_arc(&env).unwrap().has_flag_by_hash(flag_hash) { 1 } else { 0 }
+    let form = get_value_arc!(form, env);
+    wasm_ok(if form.has_flag_by_hash(flag_hash) { 1 } else { 0 })
 }
 
 

src/script_implementations/wasm/export_registry/static_data/item.rs

@@ -1,4 +1,5 @@
-use crate::script_implementations::wasm::export_registry::register;
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value, get_value_arc, wasm_ok};
+use crate::script_implementations::wasm::export_registry::{register, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::Item;
@@ -12,60 +13,67 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         lib: ExternRef<dyn ItemLibrary>,
         string_key: ExternRef<StringKey>,
-    ) -> ExternRef<dyn Item> {
+    ) -> WasmResult<ExternRef<dyn Item>> {
-        let lib = lib.value_func_box(&env).unwrap();
+        let lib = get_value_arc!(lib, env);
-        let m = lib.get(string_key.value_func(&env).unwrap());
+        let string_key = get_value!(string_key, env);
-        if let Some(v) = m {
+        let m = lib.get(&string_key);
-            ExternRef::func_new(&env, &v)
+        wasm_ok(if let Some(v) = m {
+            ExternRef::func_new(&env, (&v).into())
         } else {
             ExternRef::null()
-        }
+        })
     }
 
-    fn item_library_get_item_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, lib: ExternRef<dyn ItemLibrary>, hash: u32) -> ExternRef<dyn Item> {
+    fn item_library_get_item_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, lib: ExternRef<dyn ItemLibrary>, hash: u32) -> WasmResult<ExternRef<dyn Item>> {
-        let lib = lib.value_func_box(&env).unwrap();
+        let lib = get_value_arc!(lib, env);
         let m = lib.get_by_hash(hash);
-        if let Some(v) = m {
+        wasm_ok(if let Some(v) = m {
-            ExternRef::func_new(&env, &v)
+            ExternRef::func_new(&env, (&v).into())
         } else {
             ExternRef::null()
-        }
+        })
     }
 
     fn item_get_price(
         env: FunctionEnvMut<WebAssemblyEnv>,
         item: ExternRef<dyn Item>,
-    ) -> i32 {
+    ) -> WasmResult<i32> {
-        item.value_func_arc(&env).unwrap().price()
+        let item = get_value_arc!(item, env);
+        wasm_ok(item.price())
     }
 
     fn item_get_name(
         env: FunctionEnvMut<WebAssemblyEnv>,
         item: ExternRef<dyn Item>,
-    ) -> ExternRef<StringKey> {
+    ) -> WasmResult<ExternRef<StringKey>> {
-        ExternRef::func_new(&env, item.value_func_arc(&env).unwrap().name())
+        let item = get_value_arc!(item, env);
+        wasm_ok(ExternRef::func_new(&env, item.name().clone().into()))
     }
 
     fn item_get_category(
         env: FunctionEnvMut<WebAssemblyEnv>,
         item: ExternRef<dyn Item>,
-    ) -> u8 {
+    ) -> WasmResult<u8> {
-        unsafe { transmute(item.value_func_arc(&env).unwrap().category()) }
+        let item = get_value_arc!(item, env);
+        unsafe { wasm_ok(transmute(item.category())) }
     }
 
     fn item_get_battle_category(
         env: FunctionEnvMut<WebAssemblyEnv>,
         item: ExternRef<dyn Item>,
-    ) -> u8 {
+    ) -> WasmResult<u8> {
-        unsafe { transmute(item.value_func_arc(&env).unwrap().battle_category()) }
+        let item = get_value_arc!(item, env);
+        unsafe { wasm_ok(transmute(item.battle_category())) }
     }
 
     fn item_has_flag(
         env: FunctionEnvMut<WebAssemblyEnv>,
         item: ExternRef<dyn Item>,
         key: ExternRef<StringKey>
-    ) -> u8 {
+    ) -> WasmResult<u8> {
-        if item.value_func_arc(&env).unwrap().has_flag(key.value_func(&env).unwrap()) { 1 } else { 0 }
+        let item = get_value_arc!(item, env);
+        let key = get_value!(key, env);
+        wasm_ok(if item.has_flag(&key) { 1 } else { 0 })
     }
 
 }

src/script_implementations/wasm/export_registry/static_data/mod.rs

@@ -3,7 +3,7 @@ use wasmer::{FunctionEnv, FunctionEnvMut, Imports, StoreMut};
 
 use crate::defines::LevelInt;
 use crate::script_implementations::wasm::export_registry::wasm_result::{
-    get_value, get_value_void, wasm_ok, WasmResult,
+    get_value_arc, get_value_arc_void, wasm_ok, WasmResult,
 };
 use crate::script_implementations::wasm::export_registry::{register, WasmVoidResult, WasmVoidResultExtension};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
@@ -12,7 +12,6 @@ use crate::static_data::{
     ItemLibrary, LibrarySettings, MoveLibrary, SpeciesLibrary, StaticData, StaticStatisticSet, StatisticSet,
     TypeLibrary,
 };
-use anyhow_ext::Context;
 
 /// Ability data registration
 mod ability;
@@ -30,52 +29,59 @@ mod species;
 mod types;
 
 register! {
-    fn static_data_get_move_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn StaticData>) -> ExternRef<dyn MoveLibrary> {
+    fn static_data_get_move_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn StaticData>) -> WasmResult<ExternRef<dyn MoveLibrary>> {
-        ExternRef::func_new(&env, data_library.value_func_box(&env).unwrap().moves())
+        let data_library = get_value_arc!(data_library, env);
+        wasm_ok(ExternRef::func_new(&env, data_library.moves().into()))
     }
 
     fn static_data_get_species_library(
         env: FunctionEnvMut<WebAssemblyEnv>,
         data_library: ExternRef<dyn StaticData>,
-    ) -> ExternRef<dyn SpeciesLibrary> {
+    ) -> WasmResult<ExternRef<dyn SpeciesLibrary>> {
-        ExternRef::func_new(&env, data_library.value_func_box(&env).unwrap().species())
+        let data_library = get_value_arc!(data_library, env);
+        wasm_ok(ExternRef::func_new(&env, data_library.species().into()))
     }
 
-    fn static_data_get_item_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn StaticData>) -> ExternRef<dyn ItemLibrary> {
+    fn static_data_get_item_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn StaticData>) -> WasmResult<ExternRef<dyn ItemLibrary>> {
-        ExternRef::func_new(&env, data_library.value_func_box(&env).unwrap().items())
+        let data_library = get_value_arc!(data_library, env);
+        wasm_ok(ExternRef::func_new(&env, data_library.items().into()))
     }
 
-    fn static_data_get_type_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn StaticData>) -> ExternRef<dyn TypeLibrary> {
+    fn static_data_get_type_library(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn StaticData>) -> WasmResult<ExternRef<dyn TypeLibrary>> {
-        ExternRef::func_new(&env, data_library.value_func_box(&env).unwrap().types())
+        let data_library = get_value_arc!(data_library, env);
+        wasm_ok(ExternRef::func_new(&env, data_library.types().into()))
     }
 
     fn static_data_get_library_settings(
         env: FunctionEnvMut<WebAssemblyEnv>,
         data_library: ExternRef<dyn StaticData>,
-    ) -> ExternRef<dyn LibrarySettings> {
+    ) -> WasmResult<ExternRef<dyn LibrarySettings>> {
-        ExternRef::func_new(&env, data_library.value_func_box(&env).unwrap().settings())
+        let data_library = get_value_arc!(data_library, env);
+        wasm_ok(ExternRef::func_new(&env, data_library.settings().into()))
     }
 
-    fn library_settings_get_maximum_level(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn LibrarySettings>) -> LevelInt {
+    fn library_settings_get_maximum_level(env: FunctionEnvMut<WebAssemblyEnv>, data_library: ExternRef<dyn LibrarySettings>) -> WasmResult<LevelInt> {
-        data_library.value_func_box(&env).unwrap().maximum_level()
+        let data_library = get_value_arc!(data_library, env);
+        wasm_ok(data_library.maximum_level())
     }
 
-    fn static_statistics_set_get_stat(env: FunctionEnvMut<WebAssemblyEnv>, statistics_set: ExternRef<StaticStatisticSet<u16>>, stat: u8) -> u32 {
+    fn static_statistics_set_get_stat(env: FunctionEnvMut<WebAssemblyEnv>, statistics_set: ExternRef<StaticStatisticSet<u16>>, stat: u8) -> WasmResult<u32> {
         unsafe {
-            statistics_set.value_func(&env).unwrap().get_stat(transmute(stat)) as u32
+            let statistics_set = get_value_arc!(statistics_set, env);
+            wasm_ok(statistics_set.get_stat(transmute(stat)) as u32)
         }
     }
 
     fn statistic_set_get(env: FunctionEnvMut<WebAssemblyEnv>, statistics_set: ExternRef<StatisticSet<u32>>, stat: u8) -> WasmResult<i64> {
         unsafe {
-            let statistics_set = get_value!(statistics_set, env);
+            let statistics_set = get_value_arc!(statistics_set, env);
             wasm_ok(statistics_set.get_stat(transmute(stat)) as i64)
         }
     }
 
     fn statistic_set_set(env: FunctionEnvMut<WebAssemblyEnv>, statistics_set: ExternRef<StatisticSet<u32>>, stat: u8, value: u64) -> WasmVoidResult {
         unsafe {
-            let statistics_set = get_value_void!(statistics_set, env);
+            let statistics_set = get_value_arc_void!(statistics_set, env);
             statistics_set.set_stat(transmute(stat), value as u32);
             WasmVoidResult::ok()
         }
@@ -83,7 +89,7 @@ register! {
 
     fn statistic_set_increase_stat(env: FunctionEnvMut<WebAssemblyEnv>, statistics_set: ExternRef<StatisticSet<u32>>, stat: u8, value: u64) -> WasmVoidResult {
         unsafe {
-            let statistics_set = get_value_void!(statistics_set, env);
+            let statistics_set = get_value_arc_void!(statistics_set, env);
             statistics_set.increase_stat(transmute(stat), value as u32);
             WasmVoidResult::ok()
         }
@@ -91,7 +97,7 @@ register! {
 
     fn statistic_set_decrease_stat(env: FunctionEnvMut<WebAssemblyEnv>, statistics_set: ExternRef<StatisticSet<u32>>, stat: u8, value: u64) -> WasmVoidResult {
         unsafe {
-            let statistics_set = get_value_void!(statistics_set, env);
+            let statistics_set = get_value_arc_void!(statistics_set, env);
             statistics_set.decrease_stat(transmute(stat), value as u32);
             WasmVoidResult::ok()
         }

src/script_implementations/wasm/export_registry/static_data/moves.rs

@@ -1,4 +1,5 @@
-use crate::script_implementations::wasm::export_registry::register;
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value, get_value_arc, wasm_ok};
+use crate::script_implementations::wasm::export_registry::{register, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::{MoveData, MoveLibrary};
@@ -10,55 +11,67 @@ fn move_library_get_move(
     env: FunctionEnvMut<WebAssemblyEnv>,
     lib: ExternRef<dyn MoveLibrary>,
     string_key: ExternRef<StringKey>,
-) -> ExternRef<dyn MoveData> {
+) -> WasmResult<ExternRef<dyn MoveData>> {
-    let lib = lib.value_func_box(&env).unwrap();
+    let lib = get_value_arc!(lib, env);
-    let m = lib.get(string_key.value_func(&env).unwrap());
+    let string_key = get_value!(string_key, env);
-    if let Some(v) = m {
+    let m = lib.get(&string_key);
-        ExternRef::func_new(&env, &v)
+    wasm_ok(if let Some(v) = m {
+        ExternRef::func_new(&env, (&v).into())
     } else {
         ExternRef::null()
-    }
+    })
 }
 
-fn move_library_get_move_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, lib: ExternRef<dyn MoveLibrary>, hash: u32) -> ExternRef<dyn MoveData> {
+fn move_library_get_move_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, lib: ExternRef<dyn MoveLibrary>, hash: u32) -> WasmResult<ExternRef<dyn MoveData>> {
-    let lib = lib.value_func_box(&env).unwrap();
+    let lib = get_value_arc!(lib, env);
     let m = lib.get_by_hash(hash);
-    if let Some(v) = m {
+    wasm_ok(if let Some(v) = m {
-        ExternRef::func_new(&env, &v)
+        ExternRef::func_new(&env, (&v).into())
     } else {
         ExternRef::null()
-    }
+    })
 }
 
-fn move_data_get_name(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> ExternRef<StringKey> {
+fn move_data_get_name(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) ->WasmResult<ExternRef<StringKey>> {
-    ExternRef::func_new(&env, move_data.value_func_arc(&env).unwrap().name())
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(ExternRef::func_new(&env, move_data.name().clone().into()))
 }
 
-fn move_data_get_type(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> u8 {
+fn move_data_get_type(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<u8> {
-    move_data.value_func_arc(&env).unwrap().move_type().into()
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.move_type().into())
 }
-fn move_data_get_category(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> u8 {
+fn move_data_get_category(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<u8> {
-    move_data.value_func_arc(&env).unwrap().category() as u8
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.category() as u8)
 }
-fn move_data_get_base_power(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> u8 {
+fn move_data_get_base_power(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<u8> {
-    move_data.value_func_arc(&env).unwrap().base_power()
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.base_power())
 }
-fn move_data_get_accuracy(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> u8 {
+fn move_data_get_accuracy(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<u8> {
-    move_data.value_func_arc(&env).unwrap().accuracy()
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.accuracy())
 }
-fn move_data_get_base_usages(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> u8 {
+fn move_data_get_base_usages(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<u8> {
-    move_data.value_func_arc(&env).unwrap().base_usages()
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.base_usages())
 }
-fn move_data_get_target(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> u8 {
+fn move_data_get_target(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<u8> {
-    move_data.value_func_arc(&env).unwrap().target() as u8
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.target() as u8)
 }
-fn move_data_get_priority(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> i8 {
+fn move_data_get_priority(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>) -> WasmResult<i8> {
-    move_data.value_func_arc(&env).unwrap().priority()
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(move_data.priority())
 }
-fn move_data_has_flag(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>, flag: ExternRef<StringKey>) -> u8 {
+fn move_data_has_flag(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>, flag: ExternRef<StringKey>) -> WasmResult<u8> {
-    u8::from(move_data.value_func_arc(&env).unwrap().has_flag(flag.value_func(&env).unwrap()))
+    let move_data = get_value_arc!(move_data, env);
+    let flag = get_value!(flag, env);
+    wasm_ok(u8::from(move_data.has_flag(&flag)))
 }
-fn move_data_has_flag_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>, flag_hash: u32) -> u8 {
+fn move_data_has_flag_by_hash(env: FunctionEnvMut<WebAssemblyEnv>, move_data: ExternRef<dyn MoveData>, flag_hash: u32) -> WasmResult<u8> {
-    u8::from(move_data.value_func_arc(&env).unwrap().has_flag_by_hash(flag_hash))
+    let move_data = get_value_arc!(move_data, env);
+    wasm_ok(u8::from(move_data.has_flag_by_hash(flag_hash)))
 }
 }

src/script_implementations/wasm/export_registry/static_data/nature.rs

@@ -1,4 +1,5 @@
-use crate::script_implementations::wasm::export_registry::register;
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value_arc, wasm_ok};
+use crate::script_implementations::wasm::export_registry::{register, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::Nature;
@@ -9,25 +10,29 @@ register! {
 fn nature_get_increase_stat(
     env: FunctionEnvMut<WebAssemblyEnv>,
     nature: ExternRef<dyn Nature>
-) -> u8 {
+) -> WasmResult<u8> {
-    unsafe { transmute(nature.value_func_box(&env).unwrap().increased_stat()) }
+    let nature = get_value_arc!(nature, env);
+    wasm_ok(unsafe { transmute(nature.increased_stat()) })
 }
 fn nature_get_decrease_stat(
     env: FunctionEnvMut<WebAssemblyEnv>,
     nature: ExternRef<dyn Nature>
-) -> u8 {
+) -> WasmResult<u8> {
-    unsafe { transmute(nature.value_func_box(&env).unwrap().decreased_stat()) }
+    let nature = get_value_arc!(nature, env);
+    wasm_ok(unsafe { transmute(nature.decreased_stat()) })
 }
 fn nature_get_increase_modifier(
     env: FunctionEnvMut<WebAssemblyEnv>,
     nature: ExternRef<dyn Nature>
-) -> f32 {
+) -> WasmResult<f32> {
-    nature.value_func_box(&env).unwrap().increased_modifier()
+    let nature = get_value_arc!(nature, env);
+    wasm_ok(nature.increased_modifier())
 }
 fn nature_get_decrease_modifier(
     env: FunctionEnvMut<WebAssemblyEnv>,
     nature: ExternRef<dyn Nature>
-) -> f32 {
+) -> WasmResult<f32> {
-    nature.value_func_box(&env).unwrap().decreased_modifier()
+    let nature = get_value_arc!(nature, env);
+    wasm_ok(nature.decreased_modifier())
 }
 }

src/script_implementations/wasm/export_registry/static_data/species.rs

@@ -1,4 +1,5 @@
-use crate::script_implementations::wasm::export_registry::register;
+use crate::script_implementations::wasm::export_registry::wasm_result::{get_value, get_value_arc, wasm_ok};
+use crate::script_implementations::wasm::export_registry::{register, WasmResult};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
 use crate::static_data::SpeciesLibrary;
@@ -12,73 +13,78 @@ fn species_library_get_species(
     env: FunctionEnvMut<WebAssemblyEnv>,
     lib: ExternRef<dyn SpeciesLibrary>,
     string_key: ExternRef<StringKey>,
-) -> ExternRef<dyn Species> {
+) -> WasmResult<ExternRef<dyn Species>> {
-    let lib = lib.value_func_box(&env).unwrap();
+    let lib = get_value_arc!(lib, env);
-    let m = lib.get(string_key.value_func(&env).unwrap());
+    let string_key = get_value!(string_key, env);
-    if let Some(v) = m {
+    let m = lib.get(&string_key);
-        ExternRef::func_new(&env, &v)
+    wasm_ok(if let Some(v) = m {
+        ExternRef::func_new(&env, (&v).into())
     } else {
         ExternRef::null()
-    }
+    })
 }
 
 fn species_get_capture_rate(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
-) -> u8 {
+) -> WasmResult<u8> {
-    species.value_func_arc(&env).unwrap().capture_rate()
+    let species = get_value_arc!(species, env);
+    wasm_ok(species.capture_rate())
 }
 
 fn species_get_growth_rate(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
-) -> ExternRef<StringKey> {
+) -> WasmResult<ExternRef<StringKey>> {
-    let species = species.value_func_arc(&env).unwrap();
+    let species = get_value_arc!(species, env);
-    ExternRef::func_new(&env, species.growth_rate())
+    wasm_ok(ExternRef::func_new(&env, species.growth_rate().clone().into()))
 }
 
 fn species_get_gender_rate(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
-) -> f32 {
+) -> WasmResult<f32> {
-    species.value_func_arc(&env).unwrap().gender_rate()
+    let species = get_value_arc!(species, env);
+    wasm_ok(species.gender_rate())
 }
 
 fn species_get_name(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
-) -> ExternRef<StringKey> {
+) -> WasmResult<ExternRef<StringKey>> {
-    let species = species.value_func_arc(&env).unwrap();
+    let species = get_value_arc!(species, env);
-    ExternRef::func_new(&env, species.name())
+    wasm_ok(ExternRef::func_new(&env, species.name().clone().into()))
 }
 
 fn species_get_id(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
-) -> u16 {
+) -> WasmResult<u16> {
-    species.value_func_arc(&env).unwrap().id()
+    let species = get_value_arc!(species, env);
+    wasm_ok(species.id())
 }
 
 fn species_get_form_by_hash(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
     form_hash: u32
-) -> ExternRef<dyn Form> {
+) -> WasmResult<ExternRef<dyn Form>> {
-        let species = species.value_func_arc(&env).unwrap();
+    let species = get_value_arc!(species, env);
     let form = species.get_form_by_hash(form_hash);
-        if let Some(form) = form {
+    wasm_ok(if let Some(form) = form {
-            ExternRef::func_new(&env, &form)
+        ExternRef::func_new(&env, (&form).into())
     } else {
         ExternRef::null()
-        }
+    })
 }
 
 fn species_has_flag_by_hash(
     env: FunctionEnvMut<WebAssemblyEnv>,
     species: ExternRef<dyn Species>,
     flag_hash: u32
-) -> u8 {
+) -> WasmResult<u8> {
-        if species.value_func_arc(&env).unwrap().has_flag_by_hash(flag_hash) { 1 } else { 0 }
+    let species = get_value_arc!(species, env);
+    wasm_ok(if species.has_flag_by_hash(flag_hash) { 1 } else { 0 })
 }
 
 

src/script_implementations/wasm/export_registry/static_data/types.rs

@@ -1,4 +1,7 @@
 use crate::script_implementations::wasm::export_registry::register;
+use crate::script_implementations::wasm::export_registry::wasm_result::{
+    get_value, get_value_arc, try_wasm, wasm_ok, WasmResult,
+};
 use crate::script_implementations::wasm::export_registry::FunctionEnvMut;
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnv;
@@ -11,15 +14,15 @@ register! {
         env: FunctionEnvMut<WebAssemblyEnv>,
         lib: ExternRef<dyn TypeLibrary>,
         name: ExternRef<StringKey>
-    ) -> u8 {
+    ) -> WasmResult<u8> {
-        let lib = lib.value_func_arc(&env).unwrap();
+        let lib = get_value_arc!(lib, env);
-        let name = name.value_func(&env).unwrap();
+        let name = get_value!(name, env);
-        let type_id = lib.get_type_id(name);
+        let type_id = lib.get_type_id(&name);
-        if let Some(type_id) = type_id {
+        wasm_ok(if let Some(type_id) = type_id {
             type_id.into()
         } else {
             0
-        }
+        })
     }
 
     fn type_library_get_single_effectiveness(
@@ -27,9 +30,10 @@ register! {
         lib: ExternRef<dyn TypeLibrary>,
         attacking: u8,
         defending: u8
-    ) -> f32 {
+    ) -> WasmResult<f32> {
-        let lib = lib.value_func_arc(&env).unwrap();
+        let lib = get_value_arc!(lib, env);
-        lib.get_single_effectiveness(attacking.into(), defending.into()).unwrap()
+        let effectiveness = try_wasm!(lib.get_single_effectiveness(attacking.into(), defending.into()), env);
+        wasm_ok(effectiveness)
     }
 
 }

src/script_implementations/wasm/export_registry/wasm_object.rs

@@ -1 +1,449 @@
+use crate::dynamic_data::{Battle, Pokemon, WeakBattleReference, WeakBattleSideReference, WeakPokemonReference};
+use anyhow::anyhow;
+use anyhow_ext::Result;
+use std::hash::{Hash, Hasher};
+use std::sync::{Arc, Weak};
 
+#[derive(Clone)]
+#[allow(clippy::missing_docs_in_private_items)]
+pub(crate) enum WasmObject {
+    // Static data
+    StringKey(crate::StringKey),
+    EffectParameter(Weak<crate::static_data::EffectParameter>),
+
+    MoveData(Weak<dyn crate::static_data::MoveData>),
+    Species(Weak<dyn crate::static_data::Species>),
+    Form(Weak<dyn crate::static_data::Form>),
+    Item(Weak<dyn crate::static_data::Item>),
+    Ability(Weak<dyn crate::static_data::Ability>),
+    Nature(Weak<dyn crate::static_data::Nature>),
+
+    StaticStatisticSetU16(Weak<crate::static_data::StaticStatisticSet<u16>>),
+    StatisticSetU32(Weak<crate::static_data::StatisticSet<u32>>),
+    StatChangeStatisticSet(Weak<crate::static_data::ClampedStatisticSet<i8, -6, 6>>),
+    EVStatisticSet(Weak<crate::static_data::ClampedStatisticSet<u8, 0, 252>>),
+    IVStatisticSet(Weak<crate::static_data::ClampedStatisticSet<u8, 0, 31>>),
+
+    // Static data libraries
+    MoveLibrary(Weak<dyn crate::static_data::MoveLibrary>),
+    SpeciesLibrary(Weak<dyn crate::static_data::SpeciesLibrary>),
+    ItemLibrary(Weak<dyn crate::static_data::ItemLibrary>),
+    TypeLibrary(Weak<dyn crate::static_data::TypeLibrary>),
+    LibrarySettings(Weak<dyn crate::static_data::LibrarySettings>),
+    AbilityLibrary(Weak<dyn crate::static_data::AbilityLibrary>),
+    StaticData(Weak<dyn crate::static_data::StaticData>),
+
+    // Dynamic data
+    Pokemon(WeakPokemonReference),
+    PokemonParty(Weak<crate::dynamic_data::PokemonParty>),
+    LearnedMove(Weak<crate::dynamic_data::LearnedMove>),
+
+    // Dynamic data libraries
+    DynamicLibrary(Weak<dyn crate::dynamic_data::DynamicLibrary>),
+
+    // Battle data
+    Battle(WeakBattleReference),
+    ChoiceQueue(Weak<crate::dynamic_data::ChoiceQueue>),
+    BattleRandom(Weak<crate::dynamic_data::BattleRandom>),
+    BattleSide(WeakBattleSideReference),
+    BattleParty(Weak<crate::dynamic_data::BattleParty>),
+    TurnChoice(Weak<crate::dynamic_data::TurnChoice>),
+    ExecutingMove(Weak<crate::dynamic_data::ExecutingMove>),
+    HitData(Weak<crate::dynamic_data::HitData>),
+}
+
+/// Trait for converting from a [`WasmObject`] to a Rust object.
+pub(crate) trait FromWasmObj
+where
+    Self: Sized,
+{
+    /// Converts from a [`WasmObject`] to a Rust object.
+    fn from_wasm_obj(obj: WasmObject) -> Result<Self>;
+}
+
+impl PartialEq for WasmObject {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (WasmObject::StringKey(s1), WasmObject::StringKey(s2)) => s1 == s2,
+            (WasmObject::EffectParameter(s1), WasmObject::EffectParameter(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::MoveData(s1), WasmObject::MoveData(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Species(s1), WasmObject::Species(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Form(s1), WasmObject::Form(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Item(s1), WasmObject::Item(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Ability(s1), WasmObject::Ability(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Nature(s1), WasmObject::Nature(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::StaticStatisticSetU16(s1), WasmObject::StaticStatisticSetU16(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::StatisticSetU32(s1), WasmObject::StatisticSetU32(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::StatChangeStatisticSet(s1), WasmObject::StatChangeStatisticSet(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::EVStatisticSet(s1), WasmObject::EVStatisticSet(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::IVStatisticSet(s1), WasmObject::IVStatisticSet(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::MoveLibrary(s1), WasmObject::MoveLibrary(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::SpeciesLibrary(s1), WasmObject::SpeciesLibrary(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::ItemLibrary(s1), WasmObject::ItemLibrary(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::TypeLibrary(s1), WasmObject::TypeLibrary(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::LibrarySettings(s1), WasmObject::LibrarySettings(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::AbilityLibrary(s1), WasmObject::AbilityLibrary(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::StaticData(s1), WasmObject::StaticData(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Pokemon(s1), WasmObject::Pokemon(s2)) => WeakPokemonReference::eq(s1, s2),
+            (WasmObject::PokemonParty(s1), WasmObject::PokemonParty(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::LearnedMove(s1), WasmObject::LearnedMove(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::DynamicLibrary(s1), WasmObject::DynamicLibrary(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::Battle(s1), WasmObject::Battle(s2)) => WeakBattleReference::eq(s1, s2),
+            (WasmObject::ChoiceQueue(s1), WasmObject::ChoiceQueue(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::BattleRandom(s1), WasmObject::BattleRandom(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::BattleSide(s1), WasmObject::BattleSide(s2)) => WeakBattleSideReference::eq(s1, s2),
+            (WasmObject::BattleParty(s1), WasmObject::BattleParty(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::TurnChoice(s1), WasmObject::TurnChoice(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::ExecutingMove(s1), WasmObject::ExecutingMove(s2)) => Weak::ptr_eq(s1, s2),
+            (WasmObject::HitData(s1), WasmObject::HitData(s2)) => Weak::ptr_eq(s1, s2),
+
+            _ => false,
+        }
+    }
+}
+
+impl Eq for WasmObject {}
+
+impl Hash for WasmObject {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match self {
+            WasmObject::StringKey(s) => state.write_u32(s.hash()),
+            WasmObject::EffectParameter(m) => m.as_ptr().hash(state),
+            WasmObject::MoveData(m) => m.as_ptr().hash(state),
+            WasmObject::Species(m) => m.as_ptr().hash(state),
+            WasmObject::Form(m) => m.as_ptr().hash(state),
+            WasmObject::Item(m) => m.as_ptr().hash(state),
+            WasmObject::Ability(m) => m.as_ptr().hash(state),
+            WasmObject::Nature(m) => m.as_ptr().hash(state),
+            WasmObject::StaticStatisticSetU16(m) => m.as_ptr().hash(state),
+            WasmObject::StatisticSetU32(m) => m.as_ptr().hash(state),
+            WasmObject::StatChangeStatisticSet(m) => m.as_ptr().hash(state),
+            WasmObject::EVStatisticSet(m) => m.as_ptr().hash(state),
+            WasmObject::IVStatisticSet(m) => m.as_ptr().hash(state),
+            WasmObject::MoveLibrary(m) => m.as_ptr().hash(state),
+            WasmObject::SpeciesLibrary(m) => m.as_ptr().hash(state),
+            WasmObject::ItemLibrary(m) => m.as_ptr().hash(state),
+            WasmObject::TypeLibrary(m) => m.as_ptr().hash(state),
+            WasmObject::LibrarySettings(m) => m.as_ptr().hash(state),
+            WasmObject::AbilityLibrary(m) => m.as_ptr().hash(state),
+            WasmObject::StaticData(m) => m.as_ptr().hash(state),
+            WasmObject::Pokemon(m) => m.as_ptr().hash(state),
+            WasmObject::PokemonParty(m) => m.as_ptr().hash(state),
+            WasmObject::LearnedMove(m) => m.as_ptr().hash(state),
+            WasmObject::DynamicLibrary(m) => m.as_ptr().hash(state),
+            WasmObject::Battle(m) => m.as_ptr().hash(state),
+            WasmObject::ChoiceQueue(m) => m.as_ptr().hash(state),
+            WasmObject::BattleRandom(m) => m.as_ptr().hash(state),
+            WasmObject::BattleSide(m) => m.as_ptr().hash(state),
+            WasmObject::BattleParty(m) => m.as_ptr().hash(state),
+            WasmObject::TurnChoice(m) => m.as_ptr().hash(state),
+            WasmObject::ExecutingMove(m) => m.as_ptr().hash(state),
+            WasmObject::HitData(m) => m.as_ptr().hash(state),
+        };
+    }
+}
+
+/// Macro to convert a `WasmObject` into a `Result` of the specified type.
+macro_rules! get_from_wasm_obj {
+    ($variant:ident, $obj:expr) => {
+        match $obj {
+            WasmObject::$variant(b) => b.upgrade().ok_or(anyhow!("$variant was dropped")),
+            _ => Err(anyhow!("Expected $variant")),
+        }
+    };
+}
+
+/// Macro to implement `FromWasmObj` for a type.
+macro_rules! impl_from_wasm_obj {
+    ($variant:ident, $ty:ty) => {
+        impl FromWasmObj for $ty {
+            fn from_wasm_obj(obj: WasmObject) -> Result<Self> {
+                get_from_wasm_obj!($variant, obj)
+            }
+        }
+    };
+}
+
+impl From<crate::StringKey> for WasmObject {
+    fn from(value: crate::StringKey) -> Self {
+        Self::StringKey(value)
+    }
+}
+
+impl FromWasmObj for crate::StringKey {
+    fn from_wasm_obj(obj: WasmObject) -> Result<Self> {
+        match obj {
+            WasmObject::StringKey(b) => Ok(b),
+            _ => Err(anyhow!("Expected StringKey")),
+        }
+    }
+}
+
+impl From<&Arc<crate::static_data::EffectParameter>> for WasmObject {
+    fn from(value: &Arc<crate::static_data::EffectParameter>) -> Self {
+        Self::EffectParameter(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(EffectParameter, Arc<crate::static_data::EffectParameter>);
+
+impl From<&Arc<dyn crate::static_data::MoveData>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::MoveData>) -> Self {
+        Self::MoveData(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(MoveData, Arc<dyn crate::static_data::MoveData>);
+
+impl From<&Arc<dyn crate::static_data::Species>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::Species>) -> Self {
+        Self::Species(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(Species, Arc<dyn crate::static_data::Species>);
+
+impl From<&Arc<dyn crate::static_data::Form>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::Form>) -> Self {
+        Self::Form(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(Form, Arc<dyn crate::static_data::Form>);
+
+impl From<&Arc<dyn crate::static_data::Item>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::Item>) -> Self {
+        Self::Item(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(Item, Arc<dyn crate::static_data::Item>);
+
+impl From<&Arc<dyn crate::static_data::Ability>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::Ability>) -> Self {
+        Self::Ability(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(Ability, Arc<dyn crate::static_data::Ability>);
+
+impl From<&Arc<dyn crate::static_data::Nature>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::Nature>) -> Self {
+        Self::Nature(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(Nature, Arc<dyn crate::static_data::Nature>);
+
+impl From<&Arc<crate::static_data::StaticStatisticSet<u16>>> for WasmObject {
+    fn from(value: &Arc<crate::static_data::StaticStatisticSet<u16>>) -> Self {
+        Self::StaticStatisticSetU16(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(StaticStatisticSetU16, Arc<crate::static_data::StaticStatisticSet<u16>>);
+
+impl From<&Arc<crate::static_data::StatisticSet<u32>>> for WasmObject {
+    fn from(value: &Arc<crate::static_data::StatisticSet<u32>>) -> Self {
+        Self::StatisticSetU32(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(StatisticSetU32, Arc<crate::static_data::StatisticSet<u32>>);
+
+impl From<&Arc<crate::static_data::ClampedStatisticSet<i8, -6, 6>>> for WasmObject {
+    fn from(value: &Arc<crate::static_data::ClampedStatisticSet<i8, -6, 6>>) -> Self {
+        Self::StatChangeStatisticSet(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(
+    StatChangeStatisticSet,
+    Arc<crate::static_data::ClampedStatisticSet<i8, -6, 6>>
+);
+
+impl From<&Arc<crate::static_data::ClampedStatisticSet<u8, 0, 252>>> for WasmObject {
+    fn from(value: &Arc<crate::static_data::ClampedStatisticSet<u8, 0, 252>>) -> Self {
+        Self::EVStatisticSet(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(EVStatisticSet, Arc<crate::static_data::ClampedStatisticSet<u8, 0, 252>>);
+
+impl From<&Arc<crate::static_data::ClampedStatisticSet<u8, 0, 31>>> for WasmObject {
+    fn from(value: &Arc<crate::static_data::ClampedStatisticSet<u8, 0, 31>>) -> Self {
+        Self::IVStatisticSet(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(IVStatisticSet, Arc<crate::static_data::ClampedStatisticSet<u8, 0, 31>>);
+
+impl From<&Arc<dyn crate::static_data::MoveLibrary>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::MoveLibrary>) -> Self {
+        Self::MoveLibrary(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(MoveLibrary, Arc<dyn crate::static_data::MoveLibrary>);
+
+impl From<&Arc<dyn crate::static_data::SpeciesLibrary>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::SpeciesLibrary>) -> Self {
+        Self::SpeciesLibrary(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(SpeciesLibrary, Arc<dyn crate::static_data::SpeciesLibrary>);
+
+impl From<&Arc<dyn crate::static_data::ItemLibrary>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::ItemLibrary>) -> Self {
+        Self::ItemLibrary(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(ItemLibrary, Arc<dyn crate::static_data::ItemLibrary>);
+
+impl From<&Arc<dyn crate::static_data::TypeLibrary>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::TypeLibrary>) -> Self {
+        Self::TypeLibrary(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(TypeLibrary, Arc<dyn crate::static_data::TypeLibrary>);
+
+impl From<&Arc<dyn crate::static_data::LibrarySettings>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::LibrarySettings>) -> Self {
+        Self::LibrarySettings(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(LibrarySettings, Arc<dyn crate::static_data::LibrarySettings>);
+
+impl From<&Arc<dyn crate::static_data::AbilityLibrary>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::AbilityLibrary>) -> Self {
+        Self::AbilityLibrary(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(AbilityLibrary, Arc<dyn crate::static_data::AbilityLibrary>);
+
+impl From<&Arc<dyn crate::static_data::StaticData>> for WasmObject {
+    fn from(value: &Arc<dyn crate::static_data::StaticData>) -> Self {
+        Self::StaticData(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(StaticData, Arc<dyn crate::static_data::StaticData>);
+
+impl From<&Pokemon> for WasmObject {
+    fn from(value: &Pokemon) -> Self {
+        Self::Pokemon(value.weak())
+    }
+}
+
+impl From<&WeakPokemonReference> for WasmObject {
+    fn from(value: &WeakPokemonReference) -> Self {
+        Self::Pokemon(value.clone())
+    }
+}
+
+impl_from_wasm_obj!(Pokemon, Pokemon);
+
+impl From<&Arc<crate::dynamic_data::PokemonParty>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::PokemonParty>) -> Self {
+        Self::PokemonParty(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(PokemonParty, Arc<crate::dynamic_data::PokemonParty>);
+
+impl From<&Arc<crate::dynamic_data::LearnedMove>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::LearnedMove>) -> Self {
+        Self::LearnedMove(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(LearnedMove, Arc<crate::dynamic_data::LearnedMove>);
+
+impl From<&Battle> for WasmObject {
+    fn from(value: &Battle) -> Self {
+        Self::Battle(value.weak())
+    }
+}
+
+impl From<&WeakBattleReference> for WasmObject {
+    fn from(value: &WeakBattleReference) -> Self {
+        Self::Battle(value.clone())
+    }
+}
+
+impl_from_wasm_obj!(Battle, crate::dynamic_data::Battle);
+
+impl From<&Arc<crate::dynamic_data::ChoiceQueue>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::ChoiceQueue>) -> Self {
+        Self::ChoiceQueue(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(ChoiceQueue, Arc<crate::dynamic_data::ChoiceQueue>);
+
+impl From<&Arc<dyn crate::dynamic_data::DynamicLibrary>> for WasmObject {
+    fn from(value: &Arc<dyn crate::dynamic_data::DynamicLibrary>) -> Self {
+        Self::DynamicLibrary(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(DynamicLibrary, Arc<dyn crate::dynamic_data::DynamicLibrary>);
+
+impl From<&Arc<crate::dynamic_data::BattleRandom>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::BattleRandom>) -> Self {
+        Self::BattleRandom(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(BattleRandom, Arc<crate::dynamic_data::BattleRandom>);
+
+impl From<&crate::dynamic_data::BattleSide> for WasmObject {
+    fn from(value: &crate::dynamic_data::BattleSide) -> Self {
+        Self::BattleSide(value.weak())
+    }
+}
+
+impl From<&WeakBattleSideReference> for WasmObject {
+    fn from(value: &WeakBattleSideReference) -> Self {
+        Self::BattleSide(value.clone())
+    }
+}
+
+impl_from_wasm_obj!(BattleSide, crate::dynamic_data::BattleSide);
+
+impl From<&Arc<crate::dynamic_data::BattleParty>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::BattleParty>) -> Self {
+        Self::BattleParty(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(BattleParty, Arc<crate::dynamic_data::BattleParty>);
+
+impl From<&Arc<crate::dynamic_data::TurnChoice>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::TurnChoice>) -> Self {
+        Self::TurnChoice(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(TurnChoice, Arc<crate::dynamic_data::TurnChoice>);
+
+impl From<&Arc<crate::dynamic_data::ExecutingMove>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::ExecutingMove>) -> Self {
+        Self::ExecutingMove(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(ExecutingMove, Arc<crate::dynamic_data::ExecutingMove>);
+
+impl From<&Arc<crate::dynamic_data::HitData>> for WasmObject {
+    fn from(value: &Arc<crate::dynamic_data::HitData>) -> Self {
+        Self::HitData(Arc::downgrade(value))
+    }
+}
+
+impl_from_wasm_obj!(HitData, Arc<crate::dynamic_data::HitData>);

src/script_implementations/wasm/export_registry/wasm_result.rs

@@ -10,14 +10,18 @@ pub type WasmResult<T> = (u32, T);
 /// A result type that can be given to, or returned from WASM, but does not contain a value.
 pub type WasmVoidResult = u32;
 
+/// An extension trait for `WasmResult` that provides some convenience methods.
 pub(crate) trait WasmVoidResultExtension {
-    fn into_result(self, env: FunctionEnvMut<WebAssemblyEnv>) -> anyhow_ext::Result<()>;
+    /// Returns a `WasmVoidResult` that indicates success.
-    fn into_result_env(self, env: &Arc<WebAssemblyEnvironmentData>) -> anyhow_ext::Result<()>;
-    fn from_result(res: anyhow_ext::Result<()>, env: &FunctionEnvMut<WebAssemblyEnv>) -> Self;
     fn ok() -> Self;
+    /// Returns a `WasmVoidResult` that indicates failure.
     fn err(err: anyhow::Error, env: &FunctionEnvMut<WebAssemblyEnv>) -> Self;
+    /// Converts a `WasmVoidResult` into a `Result<(), anyhow::Error>`. Used specifically for script
+    /// function calls.
+    fn into_result_env(self, env: &Arc<WebAssemblyEnvironmentData>) -> anyhow::Result<()>;
 }
 
+/// Returns a success `WasmResult` with the given value.
 pub(super) fn wasm_ok<T>(value: T) -> WasmResult<T>
 where
     T: FromToNativeWasmType,
@@ -26,6 +30,8 @@ where
     (0, value)
 }
 
+/// Returns a failure `WasmResult` with the given error.
+#[allow(clippy::unwrap_used)]
 pub(super) fn wasm_err<T>(err: Error, env: &FunctionEnvMut<WebAssemblyEnv>) -> WasmResult<T>
 where
     T: FromToNativeWasmType + Default,
@@ -36,50 +42,38 @@ where
 }
 
 impl WasmVoidResultExtension for WasmVoidResult {
-    fn into_result(self, env: FunctionEnvMut<WebAssemblyEnv>) -> anyhow::Result<()> {
+    fn ok() -> Self {
-        Self::into_result_env(self, &env.data().data())
+        0
     }
 
+    #[allow(clippy::unwrap_used)]
+    fn err(err: Error, env: &FunctionEnvMut<WebAssemblyEnv>) -> Self {
+        let s = CString::new(err.to_string()).unwrap();
+        let ptr = env.data().data().copy_value_vec_to_wasm(s.as_bytes()).unwrap();
+        ptr
+    }
+
+    #[allow(clippy::unwrap_used)]
     fn into_result_env(self, env: &Arc<WebAssemblyEnvironmentData>) -> anyhow::Result<()> {
         if self == 0 {
             Ok(())
         } else {
             unsafe {
                 let ptr = self;
-                let mem: *mut c_char = env.get_raw_pointer(ptr as u32);
+                let mem: *mut c_char = env.get_raw_pointer(ptr);
                 let string = std::ffi::CStr::from_ptr(mem);
                 let e = anyhow_ext::anyhow!("{}", string.to_str().unwrap());
-                env.script_function_cache().dealloc_cstring(&env, ptr as u32).unwrap();
+                env.script_function_cache().dealloc_cstring(env, ptr).unwrap();
                 Err(e)
             }
         }
     }
-
-    fn from_result(res: anyhow::Result<()>, env: &FunctionEnvMut<WebAssemblyEnv>) -> Self {
-        match res {
-            Ok(_) => 0,
-            Err(e) => {
-                let s = CString::new(e.to_string()).unwrap();
-                let ptr = env.data().data().copy_value_vec_to_wasm(s.as_bytes()).unwrap();
-                ptr as u32
-            }
-        }
-    }
-
-    fn ok() -> Self {
-        0
-    }
-
-    fn err(err: Error, env: &FunctionEnvMut<WebAssemblyEnv>) -> Self {
-        let s = CString::new(err.to_string()).unwrap();
-        let ptr = env.data().data().copy_value_vec_to_wasm(s.as_bytes()).unwrap();
-        ptr as u32
-    }
 }
 
+/// Macro to try an expression, and return a `WasmResult` if it fails.
 macro_rules! try_wasm {
     ($e:expr, $env:expr) => {
-        match $e.with_context(|| format!("WASM function {}", stdext::function_name!())) {
+        match $e {
             Ok(v) => v,
             Err(e) => {
                 return crate::script_implementations::wasm::export_registry::wasm_err(e.into(), &$env);
@@ -88,12 +82,13 @@ macro_rules! try_wasm {
     };
 }
 
+/// Macro to try an expression, and return a `WasmVoidResult` if it fails.
 macro_rules! try_wasm_void {
     ($e:expr, $env:expr) => {
-        match $e.with_context(|| format!("WASM function {}", stdext::function_name!())) {
+        match $e {
             Ok(v) => v,
             Err(e) => {
-                return WasmVoidResult::from_result(Err(e.into()), &$env);
+                return WasmVoidResult::err(e.into(), &$env);
             }
         }
     };
@@ -102,24 +97,28 @@ macro_rules! try_wasm_void {
 pub(super) use try_wasm;
 pub(super) use try_wasm_void;
 
+/// Resolve an externref to a value. Returns an error if this fails.
 macro_rules! get_value {
     ($e:expr, $env:expr) => {
         crate::script_implementations::wasm::export_registry::try_wasm!($e.value_func(&$env), $env)
     };
 }
 
+/// Resolve an externref of an Arc to a value. Returns an error if this fails.
 macro_rules! get_value_arc {
     ($e:expr, $env:expr) => {
         crate::script_implementations::wasm::export_registry::try_wasm!($e.value_func_arc(&$env), $env)
     };
 }
 
+/// Resolve an externref to a value. Returns an error if this fails.
 macro_rules! get_value_void {
     ($e:expr, $env:expr) => {
         crate::script_implementations::wasm::export_registry::try_wasm_void!($e.value_func(&$env), $env)
     };
 }
 
+/// Resolve an externref of an Arc to a value. Returns an error if this fails.
 macro_rules! get_value_arc_void {
     ($e:expr, $env:expr) => {
         crate::script_implementations::wasm::export_registry::try_wasm_void!($e.value_func_arc(&$env), $env)
@@ -131,6 +130,7 @@ pub(super) use get_value_arc;
 pub(super) use get_value_arc_void;
 pub(super) use get_value_void;
 
+/// Resolve an externref to a value, and call a getter on it. Returns an error if this fails.
 macro_rules! get_value_call_getter {
     ($e:ident.$func:ident(), $env:expr) => {{
         let _value = crate::script_implementations::wasm::export_registry::try_wasm!($e.value_func(&$env), $env);

src/script_implementations/wasm/extern_ref.rs

@@ -1,10 +1,10 @@
-use crate::{PkmnError, ValueIdentifiable};
+use crate::ValueIdentifiable;
 use anyhow_ext::Result;
-use std::any::Any;
 use std::marker::PhantomData;
 use std::mem::transmute;
 use std::sync::Arc;
 
+use crate::script_implementations::wasm::export_registry::{FromWasmObj, WasmObject};
 use crate::script_implementations::wasm::script_resolver::{
     WebAssemblyEnv, WebAssemblyEnvironmentData, WebAssemblyScriptResolver,
 };
@@ -44,26 +44,26 @@ impl<T: ?Sized> Default for ExternRef<T> {
 impl<T: ValueIdentifiable + ?Sized> ExternRef<T> {
     /// Instantiates a new ExternRef for a bit of data. If we already have made an Extern Ref for
     /// this data and type, we use that instead.
-    pub fn new(env: &WebAssemblyEnvironmentData, value: &dyn Any) -> Self {
+    pub fn new(env: &WebAssemblyEnvironmentData, value: WasmObject) -> Self {
         Self {
-            index: env.get_extern_ref_index::<T>(value),
+            index: env.get_extern_ref_index(value),
             _phantom: Default::default(),
         }
     }
 
     /// Instantiates a new ExternRef for a bit of data using the function environment. If we already
     /// have made an Extern Ref for this data and type, we use that instead.
-    pub fn func_new(env: &FunctionEnvMut<WebAssemblyEnv>, value: &dyn Any) -> Self {
+    pub fn func_new(env: &FunctionEnvMut<WebAssemblyEnv>, value: WasmObject) -> Self {
         Self {
-            index: env.data().data().get_extern_ref_index::<T>(value),
+            index: env.data().data().get_extern_ref_index(value),
             _phantom: Default::default(),
         }
     }
 
     /// Creates an ExternRef with a given resolver. This can be used in cases where we do not have an environment variable.
-    pub(crate) fn new_with_resolver(resolver: &WebAssemblyScriptResolver, value: &dyn Any) -> Self {
+    pub(crate) fn new_with_resolver(resolver: &WebAssemblyScriptResolver, value: WasmObject) -> Self {
         Self {
-            index: resolver.environment_data().get_extern_ref_index::<T>(value),
+            index: resolver.environment_data().get_extern_ref_index(value),
             _phantom: Default::default(),
         }
     }
@@ -78,62 +78,46 @@ impl<T: ValueIdentifiable + ?Sized> ExternRef<T> {
 
     /// Returns the real value for a given ExternRef. Note that the requested type must be the same as the type of the
     /// value when it was passed before. If these types do not match, this will panic.
-    pub fn value_func<'a>(&self, env: &'a FunctionEnvMut<WebAssemblyEnv>) -> Result<&'a T>
+    pub fn value_func(&self, env: &FunctionEnvMut<WebAssemblyEnv>) -> Result<T>
     where
-        T: Sized + 'static,
+        T: FromWasmObj,
     {
-        self.value(&env.data().data())?.ok_or(PkmnError::NullReference.into())
+        self.value(&env.data().data())
     }
 
     /// Returns the real value for a given ExternRef. Note that the requested type must be the same as the type of the
     /// value when it was passed before. If these types do not match, this will panic.
     pub fn value_func_arc(&self, env: &FunctionEnvMut<WebAssemblyEnv>) -> Result<Arc<T>>
     where
-        T: 'static,
+        Arc<T>: FromWasmObj,
     {
-        self.value_arc(&env.data().data())?
+        self.value_arc(&env.data().data())
-            .ok_or(PkmnError::NullReference.into())
     }
 
     /// Returns the real value for a given ExternRef. Note that the requested type must be the same as the type of the
     /// value when it was passed before. If these types do not match, this will panic.
-    pub fn value_func_box(&self, env: &FunctionEnvMut<WebAssemblyEnv>) -> Result<&Box<T>>
+    pub fn value(&self, env: &Arc<WebAssemblyEnvironmentData>) -> Result<T>
     where
-        T: 'static,
+        T: FromWasmObj,
     {
-        self.value_box(&env.data().data())
+        let value = env.get_extern_ref_value::<T>(self.index)?;
+        let o = FromWasmObj::from_wasm_obj(value)?;
+        Ok(o)
     }
 
     /// Returns the real value for a given ExternRef. Note that the requested type must be the same as the type of the
     /// value when it was passed before. If these types do not match, this will panic.
-    pub fn value<'a>(&self, env: &Arc<WebAssemblyEnvironmentData>) -> Result<Option<&'a T>>
+    pub fn value_arc(&self, env: &Arc<WebAssemblyEnvironmentData>) -> Result<Arc<T>>
     where
-        T: Sized + 'static,
+        Arc<T>: FromWasmObj,
     {
-        Ok(env.get_extern_ref_value::<T>(self.index)?.downcast_ref::<T>())
+        let wasm_obj = env.get_extern_ref_value::<T>(self.index)?;
+        FromWasmObj::from_wasm_obj(wasm_obj)
     }
 
-    /// Returns the real value for a given ExternRef. Note that the requested type must be the same as the type of the
+    /// Returns the internal index for this ExternRef.
-    /// value when it was passed before. If these types do not match, this will panic.
+    pub(crate) fn index(&self) -> usize {
-    pub fn value_arc(&self, env: &Arc<WebAssemblyEnvironmentData>) -> Result<Option<Arc<T>>>
+        self.index
-    where
-        T: 'static,
-    {
-        Ok(env
-            .get_extern_ref_value::<T>(self.index)?
-            .downcast_ref::<Arc<T>>()
-            .cloned())
-    }
-
-    /// Returns the real value for a given ExternRef. Note that the requested type must be the same as the type of the
-    /// value when it was passed before. If these types do not match, this will panic.
-    pub fn value_box(&self, env: &Arc<WebAssemblyEnvironmentData>) -> Result<&Box<T>>
-    where
-        T: 'static,
-    {
-        env.get_extern_ref_value::<T>(self.index)?
-            .downcast_ref::<Box<T>>()
-            .ok_or(PkmnError::NullReference.into())
     }
 }
 
@@ -185,16 +169,16 @@ impl<T> Default for VecExternRef<T> {
     }
 }
 
-impl<T: 'static> VecExternRef<T> {
+// impl<T: 'static> VecExternRef<T> {
-    /// Instantiates a new VecExternRef for a given slice.
+//     /// Instantiates a new VecExternRef for a given slice.
-    pub fn new(env: &WebAssemblyEnvironmentData, value: &Vec<T>) -> Self {
+//     pub fn new(env: &WebAssemblyEnvironmentData, value: &Vec<T>) -> Self {
-        Self {
+//         Self {
-            index: env.get_extern_vec_ref_index(value),
+//             index: env.get_extern_vec_ref_index(value),
-            size: value.len() as u32,
+//             size: value.len() as u32,
-            _phantom: Default::default(),
+//             _phantom: Default::default(),
-        }
+//         }
-    }
+//     }
-}
+// }
 
 unsafe impl<T> FromToNativeWasmType for VecExternRef<T> {
     type Native = i64;

src/script_implementations/wasm/script.rs

@@ -1,4 +1,4 @@
-use anyhow_ext::{anyhow, Result};
+use anyhow_ext::Result;
 use std::any::Any;
 use std::sync::atomic::{AtomicBool, AtomicUsize};
 use std::sync::Arc;
@@ -9,7 +9,7 @@ use crate::dynamic_data::{
     Battle, DamageSource, DynamicLibrary, ExecutingMove, Pokemon, Script, ScriptOwnerData, TurnChoice,
 };
 use crate::script_implementations::wasm::export_registry::WasmVoidResultExtension;
-use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
+use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnvironmentData;
 use crate::script_implementations::wasm::WebAssemblyScriptCapabilities;
 use crate::static_data::{EffectParameter, Item, Statistic, TypeIdentifier};
@@ -86,14 +86,7 @@ macro_rules! call_func {
 /// Util macro to reduce extern ref instantiation verbosity.
 macro_rules! ex_ref {
     ($env:ident, $value:expr) => {
-        ExternRef::new($env.as_ref(), $value)
+        ExternRef::new($env.as_ref(), $value.into())
-    };
-}
-
-/// Util macro to reduce vec extern ref instantiation verbosity.
-macro_rules! vec_ex_ref {
-    ($env:ident, $value:expr) => {
-        VecExternRef::new($env.as_ref(), $value)
     };
 }
 
@@ -132,19 +125,25 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn on_initialize(&self, library: &Arc<dyn DynamicLibrary>, pars: Vec<EffectParameter>) -> Result<()> {
+    fn on_initialize(&self, library: &Arc<dyn DynamicLibrary>, pars: Vec<Arc<EffectParameter>>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::Initialize) {
             return Ok(());
         }
 
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_initialize(env) {
-            call_func!(func, env, self, ex_ref!(env, library), vec_ex_ref!(env, &pars));
+            let pars = pars
+                .into_iter()
+                .map(|p| ExternRef::<EffectParameter>::new(env, (&p).into()).index() as u32)
+                .collect::<Vec<_>>();
+            let wasm_ptr = env.copy_value_vec_to_wasm(&pars)?;
+            let r: u64 = unsafe { std::mem::transmute((wasm_ptr, pars.len() as u32)) };
+            call_func!(func, env, self, ex_ref!(env, library), r);
         }
         Ok(())
     }
 
-    fn on_before_turn(&self, choice: &TurnChoice) -> Result<()> {
+    fn on_before_turn(&self, choice: &Arc<TurnChoice>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnBeforeTurn) {
             return Ok(());
         }
@@ -155,7 +154,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_speed(&self, choice: &TurnChoice, speed: &mut u32) -> Result<()> {
+    fn change_speed(&self, choice: &Arc<TurnChoice>, speed: &mut u32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeSpeed) {
             return Ok(());
         }
@@ -169,7 +168,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_priority(&self, choice: &TurnChoice, priority: &mut i8) -> Result<()> {
+    fn change_priority(&self, choice: &Arc<TurnChoice>, priority: &mut i8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangePriority) {
             return Ok(());
         }
@@ -183,26 +182,22 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_move(&self, choice: &TurnChoice, move_name: &mut StringKey) -> Result<()> {
+    fn change_move(&self, choice: &Arc<TurnChoice>, move_name: &mut StringKey) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeMove) {
             return Ok(());
         }
 
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_move(env) {
-            let move_ref = ex_ref!(env, move_name);
+            let move_ref = ex_ref!(env, move_name.clone());
             let ptr = env.allocate_temp::<ExternRef<StringKey>>(move_ref);
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
-            *move_name = ptr
+            *move_name = ptr.value().value(env)?;
-                .value()
-                .value(env)?
-                .ok_or(anyhow!("Unable to get move name"))?
-                .clone();
         }
         Ok(())
     }
 
-    fn change_number_of_hits(&self, choice: &TurnChoice, number_of_hits: &mut u8) -> Result<()> {
+    fn change_number_of_hits(&self, choice: &Arc<TurnChoice>, number_of_hits: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeNumberOfHits) {
             return Ok(());
         }
@@ -216,7 +211,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn prevent_move(&self, mv: &ExecutingMove, prevent: &mut bool) -> Result<()> {
+    fn prevent_move(&self, mv: &Arc<ExecutingMove>, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventMove) {
             return Ok(());
         }
@@ -230,7 +225,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn fail_move(&self, mv: &ExecutingMove, fail: &mut bool) -> Result<()> {
+    fn fail_move(&self, mv: &Arc<ExecutingMove>, fail: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::FailMove) {
             return Ok(());
         }
@@ -244,7 +239,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn stop_before_move(&self, mv: &ExecutingMove, stop: &mut bool) -> Result<()> {
+    fn stop_before_move(&self, mv: &Arc<ExecutingMove>, stop: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::StopBeforeMove) {
             return Ok(());
         }
@@ -258,7 +253,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn on_before_move(&self, mv: &ExecutingMove) -> Result<()> {
+    fn on_before_move(&self, mv: &Arc<ExecutingMove>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnBeforeMove) {
             return Ok(());
         }
@@ -269,61 +264,47 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn fail_incoming_move(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, fail: &mut bool) -> Result<()> {
+    fn fail_incoming_move(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, fail: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::FailIncomingMove) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().fail_incoming_move(env) {
             let ptr = env.allocate_temp::<bool>(*fail);
-            call_func!(
+            call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), ptr.wasm_ptr);
-                func,
-                env,
-                self,
-                ex_ref!(env, mv),
-                ex_ref!(env, target.as_ref()),
-                ptr.wasm_ptr
-            );
             *fail = *ptr.value();
         }
         Ok(())
     }
 
-    fn is_invulnerable(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, invulnerable: &mut bool) -> Result<()> {
+    fn is_invulnerable(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, invulnerable: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::IsInvulnerable) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().is_invulnerable(env) {
             let ptr = env.allocate_temp::<bool>(*invulnerable);
-            call_func!(
+            call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), ptr.wasm_ptr);
-                func,
-                env,
-                self,
-                ex_ref!(env, mv),
-                ex_ref!(env, target.as_ref()),
-                ptr.wasm_ptr
-            );
             *invulnerable = *ptr.value();
         }
         Ok(())
     }
 
-    fn on_move_miss(&self, mv: &ExecutingMove, target: &Arc<Pokemon>) -> Result<()> {
+    fn on_move_miss(&self, mv: &Arc<ExecutingMove>, target: &Pokemon) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnMoveMiss) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_move_miss(env) {
-            call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target.as_ref()));
+            call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target));
         }
         Ok(())
     }
 
     fn change_move_type(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         move_type: &mut TypeIdentifier,
     ) -> Result<()> {
@@ -333,7 +314,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_move_type(env) {
             let ptr = env.allocate_temp::<TypeIdentifier>(*move_type);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *move_type = *ptr.value();
@@ -343,8 +324,8 @@ impl Script for WebAssemblyScript {
 
     fn change_effectiveness(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         effectiveness: &mut f32,
     ) -> Result<()> {
@@ -354,7 +335,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_effectiveness(env) {
             let ptr = env.allocate_temp(*effectiveness);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *effectiveness = *ptr.value();
@@ -364,8 +345,8 @@ impl Script for WebAssemblyScript {
 
     fn block_critical(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         block_critical: &mut bool,
     ) -> Result<()> {
@@ -375,7 +356,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().block_critical(env) {
             let ptr = env.allocate_temp(*block_critical);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *block_critical = *ptr.value();
@@ -385,8 +366,8 @@ impl Script for WebAssemblyScript {
 
     fn block_incoming_critical(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         block_critical: &mut bool,
     ) -> Result<()> {
@@ -396,7 +377,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().block_incoming_critical(env) {
             let ptr = env.allocate_temp(*block_critical);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *block_critical = *ptr.value();
@@ -404,14 +385,14 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_accuracy(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, accuracy: &mut u8) -> Result<()> {
+    fn change_accuracy(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8, accuracy: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeAccuracy) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_accuracy(env) {
             let ptr = env.allocate_temp(*accuracy);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *accuracy = *ptr.value();
@@ -419,14 +400,14 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_critical_stage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, stage: &mut u8) -> Result<()> {
+    fn change_critical_stage(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8, stage: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeCriticalStage) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_critical_stage(env) {
             let ptr = env.allocate_temp(*stage);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *stage = *ptr.value();
@@ -436,8 +417,8 @@ impl Script for WebAssemblyScript {
 
     fn change_critical_modifier(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         modifier: &mut f32,
     ) -> Result<()> {
@@ -447,7 +428,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_critical_modifier(env) {
             let ptr = env.allocate_temp(*modifier);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
@@ -457,8 +438,8 @@ impl Script for WebAssemblyScript {
 
     fn change_stab_modifier(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         modifier: &mut f32,
     ) -> Result<()> {
@@ -468,7 +449,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_stab_modifier(env) {
             let ptr = env.allocate_temp(*modifier);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
@@ -476,14 +457,14 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_base_power(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, base_power: &mut u8) -> Result<()> {
+    fn change_base_power(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8, base_power: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeBasePower) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_base_power(env) {
             let ptr = env.allocate_temp(*base_power);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *base_power = *ptr.value();
@@ -493,8 +474,8 @@ impl Script for WebAssemblyScript {
 
     fn bypass_defensive_stat_boost(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         bypass: &mut bool,
     ) -> Result<()> {
@@ -504,7 +485,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().bypass_defensive_stat_boost(env) {
             let ptr = env.allocate_temp(*bypass);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *bypass = *ptr.value();
@@ -514,8 +495,8 @@ impl Script for WebAssemblyScript {
 
     fn bypass_offensive_stat_boost(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         bypass: &mut bool,
     ) -> Result<()> {
@@ -525,7 +506,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().bypass_offensive_stat_boost(env) {
             let ptr = env.allocate_temp(*bypass);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *bypass = *ptr.value();
@@ -535,8 +516,8 @@ impl Script for WebAssemblyScript {
 
     fn change_offensive_stat_value(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         amount: &mut u32,
     ) -> Result<()> {
@@ -546,7 +527,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_offensive_stat_value(env) {
             let ptr = env.allocate_temp(*amount);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *amount = *ptr.value();
@@ -556,8 +537,8 @@ impl Script for WebAssemblyScript {
 
     fn change_defensive_stat_value(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         amount: &mut u32,
     ) -> Result<()> {
@@ -567,7 +548,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_defensive_stat_value(env) {
             let ptr = env.allocate_temp(*amount);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *amount = *ptr.value();
@@ -577,8 +558,8 @@ impl Script for WebAssemblyScript {
 
     fn change_damage_stat_modifier(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         modifier: &mut f32,
     ) -> Result<()> {
@@ -588,7 +569,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_damage_stat_modifier(env) {
             let ptr = env.allocate_temp(*modifier);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
@@ -598,8 +579,8 @@ impl Script for WebAssemblyScript {
 
     fn change_damage_modifier(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         modifier: &mut f32,
     ) -> Result<()> {
@@ -609,7 +590,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_damage_modifier(env) {
             let ptr = env.allocate_temp(*modifier);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
@@ -617,14 +598,14 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_damage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, damage: &mut u32) -> Result<()> {
+    fn change_damage(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8, damage: &mut u32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeDamage) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_damage(env) {
             let ptr = env.allocate_temp(*damage);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *damage = *ptr.value();
@@ -634,8 +615,8 @@ impl Script for WebAssemblyScript {
 
     fn change_incoming_damage(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         damage: &mut u32,
     ) -> Result<()> {
@@ -645,7 +626,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_incoming_damage(env) {
             let ptr = env.allocate_temp(*damage);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *damage = *ptr.value();
@@ -653,25 +634,25 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn on_incoming_hit(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) -> Result<()> {
+    fn on_incoming_hit(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnIncomingHit) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_incoming_hit(env) {
-            let target = target.as_ref();
+            let target = target;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit);
         }
         Ok(())
     }
 
-    fn on_opponent_faints(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) -> Result<()> {
+    fn on_opponent_faints(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFaintingOpponent) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_opponent_faints(env) {
-            let target = target.as_ref();
+            let target = target;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit);
         }
         Ok(())
@@ -709,8 +690,8 @@ impl Script for WebAssemblyScript {
 
     fn prevent_secondary_effect(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         prevent: &mut bool,
     ) -> Result<()> {
@@ -720,7 +701,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_secondary_effect(env) {
             let ptr = env.allocate_temp(*prevent);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *prevent = *ptr.value();
@@ -728,14 +709,14 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_effect_chance(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, chance: &mut f32) -> Result<()> {
+    fn change_effect_chance(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8, chance: &mut f32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeEffectChance) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_effect_chance(env) {
             let ptr = env.allocate_temp(*chance);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *chance = *ptr.value();
@@ -745,8 +726,8 @@ impl Script for WebAssemblyScript {
 
     fn change_incoming_effect_chance(
         &self,
-        mv: &ExecutingMove,
+        mv: &Arc<ExecutingMove>,
-        target: &Arc<Pokemon>,
+        target: &Pokemon,
         hit: u8,
         chance: &mut f32,
     ) -> Result<()> {
@@ -756,7 +737,7 @@ impl Script for WebAssemblyScript {
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_incoming_effect_chance(env) {
             let ptr = env.allocate_temp(*chance);
-            let target = target.as_ref();
+            let target = target;
             let w_ptr = ptr.wasm_ptr;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *chance = *ptr.value();
@@ -764,31 +745,31 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn on_secondary_effect(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) -> Result<()> {
+    fn on_secondary_effect(&self, mv: &Arc<ExecutingMove>, target: &Pokemon, hit: u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFaintingOpponent) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_secondary_effect(env) {
-            let target = target.as_ref();
+            let target = target;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit);
         }
         Ok(())
     }
 
-    fn on_after_hits(&self, mv: &ExecutingMove, target: &Arc<Pokemon>) -> Result<()> {
+    fn on_after_hits(&self, mv: &Arc<ExecutingMove>, target: &Pokemon) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnAfterHits) {
             return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_after_hits(env) {
-            let target = target.as_ref();
+            let target = target;
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target));
         }
         Ok(())
     }
 
-    fn prevent_self_switch(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
+    fn prevent_self_switch(&self, choice: &Arc<TurnChoice>, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSelfSwitch) {
             return Ok(());
         }
@@ -801,7 +782,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn prevent_opponent_switch(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
+    fn prevent_opponent_switch(&self, choice: &Arc<TurnChoice>, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSelfSwitch) {
             return Ok(());
         }
@@ -836,7 +817,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn prevent_self_run_away(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
+    fn prevent_self_run_away(&self, choice: &Arc<TurnChoice>, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSelfRunAway) {
             return Ok(());
         }
@@ -849,7 +830,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn prevent_opponent_run_away(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
+    fn prevent_opponent_run_away(&self, choice: &Arc<TurnChoice>, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventOpponentRunAway) {
             return Ok(());
         }
@@ -906,7 +887,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn on_after_held_item_consume(&self, pokemon: &Pokemon, item: &dyn Item) -> Result<()> {
+    fn on_after_held_item_consume(&self, pokemon: &Pokemon, item: &Arc<dyn Item>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnAfterHeldItemConsume) {
             return Ok(());
         }
@@ -960,7 +941,7 @@ impl Script for WebAssemblyScript {
         Ok(())
     }
 
-    fn change_capture_rate_bonus(&self, target: &Pokemon, pokeball: &dyn Item, modifier: &mut u8) -> Result<()> {
+    fn change_capture_rate_bonus(&self, target: &Pokemon, pokeball: &Arc<dyn Item>, modifier: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeCaptureRate) {
             return Ok(());
         }

src/script_implementations/wasm/script_function_cache.rs

@@ -8,9 +8,9 @@ use paste::paste;
 
 use crate::dynamic_data::{Battle, DynamicLibrary, ExecutingMove, Pokemon, TurnChoice};
 use crate::script_implementations::wasm::export_registry::WasmVoidResult;
-use crate::script_implementations::wasm::extern_ref::{ExternRef, VecExternRef};
+use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script_resolver::WebAssemblyEnvironmentData;
-use crate::static_data::{EffectParameter, Item, TypeIdentifier};
+use crate::static_data::{Item, TypeIdentifier};
 use crate::StringKey;
 use wasmer::{FromToNativeWasmType, TypedFunction};
 
@@ -123,7 +123,7 @@ unsafe impl<T> FromToNativeWasmType for WasmPtr<T> {
 script_function_cache! {
     stack()
     on_remove()
-    on_initialize(ExternRef<dyn DynamicLibrary>, VecExternRef<EffectParameter>)
+    on_initialize(ExternRef<dyn DynamicLibrary>, u64)
     on_before_turn(ExternRef<TurnChoice>)
     change_speed(ExternRef<TurnChoice>, WasmPtr<u32>)
     change_priority(ExternRef<TurnChoice>, WasmPtr<i8>)

src/script_implementations/wasm/script_resolver.rs

@@ -1,9 +1,8 @@
-use std::any::Any;
 use std::fmt::{Debug, Formatter};
 use std::mem::{align_of, forget, size_of};
 use std::sync::{Arc, Weak};
 
-use anyhow_ext::{anyhow, ensure, Context, Result};
+use anyhow_ext::{anyhow, Context, Result};
 use hashbrown::{HashMap, HashSet};
 use parking_lot::lock_api::RwLockReadGuard;
 use parking_lot::{RawRwLock, RwLock};
@@ -13,7 +12,7 @@ use wasmer::{
 };
 
 use crate::dynamic_data::{ItemScript, Script, ScriptOwnerData, ScriptResolver};
-use crate::script_implementations::wasm::export_registry::register_webassembly_funcs;
+use crate::script_implementations::wasm::export_registry::{register_webassembly_funcs, WasmObject};
 use crate::script_implementations::wasm::extern_ref::ExternRef;
 use crate::script_implementations::wasm::script::WebAssemblyScript;
 use crate::script_implementations::wasm::script_function_cache::ScriptFunctionCache;
@@ -192,7 +191,7 @@ impl ScriptResolver for WebAssemblyScriptResolver {
             .call(
                 &mut self.store_mut(),
                 category as u8,
-                ExternRef::new_with_resolver(self, script_key),
+                ExternRef::new_with_resolver(self, WasmObject::StringKey(script_key.clone())),
             )?;
         self.environment_data.setup_script(script, category, script_key, owner)
     }
@@ -223,7 +222,7 @@ pub struct WebAssemblyEnvironmentData {
     /// we instead keep track of all the data we've sent to WASM, and pass the ID of that data to WASM. This allows us
     /// to only operate on data we know WASM owns. We currently store this data in this continuous Vec, and give the index
     /// of the data as the ID.
-    extern_ref_pointers: RwLock<Vec<*const dyn Any>>,
+    extern_ref_pointers: RwLock<Vec<WasmObject>>,
     /// To make sure we send the same identifier to WASM when we send the same piece of data multiple times, we have a
     /// backwards lookup on extern_ref_pointers. This allows us to get the index for a given piece of data.
     extern_ref_pointers_lookup: RwLock<HashMap<ExternRefLookupKey, usize>>,
@@ -269,9 +268,7 @@ pub struct WebAssemblyEnvironmentData {
 #[derive(Clone, Eq, PartialEq, Hash)]
 struct ExternRefLookupKey {
     /// The raw pointer to the data
-    pub ptr: *const dyn Any,
+    pub obj: WasmObject,
-    /// Whether or not the reference is a Vec
-    pub is_vec: bool,
 }
 
 impl WebAssemblyEnvironmentData {
@@ -387,8 +384,8 @@ impl WebAssemblyEnvironmentData {
     /// when extern refs get actually properly implemented at compile time we might want to get rid
     /// of this code.
     #[inline(always)]
-    pub fn get_extern_ref_index<T: ?Sized>(&self, value: &dyn Any) -> usize {
+    pub(crate) fn get_extern_ref_index(&self, value: WasmObject) -> usize {
-        self.get_extern_ref_from_identifier(value, false)
+        self.get_extern_ref_from_identifier(value)
     }
 
     /// Get a numeric value from any given value. This is not a true Extern Ref from WASM, as this
@@ -397,15 +394,15 @@ impl WebAssemblyEnvironmentData {
     /// access can be touched through this, and we ensure the value is the correct type. In the future,
     /// when extern refs get actually properly implemented at compile time we might want to get rid
     /// of this code.
-    pub fn get_extern_vec_ref_index<T: 'static>(&self, value: &Vec<T>) -> usize {
+    // pub fn get_extern_vec_ref_index<T: 'static>(&self, value: &Vec<T>) -> usize {
-        let mut vec = Vec::with_capacity(value.len());
+    //     let mut vec = Vec::with_capacity(value.len());
-        for v in value {
+    //     for v in value {
-            vec.push(self.get_extern_ref_index::<T>(v));
+    //         vec.push(self.get_extern_ref_index(v));
-        }
+    //     }
-        let p = self.get_extern_ref_from_identifier(value, true);
+    //     let p = self.get_extern_ref_from_identifier(value);
-        self.extern_vec_ref_lookup.write().insert(p, vec);
+    //     self.extern_vec_ref_lookup.write().insert(p, vec);
-        p
+    //     p
-    }
+    // }
 
     /// Get an extern ref belonging to a vector we have passed to WASM.
     pub fn get_extern_vec_ref_extern_ref(&self, extern_vec_ref: usize, index: usize) -> Result<usize> {
@@ -417,44 +414,37 @@ impl WebAssemblyEnvironmentData {
     /// Gets the extern ref index belonging to a specific pointer. If none exists, this will create
     /// a new one.
     #[inline(always)]
-    fn get_extern_ref_from_identifier(&self, value: &dyn Any, is_vec: bool) -> usize {
+    fn get_extern_ref_from_identifier(&self, value: WasmObject) -> usize {
-        if let Some(v) = self.extern_ref_pointers_lookup.read().get(&ExternRefLookupKey {
+        if let Some(v) = self
-            ptr: value as *const dyn Any,
+            .extern_ref_pointers_lookup
-            is_vec,
+            .read()
-        }) {
+            .get(&ExternRefLookupKey { obj: value.clone() })
+        {
             return *v;
         }
         let index = {
             let mut extern_ref_guard = self.extern_ref_pointers.write();
-            extern_ref_guard.push(value as *const dyn Any);
+            extern_ref_guard.push(value.clone());
             extern_ref_guard.len()
         };
-        self.extern_ref_pointers_lookup.write().insert(
+        self.extern_ref_pointers_lookup
-            ExternRefLookupKey {
+            .write()
-                ptr: value as *const dyn Any,
+            .insert(ExternRefLookupKey { obj: value.clone() }, index);
-                is_vec,
+        self.extern_ref_type_lookup
-            },
+            .write()
-            index,
+            .insert(ExternRefLookupKey { obj: value });
-        );
-        self.extern_ref_type_lookup.write().insert(ExternRefLookupKey {
-            ptr: value as *const dyn Any,
-            is_vec,
-        });
         index
     }
 
     /// Gets a value from the extern ref lookup. This turns an earlier registered index back into
     /// its proper value, validates its type, and returns the value.
-    pub fn get_extern_ref_value<'a, T: ?Sized>(&self, index: usize) -> Result<&'a dyn Any> {
+    pub(crate) fn get_extern_ref_value<T: ?Sized>(&self, index: usize) -> Result<WasmObject> {
         let read_guard = self.extern_ref_pointers.read();
         let ptr = read_guard.get_res(index - 1)?;
         if self
             .extern_ref_type_lookup
             .read()
-            .get(&ExternRefLookupKey {
+            .get(&ExternRefLookupKey { obj: ptr.clone() })
-                ptr: *ptr,
-                is_vec: false,
-            })
             .is_none()
         {
             #[allow(clippy::panic)] // Allow panic here, as this is a security error.
@@ -466,17 +456,23 @@ impl WebAssemblyEnvironmentData {
             }
         }
 
-        unsafe { Ok(ptr.as_ref().unwrap()) }
+        Ok(ptr.clone())
     }
 
     /// The WASM store.
     pub fn store_ref(&self) -> StoreRef<'_> {
-        unsafe { self.store.as_ref().unwrap().as_store_ref() }
+        #[allow(clippy::unwrap_used)] // This should never be None when used.
+        unsafe {
+            self.store.as_ref().unwrap().as_store_ref()
+        }
     }
 
     /// The mutable WASM store.
     pub fn store_mut(&self) -> StoreMut<'_> {
-        unsafe { self.store.as_mut().unwrap().as_store_mut() }
+        #[allow(clippy::unwrap_used)] // This should never be None when used.
+        unsafe {
+            self.store.as_mut().unwrap().as_store_mut()
+        }
     }
 
     /// Find a loaded script based on the pointer in WASM memory.
@@ -514,28 +510,35 @@ impl WebAssemblyEnvironmentData {
                     .get::<StringKey>(&"get_script_capabilities".into())
                 {
                     let res = get_cap.call(&mut self.store_mut(), &[Value::I32(script_ptr as i32)])?;
-                    let ptr =
+                    let ptr = (self.memory() as *const WebAssemblyScriptCapabilities)
-                        (self.memory() as *const WebAssemblyScriptCapabilities).offset(res[0].i32().unwrap() as isize);
+                        .offset(res.get_res(0)?.unwrap_i32() as isize);
-                    let length = res[1].i32();
+                    let length = res.get_res(1)?.i32();
-                    ensure!(length.is_some(), "Script capabilities length was not a valid i32");
+                    match length {
-                    for i in 0..length.unwrap() as usize {
+                        None => return Err(anyhow_ext::anyhow!("Script capabilities length was not a valid i32")),
+                        Some(length) => {
+                            for i in 0..length as usize {
                                 capabilities.insert(*ptr.add(i));
                             }
                         }
                     }
+                }
+            }
             self.script_capabilities
                 .write()
                 .insert(key.clone(), Arc::new(capabilities));
         }
 
         let read_guard = self.script_capabilities.read();
-        let capabilities = read_guard.get(&key).unwrap();
+        let capabilities = read_guard.get(&key).ok_or(anyhow!("Script capabilities not found"))?;
+
+        #[allow(clippy::unwrap_used)] // This should never be None when used.
+        let environment = { self.self_arc.read().as_ref().unwrap().upgrade().unwrap() };
 
         let script = Arc::new(WebAssemblyScript::new(
             owner,
             script_ptr,
             capabilities.clone(),
-            self.self_arc.read().as_ref().unwrap().upgrade().unwrap(),
+            environment,
             script_key.clone(),
         ));
 
@@ -558,6 +561,7 @@ impl WebAssemblyEnv {
     }
 
     /// Get the actual data belonging to the current context.
+    #[allow(clippy::unwrap_used)] // This should never be None when used.
     pub fn data(&self) -> Arc<WebAssemblyEnvironmentData> {
         self.data.upgrade().unwrap()
     }

src/static_data/libraries/item_library.rs

@@ -67,7 +67,7 @@ pub mod tests {
         )
     }
 
-    pub fn build() -> Box<dyn ItemLibrary> {
+    pub fn build() -> Arc<dyn ItemLibrary> {
         let mut lib = ItemLibraryImpl::new(1);
         let m = build_item();
         // Borrow as mut so we can insert
@@ -75,6 +75,6 @@ pub mod tests {
         w.add(&"foo".into(), Arc::new(m));
         // Drops borrow as mut
 
-        Box::new(lib)
+        Arc::new(lib)
     }
 }

src/static_data/libraries/move_library.rs

@@ -71,7 +71,7 @@ pub mod tests {
         )
     }
 
-    pub fn build() -> Box<dyn MoveLibrary> {
+    pub fn build() -> Arc<dyn MoveLibrary> {
         let mut lib = MoveLibraryImpl::new(1);
         let m = build_move();
         // Borrow as mut so we can insert
@@ -79,6 +79,6 @@ pub mod tests {
         w.add(&StringKey::new("foo"), Arc::new(m));
         // Drops borrow as mut
 
-        Box::new(lib)
+        Arc::new(lib)
     }
 }

src/static_data/libraries/species_library.rs

@@ -95,7 +95,7 @@ pub mod tests {
         ))
     }
 
-    pub fn build() -> Box<dyn SpeciesLibrary> {
+    pub fn build() -> Arc<dyn SpeciesLibrary> {
         let mut lib = SpeciesLibraryImpl::new(1);
         let species = build_species();
         // Borrow as mut so we can insert
@@ -103,7 +103,7 @@ pub mod tests {
         w.add(&"foo".into(), species);
         // Drops borrow as mut
 
-        Box::new(lib)
+        Arc::new(lib)
     }
 
     #[test]
@@ -124,6 +124,8 @@ pub mod tests {
     fn add_species_to_library_then_remove() {
         let mut lib = build();
 
+        let lib = Arc::get_mut(&mut lib).unwrap();
+
         lib.remove(&"foo".into());
 
         // Borrow as read so we can read

src/static_data/libraries/static_data.rs

@@ -8,40 +8,27 @@ use crate::static_data::SpeciesLibrary;
 use crate::static_data::TypeLibrary;
 use crate::{ValueIdentifiable, ValueIdentifier};
 use std::fmt::Debug;
+use std::sync::Arc;
 
 /// The storage for all different libraries.
 pub trait StaticData: Debug + ValueIdentifiable {
     /// Several misc settings for the library.
-    fn settings(&self) -> &Box<dyn LibrarySettings>;
+    fn settings(&self) -> &Arc<dyn LibrarySettings>;
     /// All data for Pokemon species.
-    fn species(&self) -> &Box<dyn SpeciesLibrary>;
+    fn species(&self) -> &Arc<dyn SpeciesLibrary>;
-    /// All data for Pokemon species.
-    fn species_mut(&mut self) -> &mut Box<dyn SpeciesLibrary>;
     /// All data for the moves.
-    fn moves(&self) -> &Box<dyn MoveLibrary>;
+    fn moves(&self) -> &Arc<dyn MoveLibrary>;
-    /// All data for the moves.
-    fn moves_mut(&mut self) -> &mut Box<dyn MoveLibrary>;
     /// All data for the items.
-    fn items(&self) -> &Box<dyn ItemLibrary>;
+    fn items(&self) -> &Arc<dyn ItemLibrary>;
-    /// All data for the items.
-    fn items_mut(&mut self) -> &mut Box<dyn ItemLibrary>;
 
     /// All data for growth rates.
-    fn growth_rates(&self) -> &Box<dyn GrowthRateLibrary>;
+    fn growth_rates(&self) -> &Arc<dyn GrowthRateLibrary>;
-    /// All data for growth rates.
-    fn growth_rates_mut(&mut self) -> &mut Box<dyn GrowthRateLibrary>;
     /// All data related to types and type effectiveness.
-    fn types(&self) -> &Box<dyn TypeLibrary>;
+    fn types(&self) -> &Arc<dyn TypeLibrary>;
-    /// All data related to types and type effectiveness.
-    fn types_mut(&mut self) -> &mut Box<dyn TypeLibrary>;
     /// All data related to natures.
-    fn natures(&self) -> &Box<dyn NatureLibrary>;
+    fn natures(&self) -> &Arc<dyn NatureLibrary>;
-    /// All data related to natures.
-    fn natures_mut(&mut self) -> &mut Box<dyn NatureLibrary>;
     /// All data related to abilities.
-    fn abilities(&self) -> &Box<dyn AbilityLibrary>;
+    fn abilities(&self) -> &Arc<dyn AbilityLibrary>;
-    /// All data related to abilities.
-    fn abilities_mut(&mut self) -> &mut Box<dyn AbilityLibrary>;
 }
 
 /// The storage for all different libraries.
@@ -50,34 +37,34 @@ pub struct StaticDataImpl {
     /// A unique identifier so we know what value this is.
     identifier: ValueIdentifier,
     /// Several misc settings for the library.
-    settings: Box<dyn LibrarySettings>,
+    settings: Arc<dyn LibrarySettings>,
     /// All data for Pokemon species.
-    species: Box<dyn SpeciesLibrary>,
+    species: Arc<dyn SpeciesLibrary>,
     /// All data for the moves.
-    moves: Box<dyn MoveLibrary>,
+    moves: Arc<dyn MoveLibrary>,
     /// All data for the items.
-    items: Box<dyn ItemLibrary>,
+    items: Arc<dyn ItemLibrary>,
     /// All data for growth rates.
-    growth_rates: Box<dyn GrowthRateLibrary>,
+    growth_rates: Arc<dyn GrowthRateLibrary>,
     /// All data related to types and type effectiveness.
-    types: Box<dyn TypeLibrary>,
+    types: Arc<dyn TypeLibrary>,
     /// All data related to natures.
-    natures: Box<dyn NatureLibrary>,
+    natures: Arc<dyn NatureLibrary>,
     /// All data related to abilities.
-    abilities: Box<dyn AbilityLibrary>,
+    abilities: Arc<dyn AbilityLibrary>,
 }
 
 impl StaticDataImpl {
     /// Instantiates a new data collection.
     pub fn new(
-        settings: Box<dyn LibrarySettings>,
+        settings: Arc<dyn LibrarySettings>,
-        species: Box<dyn SpeciesLibrary>,
+        species: Arc<dyn SpeciesLibrary>,
-        moves: Box<dyn MoveLibrary>,
+        moves: Arc<dyn MoveLibrary>,
-        items: Box<dyn ItemLibrary>,
+        items: Arc<dyn ItemLibrary>,
-        growth_rates: Box<dyn GrowthRateLibrary>,
+        growth_rates: Arc<dyn GrowthRateLibrary>,
-        types: Box<dyn TypeLibrary>,
+        types: Arc<dyn TypeLibrary>,
-        natures: Box<dyn NatureLibrary>,
+        natures: Arc<dyn NatureLibrary>,
-        abilities: Box<dyn AbilityLibrary>,
+        abilities: Arc<dyn AbilityLibrary>,
     ) -> Self {
         Self {
             identifier: Default::default(),
@@ -95,66 +82,38 @@ impl StaticDataImpl {
 
 impl StaticData for StaticDataImpl {
     /// Several misc settings for the library.
-    fn settings(&self) -> &Box<dyn LibrarySettings> {
+    fn settings(&self) -> &Arc<dyn LibrarySettings> {
         &self.settings
     }
     /// All data for Pokemon species.
-    fn species(&self) -> &Box<dyn SpeciesLibrary> {
+    fn species(&self) -> &Arc<dyn SpeciesLibrary> {
         &self.species
     }
-    /// All data for Pokemon species.
-    fn species_mut(&mut self) -> &mut Box<dyn SpeciesLibrary> {
-        &mut self.species
-    }
     /// All data for the moves.
-    fn moves(&self) -> &Box<dyn MoveLibrary> {
+    fn moves(&self) -> &Arc<dyn MoveLibrary> {
         &self.moves
     }
-    /// All data for the moves.
-    fn moves_mut(&mut self) -> &mut Box<dyn MoveLibrary> {
-        &mut self.moves
-    }
     /// All data for the items.
-    fn items(&self) -> &Box<dyn ItemLibrary> {
+    fn items(&self) -> &Arc<dyn ItemLibrary> {
         &self.items
     }
-    /// All data for the items.
-    fn items_mut(&mut self) -> &mut Box<dyn ItemLibrary> {
-        &mut self.items
-    }
 
     /// All data for growth rates.
-    fn growth_rates(&self) -> &Box<dyn GrowthRateLibrary> {
+    fn growth_rates(&self) -> &Arc<dyn GrowthRateLibrary> {
         &self.growth_rates
     }
-    /// All data for growth rates.
-    fn growth_rates_mut(&mut self) -> &mut Box<dyn GrowthRateLibrary> {
-        &mut self.growth_rates
-    }
     /// All data related to types and type effectiveness.
-    fn types(&self) -> &Box<dyn TypeLibrary> {
+    fn types(&self) -> &Arc<dyn TypeLibrary> {
         &self.types
     }
-    /// All data related to types and type effectiveness.
-    fn types_mut(&mut self) -> &mut Box<dyn TypeLibrary> {
-        &mut self.types
-    }
     /// All data related to natures.
-    fn natures(&self) -> &Box<dyn NatureLibrary> {
+    fn natures(&self) -> &Arc<dyn NatureLibrary> {
         &self.natures
     }
-    /// All data related to natures.
-    fn natures_mut(&mut self) -> &mut Box<dyn NatureLibrary> {
-        &mut self.natures
-    }
     /// All data related to abilities.
-    fn abilities(&self) -> &Box<dyn AbilityLibrary> {
+    fn abilities(&self) -> &Arc<dyn AbilityLibrary> {
         &self.abilities
     }
-    /// All data related to abilities.
-    fn abilities_mut(&mut self) -> &mut Box<dyn AbilityLibrary> {
-        &mut self.abilities
-    }
 }
 
 impl ValueIdentifiable for StaticDataImpl {
@@ -174,22 +133,15 @@ pub mod test {
         #[derive(Debug)]
         pub StaticData{}
         impl StaticData for StaticData {
-            fn settings(&self) -> &Box<dyn LibrarySettings>;
+            fn settings(&self) -> &Arc<dyn LibrarySettings>;
-            fn species(&self) -> &Box<dyn SpeciesLibrary>;
+            fn species(&self) -> &Arc<dyn SpeciesLibrary>;
-            fn species_mut(&mut self) -> &mut Box<dyn SpeciesLibrary>;
+            fn moves(&self) -> &Arc<dyn MoveLibrary>;
-            fn moves(&self) -> &Box<dyn MoveLibrary>;
+            fn items(&self) -> &Arc<dyn ItemLibrary>;
-            fn moves_mut(&mut self) -> &mut Box<dyn MoveLibrary>;
-            fn items(&self) -> &Box<dyn ItemLibrary>;
-            fn items_mut(&mut self) -> &mut Box<dyn ItemLibrary>;
 
-            fn growth_rates(&self) -> & Box<dyn GrowthRateLibrary>;
+            fn growth_rates(&self) -> & Arc<dyn GrowthRateLibrary>;
-            fn growth_rates_mut(&mut self) -> &mut Box<dyn GrowthRateLibrary>;
+            fn types(&self) -> &Arc<dyn TypeLibrary>;
-            fn types(&self) -> &Box<dyn TypeLibrary>;
+            fn natures(&self) -> &Arc<dyn NatureLibrary>;
-            fn types_mut(&mut self) -> &mut Box<dyn TypeLibrary>;
+            fn abilities(&self) -> &Arc<dyn AbilityLibrary>;
-            fn natures(&self) -> &Box<dyn NatureLibrary>;
-            fn natures_mut(&mut self) -> &mut Box<dyn NatureLibrary>;
-            fn abilities(&self) -> &Box<dyn AbilityLibrary>;
-            fn abilities_mut(&mut self) -> &mut Box<dyn AbilityLibrary>;
         }
         impl ValueIdentifiable for StaticData {
             fn value_identifier(&self) -> ValueIdentifier{
@@ -201,14 +153,14 @@ pub mod test {
     pub fn build() -> StaticDataImpl {
         StaticDataImpl {
             identifier: Default::default(),
-            settings: Box::new(LibrarySettingsImpl::new(100, 100).unwrap()),
+            settings: Arc::new(LibrarySettingsImpl::new(100, 100).unwrap()),
             species: crate::static_data::libraries::species_library::tests::build(),
             moves: crate::static_data::libraries::move_library::tests::build(),
             items: crate::static_data::libraries::item_library::tests::build(),
-            growth_rates: Box::new(crate::static_data::libraries::growth_rate_library::tests::build()),
+            growth_rates: Arc::new(crate::static_data::libraries::growth_rate_library::tests::build()),
-            types: Box::new(crate::static_data::libraries::type_library::tests::build()),
+            types: Arc::new(crate::static_data::libraries::type_library::tests::build()),
-            natures: Box::new(crate::static_data::libraries::nature_library::tests::build()),
+            natures: Arc::new(crate::static_data::libraries::nature_library::tests::build()),
-            abilities: Box::new(crate::static_data::libraries::ability_library::tests::build()),
+            abilities: Arc::new(crate::static_data::libraries::ability_library::tests::build()),
         }
     }
 }

src/static_data/moves/secondary_effect.rs

@@ -1,6 +1,7 @@
 use crate::static_data::EffectParameter;
 use crate::{StringKey, ValueIdentifiable, ValueIdentifier};
 use std::fmt::Debug;
+use std::sync::Arc;
 
 /// A secondary effect is an effect on a move that happens after it hits.
 pub trait SecondaryEffect: Debug + ValueIdentifiable {
@@ -9,7 +10,7 @@ pub trait SecondaryEffect: Debug + ValueIdentifiable {
     /// The name of the effect.
     fn effect_name(&self) -> &StringKey;
     /// A list of parameters for the effect.
-    fn parameters(&self) -> &Vec<EffectParameter>;
+    fn parameters(&self) -> &Vec<Arc<EffectParameter>>;
 }
 
 /// A secondary effect is an effect on a move that happens after it hits.
@@ -22,12 +23,12 @@ pub struct SecondaryEffectImpl {
     /// The name of the effect.
     effect_name: StringKey,
     /// A list of parameters for the effect.
-    parameters: Vec<EffectParameter>,
+    parameters: Vec<Arc<EffectParameter>>,
 }
 
 impl SecondaryEffectImpl {
     /// Instantiates a new Secondary Effect.
-    pub fn new(chance: f32, effect_name: StringKey, parameters: Vec<EffectParameter>) -> Self {
+    pub fn new(chance: f32, effect_name: StringKey, parameters: Vec<Arc<EffectParameter>>) -> Self {
         Self {
             identifier: Default::default(),
             chance,
@@ -47,7 +48,7 @@ impl SecondaryEffect for SecondaryEffectImpl {
         &self.effect_name
     }
     /// A list of parameters for the effect.
-    fn parameters(&self) -> &Vec<EffectParameter> {
+    fn parameters(&self) -> &Vec<Arc<EffectParameter>> {
         &self.parameters
     }
 }
@@ -74,7 +75,7 @@ pub(crate) mod tests {
         impl SecondaryEffect for SecondaryEffect {
             fn chance(&self) -> f32;
             fn effect_name(&self) -> &StringKey;
-            fn parameters(&self) -> &Vec<EffectParameter>;
+            fn parameters(&self) -> &Vec<Arc<EffectParameter>>;
         }
         impl ValueIdentifiable for SecondaryEffect{
             fn value_identifier(&self) -> ValueIdentifier{

src/static_data/species_data/ability.rs

@@ -1,6 +1,7 @@
 use crate::static_data::EffectParameter;
 use crate::{StringKey, ValueIdentifiable, ValueIdentifier};
 use std::fmt::Debug;
+use std::sync::Arc;
 
 /// An ability is a passive effect in battle that is attached to a Pokemon.
 pub trait Ability: Debug + ValueIdentifiable {
@@ -9,7 +10,7 @@ pub trait Ability: Debug + ValueIdentifiable {
     /// The name of the script effect of the ability.
     fn effect(&self) -> &StringKey;
     /// The parameters for the script effect of the ability.
-    fn parameters(&self) -> &Vec<EffectParameter>;
+    fn parameters(&self) -> &Vec<Arc<EffectParameter>>;
 }
 
 /// An ability is a passive effect in battle that is attached to a Pokemon.
@@ -22,12 +23,12 @@ pub struct AbilityImpl {
     /// The name of the script effect of the ability.
     effect: StringKey,
     /// The parameters for the script effect of the ability.
-    parameters: Vec<EffectParameter>,
+    parameters: Vec<Arc<EffectParameter>>,
 }
 
 impl AbilityImpl {
     /// Instantiates a new ability.
-    pub fn new(name: &StringKey, effect: &StringKey, parameters: Vec<EffectParameter>) -> Self {
+    pub fn new(name: &StringKey, effect: &StringKey, parameters: Vec<Arc<EffectParameter>>) -> Self {
         Self {
             identifier: Default::default(),
             name: name.clone(),
@@ -47,7 +48,7 @@ impl Ability for AbilityImpl {
         &self.effect
     }
     /// The parameters for the script effect of the ability.
-    fn parameters(&self) -> &Vec<EffectParameter> {
+    fn parameters(&self) -> &Vec<Arc<EffectParameter>> {
         &self.parameters
     }
 }
@@ -81,7 +82,7 @@ pub(crate) mod tests {
         impl Ability for Ability {
             fn name(&self) -> &StringKey;
             fn effect(&self) -> &StringKey;
-            fn parameters(&self) -> &Vec<EffectParameter>;
+            fn parameters(&self) -> &Vec<Arc<EffectParameter>>;
         }
         impl ValueIdentifiable for Ability {
             fn value_identifier(&self) -> ValueIdentifier {

src/static_data/species_data/form.rs

@@ -1,6 +1,7 @@
 use anyhow_ext::{ensure, Result};
 use hashbrown::HashSet;
 use std::fmt::Debug;
+use std::sync::Arc;
 
 use crate::static_data::Statistic;
 use crate::static_data::TypeIdentifier;
@@ -23,7 +24,7 @@ pub trait Form: ValueIdentifiable + Debug {
     /// The normal types a Pokemon with this form has.
     fn types(&self) -> &Vec<TypeIdentifier>;
     /// The inherent values of a form of species that are used for the stats of a Pokemon.
-    fn base_stats(&self) -> &StaticStatisticSet<u16>;
+    fn base_stats(&self) -> &Arc<StaticStatisticSet<u16>>;
     /// The possible abilities a Pokemon with this form can have.
     fn abilities(&self) -> &Vec<StringKey>;
     /// The possible hidden abilities a Pokemon with this form can have.
@@ -74,7 +75,7 @@ pub struct FormImpl {
     /// The normal types a Pokemon with this form has.
     types: Vec<TypeIdentifier>,
     /// The inherent values of a form of species that are used for the stats of a Pokemon.
-    base_stats: StaticStatisticSet<u16>,
+    base_stats: Arc<StaticStatisticSet<u16>>,
     /// The possible abilities a Pokemon with this form can have.
     abilities: Vec<StringKey>,
     /// The possible hidden abilities a Pokemon with this form can have.
@@ -106,7 +107,7 @@ impl FormImpl {
             weight,
             base_experience,
             types,
-            base_stats,
+            base_stats: Arc::new(base_stats),
             abilities,
             hidden_abilities,
             moves,
@@ -137,7 +138,7 @@ impl Form for FormImpl {
         &self.types
     }
     /// The inherent values of a form of species that are used for the stats of a Pokemon.
-    fn base_stats(&self) -> &StaticStatisticSet<u16> {
+    fn base_stats(&self) -> &Arc<StaticStatisticSet<u16>> {
         &self.base_stats
     }
     /// The possible abilities a Pokemon with this form can have.
@@ -242,7 +243,7 @@ pub(crate) mod tests {
             fn weight(&self) -> f32;
             fn base_experience(&self) -> u32;
             fn types(&self) -> &Vec<TypeIdentifier>;
-            fn base_stats(&self) -> &StaticStatisticSet<u16>;
+            fn base_stats(&self) -> &Arc<StaticStatisticSet<u16>>;
             fn abilities(&self) -> &Vec<StringKey>;
             fn hidden_abilities(&self) -> &Vec<StringKey>;
             fn moves(&self) -> &Box<dyn LearnableMoves>;

tests/common/data_getter.rs

@@ -1,5 +1,4 @@
 use serde::Deserialize;
-use std::sync::Arc;
 
 use pkmn_lib::dynamic_data::Battle;
 
@@ -10,7 +9,7 @@ pub enum TestDataGetter {
 }
 
 impl TestDataGetter {
-    pub fn get(&self, battle: &Arc<Battle>) -> String {
+    pub fn get(&self, battle: &Battle) -> String {
         match self {
             TestDataGetter::PokemonHealth { index } => battle
                 .get_pokemon(index[0], index[1])

tests/common/library_loader.rs

@@ -65,7 +65,7 @@ pub fn load_library() -> LoadResult {
     let species_load_time = t2 - t1;
 
     let data = StaticDataImpl::new(
-        Box::new(LibrarySettingsImpl::new(100, 100).unwrap()),
+        Arc::new(LibrarySettingsImpl::new(100, 100).unwrap()),
         species,
         moves,
         items,
@@ -81,10 +81,10 @@ pub fn load_library() -> LoadResult {
     let wasm_load_time = t2 - t1;
 
     let library = Arc::new(DynamicLibraryImpl::new(
-        Box::new(data),
+        Arc::new(data),
-        Box::new(Gen7BattleStatCalculator::new()),
+        Arc::new(Gen7BattleStatCalculator::new()),
-        Box::new(Gen7DamageLibrary::new(false)),
+        Arc::new(Gen7DamageLibrary::new(false)),
-        Box::new(Gen7MiscLibrary::new()),
+        Arc::new(Gen7MiscLibrary::new()),
         script_resolver,
     ));
 
@@ -101,13 +101,13 @@ pub fn load_library() -> LoadResult {
     }
 }
 
-pub fn load_types(path: &String) -> Box<dyn TypeLibrary> {
+pub fn load_types(path: &String) -> Arc<dyn TypeLibrary> {
     let mut reader = csv::ReaderBuilder::new()
         .delimiter(b'|')
         .from_path(path.to_string() + "Types.csv")
         .unwrap();
 
-    let mut type_library = Box::new(TypeLibraryImpl::new(20));
+    let mut type_library = TypeLibraryImpl::new(20);
 
     let headers = reader.headers().unwrap();
     for header in headers.iter().skip(1) {
@@ -126,16 +126,16 @@ pub fn load_types(path: &String) -> Box<dyn TypeLibrary> {
                 .unwrap();
         }
     }
-    type_library
+    Arc::new(type_library)
 }
 
-pub fn load_natures(path: &String) -> Box<dyn NatureLibrary> {
+pub fn load_natures(path: &String) -> Arc<dyn NatureLibrary> {
     let mut reader = csv::ReaderBuilder::new()
         .delimiter(b'|')
         .from_path(path.to_string() + "Natures.csv")
         .unwrap();
 
-    let mut nature_library = Box::new(NatureLibraryImpl::new(24));
+    let mut nature_library = NatureLibraryImpl::new(24);
     for record in reader.records() {
         let record = record.unwrap();
         let nature_name = record.get(0).unwrap().into();
@@ -152,17 +152,17 @@ pub fn load_natures(path: &String) -> Box<dyn NatureLibrary> {
             );
         }
     }
-    nature_library
+    Arc::new(nature_library)
 }
 
-pub fn load_items(path: &String) -> Box<dyn ItemLibrary> {
+pub fn load_items(path: &String) -> Arc<dyn 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();
 
-    let mut item_library = Box::new(ItemLibraryImpl::new(400));
+    let mut item_library = ItemLibraryImpl::new(400);
     for v in json_array {
         let name = v.get("name").unwrap().as_str().unwrap().into();
         let category = serde_json::from_value(v.get("itemType").unwrap().clone()).unwrap();
@@ -184,17 +184,17 @@ pub fn load_items(path: &String) -> Box<dyn ItemLibrary> {
             Arc::new(ItemImpl::new(&name, category, battle_category, price as i32, flags)),
         );
     }
-    item_library
+    Arc::new(item_library)
 }
 
-pub fn load_growth_rates(path: &String) -> Box<dyn GrowthRateLibrary> {
+pub fn load_growth_rates(path: &String) -> Arc<dyn 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();
 
-    let mut growth_rate_library = Box::new(GrowthRateLibraryImpl::new(10));
+    let mut growth_rate_library = GrowthRateLibraryImpl::new(10);
     for (key, value) in o {
         let name = StringKey::new(key);
         let experience_required_json = value.as_array().unwrap();
@@ -205,17 +205,17 @@ pub fn load_growth_rates(path: &String) -> Box<dyn GrowthRateLibrary> {
 
         growth_rate_library.add_growth_rate(&name, Box::new(LookupGrowthRate::new(experience_required)));
     }
-    growth_rate_library
+    Arc::new(growth_rate_library)
 }
 
-pub fn load_abilities(path: &String) -> Box<dyn AbilityLibrary> {
+pub fn load_abilities(path: &String) -> Arc<dyn 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();
 
-    let mut ability_library = Box::new(AbilityLibraryImpl::new(400));
+    let mut ability_library = AbilityLibraryImpl::new(400);
     for (key, value) in o {
         let name = StringKey::new(key);
         let mut effect = StringKey::empty();
@@ -231,16 +231,16 @@ pub fn load_abilities(path: &String) -> Box<dyn AbilityLibrary> {
 
         ability_library.add(&name, Arc::new(AbilityImpl::new(&name, &effect, parameters)));
     }
-    ability_library
+    Arc::new(ability_library)
 }
 
-pub fn load_moves(path: &String, types: &Box<dyn TypeLibrary>) -> Box<dyn MoveLibrary> {
+pub fn load_moves(path: &String, types: &Arc<dyn TypeLibrary>) -> Arc<dyn 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 = Box::new(MoveLibraryImpl::new(600));
+    let mut move_library = MoveLibraryImpl::new(600);
     for move_data in data {
         let move_data = move_data.as_object().unwrap();
         let move_name = move_data.get("name").unwrap().as_str().unwrap().into();
@@ -298,21 +298,21 @@ pub fn load_moves(path: &String, types: &Box<dyn TypeLibrary>) -> Box<dyn MoveLi
             )),
         );
     }
-    move_library
+    Arc::new(move_library)
 }
 
 pub fn load_species(
     path: &String,
-    types: &Box<dyn TypeLibrary>,
+    types: &Arc<dyn TypeLibrary>,
-    moves: &Box<dyn MoveLibrary>,
+    moves: &Arc<dyn MoveLibrary>,
-) -> Box<dyn SpeciesLibrary> {
+) -> Arc<dyn SpeciesLibrary> {
     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();
 
-    let mut species_library = Box::new(SpeciesLibraryImpl::new(800));
+    let mut species_library = SpeciesLibraryImpl::new(800);
     for (key, value) in o.iter() {
         if key.starts_with('$') {
             continue;
@@ -349,7 +349,7 @@ pub fn load_species(
         );
         species_library.add(&name, Arc::new(species));
     }
-    species_library
+    Arc::new(species_library)
 }
 
 #[cfg(not(feature = "wasm"))]
@@ -372,8 +372,8 @@ fn load_script_resolver(path: &String) -> Box<dyn ScriptResolver> {
 fn parse_form(
     name: StringKey,
     value: &Value,
-    types: &Box<dyn TypeLibrary>,
+    types: &Arc<dyn TypeLibrary>,
-    moves: &Box<dyn MoveLibrary>,
+    moves: &Arc<dyn MoveLibrary>,
 ) -> Arc<dyn Form> {
     let mut abilities = Vec::new();
     for a in value.get("abilities").unwrap().as_array().unwrap() {
@@ -457,7 +457,7 @@ where
     )
 }
 
-fn parse_moves(value: &Value, move_library: &Box<dyn MoveLibrary>) -> Box<dyn LearnableMoves> {
+fn parse_moves(value: &Value, move_library: &Arc<dyn MoveLibrary>) -> Box<dyn LearnableMoves> {
     let mut moves = LearnableMovesImpl::new(100);
 
     let level_moves = value.get("levelMoves").unwrap().as_array().unwrap();
@@ -471,8 +471,8 @@ fn parse_moves(value: &Value, move_library: &Box<dyn MoveLibrary>) -> Box<dyn Le
     Box::new(moves)
 }
 
-fn parse_effect_parameter(value: &Value) -> EffectParameter {
+fn parse_effect_parameter(value: &Value) -> Arc<EffectParameter> {
-    match value {
+    Arc::new(match value {
         Value::Null => {
             panic!("Unexpected type")
         }
@@ -491,7 +491,7 @@ fn parse_effect_parameter(value: &Value) -> EffectParameter {
         Value::Object(_) => {
             panic!("Unexpected type")
         }
-    }
+    })
 }
 
 #[test]

tests/common/test_case.rs

@@ -49,14 +49,14 @@ impl TestCase {
             let pokemon = party
                 .pokemon
                 .iter()
-                .map(|a| Some(Arc::new(a.to_pokemon(library.clone()))))
+                .map(|a| Some(a.to_pokemon(library.clone())))
                 .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).unwrap());
+            battle_parties.push(Arc::new(BattleParty::new(party.0.clone(), party.1).unwrap()));
         }
         let battle = Battle::new(
             library,

tests/common/test_step.rs

@@ -1,5 +1,4 @@
 use serde::Deserialize;
-use std::sync::Arc;
 
 use pkmn_lib::dynamic_data::Battle;
 use pkmn_lib::dynamic_data::{MoveChoice, PassChoice, TurnChoice};
@@ -32,7 +31,7 @@ pub enum TestStep {
 }
 
 impl TestStep {
-    pub fn execute(&self, battle: &Arc<Battle>) {
+    pub fn execute(&self, battle: &Battle) {
         match self {
             TestStep::SetPokemon { place, from_party } => {
                 let p = battle.parties()[from_party[0] as usize].get_pokemon(from_party[1] as usize);
@@ -73,7 +72,7 @@ impl TestStep {
                 assert!(battle.try_set_choice(TurnChoice::Pass(PassChoice::new(p))).unwrap());
             }
             TestStep::Assert { value, expected } => {
-                let v = value.get(&battle);
+                let v = value.get(battle);
                 assert_eq!(&v, expected)
             }
         }

tests/integration.rs

@@ -84,28 +84,27 @@ fn load_non_existing_wasm_script() {
 #[test]
 fn validate_assurance() {
     let lib = get_library();
-    let p1 = Arc::new(
+    let p1 = PokemonBuilder::new(lib.clone(), "charizard".into(), 100)
-        PokemonBuilder::new(lib.clone(), "charizard".into(), 100)
         .learn_move("assurance".into())
         .build()
-            .unwrap(),
+        .unwrap();
-    );
+    let p2 = PokemonBuilder::new(lib.clone(), "venusaur".into(), 100)
-    let p2 = Arc::new(
-        PokemonBuilder::new(lib.clone(), "venusaur".into(), 100)
         .build()
-            .unwrap(),
+        .unwrap();
-    );
+    let party1 = Arc::new(
-
+        BattleParty::new(
-    let party1 = BattleParty::new(
             Arc::new(PokemonParty::new_from_vec(vec![Some(p1.clone())])),
             vec![(0, 0)],
         )
-    .unwrap();
+        .unwrap(),
-    let party2 = BattleParty::new(
+    );
+    let party2 = Arc::new(
+        BattleParty::new(
             Arc::new(PokemonParty::new_from_vec(vec![Some(p2.clone())])),
             vec![(1, 0)],
         )
-    .unwrap();
+        .unwrap(),
+    );
 
     let battle = Battle::new(lib.clone(), vec![party1, party2], false, 2, 1, None);
 
@@ -118,18 +117,18 @@ fn validate_assurance() {
         .unwrap();
 
     let mv = p1.learned_moves().read()[0].as_ref().unwrap().clone();
-    let choice = TurnChoice::Move(MoveChoice::new(p1.clone(), mv.clone(), 1, 0));
+    let choice = Arc::new(TurnChoice::Move(MoveChoice::new(p1.clone(), mv.clone(), 1, 0)));
     script.on_before_turn(&choice).unwrap();
     assert!(battle.sides()[1].has_volatile_script(&"assurance_data".into()));
 
-    let executing_move = ExecutingMove::new(
+    let executing_move = Arc::new(ExecutingMove::new(
         vec![],
         1,
         p1,
         mv.clone(),
         mv.move_data().clone(),
         ScriptContainer::default(),
-    );
+    ));
     let mut v = 20_u8;
     script.change_base_power(&executing_move, &p2, 0, &mut v).unwrap();
     assert_eq!(v, 20_u8);