keep working on docs and fixing bugs

Author: makspll

Cargo.toml

@@ -79,6 +79,7 @@ clap = { version = "4.1", features = ["derive"] }
 rand = "0.8.5"
 bevy_console = "0.13"
 rhai-rand = "0.1"
+ansi-parser = "0.9"
 
 [workspace]
 members = [

assets/scripts/game_of_life.lua

@@ -1,58 +1,63 @@
-math.randomseed(os.time())
-
-function init()
-    local LifeState = world.get_type_by_name("LifeState")
-    local life_state = world.get_component(entity,LifeState)
-    local cells = life_state.cells
-
-    -- set some cells alive
-    for _=1,10000 do 
-        local index = math.random(#cells)
-        cells[index] = 255
-    end
+-- print("The game_of_life.lua script just got loaded")
+-- print("Hello from Lua! I am initiating the game of life simulation state to a random state now")
+
+-- math.randomseed(os.time())
+-- _LifeState = world.get_type_by_name("LifeState")
+_Settings = world.get_type_by_name("Settings")
+
+-- function fetch_life_state() 
+--     -- find the entity with life state 
+--     local life_state = nil
+--     for i,result in pairs(world.query({_LifeState}):build()) do 
+--         life_state = result:components()[1]
+--         break
+--     end 
+--     return life_state
+-- end    
+
+function on_init()
+    -- print("On init was called")
+    -- local life_state = fetch_life_state()
+    -- local cells = life_state.cells
+
+    -- -- set some cells alive
+    -- for _=1,10000 do 
+    --     local index = math.random(#cells)
+    --     cells[index] = 255
+    -- end
 end
 
 function on_update()
-    local LifeState = world.get_type_by_name("LifeState")
-    local Settings = world.get_type_by_name("Settings")
-
-    local life_state = world.get_component(entity,LifeState)
-    -- note currently this is a copy of the cells, as of now the macro does not automatically support Vec<T> proxies by reference
-    local cells = life_state.cells
-
-    -- note that here we do not make use of LuaProxyable and just go off pure reflection
-    local settings = world.get_resource(Settings)
-    local dimensions = settings.physical_grid_dimensions
-
-    
-    -- primitives are passed by value to lua, keep a hold of old state but turn 255's into 1's
-    local prev_state = {}
-    for k,v in pairs(cells) do 
-        prev_state[k] = (not(v == 0)) and 1 or 0
-    end
-
-    for i=1,(dimensions[1] * dimensions[2]) do 
-        local north = prev_state[i - dimensions[1]] or 1
-        local south = prev_state[i + dimensions[1]] or 1 
-        local east = prev_state[i + 1] or 1 
-        local west = prev_state[i - 1] or 1
-        local northeast = prev_state[i - dimensions[1] + 1] or 1
-        local southeast = prev_state[i + dimensions[1] + 1] or 1
-        local northwest = prev_state[i - dimensions[1] - 1] or 1
-        local southwest = prev_state[i + dimensions[1] - 1] or 1
-
-        local neighbours = north + south + east + west 
-            + northeast + southeast + northwest + southwest
+    -- local cells = fetch_life_state().cells
+    local settings = world.get_resource(_Settings)
+    -- local dimensions = settings.physical_grid_dimensions
+    -- local dimension_x = dimensions._1
+    -- local dimension_y = dimensions._2
+
+    -- -- primitives are passed by value to lua, keep a hold of old state but turn 255's into 1's
+    -- local prev_state = {}
+    -- for k,v in pairs(cells) do 
+    --     prev_state[k] = (not(v == 0)) and 1 or 0
+    -- end
+    -- for i=1,(dimension_x * dimension_y) do 
+    --     local north = prev_state[i - dimension_x] or 1
+    --     local south = prev_state[i + dimension_x] or 1 
+    --     local east = prev_state[i + 1] or 1 
+    --     local west = prev_state[i - 1] or 1
+    --     local northeast = prev_state[i - dimension_x + 1] or 1
+    --     local southeast = prev_state[i + dimension_x + 1] or 1
+    --     local northwest = prev_state[i - dimension_x - 1] or 1
+    --     local southwest = prev_state[i + dimension_x - 1] or 1
+
+    --     local neighbours = north + south + east + west 
+    --         + northeast + southeast + northwest + southwest
 
-        -- was dead and got 3 neighbours now
-        if prev_state[i] == 0 and neighbours == 3 then
-            cells[i] = 255
-        -- was alive and should die now
-        elseif prev_state[i] == 1 and ((neighbours < 2) or (neighbours > 3)) then
-            cells[i] = 0
-        end
-    end
-
-    -- propagate the updates
-    life_state.cells = cells
+    --     -- was dead and got 3 neighbours now
+    --     if prev_state[i] == 0 and neighbours == 3 then
+    --         cells[i] = 255
+    --     -- was alive and should die now
+    --     elseif prev_state[i] == 1 and ((neighbours < 2) or (neighbours > 3)) then
+    --         cells[i] = 0
+    --     end
+    -- end
 end

crates/bevy_mod_scripting_core/src/bindings/allocator.rs

@@ -3,12 +3,14 @@ use bevy::reflect::{PartialReflect, Reflect};
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
 use std::any::{Any, TypeId};
 use std::cell::UnsafeCell;
+use std::cmp::Ordering;
 use std::collections::HashMap;
 use std::fmt::{Display, Formatter};
+use std::hash::Hasher;
 use std::io::Read;
 use std::sync::Arc;
 
-#[derive(Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
+#[derive(Clone, Debug)]
 pub struct ReflectAllocationId(pub(crate) Arc<usize>);
 impl ReflectAllocationId {
     pub fn id(&self) -> usize {
@@ -25,6 +27,32 @@ impl ReflectAllocationId {
     }
 }
 
+impl std::hash::Hash for ReflectAllocationId {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.id().hash(state);
+    }
+}
+
+impl PartialEq for ReflectAllocationId {
+    fn eq(&self, other: &Self) -> bool {
+        self.id() == other.id()
+    }
+}
+
+impl Eq for ReflectAllocationId {}
+
+impl PartialOrd for ReflectAllocationId {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.id().cmp(&other.id()))
+    }
+}
+
+impl Ord for ReflectAllocationId {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.id().cmp(&other.id())
+    }
+}
+
 /// Pointer which owns the value it points to, and will deallocate it when dropped
 #[derive(Debug)]
 pub struct OwningPtr<T: ?Sized> {
@@ -193,7 +221,15 @@ impl ReflectAllocator {
     /// Runs a garbage collection pass on the allocations, removing any allocations which have no more strong references
     /// Needs to be run periodically to prevent memory leaks
     pub fn clean_garbage_allocations(&mut self) {
-        self.allocations.retain(|k, _| Arc::strong_count(&k.0) > 1);
+        bevy::log::debug!("Cleaning garbage allocations");
+
+        self.allocations.retain(|k, _| {
+            let retain = Arc::strong_count(&k.0) > 1;
+            if !retain {
+                bevy::log::debug!("Deallocating allocation {:?}", k);
+            }
+            retain
+        });
     }
 }
 

crates/bevy_mod_scripting_core/src/bindings/function/from.rs

@@ -182,8 +182,10 @@ impl<T: FromReflect> FromScript for Val<T> {
                     T::from_reflect(r).ok_or_else(|| {
                         InteropError::failed_from_reflect(
                             Some(TypeId::of::<T>()),
-                            format!("from reflect failed to produce output when converting to Val<T> from: {r:?}")
-                                .to_owned(),
+                            format!(
+                                "Expected '{}' but receievd: {r:?}",
+                                std::any::type_name::<T>()
+                            ),
                         )
                     })
                 },

crates/bevy_mod_scripting_core/src/bindings/function/mod.rs

@@ -46,10 +46,19 @@ impl CallScriptFunction for DynamicScriptFunction {
     ) -> Result<ScriptValue, InteropError> {
         let args = args.into_iter().collect::<Vec<_>>();
         let world_callback_access = WorldCallbackAccess::from_guard(world.clone());
+        bevy::log::debug!(
+            "Calling function {} with args {:?}",
+            self.name(),
+            args.display_with_world(world.clone())
+        );
         // should we be inlining call errors into the return value?
         let return_val = self.call(context, world_callback_access, args);
         match return_val {
-            ScriptValue::Error(e) => Err(InteropError::function_interop_error(self.name(), e)),
+            ScriptValue::Error(e) => Err(InteropError::function_interop_error(
+                self.name(),
+                context.self_type,
+                e,
+            )),
             v => Ok(v),
         }
     }
@@ -67,7 +76,11 @@ impl CallScriptFunction for DynamicScriptFunctionMut {
         // should we be inlining call errors into the return value?
         let return_val = self.call(context, world_callback_access, args);
         match return_val {
-            ScriptValue::Error(e) => Err(InteropError::function_interop_error(self.name(), e)),
+            ScriptValue::Error(e) => Err(InteropError::function_interop_error(
+                self.name(),
+                context.self_type,
+                e,
+            )),
             v => Ok(v),
         }
     }

crates/bevy_mod_scripting_core/src/bindings/function/script_function.rs

@@ -16,11 +16,11 @@ use bevy::{
     },
 };
 use parking_lot::{RwLock, RwLockReadGuard, RwLockWriteGuard};
-use std::borrow::Cow;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::ops::{Deref, DerefMut};
 use std::sync::Arc;
+use std::{any::TypeId, borrow::Cow};
 
 #[diagnostic::on_unimplemented(
     message = "Only functions with all arguments impplementing FromScript and return values supporting IntoScript are supported. Registering functions also requires they implement GetInnerTypeDependencies",
@@ -96,8 +96,8 @@ macro_rules! register_tuple_dependencies {
     };
 }
 
-no_type_dependencies!(ReflectReference, InteropError);
-self_type_dependency_only!(WorldCallbackAccess, CallerContext);
+no_type_dependencies!(InteropError);
+self_type_dependency_only!(WorldCallbackAccess, CallerContext, ReflectReference);
 
 recursive_type_dependencies!(
     (Val<T> where T: GetTypeRegistration),
@@ -118,8 +118,10 @@ pub trait GetFunctionTypeDependencies<Marker> {
 /// The caller context when calling a script function.
 /// Functions can choose to react to caller preferences such as converting 1-indexed numbers to 0-indexed numbers
 #[derive(Clone, Copy, Debug, Reflect)]
+#[reflect(opaque)]
 pub struct CallerContext {
     pub convert_to_0_indexed: bool,
+    pub self_type: Option<TypeId>,
 }
 
 /// The Script Function equivalent for dynamic functions. Currently unused

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -76,7 +76,7 @@ impl ReflectReferencePrinter {
         let base_kind = match base.base_id {
             ReflectBase::Component(e, _) => format!("Component on entity {}", e),
             ReflectBase::Resource(_) => "Resource".to_owned(),
-            ReflectBase::Owned(_) => "Allocation".to_owned(),
+            ReflectBase::Owned(ref id) => format!("Allocation({})", id),
         };
 
         out.push_str(&format!("{}({})", base_kind, type_path));
@@ -328,7 +328,7 @@ macro_rules! impl_dummy_display (
     ($t:ty) => {
         impl std::fmt::Display for $t {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(f, "Displaying {} without world access: {:#?}", stringify!($t), self)?;
+                write!(f, "<use display_with_world instead: {:#?}>", stringify!($t))?;
                 Ok(())
             }
         }
@@ -403,7 +403,7 @@ impl DisplayWithWorld for ScriptValue {
             ScriptValue::Integer(i) => i.to_string(),
             ScriptValue::Float(f) => f.to_string(),
             ScriptValue::String(cow) => cow.to_string(),
-            ScriptValue::Error(script_error) => script_error.to_string(),
+            ScriptValue::Error(script_error) => script_error.display_with_world(world),
             ScriptValue::List(vec) => {
                 let mut string = String::new();
                 ReflectReferencePrinter::pretty_print_key_values(
@@ -417,3 +417,31 @@ impl DisplayWithWorld for ScriptValue {
         }
     }
 }
+
+impl<T: DisplayWithWorld> DisplayWithWorld for Vec<T> {
+    fn display_with_world(&self, world: WorldGuard) -> String {
+        let mut string = String::new();
+        BracketType::Square.surrounded(&mut string, |string| {
+            for (i, v) in self.iter().enumerate() {
+                string.push_str(&v.display_with_world(world.clone()));
+                if i != self.len() - 1 {
+                    string.push_str(", ");
+                }
+            }
+        });
+        string
+    }
+
+    fn display_value_with_world(&self, world: WorldGuard) -> String {
+        let mut string = String::new();
+        BracketType::Square.surrounded(&mut string, |string| {
+            for (i, v) in self.iter().enumerate() {
+                string.push_str(&v.display_value_with_world(world.clone()));
+                if i != self.len() - 1 {
+                    string.push_str(", ");
+                }
+            }
+        });
+        string
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/query.rs

@@ -132,15 +132,33 @@ impl<'w> WorldAccessGuard<'w> {
             // which entities match the query
             // so we might be being slightly overkill
             for c in &query.components {
-                dynamic_query.ref_id(c.component_id().unwrap());
+                dynamic_query.ref_id(c.component_id().ok_or_else(|| {
+                    InteropError::unsupported_operation(
+                        Some(c.type_id()),
+                        None,
+                        "query for component on non-component type".to_owned(),
+                    )
+                })?);
             }
 
             for w in query.with {
-                dynamic_query.with_id(w.component_id.unwrap());
+                dynamic_query.with_id(w.component_id.ok_or_else(|| {
+                    InteropError::unsupported_operation(
+                        Some(w.type_id()),
+                        None,
+                        "query for entity with component which is non-component type".to_owned(),
+                    )
+                })?);
             }
 
             for without_id in query.without {
-                dynamic_query.without_id(without_id.component_id.unwrap());
+                dynamic_query.without_id(without_id.component_id.ok_or_else(|| {
+                    InteropError::unsupported_operation(
+                        Some(without_id.type_id()),
+                        None,
+                        "query for entity without component which is non-component type".to_owned(),
+                    )
+                })?);
             }
 
             let mut built_query = dynamic_query.build();

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -218,6 +218,7 @@ impl ReflectReference {
     ///
     /// # Panics
     /// - if the value is aliased and the access is not allowed
+    #[track_caller]
     pub fn with_reflect<O, F: FnOnce(&dyn PartialReflect) -> O>(
         &self,
         world: WorldGuard,
@@ -238,6 +239,7 @@ impl ReflectReference {
     ///
     /// # Panics
     /// - if the value is aliased and the access is not allowed
+    #[track_caller]
     pub fn with_reflect_mut<O, F: FnOnce(&mut dyn PartialReflect) -> O>(
         &self,
         world: WorldGuard,