improve logs and things

Author: makspll

assets/scripts/game_of_life.lua

@@ -1,10 +1,11 @@
-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")
 
+world.info("Lua: The game_of_life.lua script just got loaded")
+world.info("Lua: Hello! I am initiating the game of life simulation state with randomness!")
+
+math.randomseed(os.time())
+
 function fetch_life_state() 
     -- find the entity with life state 
     local life_state = nil
@@ -19,11 +20,34 @@ local life_state = fetch_life_state()
 local cells = life_state.cells
 
 -- set some cells alive
-for _=1,10000 do 
+for _=1,1000 do 
     local index = math.random(#cells)
     cells[index] = 255
 end
 
+function on_click(x,y)
+    -- get the settings
+    world.info("Lua: Clicked at x: " .. x .. " y: " .. y)
+    local settings = world.get_resource(Settings)
+    local dimensions = settings.physical_grid_dimensions
+    local screen = settings.display_grid_dimensions
+
+    local dimension_x = dimensions._1
+    local dimension_y = dimensions._2
+
+    local screen_x = screen._1
+    local screen_y = screen._2
+
+    local cell_width = screen_x / dimension_x
+    local cell_height = screen_y / dimension_y
+
+    local cell_x = math.floor(x / cell_width)
+    local cell_y = math.floor(y / cell_height)
+
+    local index = (cell_y * dimension_x) + cell_x
+    cells[index] = 255
+end
+
 function on_update()
     local cells = fetch_life_state().cells
     world.log_all_allocations()
@@ -38,14 +62,15 @@ function on_update()
         prev_state[#prev_state+1] = (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
+        -- wrap around the north and south edges
+        local north = prev_state[i - dimension_x] or prev_state[i + dimension_x * (dimension_y - 1)]
+        local south = prev_state[i + dimension_x] or prev_state[i - dimension_x * (dimension_y - 1)]
+        local east = prev_state[i + 1] or 0
+        local west = prev_state[i - 1] or 0
+        local northeast = prev_state[i - dimension_x + 1] or 0
+        local southeast = prev_state[i + dimension_x + 1] or 0
+        local northwest = prev_state[i - dimension_x - 1] or 0
+        local southwest = prev_state[i + dimension_x - 1] or 0
 
         local neighbours = north + south + east + west 
             + northeast + southeast + northwest + southwest

crates/bevy_mod_scripting_core/src/asset.rs

@@ -4,10 +4,10 @@ use std::{
 };
 
 use bevy::{
-    asset::{Asset, AssetLoader, AsyncReadExt},
+    asset::{Asset, AssetId, AssetLoader, AsyncReadExt},
     ecs::system::Resource,
     reflect::TypePath,
-    utils::BoxedFuture,
+    utils::{BoxedFuture, HashMap},
 };
 
 use crate::{prelude::ScriptError, script::ScriptId};
@@ -84,3 +84,23 @@ impl Default for ScriptAssetSettings {
 pub struct AssetPathToScriptIdMapper {
     pub map: fn(&Path) -> ScriptId,
 }
+
+/// A cache of asset id's to their script id's. Necessary since when we drop an asset we won't have the ability to get the path from the asset.
+#[derive(Default, Debug, Resource)]
+pub struct AssetIdToScriptIdMap {
+    pub map: HashMap<AssetId<ScriptAsset>, ScriptId>,
+}
+
+impl AssetIdToScriptIdMap {
+    pub fn insert(&mut self, id: AssetId<ScriptAsset>, path: ScriptId) {
+        self.map.insert(id, path);
+    }
+
+    pub fn get(&self, id: AssetId<ScriptAsset>) -> Option<&ScriptId> {
+        self.map.get(&id)
+    }
+
+    pub fn remove(&mut self, id: AssetId<ScriptAsset>) -> Option<ScriptId> {
+        self.map.remove(&id)
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -3,7 +3,10 @@ use crate::reflection_extensions::{FakeType, TypeIdExtensions};
 use super::{
     script_value::ScriptValue, ReflectBase, ReflectBaseType, ReflectReference, WorldGuard,
 };
-use bevy::reflect::{PartialReflect, ReflectRef};
+use bevy::{
+    prelude::World,
+    reflect::{PartialReflect, ReflectRef},
+};
 use itertools::Itertools;
 use std::{any::TypeId, borrow::Cow};
 
@@ -56,7 +59,7 @@ macro_rules! downcast_case {
 }
 
 impl ReflectReferencePrinter {
-    const UNREGISTERED_TYPE: &'static str = "Unregistered TypeId";
+    const UNREGISTERED_TYPE: &'static str = "Unregistered";
     const UNKNOWN_FIELD: &'static str = "<Unknown Field>";
 
     pub fn new(reference: ReflectReference) -> Self {
@@ -65,13 +68,7 @@ impl ReflectReferencePrinter {
 
     fn pretty_print_base(base: &ReflectBaseType, world: WorldGuard, out: &mut String) {
         let type_id = base.type_id;
-        let type_registry = world.type_registry();
-        let type_registry = type_registry.read();
-
-        let type_path = type_registry
-            .get_type_info(type_id)
-            .map(|t| t.type_path_table().short_path())
-            .unwrap_or_else(|| ReflectReferencePrinter::UNREGISTERED_TYPE);
+        let type_path = type_id.display_with_world(world.clone());
 
         let base_kind = match base.base_id {
             ReflectBase::Component(e, _) => format!("Component on entity {}", e),
@@ -365,6 +362,9 @@ impl DisplayWithWorld for TypeId {
     fn display_with_world(&self, world: WorldGuard) -> String {
         if *self == TypeId::of::<FakeType>() {
             return "Dynamic Type".to_owned();
+        } else if *self == TypeId::of::<World>() {
+            // does not implement Reflect, so we do this manually
+            return "World".to_owned();
         }
 
         let type_registry = world.type_registry();

crates/bevy_mod_scripting_core/src/commands.rs

@@ -117,7 +117,7 @@ impl<P: IntoScriptPluginParams> Command for CreateOrUpdateScript<P> {
                 match ctxt {
                     Ok(ctxt) => contexts.insert(ctxt),
                     Err(e) => {
-                        handle_script_errors(world, [e.with_context(format!("Loading context for script with id: {}. With runtime type: {} and context type: {}", self.id, type_name::<P::R>(), type_name::<P::C>()))].into_iter());
+                        handle_script_errors(world, [e.with_context(format!("Loading script with id: {}. Runtime type: {}, Context type: {}", self.id, type_name::<P::R>(), type_name::<P::C>()))].into_iter());
                         return;
                     }
                 }

crates/bevy_mod_scripting_core/src/lib.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::arc_with_non_send_sync)]
 
 use crate::event::ScriptErrorEvent;
-use asset::{ScriptAsset, ScriptAssetLoader, ScriptAssetSettings};
+use asset::{AssetIdToScriptIdMap, ScriptAsset, ScriptAssetLoader, ScriptAssetSettings};
 use bevy::prelude::*;
 use bindings::{
     function::script_function::AppScriptFunctionRegistry, script_value::ScriptValue,
@@ -83,6 +83,7 @@ impl<P: IntoScriptPluginParams> Plugin for ScriptingPlugin<P> {
             .init_resource::<AppReflectAllocator>()
             .init_resource::<ScriptAssetSettings>()
             .init_resource::<Scripts>()
+            .init_resource::<AssetIdToScriptIdMap>()
             .init_asset::<ScriptAsset>()
             .register_asset_loader(ScriptAssetLoader {
                 language: "<>".into(),
@@ -230,6 +231,8 @@ impl<D: DocumentationFragment> StoreDocumentation<D> for App {
 
 #[cfg(test)]
 mod test {
+    use asset::AssetIdToScriptIdMap;
+
     use super::*;
 
     #[test]
@@ -261,5 +264,6 @@ mod test {
             .contains_resource::<ContextLoadingSettings<Plugin>>());
         assert!(app.world().contains_non_send::<RuntimeContainer<Plugin>>());
         assert!(app.world().contains_non_send::<ScriptContexts<Plugin>>());
+        assert!(app.world().contains_resource::<AssetIdToScriptIdMap>());
     }
 }

crates/bevy_mod_scripting_core/src/systems.rs

@@ -2,7 +2,7 @@ use bevy::{ecs::system::SystemState, prelude::*};
 use std::any::type_name;
 
 use crate::{
-    asset::{ScriptAsset, ScriptAssetSettings},
+    asset::{AssetIdToScriptIdMap, ScriptAsset, ScriptAssetSettings},
     bindings::{pretty_print::DisplayWithWorld, ReflectAllocator, WorldAccessGuard, WorldGuard},
     commands::{CreateOrUpdateScript, DeleteScript},
     context::{Context, ContextLoadingSettings, ScriptContexts},
@@ -35,39 +35,51 @@ pub fn sync_script_data<P: IntoScriptPluginParams>(
     mut events: EventReader<AssetEvent<ScriptAsset>>,
     script_assets: Res<Assets<ScriptAsset>>,
     asset_settings: Res<ScriptAssetSettings>,
+    mut asset_path_map: ResMut<AssetIdToScriptIdMap>,
     mut commands: Commands,
 ) {
     for event in events.read() {
-        debug!("Responding to script asset event: {:?}", event);
+        trace!("Received script asset event: {:?}", event);
         let (id, remove) = match event {
             // emitted when a new script asset is loaded for the first time
             AssetEvent::Added { id } => (id, false),
             AssetEvent::Modified { id } => (id, false),
-            AssetEvent::Removed { id } | AssetEvent::Unused { id } => (id, true),
+            AssetEvent::Removed { id } => (id, true),
             _ => continue,
         };
+        info!("Responding to script asset event: {:?}", event);
         // get the path
         let asset = script_assets.get(*id);
-        let asset = match asset.as_ref() {
-            Some(a) => a,
+
+        let script_id = match asset_path_map.get(*id) {
+            Some(id) => id.clone(),
             None => {
-                if remove {
-                    debug!(
-                        "Script presumably failed to load, no need to remove anything, ignoring."
-                    );
-                    continue;
-                } else {
-                    panic!("Asset was expected to be loaded!");
-                }
+                // we should only enter this branch for new assets
+                let asset = match asset {
+                    Some(asset) => asset,
+                    None => {
+                        // this can happen if an asset is loaded and immediately unloaded, we can ignore this
+                        continue;
+                    }
+                };
+
+                let path = &asset.asset_path;
+                let converter = asset_settings.script_id_mapper.map;
+                let script_id = converter(path);
+                asset_path_map.insert(*id, script_id.clone());
+
+                script_id
             }
         };
 
-        let path = &asset.asset_path;
-        // convert it to script id
-        let converter = asset_settings.script_id_mapper.map;
-        let script_id = converter(path);
-
         if !remove {
+            let asset = match asset {
+                Some(asset) => asset,
+                None => {
+                    // this can happen if an asset is loaded and immediately unloaded, we can ignore this
+                    continue;
+                }
+            };
             commands.queue(CreateOrUpdateScript::<P>::new(
                 script_id,
                 asset.content.clone(),
@@ -164,7 +176,7 @@ pub fn event_handler<L: IntoCallbackLabel, P: IntoScriptPluginParams>(
                 let script = match scripts.scripts.get(script_id) {
                     Some(s) => s,
                     None => {
-                        info!(
+                        trace!(
                             "Script `{}` on entity `{:?}` is either still loading or doesn't exist, ignoring.",
                             script_id, entity
                         );

crates/bevy_mod_scripting_functions/src/core.rs

@@ -32,9 +32,7 @@ pub fn register_world_functions(reg: &mut World) -> Result<(), FunctionRegistrat
         .register(
             "get_type_by_name",
             |world: WorldCallbackAccess, type_name: String| {
-                println!("get_type_by_name in: {}", type_name);
                 let val = world.get_type_by_name(type_name)?;
-                println!("get_type_by_name out: {:?}", val);
                 Ok(val.map(Val))
             },
         )
@@ -151,14 +149,9 @@ pub fn register_world_functions(reg: &mut World) -> Result<(), FunctionRegistrat
             let world = s.try_read().expect("stale world");
             let allocator = world.allocator();
             let allocator = allocator.read();
-            for (id,a) in allocator.iter_allocations() {
+            for (id,_) in allocator.iter_allocations() {
                 let raid = ReflectAccessId::for_allocation(id.clone());
                 if world.claim_read_access(raid) {
-                    {
-                        let ptr = a.get_ptr();
-                        let a = unsafe { &*ptr };
-                        bevy::log::info!("Allocation Id: {}, value: {:?}", id.id(), a);
-                    }
                     // Safety: ref released above
                     unsafe { world.release_access(raid) };
                 } else {

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

@@ -144,9 +144,7 @@ fn try_call_overloads(
         }
     }
 
-    Err(last_error
-        .unwrap_or_else(|| InteropError::missing_function(type_id, key.to_string()).into())
-        .into())
+    Err(last_error.unwrap_or_else(|| InteropError::missing_function(type_id, key.to_string())))
 }
 
 impl UserData for LuaReflectReference {
@@ -375,8 +373,11 @@ impl UserData for LuaStaticReflectReference {
                         return func?.into_lua(lua);
                     }
                 };
-
-                Err(InteropError::missing_function(type_id, key.to_string()).into())
+                let world = lua.get_world();
+                Err(
+                    InteropError::missing_function(type_id, key.display_with_world(world.clone()))
+                        .into(),
+                )
             },
         );
     }

crates/languages/bevy_mod_scripting_lua/src/lib.rs

@@ -27,7 +27,7 @@ use bindings::{
     world::{GetWorld, LuaWorld},
 };
 pub use mlua;
-use mlua::{Function, IntoLuaMulti, Lua};
+use mlua::{Function, IntoLua, IntoLuaMulti, Lua, MultiValue};
 pub mod bindings;
 pub mod prelude {
     pub use crate::mlua::{self, prelude::*, Value};
@@ -195,13 +195,13 @@ pub fn lua_handler(
             Err(_) => return Ok(()),
         };
 
-        handler
-            .call::<()>(
-                args.into_iter()
-                    .map(LuaScriptValue::from)
-                    .collect::<Vec<_>>(),
-            )
-            .map_err(ScriptError::from_mlua_error)?;
+        let input = MultiValue::from_vec(
+            args.into_iter()
+                .map(|arg| LuaScriptValue::from(arg).into_lua(context))
+                .collect::<Result<_, _>>()?,
+        );
+
+        handler.call::<()>(input)?;
         Ok(())
     })
 }