diff --git a/gen_7_scripts/src/common_usings.rs b/gen_7_scripts/src/common_usings.rs
index bc9f967..77d471d 100644
--- a/gen_7_scripts/src/common_usings.rs
+++ b/gen_7_scripts/src/common_usings.rs
@@ -4,6 +4,7 @@ pub use alloc::rc::Rc;
 pub use alloc::vec::Vec;
 pub use atomic_float::AtomicF32;
 pub use core::any::Any;
+pub use core::num::Saturating;
 pub use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU32, Ordering};
 pub use pkmn_lib_interface::app_interface::{
     get_volatile_as, BattleSide, DamageSource, DynamicLibrary, EffectParameter, ExecutingMove,
diff --git a/gen_7_scripts/src/moves/acrobatics.rs b/gen_7_scripts/src/moves/acrobatics.rs
index b3cb268..77da40e 100755
--- a/gen_7_scripts/src/moves/acrobatics.rs
+++ b/gen_7_scripts/src/moves/acrobatics.rs
@@ -21,14 +21,10 @@ impl Script for Acrobatics {
         mv: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        base_power: &mut u8,
+        base_power: &mut Saturating<u8>,
     ) -> PkmnResult<()> {
         if mv.user().held_item()?.is_none() {
-            if *base_power >= 128_u8 {
-                *base_power = 255
-            } else {
-                *base_power *= 2;
-            }
+            *base_power *= 2;
         }
         Ok(())
     }
@@ -65,11 +61,11 @@ mod tests {
         let mv = mock_executing_move(false);
 
         let script = Acrobatics::new();
-        let mut base_power = 50u8;
+        let mut base_power = Saturating(50u8);
         script
             .change_base_power(mv, Rc::new(MockPokemon::new()), 0, &mut base_power)
             .unwrap();
-        assert_eq!(100, base_power);
+        assert_eq!(100, base_power.0);
     }
 
     #[test]
@@ -77,11 +73,11 @@ mod tests {
         let mv = mock_executing_move(false);
 
         let script = Acrobatics::new();
-        let mut base_power = 200u8;
+        let mut base_power = Saturating(200u8);
         script
             .change_base_power(mv, Rc::new(MockPokemon::new()), 0, &mut base_power)
             .unwrap();
-        assert_eq!(255, base_power);
+        assert_eq!(255, base_power.0);
     }
 
     #[test]
@@ -89,10 +85,10 @@ mod tests {
         let mv = mock_executing_move(true);
 
         let script = Acrobatics::new();
-        let mut base_power = 50u8;
+        let mut base_power = Saturating(50u8);
         script
             .change_base_power(mv, Rc::new(MockPokemon::new()), 0, &mut base_power)
             .unwrap();
-        assert_eq!(50, base_power);
+        assert_eq!(50, base_power.0);
     }
 }
diff --git a/gen_7_scripts/src/moves/assurance.rs b/gen_7_scripts/src/moves/assurance.rs
index f2ed16b..dd48a23 100755
--- a/gen_7_scripts/src/moves/assurance.rs
+++ b/gen_7_scripts/src/moves/assurance.rs
@@ -40,7 +40,7 @@ impl Script for Assurance {
         _move: ExecutingMove,
         target: Pokemon,
         _hit: u8,
-        base_power: &mut u8,
+        base_power: &mut Saturating<u8>,
     ) -> PkmnResult<()> {
         if let Some(s) = get_volatile_as::<AssuranceData>(
             target.battle_side()?.as_ref(),
diff --git a/gen_7_scripts/src/moves/increased_critical_stage.rs b/gen_7_scripts/src/moves/increased_critical_stage.rs
index 68cd01f..7d99c40 100644
--- a/gen_7_scripts/src/moves/increased_critical_stage.rs
+++ b/gen_7_scripts/src/moves/increased_critical_stage.rs
@@ -21,7 +21,7 @@ impl Script for IncreasedCriticalStage {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        stage: &mut u8,
+        stage: &mut Saturating<u8>,
     ) -> PkmnResult<()> {
         *stage += 1;
         Ok(())
diff --git a/gen_7_scripts/src/moves/multi_hit_move.rs b/gen_7_scripts/src/moves/multi_hit_move.rs
index 98df254..2bc94bb 100755
--- a/gen_7_scripts/src/moves/multi_hit_move.rs
+++ b/gen_7_scripts/src/moves/multi_hit_move.rs
@@ -21,7 +21,11 @@ impl Script for MultiHitMove {
         &[ScriptCapabilities::ChangeNumberOfHits]
     }
 
-    fn change_number_of_hits(&self, choice: TurnChoice, number_of_hits: &mut u8) -> PkmnResult<()> {
+    fn change_number_of_hits(
+        &self,
+        choice: TurnChoice,
+        number_of_hits: &mut Saturating<u8>,
+    ) -> PkmnResult<()> {
         // 35% chance that it will hit 2 times, a 35% chance it will hit 3 times, a 15% chance it
         // will hit 4 times, and a 15% chance it will hit 5 times.
         let rand_value = choice
@@ -30,12 +34,12 @@ impl Script for MultiHitMove {
             .unwrap()
             .random()
             .get_between(0, 100)?;
-        *number_of_hits = match rand_value {
+        number_of_hits.0 = match rand_value {
             0..=34 => 2,
             35..=69 => 3,
             70..=84 => 4,
             85..=100 => 5,
-            _ => *number_of_hits,
+            _ => number_of_hits.0,
         };
         Ok(())
     }
diff --git a/gen_7_scripts/src/moves/struggle.rs b/gen_7_scripts/src/moves/struggle.rs
index f087e7a..f0589fa 100644
--- a/gen_7_scripts/src/moves/struggle.rs
+++ b/gen_7_scripts/src/moves/struggle.rs
@@ -23,9 +23,9 @@ impl Script for Struggle {
     fn change_number_of_hits(
         &self,
         _choice: TurnChoice,
-        number_of_hits: &mut u8,
+        number_of_hits: &mut Saturating<u8>,
     ) -> PkmnResult<()> {
-        *number_of_hits = 1;
+        number_of_hits.0 = 1;
         Ok(())
     }
 
diff --git a/gen_7_scripts/src/side/aurora_veil_effect.rs b/gen_7_scripts/src/side/aurora_veil_effect.rs
index 50e21ef..1301059 100644
--- a/gen_7_scripts/src/side/aurora_veil_effect.rs
+++ b/gen_7_scripts/src/side/aurora_veil_effect.rs
@@ -28,7 +28,7 @@ impl Script for AuroraVeilEffect {
         mv: ExecutingMove,
         target: Pokemon,
         hit: u8,
-        damage: &mut u32,
+        damage: &mut Saturating<u32>,
     ) -> PkmnResult<()> {
         if mv.get_hit_data(&target, hit)?.is_critical()? {
             return Ok(());
@@ -48,7 +48,7 @@ impl Script for AuroraVeilEffect {
         if target.battle()?.unwrap().pokemon_per_side()? > 1 {
             modifier = 1.5
         }
-        *damage = (*damage as f32 / modifier) as u32;
+        damage.0 = (damage.0 as f32 / modifier) as u32;
         Ok(())
     }
 
diff --git a/pkmn_lib_interface/src/handling/script.rs b/pkmn_lib_interface/src/handling/script.rs
index 31217a5..41cb009 100755
--- a/pkmn_lib_interface/src/handling/script.rs
+++ b/pkmn_lib_interface/src/handling/script.rs
@@ -8,6 +8,8 @@ use alloc::rc::Rc;
 use alloc::vec::Vec;
 use core::any::Any;
 use core::fmt::{Debug, Display, Formatter};
+use core::num::Saturating;
+
 type Result<T> = crate::result::PkmnResult<T>;
 
 pub trait Script {
@@ -45,7 +47,7 @@ pub trait Script {
 
     /// This function allows you to modify the effective speed of the Pokemon. This is ran before
     /// turn ordering, so overriding here will allow you to put certain Pokemon before others.
-    fn change_speed(&self, _choice: TurnChoice, _speed: &mut u32) -> Result<()> {
+    fn change_speed(&self, _choice: TurnChoice, _speed: &mut Saturating<u32>) -> Result<()> {
         Ok(())
     }
     /// This function allows you to modify the effective priority of the Pokemon. This is ran before
@@ -63,7 +65,11 @@ pub trait Script {
     /// This function allows you to change a move into a multi-hit move. The number of hits set here
     /// gets used as the number of hits. If set to 0, this will behave as if the move missed on its
     /// first hit.
-    fn change_number_of_hits(&self, _choice: TurnChoice, _number_of_hits: &mut u8) -> Result<()> {
+    fn change_number_of_hits(
+        &self,
+        _choice: TurnChoice,
+        _number_of_hits: &mut Saturating<u8>,
+    ) -> Result<()> {
         Ok(())
     }
 
@@ -157,7 +163,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _accuracy: &mut u8,
+        _accuracy: &mut Saturating<u8>,
     ) -> Result<()> {
         Ok(())
     }
@@ -168,7 +174,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _stage: &mut u8,
+        _stage: &mut Saturating<u8>,
     ) -> Result<()> {
         Ok(())
     }
@@ -201,7 +207,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _base_power: &mut u8,
+        _base_power: &mut Saturating<u8>,
     ) -> Result<()> {
         Ok(())
     }
@@ -231,7 +237,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _amount: &mut u32,
+        _amount: &mut Saturating<u32>,
     ) -> Result<()> {
         Ok(())
     }
@@ -241,7 +247,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _amount: &mut u32,
+        _amount: &mut Saturating<u32>,
     ) -> Result<()> {
         Ok(())
     }
@@ -273,7 +279,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _damage: &mut u32,
+        _damage: &mut Saturating<u32>,
     ) -> Result<()> {
         Ok(())
     }
@@ -283,7 +289,7 @@ pub trait Script {
         _move: ExecutingMove,
         _target: Pokemon,
         _hit: u8,
-        _damage: &mut u32,
+        _damage: &mut Saturating<u32>,
     ) -> Result<()> {
         Ok(())
     }
@@ -428,7 +434,7 @@ pub trait Script {
         &self,
         _fainted_mon: Pokemon,
         _winning_mon: Pokemon,
-        _amount: &mut u32,
+        _amount: &mut Saturating<u32>,
     ) -> Result<()> {
         Ok(())
     }
@@ -454,7 +460,7 @@ pub trait Script {
         &self,
         _target: Pokemon,
         _pokeball: Item,
-        _modifier: &mut u8,
+        _modifier: &mut Saturating<u8>,
     ) -> Result<()> {
         Ok(())
     }
diff --git a/pkmn_lib_interface/src/lib.rs b/pkmn_lib_interface/src/lib.rs
index 877ce23..97d77a7 100755
--- a/pkmn_lib_interface/src/lib.rs
+++ b/pkmn_lib_interface/src/lib.rs
@@ -13,6 +13,7 @@
 #![feature(build_hasher_simple_hash_one)]
 #![feature(adt_const_params)]
 #![feature(try_trait_v2)]
+#![feature(saturating_int_impl)]
 #![cfg_attr(not(feature = "mock_data"), no_std)]
 #![allow(incomplete_features)]
 // These give false positives too often
@@ -86,8 +87,8 @@ mod implementation {
     };
 }
 
-    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_PTR_CACHE: Option<HashMap<*const dyn Script, u32>> = None;
+    static mut SCRIPT_PTR_REVERSE_CACHE: Option<HashMap<u32, Box<dyn Script>>> = None;
     static mut SCRIPT_INDEX_COUNTER: AtomicU32 = AtomicU32::new(1);
 
     #[repr(C)]
@@ -100,7 +101,7 @@ mod implementation {
         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());
+                    SCRIPT_PTR_CACHE = Some(HashMap::new());
                 }
                 let cache = SCRIPT_PTR_CACHE.as_mut().unwrap();
                 cache
@@ -110,7 +111,7 @@ mod implementation {
         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());
+                    SCRIPT_PTR_REVERSE_CACHE = Some(HashMap::new());
                 }
                 let cache = SCRIPT_PTR_REVERSE_CACHE.as_mut().unwrap();
                 cache
@@ -160,537 +161,582 @@ mod implementation {
 
     exported_functions! {
 
-    fn load_script(category: ScriptCategory, name: ExternRef<StringKey>) -> ScriptPtr {
-        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::null();
-        }
-        let b = boxed_script.unwrap();
-        ScriptPtr::new(b)
-    }
-
-    fn destroy_script(script: *mut Box<dyn Script>) {
-        // By turning it from a raw pointer back into a Box with from_raw, we give ownership back to rust.
-        // This lets Rust do the cleanup.
-        let boxed_script = Box::from_raw(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().unwrap().get_capabilities();
-        FFIArray::new(c)
-    }
-
-    fn script_stack(script: ScriptPtr) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().stack())
-    }
-
-    fn script_on_remove(script: ScriptPtr) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_remove())
-    }
-
-    fn script_on_initialize(
-        script: ScriptPtr,
-        library: ExternRef<DynamicLibraryImpl>,
-        parameters: u64,
-    ) -> WasmVoidResult {
-        let parameters : FFIArray<ExternRef<EffectParameter>> = FFIArray::from_u64(parameters);
-        let parameters = Vec::from_raw_parts(parameters.ptr(), parameters.len(), parameters.len());
-        let parameters = parameters.into_iter().map(|p| Rc::new(EffectParameter::new(p).unwrap())).collect::<Vec<_>>();
-        WasmVoidResult::from_res(script.val().unwrap().on_initialize(library.not_null_rc(), Some(parameters)))
-    }
-
-    fn script_on_before_turn(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_before_turn(choice.not_null()))
-    }
-
-    fn script_change_speed(
-        script:ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        speed: *mut u32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_speed(choice.not_null(), speed.as_mut().unwrap()))
-    }
-
-    fn script_change_priority(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        priority: *mut i8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_priority(choice.not_null(), priority.as_mut().unwrap()))
-    }
-
-    fn script_change_move(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        mv: *mut ExternRef<StringKey>,
-    ) -> WasmVoidResult {
-        let old = mv.as_ref().unwrap().not_null();
-        let mut new = old.clone();
-        let res = script.val().unwrap().change_move(choice.not_null(), &mut new);
-        match res {
-            Ok(_) => {
-                if old != new {
-                    *mv = new.ptr();
-                }
-                WasmVoidResult::ok(())
+        fn load_script(category: ScriptCategory, name: ExternRef<StringKey>) -> ScriptPtr {
+            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::null();
             }
-            Err(e) => WasmVoidResult::err(e),
+            let b = boxed_script.unwrap();
+            ScriptPtr::new(b)
         }
-    }
 
-    fn script_change_number_of_hits(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        out: *mut u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_number_of_hits(choice.not_null(), out.as_mut().unwrap()))
-    }
+        fn destroy_script(script: *mut Box<dyn Script>) {
+            // By turning it from a raw pointer back into a Box with from_raw, we give ownership back to rust.
+            // This lets Rust do the cleanup.
+            let boxed_script = Box::from_raw(script);
+            drop(boxed_script);
+        }
 
-    fn script_prevent_move(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_move(mv.not_null_rc(), out.as_mut().unwrap()))
-    }
+        fn script_get_name(script: ScriptPtr) -> *mut c_char {
+            let c = script.val().unwrap().get_name();
+            CString::new(c).unwrap().into_raw()
+        }
 
-    fn script_fail_move(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().fail_move(mv.not_null_rc(), out.as_mut().unwrap()))
-    }
 
-    fn script_stop_before_move(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().stop_before_move(mv.not_null_rc(), out.as_mut().unwrap()))
-    }
+        fn get_script_capabilities(script: ScriptPtr) -> FFIArray<ScriptCapabilities> {
+            let c = script.val().unwrap().get_capabilities();
+            FFIArray::new(c)
+        }
 
-    fn script_on_before_move(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_before_move(mv.not_null_rc()))
-    }
+        fn script_stack(script: ScriptPtr) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().stack())
+        }
 
-    fn script_fail_incoming_move(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().fail_incoming_move(mv.not_null_rc(), target.not_null_rc(), out.as_mut().unwrap()))
-    }
+        fn script_on_remove(script: ScriptPtr) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_remove())
+        }
 
-    fn script_is_invulnerable(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().is_invulnerable(mv.not_null_rc(), target.not_null_rc(), out.as_mut().unwrap()))
-    }
+        fn script_on_initialize(
+            script: ScriptPtr,
+            library: ExternRef<DynamicLibraryImpl>,
+            parameters: u64,
+        ) -> WasmVoidResult {
+            let parameters : FFIArray<ExternRef<EffectParameter>> = FFIArray::from_u64(parameters);
+            let parameters = Vec::from_raw_parts(parameters.ptr(), parameters.len(), parameters.len());
+            let parameters = parameters.into_iter().map(|p| Rc::new(EffectParameter::new(p).unwrap())).collect::<Vec<_>>();
+            WasmVoidResult::from_res(script.val().unwrap().on_initialize(library.not_null_rc(), Some(parameters)))
+        }
 
-    fn script_on_move_miss(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_move_miss(mv.not_null_rc(), target.not_null_rc()))
-    }
+        fn script_on_before_turn(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_before_turn(choice.not_null()))
+        }
 
-    fn script_change_move_type(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut TypeIdentifier,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_move_type(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_speed(
+            script:ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            speed: *mut u32,
+        ) -> WasmVoidResult {
+            let out = speed.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*speed);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_speed(choice.not_null(), &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_change_effectiveness(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_effectiveness(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_priority(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            priority: *mut i8,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_priority(choice.not_null(), priority.as_mut().unwrap()))
+        }
 
-    fn script_block_critical(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().block_critical(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_move(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            mv: *mut ExternRef<StringKey>,
+        ) -> WasmVoidResult {
+            let old = mv.as_ref().unwrap().not_null();
+            let mut new = old.clone();
+            let res = script.val().unwrap().change_move(choice.not_null(), &mut new);
+            match res {
+                Ok(_) => {
+                    if old != new {
+                        *mv = new.ptr();
+                    }
+                    WasmVoidResult::ok(())
+                }
+                Err(e) => WasmVoidResult::err(e),
+            }
+        }
 
-    fn script_block_incoming_critical(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().block_incoming_critical(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_number_of_hits(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            out: *mut u8,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_number_of_hits(choice.not_null(), &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_change_accuracy(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_accuracy(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_prevent_move(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_move(mv.not_null_rc(), out.as_mut().unwrap()))
+        }
 
-    fn script_change_critical_stage(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_critical_stage(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_fail_move(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().fail_move(mv.not_null_rc(), out.as_mut().unwrap()))
+        }
 
-    fn script_change_critical_modifier(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_critical_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_stop_before_move(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().stop_before_move(mv.not_null_rc(), out.as_mut().unwrap()))
+        }
 
-    fn script_change_stab_modifier(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_stab_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_on_before_move(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_before_move(mv.not_null_rc()))
+        }
 
-    fn script_change_base_power(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_base_power(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_fail_incoming_move(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().fail_incoming_move(mv.not_null_rc(), target.not_null_rc(), out.as_mut().unwrap()))
+        }
 
-    fn script_bypass_defensive_stat_boost(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().bypass_defensive_stat_boost(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_is_invulnerable(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().is_invulnerable(mv.not_null_rc(), target.not_null_rc(), out.as_mut().unwrap()))
+        }
 
-    fn script_bypass_offensive_stat_boost(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().bypass_offensive_stat_boost(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_on_move_miss(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_move_miss(mv.not_null_rc(), target.not_null_rc()))
+        }
 
-    fn script_change_defensive_stat_value(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_defensive_stat_value(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_move_type(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut TypeIdentifier,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_move_type(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_change_offensive_stat_value(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_offensive_stat_value(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_effectiveness(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_effectiveness(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_change_damage_stat_modifier(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_damage_stat_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_block_critical(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().block_critical(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_change_damage_modifier(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_damage_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_block_incoming_critical(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().block_incoming_critical(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_change_damage(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_damage(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_accuracy(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u8,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_accuracy(mv.not_null_rc(), target.not_null_rc(), hit, &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_change_incoming_damage(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut u32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_incoming_damage(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_critical_stage(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u8,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_critical_stage(mv.not_null_rc(), target.not_null_rc(), hit, &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_on_incoming_hit(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_incoming_hit(mv.not_null_rc(), target.not_null_rc(), hit))
-    }
+        fn script_change_critical_modifier(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_critical_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_on_opponent_faints(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_opponent_faints(mv.not_null_rc(), target.not_null_rc(), hit))
-    }
+        fn script_change_stab_modifier(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_stab_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_prevent_stat_boost_change(
-        script: ScriptPtr,
-        target: ExternRef<PokemonImpl>,
-        stat: Statistic,
-        amount: i8,
-        self_inflicted: u8,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_stat_boost_change(target.not_null_rc(), stat, amount, self_inflicted == 1, out.as_mut().unwrap()))
-    }
+        fn script_change_base_power(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u8,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_base_power(mv.not_null_rc(), target.not_null_rc(), hit,
+                    &mut out_saturating));
+            *out = out_saturating.0;
+            res
+        }
 
-    fn script_prevent_secondary_effect(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_secondary_effect(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_bypass_defensive_stat_boost(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().bypass_defensive_stat_boost(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_change_effect_chance(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_effect_chance(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_bypass_offensive_stat_boost(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().bypass_offensive_stat_boost(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_change_incoming_effect_chance(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-        out: *mut f32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_incoming_effect_chance(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
-    }
+        fn script_change_defensive_stat_value(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u32,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_defensive_stat_value(mv.not_null_rc(), target.not_null_rc(), hit, &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_on_secondary_effect(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-        hit: u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_secondary_effect(mv.not_null_rc(), target.not_null_rc(), hit))
-    }
+        fn script_change_offensive_stat_value(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u32,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_offensive_stat_value(mv.not_null_rc(), target.not_null_rc(), hit, &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_on_after_hits(
-        script: ScriptPtr,
-        mv: ExternRef<ExecutingMoveImpl>,
-        target: ExternRef<PokemonImpl>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_after_hits(mv.not_null_rc(), target.not_null_rc()))
-    }
+        fn script_change_damage_stat_modifier(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_damage_stat_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_prevent_self_switch(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_self_switch(choice.not_null(), out.as_mut().unwrap()))
-    }
+        fn script_change_damage_modifier(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_damage_modifier(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_prevent_opponent_switch(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_opponent_switch(choice.not_null(), out.as_mut().unwrap()))
-    }
+        fn script_change_damage(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u32,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_damage(mv.not_null_rc(), target.not_null_rc(), hit, &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_on_fail(
-        script: ScriptPtr,
-        pokemon: ExternRef<PokemonImpl>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_fail(pokemon.not_null_rc()))
-    }
+        fn script_change_incoming_damage(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut u32,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_incoming_damage(mv.not_null_rc(), target.not_null_rc(), hit, &mut out_saturating));
+            *out = out_saturating.0;
+            return res;
+        }
 
-    fn script_on_opponent_fail(
-        script: ScriptPtr,
-        pokemon: ExternRef<PokemonImpl>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_opponent_fail(pokemon.not_null_rc()))
-    }
+        fn script_on_incoming_hit(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_incoming_hit(mv.not_null_rc(), target.not_null_rc(), hit))
+        }
 
-    fn script_prevent_self_run_away(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_self_run_away(choice.not_null(), out.as_mut().unwrap()))
-    }
+        fn script_on_opponent_faints(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_opponent_faints(mv.not_null_rc(), target.not_null_rc(), hit))
+        }
 
-    fn script_prevent_opponent_run_away(
-        script: ScriptPtr,
-        choice: ExternRef<TurnChoice>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().prevent_opponent_run_away(choice.not_null(), out.as_mut().unwrap()))
-    }
+        fn script_prevent_stat_boost_change(
+            script: ScriptPtr,
+            target: ExternRef<PokemonImpl>,
+            stat: Statistic,
+            amount: i8,
+            self_inflicted: u8,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_stat_boost_change(target.not_null_rc(), stat, amount, self_inflicted == 1, out.as_mut().unwrap()))
+        }
 
-    fn script_on_end_turn(
-        script: ScriptPtr,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_end_turn())
-    }
+        fn script_prevent_secondary_effect(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_secondary_effect(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_on_damage(
-        script: ScriptPtr,
-        pokemon: ExternRef<PokemonImpl>,
-        source: DamageSource,
-        old_health: u32,
-        new_health: u32,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_damage(pokemon.not_null_rc(), source, old_health, new_health))
-    }
+        fn script_change_effect_chance(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_effect_chance(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_on_faint(
-        script: ScriptPtr,
-        pokemon: ExternRef<PokemonImpl>,
-        source: DamageSource,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_faint(pokemon.not_null_rc(), source))
-    }
+        fn script_change_incoming_effect_chance(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+            out: *mut f32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().change_incoming_effect_chance(mv.not_null_rc(), target.not_null_rc(), hit, out.as_mut().unwrap()))
+        }
 
-    fn script_on_switch_in(
-        script: ScriptPtr,
-        pokemon: ExternRef<PokemonImpl>,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_switch_in(pokemon.not_null_rc()))
-    }
+        fn script_on_secondary_effect(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+            hit: u8,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_secondary_effect(mv.not_null_rc(), target.not_null_rc(), hit))
+        }
 
-    fn script_on_after_held_item_consume(
-        script: ScriptPtr,
-        pokemon: ExternRef<PokemonImpl>,
-        item: ExternRef<ItemImpl>
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().on_after_held_item_consume(pokemon.not_null_rc(), item.not_null_rc()))
-    }
+        fn script_on_after_hits(
+            script: ScriptPtr,
+            mv: ExternRef<ExecutingMoveImpl>,
+            target: ExternRef<PokemonImpl>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_after_hits(mv.not_null_rc(), target.not_null_rc()))
+        }
 
-    fn script_change_experience_gained(
-        script: ScriptPtr,
-        fainted_pokemon: ExternRef<PokemonImpl>,
-        winning_pokemon: ExternRef<PokemonImpl>,
-        out: *mut u32
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_experience_gained(
-                fainted_pokemon.not_null_rc(),
-                winning_pokemon.not_null_rc(),
-                out.as_mut().unwrap()
-        ))
-    }
+        fn script_prevent_self_switch(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_self_switch(choice.not_null(), out.as_mut().unwrap()))
+        }
 
-    fn script_share_experience(
-        script: ScriptPtr,
-        fainted_pokemon: ExternRef<PokemonImpl>,
-        winning_pokemon: ExternRef<PokemonImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().share_experience(
-                fainted_pokemon.not_null_rc(),
-                winning_pokemon.not_null_rc(),
-                out.as_mut().unwrap()
-        ))
-    }
+        fn script_prevent_opponent_switch(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_opponent_switch(choice.not_null(), out.as_mut().unwrap()))
+        }
 
-    fn script_block_weather(
-        script: ScriptPtr,
-        battle: ExternRef<BattleImpl>,
-        out: *mut bool,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().block_weather(battle.not_null_rc(), out.as_mut().unwrap()))
-    }
+        fn script_on_fail(
+            script: ScriptPtr,
+            pokemon: ExternRef<PokemonImpl>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_fail(pokemon.not_null_rc()))
+        }
 
-    fn script_change_capture_rate_bonus(
-        script: ScriptPtr,
-        target: ExternRef<PokemonImpl>,
-        pokeball: ExternRef<ItemImpl>,
-        out: *mut u8,
-    ) -> WasmVoidResult {
-        WasmVoidResult::from_res(script.val().unwrap().change_capture_rate_bonus(
-                target.not_null_rc(),
-                pokeball.not_null_rc(),
-                out.as_mut().unwrap()
-        ))
-    }
+        fn script_on_opponent_fail(
+            script: ScriptPtr,
+            pokemon: ExternRef<PokemonImpl>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_opponent_fail(pokemon.not_null_rc()))
+        }
+
+        fn script_prevent_self_run_away(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_self_run_away(choice.not_null(), out.as_mut().unwrap()))
+        }
+
+        fn script_prevent_opponent_run_away(
+            script: ScriptPtr,
+            choice: ExternRef<TurnChoice>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().prevent_opponent_run_away(choice.not_null(), out.as_mut().unwrap()))
+        }
+
+        fn script_on_end_turn(
+            script: ScriptPtr,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_end_turn())
+        }
+
+        fn script_on_damage(
+            script: ScriptPtr,
+            pokemon: ExternRef<PokemonImpl>,
+            source: DamageSource,
+            old_health: u32,
+            new_health: u32,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_damage(pokemon.not_null_rc(), source, old_health, new_health))
+        }
+
+        fn script_on_faint(
+            script: ScriptPtr,
+            pokemon: ExternRef<PokemonImpl>,
+            source: DamageSource,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_faint(pokemon.not_null_rc(), source))
+        }
+
+        fn script_on_switch_in(
+            script: ScriptPtr,
+            pokemon: ExternRef<PokemonImpl>,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_switch_in(pokemon.not_null_rc()))
+        }
+
+        fn script_on_after_held_item_consume(
+            script: ScriptPtr,
+            pokemon: ExternRef<PokemonImpl>,
+            item: ExternRef<ItemImpl>
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().on_after_held_item_consume(pokemon.not_null_rc(), item.not_null_rc()))
+        }
+
+        fn script_change_experience_gained(
+            script: ScriptPtr,
+            fainted_pokemon: ExternRef<PokemonImpl>,
+            winning_pokemon: ExternRef<PokemonImpl>,
+            out: *mut u32
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_experience_gained(
+                    fainted_pokemon.not_null_rc(),
+                    winning_pokemon.not_null_rc(),
+                    &mut out_saturating
+            ));
+            *out = out_saturating.0;
+            return res;
+        }
+
+        fn script_share_experience(
+            script: ScriptPtr,
+            fainted_pokemon: ExternRef<PokemonImpl>,
+            winning_pokemon: ExternRef<PokemonImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().share_experience(
+                    fainted_pokemon.not_null_rc(),
+                    winning_pokemon.not_null_rc(),
+                    out.as_mut().unwrap()
+            ))
+        }
+
+        fn script_block_weather(
+            script: ScriptPtr,
+            battle: ExternRef<BattleImpl>,
+            out: *mut bool,
+        ) -> WasmVoidResult {
+            WasmVoidResult::from_res(script.val().unwrap().block_weather(battle.not_null_rc(), out.as_mut().unwrap()))
+        }
+
+        fn script_change_capture_rate_bonus(
+            script: ScriptPtr,
+            target: ExternRef<PokemonImpl>,
+            pokeball: ExternRef<ItemImpl>,
+            out: *mut u8,
+        ) -> WasmVoidResult {
+            let out = out.as_mut().unwrap();
+            let mut out_saturating = core::num::Saturating(*out);
+            let res = WasmVoidResult::from_res(script.val().unwrap().change_capture_rate_bonus(
+                    target.not_null_rc(),
+                    pokeball.not_null_rc(),
+                    &mut out_saturating
+            ));
+            *out = out_saturating.0;
+            return res;
+        }
     }
 }