start cleaning up examples, use ScriptValue as argument for all things

Author: makspll

Cargo.toml

@@ -123,10 +123,6 @@ name = "console_integration_rhai"
 path = "examples/rhai/console_integration.rs"
 required-features = ["rhai", "bevy/file_watcher", "bevy/multi_threaded"]
 
-[[example]]
-name = "complex_game_loop_lua"
-path = "examples/lua/complex_game_loop.rs"
-required-features = ["lua54"]
 
 [[example]]
 name = "dynamic_queries_lua"
@@ -148,15 +144,6 @@ required-features = ["rhai", "bevy/file_watcher", "bevy/multi_threaded"]
 name = "game_of_life_rhai"
 path = "examples/rhai/game_of_life.rs"
 
-[[example]]
-name = "event_recipients_lua"
-path = "examples/lua/event_recipients.rs"
-required-features = ["lua54"]
-
-[[example]]
-name = "coroutines_lua"
-path = "examples/lua/coroutines.rs"
-required-features = ["lua54"]
 
 [[example]]
 name = "bevy_api_lua"
@@ -168,10 +155,6 @@ name = "bevy_api_rhai"
 path = "examples/rhai/bevy_api.rs"
 required-features = ["rhai"]
 
-[[example]]
-name = "wrappers"
-path = "examples/wrappers.rs"
-required-features = ["lua54"]
 
 [[example]]
 name = "minimal_rune"

crates/bevy_mod_scripting_core/src/event.rs

@@ -1,6 +1,6 @@
 use bevy::{ecs::entity::Entity, prelude::Event};
 
-use crate::{error::ScriptError, handler::Args, script::ScriptId};
+use crate::{error::ScriptError, handler::Args, prelude::ScriptValue, script::ScriptId};
 
 /// An error coming from a script
 #[derive(Debug, Event)]
@@ -50,6 +50,23 @@ impl CallbackLabel {
     }
 }
 
+#[macro_export]
+macro_rules! callback_labels {
+    ($($name:ident => $label:expr),*) => {
+        pub enum CallbackLabels {
+            $($name),*
+        }
+
+        impl IntoCallbackLabel for CallbackLabels {
+            fn into_callback_label() -> CallbackLabel {
+                match self {
+                    $(CallbackLabels::$name => $label.into()),*
+                }
+            }
+        }
+    };
+}
+
 pub trait IntoCallbackLabel {
     fn into_callback_label() -> CallbackLabel;
 }
@@ -90,22 +107,26 @@ pub enum Recipients {
 
 /// A callback event meant to trigger a callback in a subset/set of scripts in the world with the given arguments
 #[derive(Clone, Event, Debug)]
-pub struct ScriptCallbackEvent<A: Args> {
+pub struct ScriptCallbackEvent {
     pub label: CallbackLabel,
     pub recipients: Recipients,
-    pub args: A,
+    pub args: Vec<ScriptValue>,
 }
 
-impl<A: Args> ScriptCallbackEvent<A> {
-    pub fn new<L: Into<CallbackLabel>>(label: L, args: A, recipients: Recipients) -> Self {
+impl ScriptCallbackEvent {
+    pub fn new<L: Into<CallbackLabel>>(
+        label: L,
+        args: Vec<ScriptValue>,
+        recipients: Recipients,
+    ) -> Self {
         Self {
             label: label.into(),
             args,
             recipients,
         }
     }
 
-    pub fn new_for_all<L: Into<CallbackLabel>>(label: L, args: A) -> Self {
+    pub fn new_for_all<L: Into<CallbackLabel>>(label: L, args: Vec<ScriptValue>) -> Self {
         Self::new(label, args, Recipients::All)
     }
 }

crates/bevy_mod_scripting_core/src/handler.rs

@@ -3,16 +3,16 @@ use bevy::ecs::{entity::Entity, system::Resource, world::World};
 use crate::{
     context::{Context, ContextPreHandlingInitializer},
     event::CallbackLabel,
-    prelude::ScriptError,
+    prelude::{ScriptError, ScriptValue},
     runtime::Runtime,
     script::ScriptId,
 };
 
 pub trait Args: Clone + Send + Sync + 'static {}
 impl<T: Clone + Send + Sync + 'static> Args for T {}
 
-pub type HandlerFn<A, C, R> = fn(
-    args: A,
+pub type HandlerFn<C, R> = fn(
+    args: Vec<ScriptValue>,
     entity: Entity,
     script_id: &ScriptId,
     callback: &CallbackLabel,
@@ -24,11 +24,11 @@ pub type HandlerFn<A, C, R> = fn(
 
 /// A resource that holds the settings for the callback handler for a specific combination of type parameters
 #[derive(Resource)]
-pub struct CallbackSettings<A: Args, C: Context, R: Runtime> {
-    pub callback_handler: Option<HandlerFn<A, C, R>>,
+pub struct CallbackSettings<C: Context, R: Runtime> {
+    pub callback_handler: Option<HandlerFn<C, R>>,
 }
 
-impl<A: Args, C: Context, R: Runtime> Default for CallbackSettings<A, C, R> {
+impl<C: Context, R: Runtime> Default for CallbackSettings<C, R> {
     fn default() -> Self {
         Self {
             callback_handler: None,

crates/bevy_mod_scripting_core/src/lib.rs

@@ -40,20 +40,20 @@ pub mod prelude {
 }
 
 /// Bevy plugin enabling scripting within the bevy mod scripting framework
-pub struct ScriptingPlugin<A: Args, C: Context, R: Runtime> {
+pub struct ScriptingPlugin<C: Context, R: Runtime> {
     /// Callback for initiating the runtime
     pub runtime_builder: fn() -> R,
     /// Settings for the runtime
     pub runtime_settings: Option<RuntimeSettings<R>>,
     /// The handler used for executing callbacks in scripts
-    pub callback_handler: Option<HandlerFn<A, C, R>>,
+    pub callback_handler: Option<HandlerFn<C, R>>,
     /// The context builder for loading contexts
     pub context_builder: Option<ContextBuilder<C, R>>,
     /// The context assigner for assigning contexts to scripts, if not provided default strategy of keeping each script in its own context is used
     pub context_assigner: Option<ContextAssigner<C>>,
 }
 
-impl<A: Args, C: Context, R: Runtime + Default> Default for ScriptingPlugin<A, C, R> {
+impl<C: Context, R: Runtime + Default> Default for ScriptingPlugin<C, R> {
     fn default() -> Self {
         Self {
             runtime_builder: R::default,
@@ -65,10 +65,10 @@ impl<A: Args, C: Context, R: Runtime + Default> Default for ScriptingPlugin<A, C
     }
 }
 
-impl<A: Args, C: Context, R: Runtime> Plugin for ScriptingPlugin<A, C, R> {
+impl<C: Context, R: Runtime> Plugin for ScriptingPlugin<C, R> {
     fn build(&self, app: &mut bevy::prelude::App) {
         app.add_event::<ScriptErrorEvent>()
-            .add_event::<ScriptCallbackEvent<A>>()
+            .add_event::<ScriptCallbackEvent>()
             .init_resource::<AppReflectAllocator>()
             .init_resource::<ScriptAssetSettings>()
             .init_resource::<Scripts>()
@@ -84,7 +84,7 @@ impl<A: Args, C: Context, R: Runtime> Plugin for ScriptingPlugin<A, C, R> {
                 runtime: (self.runtime_builder)(),
             })
             .init_non_send_resource::<ScriptContexts<C>>()
-            .insert_resource::<CallbackSettings<A, C, R>>(CallbackSettings {
+            .insert_resource::<CallbackSettings<C, R>>(CallbackSettings {
                 callback_handler: self.callback_handler,
             })
             .insert_resource::<ContextLoadingSettings<C, R>>(ContextLoadingSettings {
@@ -224,13 +224,13 @@ mod test {
         #[derive(Default, Clone)]
         struct R;
         app.add_plugins(AssetPlugin::default());
-        app.add_plugins(ScriptingPlugin::<A, C, R>::default());
+        app.add_plugins(ScriptingPlugin::<C, R>::default());
 
         assert!(app.world().contains_resource::<Scripts>());
         assert!(app.world().contains_resource::<AppTypeRegistry>());
         assert!(app.world().contains_resource::<ScriptAssetSettings>());
         assert!(app.world().contains_resource::<RuntimeSettings<R>>());
-        assert!(app.world().contains_resource::<CallbackSettings<A, C, R>>());
+        assert!(app.world().contains_resource::<CallbackSettings<C, R>>());
         assert!(app
             .world()
             .contains_resource::<ContextLoadingSettings<C, R>>());

crates/bevy_mod_scripting_core/src/systems.rs

@@ -94,8 +94,8 @@ macro_rules! push_err_and_continue {
 pub fn event_handler<L: IntoCallbackLabel, A: Args, C: Context, R: Runtime>(
     world: &mut World,
     params: &mut SystemState<(
-        EventReader<ScriptCallbackEvent<A>>,
-        Res<CallbackSettings<A, C, R>>,
+        EventReader<ScriptCallbackEvent>,
+        Res<CallbackSettings<C, R>>,
         Res<ContextLoadingSettings<C, R>>,
         Res<Scripts>,
         Query<(Entity, Ref<ScriptComponent>)>,
@@ -232,6 +232,7 @@ mod test {
     use crate::{
         event::CallbackLabel,
         handler::HandlerFn,
+        prelude::ScriptValue,
         script::{Script, ScriptId},
     };
 
@@ -249,20 +250,20 @@ mod test {
     }
 
     struct TestContext {
-        pub invocations: Vec<String>,
+        pub invocations: Vec<ScriptValue>,
     }
 
     fn setup_app<L: IntoCallbackLabel + 'static, A: Args, C: Context, R: Runtime>(
-        handler_fn: HandlerFn<A, C, R>,
+        handler_fn: HandlerFn<C, R>,
         runtime: R,
         contexts: HashMap<u32, C>,
         scripts: HashMap<ScriptId, Script>,
     ) -> App {
         let mut app = App::new();
 
-        app.add_event::<ScriptCallbackEvent<A>>();
+        app.add_event::<ScriptCallbackEvent>();
         app.add_event::<ScriptErrorEvent>();
-        app.insert_resource::<CallbackSettings<A, C, R>>(CallbackSettings {
+        app.insert_resource::<CallbackSettings<C, R>>(CallbackSettings {
             callback_handler: Some(handler_fn),
         });
         app.add_systems(Update, event_handler::<L, A, C, R>);
@@ -301,7 +302,7 @@ mod test {
         };
         let mut app = setup_app::<OnTestCallback, String, TestContext, TestRuntime>(
             |args, entity, script, _, ctxt, _, runtime, _| {
-                ctxt.invocations.push(args);
+                ctxt.invocations.extend(args);
                 runtime.invocations.push((entity, script.clone()));
                 Ok(())
             },
@@ -314,11 +315,10 @@ mod test {
             .spawn(ScriptComponent(vec![test_script_id.clone()]))
             .id();
 
-        app.world_mut()
-            .send_event(ScriptCallbackEvent::<String>::new_for_all(
-                OnTestCallback::into_callback_label(),
-                "test_args".to_owned(),
-            ));
+        app.world_mut().send_event(ScriptCallbackEvent::new_for_all(
+            OnTestCallback::into_callback_label(),
+            vec![ScriptValue::String("test_args".into())],
+        ));
         app.update();
 
         let test_context = app
@@ -336,7 +336,7 @@ mod test {
                 .get(&test_ctxt_id)
                 .unwrap()
                 .invocations,
-            vec!["test_args"]
+            vec![ScriptValue::String("test_args".into())]
         );
 
         assert_eq!(
@@ -389,7 +389,7 @@ mod test {
         };
         let mut app = setup_app::<OnTestCallback, String, TestContext, TestRuntime>(
             |args, entity, script, _, ctxt, _, runtime, _| {
-                ctxt.invocations.push(args);
+                ctxt.invocations.extend(args);
                 runtime.invocations.push((entity, script.clone()));
                 Ok(())
             },
@@ -402,19 +402,17 @@ mod test {
             .spawn(ScriptComponent(vec![test_script_id.clone()]))
             .id();
 
-        app.world_mut()
-            .send_event(ScriptCallbackEvent::<String>::new(
-                OnTestCallback::into_callback_label(),
-                "test_args_script".to_owned(),
-                crate::event::Recipients::Script(test_script_id.clone()),
-            ));
+        app.world_mut().send_event(ScriptCallbackEvent::new(
+            OnTestCallback::into_callback_label(),
+            vec![ScriptValue::String("test_args_script".into())],
+            crate::event::Recipients::Script(test_script_id.clone()),
+        ));
 
-        app.world_mut()
-            .send_event(ScriptCallbackEvent::<String>::new(
-                OnTestCallback::into_callback_label(),
-                "test_args_entity".to_owned(),
-                crate::event::Recipients::Entity(test_entity_id),
-            ));
+        app.world_mut().send_event(ScriptCallbackEvent::new(
+            OnTestCallback::into_callback_label(),
+            vec![ScriptValue::String("test_args_entity".into())],
+            crate::event::Recipients::Entity(test_entity_id),
+        ));
 
         app.update();
 
@@ -433,7 +431,10 @@ mod test {
                 .get(&test_ctxt_id)
                 .unwrap()
                 .invocations,
-            vec!["test_args_script", "test_args_entity"]
+            vec![
+                ScriptValue::String("test_args_script".into()),
+                ScriptValue::String("test_args_entity".into())
+            ]
         );
 
         assert_eq!(