removes beforeserialization hook (#12319)

Content.Server/Atmos/Serialization/TileAtmosCollectionSerializer.cs

@@ -0,0 +1,89 @@
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Validation;
+using Robust.Shared.Serialization.TypeSerializers.Interfaces;
+
+namespace Content.Server.Atmos.Serialization;
+
+public sealed class TileAtmosCollectionSerializer : ITypeSerializer<Dictionary<Vector2i, TileAtmosphere>, MappingDataNode>
+{
+    public ValidationNode Validate(ISerializationManager serializationManager, MappingDataNode node,
+        IDependencyCollection dependencies, ISerializationContext? context = null)
+    {
+        return serializationManager.ValidateNode<TileAtmosData>(node, context);
+    }
+
+    public Dictionary<Vector2i, TileAtmosphere> Read(ISerializationManager serializationManager, MappingDataNode node, IDependencyCollection dependencies,
+        bool skipHook, ISerializationContext? context = null, Dictionary<Vector2i, TileAtmosphere>? value = default)
+    {
+        var data = serializationManager.Read<TileAtmosData>(node, context, skipHook);
+        var tiles = new Dictionary<Vector2i, TileAtmosphere>();
+        if (data.TilesUniqueMixes != null)
+        {
+            foreach (var (indices, mix) in data.TilesUniqueMixes)
+            {
+                try
+                {
+                    tiles.Add(indices, new TileAtmosphere(EntityUid.Invalid, indices,
+                        data.UniqueMixes![mix].Clone()));
+                }
+                catch (ArgumentOutOfRangeException)
+                {
+                    Logger.Error(
+                        $"Error during atmos serialization! Tile at {indices} points to an unique mix ({mix}) out of range!");
+                }
+            }
+        }
+
+        return tiles;
+    }
+
+    public DataNode Write(ISerializationManager serializationManager, Dictionary<Vector2i, TileAtmosphere> value, IDependencyCollection dependencies,
+        bool alwaysWrite = false, ISerializationContext? context = null)
+    {
+        var uniqueMixes = new List<GasMixture>();
+        var uniqueMixHash = new Dictionary<GasMixture, int>();
+        var tiles = new Dictionary<Vector2i, int>();
+
+        foreach (var (indices, tile) in value)
+        {
+            if (tile.Air == null) continue;
+
+            if (uniqueMixHash.TryGetValue(tile.Air, out var index))
+            {
+                tiles[indices] = index;
+                continue;
+            }
+
+            uniqueMixes.Add(tile.Air);
+            var newIndex = uniqueMixes.Count - 1;
+            uniqueMixHash[tile.Air] = newIndex;
+            tiles[indices] = newIndex;
+        }
+
+        if (uniqueMixes.Count == 0) uniqueMixes = null;
+        if (tiles.Count == 0) tiles = null;
+
+        return serializationManager.WriteValue(new TileAtmosData
+        {
+            UniqueMixes = uniqueMixes,
+            TilesUniqueMixes = tiles
+        }, alwaysWrite, context);
+    }
+
+    public Dictionary<Vector2i, TileAtmosphere> Copy(ISerializationManager serializationManager, Dictionary<Vector2i, TileAtmosphere> source, Dictionary<Vector2i, TileAtmosphere> target, bool skipHook,
+        ISerializationContext? context = null)
+    {
+        serializationManager.Copy(source, ref target, context, skipHook);
+        return target;
+    }
+
+    [DataDefinition]
+    private struct TileAtmosData
+    {
+        [DataField("uniqueMixes")] public List<GasMixture>? UniqueMixes;
+
+        [DataField("tiles")] public Dictionary<Vector2i, int>? TilesUniqueMixes;
+    }
+}