assets/editor/entities/camera.entity

@@ -1,5 +1,6 @@
+uuid 739619d7-b8a1-42b4-8803-2b8cfedeebf1
 name "Editor Camera"
-editorTag
+editor_tag
-camera target window "window.entity"
+camera render_target window b90f31a2-34d9-42c2-9e53-646d9c9c6c70
-flyCamera
+fly_camera
-transform translation 10.0 10.0 10.0 rotation 0.0 0.0 0.0 1.0 scale 1.0 1.0 1.0
+transform transform 10.0 10.0 10.0

assets/editor/entities/ui_container.entity

@@ -1,3 +1,4 @@
-editorTag
+uuid 08e1a4d9-6c76-471d-af02-1aa7db1b435a
-uiNode
+editor_tag
-targetCamera "camera.entity"
+ui_node
+target_camera 739619d7-b8a1-42b4-8803-2b8cfedeebf1

assets/editor/entities/ui_title.entity

@@ -1,3 +1,4 @@
-editorTag
+uuid 0088bc7d-851e-402b-9d20-fadfe5cab106
-uiText "Welcome to the editor" color #ffffff size 12.0
+editor_tag
-parent "ui_container.entity"
+ui_text text "Welcome to the editor" color 1.0 1.0 1.0 1.0
+parent 08e1a4d9-6c76-471d-af02-1aa7db1b435a

assets/editor/entities/window.entity

@@ -1,3 +1,4 @@
-editorTag
+uuid b90f31a2-34d9-42c2-9e53-646d9c9c6c70
+editor_tag
 name "Editor Window"
-window "Editor" visible false
+window title "Editor" visible false

assets/levels/00/entities/camera.entity

@@ -1,3 +1,4 @@
 name camera
+uuid 2e45b7e9-6722-4d50-8ea5-67f25b8b0f62
 transform translation 2.0 2.0 0.0 rotation 0.0 0.0 0.0 1.0 scale 1.0 1.0 1.0
 camera

assets/levels/00/entities/van.entity

@@ -1,3 +1,4 @@
 name van
+uuid 5c270e84-814c-4d51-9ccd-ab79d9e01f1d
 transform translation 0.0 0.0 0.0 rotation 0.0 0.0 0.0 1.0 scale 1.0 1.0 1.0
 model "models/van.glb" "Scene"

obrc/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "obrc"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

obrc/src/main.rs

@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}

src/editor.rs

@@ -53,9 +53,8 @@ impl std::convert::From<&EditorState> for bool {
 }
 
 /// Tag component for editor entities
-#[derive(Component, Reflect, Debug, Default)]
+#[derive(Component)]
-#[reflect(Component, Default)]
+struct EditorTag;
-pub(crate) struct EditorTag;
 
 fn toggle_editor_state(
     curr_state: Res<State<EditorState>>,
@@ -74,11 +73,15 @@ fn toggle_editor_state(
     }
 }
 
-fn spawn_editor(mut _commands: Commands) {
+fn spawn_editor(
+    mut _commands: Commands,
+) {
     todo!("Spawn editor");
 }
 
-fn despawn_editor(mut _comands: Commands) {
+fn despawn_editor(
+    mut _comands: Commands,
+) {
     todo!("Despawn editor");
 }
 

src/parser.rs

@@ -1,7 +1,11 @@
+use nom::character::complete::hex_digit1;
+
 use crate::prelude::*;
 
 #[derive(Error, Debug)]
 pub(crate) enum SaveEntityParseError {
+    #[error("Failed to parse Uuid: {0}")]
+    Uuid(#[from] uuid::Error),
     #[error("Failed to parse name")]
     Name,
     #[error("Failed to parse Transform")]
@@ -10,6 +14,8 @@ pub(crate) enum SaveEntityParseError {
     Nom(nom::Err<nom::error::Error<Box<str>>>),
     #[error("Failed to parse camera")]
     Camera,
+    #[error("Failed to parse marker component")]
+    Marker,
 }
 
 // Convert Nom error to parse error
@@ -43,9 +49,8 @@ fn parse_string(i: &str) -> IResult<&str, &str> {
 }
 
 ///
-/// Returns reflected `Transform`
 ///
-pub(crate) fn parse_save_transform(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_transform(line: &str) -> Result<Transform, SaveEntityParseError> {
     let (rem, _) = tag("transform")(line)?;
 
     let mut transform = Transform::default();
@@ -75,7 +80,7 @@ pub(crate) fn parse_save_transform(line: &str) -> Result<Box<dyn Reflect>, SaveE
     // Assert there are no trailing characters on the line
     debug_assert_eq!(curr, "");
 
-    Ok(transform.clone_value())
+    Ok(transform)
 }
 
 #[test]
@@ -88,23 +93,19 @@ fn test_parse_transform() {
         scale: Vec3::new(1.1, 1.2, 1.3),
     };
 
-    assert!(expected
+    assert_eq!(parsed, expected);
-        .clone_value()
-        .reflect_partial_eq(parsed.as_reflect())
-        .unwrap());
 }
 
 ///
-/// Returns a reflected `Name`
 ///
-pub(crate) fn parse_save_name(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_name(line: &str) -> Result<Name, SaveEntityParseError> {
     let (remainder, _) = tag("name")(line)?;
     let n = remainder.trim().to_string();
     if n.is_empty() {
         Err(SaveEntityParseError::Name)
     } else {
         let name = Name::new(n);
-        Ok(name.clone_value())
+        Ok(name)
     }
 }
 
@@ -115,104 +116,87 @@ fn test_parse_name() {
         let parsed = parse_save_name(line).unwrap();
         let expected = Name::new("Van");
 
-        assert!(expected
+        assert_eq!(parsed, expected);
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
     }
     {
         let line = "name Big Mike";
         let parsed = parse_save_name(line).unwrap();
         let expected = Name::new("Big Mike");
 
-        assert!(expected
+        assert_eq!(parsed, expected);
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
     }
 }
 
-#[derive(Debug, Default, Reflect, PartialEq)]
+#[derive(Component, Clone, Debug, Reflect, PartialEq)]
-#[reflect(Component, PartialEq)]
+#[reflect(Component)]
-pub(crate) struct SaveModel {
+pub(crate) struct EntityUuid {
-    gltf_file: PathBuf,
+    id: String,
-    scene_name: String,
 }
 
-impl Component for SaveModel {
+///
-    const STORAGE_TYPE: StorageType = StorageType::Table;
+///
+pub(crate) fn parse_save_uuid(line: &str) -> Result<EntityUuid, SaveEntityParseError> {
+    let (remainder, _) = tag("uuid")(line)?;
+    let id = remainder.trim().into();
+    Ok(EntityUuid { id })
+}
 
-    fn register_component_hooks(hooks: &mut ComponentHooks) {
+#[test]
-        todo!("Assign Scene Handle for SaveModel")
+fn test_parse_uuid() {
-    }
+    let line = "uuid 1c16ab9a-5f79-4340-8469-4086f69c64f2";
+    let parsed = parse_save_uuid(line).unwrap();
+    let expected = EntityUuid {
+        id: "1c16ab9a-5f79-4340-8469-4086f69c64f2".into(),
+    };
+
+    assert_eq!(parsed, expected);
 }
 
 ///
-/// Returns a reflected `SaveModel`
 ///
-pub(crate) fn parse_save_model(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+pub(crate) fn parse_save_model(line: &str) -> Result<(String, String), SaveEntityParseError> {
     let (rem, (_, _, gltf_path, _, scene_name)) =
         tuple((tag("model"), space1, parse_string, space1, parse_string))(line)?;
 
     debug_assert!(rem == "");
 
-    Ok(SaveModel {
+    Ok((gltf_path.into(), scene_name.into()))
-        gltf_file: gltf_path.into(),
-        scene_name: scene_name.into(),
-    }
-    .clone_value())
 }
 
 #[test]
 fn test_parse_model() {
     let line = "model \"models/foo.glb\" \"My Scene\"";
     let parsed = parse_save_model(line).unwrap();
-    let expected = SaveModel {
+    let expected = (String::from("models/foo.glb"), String::from("My Scene"));
-        gltf_file: "models/foo.glb".into(),
-        scene_name: "My Scene".into(),
-    };
 
-    assert!(expected
+    assert_eq!(parsed, expected);
-        .clone_value()
-        .reflect_partial_eq(parsed.as_reflect())
-        .unwrap());
 }
 
-#[derive(Debug, Default, PartialEq, Reflect, Clone)]
+#[derive(Component, Debug, Default, PartialEq, Reflect, Clone)]
-#[reflect_value(Component, Default, PartialEq)]
+#[reflect_value(Component, Default)]
 pub(crate) enum SaveCameraRenderTarget {
     #[default]
     Default,
-    Window(PathBuf),
+    Window(Uuid),
 }
 
-impl Component for SaveCameraRenderTarget {
+pub(crate) fn parse_save_camera(
-    const STORAGE_TYPE: StorageType = StorageType::Table;
+    line: &str,
-
+) -> Result<SaveCameraRenderTarget, SaveEntityParseError> {
-    fn register_component_hooks(hooks: &mut ComponentHooks) {
-        todo!("Assign Render Target")
-    }
-}
-
-///
-/// Returns a reflected `SaveCameraRenderTarget
-///
-pub(crate) fn parse_save_camera(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
     if let Ok((rem, _camera)) = tag::<&str, &str, ()>("camera")(line) {
         if let Ok((rem, (_, _target))) = tuple((space1::<&str, ()>, tag("target")))(rem) {
             if let Ok((rem, (_, _window))) = tuple((space1::<&str, ()>, tag("window")))(rem) {
                 // Camera + target + window + UUID
-                if let Ok((rem, (_, path))) =
+                if let Ok((rem, (_, uuid))) = tuple((space1::<&str, ()>, take(36usize)))(rem) {
-                    tuple((space1::<&str, nom::error::Error<&str>>, parse_string))(rem)
-                {
                     debug_assert!(rem == "");
 
-                    Ok(SaveCameraRenderTarget::Window(path.into()).clone_value())
+                    let parsed_uuid = Uuid::parse_str(uuid)?;
+                    Ok(SaveCameraRenderTarget::Window(parsed_uuid))
                 // Camera + target + widow
                 } else {
                     debug_assert!(rem == "");
 
-                    Ok(SaveCameraRenderTarget::Default.clone_value())
+                    Ok(SaveCameraRenderTarget::Default)
                 }
             // camera + target
             } else {
@@ -224,7 +208,7 @@ pub(crate) fn parse_save_camera(line: &str) -> Result<Box<dyn Reflect>, SaveEnti
         } else {
             debug_assert!(rem == "");
 
-            Ok(SaveCameraRenderTarget::Default.clone_value())
+            Ok(SaveCameraRenderTarget::Default)
         }
     // Nothing parsed well
     } else {
@@ -238,19 +222,13 @@ fn test_parse_camera() {
         let line = "camera";
         let parsed = parse_save_camera(line).unwrap();
         let expected = SaveCameraRenderTarget::Default;
-        assert!(expected
+        assert_eq!(parsed, expected);
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
     }
     {
         let line = "camera target window";
         let parsed = parse_save_camera(line).unwrap();
         let expected = SaveCameraRenderTarget::Default;
-        assert!(expected
+        assert_eq!(parsed, expected);
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
     }
     {
         let line = "camera target";
@@ -258,13 +236,11 @@ fn test_parse_camera() {
         assert!(parsed.is_err());
     }
     {
-        let line = "camera target window \"some.entity\"";
+        let line = "camera target window 9a1367e0-71e5-4c79-b4ad-02aa44b68af0";
+        let target_uuid = Uuid::parse_str("9a1367e0-71e5-4c79-b4ad-02aa44b68af0").unwrap();
         let parsed = parse_save_camera(line).unwrap();
-        let expected = SaveCameraRenderTarget::Window("some.entity".into());
+        let expected = SaveCameraRenderTarget::Window(target_uuid);
-        assert!(expected
+        assert_eq!(parsed, expected);
-            .clone_value()
-            .reflect_partial_eq(parsed.as_reflect())
-            .unwrap());
     }
     {
         let line = "notcamera";
@@ -275,32 +251,20 @@ fn test_parse_camera() {
 
 /// SaveParent entity which is a reference to which entity this is a child of
 /// A run-time system converts this to a bevy Parent component
-#[derive(PartialEq, Debug, Reflect, Clone)]
+#[derive(Component, PartialEq, Debug, Reflect, Clone)]
-#[reflect_value(Component, PartialEq)]
+#[reflect_value(Component)]
 pub(crate) struct SaveParent(String);
 
-impl Component for SaveParent {
-    const STORAGE_TYPE: StorageType = StorageType::Table;
-
-    fn register_component_hooks(hooks: &mut ComponentHooks) {
-        todo!("Assign parent for entity")
-    }
-}
-
-///
 /// Parses a parent entity with this format:
 /// ```text
 /// parent some_other_file.entity
 /// ```
-///
+pub(crate) fn parse_save_parent(line: &str) -> Result<SaveParent, SaveEntityParseError> {
-/// Returns a reflected `SaveParent`
-///
-pub(crate) fn parse_save_parent(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
     let (rem, (_, _, parent_file)) = tuple((tag("parent"), space1, parse_string))(line)?;
 
     debug_assert!(rem.is_empty());
 
-    Ok(SaveParent(parent_file.into()).clone_value())
+    Ok(SaveParent(parent_file.into()))
 }
 
 #[test]
@@ -308,19 +272,14 @@ fn test_parse_parent() {
     let line = "parent \"some_other_file.entity\"";
     let parsed = parse_save_parent(line).unwrap();
     let expected = SaveParent("some_other_file.entity".into());
-    assert!(expected
+    assert_eq!(parsed, expected);
-        .clone_value()
-        .reflect_partial_eq(parsed.as_reflect())
-        .unwrap());
 }
 
 ///
 /// Parse the Window component (which is very big!)
 /// We only sparsely define the bits that we want to edit (for now)
 ///
-/// Returns a reflected `Window`
+pub(crate) fn parse_save_window(line: &str) -> Result<Window, SaveEntityParseError> {
-///
-pub(crate) fn parse_save_window(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
     let (rem, (_, _, window_title)) = tuple((tag("window"), space1, parse_string))(line)?;
 
     let (rem, (_, _, _, visibility)) = tuple((space1, tag("visible"), space1, parse_bool))(rem)?;
@@ -331,8 +290,7 @@ pub(crate) fn parse_save_window(line: &str) -> Result<Box<dyn Reflect>, SaveEnti
         title: window_title.into(),
         visible: visibility,
         ..default()
-    }
+    })
-    .clone_value())
 }
 
 #[test]
@@ -344,22 +302,17 @@ fn test_parse_window() {
         title: "Editor".into(),
         ..default()
     };
-    assert!(expected
+    assert_eq!(parsed.visible, expected.visible);
-        .clone_value()
+    assert_eq!(parsed.title, expected.title);
-        .reflect_partial_eq(parsed.as_reflect())
-        .unwrap());
 }
 
 ///
 /// The UI Text bundle specified as a sparse subset of a bundle
 /// ```text
-/// uiText "This is the text" color #abc123 size 12.34
+/// text "This is the text" color #abc123 size 12.34
 /// ```
-///
+pub(crate) fn parse_save_ui_text(line: &str) -> Result<TextBundle, SaveEntityParseError> {
-/// Returns a reflected `Text`
+    let (rem, (_tag_text, _space1, text)) = tuple((tag("text"), space1, parse_string))(line)?;
-///
-pub(crate) fn parse_save_ui_text(line: &str) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
-    let (rem, (_tag_text, _space1, text)) = tuple((tag("uiText"), space1, parse_string))(line)?;
 
     let (rem, (_space, _tag_color, _space1, _hash, hex_color)) =
         tuple((space1, tag("color"), space1, char('#'), hex_digit1))(rem)?;
@@ -374,12 +327,15 @@ pub(crate) fn parse_save_ui_text(line: &str) -> Result<Box<dyn Reflect>, SaveEnt
         font_size,
         ..default()
     };
-    Ok(Text::from_section(text, style).clone_value())
+    Ok(TextBundle {
+        text: Text::from_section(text, style),
+        ..default()
+    })
 }
 
 #[test]
 fn test_save_ui_text() {
-    let line = "uiText \"This is the text\" color #caffee size 14.6";
+    let line = "text \"This is the text\" color #caffee size 14.6";
     let parsed = parse_save_ui_text(line).unwrap();
     let expected = Text::from_section(
         "This is the text",
@@ -389,22 +345,24 @@ fn test_save_ui_text() {
             ..default()
         },
     );
-    assert!(expected
+    assert_eq!(parsed.text.sections[0].value, expected.sections[0].value);
-        .clone_value()
+    assert_eq!(
-        .reflect_partial_eq(parsed.as_reflect())
+        parsed.text.sections[0].style.color,
-        .unwrap());
+        expected.sections[0].style.color,
+    );
+    assert_eq!(
+        parsed.text.sections[0].style.font_size,
+        expected.sections[0].style.font_size,
+    );
 }
 
 ///
 /// Returns a parser function for a basic stand-alone tag
 /// e.g., "editor_tag" or "ui_node"
-///
 pub(crate) fn parse_save_tag<T: Component + Reflect + Default>(
     t: &str,
-) -> impl FnOnce(&str) -> Result<Box<dyn Reflect>, SaveEntityParseError> + '_ {
+) -> impl FnOnce(&str) -> Result<T, SaveEntityParseError> + '_ {
-    move |line: &str| -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+    move |line: &str| -> Result<T, SaveEntityParseError> { Ok(tag(t)(line).map(|_| T::default())?) }
-        Ok(tag(t)(line).map(|_| T::default().clone_value())?)
-    }
 }
 
 #[derive(Component, Reflect, PartialEq, Debug, Default)]
@@ -416,37 +374,24 @@ fn test_save_tag() {
     let line = "testing";
     let parsed = parse_save_tag::<TestingTag>("testing")(line).unwrap();
     let expected = TestingTag;
-    assert!(expected
+    assert_eq!(parsed, expected);
-        .clone_value()
-        .reflect_partial_eq(parsed.as_reflect())
-        .unwrap());
 }
 
-#[derive(Clone, Debug, Reflect, PartialEq)]
+#[derive(Component, Clone, Debug, Reflect, PartialEq)]
 #[reflect(Component)]
 pub(crate) struct SaveTargetCamera(String);
 
-impl Component for SaveTargetCamera {
-    const STORAGE_TYPE: StorageType = StorageType::Table;
-
-    fn register_component_hooks(hooks: &mut ComponentHooks) {
-        todo!("Assign target camera")
-    }
-}
-
 /// Parses the a SaveTargetCamera which at runtime is converted to a TargetCamera
 /// ```text
-/// targetCamera "./level-camera.entity"
+/// target-camera "./level-camera.entity"
 /// ```
-///
-/// Returns reflected `SaveTargetCamera`
 pub(crate) fn parse_save_target_camera(
     line: &str,
-) -> Result<Box<dyn Reflect>, SaveEntityParseError> {
+) -> Result<SaveTargetCamera, SaveEntityParseError> {
     Ok(
-        tuple((tag("targetCamera"), space1, parse_string))(line).map(
+        tuple((tag("target-camera"), space1, parse_string))(line).map(
             |(_, (_, _, target_camera_entity_file))| {
-                SaveTargetCamera(target_camera_entity_file.into()).clone_value()
+                SaveTargetCamera(target_camera_entity_file.into())
             },
         )?,
     )
@@ -454,12 +399,8 @@ pub(crate) fn parse_save_target_camera(
 
 #[test]
 fn test_target_camera() {
-    let line = "targetCamera \"./level-camera.entity\"";
+    let line = "target-camera \"./level-camera.entity\"";
     let parsed = parse_save_target_camera(line).unwrap();
     let expected = SaveTargetCamera("./level-camera.entity".into());
-
+    assert_eq!(parsed, expected);
-    assert!(expected
-        .clone_value()
-        .reflect_partial_eq(parsed.as_reflect())
-        .unwrap());
 }

src/prelude.rs

@@ -9,18 +9,16 @@ pub(crate) use bevy::{
     render::camera::RenderTarget,
     window::{PrimaryWindow, WindowCloseRequested, WindowRef},
 };
-pub(crate) use nom::character::complete::hex_digit1;
+pub(crate) use nom::bytes::complete::take;
 pub(crate) use nom::{
-    branch::alt,
+    branch::{alt, permutation},
     bytes::complete::{tag, take_until1},
-    character::complete::{char, space1},
+    character::complete::{char, hex_digit1, space1},
     number::complete::float,
     sequence::tuple,
     IResult,
 };
-pub(crate) use std::path::PathBuf;
 pub(crate) use thiserror::Error;
+pub(crate) use uuid::Uuid;
 
 pub(crate) use crate::{conditions::*, parser::*};
-
-pub(crate) use bevy::ecs::component::{ComponentHooks, StorageType};

src/save.rs

@@ -5,9 +5,10 @@ pub(crate) struct SavePlugin;
 
 impl Plugin for SavePlugin {
     fn build(&self, app: &mut App) {
-        app.register_type::<SaveCameraRenderTarget>()
+        app
+            .register_type::<EntityUuid>()
+            .register_type::<SaveCameraRenderTarget>()
             .register_type::<GltfScene>()
-            .register_type::<SaveModel>()
             .init_asset::<SaveEntity>()
             .init_asset_loader::<SaveEntityLoader>()
             .init_asset_loader::<SaveSceneLoader>()
@@ -36,40 +37,31 @@ impl SaveEntity {
     ) -> Result<SaveEntity, SaveEntityParseError> {
         let lines = text.split('\n');
         let mut entity = SaveEntity { ..default() };
-        let fns = [
+        lines.into_iter().for_each(|line| {
-            parse_save_name,
+
-            parse_save_transform,
+            if let Ok(name) = parse_save_name(line) {
-            parse_save_model,
+                entity.components.push(name.clone_value());
-            parse_save_camera,
+            } else if let Ok(transform) = parse_save_transform(line) {
-            parse_save_parent,
+                entity.components.push(transform.clone_value());
-            parse_save_window,
+            } else if let Ok(uuid) = parse_save_uuid(line) {
-            parse_save_target_camera,
+                entity.components.push(uuid.clone_value());
-            parse_save_ui_text,
+            } else if let Ok((gltf_file, scene_name)) = parse_save_model(line) {
-            // parse_save_tag::<EditorTag>("editor_tag"),
+                let gltf_scene = GltfScene { gltf: load_context.load(gltf_file), name: scene_name };
-        ];
+                entity.components.push(gltf_scene.clone_value());
-        lines
+            } else if let Ok(target) = parse_save_camera(line) {
-            .into_iter()
+                entity.components.push(target.clone_value());
-            .filter(|line| !line.is_empty())
+            } else if let Ok(parent) = parse_save_parent(line) {
-            .for_each(|line| {
+                entity.components.push(parent.clone_value());
-                // track if this line matched any components
+            } else if let Ok(window) = parse_save_window(line) {
-                let mut good = false;
+                entity.components.push(window.clone_value());
-
+            // } else if let Ok(ui_text_bundle) = parse_save_ui_text(line) {
-                // Run line against all parsers
+            //     entity.components.push(ui_text_bundle.clone_value());
-                for f in fns {
+            } else if let Ok(target_camera) = parse_save_target_camera(line) {
-                    if let Ok(v) = f(line) {
+                entity.components.push(target_camera.clone_value());
-                        entity.components.push(v);
+            } else {
-                        good = true;
+                error!("Failed to parse line component `{:?}`", line);
-                    }
+            }
-                }
+        });
-
-                if !good {
-                    error!(
-                        file = load_context.path().to_str().unwrap(),
-                        line = line,
-                        "failed to parse component",
-                    );
-                }
-            });
         Ok(entity)
     }
 }
@@ -137,11 +129,11 @@ impl AssetLoader for SaveSceneLoader {
 
         let asset_path = load_context.path().to_path_buf();
         let parent_dir = asset_path.parent().unwrap();
-        let _sub_assets: Vec<Handle<SaveEntity>> = s
+        let _sub_assets: Vec<Handle<SaveEntity>> = s.lines().map(|line| {
-            .lines()
+            parent_dir.join(line)
-            .map(|line| parent_dir.join(line))
+        }).map(|path| {
-            .map(|path| load_context.load(path))
+            load_context.load(path)
-            .collect();
+        }).collect();
 
         Ok(DynamicScene::default())
     }
@@ -151,10 +143,14 @@ impl AssetLoader for SaveSceneLoader {
     }
 }
 
+
 fn test_load_entity(loader: Res<AssetServer>, mut commands: Commands) {
     let _: Handle<DynamicScene> = loader.load("editor/_.scene");
     let handle: Handle<SaveEntity> = loader.load("levels/00/entities/van.entity");
-    commands.spawn((SpatialBundle { ..default() }, handle));
+    commands.spawn((
+        SpatialBundle { ..default() },
+        handle,
+    ));
 }
 
 fn spawn_loaded_entities(

work.log

@@ -1 +0,0 @@
-Wed Jul 31 09:09:04 PM PDT 2024 Ended work on T -> Box<dyn Reflect> parsing stuff