Merge pull request 'reloading' (#1) from wip into master

Reviewed-on: #1

.gitea/workflows/build.yaml

@@ -0,0 +1,25 @@
+name: Build
+on: [push]
+
+jobs:
+  Build:
+    env:
+      RUNNER_TOOL_CACHE: /toolcache
+    container: rust:alpine
+    steps:
+      - name: Install node
+        run: apk add nodejs gcc libc-dev pkgconf libx11-dev alsa-lib-dev eudev-dev tar openssl-dev
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Restore cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Build
+        run: cargo build --release

.github/workflows/docs.yml

@@ -1,50 +0,0 @@
-name: Docs
-on:
-  push:
-    branches: [master]
-permissions:
-  contents: read
-  pages: write
-  id-token: write
-concurrency:
-  group: deploy
-  cancel-in-progress: false
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-      - name: Install Dependencies
-        run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-      - name: Setup Rust
-        uses: dtolnay/rust-toolchain@stable
-      - name: Configure cache
-        uses: Swatinem/rust-cache@v2
-      - name: Setup pages
-        id: pages
-        uses: actions/configure-pages@v4
-      - name: Clean docs folder
-        run: cargo clean --doc
-      - name: Build docs
-        run: cargo doc --no-deps
-      - name: Add redirect
-        run: echo '<meta http-equiv="refresh" content="0;url=bevy_dirworld/index.html">' > target/doc/index.html
-      - name: Remove lock file
-        run: rm target/doc/.lock
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: target/doc
-  deploy:
-    name: Deploy
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: ubuntu-latest
-    needs: build
-    steps:
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.github/workflows/rust.yml

@@ -1,24 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install Dependencies
-      run: sudo apt-get update; sudo apt-get install --no-install-recommends libasound2-dev libudev-dev
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose

.gitignore

@@ -1 +1,3 @@
 /target
+Cargo.lock
+.cargo

Cargo.toml

@@ -1,22 +1,22 @@
 [package]
 name = "bevy_dirworld"
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 
 [dependencies]
 async-channel = "2.3"
-notify = "7.0"
+notify = "8.0"
 tar = "0.4"
 xz2 = "0.1"
 rust-crypto = "0.2"
 multi_key_map = "0.3"
 serde = "1.0"
 rmp-serde = "1.3"
-notify-debouncer-full = "0.4"
+notify-debouncer-full = "0.5"
 md5 = "0.7"
 aes = "0.8"
 hex = "0.4"
-hex-literal = "0.4"
+hex-literal = "1.0"
 uuid = "1.11"
 lazy_static = "1.5"
 
@@ -30,7 +30,7 @@ version = "0.2"
 features = ["serialize"]
 
 [dependencies.occule]
-git = "https://git.exvacuum.dev/occule"
+git = "https://git.soaos.dev/soaos/occule"
 tag = "v0.3.1"
 
 [dependencies.yarnspinner]
@@ -39,15 +39,15 @@ optional = true
 features = ["serde"]
 
 [dependencies.bevy_mod_scripting]
-version = "0.8"
-features = ["lua54", "lua_script_api"]
+version = "0.11"
+features = ["lua54", "bevy_bindings"]
 
 [dependencies.bevy_basic_interaction]
-git = "https://git.exvacuum.dev/bevy_basic_interaction"
+git = "https://git.soaos.dev/soaos/bevy_basic_interaction"
 tag = "v0.2.0"
 
 [dependencies.strum]
-version = "0.26"
+version = "0.27"
 features = ["derive"]
 
 [features]

src/commands.rs

@@ -59,7 +59,7 @@ impl Command for DirworldLockDoorCommand {
                         .take_read_buffer()
                         .take_remaining()
                         .iter()
-                        .map(|&i| i),
+                        .copied(),
                 );
                 match result {
                     BufferResult::BufferUnderflow => break,
@@ -75,7 +75,7 @@ impl Command for DirworldLockDoorCommand {
 
             // Insert key hash as payload relationship
             let key_digest = md5::compute(&self.key[..16]);
-            let mut payload = payload.unwrap_or_else(|| DirworldEntityPayload::new());
+            let mut payload = payload.unwrap_or_else(DirworldEntityPayload::new);
             let relationships = payload.relationships.get_or_insert_default();
             relationships.insert("key".into(), key_digest.0);
 
@@ -89,7 +89,7 @@ impl Command for DirworldLockDoorCommand {
         });
         world.resource_mut::<DirworldTasks>().insert(
             format!("Locking {:?}", self.path.file_name().unwrap()),
-            task,
+            Some(task),
         );
     }
 }
@@ -125,7 +125,7 @@ impl Command for DirworldUnlockDoorCommand {
                         .take_read_buffer()
                         .take_remaining()
                         .iter()
-                        .map(|&i| i),
+                        .copied(),
                 );
                 match result {
                     BufferResult::BufferUnderflow => break,
@@ -154,7 +154,7 @@ impl Command for DirworldUnlockDoorCommand {
                 let new_path = parent.join(path.file_stem_no_extensions().unwrap());
                 let _ = fs::create_dir(new_path.clone());
                 command_queue.push(DirworldSaveEntityCommand {
-                    path: new_path.into(),
+                    path: new_path,
                     payload,
                 });
                 return Some(command_queue);
@@ -163,7 +163,7 @@ impl Command for DirworldUnlockDoorCommand {
         });
         world.resource_mut::<DirworldTasks>().insert(
             format!("Unlocking {:?}", self.path.file_name().unwrap()),
-            task,
+            Some(task),
         );
     }
 }
@@ -265,7 +265,7 @@ pub trait DirworldCommands {
     fn dirworld_save_entity(&mut self, path: PathBuf, payload: DirworldEntityPayload);
 }
 
-impl<'w, 's> DirworldCommands for Commands<'w, 's> {
+impl DirworldCommands for Commands<'_, '_> {
     fn dirworld_lock_door(&mut self, path: PathBuf, key: Vec<u8>) {
         self.queue(DirworldLockDoorCommand { key, path });
     }

src/conditionals.rs

@@ -82,7 +82,7 @@ impl Condition {
             Condition::ChildOf { .. } => "conditional_child_of",
             Condition::ParentOf { .. } => "conditional_parent_of",
             Condition::DescendantOf { .. } => "conditional_descendant_of",
-            Condition::AncestorOf { .. } =>"conditional_ancestor_of",
+            Condition::AncestorOf { .. } => "conditional_ancestor_of",
             Condition::InRoom(_) => "conditional_in_room",
             Condition::ObjectInRoom(_) => "conditional_object_in_room",
         }
@@ -93,51 +93,37 @@ impl Condition {
         match name {
             "conditional_true" => Some(Condition::True),
             "conditional_child_of" => {
-                let Some(child) = args.get(0).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
-                let Some(parent) = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
+                let child = args.first().and_then(|arg| Uuid::parse_str(arg).ok())?;
+                let parent = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok())?;
                 Some(Condition::ChildOf { child, parent })
             }
             "conditional_parent_of" => {
-                let Some(child) = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
-                let Some(parent) = args.get(0).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
+                let child = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok())?;
+                let parent = args.first().and_then(|arg| Uuid::parse_str(arg).ok())?;
                 Some(Condition::ParentOf { child, parent })
             }
             "conditional_descendant_of" => {
-                let Some(descendant) = args.get(0).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
-                let Some(ancestor) = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
-                Some(Condition::DescendantOf { descendant, ancestor })
+                let descendant = args.first().and_then(|arg| Uuid::parse_str(arg).ok())?;
+                let ancestor = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok())?;
+                Some(Condition::DescendantOf {
+                    descendant,
+                    ancestor,
+                })
             }
             "conditional_ancestor_of" => {
-                let Some(descendant) = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
-                let Some(ancestor) = args.get(0).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
-                Some(Condition::AncestorOf { descendant, ancestor })
+                let descendant = args.get(1).and_then(|arg| Uuid::parse_str(arg).ok())?;
+                let ancestor = args.first().and_then(|arg| Uuid::parse_str(arg).ok())?;
+                Some(Condition::AncestorOf {
+                    descendant,
+                    ancestor,
+                })
             }
             "condtitional_in_room" => {
-                let Some(room_id) = args.get(0).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
+                let room_id = args.first().and_then(|arg| Uuid::parse_str(arg).ok())?;
                 Some(Condition::InRoom(room_id))
             }
             "condtitional_object_in_room" => {
-                let Some(object_id) = args.get(0).and_then(|arg| Uuid::parse_str(arg).ok()) else {
-                    return None;
-                };
+                let object_id = args.first().and_then(|arg| Uuid::parse_str(arg).ok())?;
                 Some(Condition::ObjectInRoom(object_id))
             }
             _ => None,
@@ -169,9 +155,7 @@ fn ancestor_of(world: &mut World, ancestor: Uuid, descendant: Uuid) -> bool {
         return false;
     };
 
-    AncestorIter::new(&parents, descendant_entity)
-        .find(|descendant| *descendant == ancestor_entity)
-        .is_some()
+    AncestorIter::new(&parents, descendant_entity).any(|descendant| descendant == ancestor_entity)
 }
 
 fn parent_of(world: &mut World, parent: Uuid, child: Uuid) -> bool {
@@ -203,18 +187,18 @@ fn parent_of(world: &mut World, parent: Uuid, child: Uuid) -> bool {
 
 fn in_room(world: &mut World, room: Uuid) -> bool {
     let current_dir = world.resource::<DirworldCurrentDir>();
-    current_dir.payload.as_ref().is_some_and(|payload| payload.id == room)
+    current_dir
+        .payload
+        .as_ref()
+        .is_some_and(|payload| payload.id == room)
 }
 
 fn object_in_room(world: &mut World, object: Uuid) -> bool {
     let mut dirworld_entities = world.query::<&DirworldEntity>();
-    dirworld_entities
-        .iter(world)
-        .find(|entity| {
-            entity
-                .payload
-                .as_ref()
-                .is_some_and(|payload| payload.id == object)
-        })
-        .is_some()
+    dirworld_entities.iter(world).any(|entity| {
+        entity
+            .payload
+            .as_ref()
+            .is_some_and(|payload| payload.id == object)
+    })
 }

src/events.rs

@@ -2,33 +2,32 @@ use std::path::PathBuf;
 
 use bevy::prelude::*;
 
-/// Events related to activities in the dirworld.
-#[derive(Event)]
-pub enum DirworldNavigationEvent {
-    /// Triggered when a room is left.
-    LeftRoom {
-        /// Path of room just left.
-        path: PathBuf,
-    },
-    /// Triggered when a room is entered.
-    EnteredRoom {
-        /// Path of room just entered.
-        path: PathBuf,
-    },
-}
-
 /// Event called when leaving a room
 #[derive(Debug, Event, Deref, DerefMut, Clone)]
 pub struct DirworldLeaveRoom(pub PathBuf);
 
-/// Event called when entering a room
-#[derive(Debug, Event, Deref, DerefMut, Clone)]
-pub struct DirworldEnterRoom(pub PathBuf);
+/// Event called when entering a room, but before loading and spawning entities.
+#[derive(Debug, Event, Clone)]
+pub struct DirworldEnterRoom {
+    /// Room entered
+    pub exited: PathBuf,
+    /// Room exited from
+    pub entered: PathBuf,
+}
 
 /// Event called when changing the world root
 #[derive(Debug, Event, Deref, DerefMut, Clone)]
 pub struct DirworldChangeRoot(pub PathBuf);
 
+/// Event called once navigation between rooms is complete (all entities loaded and spawned).
+#[derive(Debug, Event, Clone)]
+pub struct DirworldNavigationComplete {
+    /// Room entered
+    pub from: PathBuf,
+    /// Room exited
+    pub to: PathBuf,
+}
+
 /// Event called to spawn a dirworld entities
 #[derive(Event, Debug, Deref, DerefMut, Clone, Copy)]
 pub struct DirworldSpawn(pub Entity);

src/lib.rs

@@ -1,4 +1,6 @@
 #![warn(missing_docs)]
+#![allow(clippy::too_many_arguments)]
+#![allow(clippy::type_complexity)]
 
 //! Plugin for bevy engine enabling interaction with and representation of the file system in the world.
 
@@ -6,16 +8,18 @@ use std::{ffi::OsStr, path::PathBuf};
 
 use actor::ActorPlugin;
 use bevy::{ecs::system::IntoObserverSystem, prelude::*};
-use bevy_mod_scripting::core::{AddScriptApiProvider, AddScriptHost, AddScriptHostHandler, ScriptingPlugin};
-use bevy_mod_scripting::lua::LuaScriptHost;
+use bevy_mod_scripting::lua::LuaScriptingPlugin;
 use cache::DirworldCache;
-use events::{DirworldChangeRoot, DirworldEnterRoom, DirworldLeaveRoom, DirworldSpawn};
+use events::{
+    DirworldChangeRoot, DirworldEnterRoom, DirworldLeaveRoom, DirworldNavigationComplete,
+    DirworldSpawn,
+};
 use occule::Codec;
 use preload::{DirworldPreload, DirworldPreloadPlugin};
-use resources::EntryType;
 use resources::{
     DirworldCodecs, DirworldCurrentDir, DirworldObservers, DirworldRootDir, DirworldTasks,
 };
+use resources::{DirworldLastDir, EntryType};
 pub use watcher::DirworldWatcherEvent;
 pub use watcher::DirworldWatcherSet;
 
@@ -69,7 +73,7 @@ impl Plugin for DirworldPlugin {
                 custom_function_registration: Some(yarnspinner_api::setup_yarnspinner_functions),
             },
             DirworldPreloadPlugin,
-            ScriptingPlugin,
+            LuaScriptingPlugin::default(),
         ))
         .add_systems(Startup, watcher::setup)
         .add_systems(
@@ -80,13 +84,11 @@ impl Plugin for DirworldPlugin {
                 yarnspinner_api::process_commands,
             ),
         )
-        .add_script_host::<LuaScriptHost<()>>(PostUpdate)
-        .add_script_handler::<LuaScriptHost<()>, 0, 0>(PostUpdate)
-        .add_api_provider::<LuaScriptHost<()>>(Box::new(lua_api::ConditionalAPI))
         .add_systems(PostUpdate, watcher::update)
         .init_resource::<DirworldRootDir>()
         .init_resource::<DirworldCache>()
         .init_resource::<DirworldCurrentDir>()
+        .init_resource::<DirworldLastDir>()
         .init_resource::<DirworldTasks>()
         .init_resource::<DirworldObservers>()
         .init_resource::<DirworldCodecs>()
@@ -94,6 +96,7 @@ impl Plugin for DirworldPlugin {
         .add_event::<DirworldLeaveRoom>()
         .add_event::<DirworldChangeRoot>()
         .add_event::<DirworldWatcherEvent>()
+        .add_event::<DirworldNavigationComplete>()
         .add_observer(observers::navigate_to_room)
         .add_observer(observers::handle_changes)
         .add_observer(observers::change_root)
@@ -130,7 +133,7 @@ impl Extensions for PathBuf {
 
     fn file_stem_no_extensions(&self) -> Option<String> {
         let mut temp_path = self.clone();
-        while let Some(_) = temp_path.extension() {
+        while temp_path.extension().is_some() {
             temp_path.set_extension("");
         }
         temp_path
@@ -141,7 +144,7 @@ impl Extensions for PathBuf {
 
     fn no_extensions(&self) -> PathBuf {
         let mut temp_path = self.clone();
-        while let Some(_) = temp_path.extension() {
+        while temp_path.extension().is_some() {
             temp_path.set_extension("");
         }
         temp_path

src/lua_api.rs

@@ -1,37 +1,43 @@
-use std::{str::FromStr, sync::Mutex};
+// TODO: remove
+#![allow(dead_code)]
+
+use std::str::FromStr;
 
 use bevy::prelude::*;
-use bevy_mod_scripting::api::providers::bevy_reflect::LuaVec3;
-use bevy_mod_scripting::{api::providers::bevy_ecs::LuaEntity, lua::tealr::mlu::mlua::Error as LuaError};
-use bevy_mod_scripting::lua::LuaEvent;
-use bevy_mod_scripting::prelude::*;
+use bevy_mod_scripting::core::{
+    bindings::function::{
+        from::Val,
+        namespace::{GlobalNamespace, NamespaceBuilder},
+        script_function::FunctionCallContext,
+    },
+    callback_labels,
+    error::InteropError,
+    event::ScriptCallbackEvent,
+};
 use uuid::Uuid;
 
 use crate::{components::DirworldEntity, conditionals::Condition};
 
-pub fn trigger_update(mut w: PriorityEventWriter<LuaEvent<()>>) {
-    let event = LuaEvent::<()> {
-        args: (),
-        hook_name: "on_update".into(),
-        recipients: Recipients::All,
-    };
-    w.send(event, 0);
+callback_labels!(OnUpdate => "on_update");
+
+pub fn trigger_update(mut w: EventWriter<ScriptCallbackEvent>) {
+    w.send(ScriptCallbackEvent::new_for_all(OnUpdate, vec![]));
 }
 
 // ACTUAL API STUFF BELOW THIS POINT {{{
 
 macro_rules! register_fns {
-    ($runtime:expr, $($function:expr),+) => {
+    ($world:expr, $($function:expr),+) => {
         {
-            let ctx = $runtime.get_mut().unwrap();
-            $(ctx.globals().set(stringify!($function).to_string(), ctx.create_function($function).unwrap()).unwrap();)+
+            NamespaceBuilder::<GlobalNamespace>::new_unregistered($world)
+            $(.register(stringify!($function), $function))+;
         }
     };
 }
 
-pub fn register(api: &mut Mutex<Lua>) {
+pub fn register(world: &mut World) {
     register_fns!(
-        api,
+        world,
         translate,
         rotate,
         get_dirworld_id,
@@ -45,65 +51,58 @@ pub fn register(api: &mut Mutex<Lua>) {
     )
 }
 
-fn translate(ctx: &Lua, (entity, translation): (LuaEntity, LuaVec3)) -> Result<(), LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
-    if let Some(mut transform) = world.entity_mut(entity.inner().unwrap()).get_mut::<Transform>() {
-        transform.translation += translation.inner().unwrap();
-    }
-    Ok(())
+fn translate(ctx: FunctionCallContext, entity: Val<Entity>, translation: Val<Vec3>) {
+    let world = ctx.world().unwrap();
+    // TODO: Handle
+    let _ = world.with_global_access(|world| {
+        if let Some(mut transform) = world.entity_mut(*entity).get_mut::<Transform>() {
+            transform.translation += *translation;
+        }
+    });
 }
 
-fn rotate(ctx: &Lua, (entity, axis, angle): (LuaEntity, LuaVec3, f32)) -> Result<(), LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
-    if let Some(mut transform) = world.entity_mut(entity.inner().unwrap()).get_mut::<Transform>() {
-        transform.rotation *= Quat::from_axis_angle(axis.inner().unwrap(), angle);
-    }
-    Ok(())
+fn rotate(ctx: FunctionCallContext, entity: Val<Entity>, axis: Val<Vec3>, angle: f32) {
+    let world = ctx.world().unwrap();
+    let _ = world.with_global_access(|world| {
+        if let Some(mut transform) = world.entity_mut(*entity).get_mut::<Transform>() {
+            transform.rotation *= Quat::from_axis_angle(*axis, angle);
+        }
+    });
 }
 
-fn get_dirworld_id(ctx: &Lua, (entity,): (LuaEntity,)) -> Result<String, LuaError> {
-    let world = ctx.get_world()?;
-    let world = world.read();
-    if let Some(dirworld_entity) = world.entity(entity.inner().unwrap()).get::<DirworldEntity>() {
-        dirworld_entity.payload.as_ref().map(|p| p.id.to_string()).ok_or(LuaError::runtime("Failed to get entity id from payload"))
-    } else {
-        Err(LuaError::runtime("Entity missing DirworldEntity component"))
-    }
+fn get_dirworld_id(ctx: FunctionCallContext, entity: Val<Entity>) -> Result<String, InteropError> {
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = if let Some(dirworld_entity) = world.entity(*entity).get::<DirworldEntity>() {
+            Ok(dirworld_entity
+                .payload
+                .as_ref()
+                .map(|p| p.id.to_string())
+                .unwrap())
+        } else {
+            Err(InteropError::missing_entity(*entity))
+        };
+    });
+    result
 }
 
 // Conditionals
 
-pub struct ConditionalAPI;
-
-impl APIProvider for ConditionalAPI {
-    type APITarget = Mutex<Lua>;
-
-    type ScriptContext = Mutex<Lua>;
-
-    type DocTarget = LuaDocFragment;
-
-    fn attach_api(
-        &mut self,
-        api: &mut Self::APITarget,
-    ) -> Result<(), bevy_mod_scripting::prelude::ScriptError> {
-        register(api);
-        Ok(())
-    }
+fn condition_true(ctx: FunctionCallContext) -> Result<bool, InteropError> {
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::True.evaluate(world));
+    });
+    result
 }
 
-
-
-fn condition_true(ctx: &Lua, _: ()) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
-    Ok(Condition::True.evaluate(&mut world))
-}
-
-fn condition_ancestor_of(ctx: &Lua, (ancestor, descendant): (String, String)) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
+fn condition_ancestor_of(
+    ctx: FunctionCallContext,
+    ancestor: String,
+    descendant: String,
+) -> Result<bool, InteropError> {
     let Ok(ancestor) = Uuid::from_str(&ancestor) else {
         warn!("Provided ancestor is not a valid UUID");
         return Ok(false);
@@ -112,15 +111,23 @@ fn condition_ancestor_of(ctx: &Lua, (ancestor, descendant): (String, String)) ->
         warn!("Provided descendant is not a valid UUID");
         return Ok(false);
     };
-    Ok(Condition::AncestorOf {
-        ancestor,
-        descendant,
-    }.evaluate(&mut world))
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::AncestorOf {
+            ancestor,
+            descendant,
+        }
+        .evaluate(world));
+    });
+    result
 }
 
-fn condition_descendant_of(ctx: &Lua, (descendant, ancestor): (String, String)) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
+fn condition_descendant_of(
+    ctx: FunctionCallContext,
+    descendant: String,
+    ancestor: String,
+) -> Result<bool, InteropError> {
     let Ok(ancestor) = Uuid::from_str(&ancestor) else {
         warn!("Provided ancestor is not a valid UUID");
         return Ok(false);
@@ -129,15 +136,23 @@ fn condition_descendant_of(ctx: &Lua, (descendant, ancestor): (String, String))
         warn!("Provided descendant is not a valid UUID");
         return Ok(false);
     };
-    Ok(Condition::DescendantOf {
-        ancestor,
-        descendant,
-    }.evaluate(&mut world))
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::DescendantOf {
+            ancestor,
+            descendant,
+        }
+        .evaluate(world));
+    });
+    result
 }
 
-fn condition_parent_of(ctx: &Lua, (parent, child): (String, String)) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
+fn condition_parent_of(
+    ctx: FunctionCallContext,
+    parent: String,
+    child: String,
+) -> Result<bool, InteropError> {
     let Ok(parent) = Uuid::from_str(&parent) else {
         warn!("Provided ancestor is not a valid UUID");
         return Ok(false);
@@ -146,15 +161,19 @@ fn condition_parent_of(ctx: &Lua, (parent, child): (String, String)) -> Result<b
         warn!("Provided descendant is not a valid UUID");
         return Ok(false);
     };
-    Ok(Condition::ParentOf {
-        parent,
-        child,
-    }.evaluate(&mut world))
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::ParentOf { parent, child }.evaluate(world));
+    });
+    result
 }
 
-fn condition_child_of(ctx: &Lua, (child, parent): (String, String)) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
+fn condition_child_of(
+    ctx: FunctionCallContext,
+    child: String,
+    parent: String,
+) -> Result<bool, InteropError> {
     let Ok(parent) = Uuid::from_str(&parent) else {
         warn!("Provided ancestor is not a valid UUID");
         return Ok(false);
@@ -163,30 +182,41 @@ fn condition_child_of(ctx: &Lua, (child, parent): (String, String)) -> Result<bo
         warn!("Provided descendant is not a valid UUID");
         return Ok(false);
     };
-    Ok(Condition::ChildOf {
-        parent,
-        child,
-    }.evaluate(&mut world))
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::ChildOf { parent, child }.evaluate(world));
+    });
+    result
 }
 
-fn condition_in_room(ctx: &Lua, (room,): (String,)) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
+fn condition_in_room(ctx: FunctionCallContext, room: String) -> Result<bool, InteropError> {
     let Ok(room) = Uuid::from_str(&room) else {
         warn!("Provided room is not a valid UUID");
         return Ok(false);
     };
-    Ok(Condition::InRoom(room).evaluate(&mut world))
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::InRoom(room).evaluate(world));
+    });
+    result
 }
 
-fn condition_object_in_room(ctx: &Lua, (object,): (String,)) -> Result<bool, LuaError> {
-    let world = ctx.get_world()?;
-    let mut world = world.write();
+fn condition_object_in_room(
+    ctx: FunctionCallContext,
+    object: String,
+) -> Result<bool, InteropError> {
     let Ok(object) = Uuid::from_str(&object) else {
         warn!("Provided object is not a valid UUID");
         return Ok(false);
     };
-    Ok(Condition::ObjectInRoom(object).evaluate(&mut world))
+    let world = ctx.world()?;
+    let mut result = Ok(Default::default());
+    let _ = world.with_global_access(|world| {
+        result = Ok(Condition::ObjectInRoom(object).evaluate(world));
+    });
+    result
 }
 
 // }}}

src/observers.rs

@@ -1,5 +1,6 @@
 use std::ops::Deref;
 
+use avian3d::prelude::{Physics, PhysicsTime};
 use bevy::prelude::*;
 use notify::{
     event::{MetadataKind, ModifyKind, RenameMode},
@@ -7,9 +8,17 @@ use notify::{
 };
 
 use crate::{
-    cache::DirworldCache, components::{DirworldEntity, Persist}, events::{DirworldChangeRoot, DirworldEnterRoom, DirworldLeaveRoom}, preload::{load_entity, PreloadState, RoomAssets}, resources::{
-        DirworldCodecs, DirworldCurrentDir, DirworldObservers, DirworldRootDir,
-    }, utils::{despawn_entity_by_path, extract_entity_payload}, DirworldWatcherEvent
+    cache::DirworldCache,
+    components::{DirworldEntity, Persist},
+    events::{
+        DirworldChangeRoot, DirworldEnterRoom, DirworldLeaveRoom,
+    },
+    preload::{load_entity, reload_entity, DirworldPreloadBegin, PreloadState, ReloadPaths, RoomAssets},
+    resources::{
+        DirworldCodecs, DirworldCurrentDir, DirworldObservers, DirworldRootDir, DirworldTasks,
+    },
+    utils::{despawn_entity_by_path, extract_entity_payload},
+    DirworldWatcherEvent,
 };
 
 /// On navigation from a room, insert modified payloads into the cache
@@ -29,17 +38,26 @@ pub fn navigate_from_room(
 
 pub fn navigate_to_room(
     trigger: Trigger<DirworldEnterRoom>,
+    mut commands: Commands,
+    mut event_writer: EventWriter<DirworldEnterRoom>,
+    mut preload_event_writer: EventWriter<DirworldPreloadBegin>,
     root_dir: Res<DirworldRootDir>,
     mut cache: ResMut<DirworldCache>,
     observers: Res<DirworldObservers>,
     codecs: Res<DirworldCodecs>,
-    mut commands: Commands,
-    mut event_writer: EventWriter<DirworldEnterRoom>,
     mut current_dir: ResMut<DirworldCurrentDir>,
     mut next_preload_state: ResMut<NextState<PreloadState>>,
     mut room_assets: ResMut<RoomAssets>,
+    mut dirworld_tasks: ResMut<DirworldTasks>,
+    mut time: ResMut<Time<Physics>>,
+    persitent_entities: Query<&DirworldEntity, With<Persist>>,
 ) {
-    let path = &trigger.event().0;
+    time.pause();
+    dirworld_tasks.insert("Loading Room".into(), None);
+    let DirworldEnterRoom {
+        exited: old_path,
+        entered: path,
+    } = &trigger.event();
 
     let room_payload = extract_entity_payload(&path.join(".door"), &codecs).0;
     *current_dir = DirworldCurrentDir {
@@ -49,8 +67,7 @@ pub fn navigate_to_room(
     let entries = match path.read_dir() {
         Ok(entries) => entries
             .flatten()
-            .map(|entry| entry.path().canonicalize())
-            .flatten()
+            .flat_map(|entry| entry.path().canonicalize())
             .filter(|entry| {
                 !entry
                     .file_name()
@@ -60,6 +77,7 @@ pub fn navigate_to_room(
                 root_dir
                     .clone()
                     .map(|root_dir| {
+                        info!("Root: {root_dir:?}, Path: {path:?}");
                         if root_dir == *path {
                             None
                         } else {
@@ -84,8 +102,11 @@ pub fn navigate_to_room(
             &mut commands,
             &mut next_preload_state,
             &mut room_assets,
+            &root_dir,
+            &persitent_entities,
         );
     }
+    preload_event_writer.send(DirworldPreloadBegin { old_path: old_path.clone(), path: path.clone() });
     event_writer.send(trigger.event().clone());
 }
 
@@ -95,10 +116,9 @@ pub fn handle_changes(
     dirworld_entities: Query<(Entity, &DirworldEntity)>,
     observers: Res<DirworldObservers>,
     codecs: Res<DirworldCodecs>,
-    mut cache: ResMut<DirworldCache>,
     mut event_writer: EventWriter<DirworldWatcherEvent>,
-    mut next_preload_state: ResMut<NextState<PreloadState>>,
     mut room_assets: ResMut<RoomAssets>,
+    mut reload_paths: ResMut<ReloadPaths>,
 ) {
     let event = &trigger.event().0;
     info!("Watcher Event: {event:?}");
@@ -110,39 +130,36 @@ pub fn handle_changes(
         }
         EventKind::Create(_) | EventKind::Modify(ModifyKind::Name(RenameMode::To)) => {
             for path in &event.paths {
-                load_entity(
-                    &path,
-                    &mut cache,
+                reload_entity(
+                    path,
                     &codecs,
                     &observers,
                     &mut commands,
-                    &mut next_preload_state,
                     &mut room_assets,
+                    &mut reload_paths,
                 );
             }
         }
         EventKind::Modify(ModifyKind::Name(RenameMode::Both)) => {
             despawn_entity_by_path(&mut commands, &dirworld_entities, &event.paths[0]);
-            load_entity(
+            reload_entity(
                 &event.paths[1],
-                &mut cache,
                 &codecs,
                 &observers,
                 &mut commands,
-                &mut next_preload_state,
                 &mut room_assets,
+                &mut reload_paths,
             );
         }
         EventKind::Modify(ModifyKind::Metadata(MetadataKind::Any)) => {
             despawn_entity_by_path(&mut commands, &dirworld_entities, &event.paths[1]);
-            load_entity(
+            reload_entity(
                 &event.paths[0],
-                &mut cache,
                 &codecs,
                 &observers,
                 &mut commands,
-                &mut next_preload_state,
                 &mut room_assets,
+                &mut reload_paths,
             );
         }
         _ => {
@@ -161,9 +178,12 @@ pub fn change_root(
         commands.trigger(DirworldLeaveRoom(old_dir.to_path_buf()));
     };
 
-    let new_root = &trigger.event().0;
+    let new_root = &trigger.event().0.canonicalize().unwrap();
     info!("Changing Root to {}", new_root.display());
     **root_dir = Some(new_root.to_path_buf());
 
-    commands.trigger(DirworldEnterRoom(new_root.to_path_buf()));
+    commands.trigger(DirworldEnterRoom {
+        exited: new_root.to_path_buf(),
+        entered: new_root.to_path_buf(),
+    });
 }

src/payload/components/mod.rs

@@ -9,6 +9,11 @@ use yarnspinner::core::YarnValue;
 #[derive(Serialize, Deserialize, Clone, Default, Deref, DerefMut, Debug)]
 pub struct Transform(pub bevy::prelude::Transform);
 
+/// Transform for the destination of a door
+/// Used to determine where to spawn ".." door and player when entering a room
+#[derive(Serialize, Deserialize, Clone, Default, Deref, DerefMut, Debug)]
+pub struct DoorDestination(pub bevy::prelude::Transform);
+
 /// Payload component that represent's an entity's name
 #[derive(Serialize, Deserialize, Clone, Default, Deref, DerefMut, Debug)]
 pub struct Name(pub String);

src/payload/mod.rs

@@ -27,6 +27,8 @@ pub struct DirworldEntityPayload {
     pub relationships: Option<components::Relationships>,
     /// Pickup information for this entity
     pub pickup: Option<components::Pickup>,
+    /// Door destination
+    pub door_destination: Option<components::DoorDestination>,
 }
 
 impl DirworldEntityPayload {
@@ -38,4 +40,3 @@ impl DirworldEntityPayload {
         }
     }
 }
-

src/preload/events.rs

@@ -1,3 +1,5 @@
+use std::path::PathBuf;
+
 use bevy::prelude::*;
 
 /// Event used to trigger preload callbacks after the asset file has been pre-processed to extract
@@ -10,3 +12,11 @@ pub struct DirworldPreload {
     pub data: Option<Vec<u8>>,
 }
 
+/// Event triggered once preloading begins in a room
+#[derive(Debug, Event, Clone)]
+pub struct DirworldPreloadBegin {
+    /// Path of old room
+    pub old_path: PathBuf,
+    /// Path of loading room
+    pub path: PathBuf,
+}

src/preload/mod.rs

@@ -1,4 +1,6 @@
 use crate::cache::DirworldCache;
+use crate::components::Persist;
+use crate::resources::DirworldRootDir;
 use crate::{
     components::DirworldEntity,
     resources::{DirworldCodecs, DirworldObservers, EntryType},
@@ -6,6 +8,7 @@ use crate::{
     Extensions,
 };
 use bevy::prelude::*;
+use std::path::Path;
 use std::{collections::HashMap, path::PathBuf};
 
 mod systems;
@@ -13,8 +16,9 @@ mod systems;
 mod resources;
 pub use resources::*;
 
-mod events;
-pub use events::DirworldPreload;
+/// Preload-related events
+pub mod events;
+pub use events::*;
 
 pub(crate) struct DirworldPreloadPlugin;
 
@@ -22,9 +26,19 @@ impl Plugin for DirworldPreloadPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
             PostUpdate,
-            systems::handle_preload.run_if(in_state(PreloadState::Loading)),
+            (
+                systems::cache_preload_paths,
+                systems::handle_preload.run_if(in_state(PreloadState::Loading)),
+            ),
         )
-        .add_systems(OnEnter(PreloadState::Done), systems::handle_spawn)
+        .add_systems(OnEnter(PreloadState::Spawning), systems::handle_spawn)
+        .add_systems(Update, systems::handle_reloads.run_if(in_state(PreloadState::Done)))
+        .add_event::<DirworldPreloadBegin>()
+        .init_resource::<ReloadPaths>()
+        .insert_resource(PreloadPaths {
+            src: PathBuf::new(),
+            dst: PathBuf::new(),
+        })
         .init_resource::<RoomAssets>()
         .init_state::<PreloadState>();
     }
@@ -36,11 +50,66 @@ pub enum PreloadState {
     /// Indicates assets are in the process of loading
     #[default]
     Loading,
+    /// Initial Spawning
+    Spawning,
     /// Indicates all room assets are finished loading, i.e. all assets are loaded with
     /// dependencies
     Done,
 }
 
+/// Begins the reload process for an entity
+pub fn reload_entity(
+    entry: &PathBuf,
+    codecs: &DirworldCodecs,
+    observers: &DirworldObservers,
+    commands: &mut Commands,
+    room_assets: &mut RoomAssets,
+    reload_paths: &mut ReloadPaths,
+) {
+    let (payload, data) = extract_entity_payload(entry, codecs);
+    let entry_type = if entry.is_dir() {
+        EntryType::Folder
+    } else {
+        EntryType::File(entry.extensions())
+    };
+    let transform = if entry.file_name().is_none() {
+        payload
+            .as_ref()
+            .map(|payload| {
+                payload
+                    .door_destination
+                    .as_ref()
+                    .expect("Door destination missing from payload!")
+                    .0
+            })
+            .unwrap_or_default()
+    } else {
+        payload
+            .as_ref()
+            .map(|payload| payload.transform.0)
+            .unwrap_or_default()
+    };
+    info!("{transform:?}");
+    let entity = commands
+        .spawn((
+            transform,
+            Visibility::Inherited,
+            DirworldEntity {
+                path: entry.clone(),
+                payload,
+            },
+        ))
+        .id();
+
+    info!("Entity: {entity:?}");
+    if let Some(observer) = observers.get(&entry_type) {
+        reload_paths.push(entry.clone());
+        room_assets.insert(entry.clone(), HashMap::default());
+        commands.trigger_targets(DirworldPreload { entity, data }, *observer);
+        info!("Triggered reload for {entry:?}");
+    }
+}
+
 /// Initiates loading of an asset
 // TODO: Make into a command extension
 pub fn load_entity(
@@ -51,21 +120,45 @@ pub fn load_entity(
     commands: &mut Commands,
     preload_state: &mut NextState<PreloadState>,
     room_assets: &mut RoomAssets,
+    root_dir: &DirworldRootDir,
+    persistent_entities: &Query<&DirworldEntity, With<Persist>>,
 ) {
-    let (mut payload, data) = extract_entity_payload(&entry, &codecs);
-    payload = payload.map(|p| cache.get_entity_cache(&entry).unwrap_or(p));
+    info!("Entity: {entry:?}");
+    if persistent_entities.iter().any(|e| e.path == *entry) {
+        info!("Entity is persistent, skipping...");
+        return;
+    }
+    if Some(entry.canonicalize().unwrap()) == root_dir.0.as_ref().and_then(|d| d.parent().map(Path::to_path_buf)) {
+        info!("Entity is root directory, skipping...");
+        return;
+    }
+    let (mut payload, data) = extract_entity_payload(entry, codecs);
+    payload = payload.map(|p| cache.get_entity_cache(entry).unwrap_or(p));
     let entry_type = if entry.is_dir() {
         EntryType::Folder
     } else {
         EntryType::File(entry.extensions())
     };
-    let transform = payload
-        .as_ref()
-        .map(|payload| payload.transform.clone())
-        .unwrap_or_default();
+    let transform = if entry.file_name().is_none() {
+        payload
+            .as_ref()
+            .map(|payload| {
+                payload
+                    .door_destination
+                    .as_ref()
+                    .expect("Door destination missing from payload!")
+                    .0
+            })
+            .unwrap_or_default()
+    } else {
+        payload
+            .as_ref()
+            .map(|payload| payload.transform.0)
+            .unwrap_or_default()
+    };
     let entity = commands
         .spawn((
-            *transform,
+            transform,
             Visibility::Inherited,
             DirworldEntity {
                 path: entry.clone(),
@@ -76,7 +169,7 @@ pub fn load_entity(
     if let Some(observer) = observers.get(&entry_type) {
         preload_state.set(PreloadState::Loading);
         room_assets.insert(entry.clone(), HashMap::default());
-        commands.trigger_targets(DirworldPreload { entity, data }, observer.clone());
+        commands.trigger_targets(DirworldPreload { entity, data }, *observer);
         info!("Triggered preload for {entry:?}");
     }
 }

src/preload/resources.rs

@@ -5,3 +5,16 @@ use bevy::prelude::*;
 /// A map of asset handles required by each entry in a room, indexed by their paths
 #[derive(Resource, Default, Debug, Deref, DerefMut)]
 pub struct RoomAssets(pub HashMap<PathBuf, HashMap<String, UntypedHandle>>);
+
+/// Paths used while preloading entities
+#[derive(Resource, Clone)]
+pub struct PreloadPaths {
+    /// Path of old room
+    pub src: PathBuf,
+    /// Path of current room
+    pub dst: PathBuf,
+}
+
+/// Paths which are currently in the process of being reloaded
+#[derive(Resource, Deref, DerefMut, Debug, Default)]
+pub struct ReloadPaths(Vec<PathBuf>);

src/preload/systems.rs

@@ -1,13 +1,30 @@
+use avian3d::prelude::{Physics, PhysicsTime};
 use bevy::prelude::*;
 
-use crate::{components::DirworldEntity, events::DirworldSpawn, resources::{DirworldObservers, EntryType}, Extensions};
+use crate::{
+    components::{DirworldEntity, Persist},
+    events::{DirworldNavigationComplete, DirworldSpawn},
+    resources::{DirworldObservers, DirworldTasks, EntryType},
+    Extensions,
+};
 
-use super::{PreloadState, RoomAssets};
+use super::{DirworldPreloadBegin, PreloadPaths, PreloadState, ReloadPaths, RoomAssets};
+
+pub fn cache_preload_paths(
+    mut event_reader: EventReader<DirworldPreloadBegin>,
+    mut paths: ResMut<PreloadPaths>,
+) {
+    for DirworldPreloadBegin { old_path, path } in event_reader.read() {
+        paths.src = old_path.canonicalize().unwrap();
+        paths.dst = path.canonicalize().unwrap();
+    }
+}
 
 pub fn handle_preload(
     asset_server: Res<AssetServer>,
     room_assets: Res<RoomAssets>,
     mut next_state: ResMut<NextState<PreloadState>>,
+    mut dirworld_tasks: ResMut<DirworldTasks>,
 ) {
     if room_assets.is_empty()
         || room_assets
@@ -16,14 +33,19 @@ pub fn handle_preload(
             .all(|a| asset_server.is_loaded_with_dependencies(a))
     {
         info!("Preload Done.");
-        next_state.set(PreloadState::Done);
+        next_state.set(PreloadState::Spawning);
+        dirworld_tasks.remove("Loading Room");
     }
 }
 
 pub fn handle_spawn(
-    dirworld_entity_query: Query<(Entity, &DirworldEntity)>,
+    preload_paths: Res<PreloadPaths>,
+    dirworld_entity_query: Query<(Entity, &DirworldEntity), Without<Persist>>,
     mut commands: Commands,
     observers: Res<DirworldObservers>,
+    mut event_writer: EventWriter<DirworldNavigationComplete>,
+    mut time: ResMut<Time<Physics>>,
+    mut next_state: ResMut<NextState<PreloadState>>,
 ) {
     info!("Spawning");
     for (entity, DirworldEntity { path, .. }) in dirworld_entity_query.iter() {
@@ -34,8 +56,52 @@ pub fn handle_spawn(
         };
         if let Some(observer) = observers.get(&entry_type) {
             info!("Found observer {observer:?} for {entry_type:?}");
-            commands.trigger_targets(DirworldSpawn(entity), observer.clone());
+            commands.trigger_targets(DirworldSpawn(entity), *observer);
         }
     }
+    time.unpause();
+    event_writer.send(DirworldNavigationComplete {
+        from: preload_paths.src.clone(),
+        to: preload_paths.dst.clone(),
+    });
+    next_state.set(PreloadState::Done);
 }
 
+pub fn handle_reloads(
+    room_assets: ResMut<RoomAssets>,
+    mut reload_paths: ResMut<ReloadPaths>,
+    asset_server: Res<AssetServer>,
+    observers: Res<DirworldObservers>,
+    dirworld_entity_query: Query<(Entity, &DirworldEntity), Without<Persist>>,
+    mut commands: Commands,
+) {
+    reload_paths.retain(|reload_path| {
+        let mut result = true;
+        if let Some(assets) = room_assets.get(reload_path) {
+            if assets
+                .values()
+                .all(|asset| asset_server.is_loaded_with_dependencies(asset))
+            {
+                result = false;
+            }
+        } else {
+            result = false;
+        }
+        if !result {
+            let (entity, _) = dirworld_entity_query
+                .iter()
+                .find(|(_, DirworldEntity { path, .. })| path == reload_path)
+                .unwrap();
+            let entry_type = if reload_path.is_dir() {
+                EntryType::Folder
+            } else {
+                EntryType::File(reload_path.extensions())
+            };
+            if let Some(observer) = observers.get(&entry_type) {
+                info!("RELOAD: Found observer {observer:?} for {entry_type:?}");
+                commands.trigger_targets(DirworldSpawn(entity), *observer);
+            }
+        }
+        result
+    });
+}

src/resources.rs

@@ -12,16 +12,20 @@ pub struct DirworldRootDir(pub Option<PathBuf>);
 
 /// Current directory of the world
 #[derive(Resource, Default)]
-pub struct DirworldCurrentDir{ 
+pub struct DirworldCurrentDir {
     /// Path of current directory
     pub path: PathBuf,
     /// Payload (contents of .door file) in current directory, if present
     pub payload: Option<DirworldEntityPayload>,
 }
 
+/// Last room player was in
+#[derive(Resource, Deref, DerefMut, Default, Debug)]
+pub struct DirworldLastDir(pub PathBuf);
+
 /// Running background tasks
 #[derive(Default, Resource, Deref, DerefMut)]
-pub struct DirworldTasks(pub BTreeMap<String, Task<Option<CommandQueue>>>);
+pub struct DirworldTasks(pub BTreeMap<String, Option<Task<Option<CommandQueue>>>>);
 
 /// A map between file types and their corresponding preload/spawn callback observers
 #[derive(Debug, Default, Resource, Deref, DerefMut)]
@@ -39,4 +43,3 @@ pub enum EntryType {
     /// A folder
     Folder,
 }
-

src/systems.rs

@@ -6,25 +6,15 @@ use bevy::{
 use crate::resources::DirworldTasks;
 
 pub fn remove_completed_tasks(mut commands: Commands, mut tasks: ResMut<DirworldTasks>) {
-    tasks.retain(|_, task| {
-        if task.is_finished() {
-            if let Some(Some(mut command_queue)) = block_on(future::poll_once(&mut *task)) {
-                commands.append(&mut command_queue);
+    tasks.retain(|_, task| match task {
+        Some(task) => {
+            if task.is_finished() {
+                if let Some(Some(mut command_queue)) = block_on(future::poll_once(&mut *task)) {
+                    commands.append(&mut command_queue);
+                }
             }
+            !task.is_finished()
         }
-        !task.is_finished()
+        None => true,
     });
 }
-
-// pub fn sync_entity_transforms(
-//     mut dirworld_entity_query: Query<(&mut DirworldEntity, Ref<Transform>, &GlobalTransform)>,
-// ) {
-//     for (mut dirworld_entity, transform, global_transform) in dirworld_entity_query.iter_mut() {
-//         if transform.is_changed() && !transform.is_added() {
-//             if let Some(payload) = &mut dirworld_entity.payload {
-//                 let transform = global_transform.compute_transform();
-//                 *payload.transform = transform;
-//             }
-//         }
-//     }
-// }

src/utils.rs

@@ -3,7 +3,8 @@ use std::{fs, path::PathBuf};
 use bevy::prelude::*;
 
 use crate::{
-    components::DirworldEntity, payload::DirworldEntityPayload, resources::DirworldCodecs, Extensions
+    components::DirworldEntity, payload::DirworldEntityPayload, resources::DirworldCodecs,
+    Extensions,
 };
 
 /// Extracts the binary payload from a file
@@ -15,7 +16,14 @@ pub fn extract_entity_payload(
     let mut payload = None;
 
     if path.is_dir() {
-        let payload_file_path = path.join(".door");
+        let payload_file_path = if path.file_name().is_none() {
+            path.parent()
+                .expect(".. missing parent somehow")
+                .join(".door")
+        } else {
+            path.join(".door")
+        };
+        info!("{payload_file_path:?}");
         if payload_file_path.exists() {
             if let Ok(payload_file_data) = fs::read(&payload_file_path) {
                 match rmp_serde::from_slice::<DirworldEntityPayload>(&payload_file_data) {
@@ -28,34 +36,31 @@ pub fn extract_entity_payload(
                 }
             }
         }
-    } else {
-        if let Some(extensions) = path.extensions() {
-            if let Ok(file_data) = fs::read(&path) {
-                if let Some(codec) = codecs.get(&extensions) {
-                    match codec.decode(&file_data) {
-                        Ok((carrier, extracted_payload)) => {
-                            match rmp_serde::from_slice::<DirworldEntityPayload>(&extracted_payload)
-                            {
-                                Ok(deserialized_payload) => {
-                                    data = Some(carrier);
-                                    payload = Some(deserialized_payload);
-                                }
-                                Err(e) => {
-                                    warn!("Could not deserialize extracted payload: {e:?}");
-                                    data = Some(file_data);
-                                }
+    } else if let Some(extensions) = path.extensions() {
+        if let Ok(file_data) = fs::read(path) {
+            if let Some(codec) = codecs.get(&extensions) {
+                match codec.decode(&file_data) {
+                    Ok((carrier, extracted_payload)) => {
+                        match rmp_serde::from_slice::<DirworldEntityPayload>(&extracted_payload) {
+                            Ok(deserialized_payload) => {
+                                data = Some(carrier);
+                                payload = Some(deserialized_payload);
                             }
-                        }
-                        Err(e) => match e {
-                            occule::Error::DataNotEncoded => {
+                            Err(e) => {
+                                warn!("Could not deserialize extracted payload: {e:?}");
                                 data = Some(file_data);
                             }
-                            _ => error!("Could not decode payload: {e:?}"),
-                        },
+                        }
                     }
-                } else {
-                    data = Some(file_data);
+                    Err(e) => match e {
+                        occule::Error::DataNotEncoded => {
+                            data = Some(file_data);
+                        }
+                        _ => error!("Could not decode payload: {e:?}"),
+                    },
                 }
+            } else {
+                data = Some(file_data);
             }
         }
     }

src/watcher.rs

@@ -1,7 +1,4 @@
-use std::{
-    path::PathBuf,
-    time::Duration,
-};
+use std::{path::PathBuf, time::Duration};
 
 use async_channel::{Receiver, Sender};
 use bevy::{prelude::*, tasks::IoTaskPool};

src/yarnspinner_api.rs

@@ -1,8 +1,6 @@
 use bevy::{log::info, prelude::World};
 use lazy_static::lazy_static;
-use std::sync::{
-    Arc, Condvar, Mutex,
-};
+use std::sync::{Arc, Condvar, Mutex};
 
 use crate::{actor::resources::FunctionLibrary, conditionals::Condition};
 
@@ -28,7 +26,7 @@ pub fn setup_yarnspinner_functions(library: &mut FunctionLibrary) {
 
 pub fn process_commands(world: &mut World) {
     let command_count = YARNSPINNER_COMMAND_COUNT.1.lock().unwrap();
-    if *command_count <= 0 { 
+    if *command_count == 0 {
         return;
     }
 
@@ -41,7 +39,7 @@ pub fn process_commands(world: &mut World) {
     }
 
     let mut command_count = YARNSPINNER_COMMAND_COUNT.1.lock().unwrap();
-    while !*command_count <= 0 {
+    while !*command_count == 0 {
         info!("Command Count: {}", *command_count);
         command_count = YARNSPINNER_COMMAND_COUNT.0.wait(command_count).unwrap();
     }