Automatically resolve entities from UUIDs

Also fix bug when doing so caused the level to be marked as unsaved

Author: idanarye

examples/example2d.rs

@@ -143,7 +143,7 @@ fn main() {
     // Common systems
     // ========================================================================
 
-    app.add_systems(Update, (resolve_laser_pointers, draw_laser_pointers));
+    app.add_systems(Update, draw_laser_pointers);
     app.add_systems(
         Update,
         (control_player, eat_fruits).run_if(in_state(YoleckEditorState::GameActive)),
@@ -574,15 +574,6 @@ fn populate_triangle(
 // LaserPointer (shared)
 // ============================================================================
 
-fn resolve_laser_pointers(
-    mut query: Query<&mut TextLaserPointer>,
-    uuid_registry: Res<YoleckUuidRegistry>,
-) {
-    for mut laser_pointer in query.iter_mut() {
-        let _ = laser_pointer.target.resolve(&uuid_registry);
-    }
-}
-
 fn draw_laser_pointers(
     query: Query<(&TextLaserPointer, &GlobalTransform)>,
     targets_query: Query<&GlobalTransform>,

examples/example3d.rs

@@ -74,7 +74,7 @@ fn main() {
     });
     app.add_yoleck_auto_edit::<LaserPointer>();
     app.add_systems(YoleckSchedule::Populate, populate_simple_sphere);
-    app.add_systems(Update, (resolve_laser_pointers, draw_laser_pointers));
+    app.add_systems(Update, draw_laser_pointers);
 
     app.add_systems(
         Update,
@@ -278,15 +278,6 @@ fn populate_simple_sphere(
     });
 }
 
-fn resolve_laser_pointers(
-    mut query: Query<&mut LaserPointer>,
-    uuid_registry: Res<YoleckUuidRegistry>,
-) {
-    for mut laser_pointer in query.iter_mut() {
-        let _ = laser_pointer.target.resolve(&uuid_registry);
-    }
-}
-
 fn draw_laser_pointers(
     query: Query<(&LaserPointer, &GlobalTransform)>,
     targets_query: Query<&GlobalTransform>,

macros/src/lib.rs

@@ -228,22 +228,20 @@ fn impl_yoleck_auto_edit_derive(input: DeriveInput) -> Result<TokenStream, Error
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
 
-    let fields = match &input.data {
-        Data::Struct(data) => match &data.fields {
-            Fields::Named(fields) => &fields.named,
-            _ => {
-                return Err(Error::new_spanned(
-                    &input,
-                    "YoleckAutoEdit only supports structs with named fields",
-                ));
-            }
-        },
-        _ => {
+    let fields = if let Data::Struct(data) = &input.data {
+        if let Fields::Named(fields) = &data.fields {
+            &fields.named
+        } else {
             return Err(Error::new_spanned(
                 &input,
-                "YoleckAutoEdit only supports structs",
+                "YoleckAutoEdit only supports structs with named fields",
             ));
         }
+    } else {
+        return Err(Error::new_spanned(
+            &input,
+            "YoleckAutoEdit only supports structs",
+        ));
     };
 
     let mut field_uis = Vec::new();
@@ -256,9 +254,16 @@ fn impl_yoleck_auto_edit_derive(input: DeriveInput) -> Result<TokenStream, Error
     }
 
     let mut entity_ref_fields = Vec::new();
+    let mut entity_ref_field_names = Vec::new();
     for field in fields {
         if let Some(info) = parse_entity_ref_attrs(field)? {
             entity_ref_fields.push(info);
+            entity_ref_field_names.push(
+                field
+                    .ident
+                    .as_ref()
+                    .expect("fields are taken from a named struct variant"),
+            );
         }
     }
 
@@ -322,6 +327,12 @@ fn impl_yoleck_auto_edit_derive(input: DeriveInput) -> Result<TokenStream, Error
             fn get_entity_ref_mut(&mut self, field_name: &str) -> &mut bevy_yoleck::entity_ref::YoleckEntityRef {
                 #get_entity_ref_mut_body
             }
+
+            fn resolve_entity_refs(&mut self, registry: &bevy_yoleck::prelude::YoleckUuidRegistry) {
+                #(
+                    let _ = self.#entity_ref_field_names.resolve(registry);
+                )*
+            }
         }
     };
 

src/auto_edit.rs

@@ -1,11 +1,16 @@
 use bevy::prelude::*;
 use bevy_egui::egui;
 
+use crate::YoleckInternalSchedule;
+use crate::entity_ref::resolve_entity_refs;
+
 #[cfg(feature = "vpeol")]
 use crate::entity_ref::validate_entity_ref_requirements_for;
 
 #[cfg(feature = "vpeol")]
 use crate::entity_ref::YoleckEntityRef;
+#[cfg(feature = "vpeol")]
+use crate::prelude::YoleckUuidRegistry;
 
 #[cfg(feature = "vpeol")]
 use std::collections::HashMap;
@@ -635,6 +640,7 @@ pub fn auto_edit_system<T: YoleckComponent + YoleckAutoEdit + YoleckEntityRefAcc
     mut ui: ResMut<YoleckUi>,
     mut edit: YoleckEdit<&mut T>,
     entities_query: Query<(&YoleckEntityUuid, &YoleckManaged)>,
+    registry: Res<YoleckUuidRegistry>,
 ) {
     let Ok(mut component) = edit.single_mut() else {
         return;
@@ -668,6 +674,8 @@ pub fn auto_edit_system<T: YoleckComponent + YoleckAutoEdit + YoleckEntityRefAcc
         ui.separator();
         T::auto_edit(&mut component, ui);
     });
+
+    component.resolve_entity_refs(registry.as_ref());
 }
 
 #[cfg(not(feature = "vpeol"))]
@@ -712,6 +720,10 @@ impl YoleckAutoEditExt for App {
         &mut self,
     ) {
         self.add_yoleck_edit_system(auto_edit_system::<T>);
+        self.add_systems(
+            YoleckInternalSchedule::PostLoadResolutions,
+            resolve_entity_refs::<T>,
+        );
 
         let construction_specs = self
             .world_mut()
@@ -723,7 +735,15 @@ impl YoleckAutoEditExt for App {
     }
 
     #[cfg(not(feature = "vpeol"))]
-    fn add_yoleck_auto_edit<T: YoleckComponent + YoleckAutoEdit>(&mut self) {
+    fn add_yoleck_auto_edit<T: YoleckComponent + YoleckAutoEdit + YoleckEntityRefAccessor>(
+        &mut self,
+    ) {
+        use crate::YoleckInternalSchedule;
+
         self.add_yoleck_edit_system(auto_edit_system::<T>);
+        self.add_systems(
+            YoleckInternalSchedule::PostLoadResolutions,
+            resolve_entity_refs::<T>,
+        );
     }
 }

src/entity_management.rs

@@ -16,7 +16,7 @@ use crate::populating::PopulateReason;
 use crate::prelude::{YoleckEntityUuid, YoleckUuidRegistry};
 use crate::{
     YoleckBelongsToLevel, YoleckEntityConstructionSpecs, YoleckEntityLifecycleStatus,
-    YoleckLevelJustLoaded, YoleckManaged, YoleckSchedule, YoleckState,
+    YoleckInternalSchedule, YoleckLevelJustLoaded, YoleckManaged, YoleckSchedule, YoleckState,
 };
 
 /// Used by Yoleck to determine how to handle the entity.
@@ -185,6 +185,10 @@ pub(crate) fn process_loading_command(
     }
 }
 
+pub(crate) fn yoleck_run_post_load_resolutions_schedule(world: &mut World) {
+    world.run_schedule(YoleckInternalSchedule::PostLoadResolutions);
+}
+
 pub(crate) fn yoleck_run_level_loaded_schedule(world: &mut World) {
     world.run_schedule(YoleckSchedule::LevelLoaded);
 }

src/entity_ref.rs

@@ -1,7 +1,11 @@
+use std::any::TypeId;
+
+use bevy::ecs::component::Mutable;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
+use crate::YoleckManaged;
 use crate::entity_uuid::YoleckUuidRegistry;
 use crate::errors::YoleckEntityRefCannotBeResolved;
 
@@ -58,6 +62,18 @@ pub struct YoleckEntityRef {
     resolved: Option<Entity>,
 }
 
+// impl std::hash::Hash for YoleckEntityRef {
+// fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+// self.uuid.hash(state);
+// }
+// }
+
+// impl PartialEq for YoleckEntityRef {
+// fn eq(&self, other: &Self) -> bool {
+// self.uuid == other.uuid
+// }
+// }
+
 impl YoleckEntityRef {
     pub fn new() -> Self {
         Self {
@@ -118,6 +134,8 @@ impl YoleckEntityRef {
 pub trait YoleckEntityRefAccessor: Sized + Send + Sync + 'static {
     fn entity_ref_fields() -> &'static [(&'static str, Option<&'static str>)];
     fn get_entity_ref_mut(&mut self, field_name: &str) -> &mut YoleckEntityRef;
+    // TODO: make this more versatile
+    fn resolve_entity_refs(&mut self, registry: &YoleckUuidRegistry);
 }
 
 #[cfg(feature = "vpeol")]
@@ -139,3 +157,19 @@ pub(crate) fn validate_entity_ref_requirements_for<T: YoleckEntityRefAccessor>(
         }
     }
 }
+
+pub fn resolve_entity_refs<
+    T: 'static + Component<Mutability = Mutable> + YoleckEntityRefAccessor,
+>(
+    mut query: Query<(&mut T, &mut YoleckManaged)>,
+    registry: Res<YoleckUuidRegistry>,
+) {
+    for (mut component, mut managed) in query.iter_mut() {
+        component.resolve_entity_refs(registry.as_ref());
+        if let Some(data) = managed.components_data.get_mut(&TypeId::of::<T>())
+            && let Some(data) = data.downcast_mut::<T>()
+        {
+            data.resolve_entity_refs(registry.as_ref());
+        }
+    }
+}

src/lib.rs

@@ -292,16 +292,21 @@ impl Plugin for YoleckPluginBase {
                 entity_management::yoleck_process_raw_entries,
                 ApplyDeferred,
                 (
-                    entity_management::yoleck_run_level_loaded_schedule,
+                    entity_management::yoleck_run_post_load_resolutions_schedule,
+                    entity_management::yoleck_run_level_loaded_schedule.run_if(
+                        |freshly_loaded_level_entities: Query<
+                            (),
+                            (With<YoleckLevelJustLoaded>, Without<YoleckLevelInEditor>),
+                        >| { !freshly_loaded_level_entities.is_empty() },
+                    ),
                     entity_management::yoleck_remove_just_loaded_marker_from_levels,
                     ApplyDeferred,
                 )
                     .chain()
                     .run_if(
-                        |freshly_loaded_level_entities: Query<
-                            (),
-                            (With<YoleckLevelJustLoaded>, Without<YoleckLevelInEditor>),
-                        >| { !freshly_loaded_level_entities.is_empty() },
+                        |freshly_loaded_level_entities: Query<(), With<YoleckLevelJustLoaded>>| {
+                            !freshly_loaded_level_entities.is_empty()
+                        },
                     ),
             )
                 .chain()
@@ -332,6 +337,7 @@ impl Plugin for YoleckPluginBase {
                 .before(YoleckSystems::ProcessRawEntities),),
         );
         app.add_schedule(Schedule::new(YoleckSchedule::Populate));
+        app.add_schedule(Schedule::new(YoleckInternalSchedule::PostLoadResolutions));
         app.add_schedule(Schedule::new(YoleckSchedule::LevelLoaded));
         app.add_schedule(Schedule::new(YoleckSchedule::OverrideCommonComponents));
     }
@@ -567,7 +573,7 @@ pub struct YoleckManaged {
 
     lifecycle_status: YoleckEntityLifecycleStatus,
 
-    components_data: HashMap<TypeId, BoxedAny>,
+    pub(crate) components_data: HashMap<TypeId, BoxedAny>,
 }
 
 /// A marker for entities that belongs to the Yoleck level and should be despawned with it.
@@ -645,6 +651,9 @@ pub struct YoleckPlaytestLevel(pub Option<YoleckRawLevel>);
 #[derive(ScheduleLabel, Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum YoleckInternalSchedule {
     UpdateManagedDataFromComponents,
+    /// Before [`LevelLoaded`][YoleckSchedule::LevelLoaded] to resolve things like entity
+    /// references.
+    PostLoadResolutions,
 }
 
 /// Schedules for user code to do the actual entity/level population after Yoleck spawns the level