Merge Feature-DNF

README.md

@@ -68,6 +68,7 @@ This is a table of games that are confirmed to be compatible with the current st
 | Bioshock 2 | Vengeance | 143/059 | |
 | Unreal Championship 2: Liandri Conflict | 3323 | 151/002 | (Third-party) <https://forums.beyondunreal.com/threads/unreal-championship-2-script-decompiler-release.206036/> |
 | The Chronicles of Spellborn | Unknown | 159/029 | |
+| Duke Nukem Forever (2011) | Unknown | 156/036 | [Extraction is required](https://github.com/DaZombieKiller/MegaPackageExtractor) |
 |     |     |     |     |
 |     |     |     |     |
 | Roboblitz | 2306 | 369/006 |     |

src/Branch/UE2/DNF/Tokens/BreakpointToken.cs

@@ -0,0 +1,15 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class BreakpointToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            // TODO:
+            Decompiler.PreComment = "// Breakpoint";
+            Decompiler.MarkSemicolon();
+            return "@UnknownSyntax";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/DynamicArrayEmptyToken.cs

@@ -0,0 +1,19 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class DynamicArrayEmptyToken : UStruct.UByteCodeDecompiler.DynamicArrayMethodToken
+    {
+        public override void Deserialize(IUnrealStream stream)
+        {
+            // Array
+            DeserializeNext();
+        }
+
+        public override string Decompile()
+        {
+            Decompiler.MarkSemicolon();
+            return $"{DecompileNext()}.Empty()";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/IntConstWordToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class IntConstWordToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public ushort Value;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Value = stream.ReadUInt16();
+            Decompiler.AlignSize(sizeof(ushort));
+        }
+
+        public override string Decompile()
+        {
+            return PropertyDisplay.FormatLiteral(Value);
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/RotConstBytesToken.cs

@@ -0,0 +1,18 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstBytesToken : UStruct.UByteCodeDecompiler.RotationConstToken
+    {
+        public override void Deserialize(IUnrealStream stream)
+        {
+            // FIXME: These must have been compressed right?
+            Value.Pitch = stream.ReadByte(); 
+            Decompiler.AlignSize(sizeof(byte));
+            Value.Roll = stream.ReadByte(); 
+            Decompiler.AlignSize(sizeof(byte));
+            Value.Yaw = stream.ReadByte(); 
+            Decompiler.AlignSize(sizeof(byte));
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/RotConstPitchToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstPitchToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public int Pitch;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Pitch = stream.ReadInt32();
+            Decompiler.AlignSize(sizeof(int));
+        }
+
+        public override string Decompile()
+        {
+            return $"rotpitch({PropertyDisplay.FormatLiteral(Pitch)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/RotConstRollToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstRollToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public int Roll;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Roll = stream.ReadInt32();
+            Decompiler.AlignSize(sizeof(int));
+        }
+
+        public override string Decompile()
+        {
+            return $"rotroll({PropertyDisplay.FormatLiteral(Roll)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/RotConstYawToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstYawToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public int Yaw;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Yaw = stream.ReadInt32();
+            Decompiler.AlignSize(sizeof(int));
+        }
+
+        public override string Decompile()
+        {
+            return $"rotyaw({PropertyDisplay.FormatLiteral(Yaw)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/RotConstZeroToken.cs

@@ -0,0 +1,12 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class RotConstZeroToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            return "rot(0, 0, 0)";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorConstUnitZToken.cs

@@ -0,0 +1,13 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorConstUnitZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            // TODO
+            return "@UnknownSyntax";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorConstZeroToken.cs

@@ -0,0 +1,12 @@
+using UELib.Core;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorConstZeroToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public override string Decompile()
+        {
+            return "vect(0, 0, 0)";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorXToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorXToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float X;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            X = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectx({PropertyDisplay.FormatLiteral(X)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorXYToken.cs

@@ -0,0 +1,24 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorXYToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float X, Y;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            X = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+
+            Y = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectxy({PropertyDisplay.FormatLiteral(X)}, {PropertyDisplay.FormatLiteral(Y)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorXZToken.cs

@@ -0,0 +1,24 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorXZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float X, Z;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            X = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+
+            Z = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectxz({PropertyDisplay.FormatLiteral(X)}, {PropertyDisplay.FormatLiteral(Z)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorYToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorYToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float Y;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Y = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vecty({PropertyDisplay.FormatLiteral(Y)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorYZToken.cs

@@ -0,0 +1,24 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorYZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float Y, Z;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Y = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+
+            Z = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectyz({PropertyDisplay.FormatLiteral(Y)}, {PropertyDisplay.FormatLiteral(Z)})";
+        }
+    }
+}

src/Branch/UE2/DNF/Tokens/VectorZToken.cs

@@ -0,0 +1,21 @@
+using UELib.Core;
+using UELib.UnrealScript;
+
+namespace UELib.Branch.UE2.DNF.Tokens
+{
+    public class VectorZToken : UStruct.UByteCodeDecompiler.Token
+    {
+        public float Z;
+
+        public override void Deserialize(IUnrealStream stream)
+        {
+            Z = stream.ReadFloat();
+            Decompiler.AlignSize(sizeof(float));
+        }
+
+        public override string Decompile()
+        {
+            return $"vectz({PropertyDisplay.FormatLiteral(Z)})";
+        }
+    }
+}