Merge pull request #103 from EDITzDev/huxley

EliotVU · web-flow · commit 8f7037981cc1 · 2025-03-03T18:19:56.000+01:00
Huxley Support
diff --git a/src/Branch/PackageObjectLegacyVersion.cs b/src/Branch/PackageObjectLegacyVersion.cs
@@ -228,11 +228,12 @@ public enum PackageObjectLegacyVersion
         IsModificationAddedToStructMember = GameFFOW,
 
         [Discardable] GameGOWPC = 490,
+        [Discardable] GameHuxley = 496,
 
         /// <summary>
-        ///     FIXME: Version, not attested in (GoW v490)
+        ///     FIXME: Version, not attested in (Huxley v496)
         /// </summary>
-        SkipSizeAddedToArrayTokenIntrinsics = GameGOWPC + 1,
+        SkipSizeAddedToArrayTokenIntrinsics = GameHuxley + 1,
 
         VerticalOffsetAddedToUFont = 506,
         CleanupFonts = 511,
diff --git a/src/Branch/UE3/HUXLEY/CryptoDecoderHuxley.cs b/src/Branch/UE3/HUXLEY/CryptoDecoderHuxley.cs
@@ -0,0 +1,48 @@
+﻿using UELib.Decoding;
+
+namespace UELib.Branch.UE3.HUXLEY
+{
+    public class CryptoDecoderHuxley : IBufferDecoder
+    {
+        private readonly uint _Key;
+
+        public CryptoDecoderHuxley(string name)
+        {
+            for (int i = 0; i < name.Length; i++)
+            {
+                _Key *= 16;
+                _Key ^= name[i];
+            }
+        }
+
+        public CryptoDecoderHuxley(uint key) => _Key = key;
+
+        public void PreDecode(IUnrealStream stream)
+        {
+        }
+
+        public void DecodeBuild(IUnrealStream stream, UnrealPackage.GameBuild build)
+        {
+        }
+
+        public void DecodeRead(long position, byte[] buffer, int index, int count)
+        {
+            for (int i = index; i + 4 <= count; i += 4)
+            {
+                for (int j = 0; j < 4; j++)
+                {
+                    buffer[i + j] = (byte)((_Key >> (j * 8)) ^ buffer[i + j]);
+                }
+
+                for (int j = 0; j < 4; j++)
+                {
+                    buffer[i + j] = (byte)((count >> (j * 8)) ^ buffer[i + j]);
+                }
+            }
+        }
+
+        public unsafe void DecodeByte(long position, byte* b)
+        {
+        }
+    }
+}
diff --git a/src/Branch/UE3/HUXLEY/EngineBranchHuxley.cs b/src/Branch/UE3/HUXLEY/EngineBranchHuxley.cs
@@ -0,0 +1,31 @@
+﻿using System;
+
+using UELib.Core;
+
+namespace UELib.Branch.UE3.HUXLEY
+{
+    public class EngineBranchHuxley : DefaultEngineBranch
+    {
+        [Flags]
+        public enum PackageFlags : uint
+        {
+            UseCrypt = 0x8000000
+        }
+
+        public EngineBranchHuxley(BuildGeneration generation) : base(generation)
+        {
+        }
+
+        public override void PostDeserializeSummary(UnrealPackage linker, IUnrealStream stream, ref UnrealPackage.PackageFileSummary summary)
+        {
+            base.PostDeserializeSummary(linker, stream, ref summary);
+
+            if (summary.PackageFlags.HasFlags((uint)PackageFlags.UseCrypt))
+            {
+                stream.Decoder = linker.Summary.LicenseeVersion >= 23
+                    ? new CryptoDecoderHuxley(linker.PackageName)
+                    : new CryptoDecoderHuxley(linker.Summary.Guid.A);
+            }
+        }
+    }
+}
diff --git a/src/Core/Classes/Props/UProperty.cs b/src/Core/Classes/Props/UProperty.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Diagnostics.Contracts;
 using UELib.Annotations;
 using UELib.Branch;
 using UELib.Flags;
@@ -223,6 +224,14 @@ protected override void Deserialize()
                 RepOffset = _Buffer.ReadUShort();
                 Record(nameof(RepOffset), RepOffset);
             }
+#if HUXLEY
+            if (Package.Build == UnrealPackage.GameBuild.BuildName.Huxley)
+            {
+                // A property linked to the "Core.Object.LazyLoadPropertyInfo" struct.
+                var partLoadInfoProperty = _Buffer.ReadObject();
+                Record(nameof(partLoadInfoProperty), partLoadInfoProperty);
+            }
+#endif
 #if R6
             if (Package.Build == UnrealPackage.GameBuild.BuildName.R6Vegas)
             {
diff --git a/src/Core/Classes/UObject.cs b/src/Core/Classes/UObject.cs
@@ -187,17 +187,42 @@ public void BeginDeserializing()
 
         private void InitBuffer()
         {
-            Package.Stream.Seek(ExportTable.SerialOffset, SeekOrigin.Begin);
+            InitBuffer(Package.Stream);
+        }
+
+        private void InitBuffer(UPackageStream stream)
+        {
+            long objectOffset = ExportTable.SerialOffset;
+            int objectSize = ExportTable.SerialSize;
 
-            //Console.WriteLine( "Init buffer for {0}", (string)this );
-            var buffer = new byte[ExportTable.SerialSize];
-            _Buffer = new UObjectRecordStream(Package.Stream, buffer);
+            byte[] buffer = new byte[objectSize];
+            int byteCount;
+
+            // Make an object stream with a decoder as the base stream.
+            if (stream.Decoder != null)
+            {
+                var decoder = stream.Decoder;
+                // Read without decoding, because the encryption may be affected by the read count. e.g. "Huxley"
+                stream.Decoder = null;
+                // Bypass the terrible and slow endian reverse call
+                stream.Seek(objectOffset, SeekOrigin.Begin);
+                byteCount = stream.EndianAgnosticRead(buffer, 0, objectSize);
+                stream.Decoder = decoder;
+
+                var baseStream = new MemoryDecoderStream(stream.Decoder, buffer, objectOffset);
+                _Buffer = new UObjectRecordStream(stream, baseStream);
+            }
+            else
+            {
+                // Bypass the terrible and slow endian reverse call
+                stream.Seek(objectOffset, SeekOrigin.Begin);
+                byteCount = stream.EndianAgnosticRead(buffer, 0, objectSize);
+
+                _Buffer = new UObjectRecordStream(stream, buffer);
+            }
 
-            // Bypass the terrible and slow endian reverse call
-            int read = Package.Stream.EndianAgnosticRead(buffer, 0, ExportTable.SerialSize);
-            Contract.Assert(ExportTable.SerialOffset + ExportTable.SerialSize <= Package.Stream.Length,
-                "Exceeded file's length");
-            //Debug.Assert(read == ExportTable.SerialSize, $"Incomplete read; expected a total bytes of {ExportTable.SerialSize} but got {read}");
+            Contract.Assert(byteCount == objectSize,
+                $"Incomplete read; expected a total bytes of {objectSize} but got {byteCount}");
         }
 
         internal void EnsureBuffer()
@@ -216,7 +241,7 @@ internal void MaybeDisposeBuffer()
             if (_Buffer == null || (DeserializationState & ObjectState.Deserializing) != 0)
                 return;
 
-            _Buffer.DisposeBuffer();
+            _Buffer.Dispose();
             _Buffer = null;
             //Console.WriteLine( "Disposed" );
         }
diff --git a/src/Core/Tables/UExportTableItem.cs b/src/Core/Tables/UExportTableItem.cs
@@ -217,6 +217,15 @@ public void Deserialize(IUnrealStream stream)
             {
                 stream.Skip(sizeof(int));
             }
+#endif
+#if HUXLEY
+            if (stream.Package.Build == UnrealPackage.GameBuild.BuildName.Huxley)
+            {
+                if (stream.LicenseeVersion >= 22)
+                {
+                    int SerialSize2 = stream.ReadInt32();
+                }
+            }
 #endif
             if (stream.Version >= (uint)PackageObjectLegacyVersion.AddedComponentMapToExports &&
                 stream.Version < (uint)PackageObjectLegacyVersion.ComponentMapDeprecated
@@ -286,7 +295,11 @@ public void Deserialize(IUnrealStream stream)
             }
 #endif
             stream.Skip(16); // Package guid
+#if HUXLEY
+            if (stream.Version >= 475)
+#else
             if (stream.Version > 486) // 475?  486(> Stargate Worlds)
+#endif
             {
                 stream.Skip(4); // Package flags
             }
diff --git a/src/Core/Tables/UObjectTableItem.cs b/src/Core/Tables/UObjectTableItem.cs
@@ -104,13 +104,9 @@ public static string GetReferencePath([CanBeNull] UObjectTableItem item)
 
         public virtual byte[] CopyBuffer()
         {
-            var buff = new byte[Size];
+            byte[] buff = new byte[Size];
             Owner.Stream.Seek(Offset, SeekOrigin.Begin);
-            Owner.Stream.Read(buff, 0, Size);
-            if (Owner.Stream.BigEndianCode)
-            {
-                Array.Reverse(buff);
-            }
+            Owner.Stream.EndianAgnosticRead(buff, 0, Size);
 
             return buff;
         }
diff --git a/src/Eliot.UELib.csproj b/src/Eliot.UELib.csproj
@@ -1,6 +1,6 @@
-<Project Sdk="Microsoft.NET.Sdk">
+﻿<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <DefineConstants>DECOMPILE;BINARYMETADATA;UE1;UE2;UE3;UE4;VENGEANCE;SWAT4;UNREAL2;INFINITYBLADE;BORDERLANDS2;GOW2;APB;SPECIALFORCE2;XIII;SINGULARITY;THIEF_DS;DEUSEX_IW;BORDERLANDS;MIRRORSEDGE;BIOSHOCK;HAWKEN;UT;DISHONORED;REMEMBERME;ALPHAPROTOCOL;VANGUARD;TERA;MKKE;TRANSFORMERS;XCOM2;DD2;DCUO;AA2;SPELLBORN;BATMAN;MOH;ROCKETLEAGUE;DNF;LSGAME;UNDYING;HP;DEVASTATION;BATTLEBORN;SPLINTERCELLX;AHIT;GIGANTIC;ENDWAR;SG1;MASS_EFFECT;MOV;MIDWAY;SHADOWSTRIKE;R6</DefineConstants>
+    <DefineConstants>DECOMPILE;BINARYMETADATA;UE1;UE2;UE3;UE4;VENGEANCE;SWAT4;UNREAL2;INFINITYBLADE;BORDERLANDS2;GOW2;APB;SPECIALFORCE2;XIII;SINGULARITY;THIEF_DS;DEUSEX_IW;BORDERLANDS;MIRRORSEDGE;BIOSHOCK;HAWKEN;UT;DISHONORED;REMEMBERME;ALPHAPROTOCOL;VANGUARD;TERA;MKKE;TRANSFORMERS;XCOM2;DD2;DCUO;AA2;SPELLBORN;BATMAN;MOH;ROCKETLEAGUE;DNF;LSGAME;UNDYING;HP;DEVASTATION;BATTLEBORN;SPLINTERCELLX;AHIT;GIGANTIC;ENDWAR;SG1;MASS_EFFECT;MOV;MIDWAY;SHADOWSTRIKE;R6;HUXLEY</DefineConstants>
     <TargetFrameworks>net48;netstandard2.0;netstandard2.1;net8.0</TargetFrameworks>
     <LangVersion>12.0</LangVersion>
     <OutputType>Library</OutputType>
diff --git a/src/UnrealPackage.cs b/src/UnrealPackage.cs
@@ -14,6 +14,7 @@
 using UELib.Branch.UE3.APB;
 using UELib.Branch.UE3.DD2;
 using UELib.Branch.UE3.GIGANTIC;
+using UELib.Branch.UE3.HUXLEY;
 using UELib.Branch.UE3.MOH;
 using UELib.Branch.UE3.R6;
 using UELib.Branch.UE3.RSS;
@@ -456,6 +457,15 @@ public enum BuildName
                 /// </summary>
                 [Build(490, 9)] GoW1,
 
+                /// <summary>
+                /// Huxley
+                /// 
+                /// 496/023
+                /// </summary>
+                [Build(496, 23)]
+                [BuildEngineBranch(typeof(EngineBranchHuxley))]
+                Huxley,
+
                 [Build(511, 039, BuildGeneration.HMS)] // The Bourne Conspiracy
                 [Build(511, 145, BuildGeneration.HMS)] // Transformers: War for Cybertron (PC version)
                 [Build(511, 144, BuildGeneration.HMS)]
@@ -1247,6 +1257,21 @@ public void Deserialize(IUnrealStream stream)
 
                     stream.Skip(4);
                 }
+#endif
+#if HUXLEY
+                if (stream.Package.Build == GameBuild.BuildName.Huxley)
+                {
+                    if (LicenseeVersion >= 8)
+                    {
+                        int huxleySignature = stream.ReadInt32();
+                        Contract.Assert(huxleySignature != 0xFEFEFEFE, "[HUXLEY] Invalid Signature!");
+                    }
+
+                    if (LicenseeVersion >= 17)
+                    {
+                        int unk = stream.ReadInt32();
+                    }
+                }
 #endif
                 if (stream.Version >= VHeaderSize)
                 {
@@ -2560,10 +2585,9 @@ public bool ContainsEditorData()
 
         public byte[] CopyBuffer()
         {
-            var buff = new byte[HeaderSize];
+            byte[] buff = new byte[Summary.HeaderSize];
             Stream.Seek(0, SeekOrigin.Begin);
-            Stream.Read(buff, 0, HeaderSize);
-            if (Stream.BigEndianCode) Array.Reverse(buff);
+            Stream.EndianAgnosticRead(buff, 0, Summary.HeaderSize);
 
             return buff;
         }
diff --git a/src/UnrealStream.cs b/src/UnrealStream.cs

Original file line number	Diff line number	Diff line change
`@@ -217,6 +217,15 @@ public void Deserialize(IUnrealStream stream)`
`217`	`217`	`{`
`218`	`218`	`stream.Skip(sizeof(int));`
`219`	`219`	`}`
	`220`	`+#endif`
	`221`	`+#if HUXLEY`
	`222`	`+ if (stream.Package.Build == UnrealPackage.GameBuild.BuildName.Huxley)`
	`223`	`+ {`
	`224`	`+ if (stream.LicenseeVersion >= 22)`
	`225`	`+ {`
	`226`	`+ int SerialSize2 = stream.ReadInt32();`
	`227`	`+ }`
	`228`	`+ }`
`220`	`229`	`#endif`
`221`	`230`	`if (stream.Version >= (uint)PackageObjectLegacyVersion.AddedComponentMapToExports &&`
`222`	`231`	`stream.Version < (uint)PackageObjectLegacyVersion.ComponentMapDeprecated`
`@@ -286,7 +295,11 @@ public void Deserialize(IUnrealStream stream)`
`286`	`295`	`}`
`287`	`296`	`#endif`
`288`	`297`	`stream.Skip(16); // Package guid`
	`298`	`+#if HUXLEY`
	`299`	`+ if (stream.Version >= 475)`
	`300`	`+#else`
`289`	`301`	`if (stream.Version > 486) // 475? 486(> Stargate Worlds)`
	`302`	`+#endif`
`290`	`303`	`{`
`291`	`304`	`stream.Skip(4); // Package flags`
`292`	`305`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,13 +104,9 @@ public static string GetReferencePath([CanBeNull] UObjectTableItem item)`
`104`	`104`
`105`	`105`	`public virtual byte[] CopyBuffer()`
`106`	`106`	`{`
`107`		`- var buff = new byte[Size];`
	`107`	`+ byte[] buff = new byte[Size];`
`108`	`108`	`Owner.Stream.Seek(Offset, SeekOrigin.Begin);`
`109`		`- Owner.Stream.Read(buff, 0, Size);`
`110`		`- if (Owner.Stream.BigEndianCode)`
`111`		`- {`
`112`		`- Array.Reverse(buff);`
`113`		`- }`
	`109`	`+ Owner.Stream.EndianAgnosticRead(buff, 0, Size);`
`114`	`110`
`115`	`111`	`return buff;`
`116`	`112`	`}`