Adds assist and assurance, fixes

pkmn_lib_interface/src/app_interface/dynamic_data/battle.rs

@@ -50,6 +50,12 @@ impl Battle {
     pub fn get_pokemon(&self, side: u8, index: u8) -> Option<Pokemon> {
         unsafe { battle_get_pokemon(self.inner.reference, side, index).get_value() }
     }
+
+    pub fn find_party_for_pokemon(&self, pokemon: &Pokemon) -> Option<BattleParty> {
+        unsafe {
+            battle_find_party_for_pokemon(self.inner.reference, pokemon.reference()).get_value()
+        }
+    }
 }
 
 wasm_value_getters! {
@@ -80,4 +86,8 @@ extern "wasm" {
     fn battle_get_random(r: ExternRef<Battle>) -> ExternRef<BattleRandom>;
     fn battle_get_choice_queue(r: ExternRef<Battle>) -> ExternRef<ChoiceQueue>;
     fn battle_get_pokemon(r: ExternRef<Battle>, side: u8, index: u8) -> ExternRef<Pokemon>;
+    fn battle_find_party_for_pokemon(
+        r: ExternRef<Battle>,
+        mon: ExternRef<Pokemon>,
+    ) -> ExternRef<BattleParty>;
 }

pkmn_lib_interface/src/app_interface/dynamic_data/battle_side.rs

@@ -1,10 +1,13 @@
 use crate::app_interface::{Battle, Pokemon};
+use crate::handling::cacheable::Cacheable;
 use crate::handling::cached_value::CachedValue;
-use crate::handling::Cacheable;
 use crate::{
     cached_value, cached_value_getters, wasm_value_getters, ExternRef, ExternalReferenceType,
+    Script, ScriptPtr,
 };
+use alloc::boxed::Box;
 use alloc::rc::Rc;
+use cstr_core::{c_char, CString};
 
 struct BattleSideInner {
     reference: ExternRef<BattleSide>,
@@ -41,6 +44,39 @@ impl BattleSide {
     pub fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
         unsafe { battleside_get_pokemon(self.inner.reference, index).get_value() }
     }
+
+    #[cfg(not(feature = "mock_data"))]
+    pub fn add_volatile(&self, script: Box<dyn Script>) -> &dyn Script {
+        unsafe {
+            battleside_add_volatile(self.inner.reference, ScriptPtr::new(script))
+                .val()
+                .unwrap()
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    pub fn remove_volatile(&self, script: &dyn Script) {
+        unsafe {
+            let name = CString::new(script.get_name()).unwrap();
+            battleside_remove_volatile(self.inner.reference, name.into_raw());
+        }
+    }
+
+    #[cfg(not(feature = "mock_data"))]
+    pub fn get_volatile<T>(&self, script_name: &str) -> Option<&T>
+    where
+        T: Script + 'static,
+    {
+        unsafe {
+            let script_name = CString::new(script_name).unwrap();
+            let s = battleside_get_volatile(self.inner.reference, script_name.into_raw()).val();
+            if let Some(s) = s {
+                Some(s.as_any().downcast_ref().unwrap())
+            } else {
+                None
+            }
+        }
+    }
 }
 
 wasm_value_getters! {
@@ -64,4 +100,10 @@ extern "wasm" {
     fn battleside_get_pokemon_per_side(r: ExternRef<BattleSide>) -> u8;
     fn battleside_get_battle(r: ExternRef<BattleSide>) -> ExternRef<Battle>;
     fn battleside_get_pokemon(r: ExternRef<BattleSide>, index: usize) -> ExternRef<Pokemon>;
+
+    fn battleside_add_volatile_by_name(r: ExternRef<BattleSide>, name: *const c_char) -> ScriptPtr;
+    fn battleside_add_volatile(r: ExternRef<BattleSide>, script: ScriptPtr) -> ScriptPtr;
+    fn battleside_has_volatile(r: ExternRef<BattleSide>, name: *const c_char) -> bool;
+    fn battleside_remove_volatile(r: ExternRef<BattleSide>, name: *const c_char);
+    fn battleside_get_volatile(r: ExternRef<BattleSide>, name: *const c_char) -> ScriptPtr;
 }

pkmn_lib_interface/src/app_interface/dynamic_data/party.rs

@@ -15,6 +15,10 @@ impl Party {
     pub fn get_pokemon(&self, index: usize) -> Option<Pokemon> {
         unsafe { party_get_pokemon(self.reference, index).get_value() }
     }
+
+    pub fn length(&self) -> usize {
+        unsafe { party_get_length(self.reference) }
+    }
 }
 
 impl ExternalReferenceType for Party {
@@ -26,4 +30,5 @@ impl ExternalReferenceType for Party {
 #[cfg(not(feature = "mock_data"))]
 extern "wasm" {
     fn party_get_pokemon(r: ExternRef<Party>, index: usize) -> ExternRef<Pokemon>;
+    fn party_get_length(r: ExternRef<Party>) -> usize;
 }

pkmn_lib_interface/src/app_interface/dynamic_data/pokemon.rs

@@ -1,7 +1,7 @@
 use crate::app_interface::ability::{Ability, AbilityIndex};
 use crate::app_interface::{
-    Battle, ClampedStatisticSet, Form, Gender, Item, LearnedMove, LevelInt, Nature, Species,
-    Statistic, StatisticSet,
+    Battle, BattleSide, ClampedStatisticSet, Form, Gender, Item, LearnedMove, LevelInt, Nature,
+    Species, Statistic, StatisticSet,
 };
 use crate::handling::cached_value::CachedValue;
 use crate::handling::Cacheable;
@@ -169,6 +169,15 @@ impl Pokemon {
     pub fn heal(&self, amount: u32, allow_revive: bool) -> bool {
         unsafe { pokemon_heal(self.inner.reference, amount, allow_revive) }
     }
+
+    #[cfg(not(feature = "mock_data"))]
+    pub fn battle_side(&self) -> BattleSide {
+        self.battle()
+            .unwrap()
+            .sides()
+            .get(self.battle_side_index() as u32)
+            .unwrap()
+    }
 }
 
 #[cfg(not(feature = "mock_data"))]

pkmn_lib_interface/src/handling/mod.rs

@@ -71,7 +71,7 @@ macro_rules! wasm_optional_reference_getters {
                 $v fn $name(&self) -> Option<$type> {
                     paste::paste!{
                         unsafe{
-                            [<$base_type:snake get_ $name>](self.inner.reference).get_value()
+                            [<$base_type:snake _get_ $name>](self.inner.reference).get_value()
                         }
                     }
                 }
@@ -83,7 +83,7 @@ macro_rules! wasm_optional_reference_getters {
 extern "wasm" {
             $(
                 paste::paste!{
-                    fn [<$base_type:snake get_ $name>](r: ExternRef<$base_type>) -> ExternRef<$type>;
+                    fn [<$base_type:snake _get_ $name>](r: ExternRef<$base_type>) -> ExternRef<$type>;
                 }
             )*
         }

pkmn_lib_interface/src/handling/script.rs

@@ -3,17 +3,15 @@ use crate::app_interface::{
     Battle, DamageSource, DynamicLibrary, EffectParameter, ExecutingMove, Item, Pokemon, Statistic,
 };
 use crate::handling::ScriptCapabilities;
-use crate::{ExternRef, StringKey, TurnChoice, TypeIdentifier};
-use core::ffi::c_void;
+use crate::{ExternRef, ExternalReferenceType, ScriptPtr, StringKey, TurnChoice, TypeIdentifier};
+use core::any::Any;
 use core::fmt::Debug;
 
 pub trait Script {
     fn new() -> Self
     where
         Self: Sized;
-    fn get_name() -> &'static str
-    where
-        Self: Sized;
+    fn get_name(&self) -> &'static str;
     fn get_capabilities(&self) -> &[ScriptCapabilities];
 
     /// This function is ran when a volatile effect is added while that volatile effect already is
@@ -343,6 +341,21 @@ pub trait Script {
     /// rate of this attempt. Pokeball modifier effects should be implemented here, as well as for
     /// example status effects that change capture rates.
     fn change_capture_rate_bonus(&self, _target: Pokemon, _pokeball: Item, _modifier: &mut u8) {}
+
+    fn as_any(&self) -> &dyn Any;
+
+    #[cfg(not(feature = "mock_data"))]
+    fn get_owner<T>(&self) -> Option<T>
+    where
+        T: ExternalReferenceType,
+        Self: Sized,
+    {
+        unsafe {
+            script_get_owner(ScriptPtr::from_existing(self))
+                .cast::<T>()
+                .get_value()
+        }
+    }
 }
 
 impl Debug for dyn Script {
@@ -351,13 +364,7 @@ impl Debug for dyn Script {
     }
 }
 
-pub trait OwnerGetter {
-    fn get_owner<T>(&self) -> Option<ExternRef<T>> {
-        unimplemented!()
-    }
-}
-
 #[cfg(not(feature = "mock_data"))]
 extern "wasm" {
-    pub fn get_script_owner(pointer: *const c_void) -> ExternRef<u8>;
+    fn script_get_owner(pointer: ScriptPtr) -> ExternRef<u8>;
 }

pkmn_lib_interface/src/lib.rs

@@ -36,6 +36,9 @@ use crate::handling::ffi_array::FFIArray;
 use crate::handling::ScriptCapabilities;
 use crate::handling::{Script, ScriptCategory};
 use alloc::boxed::Box;
+use core::sync::atomic::{AtomicU32, Ordering};
+use cstr_core::{c_char, CString};
+use hashbrown::HashMap;
 
 #[macro_use]
 #[allow(dead_code)]
@@ -71,22 +74,76 @@ macro_rules! exported_functions {
     };
 }
 
+static mut script_ptr_cache: Option<hashbrown::HashMap<*const dyn Script, u32>> = None;
+static mut script_ptr_reverse_cache: Option<hashbrown::HashMap<u32, Box<dyn Script>>> = None;
+static mut script_index_counter: AtomicU32 = AtomicU32::new(1);
+
 #[repr(C)]
 pub struct ScriptPtr {
-    ptr: *const Box<dyn Script>,
+    index: u32,
 }
 
 impl ScriptPtr {
-    pub fn new(ptr: *const Box<dyn Script>) -> Self {
-        Self { ptr }
+    fn get_cache<'a>() -> &'a mut HashMap<*const dyn Script, u32> {
+        unsafe {
+            if let None = script_ptr_cache {
+                script_ptr_cache = Some(hashbrown::HashMap::new());
+            }
+            let cache = script_ptr_cache.as_mut().unwrap();
+            cache
+        }
     }
 
-    pub fn val(&self) -> &dyn Script {
-        unsafe { self.ptr.as_ref().unwrap().as_ref() }
+    fn get_reverse_cache<'a>() -> &'a mut HashMap<u32, Box<dyn Script>> {
+        unsafe {
+            if let None = script_ptr_reverse_cache {
+                script_ptr_reverse_cache = Some(hashbrown::HashMap::new());
+            }
+            let cache = script_ptr_reverse_cache.as_mut().unwrap();
+            cache
+        }
     }
 
-    pub fn ptr(&self) -> *const Box<dyn Script> {
-        self.ptr
+    pub fn from_existing(ptr: &dyn Script) -> Self {
+        let cache = Self::get_cache();
+        let index = *cache.get(&(ptr as *const dyn Script)).unwrap();
+        Self { index }
+    }
+
+    pub fn new(ptr: Box<dyn Script>) -> Self {
+        unsafe {
+            let cache = Self::get_cache();
+            let mut index = cache.get(&(ptr.as_ref() as *const dyn Script)).cloned();
+            if index.is_none() {
+                index = Some(script_index_counter.fetch_add(1, Ordering::SeqCst));
+                let reverse_cache = Self::get_reverse_cache();
+                reverse_cache.insert(index.unwrap(), ptr);
+
+                let v = reverse_cache.get(&index.unwrap()).unwrap();
+                cache.insert(v.as_ref(), index.unwrap());
+            }
+            Self {
+                index: index.unwrap(),
+            }
+        }
+    }
+
+    pub fn null() -> Self {
+        Self { index: 0 }
+    }
+
+    pub fn val<'a, 'b>(&'a self) -> Option<&'b dyn Script> {
+        unsafe {
+            if self.index == 0 {
+                return None;
+            }
+            let cache = Self::get_reverse_cache();
+            if let Some(c) = cache.get(&self.index) {
+                Some(c.as_ref())
+            } else {
+                None
+            }
+        }
     }
 }
 
@@ -96,10 +153,10 @@ fn load_script(category: ScriptCategory, name: ExternRef<StringKey>) -> ScriptPt
     let name_c = StringKey::new(name);
     let boxed_script = unsafe { &LOAD_SCRIPT_FN }.as_ref().unwrap()(category, &name_c);
     if boxed_script.is_none() {
-        return ScriptPtr::new(core::ptr::null());
+        return ScriptPtr::null();
     }
-    let b = Box::new(boxed_script.unwrap());
-    ScriptPtr::new(Box::into_raw(b))
+    let b = boxed_script.unwrap();
+    ScriptPtr::new(b)
 }
 
 fn destroy_script(script: *mut Box<dyn Script>) {
@@ -109,17 +166,23 @@ fn destroy_script(script: *mut Box<dyn Script>) {
     drop(boxed_script);
 }
 
+fn script_get_name(script: ScriptPtr) -> *mut c_char {
+    let c = script.val().unwrap().get_name();
+    CString::new(c).unwrap().into_raw()
+}
+
+
 fn get_script_capabilities(script: ScriptPtr) -> FFIArray<ScriptCapabilities> {
-    let c = script.val().get_capabilities();
+    let c = script.val().unwrap().get_capabilities();
     FFIArray::new(c)
 }
 
 fn script_stack(script: ScriptPtr) {
-    script.val().stack();
+    script.val().unwrap().stack();
 }
 
 fn script_on_remove(script: ScriptPtr) {
-    script.val().on_remove();
+    script.val().unwrap().on_remove();
 }
 
 fn script_on_initialize(
@@ -128,14 +191,14 @@ fn script_on_initialize(
     parameters: VecExternRef<EffectParameter>,
 ) {
     let parameters = ImmutableList::from_ref(parameters);
-    script.val().on_initialize(&library.not_null(), Some(parameters));
+    script.val().unwrap().on_initialize(&library.not_null(), Some(parameters));
 }
 
 fn script_on_before_turn(
     script: ScriptPtr,
     choice: ExternRef<TurnChoice>,
 ) {
-    script.val().on_before_turn(choice.not_null())
+    script.val().unwrap().on_before_turn(choice.not_null())
 }
 
 fn script_change_speed(
@@ -143,7 +206,7 @@ fn script_change_speed(
     choice: ExternRef<TurnChoice>,
     speed: *mut u32,
 ) {
-    script.val().change_speed(choice.not_null(), speed.as_mut().unwrap())
+    script.val().unwrap().change_speed(choice.not_null(), speed.as_mut().unwrap())
 }
 
 fn script_change_priority(
@@ -151,7 +214,7 @@ fn script_change_priority(
     choice: ExternRef<TurnChoice>,
     priority: *mut i8,
 ) {
-    script.val().change_priority(choice.not_null(), priority.as_mut().unwrap())
+    script.val().unwrap().change_priority(choice.not_null(), priority.as_mut().unwrap())
 }
 
 fn script_change_move(
@@ -161,7 +224,7 @@ fn script_change_move(
 ) {
     let old = mv.as_ref().unwrap().not_null();
     let mut new = old.clone();
-    script.val().change_move(choice.not_null(), &mut new);
+    script.val().unwrap().change_move(choice.not_null(), &mut new);
     if old != new {
         *mv = new.ptr();
     }
@@ -172,7 +235,7 @@ fn script_change_number_of_hits(
     choice: ExternRef<TurnChoice>,
     out: *mut u8,
 ) {
-    script.val().change_number_of_hits(choice.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().change_number_of_hits(choice.not_null(), out.as_mut().unwrap());
 }
 
 fn script_prevent_move(
@@ -180,7 +243,7 @@ fn script_prevent_move(
     mv: ExternRef<ExecutingMove>,
     out: *mut bool,
 ) {
-    script.val().prevent_move(mv.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().prevent_move(mv.not_null(), out.as_mut().unwrap());
 }
 
 fn script_fail_move(
@@ -188,7 +251,7 @@ fn script_fail_move(
     mv: ExternRef<ExecutingMove>,
     out: *mut bool,
 ) {
-    script.val().fail_move(mv.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().fail_move(mv.not_null(), out.as_mut().unwrap());
 }
 
 fn script_stop_before_move(
@@ -196,14 +259,14 @@ fn script_stop_before_move(
     mv: ExternRef<ExecutingMove>,
     out: *mut bool,
 ) {
-    script.val().stop_before_move(mv.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().stop_before_move(mv.not_null(), out.as_mut().unwrap());
 }
 
 fn script_on_before_move(
     script: ScriptPtr,
     mv: ExternRef<ExecutingMove>,
 ) {
-    script.val().on_before_move(mv.not_null());
+    script.val().unwrap().on_before_move(mv.not_null());
 }
 
 fn script_fail_incoming_move(
@@ -212,7 +275,7 @@ fn script_fail_incoming_move(
     target: ExternRef<Pokemon>,
     out: *mut bool,
 ) {
-    script.val().fail_incoming_move(mv.not_null(), target.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().fail_incoming_move(mv.not_null(), target.not_null(), out.as_mut().unwrap());
 }
 
 fn script_is_invulnerable(
@@ -221,7 +284,7 @@ fn script_is_invulnerable(
     target: ExternRef<Pokemon>,
     out: *mut bool,
 ) {
-    script.val().is_invulnerable(mv.not_null(), target.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().is_invulnerable(mv.not_null(), target.not_null(), out.as_mut().unwrap());
 }
 
 fn script_on_move_miss(
@@ -229,7 +292,7 @@ fn script_on_move_miss(
     mv: ExternRef<ExecutingMove>,
     target: ExternRef<Pokemon>,
 ) {
-    script.val().on_move_miss(mv.not_null(), target.not_null());
+    script.val().unwrap().on_move_miss(mv.not_null(), target.not_null());
 }
 
 fn script_change_move_type(
@@ -239,7 +302,7 @@ fn script_change_move_type(
     hit: u8,
     out: *mut TypeIdentifier,
 ) {
-    script.val().change_move_type(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_move_type(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_effectiveness(
@@ -249,7 +312,7 @@ fn script_change_effectiveness(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_effectiveness(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_effectiveness(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_block_critical(
@@ -259,7 +322,7 @@ fn script_block_critical(
     hit: u8,
     out: *mut bool,
 ) {
-    script.val().block_critical(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().block_critical(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_block_incoming_critical(
@@ -269,7 +332,7 @@ fn script_block_incoming_critical(
     hit: u8,
     out: *mut bool,
 ) {
-    script.val().block_incoming_critical(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().block_incoming_critical(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_accuracy(
@@ -279,7 +342,7 @@ fn script_change_accuracy(
     hit: u8,
     out: *mut u8,
 ) {
-    script.val().change_accuracy(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_accuracy(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_critical_stage(
@@ -289,7 +352,7 @@ fn script_change_critical_stage(
     hit: u8,
     out: *mut u8,
 ) {
-    script.val().change_critical_stage(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_critical_stage(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_critical_modifier(
@@ -299,7 +362,7 @@ fn script_change_critical_modifier(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_critical_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_critical_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_stab_modifier(
@@ -309,7 +372,7 @@ fn script_change_stab_modifier(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_stab_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_stab_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_base_power(
@@ -319,7 +382,7 @@ fn script_change_base_power(
     hit: u8,
     out: *mut u8,
 ) {
-    script.val().change_base_power(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_base_power(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_bypass_defensive_stat_boost(
@@ -329,7 +392,7 @@ fn script_bypass_defensive_stat_boost(
     hit: u8,
     out: *mut bool,
 ) {
-    script.val().bypass_defensive_stat_boost(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().bypass_defensive_stat_boost(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_bypass_offensive_stat_boost(
@@ -339,7 +402,7 @@ fn script_bypass_offensive_stat_boost(
     hit: u8,
     out: *mut bool,
 ) {
-    script.val().bypass_offensive_stat_boost(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().bypass_offensive_stat_boost(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_defensive_stat_value(
@@ -349,7 +412,7 @@ fn script_change_defensive_stat_value(
     hit: u8,
     out: *mut u32,
 ) {
-    script.val().change_defensive_stat_value(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_defensive_stat_value(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_offensive_stat_value(
@@ -359,7 +422,7 @@ fn script_change_offensive_stat_value(
     hit: u8,
     out: *mut u32,
 ) {
-    script.val().change_offensive_stat_value(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_offensive_stat_value(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_damage_stat_modifier(
@@ -369,7 +432,7 @@ fn script_change_damage_stat_modifier(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_damage_stat_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_damage_stat_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_damage_modifier(
@@ -379,7 +442,7 @@ fn script_change_damage_modifier(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_damage_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_damage_modifier(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_damage(
@@ -389,7 +452,7 @@ fn script_change_damage(
     hit: u8,
     out: *mut u32,
 ) {
-    script.val().change_damage(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_damage(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_incoming_damage(
@@ -399,7 +462,7 @@ fn script_change_incoming_damage(
     hit: u8,
     out: *mut u32,
 ) {
-    script.val().change_incoming_damage(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_incoming_damage(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_on_incoming_hit(
@@ -408,7 +471,7 @@ fn script_on_incoming_hit(
     target: ExternRef<Pokemon>,
     hit: u8,
 ) {
-    script.val().on_incoming_hit(mv.not_null(), target.not_null(), hit);
+    script.val().unwrap().on_incoming_hit(mv.not_null(), target.not_null(), hit);
 }
 
 fn script_on_opponent_faints(
@@ -417,7 +480,7 @@ fn script_on_opponent_faints(
     target: ExternRef<Pokemon>,
     hit: u8,
 ) {
-    script.val().on_opponent_faints(mv.not_null(), target.not_null(), hit);
+    script.val().unwrap().on_opponent_faints(mv.not_null(), target.not_null(), hit);
 }
 
 fn script_prevent_stat_boost_change(
@@ -428,7 +491,7 @@ fn script_prevent_stat_boost_change(
     self_inflicted: u8,
     out: *mut bool,
 ) {
-    script.val().prevent_stat_boost_change(target.not_null(), stat, amount, self_inflicted == 1, out.as_mut().unwrap());
+    script.val().unwrap().prevent_stat_boost_change(target.not_null(), stat, amount, self_inflicted == 1, out.as_mut().unwrap());
 }
 
 fn script_prevent_secondary_effect(
@@ -438,7 +501,7 @@ fn script_prevent_secondary_effect(
     hit: u8,
     out: *mut bool,
 ) {
-    script.val().prevent_secondary_effect(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().prevent_secondary_effect(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_effect_chance(
@@ -448,7 +511,7 @@ fn script_change_effect_chance(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_effect_chance(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_effect_chance(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_change_incoming_effect_chance(
@@ -458,7 +521,7 @@ fn script_change_incoming_effect_chance(
     hit: u8,
     out: *mut f32,
 ) {
-    script.val().change_incoming_effect_chance(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
+    script.val().unwrap().change_incoming_effect_chance(mv.not_null(), target.not_null(), hit, out.as_mut().unwrap());
 }
 
 fn script_on_secondary_effect(
@@ -467,7 +530,7 @@ fn script_on_secondary_effect(
     target: ExternRef<Pokemon>,
     hit: u8,
 ) {
-    script.val().on_secondary_effect(mv.not_null(), target.not_null(), hit);
+    script.val().unwrap().on_secondary_effect(mv.not_null(), target.not_null(), hit);
 }
 
 fn script_on_after_hits(
@@ -475,7 +538,7 @@ fn script_on_after_hits(
     mv: ExternRef<ExecutingMove>,
     target: ExternRef<Pokemon>,
 ) {
-    script.val().on_after_hits(mv.not_null(), target.not_null());
+    script.val().unwrap().on_after_hits(mv.not_null(), target.not_null());
 }
 
 fn script_prevent_self_switch(
@@ -483,7 +546,7 @@ fn script_prevent_self_switch(
     choice: ExternRef<TurnChoice>,
     out: *mut bool,
 ) {
-    script.val().prevent_self_switch(choice.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().prevent_self_switch(choice.not_null(), out.as_mut().unwrap());
 }
 
 fn script_prevent_opponent_switch(
@@ -491,21 +554,21 @@ fn script_prevent_opponent_switch(
     choice: ExternRef<TurnChoice>,
     out: *mut bool,
 ) {
-    script.val().prevent_opponent_switch(choice.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().prevent_opponent_switch(choice.not_null(), out.as_mut().unwrap());
 }
 
 fn script_on_fail(
     script: ScriptPtr,
     pokemon: ExternRef<Pokemon>,
 ) {
-    script.val().on_fail(pokemon.not_null());
+    script.val().unwrap().on_fail(pokemon.not_null());
 }
 
 fn script_on_opponent_fail(
     script: ScriptPtr,
     pokemon: ExternRef<Pokemon>,
 ) {
-    script.val().on_opponent_fail(pokemon.not_null());
+    script.val().unwrap().on_opponent_fail(pokemon.not_null());
 }
 
 fn script_prevent_self_run_away(
@@ -513,7 +576,7 @@ fn script_prevent_self_run_away(
     choice: ExternRef<TurnChoice>,
     out: *mut bool,
 ) {
-    script.val().prevent_self_run_away(choice.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().prevent_self_run_away(choice.not_null(), out.as_mut().unwrap());
 }
 
 fn script_prevent_opponent_run_away(
@@ -521,13 +584,13 @@ fn script_prevent_opponent_run_away(
     choice: ExternRef<TurnChoice>,
     out: *mut bool,
 ) {
-    script.val().prevent_opponent_run_away(choice.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().prevent_opponent_run_away(choice.not_null(), out.as_mut().unwrap());
 }
 
 fn script_on_end_turn(
     script: ScriptPtr,
 ) {
-    script.val().on_end_turn();
+    script.val().unwrap().on_end_turn();
 }
 
 fn script_on_damage(
@@ -537,7 +600,7 @@ fn script_on_damage(
     old_health: u32,
     new_health: u32,
 ) {
-    script.val().on_damage(pokemon.not_null(), source, old_health, new_health);
+    script.val().unwrap().on_damage(pokemon.not_null(), source, old_health, new_health);
 }
 
 fn script_on_faint(
@@ -545,14 +608,14 @@ fn script_on_faint(
     pokemon: ExternRef<Pokemon>,
     source: DamageSource,
 ) {
-    script.val().on_faint(pokemon.not_null(), source);
+    script.val().unwrap().on_faint(pokemon.not_null(), source);
 }
 
 fn script_on_switch_in(
     script: ScriptPtr,
     pokemon: ExternRef<Pokemon>,
 ) {
-    script.val().on_switch_in(pokemon.not_null());
+    script.val().unwrap().on_switch_in(pokemon.not_null());
 }
 
 fn script_on_after_held_item_consume(
@@ -560,7 +623,7 @@ fn script_on_after_held_item_consume(
     pokemon: ExternRef<Pokemon>,
     item: ExternRef<Item>
 ) {
-    script.val().on_after_held_item_consume(pokemon.not_null(), &item.not_null());
+    script.val().unwrap().on_after_held_item_consume(pokemon.not_null(), &item.not_null());
 }
 
 fn script_change_experience_gained(
@@ -569,7 +632,7 @@ fn script_change_experience_gained(
     winning_pokemon: ExternRef<Pokemon>,
     out: *mut u32
 ) {
-    script.val().change_experience_gained(fainted_pokemon.not_null(), winning_pokemon.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().change_experience_gained(fainted_pokemon.not_null(), winning_pokemon.not_null(), out.as_mut().unwrap());
 }
 
 fn script_share_experience(
@@ -578,7 +641,7 @@ fn script_share_experience(
     winning_pokemon: ExternRef<Pokemon>,
     out: *mut bool,
 ) {
-    script.val().share_experience(fainted_pokemon.not_null(), winning_pokemon.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().share_experience(fainted_pokemon.not_null(), winning_pokemon.not_null(), out.as_mut().unwrap());
 }
 
 fn script_block_weather(
@@ -586,7 +649,7 @@ fn script_block_weather(
     battle: ExternRef<Battle>,
     out: *mut bool,
 ) {
-    script.val().block_weather(battle.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().block_weather(battle.not_null(), out.as_mut().unwrap());
 }
 
 fn script_change_capture_rate_bonus(
@@ -595,7 +658,7 @@ fn script_change_capture_rate_bonus(
     pokeball: ExternRef<Item>,
     out: *mut u8,
 ) {
-    script.val().change_capture_rate_bonus(target.not_null(), pokeball.not_null(), out.as_mut().unwrap());
+    script.val().unwrap().change_capture_rate_bonus(target.not_null(), pokeball.not_null(), out.as_mut().unwrap());
 }
 
 

pkmn_lib_interface/src/utils.rs

@@ -37,6 +37,9 @@ pub fn print_raw(s: &[u8]) {
 #[macro_export]
 macro_rules! println { ($($args:tt)*) => { pkmn_lib_interface::utils::print_raw(alloc::format!($($args)*).as_bytes()); } }
 
+#[macro_export]
+macro_rules! crate_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()); } }