Initial changes for unserializing the total count of all child object…

…s for the object pool dictionaries optimization.
UnderminersTeam · Feb 1, 2023 · 0bc4fed · 0bc4fed
1 parent 735e2fc
commit 0bc4fed
Show file tree

Hide file tree

Showing 7 changed files with 361 additions and 9 deletions.
diff --git a/UndertaleModLib/Models/UndertaleGeneralInfo.cs b/UndertaleModLib/Models/UndertaleGeneralInfo.cs
@@ -451,6 +451,17 @@ public void Unserialize(UndertaleReader reader)
         reader.Bytecode14OrLower = BytecodeVersion <= 14;
     }
 
+    /// <inheritdoc cref="UndertaleObject.UnserializeChildObjectCount(UndertaleReader)"/>
+    public static uint UnserializeChildObjectCount(UndertaleReader reader)
+    {
+        reader.Position++;                            // "IsDebuggerDisabled"
+        bool readDebugPort = reader.ReadByte() >= 14; // "BytecodeVersion" >= 14
+        reader.Position += (uint)(122 + (readDebugPort ? 4 : 0));
+
+        // "RoomOrder"
+        return UndertaleSimpleResourcesList<UndertaleRoom, UndertaleChunkROOM>.UnserializeChildObjectCount(reader);
+    }
+
     /// <summary>
     /// Generates "info number" used for GMS2 UIDs.
     /// </summary>

diff --git a/UndertaleModLib/UndertaleBaseTypes.cs b/UndertaleModLib/UndertaleBaseTypes.cs
@@ -20,6 +20,18 @@ public interface UndertaleObject
         /// </summary>
         /// <param name="reader">Where to deserialize from.</param>
         void Unserialize(UndertaleReader reader);
+
+        /*
+         * As for C# 10, it's impossible to inherit static methods from an interface :(
+         * (so this method is for inheriting XML commentary only)
+         */
+        /// <summary>
+        /// Deserializes the total child object count of this object from specified <see cref="UndertaleReader"/>.
+        /// </summary>
+        /// <param name="reader">Where to deserialize from.</param>
+        /// <returns>The object count.</returns>
+        static uint UnserializeChildObjectCount(UndertaleReader reader) => 0;
+
     }
 
     public interface UndertaleObjectLenCheck : UndertaleObject
@@ -107,4 +119,9 @@ public interface ISearchable
         /// <paramref name="filter"/> is the empty string (""); otherwise, false.</returns>
         bool SearchMatches(string filter);
     }
+
+    public interface IStaticChildObjCount
+    {
+        public static readonly uint ChildObjectCount = 0;
+    }
 }
diff --git a/UndertaleModLib/UndertaleChunkTypes.cs b/UndertaleModLib/UndertaleChunkTypes.cs
@@ -17,6 +17,7 @@ public abstract class UndertaleChunk
 
         internal abstract void SerializeChunk(UndertaleWriter writer);
         internal abstract void UnserializeChunk(UndertaleReader reader);
+        internal abstract uint UnserializeObjectCount(UndertaleReader reader);
 
         public void Serialize(UndertaleWriter writer)
         {
@@ -79,7 +80,8 @@ public static UndertaleChunk Unserialize(UndertaleReader reader)
                 }
 
                 UndertaleChunk chunk = (UndertaleChunk)Activator.CreateInstance(type);
-                Util.DebugUtil.Assert(chunk.Name == name);
+                Util.DebugUtil.Assert(chunk.Name == name,
+                                      $"Chunk name mismatch: expected \"{name}\", got \"{chunk.Name}\".");
                 chunk.Length = length;
 
                 reader.SubmitMessage("Reading chunk " + chunk.Name);
@@ -124,6 +126,41 @@ public static UndertaleChunk Unserialize(UndertaleReader reader)
                 throw new UndertaleSerializationException(e.Message + "\nat " + reader.Position.ToString("X8") + " while reading chunk " + name, e);
             }
         }
+        public static uint CountChunkChildObjects(UndertaleReader reader)
+        {
+            string name = "(unknown)";
+            try
+            {
+                name = reader.ReadChars(4);
+                uint length = reader.ReadUInt32();
+
+                Type type = Type.GetType(typeof(UndertaleChunk).FullName + name);
+                if (type == null)
+                    throw new IOException("Unknown chunk " + name + "!!!");
+
+                UndertaleChunk chunk = (UndertaleChunk)Activator.CreateInstance(type);
+                Util.DebugUtil.Assert(chunk.Name == name,
+                                      $"Chunk name mismatch: expected \"{name}\", got \"{chunk.Name}\".");
+                chunk.Length = length;
+
+                uint chunkStart = reader.Position;
+
+                reader.SubmitMessage("Counting objects of chunk " + chunk.Name);
+                uint count = chunk.UnserializeObjectCount(reader);
+
+                reader.Position = chunkStart + chunk.Length;
+
+                return count;
+            }
+            catch (UndertaleSerializationException e)
+            {
+                throw new UndertaleSerializationException(e.Message + " in chunk " + name, e);
+            }
+            catch (Exception e)
+            {
+                throw new UndertaleSerializationException(e.Message + "\nat " + reader.Position.ToString("X8") + " while counting objects of chunk " + name, e);
+            }
+        }
     }
 
     public interface IUndertaleSingleChunk
@@ -156,6 +193,8 @@ internal override void UnserializeChunk(UndertaleReader reader)
             Object = reader.ReadUndertaleObject<T>();
         }
 
+        internal override uint UnserializeObjectCount(UndertaleReader reader) => 1;
+
         public UndertaleObject GetObject() => Object;
 
         public override string ToString()
@@ -179,6 +218,11 @@ internal override void UnserializeChunk(UndertaleReader reader)
             List.Unserialize(reader);
         }
 
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            return reader.ReadUInt32();
+        }
+
         public IList GetList() => List;
         public void GenerateIndexDict()
         {
@@ -256,6 +300,11 @@ internal override void UnserializeChunk(UndertaleReader reader)
             List.Unserialize(reader);
         }
 
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            return reader.ReadUInt32();
+        }
+
         public IList GetList() => List;
     }
 
@@ -268,5 +317,7 @@ internal override void SerializeChunk(UndertaleWriter writer)
         internal override void UnserializeChunk(UndertaleReader reader)
         {
         }
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader) => 0;
     }
 }
diff --git a/UndertaleModLib/UndertaleChunks.cs b/UndertaleModLib/UndertaleChunks.cs
@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Text;
 using System.Threading.Tasks;
 using UndertaleModLib.Models;
@@ -96,16 +97,45 @@ internal override void UnserializeChunk(UndertaleReader reader)
                 }
             }
         }
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            uint totalCount = 0;
+            uint startPos = reader.Position;
+
+            while (reader.Position < startPos + Length)
+                totalCount += reader.CountChunkChildObjects();
+
+            return totalCount;
+        }
     }
 
     public class UndertaleChunkGEN8 : UndertaleSingleChunk<UndertaleGeneralInfo>
     {
         public override string Name => "GEN8";
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            uint count = 1;
+
+            count += UndertaleGeneralInfo.UnserializeChildObjectCount(reader);
+
+            return count;
+        }
     }
 
     public class UndertaleChunkOPTN : UndertaleSingleChunk<UndertaleOptions>
     {
         public override string Name => "OPTN";
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            uint count = 1;
+
+            count += reader.GetChildObjectCount<UndertaleOptions>();
+
+            return count;
+        }
     }
 
     public class UndertaleChunkLANG : UndertaleSingleChunk<UndertaleLanguage>
@@ -655,6 +685,12 @@ internal override void UnserializeChunk(UndertaleReader reader)
             while (reader.Position + varLength <= startPosition + Length)
                 List.Add(reader.ReadUndertaleObject<UndertaleVariable>());
         }
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            int varLength = reader.Bytecode14OrLower ? 12 : 20;
+            return Length / (uint)varLength;
+        }
     }
 
     public class UndertaleChunkFUNC : UndertaleChunk
@@ -698,6 +734,7 @@ internal override void UnserializeChunk(UndertaleReader reader)
             {
                 uint startPosition = reader.Position;
                 Functions.Clear();
+                Functions.SetCapacity(Length / 12);
                 while (reader.Position + 12 <= startPosition + Length)
                     Functions.Add(reader.ReadUndertaleObject<UndertaleFunction>());
             }
@@ -707,6 +744,21 @@ internal override void UnserializeChunk(UndertaleReader reader)
                 CodeLocals = reader.ReadUndertaleObject<UndertaleSimpleList<UndertaleCodeLocals>>();
             }
         }
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            uint count = 0;
+
+            if (!reader.Bytecode14OrLower)
+            {
+                count += reader.GetChildObjectCount<UndertaleSimpleList<UndertaleFunction>>();
+                count += reader.GetChildObjectCount<UndertaleSimpleList<UndertaleCodeLocals>>();
+            }
+            else
+                count = Length / 12;
+
+            return count;
+        }
     }
 
     public class UndertaleChunkSTRG : UndertaleAlignUpdatedListChunk<UndertaleString>

diff --git a/UndertaleModLib/UndertaleDebugChunks.cs b/UndertaleModLib/UndertaleDebugChunks.cs
@@ -44,6 +44,11 @@ internal override void UnserializeChunk(UndertaleReader reader)
                 }
             }
         }
+
+        internal override uint UnserializeObjectCount(UndertaleReader reader)
+        {
+            throw new NotImplementedException();
+        }
     }
 
     public class UndertaleDebugChunkSCPT : UndertaleListChunk<UndertaleScriptSource>
-Original file line number
+Diff line change
@@ Expand Up @@
                     }
                 }
             }
+            internal override uint UnserializeObjectCount(UndertaleReader reader)
+            {
+                throw new NotImplementedException();
+            }
         }
         public class UndertaleDebugChunkSCPT : UndertaleListChunk<UndertaleScriptSource>
@@ Expand Down @@