directory-aware navigation

4 files changed, 70 insertions, 11 deletions

diff --git a/src/preload/events.rs b/src/preload/events.rs
index 7167d73..a6f9d16 100644
--- a/src/preload/events.rs
+++ b/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,8 @@ pub struct DirworldPreload {
     pub data: Option<Vec<u8>>,
 }
 
+#[derive(Debug, Event, Clone)]
+pub struct DirworldPreloadBegin {
+    pub old_path: PathBuf,
+    pub path: PathBuf,
+}
diff --git a/src/preload/mod.rs b/src/preload/mod.rs
index b90db38..266cb37 100644
--- a/src/preload/mod.rs
+++ b/src/preload/mod.rs
@@ -13,8 +13,8 @@ mod systems;
 mod resources;
 pub use resources::*;
 
-mod events;
-pub use events::DirworldPreload;
+pub mod events;
+pub use events::*;
 
 pub(crate) struct DirworldPreloadPlugin;
 
@@ -22,9 +22,17 @@ 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_event::<DirworldPreloadBegin>()
+        .insert_resource(PreloadPaths {
+            src: PathBuf::new(),
+            dst: PathBuf::new(),
+        })
         .init_resource::<RoomAssets>()
         .init_state::<PreloadState>();
     }
@@ -52,6 +60,7 @@ pub fn load_entity(
     preload_state: &mut NextState<PreloadState>,
     room_assets: &mut RoomAssets,
 ) {
+    info!("Entity: {entry:?}");
     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() {
@@ -59,13 +68,26 @@ pub fn load_entity(
     } 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(),
diff --git a/src/preload/resources.rs b/src/preload/resources.rs
index 4060c10..9cfec70 100644
--- a/src/preload/resources.rs
+++ b/src/preload/resources.rs
@@ -5,3 +5,9 @@ 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>>);
+
+#[derive(Resource, Clone)]
+pub struct PreloadPaths {
+    pub src: PathBuf,
+    pub dst: PathBuf,
+}
diff --git a/src/preload/systems.rs b/src/preload/systems.rs
index ec867ae..330c897 100644
--- a/src/preload/systems.rs
+++ b/src/preload/systems.rs
@@ -1,13 +1,31 @@
 use bevy::prelude::*;
 
-use crate::{components::DirworldEntity, events::DirworldSpawn, resources::{DirworldObservers, EntryType}, Extensions};
+use crate::{
+    components::DirworldEntity,
+    events::{DirworldNavigationComplete, DirworldSpawn},
+    resources::{DirworldObservers, DirworldTasks, EntryType},
+    Extensions,
+};
 
-use super::{PreloadState, RoomAssets};
+use super::{
+    DirworldPreloadBegin, PreloadPaths, PreloadState, 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
@@ -17,13 +35,16 @@ pub fn handle_preload(
     {
         info!("Preload Done.");
         next_state.set(PreloadState::Done);
+        dirworld_tasks.remove("Loading Room");
     }
 }
 
 pub fn handle_spawn(
+    preload_paths: Res<PreloadPaths>,
     dirworld_entity_query: Query<(Entity, &DirworldEntity)>,
     mut commands: Commands,
     observers: Res<DirworldObservers>,
+    mut event_writer: EventWriter<DirworldNavigationComplete>,
 ) {
     info!("Spawning");
     for (entity, DirworldEntity { path, .. }) in dirworld_entity_query.iter() {
@@ -37,5 +58,8 @@ pub fn handle_spawn(
             commands.trigger_targets(DirworldSpawn(entity), observer.clone());
         }
     }
+    event_writer.send(DirworldNavigationComplete {
+        from: preload_paths.src.clone(),
+        to: preload_paths.dst.clone(),
+    });
 }
-