check if datacore has changed since last codegen and throw

src/StarBreaker.Common/Utilities/TimeLogger.cs

@@ -11,15 +11,13 @@ public TimeLogger()
         timestamp = Stopwatch.GetTimestamp();
     }
 
-    [Conditional("DEBUG")]
     public void LogReset(string message)
     {
         var elapsed = Stopwatch.GetElapsedTime(timestamp);
         Console.WriteLine($"{message}: {elapsed.TotalMilliseconds}ms");
         timestamp = Stopwatch.GetTimestamp();
     }
 
-    [Conditional("DEBUG")]
     public void LogContinue(string message)
     {
         var elapsed = Stopwatch.GetElapsedTime(timestamp);

src/StarBreaker.DataCore.Generated/DataCoreBinaryGenerated.cs

@@ -1,16 +1,27 @@
-using StarBreaker.Common;
+using System.Diagnostics;
+using StarBreaker.Common;
 using StarBreaker.DataCore;
 
 namespace StarBreaker.DataCoreGenerated;
 
-//TODO: come up with a way of hashing the types we generated, then verify that the datacore file we're reading matches the types we have.
-// if they don't match we *WILL* fail to read it. We should throw before this.
 public sealed partial class DataCoreBinaryGenerated : IDataCoreBinary<DataCoreTypedRecord>
 {
     public DataCoreDatabase Database { get; }
 
     public DataCoreBinaryGenerated(DataCoreDatabase database)
     {
+        if (DataCoreConstants.StructCount != database.StructDefinitions.Length)
+            throw new InvalidOperationException($"DataCoreBinaryGenerated: Struct count mismatch. Expected {DataCoreConstants.StructCount}, got {database.StructDefinitions.Length}");
+
+        if (DataCoreConstants.EnumCount != database.EnumDefinitions.Length)
+            throw new InvalidOperationException($"DataCoreBinaryGenerated: Enum count mismatch. Expected {DataCoreConstants.EnumCount}, got {database.EnumDefinitions.Length}");
+
+        if (DataCoreConstants.StructsHash != database.StructsHash)
+            throw new InvalidOperationException($"DataCoreBinaryGenerated: Structs hash mismatch. Expected {DataCoreConstants.StructsHash}, got {database.StructsHash}");
+
+        if (DataCoreConstants.EnumsHash != database.EnumsHash)
+            throw new InvalidOperationException($"DataCoreBinaryGenerated: Enums hash mismatch. Expected {DataCoreConstants.EnumsHash}, got {database.EnumsHash}");
+
         Database = database;
     }
 
@@ -58,14 +69,13 @@ public void SaveToFile(DataCoreRecord record, string path)
     public T EnumParse<T>(DataCoreStringId stringId, T unknown) where T : struct, Enum
     {
         var value = stringId.ToString(Database);
-        
+
         if (value == "")
             return unknown;
 
         if (!Enum.TryParse<T>(value, out var eVal))
         {
-            var type = typeof(T);
-            Console.WriteLine($"Error parsing Enum of type {type.Name} with value {value}. Setting to unknown.");
+            Debug.WriteLine($"Error parsing Enum of type {typeof(T).Name} with value {value}. Setting to unknown.");
             return unknown;
         }
 

src/StarBreaker.DataCore.TypeGenerator/DataCoreCodeGenerator.cs

@@ -21,6 +21,7 @@ public void Generate(string path)
         GenerateTypes(path);
         GenerateEnums(path);
         GenerateTypeMap(path);
+        GenerateConstantsFile(path);
     }
 
     private void GenerateTypeMap(string path)
@@ -386,4 +387,20 @@ private void WriteArrayRead(StringBuilder sb, DataCorePropertyDefinition propert
                 throw new ArgumentOutOfRangeException();
         }
     }
+
+    private void GenerateConstantsFile(string path)
+    {
+        var sb = new StringBuilder();
+        sb.AppendLine("namespace StarBreaker.DataCoreGenerated;");
+        sb.AppendLine();
+        sb.AppendLine("public static class DataCoreConstants");
+        sb.AppendLine("{");
+        sb.AppendLine($"    public const int StructCount = {Database.StructDefinitions.Length};");
+        sb.AppendLine($"    public const int EnumCount = {Database.EnumDefinitions.Length};");
+        sb.AppendLine($"    public const int StructsHash = {Database.StructsHash};");
+        sb.AppendLine($"    public const int EnumsHash = {Database.EnumsHash};");
+        sb.AppendLine("}");
+
+        File.WriteAllText(Path.Combine(path, "Constants.cs"), sb.ToString());
+    }
 }

src/StarBreaker.DataCore/DataCoreDatabase.cs

@@ -47,6 +47,10 @@ public sealed class DataCoreDatabase
     private readonly FrozenDictionary<int, string> CachedStrings2;
     private readonly FrozenDictionary<CigGuid, DataCoreRecord> RecordMap;
 
+    public int StructsHash => StructDefinitions.Sum(x => x.FirstAttributeIndex ^ x.AttributeCount);
+
+    public int EnumsHash => EnumDefinitions.Sum(x => x.FirstValueIndex ^ x.ValueCount);
+
     public DataCoreDatabase(Stream fs)
     {
         using var reader = new BinaryReader(fs);

src/StarBreaker.Sandbox/DataCoreSandbox.cs

@@ -53,7 +53,8 @@ private static void ExtractGenerated()
 
         var allRecords = df.DataCore.Database.MainRecords
             .AsParallel()
-            .Select(x => df.GetFromRecord(x)).ToList();
+            .Select(x => df.GetFromRecord(x))
+            .ToList();
         timer.LogReset("Extracted all records.");
 
         var classDefinitions = allRecords.Where(r => r.Data is EntityClassDefinition).Select(r => r.Data as EntityClassDefinition).ToList();