A lot more work on handling scripts properly.

src/dynamic_data/script_handling/mod.rs

@@ -1,6 +1,7 @@
-use crate::dynamic_data::script_handling::script::Script;
+use crate::dynamic_data::script_handling::script::{Script, ScriptContainer};
 use crate::dynamic_data::script_handling::script_set::ScriptSet;
-use std::sync::Weak;
+use parking_lot::RwLock;
+use std::sync::{Arc, Weak};
 
 pub mod item_script;
 pub mod script;
@@ -12,6 +13,8 @@ macro_rules! script_hook {
     ($hook_name: ident, $source: ident, $($parameters: expr),*) => {
         let mut aggregator = $source.get_script_iterator();
         while let Some(script) = aggregator.get_next() {
+            let lock = &mut script.get();
+            let script = lock.as_mut().unwrap();
             if script.is_suppressed() {
                 continue;
             }
@@ -20,47 +23,76 @@ macro_rules! script_hook {
     };
 }
 
-pub trait ScriptSource {
+#[derive(Default)]
+pub struct ScriptSourceData {
+    is_initialized: bool,
+    scripts: Vec<ScriptWrapper>,
+}
+
+pub trait ScriptSource<'a> {
     fn get_script_iterator(&self) -> ScriptAggregator {
-        todo!()
+        let lock = self.get_script_source_data();
+        if !lock.read().is_initialized {
+            let mut data = lock.write();
+            data.scripts = Vec::with_capacity(self.get_script_count());
+            self.collect_scripts(&mut data.scripts);
+            data.is_initialized = true;
+        }
+        ScriptAggregator::new(&lock.read().scripts as *const Vec<ScriptWrapper>)
     }
-    fn get_script_count(&self);
+    fn get_script_count(&self) -> usize;
+    fn get_script_source_data(&self) -> &RwLock<ScriptSourceData>;
+    fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>);
+    fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>);
 }
 
 pub enum ScriptWrapper {
-    Script(Weak<Box<dyn Script>>),
-    Set(Weak<ScriptSet>),
+    Script(Weak<RwLock<Option<Box<dyn Script>>>>),
+    Set(Weak<RwLock<ScriptSet>>),
+}
+
+impl From<&ScriptContainer> for ScriptWrapper {
+    fn from(c: &ScriptContainer) -> Self {
+        ScriptWrapper::Script(Arc::downgrade(c.arc()))
+    }
+}
+
+impl From<&Arc<RwLock<ScriptSet>>> for ScriptWrapper {
+    fn from(c: &Arc<RwLock<ScriptSet>>) -> Self {
+        ScriptWrapper::Set(Arc::downgrade(c))
+    }
 }
 
 pub struct ScriptAggregator {
-    scripts: Vec<Option<ScriptWrapper>>,
+    scripts: *const Vec<ScriptWrapper>,
     size: i32,
     index: i32,
     set_index: i32,
 }
 
 impl ScriptAggregator {
-    pub fn new(scripts: Vec<Option<ScriptWrapper>>) -> Self {
-        let len = scripts.len();
-        Self {
-            scripts,
-            size: len as i32,
-            index: -1,
-            set_index: -1,
+    pub fn new(scripts: *const Vec<ScriptWrapper>) -> Self {
+        unsafe {
+            let len = scripts.as_ref().unwrap().len();
+            Self {
+                scripts,
+                size: len as i32,
+                index: -1,
+                set_index: -1,
+            }
         }
     }
 
     fn increment_to_next_value(&mut self) -> bool {
         if self.index != -1 {
-            if let Some(wrapper) = &self.scripts[self.index as usize] {
-                if let ScriptWrapper::Set(set) = wrapper {
-                    if let Some(set) = set.upgrade() {
-                        self.set_index += 1;
-                        if self.set_index as usize >= set.count() {
-                            self.set_index = -1;
-                        } else {
-                            return true;
-                        }
+            let wrapper = unsafe { &self.scripts.as_ref().unwrap()[self.index as usize] };
+            if let ScriptWrapper::Set(set) = wrapper {
+                if let Some(set) = set.upgrade() {
+                    self.set_index += 1;
+                    if self.set_index as usize >= set.read().count() {
+                        self.set_index = -1;
+                    } else {
+                        return true;
                     }
                 }
             }
@@ -68,14 +100,15 @@ impl ScriptAggregator {
         self.index += 1;
         for index in self.index..self.size {
             self.index = index;
-            if let Some(wrapper) = &self.scripts[index as usize] {
-                if let ScriptWrapper::Set(s) = wrapper {
-                    if let Some(..) = s.upgrade() {
-                        self.set_index = 0;
-                        return true;
-                    }
-                } else if let ScriptWrapper::Script(script) = wrapper {
-                    if let Some(..) = script.upgrade() {
+            let wrapper = unsafe { &self.scripts.as_ref().unwrap()[self.index as usize] };
+            if let ScriptWrapper::Set(s) = wrapper {
+                if let Some(..) = s.upgrade() {
+                    self.set_index = 0;
+                    return true;
+                }
+            } else if let ScriptWrapper::Script(script) = wrapper {
+                if let Some(v) = script.upgrade() {
+                    if let Some(..) = v.read().as_ref() {
                         return true;
                     }
                 }
@@ -85,18 +118,318 @@ impl ScriptAggregator {
         false
     }
 
-    pub fn get_next(&mut self) -> Option<&Box<dyn Script>> {
+    pub fn get_next(&mut self) -> Option<ScriptContainer> {
         if !self.increment_to_next_value() {
             return None;
         }
-        return match self.scripts[self.index as usize].as_ref().unwrap() {
-            // We can make this unsafe as we know there is a strong reference. This is validated in
-            // increment_to_next_value
-            ScriptWrapper::Script(script) => unsafe { Some(&*script.as_ptr()) },
-            ScriptWrapper::Set(set) => unsafe {
-                let r = (&*set.as_ptr()).at(self.set_index as usize);
-                Some(r.as_ref())
-            },
-        };
+        unsafe {
+            return match &self.scripts.as_ref().unwrap()[self.index as usize] {
+                // increment_to_next_value
+                ScriptWrapper::Script(script) => Some(script.upgrade().unwrap().into()),
+                ScriptWrapper::Set(set) => {
+                    let lock = set.as_ptr().as_ref().unwrap();
+                    let l = lock.read();
+                    let sc = l.at(self.set_index as usize);
+                    return Some(sc.clone());
+                }
+            };
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.index = -1;
+        self.set_index = -1;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dynamic_data::script_handling::script::ScriptContainer;
+    use crate::static_data::EffectParameter;
+    use crate::StringKey;
+    use std::any::Any;
+
+    pub struct TestScript {
+        name: StringKey,
+        test_count: usize,
+    }
+
+    impl TestScript {
+        fn new() -> Self {
+            Self {
+                name: StringKey::new("test"),
+                test_count: 0,
+            }
+        }
+        fn new_with_name(name: &str) -> Self {
+            Self {
+                name: StringKey::new(name),
+                test_count: 0,
+            }
+        }
+    }
+
+    impl Script for TestScript {
+        fn name(&self) -> &StringKey {
+            &self.name
+        }
+
+        fn get_suppressed_count(&self) -> usize {
+            0
+        }
+
+        fn add_suppression(&self) {}
+
+        fn remove_suppression(&self) {}
+
+        fn on_initialize(&mut self, _pars: &[EffectParameter]) {
+            self.test_count += 1;
+        }
+
+        fn as_any(&self) -> &dyn Any {
+            self
+        }
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_single_script() {
+        let script = ScriptContainer::new(Box::new(TestScript::new()));
+        let scripts = vec![ScriptWrapper::from(&script)];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        while let Some(v) = aggregator.get_next() {
+            v.get().as_mut().unwrap().on_initialize(&[]);
+        }
+        let a = script.get_as::<TestScript>();
+        assert_eq!(a.test_count, 1);
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_single_script_with_resets() {
+        let script = ScriptContainer::new(Box::new(TestScript::new()));
+        let scripts = vec![ScriptWrapper::from(&script)];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        for i in 1..11 {
+            aggregator.reset();
+            while let Some(v) = aggregator.get_next() {
+                v.get().as_mut().unwrap().on_initialize(&[]);
+            }
+            let a = script.get_as::<TestScript>();
+            assert_eq!(a.test_count, i);
+        }
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_three_script() {
+        let script1 = ScriptContainer::new(Box::new(TestScript::new()));
+        let script2 = ScriptContainer::new(Box::new(TestScript::new()));
+        let script3 = ScriptContainer::new(Box::new(TestScript::new()));
+        let scripts = vec![
+            ScriptWrapper::from(&script1),
+            ScriptWrapper::from(&script2),
+            ScriptWrapper::from(&script3),
+        ];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        while let Some(v) = aggregator.get_next() {
+            v.get().as_mut().unwrap().on_initialize(&[]);
+        }
+        let a = script1.get_as::<TestScript>();
+        assert_eq!(a.test_count, 1);
+        let a = script2.get_as::<TestScript>();
+        assert_eq!(a.test_count, 1);
+        let a = script3.get_as::<TestScript>();
+        assert_eq!(a.test_count, 1);
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_three_script_with_resets() {
+        let script1 = ScriptContainer::new(Box::new(TestScript::new()));
+        let script2 = ScriptContainer::new(Box::new(TestScript::new()));
+        let script3 = ScriptContainer::new(Box::new(TestScript::new()));
+        let scripts = vec![
+            ScriptWrapper::from(&script1),
+            ScriptWrapper::from(&script2),
+            ScriptWrapper::from(&script3),
+        ];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        for i in 1..11 {
+            aggregator.reset();
+            while let Some(v) = aggregator.get_next() {
+                v.get().as_mut().unwrap().on_initialize(&[]);
+            }
+            let a = script1.get_as::<TestScript>();
+            assert_eq!(a.test_count, i);
+            let a = script2.get_as::<TestScript>();
+            assert_eq!(a.test_count, i);
+            let a = script3.get_as::<TestScript>();
+            assert_eq!(a.test_count, i);
+        }
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_script_set() {
+        let set = Arc::new(RwLock::new(ScriptSet::default()));
+        let mut mut_set = set.write();
+        mut_set.add(Box::new(TestScript::new_with_name("test_a")));
+        mut_set.add(Box::new(TestScript::new_with_name("test_b")));
+        mut_set.add(Box::new(TestScript::new_with_name("test_c")));
+        // Drop so we don't have a lock on it anymore.
+        drop(mut_set);
+
+        let scripts = vec![ScriptWrapper::from(&set)];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        for i in 1..11 {
+            aggregator.reset();
+            while let Some(v) = aggregator.get_next() {
+                v.get().as_mut().unwrap().on_initialize(&[]);
+            }
+            let set = set.read();
+            let s = set.at(0).get_as::<TestScript>();
+            assert_eq!(s.test_count, i);
+            assert_eq!(s.name().str(), "test_a");
+            let s = set.at(1).get_as::<TestScript>();
+            assert_eq!(s.test_count, i);
+            assert_eq!(s.name().str(), "test_b");
+            let s = set.at(2).get_as::<TestScript>();
+            assert_eq!(s.test_count, i);
+            assert_eq!(s.name().str(), "test_c");
+        }
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_script_set_when_removing_last() {
+        let set = Arc::new(RwLock::new(ScriptSet::default()));
+        let mut mut_set = set.write();
+        mut_set.add(Box::new(TestScript::new_with_name("test_a")));
+        mut_set.add(Box::new(TestScript::new_with_name("test_b")));
+        mut_set.add(Box::new(TestScript::new_with_name("test_c")));
+        // Drop so we don't have a lock on it anymore.
+        drop(mut_set);
+
+        let scripts = vec![ScriptWrapper::from(&set)];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        assert_eq!(
+            aggregator
+                .get_next()
+                .unwrap()
+                .get()
+                .as_mut()
+                .unwrap()
+                .name()
+                .str(),
+            "test_a"
+        );
+        assert_eq!(
+            aggregator
+                .get_next()
+                .unwrap()
+                .get()
+                .as_mut()
+                .unwrap()
+                .name()
+                .str(),
+            "test_b"
+        );
+
+        let mut mut_set = set.write();
+        mut_set.remove(&StringKey::new("test_c"));
+        drop(mut_set);
+
+        assert!(aggregator.get_next().is_none());
+    }
+
+    #[test]
+    fn script_aggregator_property_iterates_script_set_when_removing_middle() {
+        let set = Arc::new(RwLock::new(ScriptSet::default()));
+        let mut mut_set = set.write();
+        mut_set.add(Box::new(TestScript::new_with_name("test_a")));
+        mut_set.add(Box::new(TestScript::new_with_name("test_b")));
+        mut_set.add(Box::new(TestScript::new_with_name("test_c")));
+        // Drop so we don't have a lock on it anymore.
+        drop(mut_set);
+
+        let scripts = vec![ScriptWrapper::from(&set)];
+        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
+        assert_eq!(
+            aggregator
+                .get_next()
+                .unwrap()
+                .get()
+                .as_mut()
+                .unwrap()
+                .name()
+                .str(),
+            "test_a"
+        );
+
+        let mut mut_set = set.write();
+        mut_set.remove(&StringKey::new("test_b"));
+        drop(mut_set);
+
+        assert_eq!(
+            aggregator
+                .get_next()
+                .unwrap()
+                .get()
+                .as_mut()
+                .unwrap()
+                .name()
+                .str(),
+            "test_c"
+        );
+        assert!(aggregator.get_next().is_none());
+    }
+
+    pub struct TestScriptSource {
+        pub data: RwLock<ScriptSourceData>,
+        pub script: ScriptContainer,
+    }
+
+    impl<'a> ScriptSource<'a> for TestScriptSource {
+        fn get_script_count(&self) -> usize {
+            1
+        }
+
+        fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
+            &self.data
+        }
+
+        fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
+            scripts.push((&self.script).into());
+        }
+
+        fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
+            self.get_own_scripts(scripts);
+        }
+    }
+
+    #[test]
+    fn script_source_set_script_then_rerun() {
+        let source = TestScriptSource {
+            data: RwLock::new(ScriptSourceData::default()),
+            script: ScriptContainer::default(),
+        };
+
+        let mut aggregator = source.get_script_iterator();
+        aggregator.reset();
+        assert!(aggregator.get_next().is_none());
+        aggregator.reset();
+        source.script.set(Box::new(TestScript::new()));
+        assert!(aggregator.get_next().is_some());
+    }
+
+    #[test]
+    fn script_source_clear_script_then_rerun() {
+        let source = TestScriptSource {
+            data: RwLock::new(ScriptSourceData::default()),
+            script: ScriptContainer::default(),
+        };
+
+        let mut aggregator = source.get_script_iterator();
+        source.script.set(Box::new(TestScript::new()));
+        assert!(aggregator.get_next().is_some());
+        aggregator.reset();
+        source.script.clear();
+        assert!(aggregator.get_next().is_none());
     }
 }

src/dynamic_data/script_handling/script.rs

@@ -2,7 +2,10 @@ use crate::dynamic_data::models::damage_source::DamageSource;
 use crate::dynamic_data::models::pokemon::Pokemon;
 use crate::static_data::moves::secondary_effect::EffectParameter;
 use crate::StringKey;
+use parking_lot::{MappedRwLockReadGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};
+use std::any::Any;
 use std::fmt::{Debug, Formatter};
+use std::sync::Arc;
 
 pub trait Script {
     fn name(&self) -> &StringKey;
@@ -15,50 +18,59 @@ pub trait Script {
     fn remove_suppression(&self);
 
     // FIXME: add missing parameters
-    fn stack(&self);
-    fn on_remove(&self);
-    fn on_initialize(&self, pars: &Vec<EffectParameter>);
-    fn on_before_turn(&self);
-    fn change_speed(&self);
-    fn change_priority(&self);
-    fn change_attack(&self);
-    fn change_number_of_hits(&self);
-    fn prevent_attack(&self);
-    fn fail_attack(&self);
-    fn stop_before_attack(&self);
-    fn on_before_attack(&self);
-    fn fail_incoming_attack(&self);
-    fn is_invulnerable(&self);
-    fn on_attack_miss(&self);
-    fn change_attack_type(&self);
-    fn block_critical(&self);
-    fn override_base_power(&self);
-    fn change_damage_stats_user(&self);
-    fn bypass_defensive_stat(&self);
-    fn bypass_offensive_stat(&self);
-    fn change_stat_modifier(&self);
-    fn change_damage_modifier(&self);
-    fn change_damage(&self);
-    fn change_incoming_damage(&self);
-    fn on_incoming_hit(&self);
-    fn on_opponent_faints(&self);
-    fn prevent_stat_boost_change(&self);
-    fn change_stat_boost_change(&self);
-    fn on_secondary_effect(&self);
-    fn on_after_hits(&self);
-    fn prevent_self_switch(&self);
-    fn prevent_opponent_switch(&self);
-    fn modify_effect_chance(&self);
-    fn modify_incoming_effect_change(&self);
-    fn on_fail(&self);
-    fn on_opponent_fail(&self);
-    fn prevent_self_run_away(&self);
-    fn prevent_opponent_run_away(&self);
-    fn on_end_turn(&self);
-    fn on_damage(&self, pokemon: &Pokemon, source: DamageSource, old_health: u32, new_health: u32);
-    fn on_faint(&self, pokemon: &Pokemon, source: DamageSource);
-    fn on_switch_in(&self, pokemon: &Pokemon);
-    fn on_after_held_item_consume(&self);
+    fn stack(&self) {}
+    fn on_remove(&self) {}
+    fn on_initialize(&mut self, _pars: &[EffectParameter]) {}
+    fn on_before_turn(&self) {}
+    fn change_speed(&self) {}
+    fn change_priority(&self) {}
+    fn change_attack(&self) {}
+    fn change_number_of_hits(&self) {}
+    fn prevent_attack(&self) {}
+    fn fail_attack(&self) {}
+    fn stop_before_attack(&self) {}
+    fn on_before_attack(&self) {}
+    fn fail_incoming_attack(&self) {}
+    fn is_invulnerable(&self) {}
+    fn on_attack_miss(&self) {}
+    fn change_attack_type(&self) {}
+    fn block_critical(&self) {}
+    fn override_base_power(&self) {}
+    fn change_damage_stats_user(&self) {}
+    fn bypass_defensive_stat(&self) {}
+    fn bypass_offensive_stat(&self) {}
+    fn change_stat_modifier(&self) {}
+    fn change_damage_modifier(&self) {}
+    fn change_damage(&self) {}
+    fn change_incoming_damage(&self) {}
+    fn on_incoming_hit(&self) {}
+    fn on_opponent_faints(&self) {}
+    fn prevent_stat_boost_change(&self) {}
+    fn change_stat_boost_change(&self) {}
+    fn on_secondary_effect(&self) {}
+    fn on_after_hits(&self) {}
+    fn prevent_self_switch(&self) {}
+    fn prevent_opponent_switch(&self) {}
+    fn modify_effect_chance(&self) {}
+    fn modify_incoming_effect_change(&self) {}
+    fn on_fail(&self) {}
+    fn on_opponent_fail(&self) {}
+    fn prevent_self_run_away(&self) {}
+    fn prevent_opponent_run_away(&self) {}
+    fn on_end_turn(&self) {}
+    fn on_damage(
+        &self,
+        _pokemon: &Pokemon,
+        _source: DamageSource,
+        _old_health: u32,
+        _new_health: u32,
+    ) {
+    }
+    fn on_faint(&self, _pokemon: &Pokemon, _source: DamageSource) {}
+    fn on_switch_in(&self, _pokemon: &Pokemon) {}
+    fn on_after_held_item_consume(&self) {}
+
+    fn as_any(&self) -> &dyn Any;
 }
 
 impl Debug for dyn Script {
@@ -66,3 +78,48 @@ impl Debug for dyn Script {
         Ok(())
     }
 }
+
+type ScriptHolder = Arc<RwLock<Option<Box<dyn Script>>>>;
+
+#[derive(Default, Debug, Clone)]
+pub struct ScriptContainer {
+    script: ScriptHolder,
+}
+
+impl ScriptContainer {
+    pub fn new(script: Box<dyn Script>) -> ScriptContainer {
+        Self {
+            script: Arc::new(RwLock::new(Some(script))),
+        }
+    }
+
+    pub fn get(&self) -> RwLockWriteGuard<'_, Option<Box<dyn Script>>> {
+        self.script.write()
+    }
+
+    pub fn set(&self, script: Box<dyn Script>) {
+        self.script.write().replace(script);
+    }
+
+    pub fn clear(&self) {
+        self.script.write().take();
+    }
+
+    pub fn arc(&self) -> &ScriptHolder {
+        &self.script
+    }
+
+    pub fn get_as<T: 'static>(&self) -> MappedRwLockReadGuard<T> {
+        RwLockReadGuard::map(self.script.read(), |a| unsafe {
+            let ptr = a.as_ref().as_ref().unwrap().as_ref() as *const dyn Script;
+            let any = ptr.as_ref().unwrap().as_any();
+            any.downcast_ref::<T>().unwrap()
+        })
+    }
+}
+
+impl From<ScriptHolder> for ScriptContainer {
+    fn from(a: ScriptHolder) -> Self {
+        Self { script: a }
+    }
+}

src/dynamic_data/script_handling/script_set.rs

@@ -1,21 +1,23 @@
-use crate::dynamic_data::script_handling::script::Script;
+use crate::dynamic_data::script_handling::script::{Script, ScriptContainer};
 use crate::{PkmnResult, StringKey};
 use indexmap::IndexMap;
-use std::sync::Arc;
 
 #[derive(Debug, Default)]
 pub struct ScriptSet {
-    scripts: IndexMap<StringKey, Arc<Box<dyn Script>>>,
+    scripts: IndexMap<StringKey, ScriptContainer>,
 }
 
 impl ScriptSet {
-    pub fn add(&mut self, script: Box<dyn Script>) -> Arc<Box<dyn Script>> {
-        if let Some(existing) = self.scripts.get(script.name()) {
-            existing.stack();
-            return existing.clone();
+    pub fn add(&mut self, script: Box<dyn Script>) -> ScriptContainer {
+        if let Some(lock) = self.scripts.get(script.name()) {
+            let existing = lock.get();
+            if let Some(v) = &*existing {
+                v.stack();
+                return lock.clone();
+            }
         }
-        let arc = Arc::new(script);
-        self.scripts.insert(arc.name().clone(), arc.clone());
+        self.scripts
+            .insert(script.name().clone(), ScriptContainer::new(script));
         self.scripts.last().unwrap().1.clone()
     }
 
@@ -23,38 +25,42 @@ impl ScriptSet {
         &mut self,
         key: &StringKey,
         instantiation: &'b F,
-    ) -> PkmnResult<Option<Arc<Box<dyn Script>>>>
+    ) -> PkmnResult<Option<ScriptContainer>>
     where
         F: Fn() -> PkmnResult<Option<Box<dyn Script>>>,
     {
-        if let Some(existing) = self.scripts.get(key) {
-            existing.stack();
-            return Ok(Some(existing.clone()));
+        if let Some(lock) = self.scripts.get(key) {
+            let existing = lock.get();
+            if let Some(v) = &*existing {
+                v.stack();
+                return Ok(Some(lock.clone()));
+            }
         }
         let script = instantiation()?;
         if let Some(script) = script {
-            let arc = Arc::new(script);
-            self.scripts.insert(arc.name().clone(), arc.clone());
+            let name = script.name().clone();
+            let arc = ScriptContainer::new(script);
+            self.scripts.insert(name, arc.clone());
             Ok(Some(self.scripts.last().unwrap().1.clone()))
         } else {
             Ok(None)
         }
     }
 
-    pub fn get(&self, key: &StringKey) -> Option<&Arc<Box<dyn Script>>> {
+    pub fn get(&self, key: &StringKey) -> Option<&ScriptContainer> {
         self.scripts.get(key)
     }
 
     pub fn remove(&mut self, key: &StringKey) {
         let value = self.scripts.shift_remove(key);
         if let Some(script) = value {
-            script.on_remove();
+            script.get().as_ref().as_ref().unwrap().on_remove();
         }
     }
 
     pub fn clear(&mut self) {
         for script in &self.scripts {
-            script.1.on_remove();
+            script.1.get().as_ref().as_ref().unwrap().on_remove();
         }
         self.scripts.clear();
     }
@@ -63,7 +69,7 @@ impl ScriptSet {
         self.scripts.contains_key(key)
     }
 
-    pub fn at(&self, index: usize) -> &Arc<Box<dyn Script>> {
+    pub fn at(&self, index: usize) -> &ScriptContainer {
         &self.scripts[index]
     }
 

src/dynamic_data/script_handling/volatile_scripts.rs

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