LETS GOO

Author: makspll

crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs

@@ -353,7 +353,7 @@ impl ScriptFunctionRegistryArc {
     }
 }
 
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct FunctionKey {
     pub name: Cow<'static, str>,
     pub namespace: Namespace,
@@ -504,6 +504,23 @@ impl ScriptFunctionRegistry {
     pub fn iter_all(&self) -> impl Iterator<Item = (&FunctionKey, &DynamicScriptFunction)> {
         self.functions.iter()
     }
+
+    /// Insert a function into the registry with the given key, this will not perform any overloading logic.
+    /// Do not use unless you really need to.
+    pub fn raw_insert(
+        &mut self,
+        namespace: Namespace,
+        name: impl Into<Cow<'static, str>>,
+        func: DynamicScriptFunction,
+    ) {
+        self.functions.insert(
+            FunctionKey {
+                name: name.into(),
+                namespace,
+            },
+            func,
+        );
+    }
 }
 
 macro_rules! count {

crates/bevy_mod_scripting_core/src/lib.rs

@@ -13,6 +13,7 @@ use context::{
     Context, ContextAssigner, ContextBuilder, ContextInitializer, ContextLoadingSettings,
     ContextPreHandlingInitializer, ScriptContexts,
 };
+use error::ScriptError;
 use event::ScriptCallbackEvent;
 use handler::{CallbackSettings, HandlerFn};
 use runtime::{initialize_runtime, Runtime, RuntimeContainer, RuntimeInitializer, RuntimeSettings};
@@ -213,7 +214,12 @@ fn once_per_app_init(app: &mut App) {
 fn register_script_plugin_systems<P: IntoScriptPluginParams>(app: &mut App) {
     app.add_systems(
         PostStartup,
-        (initialize_runtime::<P>).in_set(ScriptingSystemSet::RuntimeInitialization),
+        (initialize_runtime::<P>.pipe(|e: In<Result<(), ScriptError>>| {
+            if let Err(e) = e.0 {
+                error!("Error initializing runtime: {:?}", e);
+            }
+        }))
+        .in_set(ScriptingSystemSet::RuntimeInitialization),
     );
 
     configure_asset_systems_for_plugin::<P>(app);

crates/bevy_mod_scripting_core/src/runtime.rs

@@ -1,7 +1,7 @@
 //! "Runtime" here refers to the execution evironment of scripts. This might be the VM executing bytecode or the interpreter executing source code.
 //! The important thing is that there is only one runtime which is used to execute all scripts of a particular type or `context`.
 
-use crate::IntoScriptPluginParams;
+use crate::{error::ScriptError, IntoScriptPluginParams};
 use bevy::{
     ecs::system::Resource,
     prelude::{NonSendMut, Res},
@@ -10,7 +10,8 @@ use bevy::{
 pub trait Runtime: 'static {}
 impl<T: 'static> Runtime for T {}
 
-pub type RuntimeInitializer<P> = fn(&mut <P as IntoScriptPluginParams>::R);
+pub type RuntimeInitializer<P> =
+    fn(&mut <P as IntoScriptPluginParams>::R) -> Result<(), ScriptError>;
 
 #[derive(Resource)]
 pub struct RuntimeSettings<P: IntoScriptPluginParams> {
@@ -42,8 +43,9 @@ pub struct RuntimeContainer<P: IntoScriptPluginParams> {
 pub fn initialize_runtime<P: IntoScriptPluginParams>(
     mut runtime: NonSendMut<RuntimeContainer<P>>,
     settings: Res<RuntimeSettings<P>>,
-) {
+) -> Result<(), ScriptError> {
     for initializer in settings.initializers.iter() {
-        (initializer)(&mut runtime.runtime);
+        (initializer)(&mut runtime.runtime)?;
     }
+    Ok(())
 }

crates/languages/bevy_mod_scripting_lua/src/bindings/reference.rs

@@ -277,11 +277,6 @@ impl UserData for LuaStaticReflectReference {
 
                 let key: ScriptValue = key.into();
 
-                // if let ScriptValue::String(ref key) = key {
-                //     if let Some(func) = lookup_function(lua, key, type_id) {
-                //         return func?.into_lua(lua);
-                //     }
-                // };
                 let key = match key.as_string() {
                     Ok(name) => match world.lookup_function([type_id], name) {
                         Ok(func) => return Ok(LuaScriptValue(ScriptValue::Function(func))),

crates/languages/bevy_mod_scripting_rhai/Cargo.toml

@@ -21,6 +21,7 @@ rhai = { workspace = true, features = ["sync"] }
 bevy_mod_scripting_core = { workspace = true, features = ["rhai_impls"] }
 bevy_mod_scripting_functions = { workspace = true, features = [
 ], default-features = false }
+strum = { version = "0.26", features = ["derive"] }
 
 [dev-dependencies]
 script_integration_test_harness = { workspace = true }