refactor: Accept Handle<ScriptAsset> in ScriptComponents.

Author: shanecelis

crates/bevy_mod_scripting_core/src/commands.rs

@@ -338,12 +338,12 @@ impl<P: IntoScriptPluginParams> Command for RunScriptCallback<P> {
 /// Adds a static script to the collection of static scripts
 pub struct AddStaticScript {
     /// The ID of the script to add
-    id: ScriptId,
+    id: Handle<ScriptAsset>,
 }
 
 impl AddStaticScript {
     /// Creates a new AddStaticScript command with the given ID
-    pub fn new(id: impl Into<ScriptId>) -> Self {
+    pub fn new(id: impl Into<Handle<ScriptAsset>>) -> Self {
         Self { id: id.into() }
     }
 }
@@ -358,12 +358,12 @@ impl Command for AddStaticScript {
 /// Removes a static script from the collection of static scripts
 pub struct RemoveStaticScript {
     /// The ID of the script to remove
-    id: ScriptId,
+    id: Handle<ScriptAsset>,
 }
 
 impl RemoveStaticScript {
     /// Creates a new RemoveStaticScript command with the given ID
-    pub fn new(id: ScriptId) -> Self {
+    pub fn new(id: Handle<ScriptAsset>) -> Self {
         Self { id }
     }
 }

crates/bevy_mod_scripting_core/src/handler.rs

@@ -180,7 +180,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
             for script_id in entity_scripts.iter() {
                 match &event.recipients {
                     crate::event::Recipients::Script(target_script_id)
-                        if target_script_id != script_id =>
+                        if *target_script_id != script_id.id() =>
                     {
                         continue
                     }
@@ -197,7 +197,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
 
                 let call_result = handler_ctxt.call_dynamic_label(
                     &callback_label,
-                    script_id,
+                    &script_id.id(),
                     *entity,
                     event.args.clone(),
                     guard.clone(),
@@ -208,7 +208,7 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
                         guard.clone(),
                         ScriptCallbackResponseEvent::new(
                             callback_label.clone(),
-                            script_id.clone(),
+                            script_id.id(),
                             call_result.clone(),
                         ),
                     );
@@ -234,9 +234,15 @@ pub(crate) fn event_handler_inner<P: IntoScriptPluginParams>(
                             }
                             _ => {}
                         }
-                        let e = e
-                            .with_script(script_id.clone())
-                            .with_context(format!("Event handling for: Language: {}", P::LANGUAGE));
+                        let e = {
+
+                            if let Some(path) = script_id.path() {
+                                e.with_script(path)
+                            } else {
+                                e
+                            }
+                            .with_context(format!("Event handling for: Language: {}", P::LANGUAGE))
+                        };
                         push_err_and_continue!(errors, Err(e));
                     }
                 };

crates/bevy_mod_scripting_core/src/lib.rs

@@ -353,21 +353,21 @@ pub trait ManageStaticScripts {
     /// Registers a script id as a static script.
     ///
     /// Event handlers will run these scripts on top of the entity scripts.
-    fn add_static_script(&mut self, script_id: impl Into<ScriptId>) -> &mut Self;
+    fn add_static_script(&mut self, script_id: impl Into<Handle<ScriptAsset>>) -> &mut Self;
 
     /// Removes a script id from the list of static scripts.
     ///
     /// Does nothing if the script id is not in the list.
-    fn remove_static_script(&mut self, script_id: impl Into<ScriptId>) -> &mut Self;
+    fn remove_static_script(&mut self, script_id: impl Into<Handle<ScriptAsset>>) -> &mut Self;
 }
 
 impl ManageStaticScripts for App {
-    fn add_static_script(&mut self, script_id: impl Into<ScriptId>) -> &mut Self {
+    fn add_static_script(&mut self, script_id: impl Into<Handle<ScriptAsset>>) -> &mut Self {
         AddStaticScript::new(script_id.into()).apply(self.world_mut());
         self
     }
 
-    fn remove_static_script(&mut self, script_id: impl Into<ScriptId>) -> &mut Self {
+    fn remove_static_script(&mut self, script_id: impl Into<Handle<ScriptAsset>>) -> &mut Self {
         RemoveStaticScript::new(script_id.into()).apply(self.world_mut());
         self
     }

crates/bevy_mod_scripting_core/src/script.rs

@@ -16,10 +16,10 @@ pub type ScriptId = AssetId<ScriptAsset>;
 /// A component which identifies the scripts existing on an entity.
 ///
 /// Event handlers search for components with this component to figure out which scripts to run and on which entities.
-pub struct ScriptComponent(pub Vec<ScriptId>);
+pub struct ScriptComponent(pub Vec<Handle<ScriptAsset>>);
 
 impl Deref for ScriptComponent {
-    type Target = Vec<ScriptId>;
+    type Target = Vec<Handle<ScriptAsset>>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -28,7 +28,7 @@ impl Deref for ScriptComponent {
 
 impl ScriptComponent {
     /// Creates a new [`ScriptComponent`] with the given ScriptID's
-    pub fn new<S: Into<ScriptId>, I: IntoIterator<Item = S>>(components: I) -> Self {
+    pub fn new<S: Into<Handle<ScriptAsset>>, I: IntoIterator<Item = S>>(components: I) -> Self {
         Self(components.into_iter().map(Into::into).collect())
     }
 }
@@ -111,29 +111,29 @@ impl<P: IntoScriptPluginParams> Clone for Script<P> {
 /// Useful for `global` or `static` scripts which operate over a larger scope than a single entity.
 #[derive(Default, Resource)]
 pub struct StaticScripts {
-    pub(crate) scripts: HashSet<ScriptId>,
+    pub(crate) scripts: HashSet<Handle<ScriptAsset>>,
 }
 
 #[profiling::all_functions]
 impl StaticScripts {
     /// Inserts a static script into the collection
-    pub fn insert<S: Into<ScriptId>>(&mut self, script: S) {
+    pub fn insert<S: Into<Handle<ScriptAsset>>>(&mut self, script: S) {
         self.scripts.insert(script.into());
     }
 
     /// Removes a static script from the collection, returning `true` if the script was in the collection, `false` otherwise
-    pub fn remove<S: Into<ScriptId>>(&mut self, script: S) -> bool {
+    pub fn remove<S: Into<Handle<ScriptAsset>>>(&mut self, script: S) -> bool {
         self.scripts.remove(&script.into())
     }
 
     /// Checks if a static script is in the collection
     /// Returns `true` if the script is in the collection, `false` otherwise
-    pub fn contains<S: Into<ScriptId>>(&self, script: S) -> bool {
+    pub fn contains<S: Into<Handle<ScriptAsset>>>(&self, script: S) -> bool {
         self.scripts.contains(&script.into())
     }
 
     /// Returns an iterator over the static scripts
-    pub fn iter(&self) -> impl Iterator<Item = &ScriptId> {
+    pub fn iter(&self) -> impl Iterator<Item = &Handle<ScriptAsset>> {
         self.scripts.iter()
     }
 }

examples/game_of_life.rs

@@ -54,7 +54,6 @@ fn console_app(app: &mut App) -> &mut App {
 fn run_script_cmd(
     mut log: ConsoleCommand<GameOfLifeCommand>,
     mut commands: Commands,
-    mut loaded_scripts: ResMut<LoadedScripts>,
     asset_server: Res<AssetServer>,
     mut script_handle: Local<Option<Handle<ScriptAsset>>>,
 ) {
@@ -71,22 +70,18 @@ fn run_script_cmd(
                 );
 
                 let script_path = format!("scripts/game_of_life.{}", language);
-                *script_handle = Some(asset_server.load(script_path));
-                let script_id = script_handle.as_ref().unwrap().id();
                 if !use_static_script {
                     bevy::log::info!("Spawning an entity with ScriptComponent");
-                    commands.spawn(ScriptComponent::new(vec![script_id]));
+                    commands.spawn(ScriptComponent::new(vec![asset_server.load(script_path)]));
                 } else {
                     bevy::log::info!("Using static script instead of spawning an entity");
-                    commands.queue(AddStaticScript::new(script_id))
+                    commands.queue(AddStaticScript::new(asset_server.load(script_path)))
                 }
             }
             GameOfLifeCommand::Stop => {
                 // we can simply drop the handle, or manually delete, I'll just drop the handle
                 bevy::log::info!("Stopping game of life by dropping the handles to all scripts");
 
-                // I am not mapping the handles to the script names, so I'll just clear the entire list
-                loaded_scripts.0.clear();
 
                 // you could also do
                 // commands.queue(DeleteScript::<LuaScriptingPlugin>::new(
@@ -123,8 +118,7 @@ fn game_of_life_app(app: &mut App) -> &mut App {
         .register_type::<LifeState>()
         .register_type::<Settings>()
         .init_resource::<Settings>()
-        .init_resource::<LoadedScripts>()
-        .add_systems(Startup, (init_game_of_life_state, load_script_assets))
+        .add_systems(Startup, init_game_of_life_state)
         .add_systems(Update, (sync_window_size, send_on_click))
         .add_systems(
             FixedUpdate,
@@ -149,9 +143,6 @@ pub struct LifeState {
     pub cells: Vec<u8>,
 }
 
-#[derive(Debug, Resource, Default)]
-pub struct LoadedScripts(pub Vec<Handle<ScriptAsset>>);
-
 #[derive(Reflect, Resource)]
 #[reflect(Resource)]
 pub struct Settings {
@@ -174,17 +165,6 @@ impl Default for Settings {
     }
 }
 
-/// Prepares any scripts by loading them and storing the handles.
-pub fn load_script_assets(
-    asset_server: Res<AssetServer>,
-    mut loaded_scripts: ResMut<LoadedScripts>,
-) {
-    loaded_scripts.0.extend(vec![
-        asset_server.load("scripts/game_of_life.lua"),
-        asset_server.load("scripts/game_of_life.rhai"),
-    ]);
-}
-
 pub fn register_script_functions(app: &mut App) -> &mut App {
     let world = app.world_mut();
     NamespaceBuilder::<GlobalNamespace>::new_unregistered(world)