refactor

Author: makspll

assets/tests/add_system/added_systems_run_in_parallel.lua

@@ -39,7 +39,7 @@ digraph {
   node_14 [label="custom_system_b"];
   node_15 [label="SystemSet AssetEvents"];
   node_16 [label="SystemSet GarbageCollection"];
-  node_17 [label="SystemSet StartPhase"];
+  node_17 [label="SystemSet InitializePhase"];
   node_18 [label="SystemSet ScriptSystem(custom_system_a)"];
   node_19 [label="SystemSet ScriptSystem(custom_system_b)"];
   node_0 -> node_15 [color=red, label="child of", arrowhead=diamond];

assets/tests/add_system/added_systems_run_in_parallel.rhai

@@ -38,7 +38,7 @@ digraph {
   node_14 [label="custom_system_b"];
   node_15 [label="SystemSet AssetEvents"];
   node_16 [label="SystemSet GarbageCollection"];
-  node_17 [label="SystemSet StartPhase"];
+  node_17 [label="SystemSet InitializePhase"];
   node_18 [label="SystemSet ScriptSystem(custom_system_a)"];
   node_19 [label="SystemSet ScriptSystem(custom_system_b)"];
   node_0 -> node_15 [color=red, label="child of", arrowhead=diamond];

crates/bevy_mod_scripting_core/src/commands.rs

@@ -5,9 +5,13 @@ use std::sync::Arc;
 use crate::{
     IntoScriptPluginParams, ScriptContext,
     error::ScriptError,
-    event::{CallbackLabel, ScriptCallbackResponseEvent},
+    event::{
+        CallbackLabel, ForPlugin, ScriptAttachedEvent, ScriptCallbackResponseEvent,
+        ScriptDetachedEvent,
+    },
     extractors::CallContext,
     handler::{send_callback_response, send_script_errors},
+    pipeline::RunProcessingPipelineOnce,
     script::{DisplayProxy, ScriptAttachment},
 };
 use bevy_ecs::{system::Command, world::World};
@@ -140,3 +144,39 @@ impl<P: IntoScriptPluginParams> Command for RunScriptCallback<P> {
         let _ = self.run(world);
     }
 }
+
+/// Command which emits a [`ScriptAttachedEvent`] and then runs the processing pipeline to immediately process it.
+/// The end result is equivalent to attaching a script component or adding a static script and waiting for the normal pipeline to process it.
+pub struct AttachScript<P: IntoScriptPluginParams>(pub ForPlugin<ScriptAttachedEvent, P>);
+
+impl<P: IntoScriptPluginParams> AttachScript<P> {
+    /// Creates a new [`AttachScript`] command, which will create the given attachment, run expected callbacks, and
+    pub fn new(attachment: ScriptAttachment) -> Self {
+        Self(ForPlugin::new(ScriptAttachedEvent(attachment)))
+    }
+}
+
+/// Command which emits a [`ScriptDetachedEvent`] and then runs the processing pipeline to immediately process it.
+/// The end result is equivalent to detaching a script component or removing a static script and waiting for the normal pipeline to process it.
+pub struct DetachScript<P: IntoScriptPluginParams>(pub ForPlugin<ScriptDetachedEvent, P>);
+
+impl<P: IntoScriptPluginParams> DetachScript<P> {
+    /// Creates a new [`DetachScript`] command, which will create the given attachment, run all expected callbacks, and delete contexts if necessary.
+    pub fn new(attachment: ScriptAttachment) -> Self {
+        Self(ForPlugin::new(ScriptDetachedEvent(attachment)))
+    }
+}
+
+impl<P: IntoScriptPluginParams> Command for AttachScript<P> {
+    fn apply(self, world: &mut World) {
+        world.send_event(self.0);
+        RunProcessingPipelineOnce::<P>::new().apply(world)
+    }
+}
+
+impl<P: IntoScriptPluginParams> Command for DetachScript<P> {
+    fn apply(self, world: &mut World) {
+        world.send_event(self.0);
+        RunProcessingPipelineOnce::<P>::new().apply(world)
+    }
+}

crates/bevy_mod_scripting_core/src/event.rs

@@ -1,6 +1,6 @@
 //! Event handlers and event types for scripting.
 
-use std::sync::Arc;
+use std::{marker::PhantomData, sync::Arc};
 
 use ::{bevy_asset::Handle, bevy_ecs::entity::Entity, bevy_reflect::Reflect};
 use bevy_ecs::event::Event;
@@ -28,6 +28,62 @@ impl ScriptErrorEvent {
     }
 }
 
+/// Emitted when a script is attached.
+#[derive(Event, Clone, Debug)]
+pub struct ScriptAttachedEvent(pub ScriptAttachment);
+
+/// Emitted when a script is detached.
+#[derive(Event, Clone, Debug)]
+pub struct ScriptDetachedEvent(pub ScriptAttachment);
+
+/// Emitted when a script asset is modified and all its attachments require re-loading
+#[derive(Event, Clone, Debug)]
+pub struct ScriptAssetModifiedEvent(pub ScriptId);
+
+#[derive(Event)]
+/// Wrapper around a script event making it available to read by a specific plugin only
+pub struct ForPlugin<T, P: IntoScriptPluginParams>(T, PhantomData<fn(P)>);
+
+impl<T: std::fmt::Debug, P: IntoScriptPluginParams> std::fmt::Debug for ForPlugin<T, P> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("ForPlugin").field(&self.0).finish()
+    }
+}
+
+impl<T, P: IntoScriptPluginParams> From<T> for ForPlugin<T, P> {
+    fn from(value: T) -> Self {
+        Self::new(value)
+    }
+}
+
+impl<T: Clone, P: IntoScriptPluginParams> Clone for ForPlugin<T, P> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone(), self.1)
+    }
+}
+
+impl<T, P: IntoScriptPluginParams> ForPlugin<T, P> {
+    /// Creates a new wrapper for the specific plugin
+    pub fn new(event: T) -> Self {
+        Self(event, Default::default())
+    }
+
+    /// Retrieves the inner event
+    pub fn event(&self) -> &T {
+        &self.0
+    }
+
+    /// Retrieves the inner event mutably
+    pub fn event_mut(&mut self) -> &mut T {
+        &mut self.0
+    }
+
+    /// Unpacks the inner event
+    pub fn inner(self) -> T {
+        self.0
+    }
+}
+
 /// A string which disallows common invalid characters in callback labels,
 /// particularly at the start of the string
 ///

crates/bevy_mod_scripting_core/src/lib.rs

@@ -173,7 +173,7 @@ impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P> {
         app.insert_resource(ScriptContext::<P>::new(self.context_policy.clone()));
         app.register_asset_loader(ScriptAssetLoader::new(config.language_extensions));
 
-        app.add_plugins(ScriptLoadingPipeline::<P>::default());
+        app.add_plugins(self.processing_pipeline_plugin.clone());
 
         register_types(app);
     }