Make DamageSpecifier serializable (space-wizards#43049)

* pt1 damageable refactor

* fixes

* thusd unused

* sparse damagespecifiers

* fix thongs

* aaaaaa

* fix tests

* de-crash

Author: sowelipililimute

Content.Client/HealthAnalyzer/UI/HealthAnalyzerControl.xaml.cs

@@ -135,7 +135,7 @@ public void Populate(HealthAnalyzerUiState state)
             damageable.DamagePerGroup.OrderByDescending(damage => damage.Value)
                 .ToDictionary(x => x.Key, x => x.Value);
 
-        IReadOnlyDictionary<string, FixedPoint2> damagePerType = damageable.Damage.DamageDict;
+        var damagePerType = damageable.Damage.DamageDict;
 
         DrawDiagnosticGroups(damageSortedGroups, damagePerType);
     }
@@ -153,7 +153,7 @@ private static string GetStatus(MobState mobState)
 
     private void DrawDiagnosticGroups(
         Dictionary<string, FixedPoint2> groups,
-        IReadOnlyDictionary<string, FixedPoint2> damageDict)
+        IReadOnlyDictionary<ProtoId<DamageTypePrototype>, FixedPoint2> damageDict)
     {
         GroupsContainer.RemoveAllChildren();
 

Content.IntegrationTests/Tests/Damageable/DamageSpecifierTest.cs

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
 using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
 using Content.Shared.FixedPoint;
+using Robust.Shared.Prototypes;
 
 namespace Content.IntegrationTests.Tests.Damageable;
 
@@ -39,51 +41,51 @@ public void TestDamageSpecifierOperations()
         Assert.That(difference, Is.EqualTo(output5));
     }
 
-    private static readonly Dictionary<string, FixedPoint2> Input1 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Input1 = new()
     {
         { "A", 1.5f },
         { "B", 2 },
         { "C", 3 }
     };
 
-    private static readonly Dictionary<string, FixedPoint2> Input2 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Input2 = new()
     {
         { "A", 1 },
         { "B", 2 },
         { "C", 5 },
         { "D", 0.05f }
     };
 
-    private static readonly Dictionary<string, FixedPoint2> Output1 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Output1 = new()
     {
         { "A", -1.5f },
         { "B", -2 },
         { "C", -3 }
     };
 
-    private static readonly Dictionary<string, FixedPoint2> Output2 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Output2 = new()
     {
         { "A", 0.75f },
         { "B", 1 },
         { "C", 1.5 }
     };
 
-    private static readonly Dictionary<string, FixedPoint2> Output3 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Output3 = new()
     {
         { "A", 3f },
         { "B", 4 },
         { "C", 6 }
     };
 
-    private static readonly Dictionary<string, FixedPoint2> Output4 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Output4 = new()
     {
         { "A", 0.5f },
         { "B", 0 },
         { "C", -2 },
         { "D", -0.05f }
     };
 
-    private static readonly Dictionary<string, FixedPoint2> Output5 = new()
+    private static readonly Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> Output5 = new()
     {
         { "A", 0.25f },
         { "B", 0 },

Content.IntegrationTests/Tests/Damageable/DamageableTest.cs

@@ -148,17 +148,6 @@ await server.WaitAssertion(() =>
             {
                 var uid = sDamageableEntity;
 
-                // Check that the correct types are supported.
-                Assert.Multiple(() =>
-                {
-                    Assert.That(sDamageableComponent.Damage.DamageDict.ContainsKey(type1.ID), Is.False);
-                    Assert.That(sDamageableComponent.Damage.DamageDict.ContainsKey(type2a.ID), Is.True);
-                    Assert.That(sDamageableComponent.Damage.DamageDict.ContainsKey(type2b.ID), Is.False);
-                    Assert.That(sDamageableComponent.Damage.DamageDict.ContainsKey(type3a.ID), Is.True);
-                    Assert.That(sDamageableComponent.Damage.DamageDict.ContainsKey(type3b.ID), Is.True);
-                    Assert.That(sDamageableComponent.Damage.DamageDict.ContainsKey(type3c.ID), Is.True);
-                });
-
                 // Check that damage is evenly distributed over a group if its a nice multiple
                 var types = group3.DamageTypes;
                 var damageToDeal = FixedPoint2.New(types.Count * 5);

Content.Server/Administration/Logs/Converters/DamageSpecifierConverter.cs

@@ -0,0 +1,20 @@
+using System.Text.Json;
+using Content.Shared.Damage;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+
+namespace Content.Server.Administration.Logs.Converters;
+
+[AdminLogConverter]
+public sealed class DamageSpecifierConverter : AdminLogConverter<DamageSpecifier>
+{
+    public override void Write(Utf8JsonWriter writer, DamageSpecifier value, JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+        foreach (var (damage, amount) in value.DamageDict)
+        {
+            writer.WriteNumber(damage.Id, amount.Double());
+        }
+        writer.WriteEndObject();
+    }
+}

Content.Shared/Atmos/Components/DeltaPressureComponent.cs

@@ -67,7 +67,7 @@ public sealed partial class DeltaPressureComponent : Component
     [DataField]
     public DamageSpecifier BaseDamage = new()
     {
-        DamageDict = new Dictionary<string, FixedPoint2>
+        DamageDict = new ()
         {
             { "Structural", 10 },
         },

Content.Shared/Changeling/Components/ChangelingDevourComponent.cs

@@ -99,7 +99,7 @@ public sealed partial class ChangelingDevourComponent : Component
     [DataField, AutoNetworkedField]
     public DamageSpecifier DamagePerTick = new()
     {
-        DamageDict = new Dictionary<string, FixedPoint2>
+        DamageDict = new ()
         {
             { "Slash", 10},
             { "Piercing", 10 },

Content.Shared/Cluwne/CluwneComponent.cs

@@ -26,7 +26,7 @@ public sealed partial class CluwneComponent : Component
     {
         DamageDict = new()
         {
-            { "Genetic", 300.0 },
+            { "Cellular", 300.0 },
         },
     };
 

Content.Shared/Damage/Components/DamageableComponent.cs

@@ -17,15 +17,15 @@ namespace Content.Shared.Damage.Components;
 ///     may also have resistances to certain damage types, defined via a <see cref="DamageModifierSetPrototype"/>.
 /// </remarks>
 [RegisterComponent]
-[NetworkedComponent]
+[NetworkedComponent, AutoGenerateComponentState(true)]
 [Access(typeof(DamageableSystem), Other = AccessPermissions.ReadExecute)]
 public sealed partial class DamageableComponent : Component
 {
     /// <summary>
     ///     This <see cref="DamageContainerPrototype"/> specifies what damage types are supported by this component.
     ///     If null, all damage types will be supported.
     /// </summary>
-    [DataField("damageContainer")]
+    [DataField("damageContainer"), AutoNetworkedField]
     // ReSharper disable once InconsistentNaming - This is wrong but fixing it is potentially annoying for downstreams.
     public ProtoId<DamageContainerPrototype>? DamageContainerID;
 
@@ -37,7 +37,7 @@ public sealed partial class DamageableComponent : Component
     ///     Though DamageModifierSets can be deserialized directly, we only want to use the prototype version here
     ///     to reduce duplication.
     /// </remarks>
-    [DataField("damageModifierSet")]
+    [DataField("damageModifierSet"), AutoNetworkedField]
     public ProtoId<DamageModifierSetPrototype>? DamageModifierSetId;
 
     /// <summary>
@@ -46,7 +46,7 @@ public sealed partial class DamageableComponent : Component
     /// <remarks>
     ///     If this data-field is specified, this allows damageable components to be initialized with non-zero damage.
     /// </remarks>
-    [DataField(readOnly: true)] //TODO FULL GAME SAVE
+    [DataField, AutoNetworkedField]
     public DamageSpecifier Damage = new();
 
     /// <summary>
@@ -87,20 +87,6 @@ public sealed partial class DamageableComponent : Component
     [DataField]
     public ProtoId<HealthIconPrototype> RottingIcon = "HealthIconRotting";
 
-    [DataField]
+    [DataField, AutoNetworkedField]
     public FixedPoint2? HealthBarThreshold;
 }
-
-[Serializable, NetSerializable]
-public sealed class DamageableComponentState(
-    Dictionary<string, FixedPoint2> damageDict,
-    ProtoId<DamageContainerPrototype>? damageContainerId,
-    ProtoId<DamageModifierSetPrototype>? modifierSetId,
-    FixedPoint2? healthBarThreshold)
-    : ComponentState
-{
-    public readonly Dictionary<string, FixedPoint2> DamageDict = damageDict;
-    public readonly ProtoId<DamageContainerPrototype>? DamageContainerId = damageContainerId;
-    public readonly ProtoId<DamageModifierSetPrototype>? ModifierSetId = modifierSetId;
-    public readonly FixedPoint2? HealthBarThreshold = healthBarThreshold;
-}

Content.Shared/Damage/DamageSpecifier.cs

@@ -3,11 +3,10 @@
 using Content.Shared.Damage.Components;
 using Content.Shared.Damage.Prototypes;
 using Content.Shared.FixedPoint;
-using JetBrains.Annotations;
 using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
 using Robust.Shared.Utility;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Generic;
 
 namespace Content.Shared.Damage
 {
@@ -19,31 +18,13 @@ namespace Content.Shared.Damage
     ///     functions to apply resistance sets and supports basic math operations to modify this dictionary.
     /// </remarks>
     [DataDefinition, Serializable, NetSerializable]
-    public sealed partial class DamageSpecifier : IEquatable<DamageSpecifier>
+    public sealed partial class DamageSpecifier : IEquatable<DamageSpecifier>, IRobustCloneable<DamageSpecifier>
     {
-        // For the record I regret so many of the decisions i made when rewriting damageable
-        // Why is it just shitting out dictionaries left and right
-        // One day Arrays, stackalloc spans, and SIMD will save the day.
-        // TODO DAMAGEABLE REFACTOR
-
-        // These exist solely so the wiki works. Please do not touch them or use them.
-        [JsonPropertyName("types")]
-        [DataField("types", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<FixedPoint2, DamageTypePrototype>))]
-        [UsedImplicitly]
-        private Dictionary<string, FixedPoint2>? _damageTypeDictionary;
-
-        [JsonPropertyName("groups")]
-        [DataField("groups", customTypeSerializer: typeof(PrototypeIdDictionarySerializer<FixedPoint2, DamageGroupPrototype>))]
-        [UsedImplicitly]
-        private Dictionary<string, FixedPoint2>? _damageGroupDictionary;
-
         /// <summary>
         ///     Main DamageSpecifier dictionary. Most DamageSpecifier functions exist to somehow modifying this.
         /// </summary>
-        [JsonIgnore]
-        [ViewVariables(VVAccess.ReadWrite)]
-        [IncludeDataField(customTypeSerializer: typeof(DamageSpecifierDictionarySerializer), readOnly: true)]
-        public Dictionary<string, FixedPoint2> DamageDict { get; set; } = new();
+        [DataField("types")]
+        public Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2> DamageDict { get; set; } = new();
 
         /// <summary>
         ///     Returns a sum of the damage values.
@@ -84,6 +65,11 @@ public bool AnyPositive()
         [JsonIgnore]
         public bool Empty => DamageDict.Count == 0;
 
+        public DamageSpecifier Clone()
+        {
+            return new DamageSpecifier(this);
+        }
+
         public override string ToString()
         {
             return "DamageSpecifier(" + string.Join("; ", DamageDict.Select(x => x.Key + ":" + x.Value)) + ")";