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,18 +7,26 @@ pub trait BattlePartyTrait {
 
 pub type BattleParty = Rc<dyn BattlePartyTrait>;
 
-struct BattlePartyInner {
+#[cfg(not(feature = "mock_data"))]
+mod implementation {
+    use crate::app_interface::{BattlePartyTrait, Party, PartyImpl};
+    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 alloc::rc::Rc;
+
+    struct BattlePartyInner {
         reference: ExternRef<BattlePartyImpl>,
         party: CachedValue<Rc<PartyImpl>>,
-}
+    }
 
-#[derive(Clone)]
+    #[derive(Clone)]
-pub struct BattlePartyImpl {
+    pub struct BattlePartyImpl {
         inner: Rc<BattlePartyInner>,
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    impl BattlePartyImpl {
-impl BattlePartyImpl {
         pub fn new(reference: ExternRef<BattlePartyImpl>) -> Self {
             Self::from_ref(reference, &|reference| Self {
                 inner: Rc::new(BattlePartyInner {
@@ -32,25 +37,28 @@ impl BattlePartyImpl {
                 }),
             })
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    impl BattlePartyTrait for BattlePartyImpl {
-impl BattlePartyTrait for BattlePartyImpl {
         cached_value_getters! {
             fn party(&self) -> Party;
         }
-}
+    }
 
-crate::handling::cacheable::cacheable!(BattlePartyImpl);
+    crate::handling::cacheable::cacheable!(BattlePartyImpl);
 
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for BattlePartyImpl {
+    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"))]
-extern "wasm" {
+pub use implementation::*;
-    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;
+}
+
+pub type DynamicLibrary = Rc<dyn DynamicLibraryTrait>;
+
+#[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;
+
+    struct DynamicLibraryInner {
+        ptr: ExternRef<DynamicLibraryImpl>,
         static_data: CachedValue<StaticData>,
-}
+    }
 
-#[derive(Clone)]
+    #[derive(Clone)]
-pub struct DynamicLibrary {
+    pub struct DynamicLibraryImpl {
         inner: Rc<DynamicLibraryInner>,
-}
+    }
 
-crate::handling::cacheable::cacheable!(DynamicLibrary);
+    crate::handling::cacheable::cacheable!(DynamicLibraryImpl);
 
-impl DynamicLibrary {
+    impl DynamicLibraryImpl {
-    #[cfg(not(feature = "mock_data"))]
         pub(crate) fn new(ptr: ExternRef<Self>) -> Self {
             Self::from_ref(ptr, &|ptr| Self {
                 inner: Rc::new(DynamicLibraryInner {
                     ptr,
                     static_data: cached_value!({
-                    dynamic_library_get_static_data(ptr).get_value().unwrap()
+                        Rc::new(dynamic_library_get_static_data(ptr).get_value().unwrap())
                     }),
                 }),
             })
         }
-
-    #[cfg(feature = "mock_data")]
-    pub fn new(data: StaticData) -> Self {
-        Self {
-            inner: Rc::new(DynamicLibraryInner {
-                ptr: ExternRef::mock(),
-                static_data: data.into(),
-            }),
-        }
     }
 
-    pub fn data_library(&self) -> StaticData {
+    impl DynamicLibraryTrait for DynamicLibraryImpl {
+        fn data_library(&self) -> StaticData {
             self.inner.static_data.value()
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    impl ExternalReferenceType for DynamicLibraryImpl {
-impl ExternalReferenceType for DynamicLibrary {
         fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        DynamicLibrary::new(reference)
+            DynamicLibraryImpl::new(reference)
+        }
+    }
+
+    extern "wasm" {
+        fn dynamic_library_get_static_data(
+            ptr: ExternRef<DynamicLibraryImpl>,
+        ) -> ExternRef<StaticDataImpl>;
     }
 }
 
 #[cfg(not(feature = "mock_data"))]
-extern "wasm" {
+pub use implementation::*;
-    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!({
+                            Rc::new(
                                 executing_move_get_chosen_move(reference)
                                     .get_value()
-                                .unwrap()
+                                    .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,22 +11,44 @@ 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 {
+    use super::*;
+    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;
+
+    #[derive(Clone)]
+    pub struct LearnedMoveImpl {
+        inner: Rc<LearnedMoveInner>,
+    }
+
+    struct LearnedMoveInner {
+        reference: ExternRef<LearnedMoveImpl>,
+        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 LearnedMove {
+    impl LearnedMoveImpl {
-    #[cfg(not(feature = "mock_data"))]
         pub fn new(reference: ExternRef<Self>) -> Self {
             Self::from_ref(reference, &|reference| Self {
                 inner: Rc::new(LearnedMoveInner {
@@ -50,37 +60,40 @@ impl LearnedMove {
                 }),
             })
         }
-
-    cached_value_getters! {
-        pub fn move_data(&self) -> MoveData;
-        pub fn learn_method(&self) -> MoveLearnMethod;
     }
 
-    #[cfg(not(feature = "mock_data"))]
+    impl LearnedMoveTrait for LearnedMoveImpl {
-    pub fn restore_all_uses(&self) {
+        cached_value_getters! {
+            fn move_data(&self) -> MoveData;
+            fn learn_method(&self) -> MoveLearnMethod;
+        }
+
+        fn restore_all_uses(&self) {
             unsafe {
                 learned_move_restore_all_uses(self.inner.reference);
             }
         }
 
-    #[cfg(not(feature = "mock_data"))]
+        fn restore_uses(&self, uses: u8) {
-    pub 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 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,20 +8,24 @@ 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 {
+    use super::*;
+    use crate::app_interface::PokemonImpl;
+    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
+
+    #[derive(Clone)]
+    pub struct PartyImpl {
+        reference: ExternRef<Self>,
+    }
+
+    impl PartyImpl {
         pub fn new(reference: ExternRef<PartyImpl>) -> Self {
             Self { reference }
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    impl PartyTrait for PartyImpl {
-impl PartyTrait for PartyImpl {
         fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
             unsafe {
                 let v = party_get_pokemon(self.reference, index).get_value();
@@ -39,17 +40,19 @@ impl PartyTrait for PartyImpl {
         fn length(&self) -> usize {
             unsafe { party_get_length(self.reference) }
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    impl ExternalReferenceType for PartyImpl {
-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"))]
-extern "wasm" {
+pub use implementation::*;
-    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,8 +36,72 @@ impl TurnChoice {
     }
 }
 
+pub trait BaseTurnChoiceDataTrait {
+    fn reference(&self) -> u32;
+    fn user(&self) -> Pokemon;
+    fn speed(&self) -> u32;
+    fn has_failed(&self) -> bool;
+    fn fail(&self);
+}
+
+pub type BaseTurnChoiceData = Rc<dyn BaseTurnChoiceDataTrait>;
+
+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>>;
+}
+
 #[cfg(not(feature = "mock_data"))]
-impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
+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;
+
+    struct BaseTurnChoiceDataImpl {
+        reference: ExternRef<TurnChoice>,
+        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) }
+        }
+    }
+
+    struct MoveTurnChoiceDataInner {
+        base: BaseTurnChoiceData,
+        used_move: CachedValue<LearnedMove>,
+        target_side: CachedValue<u8>,
+        target_index: CachedValue<u8>,
+    }
+
+    #[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()
         }
@@ -119,10 +121,10 @@ impl MoveTurnChoiceDataTrait for MoveTurnChoiceDataImpl {
         fn move_script(&self) -> Option<&Box<dyn Script>> {
             unsafe { turn_choice_move_script(self.base().reference().into()).as_ref() }
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for TurnChoice {
+    impl ExternalReferenceType for TurnChoice {
         fn from_extern_value(reference: ExternRef<Self>) -> Self {
             let kind = unsafe { turn_choice_get_kind(reference) };
             match kind {
@@ -135,10 +137,10 @@ impl ExternalReferenceType for TurnChoice {
                 _ => panic!("Unknown turn choice type"),
             }
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-impl MoveTurnChoiceDataInner {
+    impl MoveTurnChoiceDataInner {
         fn from_reference(reference: ExternRef<MoveTurnChoiceDataImpl>) -> Self {
             Self {
                 base: Rc::new(BaseTurnChoiceDataImpl {
@@ -148,28 +150,35 @@ impl MoveTurnChoiceDataInner {
                     }),
                 }),
                 used_move: cached_value!({
+                    Rc::new(
                         turn_choice_move_used_move(reference.cast())
                             .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()) }),
             }
         }
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    extern "wasm" {
-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<LearnedMove>;
+        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"))]
+pub use implementation::*;

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,38 +1,57 @@
-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 {
+pub type StaticData = Rc<dyn StaticDataTrait>;
-    reference: ExternRef<StaticData>,
+
+pub trait LibrarySettingsTrait {
+    fn maximum_level(&self) -> LevelInt;
+}
+
+pub type LibrarySettings = Rc<dyn LibrarySettingsTrait>;
+
+#[cfg(not(feature = "mock_data"))]
+mod implementation {
+    use super::*;
+    use crate::app_interface::{get_hash, 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;
+
+    struct StaticDataInner {
+        reference: ExternRef<StaticDataImpl>,
         move_library: CachedValue<MoveLibrary>,
         item_library: CachedValue<ItemLibrary>,
         species_library: CachedValue<SpeciesLibrary>,
         type_library: CachedValue<TypeLibrary>,
         settings: CachedValue<LibrarySettings>,
-}
+    }
 
-#[derive(Clone)]
+    #[derive(Clone)]
-pub struct StaticData {
+    pub struct StaticDataImpl {
         inner: Rc<StaticDataInner>,
-}
+    }
 
-impl StaticData {
+    impl StaticDataImpl {
         #[cfg(not(feature = "mock_data"))]
-    pub(crate) fn new(reference: ExternRef<StaticData>) -> Self {
+        pub(crate) fn new(reference: ExternRef<StaticDataImpl>) -> Self {
             Self::from_ref(reference, &|reference| Self {
                 inner: Rc::new(StaticDataInner {
                     reference,
@@ -51,108 +70,88 @@ impl StaticData {
                         static_data_get_type_library(reference).get_value().unwrap()
                     }),
                     settings: cached_value!({
+                        Rc::new(
                             static_data_get_library_settings(reference)
                                 .get_value()
-                        .unwrap()
+                                .unwrap(),
+                        )
                     }),
                 }),
             })
         }
-
-    #[cfg(feature = "mock_data")]
-    pub fn mock(
-        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(),
-            }),
-        }
     }
 
+    impl StaticDataTrait for StaticDataImpl {
         cached_value_getters! {
-        pub fn move_library(&self) -> MoveLibrary;
+            fn move_library(&self) -> MoveLibrary;
-        pub fn item_library(&self) -> ItemLibrary;
+            fn item_library(&self) -> ItemLibrary;
-        pub fn species_library(&self) -> SpeciesLibrary;
+            fn species_library(&self) -> SpeciesLibrary;
-        pub fn type_library(&self) -> TypeLibrary;
+            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 {
+    crate::handling::cacheable::cacheable!(StaticDataImpl);
-    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 {
+    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) }),
                 }),
             }
         }
-
-    #[cfg(feature = "mock_data")]
-    pub fn mock(maximum_level: LevelInt) -> Self {
-        Self {
-            inner: Rc::new(LibrarySettingsInner {
-                maximum_level: maximum_level.into(),
-            }),
-        }
     }
 
+    impl LibrarySettingsTrait for LibrarySettingsImpl {
         cached_value_getters! {
-        pub fn maximum_level(&self) -> LevelInt;
+            fn maximum_level(&self) -> LevelInt;
+        }
     }
-}
 
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-impl ExternalReferenceType for LibrarySettings {
+    impl ExternalReferenceType for LibrarySettingsImpl {
         fn from_extern_value(reference: ExternRef<Self>) -> Self {
-        LibrarySettings::new(reference)
+            LibrarySettingsImpl::new(reference)
+        }
     }
-}
 
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-extern "wasm" {
+    extern "wasm" {
-    fn static_data_get_move_library(ptr: ExternRef<StaticData>) -> ExternRef<MoveLibrary>;
+        fn static_data_get_move_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<MoveLibrary>;
-    fn static_data_get_item_library(ptr: ExternRef<StaticData>) -> ExternRef<ItemLibrary>;
+        fn static_data_get_item_library(ptr: ExternRef<StaticDataImpl>) -> ExternRef<ItemLibrary>;
-    fn static_data_get_species_library(ptr: ExternRef<StaticData>) -> ExternRef<SpeciesLibrary>;
+        fn static_data_get_species_library(
-    fn static_data_get_type_library(ptr: ExternRef<StaticData>) -> ExternRef<TypeLibrary>;
+            ptr: ExternRef<StaticDataImpl>,
-    fn static_data_get_library_settings(ptr: ExternRef<StaticData>) -> ExternRef<LibrarySettings>;
+        ) -> 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<LibrarySettings>) -> LevelInt;
+        fn library_settings_get_maximum_level(ptr: ExternRef<LibrarySettingsImpl>) -> LevelInt;
-}
+    }
 
-#[cfg(not(feature = "mock_data"))]
+    pub trait DataLibrary<T>: Cacheable
-pub trait DataLibrary<T>: Cacheable
+    where
-where
         T: ExternalReferenceType,
         T: Clone,
-{
+    {
         fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
         fn get_self_ref(&self) -> ExternRef<Self>
         where
@@ -200,13 +199,27 @@ where
             }
             v
         }
+    }
 }
 
+#[cfg(not(feature = "mock_data"))]
+pub use implementation::*;
+
 #[cfg(feature = "mock_data")]
-pub trait DataLibrary<T>: Cacheable
+mod mocked {
-where
+    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 trait DataLibrary<T>: Cacheable
+    where
         T: Clone,
-{
+    {
         fn get_cache(&self) -> &RwLock<hashbrown::HashMap<u32, T>>;
         fn get_self_ref(&self) -> ExternRef<Self>
         where
@@ -229,4 +242,8 @@ where
         fn insert(&self, hash: u32, item: T) {
             self.get_cache().write().insert(hash, item);
         }
+    }
 }
+
+#[cfg(feature = "mock_data")]
+pub use mocked::*;

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,11 +11,31 @@ 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;
+    use core::alloc::Layout;
+    use core::panic::PanicInfo;
+    use cstr_core::{c_char, CString};
+
+    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());
+        }
+    }
+
+    #[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;
@@ -61,24 +50,42 @@ pub fn begin_panic_handler(panic_info: &PanicInfo<'_>) -> ! {
             _error(msg.as_ptr(), file.as_ptr(), line, position);
         }
         loop {}
-}
+    }
 
-#[alloc_error_handler]
+    #[alloc_error_handler]
-#[no_mangle]
+    #[no_mangle]
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-#[cfg(not(test))]
+    #[cfg(not(test))]
-fn allocation_error_handler(layout: core::alloc::Layout) -> ! {
+    fn allocation_error_handler(layout: core::alloc::Layout) -> ! {
         panic!("memory allocation of {} bytes failed", layout.size())
-}
+    }
 
-#[no_mangle]
+    #[no_mangle]
-#[cfg(not(feature = "mock_data"))]
+    #[cfg(not(feature = "mock_data"))]
-unsafe extern "wasm" fn allocate_mem(len: u32, align: u32) -> *mut u8 {
+    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);
+    }
 }
 
-#[no_mangle]
 #[cfg(not(feature = "mock_data"))]
-unsafe extern "wasm" fn dealloc_cstring(ptr: *mut c_char) {
+pub use implementation::*;
-    CString::from_raw(ptr);
+
+#[cfg(feature = "mock_data")]
+mod mocked {
+    use super::*;
+
+    pub fn print_raw(s: &[u8]) {
+        unsafe {
+            println!("{}", String::from_utf8_lossy(s));
+        }
+    }
 }
+
+#[cfg(feature = "mock_data")]
+pub use mocked::*;