com.artromskiy.deltaecs.unity 0.0.37 → 0.0.39

package/Editor/SceneEntityInspectorView.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 using Delta;
 using Delta.ECS;
 using Delta.ECS.Integration;
@@ -194,10 +193,12 @@ namespace Delta.ECS.Unity.Editor
             _header.Add(BuildEntityHeader(authoring));
             _componentEntries.AddRange(ProjectAuthoringComponents(authoring));
             RenderComponentRows();
+            _footer.Add(BuildAddComponentMenu(authoring));
             var deleteButton = new Button(() => HierarchyMenu.DeleteEntity(Authoring, authoring.StableId))
             {
                 text = "Delete Entity"
             };
+            deleteButton.AddToClassList("ecs-action-button");
             deleteButton.AddToClassList("ecs-delete-entity");
             _footer.Add(deleteButton);
         }
@@ -302,6 +303,7 @@ namespace Delta.ECS.Unity.Editor
                 text = "Unbind",
                 tooltip = "Remove the GameObject binding from this entity"
             };
+            unbind.AddToClassList("ecs-action-button");
             unbind.SetEnabled(currentView != null);
             field.RegisterValueChangedCallback(evt =>
             {
@@ -335,6 +337,12 @@ namespace Delta.ECS.Unity.Editor
         {
             return BuildComponentCard(descriptor, body =>
             {
+                if (descriptor.IsTag)
+                {
+                    body.Add(CreateClassLabel("Tag · membership only", "ecs-empty-component"));
+                    return;
+                }
+
                 if (!_previewWorld.TryRead(authoring, descriptor, out ComponentSnapshot snapshot, out EcsReadError readError))
                 {
                     body.Add(new HelpBox($"Could not read component: {readError.Code}.", HelpBoxMessageType.Error));
@@ -343,7 +351,7 @@ namespace Delta.ECS.Unity.Editor
 
                 DrawEditableValue(body, authoring, data, descriptor, snapshot.Value);
             },
-            () => ResetComponent(authoring, data, descriptor),
+            descriptor.IsTag ? null : () => ResetComponent(authoring, data, descriptor),
             () => RemoveComponent(authoring, data, descriptor));
         }
 
@@ -366,6 +374,7 @@ namespace Delta.ECS.Unity.Editor
         private VisualElement BuildAddComponentMenu(EntityAuthoring authoring)
         {
             var button = new Button { text = "Add Component" };
+            button.AddToClassList("ecs-action-button");
             button.AddToClassList("ecs-add-component");
             HashSet<ulong> existingSchemas = authoring.Components
                 .Select(GetSchemaId)
@@ -483,25 +492,26 @@ namespace Delta.ECS.Unity.Editor
         private void DrawEditableValue(VisualElement body, EntityAuthoring authoring, ComponentData data,
             ComponentDescriptor descriptor, object value)
         {
-            FieldInfo[] fields = GetComponentFields(descriptor.ValueType);
-            if (fields.Length == 0)
-            {
-                body.Add(CreateClassLabel("Component has no public fields.", "ecs-empty-component"));
-                return;
-            }
-
-            for (int i = 0; i < fields.Length; i++)
-            {
-                FieldInfo field = fields[i];
-                object current = field.GetValue(value);
-                VisualElement control = CreateFieldControl(field, current, next =>
+            bool canWrite = (descriptor.Capabilities & ComponentCapabilities.Write) != 0
+                && descriptor.ValueType.IsValueType;
+            int previousChildCount = body.childCount;
+            ComponentPropertyBinding[] bindings = ComponentPropertyBagFields.Build(body, descriptor, value,
+                canWrite,
+                (path, next) =>
                 {
-                    if (Equals(current, next)) return;
+                    object updated = value;
+                    if (!PropertyBagValueAccess.TrySetValue(ref updated, descriptor.ValueType, path, next))
+                    {
+                        Debug.LogWarning($"Could not edit a property on {descriptor.Name}: the property path is unavailable.", Authoring);
+                        RefreshContent();
+                        return;
+                    }
+
+                    if (Equals(updated, value)) return;
                     Undo.RecordObject(Authoring, $"Edit {descriptor.Name}");
-                    field.SetValue(value, next);
-                    if (_previewWorld.TryWrite(authoring, data, descriptor, value, out EcsWriteError writeError))
+                    if (_previewWorld.TryWrite(authoring, data, descriptor, updated, out EcsWriteError writeError))
                     {
-                        current = next;
+                        value = updated;
                         MarkSceneDirty();
                     }
                     else
@@ -509,66 +519,13 @@ namespace Delta.ECS.Unity.Editor
                         Debug.LogError($"Could not write {descriptor.Name}: {writeError.Code}.", Authoring);
                         RefreshContent();
                     }
-                });
-                body.Add(control);
-            }
-        }
+                },
+                (label, current, onChanged) => CreateEntityReferenceField(label, current, onChanged));
 
-        private VisualElement CreateFieldControl(FieldInfo field, object value, Action<object> onChanged)
-        {
-            string label = ObjectNames.NicifyVariableName(field.Name);
-            Type type = field.FieldType;
-            if (type == typeof(float))
-            {
-                var fieldControl = new FloatField(label) { value = (float)value, isDelayed = true };
-                AddInspectorFieldClasses(fieldControl);
-                fieldControl.RegisterValueChangedCallback(evt => onChanged(evt.newValue));
-                return fieldControl;
-            }
-
-            if (type == typeof(byte) || type == typeof(int))
-            {
-                var fieldControl = new IntegerField(label) { value = Convert.ToInt32(value), isDelayed = true };
-                AddInspectorFieldClasses(fieldControl);
-                fieldControl.RegisterValueChangedCallback(evt => onChanged(type == typeof(byte)
-                    ? (object)(byte)Mathf.Clamp(evt.newValue, byte.MinValue, byte.MaxValue)
-                    : evt.newValue));
-                return fieldControl;
-            }
-
-            if (type == typeof(bool))
-            {
-                var fieldControl = new Toggle(label) { value = (bool)value };
-                AddInspectorFieldClasses(fieldControl);
-                fieldControl.RegisterValueChangedCallback(evt => onChanged(evt.newValue));
-                return fieldControl;
-            }
-
-            if (type == typeof(float3))
-            {
-                float3 vector = (float3)value;
-                var fieldControl = new Vector3Field(label) { value = new Vector3(vector.x, vector.y, vector.z) };
-                AddInspectorFieldClasses(fieldControl);
-                fieldControl.RegisterValueChangedCallback(evt => onChanged(new float3(evt.newValue.x, evt.newValue.y, evt.newValue.z)));
-                return fieldControl;
-            }
-
-            if (type == typeof(Entity))
-            {
-                return CreateEntityReferenceField(label, (Entity)value, onChanged);
-            }
-
-            if (type.IsEnum)
+            if (bindings.Length == 0 && body.childCount == previousChildCount)
             {
-                var fieldControl = new EnumField(label, (Enum)value);
-                AddInspectorFieldClasses(fieldControl);
-                fieldControl.RegisterValueChangedCallback(evt => onChanged(evt.newValue));
-                return fieldControl;
+                body.Add(CreateClassLabel("Component has no exposed properties.", "ecs-empty-component"));
             }
-
-            var unsupported = new Label($"{label}  ·  Unsupported: {type.Name}");
-            unsupported.AddToClassList("ecs-unsupported-field");
-            return unsupported;
         }
 
         private VisualElement CreateEntityReferenceField(string label, Entity current, Action<object> onChanged)
@@ -640,13 +597,19 @@ namespace Delta.ECS.Unity.Editor
         {
             return BuildComponentCard(descriptor, body =>
             {
-                if (!world.Integration.TryRead(entity, descriptor.Id, out ComponentSnapshot snapshot, out EcsReadError error))
+                if (descriptor.IsTag)
+                {
+                    body.Add(CreateClassLabel("Tag · membership only", "ecs-empty-component"));
+                    return;
+                }
+
+                if (!world.TryRead(entity, descriptor, out ComponentSnapshot snapshot, out EcsReadError error))
                 {
                     body.Add(new HelpBox($"Could not read component: {error.Code}.", HelpBoxMessageType.Error));
                     return;
                 }
 
-                DrawReadOnlyValue(body, descriptor, snapshot.Value, world);
+                DrawRuntimeValue(body, world, entity, descriptor, snapshot);
             });
         }
 
@@ -654,7 +617,6 @@ namespace Delta.ECS.Unity.Editor
         {
             _componentItems.Clear();
             _componentItems.AddRange(_componentEntries);
-            if (_authoringEntity != null) _componentItems.Add(default);
             _componentList.itemsSource = _componentItems;
             _componentList.Rebuild();
         }
@@ -662,19 +624,10 @@ namespace Delta.ECS.Unity.Editor
         private void BindComponentItem(VisualElement row, int index)
         {
             row.Clear();
-            bool isAddButton = _authoringEntity != null && index == _componentEntries.Count;
-            row.parent.parent.EnableInClassList("ecs-add-component-row", isAddButton);
-            row.parent.parent.EnableInClassList("ecs-component-last-bound-row",
+            SetReorderableItemClass(row, "ecs-component-last-bound-row",
                 _embedded && _target.IsRuntime && index == _componentEntries.Count - 1);
-            row.EnableInClassList("ecs-component-row", !isAddButton);
-            if (isAddButton)
-            {
-                row.userData = null;
-                row.Add(BuildAddComponentMenu(_authoringEntity));
-                return;
-            }
-
             ComponentEntry entry = _componentItems[index];
+            row.EnableInClassList("ecs-component-row", true);
             row.userData = entry;
             row.Add(_target.IsRuntime
                 ? BuildRuntimeComponentCard(_target.RuntimeWorld, _target.RuntimeEntity, entry.Descriptor.Value)
@@ -683,6 +636,20 @@ namespace Delta.ECS.Unity.Editor
                     : BuildUnknownComponentCard(_authoringEntity, entry.Data));
         }
 
+        private void SetReorderableItemClass(VisualElement row, string className, bool enabled)
+        {
+            for (VisualElement ancestor = row.parent; ancestor != null && ancestor != _componentList; ancestor = ancestor.parent)
+            {
+                if (ancestor.Q<VisualElement>(className: "unity-list-view__reorderable-handle") == null)
+                {
+                    continue;
+                }
+
+                ancestor.EnableInClassList(className, enabled);
+                return;
+            }
+        }
+
         private void UnbindComponentItem(VisualElement row, int index)
         {
             if (row.userData is ComponentEntry entry && entry.Descriptor.HasValue)
@@ -752,7 +719,7 @@ namespace Delta.ECS.Unity.Editor
         {
             ReadOnlyMemory<ComponentDescriptor> catalog = world.Integration.Catalog.Components;
             _runtimeComponentBuffer = new ComponentId[catalog.Length];
-            if (!world.Integration.TryGetComponents(entity, _runtimeComponentBuffer, out int count))
+            if (!world.TryGetComponents(entity, _runtimeComponentBuffer, out int count))
             {
                 _runtimeComponentIds = null;
                 return null;
@@ -794,31 +761,113 @@ namespace Delta.ECS.Unity.Editor
             return card;
         }
 
-        private void DrawReadOnlyValue(VisualElement body, ComponentDescriptor descriptor, object value, SceneWorld world)
+        private void DrawRuntimeValue(VisualElement body, SceneWorld world, Entity entity,
+            ComponentDescriptor descriptor, ComponentSnapshot snapshot)
         {
-            FieldInfo[] fields = GetComponentFields(descriptor.ValueType);
-            if (fields.Length == 0)
+            bool canWrite = (descriptor.Capabilities & ComponentCapabilities.Write) != 0
+                && descriptor.ValueType.IsValueType;
+            int previousChildCount = body.childCount;
+            ComponentPropertyBinding[] properties = ComponentPropertyBagFields.Build(body, descriptor,
+                snapshot.Value, canWrite,
+                (path, next) => WriteRuntimeField(world, entity, descriptor, path, next),
+                (label, current, onChanged) => CreateRuntimeEntityReferenceField(world, label, current, onChanged));
+
+            if (properties.Length > 0)
             {
-                body.Add(CreateClassLabel("Component has no public fields.", "ecs-empty-component"));
+                _runtimeBindings.Add(new RuntimeValueBinding(descriptor, properties));
+            }
+            else if (body.childCount == previousChildCount)
+            {
+                body.Add(CreateClassLabel("Component has no exposed properties.", "ecs-empty-component"));
+            }
+        }
+
+        private VisualElement CreateRuntimeEntityReferenceField(SceneWorld world, string label, Entity current,
+            Action<object> onChanged)
+        {
+            Entity[] authored = world.AuthoredEntities;
+            var values = new List<Entity>(authored.Length + 2) { default };
+            var options = new List<string>(authored.Length + 2) { "None" };
+            var names = new List<string>(authored.Length);
+            for (int i = 0; i < authored.Length; i++)
+            {
+                Entity candidate = authored[i];
+                if (!world.Integration.IsAlive(candidate)) continue;
+                names.Add(GetRuntimeEntityName(world, candidate));
+            }
+
+            HashSet<string> duplicateNames = names
+                .GroupBy(name => name, StringComparer.Ordinal)
+                .Where(group => group.Count() > 1)
+                .Select(group => group.Key)
+                .ToHashSet(StringComparer.Ordinal);
+
+            int currentIndex = current.IsValid ? -1 : 0;
+            int nameIndex = 0;
+            for (int i = 0; i < authored.Length; i++)
+            {
+                Entity candidate = authored[i];
+                if (!world.Integration.IsAlive(candidate)) continue;
+                string name = names[nameIndex++];
+                string stableId = world.TryGetStableId(candidate, out string id) ? id : string.Empty;
+                values.Add(candidate);
+                options.Add(duplicateNames.Contains(name) && !string.IsNullOrEmpty(stableId)
+                    ? $"{name} ({stableId.Substring(0, Math.Min(8, stableId.Length))})"
+                    : name);
+                if (candidate == current) currentIndex = values.Count - 1;
+            }
+
+            if (current.IsValid && currentIndex < 0)
+            {
+                values.Add(current);
+                options.Add($"Current ({FormatValue(typeof(Entity), current, world)})");
+                currentIndex = values.Count - 1;
+            }
+
+            var fieldControl = new DropdownField(label, options, currentIndex);
+            AddInspectorFieldClasses(fieldControl);
+            fieldControl.userData = new RuntimeEntityReferenceChoices(options.ToArray(), values.ToArray());
+            fieldControl.RegisterValueChangedCallback(evt =>
+            {
+                int index = options.IndexOf(evt.newValue);
+                Entity next = index >= 0 && index < values.Count ? values[index] : default;
+                onChanged(next);
+            });
+            return fieldControl;
+        }
+
+        private string GetRuntimeEntityName(SceneWorld world, Entity entity)
+        {
+            return world.TryGetStableId(entity, out string stableId)
+                && world.TryGetAuthoring(stableId, out EntityAuthoring authoring)
+                    ? authoring.Name
+                    : entity.ToString();
+        }
+
+        private void WriteRuntimeField(SceneWorld world, Entity entity, ComponentDescriptor descriptor,
+            string[] path, object next)
+        {
+            if (!world.Integration.TryRead(entity, descriptor.Id, out ComponentSnapshot snapshot, out EcsReadError readError))
+            {
+                Debug.LogWarning($"Could not read {descriptor.Name} before editing: {readError.Code}.");
+                RefreshRuntimeView();
                 return;
             }
 
-            var labels = new TextField[fields.Length];
-            for (int i = 0; i < fields.Length; i++)
+            object updated = snapshot.Value;
+            if (!PropertyBagValueAccess.TrySetValue(ref updated, descriptor.ValueType, path, next))
             {
-                FieldInfo field = fields[i];
-                object fieldValue = field.GetValue(value);
-                string display = FormatValue(field.FieldType, fieldValue, world);
-                labels[i] = new TextField(ObjectNames.NicifyVariableName(field.Name))
-                {
-                    value = display,
-                    isReadOnly = true
-                };
-                AddInspectorFieldClasses(labels[i]);
-                body.Add(labels[i]);
+                Debug.LogWarning($"Could not edit {descriptor.Name}: the property path is unavailable.");
+                RefreshRuntimeView();
+                return;
             }
 
-            _runtimeBindings.Add(new RuntimeValueBinding(descriptor, fields, labels));
+            if (!world.Integration.TryWrite(entity, descriptor.Id, updated, snapshot.Stamp,
+                    out _, out EcsWriteError writeError))
+            {
+                Debug.LogWarning($"Could not edit {descriptor.Name}: {writeError.Code}.");
+                RefreshRuntimeView();
+            }
         }
 
         private string FormatValue(Type type, object value, SceneWorld world)
@@ -842,9 +891,6 @@ namespace Delta.ECS.Unity.Editor
             return value?.ToString() ?? "None";
         }
 
-        private static FieldInfo[] GetComponentFields(Type type) =>
-            type.GetFields(BindingFlags.Instance | BindingFlags.Public);
-
         private static Label CreateClassLabel(string text, string className)
         {
             var label = new Label(text);
@@ -887,7 +933,7 @@ namespace Delta.ECS.Unity.Editor
                 return;
             }
 
-            if (!world.Integration.TryGetComponents(entity, _runtimeComponentBuffer, out int count)
+            if (!world.TryGetComponents(entity, _runtimeComponentBuffer, out int count)
                 || count != _runtimeComponentIds.Length)
             {
                 RefreshContent();
@@ -911,18 +957,93 @@ namespace Delta.ECS.Unity.Editor
                     continue;
                 }
 
-                for (int fieldIndex = 0; fieldIndex < binding.Fields.Length; fieldIndex++)
+                for (int fieldIndex = 0; fieldIndex < binding.Properties.Length; fieldIndex++)
                 {
-                    FieldInfo field = binding.Fields[fieldIndex];
-                    string text = FormatValue(field.FieldType, field.GetValue(snapshot.Value), world);
-                    if (!string.Equals(binding.Labels[fieldIndex].value, text, StringComparison.Ordinal))
+                    ComponentPropertyBinding property = binding.Properties[fieldIndex];
+                    VisualElement control = property.Control;
+                    VisualElement focused = control.panel?.focusController?.focusedElement as VisualElement;
+                    if (focused != null && control.Contains(focused))
+                    {
+                        continue;
+                    }
+
+                    if (PropertyBagValueAccess.TryGetValue(snapshot.Value, binding.Descriptor.ValueType,
+                            property.Path, out object value))
                     {
-                        binding.Labels[fieldIndex].SetValueWithoutNotify(text);
+                        SetRuntimeFieldValue(control, property.ValueType, value, world);
                     }
                 }
             }
         }
 
+        private void SetRuntimeFieldValue(VisualElement control, Type type, object value, SceneWorld world)
+        {
+            if (control is FloatField floatField)
+            {
+                floatField.SetValueWithoutNotify(value == null ? 0f : (float)value);
+            }
+            else if (control is DoubleField doubleField)
+            {
+                doubleField.SetValueWithoutNotify(value == null ? 0d : (double)value);
+            }
+            else if (control is TextField textField)
+            {
+                textField.SetValueWithoutNotify(type == typeof(string) ? (string)value ?? string.Empty
+                    : type == typeof(char) ? value == null ? string.Empty : value.ToString()
+                    : FormatValue(type, value, world));
+            }
+            else if (control is IntegerField integerField)
+            {
+                integerField.SetValueWithoutNotify(value == null ? 0 : Convert.ToInt32(value));
+            }
+            else if (control is LongField longField)
+            {
+                longField.SetValueWithoutNotify(value == null ? 0L : Convert.ToInt64(value));
+            }
+            else if (control is Toggle toggle)
+            {
+                toggle.SetValueWithoutNotify(value != null && (bool)value);
+            }
+            else if (control is Vector2Field vector2Field && value is Vector2 vector2)
+            {
+                vector2Field.SetValueWithoutNotify(vector2);
+            }
+            else if (control is Vector3Field vectorField && value is Vector3 vector3)
+            {
+                vectorField.SetValueWithoutNotify(vector3);
+            }
+            else if (control is Vector3Field float3Field && value is float3 vector)
+            {
+                float3Field.SetValueWithoutNotify(new Vector3(vector.x, vector.y, vector.z));
+            }
+            else if (control is Vector4Field vector4Field && value is Vector4 vector4)
+            {
+                vector4Field.SetValueWithoutNotify(vector4);
+            }
+            else if (control is ColorField colorField && value is Color color)
+            {
+                colorField.SetValueWithoutNotify(color);
+            }
+            else if (control is EnumField enumField && value is Enum enumValue)
+            {
+                enumField.SetValueWithoutNotify(enumValue);
+            }
+            else if (control is ObjectField objectField)
+            {
+                objectField.SetValueWithoutNotify(value as UnityEngine.Object);
+            }
+            else if (control is DropdownField entityField
+                && type == typeof(Entity)
+                && entityField.userData is RuntimeEntityReferenceChoices choices)
+            {
+                int index = Array.IndexOf(choices.Entities, (Entity)value);
+                if (index >= 0)
+                {
+                    entityField.SetValueWithoutNotify(choices.Labels[index]);
+                }
+            }
+        }
+
         private ComponentEntry[] ProjectAuthoringComponents(EntityAuthoring authoring)
         {
             Dictionary<ulong, ComponentDescriptor> descriptors = _previewWorld.Integration.Catalog.Components
@@ -1089,14 +1210,24 @@ namespace Delta.ECS.Unity.Editor
         private readonly struct RuntimeValueBinding
         {
             public readonly ComponentDescriptor Descriptor;
-            public readonly FieldInfo[] Fields;
-            public readonly TextField[] Labels;
+            public readonly ComponentPropertyBinding[] Properties;
 
-            public RuntimeValueBinding(ComponentDescriptor descriptor, FieldInfo[] fields, TextField[] labels)
+            public RuntimeValueBinding(ComponentDescriptor descriptor, ComponentPropertyBinding[] properties)
             {
                 Descriptor = descriptor;
-                Fields = fields;
+                Properties = properties;
+            }
+        }
+
+        private sealed class RuntimeEntityReferenceChoices
+        {
+            public readonly string[] Labels;
+            public readonly Entity[] Entities;
+
+            public RuntimeEntityReferenceChoices(string[] labels, Entity[] entities)
+            {
                 Labels = labels;
+                Entities = entities;
             }
         }
     }

package/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 51f385a11fe94398b8d8db41a03ab731
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/README.md

@@ -18,7 +18,7 @@ Add the npm-compatible registry and package to the Unity project's
     }
   ],
   "dependencies": {
-    "com.artromskiy.deltaecs.unity": "0.0.37"
+    "com.artromskiy.deltaecs.unity": "0.0.39"
   }
 }
 ```

package/Runtime/ComponentData.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Reflection;
 using Delta.ECS;
 using Delta.ECS.Integration;
 using UnityEngine;
@@ -47,19 +46,16 @@ namespace Delta.ECS.Unity
                 value = Activator.CreateInstance(componentType);
             }
 
-            FieldInfo[] fields = componentType.GetFields(BindingFlags.Instance | BindingFlags.Public);
             List<EntityReference> references = EntityReferenceList;
             for (int i = 0; i < references.Count; i++)
             {
                 EntityReference reference = references[i];
-                for (int fieldIndex = 0; fieldIndex < fields.Length; fieldIndex++)
+                object resolvedValue = resolveEntity(reference.TargetEntityId);
+                object current = value;
+                if (PropertyBagValueAccess.TrySetValue(ref current, componentType,
+                        PropertyBagValueAccess.ParsePath(reference.FieldName), resolvedValue))
                 {
-                    FieldInfo field = fields[fieldIndex];
-                    if (field.Name == reference.FieldName && field.FieldType == typeof(Entity))
-                    {
-                        field.SetValue(value, resolveEntity(reference.TargetEntityId));
-                        break;
-                    }
+                    value = current;
                 }
             }
 
@@ -75,23 +71,13 @@ namespace Delta.ECS.Unity
 
             _json = JsonUtility.ToJson(value);
             EntityReferenceList.Clear();
+            PropertyBagValueAccess.CollectEntityReferences(value, value.GetType(), stableIdResolver, EntityReferenceList);
+        }
 
-            FieldInfo[] fields = value.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public);
-            for (int i = 0; i < fields.Length; i++)
-            {
-                FieldInfo field = fields[i];
-                if (field.FieldType != typeof(Entity))
-                {
-                    continue;
-                }
-
-                Entity target = (Entity)field.GetValue(value);
-                string targetId = stableIdResolver(target) ?? string.Empty;
-                if (!string.IsNullOrEmpty(targetId))
-                {
-                    EntityReferenceList.Add(new EntityReference(field.Name, targetId));
-                }
-            }
+        public void StoreDefaultTag()
+        {
+            _json = "{}";
+            EntityReferenceList.Clear();
         }
 
         public string GetEntityReference(string fieldName)
@@ -113,6 +99,11 @@ namespace Delta.ECS.Unity
 
         public static ComponentData CreateDefault(ComponentDescriptor descriptor)
         {
+            if (descriptor.IsTag)
+            {
+                return new ComponentData(descriptor.Schema.Value, "{}");
+            }
+
             object value = Activator.CreateInstance(descriptor.ValueType);
             return new ComponentData(descriptor.Schema.Value, JsonUtility.ToJson(value));
         }