feat: global initializer

Author: CedaryCat

src/OTAPI.UnifiedServerProcess.GlobalNetwork/Program.cs

@@ -2,6 +2,7 @@
 using OTAPI.UnifiedServerProcess.GlobalNetwork.Network;
 using OTAPI.UnifiedServerProcess.GlobalNetwork.Servers;
 using ReLogic.OS;
+using UnifiedServerProcess;
 
 namespace OTAPI.UnifiedServerProcess.GlobalNetwork
 {
@@ -26,6 +27,8 @@ static void Main(string[] args) {
             NetworkPatcher.Load();
             AppDomain.CurrentDomain.AssemblyResolve += ResolveHelpers.ResolveAssembly;
             Terraria.Program.SavePath = Platform.Get<IPathService>().GetStoragePath("Terraria");
+            Terraria.Main.SkipAssemblyLoad = true;
+            GlobalInitializer.InitializeEntryPoint();
 
             int port = 7777;
 
@@ -39,11 +42,9 @@ static void Main(string[] args) {
             Console.WriteLine("- done.");
 
             Task.Run(() => {
-                server1.Main.SkipAssemblyLoad = true;
                 server1.Program.LaunchGame(args);
             });
             Task.Run(() => {
-                server2.Main.SkipAssemblyLoad = true;
                 server2.Program.LaunchGame(args);
             });
 

src/OTAPI.UnifiedServerProcess.Test/Program.cs

@@ -9,15 +9,18 @@ internal class Program
         static void Main(string[] args) {
             AppDomain.CurrentDomain.AssemblyResolve += ResolveHelpers.ResolveAssembly;
             Terraria.Program.SavePath = Platform.Get<IPathService>().GetStoragePath("Terraria");
+            Terraria.Main.SkipAssemblyLoad = true;
 
-            var test = new RootContext("Test");
+            RootContext test;
+            for (int i = 0; i < 1200; i++) {
+                test = new RootContext("Test");
+            }
 
-            test.Hooks.NetMessage.PlayerAnnounce += (sender, e) => {
-                Console.WriteLine("[USP] Player joined: " + test.Main.player[e.Plr].name);
-            };
+            //test.Hooks.NetMessage.PlayerAnnounce += (sender, e) => {
+            //    Console.WriteLine("[USP] Player joined: " + test.Main.player[e.Plr].name);
+            //};
 
-            test.Main.SkipAssemblyLoad = true;
-            test.Program.LaunchGame(args);
+            //test.Program.LaunchGame(args);
         }
     }
 }

src/OTAPI.UnifiedServerProcess/Commons/IL.cs

@@ -11,7 +11,7 @@ public static partial class MonoModCommon
         public static class IL
         {
             /// <summary>
-            /// The name of the "this" parameter is an empty string rather than "this".
+            /// The name of the "this" TrackingParameter is an empty string rather than "this".
             /// </summary>
             public const string ThisParameterName = "";
             public static Instruction BuildParameterLoad(MethodDefinition method, MethodBody body, ParameterDefinition parameter) {
@@ -32,7 +32,7 @@ public static Instruction BuildParameterLoad(MethodDefinition method, MethodBody
             }
             public static Instruction BuildParameterSet(MethodDefinition method, MethodBody body, ParameterDefinition parameter) {
                 if (method.HasThis && ((body is not null && body.ThisParameter == parameter) || parameter.Name == "")) {
-                    throw new ArgumentException("Cannot set \"this\" parameter", nameof(parameter));
+                    throw new ArgumentException("Cannot set \"this\" TrackingParameter", nameof(parameter));
                 }
                 else {
                     var index = method.Parameters.IndexOf(parameter) + (method.HasThis ? 1 : 0);
@@ -107,7 +107,7 @@ Code.Starg_S or
                 }
                 var param = method.Parameters[paramIndex];
                 if (tmpCheck is not null && tmpCheck.Name != param.Name) {
-                    throw new InvalidOperationException("Operand parameter is invalid");
+                    throw new InvalidOperationException("Operand TrackingParameter is invalid");
                 }
                 return param;
             }
@@ -143,7 +143,7 @@ Code.Starg_S or
                     var paramIndex = paramInnerIndex - (method.HasThis ? 1 : 0);
                     parameter = method.Parameters[paramIndex];
                     if (tmpCheck is not null && tmpCheck.Name != parameter.Name) {
-                        throw new InvalidOperationException("Operand parameter is invalid");
+                        throw new InvalidOperationException("Operand TrackingParameter is invalid");
                     }
                 }
                 return true;
@@ -182,11 +182,37 @@ public static bool TryGetReferencedVariable(MethodDefinition method, Instruction
                     Code.Ldloc_1 or Code.Stloc_1 => 1,
                     Code.Ldloc_2 or Code.Stloc_2 => 2,
                     Code.Ldloc_3 or Code.Stloc_3 => 3,
+
                     Code.Ldloc_S or
                     Code.Ldloc or
-                    Code.Ldloca or
                     Code.Ldloca_S or
-                    Code.Stloc or
+                    Code.Ldloca or
+                    Code.Stloc_S or
+                    Code.Stloc => (tmpCheck = (VariableDefinition)instruction.Operand).Index,
+                    _ => -1
+                };
+
+                if (tmpCheck is not null && tmpCheck != method.Body.Variables[localIndex]) {
+                    throw new ArgumentException("Operand variable is invalid", nameof(instruction));
+                }
+
+                if (localIndex == -1) {
+                    variable = null;
+                    return false;
+                }
+
+                variable = method.Body.Variables[localIndex];
+                return true;
+            }
+            public static bool MatchSetVariable(MethodDefinition method, Instruction instruction, [NotNullWhen(true)] out VariableDefinition? variable) {
+                VariableDefinition? tmpCheck = null;
+
+                var localIndex = instruction.OpCode.Code switch {
+                    Code.Stloc_0 => 0,
+                    Code.Stloc_1 => 1,
+                    Code.Stloc_2 => 2,
+                    Code.Stloc_3 => 3,
+
                     Code.Stloc_S or
                     Code.Stloc => (tmpCheck = (VariableDefinition)instruction.Operand).Index,
                     _ => -1
@@ -204,6 +230,53 @@ Code.Stloc_S or
                 variable = method.Body.Variables[localIndex];
                 return true;
             }
+            public static bool MatchLoadVariableAddress(MethodDefinition method, Instruction instruction, [NotNullWhen(true)] out VariableDefinition? variable) {
+                VariableDefinition? tmpCheck = null;
+
+                var localIndex = instruction.OpCode.Code switch {
+                    Code.Ldloca_S or
+                    Code.Ldloca => (tmpCheck = (VariableDefinition)instruction.Operand).Index,
+                    _ => -1
+                };
+
+                if (tmpCheck is not null && tmpCheck != method.Body.Variables[localIndex]) {
+                    throw new ArgumentException("Operand variable is invalid", nameof(instruction));
+                }
+
+                if (localIndex == -1) {
+                    variable = null;
+                    return false;
+                }
+
+                variable = method.Body.Variables[localIndex];
+                return true;
+            }
+            public static bool MatchLoadVariable(MethodDefinition method, Instruction instruction, [NotNullWhen(true)] out VariableDefinition? variable) { 
+                VariableDefinition? tmpCheck = null;
+
+                var localIndex = instruction.OpCode.Code switch {
+                    Code.Ldloc_0 => 0,
+                    Code.Ldloc_1 => 1,
+                    Code.Ldloc_2 => 2,
+                    Code.Ldloc_3 => 3,
+
+                    Code.Ldloc_S or
+                    Code.Ldloc => (tmpCheck = (VariableDefinition)instruction.Operand).Index,
+                    _ => -1
+                };
+
+                if (tmpCheck is not null && tmpCheck != method.Body.Variables[localIndex]) {
+                    throw new ArgumentException("Operand variable is invalid", nameof(instruction));
+                }
+
+                if (localIndex == -1) {
+                    variable = null;
+                    return false;
+                }
+
+                variable = method.Body.Variables[localIndex];
+                return true;
+            }
             public static TypeReference GetMethodReturnType(MethodReference target, MethodDefinition callerContext) {
                 if (target is GenericInstanceMethod genericMethod) {
                     return ResolveGenericReturnType(genericMethod, genericMethod.ReturnType);