267 fix new input system compatibility

CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 # [Unreleased]
 
+## Changed
+
+### Performance
+
+- Loading should be faster if you've opened the game before
+
 ## Fixed
 
 ### Games
@@ -16,12 +22,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### General
 
 - Fixed TAS rendering popping up command prompt probably
+- Fixed music overlaying on each other every restart
 
 ### Compatibility
 
 - Fixed accidentally skipping over static constructors
 - Fixed accidentally skipping over removing some readonly fields
 - Fixed crash when trying to remove readonly fields
+- Fixed sometimes UniTAS not receiving the first update, which might cause some movie desync by 1 frame
 
 ## Changed
 

UniTAS/Patcher.Tests/Patcher.Tests.csproj

@@ -9,6 +9,8 @@
         </RestoreAdditionalProjectSources>
 
         <IsPackable>false</IsPackable>
+
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">

UniTAS/Patcher.Tests/Utils/DeepCopyTests.TestTypes.cs

@@ -16,7 +16,7 @@ private class SimpleType
         public static bool ThisShouldBeIgnored;
 
         [SuppressMessage("ReSharper", "UnusedMember.Local")]
-        private const int ThisShouldBeIgnoredToo = 42;
+        private const int THIS_SHOULD_BE_IGNORED_TOO = 42;
     }
 
     private enum TestEnum
@@ -53,4 +53,29 @@ private class DictionaryType
         public Dictionary<int, string> IntStringDictionary;
         public Dictionary<string, int> StringIntDictionary;
     }
+
+    private class SelfReferencing1
+    {
+        public SelfReferencing2 Nested;
+    }
+
+    private class SelfReferencing2
+    {
+        public SelfReferencing1 Nested;
+    }
+
+    private class SelfReferencing3
+    {
+        public SelfReferencing4 Nested;
+    }
+
+    private class SelfReferencing4
+    {
+        public List<SelfReferencing3> Nested;
+    }
+
+    private class PointerType
+    {
+        public unsafe void* Pointer;
+    }
 }

UniTAS/Patcher.Tests/Utils/DeepCopyTests.cs

@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using UniTAS.Patcher.Utils;
 
 namespace Patcher.Tests.Utils;
@@ -145,4 +147,58 @@ public void DictionaryTypeTest()
         Assert.Equal(source.IntStringDictionary, result!.IntStringDictionary);
         Assert.Equal(source.StringIntDictionary, result.StringIntDictionary);
     }
+
+    [Fact]
+    public void SelfReferencingTest()
+    {
+        var source = new SelfReferencing1();
+        var reference2 = new SelfReferencing2();
+        source.Nested = reference2;
+        reference2.Nested = source;
+
+        var result = DeepCopy.MakeDeepCopy<SelfReferencing1>(source);
+        Assert.NotSame(source, result);
+        Assert.NotSame(source.Nested, result.Nested);
+        Assert.NotSame(source.Nested.Nested, result);
+
+        Assert.Same(result, result.Nested.Nested);
+        Assert.Same(result.Nested, result.Nested.Nested.Nested);
+    }
+
+    [Fact]
+    public void SelfReferencingTest2()
+    {
+        var source = new SelfReferencing3();
+        var reference2 = new SelfReferencing4();
+        source.Nested = reference2;
+        reference2.Nested = new() { source };
+
+        var result = DeepCopy.MakeDeepCopy<SelfReferencing3>(source);
+        Assert.NotSame(source, result);
+        Assert.NotSame(source.Nested, result.Nested);
+        Assert.NotSame(source.Nested.Nested.FirstOrDefault(), result);
+
+        Assert.Same(result, result.Nested.Nested.FirstOrDefault());
+        Assert.Same(result.Nested, result.Nested.Nested.FirstOrDefault()?.Nested);
+    }
+
+    [Fact]
+    public unsafe void PointerTypeTest()
+    {
+        var source = new PointerType
+        {
+            Pointer = (void*)0x12345678,
+        };
+        var result = DeepCopy.MakeDeepCopy<PointerType>(source);
+
+        Assert.Equal((IntPtr)source.Pointer, (IntPtr)result.Pointer);
+
+        result.Pointer = (void*)0x87654321;
+
+        Assert.NotEqual((IntPtr)source.Pointer, (IntPtr)result.Pointer);
+
+        DeepCopy.MakeDeepCopy(source, out result);
+
+        Assert.Equal((IntPtr)source.Pointer, (IntPtr)result!.Pointer);
+    }
 }

UniTAS/Patcher.Tests/Utils/EitherTests.cs

@@ -24,4 +24,24 @@ public void Right()
         Assert.Equal("test", either.Right);
         Assert.Throws<InvalidOperationException>(() => either.Left);
     }
+
+    [Fact]
+    public void ImplicitLeft()
+    {
+        Either<int, string> either = 5;
+        Assert.True(either.IsLeft);
+        Assert.False(either.IsRight);
+        Assert.Equal(5, either.Left);
+        Assert.Throws<InvalidOperationException>(() => either.Right);
+    }
+
+    [Fact]
+    public void ImplicitRight()
+    {
+        Either<int, string> either = "test";
+        Assert.False(either.IsLeft);
+        Assert.True(either.IsRight);
+        Assert.Equal("test", either.Right);
+        Assert.Throws<InvalidOperationException>(() => either.Left);
+    }
 }

UniTAS/Patcher.Tests/Utils/LegacyInputSystemUtilsTest.cs

@@ -8,134 +8,133 @@ public class LegacyInputSystemUtilsTest
     [Fact]
     public void Alphabet()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("a", out var keyCode);
-        Assert.True(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("a");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.A, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("z", out keyCode);
-        Assert.True(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("z");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.Z, keyCode);
     }
 
     [Fact]
     public void AlphabetFail()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("aa", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("aa");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 
     [Fact]
     public void Number()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("0", out var keyCode);
-        Assert.True(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("0");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.Alpha0, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("9", out keyCode);
-        Assert.True(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("9");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.Alpha9, keyCode);
     }
 
     [Fact]
     public void NumberFail()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("10", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("10");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("-1", out keyCode);
-        Assert.False(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("-1");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 
     [Fact]
     public void Numpad()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("[0]", out var keyCode);
-        Assert.True(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("[0]");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.Keypad0, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("[9]", out keyCode);
-        Assert.True(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("[9]");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.Keypad9, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("[+]", out keyCode);
-        Assert.True(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("[+]");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.KeypadPlus, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("[-]", out keyCode);
-        Assert.True(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("[-]");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.KeypadMinus, keyCode);
     }
 
     [Fact]
     public void NumpadFail()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("[-1]", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("[-1]");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("[10]", out keyCode);
-        Assert.False(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("[10]");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("[+1]", out keyCode);
-        Assert.False(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("[+1]");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 
     [Fact]
     public void FunctionKey()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("f1", out var keyCode);
-        Assert.True(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("f1");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.F1, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("f15", out keyCode);
-        Assert.True(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("f15");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.F15, keyCode);
     }
 
     [Fact]
     public void FunctionKeyFail()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("f0", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("f0");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
-        ret = LegacyInputSystemUtils.KeyStringToKeyCode("f16", out keyCode);
-        Assert.False(ret);
+        keyCode = InputSystemUtils.KeyCodeParse("f16");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 
     [Fact]
     public void MostOtherKey()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("backspace", out var keyCode);
-        Assert.True(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("backspace");
+        Assert.NotNull(keyCode);
         Assert.Equal(KeyCode.Backspace, keyCode);
     }
 
     [Fact]
     public void OutOfRangeEnum()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("%", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("%");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 
     [Fact]
     public void Empty()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 
     [Fact]
     public void Null()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode(null, out var keyCode);
-        Assert.False(ret);
-        Assert.Equal(default, keyCode);
+        var keyCode = InputSystemUtils.KeyCodeParse(null);
+        Assert.Null(keyCode);
     }
 
     [Fact]
     public void Invalid()
     {
-        var ret = LegacyInputSystemUtils.KeyStringToKeyCode("foo", out var keyCode);
-        Assert.False(ret);
+        var keyCode = InputSystemUtils.KeyCodeParse("foo");
+        Assert.Null(keyCode);
         Assert.Equal(default, keyCode);
     }
 }