A lot of cleanup work

gen_7_scripts/src/moves/acrobatics.rs

@@ -1,5 +1,4 @@
 use crate::script;
-use alloc::boxed::Box;
 use core::any::Any;
 use pkmn_lib_interface::app_interface::{ExecutingMove, Pokemon};
 use pkmn_lib_interface::handling::{Script, ScriptCapabilities};

gen_7_scripts/src/moves/after_you.rs

@@ -1,4 +1,3 @@
-use alloc::boxed::Box;
 use core::any::Any;
 use pkmn_lib_interface::app_interface::{ExecutingMove, Pokemon};
 use pkmn_lib_interface::handling::{Script, ScriptCapabilities};

gen_7_scripts/src/moves/assurance.rs

@@ -3,7 +3,7 @@ use alloc::boxed::Box;
 use core::any::Any;
 use core::sync::atomic::{AtomicBool, Ordering};
 use pkmn_lib_interface::app_interface::{
-    BattleSide, DamageSource, DataLibrary, ExecutingMove, Pokemon, TurnChoice, WithVolatile,
+    BattleSide, DamageSource, ExecutingMove, Pokemon, TurnChoice, WithVolatile,
 };
 use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
 

gen_7_scripts/src/moves/aurora_veil.rs

@@ -5,9 +5,7 @@ use crate::weather::hail::Hail;
 use alloc::boxed::Box;
 use core::any::Any;
 use core::sync::atomic::{AtomicU32, Ordering};
-use pkmn_lib_interface::app_interface::{
+use pkmn_lib_interface::app_interface::{ExecutingMove, MoveCategory, Pokemon, WithVolatile};
-    BattleSide, ExecutingMove, MoveCategory, Pokemon, WithVolatile,
-};
 use pkmn_lib_interface::handling::ScriptCapabilities::OnEndTurn;
 use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
 

gen_7_scripts/src/moves/change_all_target_stats.rs

@@ -2,7 +2,7 @@ use crate::script;
 use alloc::rc::Rc;
 use core::any::Any;
 use core::sync::atomic::{AtomicI8, Ordering};
-use pkmn_lib_interface::app_interface::list::{ImmutableList, ImmutableListTrait};
+use pkmn_lib_interface::app_interface::list::ImmutableList;
 use pkmn_lib_interface::app_interface::{
     DynamicLibrary, EffectParameter, ExecutingMove, Pokemon, Statistic,
 };
@@ -34,7 +34,7 @@ impl Script for ChangeAllTargetStats {
 
     fn on_initialize(
         &self,
-        _library: &DynamicLibrary,
+        _library: DynamicLibrary,
         parameters: Option<ImmutableList<Rc<EffectParameter>>>,
     ) {
         self.amount.store(

gen_7_scripts/src/moves/change_target_stats.rs

@@ -42,7 +42,7 @@ macro_rules! change_stat_effect {
 
                 fn on_initialize(
                     &self,
-                    _library: &DynamicLibrary,
+                    _library: DynamicLibrary,
                     parameters: Option<ImmutableList<Rc<EffectParameter>>>,
                 ) {
                     self.amount.store(

gen_7_scripts/src/moves/drain.rs

@@ -3,7 +3,7 @@ use alloc::rc::Rc;
 use atomic_float::AtomicF32;
 use core::any::Any;
 use core::sync::atomic::Ordering;
-use pkmn_lib_interface::app_interface::list::{ImmutableList, ImmutableListTrait};
+use pkmn_lib_interface::app_interface::list::ImmutableList;
 use pkmn_lib_interface::app_interface::{DynamicLibrary, EffectParameter, ExecutingMove, Pokemon};
 use pkmn_lib_interface::handling::{Script, ScriptCapabilities};
 
@@ -29,7 +29,7 @@ impl Script for Drain {
 
     fn on_initialize(
         &self,
-        _library: &DynamicLibrary,
+        _library: DynamicLibrary,
         parameters: Option<ImmutableList<Rc<EffectParameter>>>,
     ) {
         self.heal_modifier.store(

pkmn_lib_interface/src/app_interface/dynamic_data/battle.rs

@@ -2,8 +2,7 @@ use alloc::rc::Rc;
 
 use crate::app_interface::list::ImmutableList;
 use crate::app_interface::{
-    BattleParty, BattlePartyImpl, BattleRandom, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon,
+    BattleParty, BattleRandom, BattleSide, ChoiceQueue, DynamicLibrary, Pokemon, StringKey,
-    StringKey,
 };
 
 #[cfg_attr(feature = "mock_data", mockall::automock)]
@@ -33,6 +32,7 @@ pub type MockBattle = MockBattleTrait;
 #[cfg(not(feature = "mock_data"))]
 mod implementation {
     use super::*;
+    use crate::app_interface::dynamic_data::dynamic_library::DynamicLibraryImpl;
     use crate::app_interface::list::{
         BattlePartyImmutableList, BattleSideImmutableList, ImmutableListWasm,
     };
@@ -44,8 +44,8 @@ mod implementation {
     use crate::handling::cached_value::CachedValue;
     use crate::handling::Cacheable;
     use crate::{
-        cached_value, cached_value_getters, wasm_value_getters, wasm_value_getters_extern,
+        cached_value, cached_value_getters, wasm_value_getters_extern, wasm_value_getters_funcs,
-        wasm_value_getters_funcs, ExternRef, ExternalReferenceType, StringKey, VecExternRef,
+        ExternRef, ExternalReferenceType, StringKey, VecExternRef,
     };
 
     struct BattleInner {
@@ -68,7 +68,9 @@ mod implementation {
             Self::from_ref(reference, &|reference| Self {
                 inner: Rc::new(BattleInner {
                     reference,
-                    library: cached_value!({ battle_get_library(reference).get_value().unwrap() }),
+                    library: cached_value!({
+                        Rc::new(battle_get_library(reference).get_value().unwrap())
+                    }),
                     parties: cached_value!({
                         let reference = battle_get_parties(reference);
                         Rc::new(BattlePartyImmutableList::from_ref(reference))
@@ -168,7 +170,7 @@ mod implementation {
 
     #[cfg(not(feature = "mock_data"))]
     extern "wasm" {
-        fn battle_get_library(r: ExternRef<BattleImpl>) -> ExternRef<DynamicLibrary>;
+        fn battle_get_library(r: ExternRef<BattleImpl>) -> ExternRef<DynamicLibraryImpl>;
         fn battle_get_parties(r: ExternRef<BattleImpl>) -> VecExternRef<BattlePartyImpl>;
         fn battle_get_sides(r: ExternRef<BattleImpl>) -> VecExternRef<BattleSideImpl>;
         fn battle_get_random(r: ExternRef<BattleImpl>) -> ExternRef<BattleRandomImpl>;

pkmn_lib_interface/src/app_interface/dynamic_data/battle_party.rs

@@ -1,7 +1,4 @@
-use crate::app_interface::{Party, PartyImpl};
+use crate::app_interface::Party;
-use crate::handling::cached_value::CachedValue;
-use crate::handling::Cacheable;
-use crate::{cached_value, cached_value_getters, ExternRef, ExternalReferenceType};
 use alloc::rc::Rc;
 
 pub trait BattlePartyTrait {
@@ -10,47 +7,58 @@ pub trait BattlePartyTrait {
 
 pub type BattleParty = Rc<dyn BattlePartyTrait>;
 
-struct BattlePartyInner {
-    reference: ExternRef<BattlePartyImpl>,
-    party: CachedValue<Rc<PartyImpl>>,
-}
-
-#[derive(Clone)]
-pub struct BattlePartyImpl {
-    inner: Rc<BattlePartyInner>,
-}
-
 #[cfg(not(feature = "mock_data"))]
-impl BattlePartyImpl {
+mod implementation {
-    pub fn new(reference: ExternRef<BattlePartyImpl>) -> Self {
+    use crate::app_interface::{BattlePartyTrait, Party, PartyImpl};
-        Self::from_ref(reference, &|reference| Self {
+    use crate::handling::cached_value::CachedValue;
-            inner: Rc::new(BattlePartyInner {
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
-                reference,
+    use crate::handling::Cacheable;
-                party: cached_value!({
+    use crate::{cached_value, cached_value_getters};
-                    Rc::new(battle_party_get_party(reference).get_value().unwrap())
+    use alloc::rc::Rc;
+
+    struct BattlePartyInner {
+        reference: ExternRef<BattlePartyImpl>,
+        party: CachedValue<Rc<PartyImpl>>,
+    }
+
+    #[derive(Clone)]
+    pub struct BattlePartyImpl {
+        inner: Rc<BattlePartyInner>,
+    }
+
+    impl BattlePartyImpl {
+        pub fn new(reference: ExternRef<BattlePartyImpl>) -> Self {
+            Self::from_ref(reference, &|reference| Self {
+                inner: Rc::new(BattlePartyInner {
+                    reference,
+                    party: cached_value!({
+                        Rc::new(battle_party_get_party(reference).get_value().unwrap())
+                    }),
                 }),
-            }),
+            })
-        })
+        }
+    }
+
+    impl BattlePartyTrait for BattlePartyImpl {
+        cached_value_getters! {
+            fn party(&self) -> Party;
+        }
+    }
+
+    crate::handling::cacheable::cacheable!(BattlePartyImpl);
+
+    #[cfg(not(feature = "mock_data"))]
+    impl ExternalReferenceType for BattlePartyImpl {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            Self::new(reference)
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    extern "wasm" {
+        fn battle_party_get_party(r: ExternRef<BattlePartyImpl>) -> ExternRef<PartyImpl>;
     }
 }
 
 #[cfg(not(feature = "mock_data"))]
-impl BattlePartyTrait for BattlePartyImpl {
+pub use implementation::*;
-    cached_value_getters! {
-        fn party(&self) -> Party;
-    }
-}
-
-crate::handling::cacheable::cacheable!(BattlePartyImpl);
-
-#[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for BattlePartyImpl {
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        Self::new(reference)
-    }
-}
-
-#[cfg(not(feature = "mock_data"))]
-extern "wasm" {
-    fn battle_party_get_party(r: ExternRef<BattlePartyImpl>) -> ExternRef<PartyImpl>;
-}

pkmn_lib_interface/src/app_interface/dynamic_data/dynamic_library.rs

@@ -1,57 +1,66 @@
 use crate::app_interface::StaticData;
-use crate::handling::cached_value::CachedValue;
-use crate::handling::Cacheable;
-use crate::{cached_value, ExternRef, ExternalReferenceType};
 use alloc::rc::Rc;
 
-struct DynamicLibraryInner {
+pub trait DynamicLibraryTrait {
-    ptr: ExternRef<DynamicLibrary>,
+    fn data_library(&self) -> StaticData;
-    static_data: CachedValue<StaticData>,
 }
 
-#[derive(Clone)]
+pub type DynamicLibrary = Rc<dyn DynamicLibraryTrait>;
-pub struct DynamicLibrary {
-    inner: Rc<DynamicLibraryInner>,
-}
 
-crate::handling::cacheable::cacheable!(DynamicLibrary);
+#[cfg(not(feature = "mock_data"))]
+mod implementation {
+    use super::*;
+    use crate::app_interface::dynamic_data::dynamic_library::DynamicLibraryTrait;
+    use crate::app_interface::StaticDataImpl;
+    use crate::cached_value;
+    use crate::handling::cached_value::CachedValue;
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
+    use crate::handling::Cacheable;
+    use alloc::rc::Rc;
 
-impl DynamicLibrary {
+    struct DynamicLibraryInner {
-    #[cfg(not(feature = "mock_data"))]
+        ptr: ExternRef<DynamicLibraryImpl>,
-    pub(crate) fn new(ptr: ExternRef<Self>) -> Self {
+        static_data: CachedValue<StaticData>,
-        Self::from_ref(ptr, &|ptr| Self {
-            inner: Rc::new(DynamicLibraryInner {
-                ptr,
-                static_data: cached_value!({
-                    dynamic_library_get_static_data(ptr).get_value().unwrap()
-                }),
-            }),
-        })
     }
 
-    #[cfg(feature = "mock_data")]
+    #[derive(Clone)]
-    pub fn new(data: StaticData) -> Self {
+    pub struct DynamicLibraryImpl {
-        Self {
+        inner: Rc<DynamicLibraryInner>,
-            inner: Rc::new(DynamicLibraryInner {
+    }
-                ptr: ExternRef::mock(),
+
-                static_data: data.into(),
+    crate::handling::cacheable::cacheable!(DynamicLibraryImpl);
-            }),
+
+    impl DynamicLibraryImpl {
+        pub(crate) fn new(ptr: ExternRef<Self>) -> Self {
+            Self::from_ref(ptr, &|ptr| Self {
+                inner: Rc::new(DynamicLibraryInner {
+                    ptr,
+                    static_data: cached_value!({
+                        Rc::new(dynamic_library_get_static_data(ptr).get_value().unwrap())
+                    }),
+                }),
+            })
         }
     }
 
-    pub fn data_library(&self) -> StaticData {
+    impl DynamicLibraryTrait for DynamicLibraryImpl {
-        self.inner.static_data.value()
+        fn data_library(&self) -> StaticData {
+            self.inner.static_data.value()
+        }
+    }
+
+    impl ExternalReferenceType for DynamicLibraryImpl {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            DynamicLibraryImpl::new(reference)
+        }
+    }
+
+    extern "wasm" {
+        fn dynamic_library_get_static_data(
+            ptr: ExternRef<DynamicLibraryImpl>,
+        ) -> ExternRef<StaticDataImpl>;
     }
 }
 
 #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for DynamicLibrary {
+pub use implementation::*;
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        DynamicLibrary::new(reference)
-    }
-}
-
-#[cfg(not(feature = "mock_data"))]
-extern "wasm" {
-    fn dynamic_library_get_static_data(ptr: ExternRef<DynamicLibrary>) -> ExternRef<StaticData>;
-}

pkmn_lib_interface/src/app_interface/dynamic_data/executing_move.rs

@@ -1,9 +1,5 @@
-#[cfg(not(feature = "mock_data"))]
-use crate::app_interface::PokemonImpl;
 use crate::app_interface::{LearnedMove, MoveData, Pokemon};
-use crate::handling::cached_value::CachedValue;
+use crate::handling::Script;
-use crate::handling::temporary::Temporary;
-use crate::{cached_value, ExternRef, ExternalReferenceType, Script};
 use alloc::rc::Rc;
 
 #[cfg_attr(feature = "mock_data", mockall::automock)]
@@ -47,6 +43,11 @@ pub use implementation::*;
 #[cfg(not(feature = "mock_data"))]
 mod implementation {
     use super::*;
+    use crate::app_interface::{LearnedMoveImpl, PokemonImpl};
+    use crate::cached_value;
+    use crate::handling::cached_value::CachedValue;
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
+    use crate::handling::temporary::Temporary;
 
     #[derive(Clone)]
     pub struct ExecutingMoveImpl {
@@ -57,7 +58,7 @@ mod implementation {
         reference: ExternRef<ExecutingMoveImpl>,
         number_of_hits: CachedValue<u8>,
         user: CachedValue<Pokemon>,
-        chosen_move: CachedValue<LearnedMove>,
+        chosen_move: CachedValue<Rc<LearnedMoveImpl>>,
         use_move: CachedValue<MoveData>,
     }
 
@@ -76,9 +77,11 @@ mod implementation {
                             Rc::new(executing_move_get_user(reference).get_value().unwrap())
                         }),
                         chosen_move: cached_value!({
-                            executing_move_get_chosen_move(reference)
+                            Rc::new(
-                                .get_value()
+                                executing_move_get_chosen_move(reference)
-                                .unwrap()
+                                    .get_value()
+                                    .unwrap(),
+                            )
                         }),
                         use_move: cached_value!({
                             executing_move_get_use_move(reference).get_value().unwrap()
@@ -196,7 +199,7 @@ mod implementation {
         fn executing_move_get_user(r: ExternRef<ExecutingMoveImpl>) -> ExternRef<PokemonImpl>;
         fn executing_move_get_chosen_move(
             r: ExternRef<ExecutingMoveImpl>,
-        ) -> ExternRef<LearnedMove>;
+        ) -> ExternRef<LearnedMoveImpl>;
         fn executing_move_get_use_move(r: ExternRef<ExecutingMoveImpl>) -> ExternRef<MoveData>;
         #[allow(improper_ctypes)]
         fn executing_move_get_script(r: ExternRef<ExecutingMoveImpl>) -> *const dyn Script;

pkmn_lib_interface/src/app_interface/dynamic_data/learned_move.rs

@@ -1,18 +1,6 @@
 use crate::app_interface::MoveData;
-use crate::handling::cacheable::Cacheable;
-use crate::handling::cached_value::CachedValue;
-use crate::{
-    cached_value, cached_value_getters, wasm_value_getters, ExternRef, ExternalReferenceType,
-};
-
 use alloc::rc::Rc;
 
-struct LearnedMoveInner {
-    reference: ExternRef<LearnedMove>,
-    move_data: CachedValue<MoveData>,
-    learn_method: CachedValue<MoveLearnMethod>,
-}
-
 #[derive(Copy, Clone, Debug, Default)]
 #[repr(u8)]
 pub enum MoveLearnMethod {
@@ -23,64 +11,89 @@ pub enum MoveLearnMethod {
     Level = 1,
 }
 
-#[derive(Clone)]
+pub trait LearnedMoveTrait {
-pub struct LearnedMove {
+    fn move_data(&self) -> MoveData;
-    inner: Rc<LearnedMoveInner>,
+    fn learn_method(&self) -> MoveLearnMethod;
+    fn restore_all_uses(&self);
+    fn restore_uses(&self, uses: u8);
 }
 
-crate::handling::cacheable::cacheable!(LearnedMove);
+pub type LearnedMove = Rc<dyn LearnedMoveTrait>;
 
 #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for LearnedMove {
+mod implementation {
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
+    use super::*;
-        Self::new(reference)
+    use crate::handling::cached_value::CachedValue;
-    }
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
-}
+    use crate::handling::Cacheable;
+    use crate::{cached_value, cached_value_getters, wasm_value_getters};
+    use alloc::rc::Rc;
 
-impl LearnedMove {
+    #[derive(Clone)]
-    #[cfg(not(feature = "mock_data"))]
+    pub struct LearnedMoveImpl {
-    pub fn new(reference: ExternRef<Self>) -> Self {
+        inner: Rc<LearnedMoveInner>,
-        Self::from_ref(reference, &|reference| Self {
+    }
-            inner: Rc::new(LearnedMoveInner {
+
-                reference,
+    struct LearnedMoveInner {
-                move_data: cached_value!({
+        reference: ExternRef<LearnedMoveImpl>,
-                    learned_move_get_move_data(reference).get_value().unwrap()
+        move_data: CachedValue<MoveData>,
+        learn_method: CachedValue<MoveLearnMethod>,
+    }
+
+    crate::handling::cacheable::cacheable!(LearnedMoveImpl);
+
+    impl ExternalReferenceType for LearnedMoveImpl {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            Self::new(reference)
+        }
+    }
+
+    impl LearnedMoveImpl {
+        pub fn new(reference: ExternRef<Self>) -> Self {
+            Self::from_ref(reference, &|reference| Self {
+                inner: Rc::new(LearnedMoveInner {
+                    reference,
+                    move_data: cached_value!({
+                        learned_move_get_move_data(reference).get_value().unwrap()
+                    }),
+                    learn_method: cached_value!({ learned_move_get_learn_method(reference) }),
                 }),
-                learn_method: cached_value!({ learned_move_get_learn_method(reference) }),
+            })
-            }),
-        })
-    }
-
-    cached_value_getters! {
-        pub fn move_data(&self) -> MoveData;
-        pub fn learn_method(&self) -> MoveLearnMethod;
-    }
-
-    #[cfg(not(feature = "mock_data"))]
-    pub fn restore_all_uses(&self) {
-        unsafe {
-            learned_move_restore_all_uses(self.inner.reference);
         }
     }
 
-    #[cfg(not(feature = "mock_data"))]
+    impl LearnedMoveTrait for LearnedMoveImpl {
-    pub fn restore_uses(&self, uses: u8) {
+        cached_value_getters! {
-        unsafe {
+            fn move_data(&self) -> MoveData;
-            learned_move_restore_uses(self.inner.reference, uses);
+            fn learn_method(&self) -> MoveLearnMethod;
+        }
+
+        fn restore_all_uses(&self) {
+            unsafe {
+                learned_move_restore_all_uses(self.inner.reference);
+            }
+        }
+
+        fn restore_uses(&self, uses: u8) {
+            unsafe {
+                learned_move_restore_uses(self.inner.reference, uses);
+            }
         }
     }
-}
 
-wasm_value_getters! {
+    wasm_value_getters! {
-    LearnedMove,
+        LearnedMoveImpl,
-    pub fn max_pp(&self) -> u8;
+        pub fn max_pp(&self) -> u8;
-    pub fn remaining_pp(&self) -> u8;
+        pub fn remaining_pp(&self) -> u8;
+    }
+
+    extern "wasm" {
+        fn learned_move_get_move_data(r: ExternRef<LearnedMoveImpl>) -> ExternRef<MoveData>;
+        fn learned_move_get_learn_method(r: ExternRef<LearnedMoveImpl>) -> MoveLearnMethod;
+        fn learned_move_restore_uses(r: ExternRef<LearnedMoveImpl>, uses: u8);
+        fn learned_move_restore_all_uses(r: ExternRef<LearnedMoveImpl>);
+    }
 }
 
 #[cfg(not(feature = "mock_data"))]
-extern "wasm" {
+pub use implementation::*;
-    fn learned_move_get_move_data(r: ExternRef<LearnedMove>) -> ExternRef<MoveData>;
-    fn learned_move_get_learn_method(r: ExternRef<LearnedMove>) -> MoveLearnMethod;
-    fn learned_move_restore_uses(r: ExternRef<LearnedMove>, uses: u8);
-    fn learned_move_restore_all_uses(r: ExternRef<LearnedMove>);
-}

pkmn_lib_interface/src/app_interface/dynamic_data/mod.rs

@@ -17,7 +17,7 @@ pub use battle_party::*;
 pub use battle_random::*;
 pub use battle_side::*;
 pub use choice_queue::*;
-pub use dynamic_library::DynamicLibrary;
+pub use dynamic_library::*;
 pub use executing_move::*;
 pub use learned_move::*;
 pub use party::*;

pkmn_lib_interface/src/app_interface/dynamic_data/party.rs

@@ -1,7 +1,4 @@
 use crate::app_interface::Pokemon;
-#[cfg(not(feature = "mock_data"))]
-use crate::app_interface::PokemonImpl;
-use crate::{ExternRef, ExternalReferenceType};
 use alloc::rc::Rc;
 
 pub trait PartyTrait {
@@ -11,45 +8,51 @@ pub trait PartyTrait {
 
 pub type Party = Rc<dyn PartyTrait>;
 
-#[derive(Clone)]
-pub struct PartyImpl {
-    reference: ExternRef<Self>,
-}
-
 #[cfg(not(feature = "mock_data"))]
-impl PartyImpl {
+mod implementation {
-    pub fn new(reference: ExternRef<PartyImpl>) -> Self {
+    use super::*;
-        Self { reference }
+    use crate::app_interface::PokemonImpl;
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
+
+    #[derive(Clone)]
+    pub struct PartyImpl {
+        reference: ExternRef<Self>,
     }
-}
 
-#[cfg(not(feature = "mock_data"))]
+    impl PartyImpl {
-impl PartyTrait for PartyImpl {
+        pub fn new(reference: ExternRef<PartyImpl>) -> Self {
-    fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
+            Self { reference }
-        unsafe {
-            let v = party_get_pokemon(self.reference, index).get_value();
-            if let Some(v) = v {
-                Some(Rc::new(v))
-            } else {
-                None
-            }
         }
     }
 
-    fn length(&self) -> usize {
+    impl PartyTrait for PartyImpl {
-        unsafe { party_get_length(self.reference) }
+        fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
+            unsafe {
+                let v = party_get_pokemon(self.reference, index).get_value();
+                if let Some(v) = v {
+                    Some(Rc::new(v))
+                } else {
+                    None
+                }
+            }
+        }
+
+        fn length(&self) -> usize {
+            unsafe { party_get_length(self.reference) }
+        }
+    }
+
+    impl ExternalReferenceType for PartyImpl {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            Self::new(reference)
+        }
+    }
+
+    extern "wasm" {
+        fn party_get_pokemon(r: ExternRef<PartyImpl>, index: usize) -> ExternRef<PokemonImpl>;
+        fn party_get_length(r: ExternRef<PartyImpl>) -> usize;
     }
 }
 
 #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for PartyImpl {
+pub use implementation::*;
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        Self::new(reference)
-    }
-}
-
-#[cfg(not(feature = "mock_data"))]
-extern "wasm" {
-    fn party_get_pokemon(r: ExternRef<PartyImpl>, index: usize) -> ExternRef<PokemonImpl>;
-    fn party_get_length(r: ExternRef<PartyImpl>) -> usize;
-}

pkmn_lib_interface/src/app_interface/dynamic_data/pokemon.rs

@@ -86,7 +86,10 @@ mod implementation {
     use super::*;
     use cstr_core::CString;
 
-    use crate::app_interface::{AbilityImpl, BattleImpl, ItemImpl, StatisticSetImpl};
+    use crate::app_interface::dynamic_data::dynamic_library::DynamicLibraryImpl;
+    use crate::app_interface::{
+        AbilityImpl, BattleImpl, ItemImpl, LearnedMoveImpl, StatisticSetImpl,
+    };
     use crate::handling::cached_value::CachedValue;
     use crate::handling::Cacheable;
     use crate::implementation::ScriptPtr;
@@ -94,7 +97,7 @@ mod implementation {
         cached_value, cached_value_getters, wasm_optional_reference_getters_extern,
         wasm_optional_reference_getters_funcs, wasm_reference_getters_extern,
         wasm_reference_getters_funcs, wasm_value_getters_extern, wasm_value_getters_funcs,
-        ExternRef, ExternalReferenceType, Script,
+        ExternRef, ExternalReferenceType,
     };
 
     struct PokemonInner {
@@ -208,7 +211,14 @@ mod implementation {
             false
         }
         fn get_learned_move(&self, index: usize) -> Option<LearnedMove> {
-            unsafe { pokemon_get_learned_move(self.inner.reference, index).get_value() }
+            unsafe {
+                let v = pokemon_get_learned_move(self.inner.reference, index).get_value();
+                if let Some(v) = v {
+                    Some(Rc::new(v))
+                } else {
+                    None
+                }
+            }
         }
         fn change_stat_boost(
             &self,
@@ -350,7 +360,9 @@ mod implementation {
             Self::from_ref(reference, &|reference| Self {
                 inner: Rc::new(PokemonInner {
                     reference,
-                    library: cached_value!({ pokemon_get_library(reference).get_value().unwrap() }),
+                    library: cached_value!({
+                        Rc::new(pokemon_get_library(reference).get_value().unwrap())
+                    }),
                     flat_stats: cached_value!({
                         Rc::new(pokemon_get_flat_stats(reference).get_value().unwrap())
                     }),
@@ -428,7 +440,7 @@ mod implementation {
     }
 
     extern "wasm" {
-        fn pokemon_get_library(r: ExternRef<PokemonImpl>) -> ExternRef<DynamicLibrary>;
+        fn pokemon_get_library(r: ExternRef<PokemonImpl>) -> ExternRef<DynamicLibraryImpl>;
         fn pokemon_get_flat_stats(r: ExternRef<PokemonImpl>) -> ExternRef<StatisticSetImpl<u32>>;
         fn pokemon_get_stat_boosts(r: ExternRef<PokemonImpl>)
             -> ExternRef<ClampedStatisticSet<i8>>;
@@ -452,7 +464,7 @@ mod implementation {
         fn pokemon_get_learned_move(
             r: ExternRef<PokemonImpl>,
             index: usize,
-        ) -> ExternRef<LearnedMove>;
+        ) -> ExternRef<LearnedMoveImpl>;
         fn pokemon_change_stat_boost(
             r: ExternRef<PokemonImpl>,
             tat: Statistic,

pkmn_lib_interface/src/app_interface/dynamic_data/turn_choices.rs

@@ -1,70 +1,8 @@
-#[cfg(not(feature = "mock_data"))]
-use crate::app_interface::PokemonImpl;
 use crate::app_interface::{LearnedMove, Pokemon};
-use crate::handling::cached_value::CachedValue;
+use crate::handling::Script;
-use crate::handling::temporary::Temporary;
-use crate::ExternRef;
-use crate::{cached_value, ExternalReferenceType, Script};
 use alloc::boxed::Box;
 use alloc::rc::Rc;
 
-pub trait BaseTurnChoiceDataTrait {
-    fn reference(&self) -> u32;
-    fn user(&self) -> Pokemon;
-    fn speed(&self) -> u32;
-    fn has_failed(&self) -> bool;
-    fn fail(&self);
-}
-
-#[cfg(not(feature = "mock_data"))]
-struct BaseTurnChoiceDataImpl {
-    reference: ExternRef<TurnChoice>,
-    user: CachedValue<Rc<PokemonImpl>>,
-}
-
-#[cfg(not(feature = "mock_data"))]
-impl BaseTurnChoiceDataTrait for BaseTurnChoiceDataImpl {
-    fn reference(&self) -> u32 {
-        self.reference.get_internal_index()
-    }
-
-    fn user(&self) -> Pokemon {
-        self.user.value()
-    }
-    fn speed(&self) -> u32 {
-        unsafe { turn_choice_get_speed(self.reference) }
-    }
-    fn has_failed(&self) -> bool {
-        unsafe { turn_choice_has_failed(self.reference) }
-    }
-    fn fail(&self) {
-        unsafe { turn_choice_fail(self.reference) }
-    }
-}
-
-pub type BaseTurnChoiceData = Rc<dyn BaseTurnChoiceDataTrait>;
-
-struct MoveTurnChoiceDataInner {
-    base: BaseTurnChoiceData,
-    used_move: CachedValue<LearnedMove>,
-    target_side: CachedValue<u8>,
-    target_index: CachedValue<u8>,
-}
-
-pub trait MoveTurnChoiceDataTrait {
-    fn base(&self) -> BaseTurnChoiceData;
-    fn used_move(&self) -> LearnedMove;
-    fn target_side(&self) -> u8;
-    fn target_index(&self) -> u8;
-    fn priority(&self) -> i8;
-    fn move_script(&self) -> Option<&Box<dyn Script>>;
-}
-
-#[derive(Clone)]
-pub struct MoveTurnChoiceDataImpl {
-    inner: Temporary<MoveTurnChoiceDataInner>,
-}
-
 pub enum TurnChoice {
     Move(Box<dyn MoveTurnChoiceDataTrait>),
     Item(),
@@ -98,78 +36,149 @@ impl TurnChoice {
     }
 }
 
-#[cfg(not(feature = "mock_data"))]
+pub trait BaseTurnChoiceDataTrait {
-impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
+    fn reference(&self) -> u32;
-    fn base(&self) -> BaseTurnChoiceData {
+    fn user(&self) -> Pokemon;
-        self.inner.value().base.clone()
+    fn speed(&self) -> u32;
-    }
+    fn has_failed(&self) -> bool;
+    fn fail(&self);
+}
 
-    fn used_move(&self) -> LearnedMove {
+pub type BaseTurnChoiceData = Rc<dyn BaseTurnChoiceDataTrait>;
-        self.inner.value().used_move.value()
+
-    }
+pub trait MoveTurnChoiceDataTrait {
-    fn target_side(&self) -> u8 {
+    fn base(&self) -> BaseTurnChoiceData;
-        self.inner.value().target_side.value()
+    fn used_move(&self) -> LearnedMove;
-    }
+    fn target_side(&self) -> u8;
-    fn target_index(&self) -> u8 {
+    fn target_index(&self) -> u8;
-        self.inner.value().target_index.value()
+    fn priority(&self) -> i8;
-    }
+    fn move_script(&self) -> Option<&Box<dyn Script>>;
-    fn priority(&self) -> i8 {
-        unsafe { turn_choice_move_priority(self.base().reference().into()) }
-    }
-    fn move_script(&self) -> Option<&Box<dyn Script>> {
-        unsafe { turn_choice_move_script(self.base().reference().into()).as_ref() }
-    }
 }
 
 #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for TurnChoice {
+mod implementation {
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
+    use super::*;
-        let kind = unsafe { turn_choice_get_kind(reference) };
+    use crate::app_interface::{LearnedMoveImpl, PokemonImpl};
-        match kind {
+    use crate::cached_value;
-            0 => TurnChoice::Move(Box::new(MoveTurnChoiceDataImpl {
+    use crate::handling::cached_value::CachedValue;
-                inner: Temporary::new(
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
-                    reference.get_internal_index(),
+    use crate::handling::temporary::Temporary;
-                    MoveTurnChoiceDataInner::from_reference(reference.cast()),
+
-                ),
+    struct BaseTurnChoiceDataImpl {
-            })),
+        reference: ExternRef<TurnChoice>,
-            _ => panic!("Unknown turn choice type"),
+        user: CachedValue<Rc<PokemonImpl>>,
+    }
+
+    impl BaseTurnChoiceDataTrait for BaseTurnChoiceDataImpl {
+        fn reference(&self) -> u32 {
+            self.reference.get_internal_index()
+        }
+
+        fn user(&self) -> Pokemon {
+            self.user.value()
+        }
+        fn speed(&self) -> u32 {
+            unsafe { turn_choice_get_speed(self.reference) }
+        }
+        fn has_failed(&self) -> bool {
+            unsafe { turn_choice_has_failed(self.reference) }
+        }
+        fn fail(&self) {
+            unsafe { turn_choice_fail(self.reference) }
         }
     }
-}
 
-#[cfg(not(feature = "mock_data"))]
+    struct MoveTurnChoiceDataInner {
-impl MoveTurnChoiceDataInner {
+        base: BaseTurnChoiceData,
-    fn from_reference(reference: ExternRef<MoveTurnChoiceDataImpl>) -> Self {
+        used_move: CachedValue<LearnedMove>,
-        Self {
+        target_side: CachedValue<u8>,
-            base: Rc::new(BaseTurnChoiceDataImpl {
+        target_index: CachedValue<u8>,
-                reference: reference.cast(),
+    }
-                user: cached_value!({
+
-                    Rc::new(turn_choice_get_user(reference.cast()).get_value().unwrap())
+    #[derive(Clone)]
+    pub struct MoveTurnChoiceDataImpl {
+        inner: Temporary<MoveTurnChoiceDataInner>,
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
+        fn base(&self) -> BaseTurnChoiceData {
+            self.inner.value().base.clone()
+        }
+
+        fn used_move(&self) -> LearnedMove {
+            self.inner.value().used_move.value()
+        }
+        fn target_side(&self) -> u8 {
+            self.inner.value().target_side.value()
+        }
+        fn target_index(&self) -> u8 {
+            self.inner.value().target_index.value()
+        }
+        fn priority(&self) -> i8 {
+            unsafe { turn_choice_move_priority(self.base().reference().into()) }
+        }
+        fn move_script(&self) -> Option<&Box<dyn Script>> {
+            unsafe { turn_choice_move_script(self.base().reference().into()).as_ref() }
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    impl ExternalReferenceType for TurnChoice {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            let kind = unsafe { turn_choice_get_kind(reference) };
+            match kind {
+                0 => TurnChoice::Move(Box::new(MoveTurnChoiceDataImpl {
+                    inner: Temporary::new(
+                        reference.get_internal_index(),
+                        MoveTurnChoiceDataInner::from_reference(reference.cast()),
+                    ),
+                })),
+                _ => panic!("Unknown turn choice type"),
+            }
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    impl MoveTurnChoiceDataInner {
+        fn from_reference(reference: ExternRef<MoveTurnChoiceDataImpl>) -> Self {
+            Self {
+                base: Rc::new(BaseTurnChoiceDataImpl {
+                    reference: reference.cast(),
+                    user: cached_value!({
+                        Rc::new(turn_choice_get_user(reference.cast()).get_value().unwrap())
+                    }),
                 }),
-            }),
+                used_move: cached_value!({
-            used_move: cached_value!({
+                    Rc::new(
-                turn_choice_move_used_move(reference.cast())
+                        turn_choice_move_used_move(reference.cast())
-                    .get_value()
+                            .get_value()
-                    .unwrap()
+                            .unwrap(),
-            }),
+                    )
-            target_side: cached_value!({ turn_choice_move_target_side(reference.cast()) }),
+                }),
-            target_index: cached_value!({ turn_choice_move_target_index(reference.cast()) }),
+                target_side: cached_value!({ turn_choice_move_target_side(reference.cast()) }),
+                target_index: cached_value!({ turn_choice_move_target_index(reference.cast()) }),
+            }
         }
     }
+
+    extern "wasm" {
+        fn turn_choice_get_kind(r: ExternRef<TurnChoice>) -> u8;
+        fn turn_choice_get_user(r: ExternRef<TurnChoice>) -> ExternRef<PokemonImpl>;
+        fn turn_choice_get_speed(r: ExternRef<TurnChoice>) -> u32;
+        fn turn_choice_has_failed(r: ExternRef<TurnChoice>) -> bool;
+        fn turn_choice_fail(r: ExternRef<TurnChoice>);
+
+        fn turn_choice_move_used_move(
+            r: ExternRef<MoveTurnChoiceDataImpl>,
+        ) -> ExternRef<LearnedMoveImpl>;
+        fn turn_choice_move_target_side(r: ExternRef<MoveTurnChoiceDataImpl>) -> u8;
+        fn turn_choice_move_target_index(r: ExternRef<MoveTurnChoiceDataImpl>) -> u8;
+        fn turn_choice_move_priority(r: ExternRef<MoveTurnChoiceDataImpl>) -> i8;
+        #[allow(improper_ctypes)]
+        fn turn_choice_move_script(r: ExternRef<MoveTurnChoiceDataImpl>) -> *const Box<dyn Script>;
+    }
 }
 
 #[cfg(not(feature = "mock_data"))]
-extern "wasm" {
+pub use implementation::*;
-    fn turn_choice_get_kind(r: ExternRef<TurnChoice>) -> u8;
-    fn turn_choice_get_user(r: ExternRef<TurnChoice>) -> ExternRef<PokemonImpl>;
-    fn turn_choice_get_speed(r: ExternRef<TurnChoice>) -> u32;
-    fn turn_choice_has_failed(r: ExternRef<TurnChoice>) -> bool;
-    fn turn_choice_fail(r: ExternRef<TurnChoice>);
-
-    fn turn_choice_move_used_move(r: ExternRef<MoveTurnChoiceDataImpl>) -> ExternRef<LearnedMove>;
-    fn turn_choice_move_target_side(r: ExternRef<MoveTurnChoiceDataImpl>) -> u8;
-    fn turn_choice_move_target_index(r: ExternRef<MoveTurnChoiceDataImpl>) -> u8;
-    fn turn_choice_move_priority(r: ExternRef<MoveTurnChoiceDataImpl>) -> i8;
-    #[allow(improper_ctypes)]
-    fn turn_choice_move_script(r: ExternRef<MoveTurnChoiceDataImpl>) -> *const Box<dyn Script>;
-}

pkmn_lib_interface/src/app_interface/list.rs

@@ -1,4 +1,3 @@
-use crate::{ExternalReferenceType, VecExternRef};
 use alloc::rc::Rc;
 
 pub trait ImmutableListTrait<T> {

pkmn_lib_interface/src/app_interface/static_data/data_libraries/item_library.rs

@@ -1,4 +1,4 @@
-use crate::app_interface::{DataLibrary, Item, ItemImpl};
+use crate::app_interface::{DataLibrary, ItemImpl};
 use crate::{ExternRef, ExternalReferenceType, StringKey};
 use alloc::rc::Rc;
 use spin::rwlock::RwLock;

pkmn_lib_interface/src/app_interface/static_data/data_libraries/mod.rs

@@ -1,232 +1,249 @@
-use crate::{cached_value, cached_value_getters, ExternRef, ExternalReferenceType, StringKey};
+use crate::app_interface::item_library::ItemLibrary;
+use crate::app_interface::move_library::MoveLibrary;
+use crate::app_interface::species_library::SpeciesLibrary;
+use crate::app_interface::type_library::TypeLibrary;
+use crate::app_interface::LevelInt;
 use alloc::rc::Rc;
-use move_library::MoveLibrary;
-use spin::rwlock::RwLock;
 
 pub mod item_library;
 pub mod move_library;
 pub mod species_library;
 pub mod type_library;
 
-use crate::app_interface::species_library::SpeciesLibrary;
+pub trait StaticDataTrait {
-use crate::app_interface::type_library::TypeLibrary;
+    fn move_library(&self) -> MoveLibrary;
-use crate::app_interface::{get_hash, LevelInt};
+    fn item_library(&self) -> ItemLibrary;
-use crate::handling::cached_value::CachedValue;
+    fn species_library(&self) -> SpeciesLibrary;
-use crate::handling::Cacheable;
+    fn type_library(&self) -> TypeLibrary;
-pub use item_library::*;
-pub use move_library::*;
-
-struct StaticDataInner {
-    reference: ExternRef<StaticData>,
-    move_library: CachedValue<MoveLibrary>,
-    item_library: CachedValue<ItemLibrary>,
-    species_library: CachedValue<SpeciesLibrary>,
-    type_library: CachedValue<TypeLibrary>,
-    settings: CachedValue<LibrarySettings>,
 }
 
-#[derive(Clone)]
+pub type StaticData = Rc<dyn StaticDataTrait>;
-pub struct StaticData {
+
-    inner: Rc<StaticDataInner>,
+pub trait LibrarySettingsTrait {
+    fn maximum_level(&self) -> LevelInt;
 }
 
-impl StaticData {
+pub type LibrarySettings = Rc<dyn LibrarySettingsTrait>;
-    #[cfg(not(feature = "mock_data"))]
+
-    pub(crate) fn new(reference: ExternRef<StaticData>) -> Self {
+#[cfg(not(feature = "mock_data"))]
-        Self::from_ref(reference, &|reference| Self {
+mod implementation {
-            inner: Rc::new(StaticDataInner {
+    use super::*;
-                reference,
+    use crate::app_interface::{get_hash, StringKey};
-                move_library: cached_value!({
+    use crate::handling::cached_value::CachedValue;
-                    static_data_get_move_library(reference).get_value().unwrap()
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
-                }),
+    use crate::handling::Cacheable;
-                item_library: cached_value!({
+    use crate::{cached_value, cached_value_getters};
-                    static_data_get_item_library(reference).get_value().unwrap()
+    use spin::RwLock;
-                }),
+
-                species_library: cached_value!({
+    struct StaticDataInner {
-                    static_data_get_species_library(reference)
+        reference: ExternRef<StaticDataImpl>,
-                        .get_value()
+        move_library: CachedValue<MoveLibrary>,
-                        .unwrap()
+        item_library: CachedValue<ItemLibrary>,
-                }),
+        species_library: CachedValue<SpeciesLibrary>,
-                type_library: cached_value!({
+        type_library: CachedValue<TypeLibrary>,
-                    static_data_get_type_library(reference).get_value().unwrap()
+        settings: CachedValue<LibrarySettings>,
-                }),
-                settings: cached_value!({
-                    static_data_get_library_settings(reference)
-                        .get_value()
-                        .unwrap()
-                }),
-            }),
-        })
     }
 
+    #[derive(Clone)]
+    pub struct StaticDataImpl {
+        inner: Rc<StaticDataInner>,
+    }
+
+    impl StaticDataImpl {
+        #[cfg(not(feature = "mock_data"))]
+        pub(crate) fn new(reference: ExternRef<StaticDataImpl>) -> Self {
+            Self::from_ref(reference, &|reference| Self {
+                inner: Rc::new(StaticDataInner {
+                    reference,
+                    move_library: cached_value!({
+                        static_data_get_move_library(reference).get_value().unwrap()
+                    }),
+                    item_library: cached_value!({
+                        static_data_get_item_library(reference).get_value().unwrap()
+                    }),
+                    species_library: cached_value!({
+                        static_data_get_species_library(reference)
+                            .get_value()
+                            .unwrap()
+                    }),
+                    type_library: cached_value!({
+                        static_data_get_type_library(reference).get_value().unwrap()
+                    }),
+                    settings: cached_value!({
+                        Rc::new(
+                            static_data_get_library_settings(reference)
+                                .get_value()
+                                .unwrap(),
+                        )
+                    }),
+                }),
+            })
+        }
+    }
+
+    impl StaticDataTrait for StaticDataImpl {
+        cached_value_getters! {
+            fn move_library(&self) -> MoveLibrary;
+            fn item_library(&self) -> ItemLibrary;
+            fn species_library(&self) -> SpeciesLibrary;
+            fn type_library(&self) -> TypeLibrary;
+        }
+    }
+
+    crate::handling::cacheable::cacheable!(StaticDataImpl);
+
+    #[cfg(not(feature = "mock_data"))]
+    impl ExternalReferenceType for StaticDataImpl {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            StaticDataImpl::new(reference)
+        }
+    }
+
+    #[derive(Clone)]
+    pub struct LibrarySettingsImpl {
+        inner: Rc<LibrarySettingsInner>,
+    }
+
+    struct LibrarySettingsInner {
+        maximum_level: CachedValue<LevelInt>,
+    }
+
+    impl LibrarySettingsImpl {
+        #[cfg(not(feature = "mock_data"))]
+        pub(crate) fn new(ptr: ExternRef<LibrarySettingsImpl>) -> Self {
+            Self {
+                inner: Rc::new(LibrarySettingsInner {
+                    maximum_level: cached_value!({ library_settings_get_maximum_level(ptr) }),
+                }),
+            }
+        }
+    }
+
+    impl LibrarySettingsTrait for LibrarySettingsImpl {
+        cached_value_getters! {
+            fn maximum_level(&self) -> LevelInt;
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    impl ExternalReferenceType for LibrarySettingsImpl {
+        fn from_extern_value(reference: ExternRef<Self>) -> Self {
+            LibrarySettingsImpl::new(reference)
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    extern "wasm" {
+        fn static_data_get_move_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<MoveLibrary>;
+        fn static_data_get_item_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<ItemLibrary>;
+        fn static_data_get_species_library(
+            ptr: ExternRef<StaticDataImpl>,
+        ) -> ExternRef<SpeciesLibrary>;
+        fn static_data_get_type_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<TypeLibrary>;
+        fn static_data_get_library_settings(
+            ptr: ExternRef<StaticDataImpl>,
+        ) -> ExternRef<LibrarySettingsImpl>;
+
+        fn library_settings_get_maximum_level(ptr: ExternRef<LibrarySettingsImpl>) -> LevelInt;
+    }
+
+    pub trait DataLibrary<T>: Cacheable
+    where
+        T: ExternalReferenceType,
+        T: Clone,
+    {
+        fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
+        fn get_self_ref(&self) -> ExternRef<Self>
+        where
+            Self: Sized;
+        fn _get_ref_by_name(ptr: ExternRef<Self>, name: ExternRef<StringKey>) -> ExternRef<T>
+        where
+            Self: Sized;
+        fn _get_ref_by_hash(ptr: ExternRef<Self>, hash: u32) -> ExternRef<T>
+        where
+            Self: Sized;
+
+        fn get(&self, name: &StringKey) -> Option<T>
+        where
+            Self: Sized,
+        {
+            if let Some(v) = self.get_cache().read().get(&name.hash()) {
+                return Some(v.clone());
+            }
+
+            let v = Self::_get_ref_by_name(self.get_self_ref(), name.ptr()).get_value();
+            if let Some(v) = &v {
+                self.get_cache().write().insert(name.hash(), v.clone());
+            }
+            v
+        }
+
+        fn get_by_str(&self, name: &str) -> Option<T>
+        where
+            Self: Sized,
+        {
+            self.get_by_hash(get_hash(name))
+        }
+
+        fn get_by_hash(&self, hash: u32) -> Option<T>
+        where
+            Self: Sized,
+        {
+            if let Some(v) = self.get_cache().read().get(&hash) {
+                return Some(v.clone());
+            }
+
+            let v = Self::_get_ref_by_hash(self.get_self_ref(), hash).get_value();
+            if let Some(v) = &v {
+                self.get_cache().write().insert(hash, v.clone());
+            }
+            v
+        }
+    }
+}
+
+#[cfg(not(feature = "mock_data"))]
+pub use implementation::*;
+
+#[cfg(feature = "mock_data")]
+mod mocked {
+    use super::*;
+    use crate::app_interface::StringKey;
+    use crate::handling::cached_value::CachedValue;
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
+    use crate::handling::Cacheable;
+    use crate::{cached_value, cached_value_getters};
+    use spin::RwLock;
+
     #[cfg(feature = "mock_data")]
-    pub fn mock(
+    pub trait DataLibrary<T>: Cacheable
-        moves: MoveLibrary,
-        items: ItemLibrary,
-        species: SpeciesLibrary,
-        types: TypeLibrary,
-        settings: LibrarySettings,
-    ) -> Self {
-        Self {
-            inner: Rc::new(StaticDataInner {
-                reference: ExternRef::mock(),
-                move_library: moves.into(),
-                item_library: items.into(),
-                species_library: species.into(),
-                type_library: types.into(),
-                settings: settings.into(),
-            }),
-        }
-    }
-
-    cached_value_getters! {
-        pub fn move_library(&self) -> MoveLibrary;
-        pub fn item_library(&self) -> ItemLibrary;
-        pub fn species_library(&self) -> SpeciesLibrary;
-        pub fn type_library(&self) -> TypeLibrary;
-    }
-}
-
-crate::handling::cacheable::cacheable!(StaticData);
-
-#[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for StaticData {
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        StaticData::new(reference)
-    }
-}
-
-struct LibrarySettingsInner {
-    maximum_level: CachedValue<LevelInt>,
-}
-
-#[derive(Clone)]
-pub struct LibrarySettings {
-    inner: Rc<LibrarySettingsInner>,
-}
-
-impl LibrarySettings {
-    #[cfg(not(feature = "mock_data"))]
-    pub(crate) fn new(ptr: ExternRef<LibrarySettings>) -> Self {
-        Self {
-            inner: Rc::new(LibrarySettingsInner {
-                maximum_level: cached_value!({ library_settings_get_maximum_level(ptr) }),
-            }),
-        }
-    }
-
-    #[cfg(feature = "mock_data")]
-    pub fn mock(maximum_level: LevelInt) -> Self {
-        Self {
-            inner: Rc::new(LibrarySettingsInner {
-                maximum_level: maximum_level.into(),
-            }),
-        }
-    }
-
-    cached_value_getters! {
-        pub fn maximum_level(&self) -> LevelInt;
-    }
-}
-
-#[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for LibrarySettings {
-    fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        LibrarySettings::new(reference)
-    }
-}
-
-#[cfg(not(feature = "mock_data"))]
-extern "wasm" {
-    fn static_data_get_move_library(ptr: ExternRef<StaticData>) -> ExternRef<MoveLibrary>;
-    fn static_data_get_item_library(ptr: ExternRef<StaticData>) -> ExternRef<ItemLibrary>;
-    fn static_data_get_species_library(ptr: ExternRef<StaticData>) -> ExternRef<SpeciesLibrary>;
-    fn static_data_get_type_library(ptr: ExternRef<StaticData>) -> ExternRef<TypeLibrary>;
-    fn static_data_get_library_settings(ptr: ExternRef<StaticData>) -> ExternRef<LibrarySettings>;
-
-    fn library_settings_get_maximum_level(ptr: ExternRef<LibrarySettings>) -> LevelInt;
-}
-
-#[cfg(not(feature = "mock_data"))]
-pub trait DataLibrary<T>: Cacheable
-where
-    T: ExternalReferenceType,
-    T: Clone,
-{
-    fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
-    fn get_self_ref(&self) -> ExternRef<Self>
     where
-        Self: Sized;
+        T: Clone,
-    fn _get_ref_by_name(ptr: ExternRef<Self>, name: ExternRef<StringKey>) -> ExternRef<T>
-    where
-        Self: Sized;
-    fn _get_ref_by_hash(ptr: ExternRef<Self>, hash: u32) -> ExternRef<T>
-    where
-        Self: Sized;
-
-    fn get(&self, name: &StringKey) -> Option<T>
-    where
-        Self: Sized,
     {
-        if let Some(v) = self.get_cache().read().get(&name.hash()) {
+        fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
-            return Some(v.clone());
+        fn get_self_ref(&self) -> ExternRef<Self>
+        where
+            Self: Sized;
+
+        fn get(&self, name: &StringKey) -> Option<T>
+        where
+            Self: Sized,
+        {
+            self.get_cache().read().get(&name.hash()).cloned()
         }
 
-        let v = Self::_get_ref_by_name(self.get_self_ref(), name.ptr()).get_value();
+        fn get_by_hash(&self, hash: u32) -> Option<T>
-        if let Some(v) = &v {
+        where
-            self.get_cache().write().insert(name.hash(), v.clone());
+            Self: Sized,
-        }
+        {
-        v
+            self.get_cache().read().get(&hash).cloned()
-    }
-
-    fn get_by_str(&self, name: &str) -> Option<T>
-    where
-        Self: Sized,
-    {
-        self.get_by_hash(get_hash(name))
-    }
-
-    fn get_by_hash(&self, hash: u32) -> Option<T>
-    where
-        Self: Sized,
-    {
-        if let Some(v) = self.get_cache().read().get(&hash) {
-            return Some(v.clone());
         }
 
-        let v = Self::_get_ref_by_hash(self.get_self_ref(), hash).get_value();
+        fn insert(&self, hash: u32, item: T) {
-        if let Some(v) = &v {
+            self.get_cache().write().insert(hash, item);
-            self.get_cache().write().insert(hash, v.clone());
         }
-        v
     }
 }
 
 #[cfg(feature = "mock_data")]
-pub trait DataLibrary<T>: Cacheable
+pub use mocked::*;
-where
-    T: Clone,
-{
-    fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
-    fn get_self_ref(&self) -> ExternRef<Self>
-    where
-        Self: Sized;
-
-    fn get(&self, name: &StringKey) -> Option<T>
-    where
-        Self: Sized,
-    {
-        self.get_cache().read().get(&name.hash()).cloned()
-    }
-
-    fn get_by_hash(&self, hash: u32) -> Option<T>
-    where
-        Self: Sized,
-    {
-        self.get_cache().read().get(&hash).cloned()
-    }
-
-    fn insert(&self, hash: u32, item: T) {
-        self.get_cache().write().insert(hash, item);
-    }
-}

pkmn_lib_interface/src/handling/script.rs

@@ -5,7 +5,6 @@ use crate::app_interface::{
 };
 use crate::handling::ScriptCapabilities;
 use crate::{ExternRef, ExternalReferenceType, StringKey};
-use alloc::boxed::Box;
 use alloc::rc::Rc;
 use core::any::Any;
 use core::fmt::Debug;
@@ -26,7 +25,7 @@ pub trait Script {
     /// This function is ran when this script starts being in effect.
     fn on_initialize(
         &self,
-        _library: &DynamicLibrary,
+        _library: DynamicLibrary,
         _parameters: Option<ImmutableList<Rc<EffectParameter>>>,
     ) {
     }

pkmn_lib_interface/src/handling/temporary.rs

@@ -41,14 +41,6 @@ impl<T> Temporary<T> {
         }
         self.value.clone()
     }
-
-    #[inline]
-    pub fn value_ref(&self) -> &T {
-        if self.is_deleted.load(Ordering::SeqCst) {
-            panic!("Accessed value after it had been deleted");
-        }
-        self.value.as_ref()
-    }
 }
 
 #[cfg(not(feature = "mock_data"))]

pkmn_lib_interface/src/lib.rs

@@ -24,7 +24,6 @@ static ALLOC: dlmalloc::GlobalDlmalloc = dlmalloc::GlobalDlmalloc {};
 
 pub(crate) use crate::app_interface::StringKey;
 pub(crate) use crate::handling::extern_ref::*;
-pub(crate) use crate::handling::Script;
 
 #[macro_use]
 #[allow(dead_code)]
@@ -36,7 +35,7 @@ pub mod utils;
 mod implementation {
     use crate::app_interface::list::{EffectParameterImmutableList, ImmutableListWasm};
     use crate::app_interface::{
-        BattleImpl, DamageSource, DynamicLibrary, EffectParameter, ExecutingMoveImpl, ItemImpl,
+        BattleImpl, DamageSource, DynamicLibraryImpl, EffectParameter, ExecutingMoveImpl, ItemImpl,
         PokemonImpl, Statistic, StringKey, TurnChoice, TypeIdentifier,
     };
     use crate::handling::extern_ref::ExternRef;
@@ -187,11 +186,11 @@ mod implementation {
 
     fn script_on_initialize(
         script: ScriptPtr,
-        library: ExternRef<DynamicLibrary>,
+        library: ExternRef<DynamicLibraryImpl>,
         parameters: VecExternRef<EffectParameter>,
     ) {
         let parameters = Rc::new(EffectParameterImmutableList::from_ref(parameters));
-        script.val().unwrap().on_initialize(&library.not_null(), Some(parameters));
+        script.val().unwrap().on_initialize(library.not_null_rc(), Some(parameters));
     }
 
     fn script_on_before_turn(

pkmn_lib_interface/src/utils.rs

@@ -1,40 +1,9 @@
-use alloc::alloc::alloc;
-use alloc::string::String;
-use core::alloc::Layout;
-#[cfg(not(feature = "mock_data"))]
-use core::panic::PanicInfo;
-#[cfg(feature = "mock_data")]
-use cstr_core::CStr;
-use cstr_core::{c_char, CString};
-
-#[cfg(not(feature = "mock_data"))]
-#[cfg(not(feature = "mock_data"))]
-extern "wasm" {
-    fn _print(s: *const u8);
-    fn _error(message: *const u8, file: *const u8, line: u32, position: u32);
-}
-
-#[cfg(not(feature = "mock_data"))]
-pub fn print_raw(s: &[u8]) {
-    unsafe {
-        let cstring = CString::from_vec_unchecked(s.to_vec());
-        _print(cstring.as_ptr());
-    }
-}
-
-#[cfg(feature = "mock_data")]
-pub fn print_raw(s: &[u8]) {
-    unsafe {
-        println!("{}", String::from_utf8_lossy(s));
-    }
-}
-
 #[macro_export]
-macro_rules! println { ($($args:tt)*) => { pkmn_lib_interface::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
+macro_rules! println { ($($args:tt)*) => { crate::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
 
 #[macro_export]
 #[cfg(debug_assertions)]
-macro_rules! dbg { ($($args:tt)*) => { pkmn_lib_interface::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
+macro_rules! dbg { ($($args:tt)*) => { crate::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
 
 #[macro_export]
 #[cfg(not(debug_assertions))]
@@ -42,43 +11,81 @@ macro_rules! dbg {
     ($($args:tt)*) => {{}};
 }
 
-#[panic_handler]
-#[no_mangle]
 #[cfg(not(feature = "mock_data"))]
-#[cfg(not(test))]
+mod implementation {
-pub fn begin_panic_handler(panic_info: &PanicInfo<'_>) -> ! {
+    use alloc::alloc::alloc;
-    let msg = CString::new(panic_info.message().unwrap().as_str().unwrap()).unwrap();
+    use core::alloc::Layout;
-    let mut line = 0;
+    use core::panic::PanicInfo;
-    let mut position = 0;
+    use cstr_core::{c_char, CString};
-    let mut file = CString::default();
+
-    if let Some(s) = panic_info.location() {
+    extern "wasm" {
-        line = s.line();
+        fn _print(s: *const u8);
-        position = s.column();
+        fn _error(message: *const u8, file: *const u8, line: u32, position: u32);
-        file = CString::new(s.file()).unwrap();
     }
 
-    unsafe {
+    #[cfg(not(feature = "mock_data"))]
-        _error(msg.as_ptr(), file.as_ptr(), line, position);
+    pub fn print_raw(s: &[u8]) {
+        unsafe {
+            let cstring = CString::from_vec_unchecked(s.to_vec());
+            _print(cstring.as_ptr());
+        }
+    }
+
+    #[panic_handler]
+    #[no_mangle]
+    #[cfg(not(feature = "mock_data"))]
+    #[cfg(not(test))]
+    pub fn begin_panic_handler(panic_info: &PanicInfo<'_>) -> ! {
+        let msg = CString::new(panic_info.message().unwrap().as_str().unwrap()).unwrap();
+        let mut line = 0;
+        let mut position = 0;
+        let mut file = CString::default();
+        if let Some(s) = panic_info.location() {
+            line = s.line();
+            position = s.column();
+            file = CString::new(s.file()).unwrap();
+        }
+
+        unsafe {
+            _error(msg.as_ptr(), file.as_ptr(), line, position);
+        }
+        loop {}
+    }
+
+    #[alloc_error_handler]
+    #[no_mangle]
+    #[cfg(not(feature = "mock_data"))]
+    #[cfg(not(test))]
+    fn allocation_error_handler(layout: core::alloc::Layout) -> ! {
+        panic!("memory allocation of {} bytes failed", layout.size())
+    }
+
+    #[no_mangle]
+    #[cfg(not(feature = "mock_data"))]
+    unsafe extern "wasm" fn allocate_mem(len: u32, align: u32) -> *mut u8 {
+        alloc(Layout::from_size_align(len as usize, align as usize).unwrap())
+    }
+
+    #[no_mangle]
+    #[cfg(not(feature = "mock_data"))]
+    unsafe extern "wasm" fn dealloc_cstring(ptr: *mut c_char) {
+        CString::from_raw(ptr);
     }
-    loop {}
 }
 
-#[alloc_error_handler]
-#[no_mangle]
 #[cfg(not(feature = "mock_data"))]
-#[cfg(not(test))]
+pub use implementation::*;
-fn allocation_error_handler(layout: core::alloc::Layout) -> ! {
+
-    panic!("memory allocation of {} bytes failed", layout.size())
+#[cfg(feature = "mock_data")]
+mod mocked {
+    use super::*;
+
+    pub fn print_raw(s: &[u8]) {
+        unsafe {
+            println!("{}", String::from_utf8_lossy(s));
+        }
+    }
 }
 
-#[no_mangle]
+#[cfg(feature = "mock_data")]
-#[cfg(not(feature = "mock_data"))]
+pub use mocked::*;
-unsafe extern "wasm" fn allocate_mem(len: u32, align: u32) -> *mut u8 {
-    alloc(Layout::from_size_align(len as usize, align as usize).unwrap())
-}
-
-#[no_mangle]
-#[cfg(not(feature = "mock_data"))]
-unsafe extern "wasm" fn dealloc_cstring(ptr: *mut c_char) {
-    CString::from_raw(ptr);
-}