update more examples

Author: makspll

assets/scripts/bevy_api.lua

@@ -0,0 +1,128 @@
+function table_to_string(t)
+    local result = "["
+    for k,v in pairs(t) do
+        result = result .. string.format("%s:%s,",k,v)
+    end
+    return result .. "]"
+end
+
+    
+-- the api provides us with 3 globals
+print(entity)
+print(script)
+print(world)
+
+-- we first retrieve ID's for our component and resource by their short name (long name/full path also work)
+local my_component_type = world:get_type_by_name("MyComponent")
+
+-- then ask the world to give us a reference to `MyComponent` on the entity we just spawned
+-- resources work the same way, but we use `get_resource` instead of `get_component`
+-- the comp object is resolved to a `bevy_script_api::script_ref::ReflectValue` which implements UserData.
+-- we can use a custom proxy instead (by implementing LuaProxyable), but this is the simplest way to get started.
+local comp = world:get_component(entity, my_component_type)
+print("Before script: ", comp)
+
+print("============")
+
+-- the index metamethod on ReflectValue's uses bevy's reflection mechanism on top of some custom sub-reflection logic to
+-- allow reflecting inside Options, Vectors etc. 
+-- when we index into ReflectValue's we either get back a custom proxy or another ReflectValue
+
+-- the LuaBevyAPIProvider provides us custom proxies for many bevy types as well as std types.
+-- all of these implementations can be overridden via the bevy TypeRegistry
+comp.usize = 2
+print("comp.usize after assigning to 2: ", comp.usize)
+
+-- vec's and matrices have custom __index and __newindex overrides
+print("comp.vec2 before: ", comp.vec2)
+comp.vec2[1] = 69
+print("comp.vec2 after: ", comp.vec2)
+
+-- Option's get converted to nil or the value inside
+print("comp.option_vec3 before: ", comp.option_vec3)
+comp.option_vec3 = Vec3.new(2,1,3)
+print("comp.option_vec3 after: ", comp.option_vec3)
+
+-- reflection via index is indexed starting at 1, unlike in Rust to match Lua's indexing
+print("comp.option_vec3[1] before: ", comp.option_vec3[1])
+comp.option_vec3[1] = 5
+print("comp.option_vec3[1] after: ", comp.option_vec3[1])
+
+print("============")
+
+-- Vec<T> references get converted to a custom proxy `LuaVec<T>` which is 
+-- also assignable via lua tables 
+
+print("comp.vec_of_option_bools before: ", table_to_string(comp.vec_of_option_bools))
+comp.vec_of_option_bools = {true,false,true}
+print("comp.vec_of_option_bools after assignment: ", table_to_string(comp.vec_of_option_bools))
+
+print("comp.vec_of_option_bools[1] before: ", comp.vec_of_option_bools[1])
+comp.vec_of_option_bools[1] = false
+print("comp.vec_of_option_bools[1] after: ", comp.vec_of_option_bools[1])
+
+-- there are some additional methods available on LuaVec proxies imitating the Vec<T> api
+print("comp.vec_of_option_bools before insert: ", table_to_string(comp.vec_of_option_bools))
+comp.vec_of_option_bools:insert(1,nil)
+print("comp.vec_of_option_bools after insert: ", table_to_string(comp.vec_of_option_bools))
+
+print("comp.vec_of_option_bools before push: ", table_to_string(comp.vec_of_option_bools))
+comp.vec_of_option_bools:push(false)
+print("comp.vec_of_option_bools after push: ", table_to_string(comp.vec_of_option_bools))
+
+print("comp.vec_of_option_bools len after push: ", #comp.vec_of_option_bools)
+
+print("comp.vec_of_option_bools before pop: ", table_to_string(comp.vec_of_option_bools))
+print(comp.vec_of_option_bools:pop())
+print("comp.vec_of_option_bools after pop: ", table_to_string(comp.vec_of_option_bools))
+
+print("the pairs inside comp.vec_of_option_bools: ")             
+for k,v in pairs(comp.vec_of_option_bools) do
+    print(string.format(" - %s:%s",k,v))
+end
+
+comp.vec_of_option_bools:clear()
+print("comp.vec_of_option_bools after clear: ", table_to_string(comp.vec_of_option_bools))
+
+print("comp.vec_of_option_bools len after clear: ", #comp.vec_of_option_bools)
+print("============")
+
+print("comp.option_vec_of_bools before: ", table_to_string(comp.option_vec_of_bools))
+print(comp.option_vec_of_bools:pop())
+print("comp.option_vec_of_bools after pop: ", table_to_string(comp.option_vec_of_bools))
+
+
+print("comp.option_vec_of_bools len after pop: ", #comp.option_vec_of_bools)
+
+print("the pairs inside comp.option_vec_of_bools: ")
+for k,v in pairs(comp.option_vec_of_bools) do
+    print(string.format(" - %s:%s",k,v))
+end
+
+print("============")
+
+local complex_vec_op = Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3.x_axis 
+print("(0,1,0).any_orthonormal_vector() + mat3.x_axis is: ", complex_vec_op) 
+
+local new_mat3 = Mat3.from_cols(Vec3.new(1,0,0),Vec3.new(0,1,0),Vec3.new(0,0,-1))
+print("new_mat3 is:", new_mat3)
+
+comp.vec2 = comp.vec2 + comp.vec2
+comp.usize = comp.vec2:min_element()
+comp.f32 = comp.f32 + comp.f32 + comp.vec2:min_element()
+comp.vec2 = Vec2.new(2,1)
+comp.quat = Quat.from_xyzw(3,2,1,4)
+comp.mat3.x_axis = Vec3.new(69,69,69)
+
+print("============")
+
+-- this is an example of something impossible to achieve with plain bevy reflection under the hood
+comp.mat3[1][1] = 42
+
+-- now let's retrieve these again to see if we actually changed their values permanently
+comp = world:get_component(entity,my_component_type)
+
+print("After script:")
+print(comp)
+
+world:exit()

assets/scripts/coroutines.lua

@@ -1,7 +1,6 @@
 local my_routine;
 
 function on_update()
-
     if my_routine == nil then
         my_routine = coroutine.create(function()
             local starttime = os.time()
@@ -18,7 +17,7 @@ function on_update()
             coroutine.resume(my_routine)
         else
             print("Couroutine has finished, no longer running")
+            world:exit()
         end
     end
-
 end

assets/scripts/dynamic_queries.lua

@@ -1,9 +1,23 @@
-function on_event()
-	local component_a = world:get_type_by_name("ComponentA")
-	local component_b = world:get_type_by_name("ComponentB")
-	local component_c = world:get_type_by_name("ComponentC")
-
-	for entity, _ in world:query(component_a):with(component_b):without(component_c):iter() do
-		print(entity)
-	end
+local component_a = world:get_type_by_name("ComponentA")
+local component_b = world:get_type_by_name("ComponentB")
+local component_c = world:get_type_by_name("ComponentC")
+
+print("Querying for entities with component_a and without component_c")
+for entity, c in world:query(component_a):without(component_c):iter() do
+	print("Entity with index: " .. entity:index() .. " component: " .. tostring(c))
+end
+
+print("Querying for entities with component_b and without component_a")
+for entity, c in world:query(component_b):without(component_a):iter() do
+	print("Entity with index: " .. entity:index() .. " component: " .. tostring(c))
 end
+
+print("Querying for all components at once")
+for entity, c1,c2,c3 in world:query(component_a, component_b, component_c):iter() do
+	print("Entity with index: " .. entity:index())
+	print("\tComponentA: " .. tostring(c1))
+	print("\tComponentB: " .. tostring(c2))
+	print("\tComponentC: " .. tostring(c3))
+end
+
+world:exit()

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -57,9 +57,16 @@ pub struct ReflectReference {
 }
 
 
-
 impl ReflectReference {
 
+    pub fn print_with_world(&self, world: &WorldAccessGuard) -> String {
+        let base = world.with_resource(|_, type_registry: Mut<AppTypeRegistry>| {
+            self.base.display_with_type_name(&type_registry.read())
+        });
+
+        format!("Reference(base: {}, path: {:?})", base, self.reflect_path)
+    }
+
     /// If this is a reference to something with a length accessible via reflection, returns that length.
     pub fn len(&self, world: &WorldAccessGuard) -> Option<usize> {
         world.with_resource(|world, type_registry: Mut<AppTypeRegistry>| {
@@ -371,11 +378,15 @@ impl ReflectBaseType {
     }
 
     pub fn display_with_type_name(&self, type_registry: &TypeRegistry) -> String {
-        format!(
-            "ReflectBase({}, {:?})",
-            Self::type_name(self.type_id, type_registry),
-            self.base_id
-        )
+        let type_name = Self::type_name(self.type_id, type_registry);
+
+        let kind = match self.base_id {
+            ReflectBase::Component(entity, _) => "Component",
+            ReflectBase::Resource(_) => "Resource",
+            ReflectBase::Owned(id) => "Allocation",
+        };
+
+        format!("{}({})", kind, type_name)
     }
 }
 

crates/bevy_mod_scripting_core/src/bindings/world.rs

@@ -18,6 +18,7 @@ use std::{
 };
 
 use bevy::{
+    app::AppExit,
     ecs::{
         component::{Component, ComponentId},
         entity::Entity,
@@ -234,6 +235,11 @@ impl WorldCallbackAccess {
         let world = self.read().unwrap_or_else(|| panic!("{STALE_WORLD_MSG}"));
         world.despawn_descendants(entity)
     }
+
+    pub fn exit(&self) {
+        let world = self.read().unwrap_or_else(|| panic!("{STALE_WORLD_MSG}"));
+        world.exit()
+    }
 }
 
 /// Unit of world access
@@ -973,6 +979,15 @@ impl<'w> WorldAccessGuard<'w> {
 
         Ok(())
     }
+
+    /// Sends AppExit event to the world with success status
+    pub fn exit(&self) {
+        if let Some(world) = self.get_whole_world_access() {
+            world.send_event(AppExit::Success);
+        } else {
+            panic!("{CONCURRENT_WORLD_ACCESS_MSG}")
+        }
+    }
 }
 
 /// Having this is permission to access the contained [`ReflectAccessId`], there is no way to access anything safely through a [`WorldAccessGuard`]

crates/bevy_mod_scripting_core/src/commands.rs

@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use std::{any::type_name, marker::PhantomData};
 
 use bevy::{asset::Handle, ecs::world::Mut, log::debug, prelude::Command};
 
@@ -7,6 +7,7 @@ use crate::{
     context::{Context, ContextLoadingSettings, ScriptContexts},
     prelude::{Runtime, RuntimeContainer},
     script::{Script, ScriptId, Scripts},
+    systems::handle_script_errors,
 };
 
 pub struct DeleteScript<C: Context, R: Runtime> {
@@ -111,8 +112,14 @@ impl<C: Context, R: Runtime> Command for CreateOrUpdateScript<C, R> {
             let current_context_id = if let Some(id) = current_context_id {
                 id
             } else {
-                let ctxt = (builder.load)(&self.id, &self.content, &settings.context_initializers, &settings.context_pre_handling_initializers, world, &mut runtime.runtime).unwrap();
-                contexts.insert(ctxt)
+                let ctxt = (builder.load)(&self.id, &self.content, &settings.context_initializers, &settings.context_pre_handling_initializers, world, &mut runtime.runtime);
+                match ctxt {
+                    Ok(ctxt) => contexts.insert(ctxt),
+                    Err(e) => {
+                        handle_script_errors(world, &format!("Failed to load context for script with id: {}. With runtime type: {} and context type: {}", self.id, type_name::<R>(), type_name::<C>()), [e]);
+                        return;
+                    }
+                }
             };
 
             if let Some(previous) = previous_context_id {

crates/bevy_mod_scripting_core/src/systems.rs

@@ -6,6 +6,7 @@ use crate::{
     bindings::ReflectAllocator,
     commands::{CreateOrUpdateScript, DeleteScript},
     context::{Context, ContextLoadingSettings, ScriptContexts},
+    error::{ScriptError, ScriptResult},
     event::{IntoCallbackLabel, ScriptCallbackEvent, ScriptErrorEvent},
     handler::{Args, CallbackSettings},
     prelude::RuntimeSettings,
@@ -181,18 +182,30 @@ pub fn event_handler<L: IntoCallbackLabel, A: Args, C: Context, R: Runtime>(
     world.insert_non_send_resource(runtime_container);
     world.insert_non_send_resource(script_contexts);
 
-    for error in errors {
-        let mut error_events = world
-            .get_resource_mut::<Events<ScriptErrorEvent>>()
-            .expect("Missing events resource");
-
-        bevy::log::error!(
-            "Encountered error in event handling for - Runtime {}, Context: {}, Args: {}. {}",
+    handle_script_errors(
+        world,
+        &format!(
+            "Encountered error in event handling for: Runtime {}, Context: {}, Args: {}",
             type_name::<R>(),
             type_name::<C>(),
-            type_name::<A>(),
-            error.to_string()
-        );
+            type_name::<A>()
+        ),
+        errors,
+    );
+}
+
+/// Handles errors caused by script execution and sends them to the error event channel
+pub(crate) fn handle_script_errors<I: IntoIterator<Item = ScriptError>>(
+    world: &mut World,
+    context: &str,
+    errors: I,
+) {
+    let mut error_events = world
+        .get_resource_mut::<Events<ScriptErrorEvent>>()
+        .expect("Missing events resource");
+
+    for error in errors {
+        bevy::log::error!("{}. {}", context, error.to_string());
         error_events.send(ScriptErrorEvent { error });
     }
 }

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

@@ -224,7 +224,12 @@ impl TealData for LuaReflectReference {
 
         m.add_meta_function(MetaMethod::Len, |l, self_: LuaReflectReference| {
             self_.len(l)
-        })
+        });
+
+        m.add_meta_function(MetaMethod::ToString, |lua, self_: LuaReflectReference| {
+            let world = lua.get_world()?;
+            Ok(self_.0.print_with_world(&world))
+        });
     }
 }
 

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

@@ -396,6 +396,15 @@ impl TealData for LuaWorld {
                 Ok(builder)
             },
         );
+
+        methods.add_method("exit", |_, this, ()| {
+            // TODO: somehow end control flow on lua side
+            let world = this.0.read().ok_or_else(|| {
+                mlua::Error::external(ScriptError::new_reflection_error("Stale world access"))
+            })?;
+            world.exit();
+            Ok(())
+        });
     }
 
     fn add_fields<'lua, F: tealr::mlu::TealDataFields<'lua, Self>>(_fields: &mut F) {}