Support for errors from scripts through separate script error handling.

src/script_implementations/wasm/script.rs

@@ -1,3 +1,4 @@
+use anyhow_ext::Result;
 use std::any::Any;
 use std::sync::atomic::{AtomicBool, AtomicUsize};
 use std::sync::Arc;
@@ -93,8 +94,8 @@ macro_rules! vec_ex_ref {
 }
 
 impl Script for WebAssemblyScript {
-    fn name(&self) -> &StringKey {
-        &self.name
+    fn name(&self) -> Result<&StringKey> {
+        Ok(&self.name)
     }
 
     fn get_marked_for_deletion(&self) -> &AtomicBool {
@@ -105,50 +106,54 @@ impl Script for WebAssemblyScript {
         &self.suppressed_count
     }
 
-    fn stack(&self) {
+    fn stack(&self) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnStack) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().stack(env) {
             call_func!(func, env, self);
         }
+        Ok(())
     }
 
-    fn on_remove(&self) {
+    fn on_remove(&self) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnRemove) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_remove(env) {
             call_func!(func, env, self);
         }
+        Ok(())
     }
 
-    fn on_initialize(&self, library: &Arc<dyn DynamicLibrary>, pars: Vec<EffectParameter>) {
+    fn on_initialize(&self, library: &Arc<dyn DynamicLibrary>, pars: Vec<EffectParameter>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::Initialize) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_initialize(env) {
             call_func!(func, env, self, ex_ref!(env, library), vec_ex_ref!(env, &pars));
         }
+        Ok(())
     }
 
-    fn on_before_turn(&self, choice: &TurnChoice) {
+    fn on_before_turn(&self, choice: &TurnChoice) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnBeforeTurn) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_before_turn(env) {
             call_func!(func, env, self, ex_ref!(env, choice));
         }
+        Ok(())
     }
 
-    fn change_speed(&self, choice: &TurnChoice, speed: &mut u32) {
+    fn change_speed(&self, choice: &TurnChoice, speed: &mut u32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeSpeed) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -157,11 +162,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *speed = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_priority(&self, choice: &TurnChoice, priority: &mut i8) {
+    fn change_priority(&self, choice: &TurnChoice, priority: &mut i8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangePriority) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -170,11 +176,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *priority = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_move(&self, choice: &TurnChoice, move_name: &mut StringKey) {
+    fn change_move(&self, choice: &TurnChoice, move_name: &mut StringKey) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeMove) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -184,11 +191,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *move_name = ptr.value().value(env).unwrap().clone();
         }
+        Ok(())
     }
 
-    fn change_number_of_hits(&self, choice: &TurnChoice, number_of_hits: &mut u8) {
+    fn change_number_of_hits(&self, choice: &TurnChoice, number_of_hits: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeNumberOfHits) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -197,11 +205,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *number_of_hits = *ptr.value();
         }
+        Ok(())
     }
 
-    fn prevent_move(&self, mv: &ExecutingMove, prevent: &mut bool) {
+    fn prevent_move(&self, mv: &ExecutingMove, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventMove) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -210,11 +219,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ptr.wasm_ptr);
             *prevent = *ptr.value();
         }
+        Ok(())
     }
 
-    fn fail_move(&self, mv: &ExecutingMove, fail: &mut bool) {
+    fn fail_move(&self, mv: &ExecutingMove, fail: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::FailMove) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -223,11 +233,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ptr.wasm_ptr);
             *fail = *ptr.value();
         }
+        Ok(())
     }
 
-    fn stop_before_move(&self, mv: &ExecutingMove, stop: &mut bool) {
+    fn stop_before_move(&self, mv: &ExecutingMove, stop: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::StopBeforeMove) {
-            return;
+            return Ok(());
         }
 
         let env = &self.environment;
@@ -236,21 +247,23 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ptr.wasm_ptr);
             *stop = *ptr.value();
         }
+        Ok(())
     }
 
-    fn on_before_move(&self, mv: &ExecutingMove) {
+    fn on_before_move(&self, mv: &ExecutingMove) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnBeforeMove) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_before_move(env) {
             call_func!(func, env, self, ex_ref!(env, mv));
         }
+        Ok(())
     }
 
-    fn fail_incoming_move(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, fail: &mut bool) {
+    fn fail_incoming_move(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, fail: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::FailIncomingMove) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().fail_incoming_move(env) {
@@ -265,11 +278,12 @@ impl Script for WebAssemblyScript {
             );
             *fail = *ptr.value();
         }
+        Ok(())
     }
 
-    fn is_invulnerable(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, invulnerable: &mut bool) {
+    fn is_invulnerable(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, invulnerable: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::IsInvulnerable) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().is_invulnerable(env) {
@@ -284,21 +298,29 @@ impl Script for WebAssemblyScript {
             );
             *invulnerable = *ptr.value();
         }
+        Ok(())
     }
 
-    fn on_move_miss(&self, mv: &ExecutingMove, target: &Arc<Pokemon>) {
+    fn on_move_miss(&self, mv: &ExecutingMove, target: &Arc<Pokemon>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnMoveMiss) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_move_miss(env) {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target.as_ref()));
         }
+        Ok(())
     }
 
-    fn change_move_type(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, move_type: &mut TypeIdentifier) {
+    fn change_move_type(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        move_type: &mut TypeIdentifier,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeMoveType) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_move_type(env) {
@@ -308,11 +330,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *move_type = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_effectiveness(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, effectiveness: &mut f32) {
+    fn change_effectiveness(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        effectiveness: &mut f32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeEffectiveness) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_effectiveness(env) {
@@ -322,11 +351,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *effectiveness = *ptr.value();
         }
+        Ok(())
     }
 
-    fn block_critical(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, block_critical: &mut bool) {
+    fn block_critical(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        block_critical: &mut bool,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::BlockCritical) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().block_critical(env) {
@@ -336,11 +372,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *block_critical = *ptr.value();
         }
+        Ok(())
     }
 
-    fn block_incoming_critical(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, block_critical: &mut bool) {
+    fn block_incoming_critical(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        block_critical: &mut bool,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::BlockIncomingCritical) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().block_incoming_critical(env) {
@@ -350,11 +393,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *block_critical = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_accuracy(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, accuracy: &mut u8) {
+    fn change_accuracy(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, accuracy: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeAccuracy) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_accuracy(env) {
@@ -364,11 +408,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *accuracy = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_critical_stage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, stage: &mut u8) {
+    fn change_critical_stage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, stage: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeCriticalStage) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_critical_stage(env) {
@@ -378,11 +423,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *stage = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_critical_modifier(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, modifier: &mut f32) {
+    fn change_critical_modifier(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        modifier: &mut f32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeCriticalModifier) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_critical_modifier(env) {
@@ -392,11 +444,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_stab_modifier(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, modifier: &mut f32) {
+    fn change_stab_modifier(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        modifier: &mut f32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeSTABModifier) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_stab_modifier(env) {
@@ -406,11 +465,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_base_power(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, base_power: &mut u8) {
+    fn change_base_power(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, base_power: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeBasePower) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_base_power(env) {
@@ -420,11 +480,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *base_power = *ptr.value();
         }
+        Ok(())
     }
 
-    fn bypass_defensive_stat_boost(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, bypass: &mut bool) {
+    fn bypass_defensive_stat_boost(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        bypass: &mut bool,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::BypassDefensiveStat) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().bypass_defensive_stat_boost(env) {
@@ -434,11 +501,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *bypass = *ptr.value();
         }
+        Ok(())
     }
 
-    fn bypass_offensive_stat_boost(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, bypass: &mut bool) {
+    fn bypass_offensive_stat_boost(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        bypass: &mut bool,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::BypassOffensiveStat) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().bypass_offensive_stat_boost(env) {
@@ -448,11 +522,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *bypass = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_offensive_stat_value(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, amount: &mut u32) {
+    fn change_offensive_stat_value(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        amount: &mut u32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeOffensiveStatValue) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_offensive_stat_value(env) {
@@ -462,11 +543,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *amount = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_defensive_stat_value(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, amount: &mut u32) {
+    fn change_defensive_stat_value(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        amount: &mut u32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeOffensiveStatValue) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_defensive_stat_value(env) {
@@ -476,11 +564,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *amount = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_damage_stat_modifier(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, modifier: &mut f32) {
+    fn change_damage_stat_modifier(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        modifier: &mut f32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeStatModifier) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_damage_stat_modifier(env) {
@@ -490,11 +585,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_damage_modifier(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, modifier: &mut f32) {
+    fn change_damage_modifier(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        modifier: &mut f32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeDamageModifier) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_damage_modifier(env) {
@@ -504,11 +606,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *modifier = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_damage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, damage: &mut u32) {
+    fn change_damage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, damage: &mut u32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeDamage) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_damage(env) {
@@ -518,11 +621,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *damage = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_incoming_damage(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, damage: &mut u32) {
+    fn change_incoming_damage(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        damage: &mut u32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeIncomingDamage) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_incoming_damage(env) {
@@ -532,28 +642,31 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *damage = *ptr.value();
         }
+        Ok(())
     }
 
-    fn on_incoming_hit(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) {
+    fn on_incoming_hit(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnIncomingHit) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_incoming_hit(env) {
             let target = target.as_ref();
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit);
         }
+        Ok(())
     }
 
-    fn on_opponent_faints(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) {
+    fn on_opponent_faints(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFaintingOpponent) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_opponent_faints(env) {
             let target = target.as_ref();
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit);
         }
+        Ok(())
     }
 
     fn prevent_stat_boost_change(
@@ -563,9 +676,9 @@ impl Script for WebAssemblyScript {
         amount: i8,
         self_inflicted: bool,
         prevent: &mut bool,
-    ) {
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventStatBoostChange) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_stat_boost_change(env) {
@@ -583,11 +696,18 @@ impl Script for WebAssemblyScript {
             );
             *prevent = *ptr.value();
         }
+        Ok(())
     }
 
-    fn prevent_secondary_effect(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, prevent: &mut bool) {
+    fn prevent_secondary_effect(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        prevent: &mut bool,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSecondaryEffects) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_secondary_effect(env) {
@@ -597,11 +717,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *prevent = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_effect_chance(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, chance: &mut f32) {
+    fn change_effect_chance(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, chance: &mut f32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeEffectChance) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_effect_chance(env) {
@@ -611,11 +732,18 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *chance = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_incoming_effect_chance(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8, chance: &mut f32) {
+    fn change_incoming_effect_chance(
+        &self,
+        mv: &ExecutingMove,
+        target: &Arc<Pokemon>,
+        hit: u8,
+        chance: &mut f32,
+    ) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeIncomingEffectChance) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_incoming_effect_chance(env) {
@@ -625,33 +753,36 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit, w_ptr);
             *chance = *ptr.value();
         }
+        Ok(())
     }
 
-    fn on_secondary_effect(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) {
+    fn on_secondary_effect(&self, mv: &ExecutingMove, target: &Arc<Pokemon>, hit: u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFaintingOpponent) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_secondary_effect(env) {
             let target = target.as_ref();
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target), hit);
         }
+        Ok(())
     }
 
-    fn on_after_hits(&self, mv: &ExecutingMove, target: &Arc<Pokemon>) {
+    fn on_after_hits(&self, mv: &ExecutingMove, target: &Arc<Pokemon>) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnAfterHits) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_after_hits(env) {
             let target = target.as_ref();
             call_func!(func, env, self, ex_ref!(env, mv), ex_ref!(env, target));
         }
+        Ok(())
     }
 
-    fn prevent_self_switch(&self, choice: &TurnChoice, prevent: &mut bool) {
+    fn prevent_self_switch(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSelfSwitch) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_self_switch(env) {
@@ -659,11 +790,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *prevent = *ptr.value();
         }
+        Ok(())
     }
 
-    fn prevent_opponent_switch(&self, choice: &TurnChoice, prevent: &mut bool) {
+    fn prevent_opponent_switch(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSelfSwitch) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_opponent_switch(env) {
@@ -671,31 +803,34 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *prevent = *ptr.value();
         }
+        Ok(())
     }
 
-    fn on_fail(&self, pokemon: &Pokemon) {
+    fn on_fail(&self, pokemon: &Pokemon) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFail) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_fail(env) {
             call_func!(func, env, self, ex_ref!(env, pokemon));
         }
+        Ok(())
     }
 
-    fn on_opponent_fail(&self, pokemon: &Pokemon) {
+    fn on_opponent_fail(&self, pokemon: &Pokemon) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFail) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_opponent_fail(env) {
             call_func!(func, env, self, ex_ref!(env, pokemon));
         }
+        Ok(())
     }
 
-    fn prevent_self_run_away(&self, choice: &TurnChoice, prevent: &mut bool) {
+    fn prevent_self_run_away(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventSelfRunAway) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_self_run_away(env) {
@@ -703,11 +838,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *prevent = *ptr.value();
         }
+        Ok(())
     }
 
-    fn prevent_opponent_run_away(&self, choice: &TurnChoice, prevent: &mut bool) {
+    fn prevent_opponent_run_away(&self, choice: &TurnChoice, prevent: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::PreventOpponentRunAway) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().prevent_opponent_run_away(env) {
@@ -715,61 +851,67 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, choice), ptr.wasm_ptr);
             *prevent = *ptr.value();
         }
+        Ok(())
     }
-    fn on_end_turn(&self) {
+    fn on_end_turn(&self) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnEndTurn) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_end_turn(env) {
             call_func!(func, env, self);
         }
+        Ok(())
     }
 
-    fn on_damage(&self, pokemon: &Pokemon, source: DamageSource, old_health: u32, new_health: u32) {
+    fn on_damage(&self, pokemon: &Pokemon, source: DamageSource, old_health: u32, new_health: u32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnDamage) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_damage(env) {
             let r = ex_ref!(env, pokemon);
             call_func!(func, env, self, r, source as u8, old_health, new_health);
         }
+        Ok(())
     }
 
-    fn on_faint(&self, pokemon: &Pokemon, source: DamageSource) {
+    fn on_faint(&self, pokemon: &Pokemon, source: DamageSource) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnFaint) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_faint(env) {
             call_func!(func, env, self, ex_ref!(env, pokemon), source as u8);
         }
+        Ok(())
     }
 
-    fn on_switch_in(&self, pokemon: &Pokemon) {
+    fn on_switch_in(&self, pokemon: &Pokemon) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnSwitchIn) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_switch_in(env) {
             call_func!(func, env, self, ex_ref!(env, pokemon));
         }
+        Ok(())
     }
 
-    fn on_after_held_item_consume(&self, pokemon: &Pokemon, item: &dyn Item) {
+    fn on_after_held_item_consume(&self, pokemon: &Pokemon, item: &dyn Item) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::OnAfterHeldItemConsume) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().on_after_held_item_consume(env) {
             call_func!(func, env, self, ex_ref!(env, pokemon), ex_ref!(env, item));
         }
+        Ok(())
     }
 
-    fn change_experience_gained(&self, fainted_mon: &Pokemon, winning_mon: &Pokemon, amount: &mut u32) {
+    fn change_experience_gained(&self, fainted_mon: &Pokemon, winning_mon: &Pokemon, amount: &mut u32) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeExperienceGain) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_experience_gained(env) {
@@ -779,11 +921,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, fainted_mon, winning_mon, ptr.wasm_ptr);
             *amount = *ptr.value();
         }
+        Ok(())
     }
 
-    fn share_experience(&self, fainted_mon: &Pokemon, winning_mon: &Pokemon, shares: &mut bool) {
+    fn share_experience(&self, fainted_mon: &Pokemon, winning_mon: &Pokemon, shares: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::DoesShareExperience) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().share_experience(env) {
@@ -793,11 +936,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, fainted_mon, winning_mon, ptr.wasm_ptr);
             *shares = *ptr.value();
         }
+        Ok(())
     }
 
-    fn block_weather(&self, battle: &Battle, blocked: &mut bool) {
+    fn block_weather(&self, battle: &Battle, blocked: &mut bool) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::BlockWeather) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().block_weather(env) {
@@ -805,11 +949,12 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, ex_ref!(env, battle), ptr.wasm_ptr);
             *blocked = *ptr.value();
         }
+        Ok(())
     }
 
-    fn change_capture_rate_bonus(&self, target: &Pokemon, pokeball: &dyn Item, modifier: &mut u8) {
+    fn change_capture_rate_bonus(&self, target: &Pokemon, pokeball: &dyn Item, modifier: &mut u8) -> Result<()> {
         if !self.has_capability(&WebAssemblyScriptCapabilities::ChangeCaptureRate) {
-            return;
+            return Ok(());
         }
         let env = &self.environment;
         if let Some(func) = env.script_function_cache().change_capture_rate_bonus(env) {
@@ -819,6 +964,7 @@ impl Script for WebAssemblyScript {
             call_func!(func, env, self, target, pokeball, ptr.wasm_ptr);
             *modifier = *ptr.value();
         }
+        Ok(())
     }
 
     fn as_any(&self) -> &dyn Any {