Merge pull request #36 from DDDDDragon/VarImprovement

[Minor] Add variable checking for AssemblyAsString actions

Author: remyCases

ModUtils/AsmUtils.cs

@@ -168,9 +168,31 @@ public static UndertaleInstruction.Reference<UndertaleVariable> CreateRefVariabl
 
             return new UndertaleInstruction.Reference<UndertaleVariable>(variable, UndertaleInstruction.VariableType.Normal);
         }
+        public static void CheckRefVariableOrCreate(string name, UndertaleInstruction.InstanceType instanceType)
+        {
+            try
+            {
+                UndertaleVariable? variable = ModLoader.Data.Variables.FirstOrDefault(t => t.Name?.Content == name);
+                
+                if (variable == null) 
+                {
+                    CreateRefVariable(name, instanceType);
+                }
+                else
+                {
+                    Log.Information(string.Format("Found variable: {0}", variable.ToString()));
+                }
+                
+            }
+            catch
+            {
+                throw;
+            }
+        }
         public static UndertaleInstruction.Reference<UndertaleVariable> GetRefVariableOrCreate(string name, UndertaleInstruction.InstanceType instanceType)
         {
-            try {
+            try 
+            {
                 UndertaleInstruction.Reference<UndertaleVariable> refVariable;
                 UndertaleVariable? variable = ModLoader.Data.Variables.FirstOrDefault(t => t.Name?.Content == name);
 
@@ -179,12 +201,12 @@ public static UndertaleInstruction.Reference<UndertaleVariable> GetRefVariableOr
                 else
                     refVariable = new UndertaleInstruction.Reference<UndertaleVariable>(variable, UndertaleInstruction.VariableType.Normal);
 
-                Log.Information(string.Format("Find variable: {0}", refVariable.ToString()));
+                Log.Information(string.Format("Found variable: {0}", refVariable.ToString()));
 
                 return refVariable;
             }
-            catch(Exception ex) {
-                Log.Error(ex, "Something went wrong");
+            catch
+            {
                 throw;
             }
         }

ModUtils/CodeUtils.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Text.RegularExpressions;
 using ModShardLauncher.Resources.Codes;
 using Serilog;
 using UndertaleModLib;
@@ -72,13 +73,47 @@ public override string ToString()
     /// </summary>
     public class FileEnumerable<T>
     {
+        private readonly Regex variableRegex = new (@"\bpop\.v\.\w\s(?<var>\w+)\.(?<name>\w+)");
         public readonly Header header;
         public readonly IEnumerable<T> ienumerable;
         public FileEnumerable(Header header, IEnumerable<T> ienumerable) 
         {
             this.header = header;
             this.ienumerable = ienumerable;
         }
+        /// <summary>
+        /// Check pop variables for intructions as string and create them if needed.
+        /// </summary>
+        /// <param name="instructions"></param>
+        public void CheckInstructionsVariables(string instructions)
+        {
+            if (header.patchingWay != PatchingWay.AssemblyAsString) return;
+
+            foreach (string instruction in instructions.Split('\n').Where(x => x.Contains("pop.v")))
+            {
+                System.Text.RegularExpressions.Match matches = variableRegex.Match(instruction);
+                if (matches.Success) 
+                {
+                    string instanceValue = matches.Groups["var"].Value;
+                    if(instanceValue == "self")
+                    {
+                        AssemblyWrapper.CheckRefVariableOrCreate(matches.Groups["name"].Value, UndertaleInstruction.InstanceType.Self);
+                    }
+                    else if(instanceValue == "global")
+                    {
+                        AssemblyWrapper.CheckRefVariableOrCreate(matches.Groups["name"].Value, UndertaleInstruction.InstanceType.Global);
+                    }
+                    else if(instanceValue == "local")
+                    {
+                        AssemblyWrapper.CheckRefVariableOrCreate(matches.Groups["name"].Value, UndertaleInstruction.InstanceType.Local);
+                    }
+                    else
+                    {
+                        Log.Warning("Cannot infer the instance type of {0}. There is a risk it will lead to an undefined variable.", instruction);
+                    }
+                }
+            }
+        }
     }
     /// <summary>
     /// A static class for notably IEnumerable Extensions to provide a functional-programing-like api while modding.
@@ -772,6 +807,7 @@ public static IEnumerable<string> InsertBelow(this IEnumerable<(Match, string)>
         /// </summary>
         public static  FileEnumerable<string> InsertBelow(this FileEnumerable<(Match, string)> fe, string inserting)
         {
+            fe.CheckInstructionsVariables(inserting);
             return new(fe.header, fe.ienumerable.InsertBelow(inserting.Split("\n")));
         }
         /// <summary>
@@ -820,6 +856,7 @@ public static IEnumerable<string> InsertAbove(this IEnumerable<(Match, string)>
         /// </summary>
         public static  FileEnumerable<string> InsertAbove(this FileEnumerable<(Match, string)> fe, string inserting)
         {
+            fe.CheckInstructionsVariables(inserting);
             return new(fe.header, fe.ienumerable.InsertAbove(inserting.Split("\n")));
         }
         /// <summary>
@@ -872,6 +909,7 @@ public static IEnumerable<string> ReplaceBy(this IEnumerable<(Match, string)> ie
         /// </summary>
         public static FileEnumerable<string> ReplaceBy(this FileEnumerable<(Match, string)> fe, string inserting)
         {
+            fe.CheckInstructionsVariables(inserting);
             return new(fe.header, fe.ienumerable.ReplaceBy(inserting.Split("\n")));
         }
         /// <summary>