Add runtime state hook (#28)

Author: makspll

api_gen_config.toml

@@ -1,5 +1,3 @@
-
-
 imports = """
 #[cfg(feature="lua")]
 use {
@@ -25,6 +23,41 @@ other = """
 crate::impl_tealr_generic!(pub(crate) struct T);
 """
 
+lua_api_defaults = """
+fn setup_script(
+	&mut self,
+	script_data: &ScriptData,
+	ctx: &mut Self::ScriptContext,
+) -> Result<(), ScriptError> {
+	let ctx = ctx.get_mut().expect("Could not get context");
+	let globals = ctx.globals();
+	globals
+		.set(
+			"entity",
+			crate::lua::bevy::LuaEntity::new(script_data.entity),
+		)
+		.map_err(ScriptError::new_other)?;
+	globals
+		.set::<_, crate::lua::bevy::LuaScriptData>("script", script_data.into())
+		.map_err(ScriptError::new_other)?;
+
+	Ok(())
+}
+
+fn setup_script_runtime(
+	&mut self,
+	world_ptr: bevy_mod_scripting_core::world::WorldPointer,
+	_script_data: &ScriptData,
+	ctx: &mut Self::ScriptContext,
+) -> Result<(), ScriptError> {
+	let ctx = ctx.get_mut().expect("Could not get context");
+	let globals = ctx.globals();
+	globals
+		.set("world", crate::lua::bevy::LuaWorld::new(world_ptr))
+		.map_err(ScriptError::new_other)
+}
+"""
+
 primitives = ["usize","isize","f32","f64","u128","u64","u32","u16","u8","i128","i64","i32","i16","i8","String","bool"]
 
 

assets/scripts/event_recipients.lua

@@ -1,6 +1,4 @@
-
-
 function on_event(id)
-    print(string.format("on_event, script_id: %d, Handling:",script.sid))
+    print(string.format("on_event, script_id: %d, Handling:", script_id))
     print(string.format("\t-> id: %d", id))
-end
+end

bevy_api_gen/src/config.rs

@@ -32,6 +32,8 @@ pub struct Config {
     pub imports: String,
     pub other: String,
 
+    pub lua_api_defaults: String,
+
     /// Describes the set of non generic things which are representible
     /// as simple lua types and don't need UserData proxies
     pub primitives: HashSet<String>,

bevy_api_gen/src/main.rs

@@ -300,6 +300,11 @@ pub(crate) fn generate_macros(
     writer.close_brace();
     // } get_doc_fragment
 
+    // impl default members
+    for line in config.lua_api_defaults.lines() {
+        writer.write_line(line);
+    }
+
     // register_with_app {
     writer.write_no_newline("fn register_with_app(&self, app: &mut App)");
     writer.open_brace();

bevy_mod_scripting_common/src/arg.rs

@@ -182,7 +182,7 @@ pub enum ArgType {
     Self_(SelfType),
 }
 
-#[allow(clippy::eval_order_dependence)]
+#[allow(clippy::mixed_read_write_in_expression)]
 impl Parse for ArgType {
     fn parse(input: ParseStream) -> Result<Self, syn::Error> {
         if input.peek(Ident) {

bevy_mod_scripting_common/src/derive_flag.rs

@@ -84,7 +84,7 @@ pub enum DeriveFlag {
 //     pub args: Punctuated<MethodMacroArg, Token![,]>,
 // }
 
-// #[allow(clippy::eval_order_dependence)]
+// #[allow(clippy::mixed_read_write_in_expression)]
 // impl Parse for MethodMacroInvokation {
 //     fn parse(input: ParseStream) -> Result<Self, syn::Error> {
 //         let f;
@@ -122,7 +122,7 @@ impl ToTokens for AutoMethod {
     }
 }
 
-#[allow(clippy::eval_order_dependence)]
+#[allow(clippy::mixed_read_write_in_expression)]
 impl Parse for AutoMethod {
     fn parse(input: ParseStream) -> Result<Self, syn::Error> {
         let f;

bevy_mod_scripting_common/src/newtype.rs

@@ -139,7 +139,7 @@ impl ToTokens for WrapperFunctionList {
     }
 }
 
-#[allow(clippy::eval_order_dependence)]
+#[allow(clippy::mixed_read_write_in_expression)]
 impl Parse for WrapperFunctionList {
     fn parse(input: ParseStream) -> Result<Self, syn::Error> {
         let f;

bevy_mod_scripting_common/src/utils.rs

@@ -40,7 +40,7 @@ macro_rules! impl_parse_enum {
             ),*
 
         }
-        #[allow(clippy::eval_order_dependence)]
+        #[allow(clippy::mixed_read_write_in_expression)]
         impl Parse for $name {
             fn parse($input_stream: ParseStream) -> Result<Self,syn::Error> {
                 let $parsed_ident : syn::Ident = $input_stream.parse()?;

bevy_mod_scripting_core/Cargo.toml

@@ -32,6 +32,6 @@ bevy = { version = "0.8.0", default-features = false, features=["bevy_asset","be
 bevy_event_priority = {path = "../bevy_event_priority", version = "0.1.1"}
 thiserror = "1.0.31"
 paste = "1.0.7"
-
+parking_lot = "0.12.1"
 
 

bevy_mod_scripting_core/src/event.rs

@@ -0,0 +1,20 @@
+use crate::{error::ScriptError, hosts::Recipients};
+
+/// An error coming from a script
+#[derive(Debug)]
+pub struct ScriptErrorEvent {
+    pub error: ScriptError,
+}
+
+/// An event emitted when a script was loaded or re-loaded (with a hot-reload),
+/// guaranteed to be sent for every script at least once and immediately after it's loaded.
+#[derive(Clone, Debug)]
+pub struct ScriptLoaded {
+    pub sid: u32,
+}
+
+/// A trait for events to be handled by scripts
+pub trait ScriptEvent: Send + Sync + Clone + 'static {
+    /// Retrieves the recipient scripts for this event
+    fn recipients(&self) -> &Recipients;
+}

bevy_mod_scripting_core/src/hosts.rs

@@ -2,10 +2,17 @@
 use bevy::{asset::Asset, prelude::*, reflect::FromReflect};
 use std::{
     collections::HashMap,
+    iter::once,
     sync::atomic::{AtomicU32, Ordering},
 };
 
-use crate::{asset::CodeAsset, docs::DocFragment, error::ScriptError};
+use crate::{
+    asset::CodeAsset,
+    docs::DocFragment,
+    error::ScriptError,
+    event::{ScriptEvent, ScriptLoaded},
+    world::WorldPointer,
+};
 
 /// Describes the target set of scripts this event should
 /// be handled by
@@ -30,7 +37,7 @@ pub struct ScriptData<'a> {
 }
 
 impl Recipients {
-    /// Returns true if the given script should
+    /// Returns true if the given script is a recipient
     pub fn is_recipient(&self, c: &ScriptData) -> bool {
         match self {
             Recipients::All => true,
@@ -47,11 +54,6 @@ impl Default for Recipients {
     }
 }
 
-pub trait ScriptEvent: Send + Sync + Clone + 'static {
-    /// Retrieves the recipient scripts for this event
-    fn recipients(&self) -> &Recipients;
-}
-
 /// A script host is the interface between your rust application
 /// and the scripts in some interpreted language.
 pub trait ScriptHost: Send + Sync + 'static + Default {
@@ -76,18 +78,27 @@ pub trait ScriptHost: Send + Sync + 'static + Default {
         providers: &mut APIProviders<Self>,
     ) -> Result<Self::ScriptContext, ScriptError>;
 
+    /// Perform one-off initialization of scripts (happens for every new or re-loaded script)
+    fn setup_script(
+        &mut self,
+        script_data: &ScriptData,
+        ctx: &mut Self::ScriptContext,
+        providers: &mut APIProviders<Self>,
+    ) -> Result<(), ScriptError>;
+
     /// the main point of contact with the bevy world.
     /// Scripts are called with appropriate events in the event order
     fn handle_events<'a>(
         &self,
-        world: &mut World,
+        world_ptr: &mut World,
         events: &[Self::ScriptEvent],
         ctxs: impl Iterator<Item = (ScriptData<'a>, &'a mut Self::ScriptContext)>,
+        providers: &mut APIProviders<Self>,
     );
 
     /// Loads and runs script instantaneously without storing any script data into the world.
-    /// The script receives the `world` global as normal, but `entity` is set to `u64::MAX`.
-    /// The script id is set to `u32::MAX`.
+    /// The host receives a fake script with `entity` set to `u64::MAX`
+    /// and where the script id is set to `u32::MAX`.
     fn run_one_shot(
         &mut self,
         script: &[u8],
@@ -101,13 +112,15 @@ pub trait ScriptHost: Send + Sync + 'static + Default {
             entity: Entity::from_bits(u64::MAX),
         };
 
-        let providers: &mut APIProviders<Self> = &mut world.resource_mut();
-        let mut ctx = self.load_script(script, &fd, providers).unwrap();
-
+        let mut providers: APIProviders<Self> = world.remove_resource().unwrap();
+        let mut ctx = self.load_script(script, &fd, &mut providers).unwrap();
+        self.setup_script(&fd, &mut ctx, &mut providers)?;
         let events = [event; 1];
-        let ctx_iter = [(fd, &mut ctx); 1].into_iter();
 
-        self.handle_events(world, &events, ctx_iter);
+        self.handle_events(world, &events, once((fd, &mut ctx)), &mut providers);
+
+        world.insert_resource(providers);
+
         Ok(())
     }
 
@@ -133,6 +146,16 @@ pub trait APIProvider: 'static + Send + Sync {
     /// engine. For one-time setup use `Self::setup_script`
     fn attach_api(&mut self, ctx: &mut Self::APITarget) -> Result<(), ScriptError>;
 
+    /// Hook executed every time a script is about to handle events, most notably used to "refresh" world pointers
+    fn setup_script_runtime(
+        &mut self,
+        _world_ptr: WorldPointer,
+        _script_data: &ScriptData,
+        _ctx: &mut Self::ScriptContext,
+    ) -> Result<(), ScriptError> {
+        Ok(())
+    }
+
     /// Setup meant to be executed once for every single script. Use this if you need to consistently setup scripts.
     /// For API's use `Self::attach_api` instead.
     fn setup_script(
@@ -184,6 +207,19 @@ impl<T: ScriptHost> APIProviders<T> {
         Ok(())
     }
 
+    pub fn setup_runtime_all(
+        &mut self,
+        world_ptr: WorldPointer,
+        script_data: &ScriptData,
+        ctx: &mut T::ScriptContext,
+    ) -> Result<(), ScriptError> {
+        for p in self.providers.iter_mut() {
+            p.setup_script_runtime(world_ptr.clone(), script_data, ctx)?;
+        }
+
+        Ok(())
+    }
+
     pub fn setup_all(
         &mut self,
         script_data: &ScriptData,
@@ -253,6 +289,10 @@ impl<C> ScriptContexts<C> {
             .get(&script_id)
             .map_or(false, |(_, c, _)| c.is_some())
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.context_entities.is_empty()
+    }
 }
 
 /// A struct defining an instance of a script asset.
@@ -309,6 +349,7 @@ impl<T: Asset> Script<T> {
         script_assets: &Assets<H::ScriptAsset>,
         providers: &mut APIProviders<H>,
         contexts: &mut ScriptContexts<H::ScriptContext>,
+        event_writer: &mut EventWriter<ScriptLoaded>,
     ) {
         debug!("reloading script {}", script.id);
         // retrieve owning entity
@@ -325,17 +366,21 @@ impl<T: Asset> Script<T> {
             script_assets,
             providers,
             contexts,
+            event_writer,
         );
     }
 
-    /// inserts a new script context for the given script
+    /// checks if a script has loaded, and if so loads (`ScriptHost::load_script`),
+    /// sets up (`ScriptHost::setup_script`) and inserts its new context into the contexts resource
+    /// otherwise inserts None. Sends ScriptLoaded event if the script was loaded
     pub(crate) fn insert_new_script_context<H: ScriptHost>(
         host: &mut H,
         new_script: &Script<H::ScriptAsset>,
         entity: Entity,
         script_assets: &Assets<H::ScriptAsset>,
         providers: &mut APIProviders<H>,
         contexts: &mut ScriptContexts<H::ScriptContext>,
+        event_writer: &mut EventWriter<ScriptLoaded>,
     ) {
         let fd = ScriptData {
             sid: new_script.id(),
@@ -355,14 +400,19 @@ impl<T: Asset> Script<T> {
         debug!("Inserted script {:?}", fd);
 
         match host.load_script(script.bytes(), &fd, providers) {
-            Ok(ctx) => {
+            Ok(mut ctx) => {
+                host.setup_script(&fd, &mut ctx, providers)
+                    .expect("Failed to setup script");
                 contexts.insert_context(fd, Some(ctx));
+                event_writer.send(ScriptLoaded {
+                    sid: new_script.id(),
+                });
             }
             Err(e) => {
                 warn! {"Error in loading script {}:\n{}", &new_script.name,e}
                 // this script will now never execute, unless manually reloaded
                 // but contexts are left in a valid state
-                contexts.insert_context(fd, None)
+                contexts.insert_context(fd, None);
             }
         }
     }