Prototype reload + other enhancements

RELEASE-NOTES.md

@@ -35,11 +35,12 @@ END TEMPLATE-->
 
 ### Breaking changes
 
-*None yet*
+* Prototype reloads now also re-apply modified components. For example this means sprite or physics changes are reflected on existing prototypes.
 
 ### New features
 
 * Console completion options now have a new flags for preventing suggestions from being escaped or quoted.
+* AddComponent now has an overload for ComponentRegistryEntry.
 
 ### Bugfixes
 

Robust.Shared/GameObjects/Systems/PrototypeReloadSystem.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Robust.Shared.IoC;
+using Robust.Shared.IoC;
 using Robust.Shared.Prototypes;
 
 namespace Robust.Shared.GameObjects;
@@ -12,7 +9,6 @@ namespace Robust.Shared.GameObjects;
 internal sealed class PrototypeReloadSystem : EntitySystem
 {
     [Dependency] private readonly IPrototypeManager _prototypes = default!;
-    [Dependency] private readonly IComponentFactory _componentFactory = default!;
 
     public override void Initialize()
     {
@@ -36,43 +32,62 @@ private void OnPrototypesReloaded(PrototypesReloadedEventArgs eventArgs)
         }
     }
 
+    private bool IsIgnored(EntityPrototype.ComponentRegistryEntry entry)
+    {
+        var compType = entry.Component.GetType();
+
+        if (compType == typeof(TransformComponent) || compType == typeof(MetaDataComponent))
+            return true;
+
+        return false;
+    }
+
     private void UpdateEntity(EntityUid entity, MetaDataComponent metaData, EntityPrototype newPrototype)
     {
         var oldPrototype = metaData.EntityPrototype;
+        var modified = false;
 
-        var oldPrototypeComponents = oldPrototype?.Components.Keys
-            .Where(n => n != "Transform" && n != "MetaData")
-            .Select(name => (name, _componentFactory.GetRegistration(name).Type))
-            .ToList() ?? new List<(string name, Type Type)>();
+        if (oldPrototype != null)
+        {
+            foreach (var oldComp in oldPrototype.Components)
+            {
+                if (IsIgnored(oldComp.Value))
+                    continue;
 
-        var newPrototypeComponents = newPrototype.Components.Keys
-            .Where(n => n != "Transform" && n != "MetaData")
-            .Select(name => (name, _componentFactory.GetRegistration(name).Type))
-            .ToList();
+                // Removed
+                if (!newPrototype.Components.TryGetValue(oldComp.Key, out var newComp))
+                {
+                    modified = true;
+                    RemComp(entity, oldComp.Value.Component.GetType());
+                    continue;
+                }
 
-        var ignoredComponents = new List<string>();
+                // Modified
+                if (!newComp.Mapping.Equals(oldComp.Value.Mapping))
+                {
+                    modified = true;
+                    EntityManager.AddComponent(entity, newComp, overwrite: true, metaData);
+                }
+            }
+        }
 
-        // Find components to be removed, and remove them
-        foreach (var (name, type) in oldPrototypeComponents.Except(newPrototypeComponents))
+        foreach (var newComp in newPrototype.Components)
         {
-            if (newPrototype.Components.ContainsKey(name))
-            {
-                ignoredComponents.Add(name);
+            if (IsIgnored(newComp.Value))
                 continue;
-            }
 
-            RemComp(entity, type);
-        }
+            // Existing component, handled above
+            if (oldPrototype?.Components.ContainsKey(newComp.Key) == true)
+                continue;
 
-        EntityManager.CullRemovedComponents();
+            // Added
+            modified = true;
+            EntityManager.AddComponent(entity, newComp.Value, overwrite: true, metadata: metaData);
+        }
 
-        // Add new components
-        foreach (var (name, _) in newPrototypeComponents.Where(t => !ignoredComponents.Contains(t.name))
-                     .Except(oldPrototypeComponents))
+        if (modified)
         {
-            var data = newPrototype.Components[name];
-            var component = _componentFactory.GetComponent(name);
-            EntityManager.AddComponent(entity, component);
+            EntityManager.CullRemovedComponents();
         }
 
         // Update entity metadata

Robust.Shared/Prototypes/EntityPrototype.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
@@ -21,7 +22,7 @@ namespace Robust.Shared.Prototypes
     /// Prototype that represents game entities.
     /// </summary>
     [Prototype("entity", -1)]
-    public sealed partial class EntityPrototype : IPrototype, IInheritingPrototype, ISerializationHooks
+    public sealed partial class EntityPrototype : IPrototype, IInheritingPrototype, ISerializationHooks, IEquatable<EntityPrototype>
     {
         private ILocalizationManager _loc = default!;
 
@@ -288,7 +289,7 @@ public override string ToString()
         public record ComponentRegistryEntry(IComponent Component, MappingDataNode Mapping);
 
         [DataDefinition]
-        public sealed partial class EntityPlacementProperties
+        public sealed partial class EntityPlacementProperties : IEquatable<EntityPlacementProperties>
         {
             public bool PlacementOverriden { get; private set; }
             public bool SnapOverriden { get; private set; }
@@ -332,6 +333,27 @@ public HashSet<string> SnapFlags
                     _snapFlags = value;
                 }
             }
+
+            public bool Equals(EntityPlacementProperties? other)
+            {
+                if (ReferenceEquals(null, other)) return false;
+                if (ReferenceEquals(this, other)) return true;
+                return _placementMode == other._placementMode &&
+                       _placementOffset.Equals(other._placementOffset) &&
+                       Equals(MountingPoints, other.MountingPoints) &&
+                       PlacementRange == other.PlacementRange &&
+                       _snapFlags.SetEquals(other._snapFlags);
+            }
+
+            public override bool Equals(object? obj)
+            {
+                return ReferenceEquals(this, obj) || obj is EntityPlacementProperties other && Equals(other);
+            }
+
+            public override int GetHashCode()
+            {
+                return HashCode.Combine(_placementMode, _placementOffset, MountingPoints, PlacementRange, _snapFlags);
+            }
         }
         /*private class PrototypeSerializationContext : YamlObjectSerializer.Context
         {
@@ -400,9 +422,71 @@ public override bool TryGetDataCache(string field, out object? value)
                 return prototype.DataCache.TryGetValue(field, out value);
             }
         }*/
+        public bool Equals(EntityPrototype? other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            var result = ID == other.ID &&
+                         Equals(_locPropertiesSet, other._locPropertiesSet) &&
+                         Equals(CategoriesInternal, other.CategoriesInternal) &&
+                         PlacementProperties.Equals(other.PlacementProperties) &&
+                         SetName == other.SetName &&
+                         SetDesc == other.SetDesc &&
+                         SetSuffix == other.SetSuffix &&
+                         CustomLocalizationID == other.CustomLocalizationID &&
+                         HideSpawnMenu == other.HideSpawnMenu &&
+                         MapSavable == other.MapSavable &&
+                         Abstract == other.Abstract;
+
+            if (!result)
+                return false;
+
+            if ((Parents == null && other.Parents != null) ||
+                (Parents != null && other.Parents == null))
+            {
+                return false;
+            }
+
+            if (Parents != null && other.Parents != null)
+            {
+                for (var i = 0; i < Parents.Length; i++)
+                {
+                    if (Parents[i] != other.Parents[i])
+                        return false;
+                }
+            }
+
+            return Components.Equals(other.Components);
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return ReferenceEquals(this, obj) || obj is EntityPrototype other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            var hashCode = new HashCode();
+            hashCode.Add(_loc);
+            hashCode.Add(_locPropertiesSet);
+            hashCode.Add(CategoriesInternal);
+            hashCode.Add(PlacementProperties);
+            hashCode.Add(ID);
+            hashCode.Add(SetName);
+            hashCode.Add(SetDesc);
+            hashCode.Add(SetSuffix);
+            hashCode.Add(Categories);
+            hashCode.Add(CustomLocalizationID);
+            hashCode.Add(HideSpawnMenu);
+            hashCode.Add(MapSavable);
+            hashCode.Add(Parents);
+            hashCode.Add(Abstract);
+            hashCode.Add(Components);
+            return hashCode.ToHashCode();
+        }
     }
 
-    public sealed class ComponentRegistry : Dictionary<string, EntityPrototype.ComponentRegistryEntry>, IEntityLoadContext, ISerializationContext
+    public sealed class ComponentRegistry : Dictionary<string, EntityPrototype.ComponentRegistryEntry>, IEntityLoadContext, ISerializationContext, IEquatable<ComponentRegistry>
     {
         public ComponentRegistry()
         {
@@ -432,5 +516,37 @@ public bool ShouldSkipComponent(string compName)
 
         public SerializationManager.SerializerProvider SerializerProvider { get; } = new();
         public bool WritingReadingPrototypes { get; } = true;
+
+        public bool Equals(ComponentRegistry? other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+
+            if (other.Count != Count)
+                return false;
+
+            foreach (var (id, component) in this)
+            {
+                if (!other.TryGetValue(id, out var otherComponent))
+                    continue;
+
+                if (!component.Mapping.Equals(otherComponent.Mapping))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return ReferenceEquals(this, obj) || obj is ComponentRegistry other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(SerializerProvider, WritingReadingPrototypes);
+        }
     }
 }