PaulNonatomic · PaulNonatomic · Dec 23, 2024 · Aug 25, 2024 · Aug 25, 2024 · Sep 9, 2024
diff --git a/.idea/indexLayout.xml b/.idea/indexLayout.xml
diff --git a/.idea/material_theme_project_new.xml b/.idea/material_theme_project_new.xml
diff --git a/.idea/projectSettingsUpdater.xml b/.idea/projectSettingsUpdater.xml
diff --git a/.idea/vcs.xml b/.idea/vcs.xml
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,32 @@
 # Change Log
 
+# [0.9.4-beta] - Dec 22, 2024
+- Added a method to migrate all state machine model assets
+
+# [0.9.3-beta] - Dec 22, 2024
+- Added a migration step to fix transitions to OnEnterState methods
+
+# [0.9.2-beta] - Dec 22, 2024
+- Added a migration step to add missing using statements
+
+# [0.9.1-beta] - Dec 22, 2024
+- Added a migration tool to upgrade to 0.9.1-beta
+- Added obsolete methods back in and marked as obsolete to allow for a smoother migration to the new version
+- Added support for LateUpdate in states
+- Added a cache for event info obtained via reflection to reduce the runtime overhead of reflection
+
+# [0.9.0-beta] - Sept 20, 2024
+- BREAKING - State enter methods now require an [Enter] attribute.
+- States now support typed transitions
+  - Example ```[Transition] public event Action<int> OnTransitionWithInt```
+  - Example ```[Enter] public void OnEnterWithInt(int value){}```
+- Abstracted validation methods to a separate class
+- Added a CounterWithTargetState.
+- Simplified the uss files used to style the basic states
+
+# [0.8.5-beta] - Sept 17, 2024
+- Fix for deleting a selection via the context menu
+
 ## [0.8.4-beta] - Sept 11, 2024
 - SharedData.ClearData is now Obsolete and will be removed in a future release. Use SharedData.ClearAllData instead.
 - Added SharedData.ClearAllData method to clear all shared data.
@@ -67,7 +94,7 @@ Added support for switching SubStateMachine models at runtime
 
 ## [0.5.1-beta] - Jul 18, 2024
 - Added a protected setter to the Model accessor of BaseSubStateMachineState
-    - This will allow for derived states to switch the model in the OnAwakeState
+    - This will allow for derived states to switch the model in the OnAwake
 
 ## [0.5.0-beta] - Jul 17, 2024
 - Removal of the StateMachineController.Model setter.

diff --git a/Editor/Migration.meta b/Editor/Migration.meta
diff --git a/Editor/Migration/MethodAttributeInserter.cs b/Editor/Migration/MethodAttributeInserter.cs
@@ -0,0 +1,70 @@
+using System.Text.RegularExpressions;
+
+namespace Nonatomic.VSM2.Editor.Migration
+{
+	public static class MethodAttributeInserter
+	{
+		/*
+		 * Explanation of this pattern (in Multiline mode):
+		 *
+		 *  ^(?<indent>[^\S\r\n]*)
+		 *    - '^[^\S\r\n]*' means at the start of a line (^), capture any whitespace 
+		 *      that is *not* a newline or carriage return. (i.e. spaces or tabs)
+		 *
+		 *  (?<body>(\[[^\]]*\]\s*)*(public|protected|private|internal)?\s*
+		 *             (virtual|abstract|override|static|sealed|async|\s)*[^\s]+\s+
+		 *             (<METHOD_NAME_HERE>)\s*\([^)]*\)\s*\{)
+		 *    - Captures the rest of the line (any existing attributes, modifiers, method name, etc.)
+		 *    - <METHOD_NAME_HERE> is a placeholder that we'll replace with the actual method name.
+		 *
+		 * RegexOptions.Multiline => '^' and '$' match the start/end of *each* line in the input.
+		 */
+		private static readonly Regex _methodRegexTemplate = new Regex(
+			@"^(?<indent>[^\S\r\n]*)(?<body>(\[[^\]]*\]\s*)*(public|protected|private|internal)?\s*(virtual|abstract|override|static|sealed|async|\s)*[^\s]+\s+(<METHOD_NAME_HERE>)\s*\([^)]*\)\s*\{)",
+			RegexOptions.Compiled | RegexOptions.Multiline
+		);
+
+		/// <summary>
+		/// Inserts <paramref name="attributeToInsert"/> above each matching method (by exact name),
+		/// preserving indentation and ensuring no duplicate attributes or extra blank lines.
+		/// </summary>
+		public static string InsertAttributeAboveMethod(
+			string sourceCode,
+			string methodName,
+			string attributeToInsert)
+		{
+			if (string.IsNullOrEmpty(sourceCode)) return sourceCode;
+			if (string.IsNullOrEmpty(methodName))  return sourceCode;
+			if (string.IsNullOrEmpty(attributeToInsert)) return sourceCode;
+
+			// Build a new regex by substituting the actual method name
+			var pattern = _methodRegexTemplate
+				.ToString()
+				.Replace("<METHOD_NAME_HERE>", Regex.Escape(methodName));
+
+			var methodRegex = new Regex(pattern, RegexOptions.Compiled | RegexOptions.Multiline);
+
+			// Perform the replacement
+			return methodRegex.Replace(sourceCode, match =>
+			{
+				var indent = match.Groups["indent"].Value; // Only spaces or tabs
+				var body   = match.Groups["body"].Value;
+
+				// If we already have the attribute in the body, don't add it again
+				if (body.Contains(attributeToInsert))
+				{
+					return match.Value; 
+				}
+
+				/*
+				 * We rebuild:
+				 *	<indent>[Attribute]
+				 *	<indent>public void OnEnter() {
+				 *		...
+				 *	}
+				 */
+				return $"{indent}{attributeToInsert}\n{indent}{body}";
+			});
+		}
+	}
+}
diff --git a/Editor/Migration/MethodAttributeInserter.cs.meta b/Editor/Migration/MethodAttributeInserter.cs.meta
diff --git a/Editor/Migration/MigrationUtils.cs b/Editor/Migration/MigrationUtils.cs
@@ -0,0 +1,73 @@
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.IO;
+
+public static class MigrationUtils
+{
+	public static string GetPathForType(Type type)
+	{
+		var guids = AssetDatabase.FindAssets("t:MonoScript");
+
+		// Figure out the "base" name if this is an open generic type definition
+		var isOpenGeneric = type.IsGenericTypeDefinition; 
+		var strippedBaseName = isOpenGeneric ? StripBacktick(type.Name) : null;
+
+		foreach (var guid in guids)
+		{
+			var path = AssetDatabase.GUIDToAssetPath(guid);
+
+			// 1. If we see an open generic, fallback to checking filename
+			if (isOpenGeneric && !string.IsNullOrEmpty(strippedBaseName))
+			{
+				var fileName = Path.GetFileName(path);
+				if (fileName.Equals(strippedBaseName + ".cs", StringComparison.OrdinalIgnoreCase))
+				{
+					var fullPath = Application.dataPath.Replace("Assets", "") + path;
+					if (File.Exists(fullPath))
+					{
+						return fullPath;
+					}
+				}
+			}
+
+			// 2. Otherwise, do the usual closed-generic / normal type check
+			var monoScript = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
+			if (monoScript == null) continue;
+
+			var scriptClass = monoScript.GetClass();
+			if (scriptClass == null) continue;
+
+			if (IsSameOrOpenGenericEquivalent(scriptClass, type))
+			{
+				var fullPath = Application.dataPath.Replace("Assets", "") + path;
+				if (File.Exists(fullPath))
+				{
+					return fullPath;
+				}
+			}
+		}
+
+		Debug.LogWarning($"Could not find a .cs file for type: {type.FullName}");
+		return null;
+	}
+
+	private static bool IsSameOrOpenGenericEquivalent(Type scriptClass, Type targetType)
+	{
+		if (scriptClass.IsGenericType && targetType.IsGenericType)
+		{
+			return scriptClass.GetGenericTypeDefinition() == targetType.GetGenericTypeDefinition();
+		}
+
+		return scriptClass == targetType;
+	}
+
+	private static string StripBacktick(string typeName)
+	{
+		// e.g. "RoundListState`1" => "RoundListState"
+		var index = typeName.IndexOf('`');
+		return (index >= 0) 
+			? typeName.Substring(0, index) 
+			: typeName;
+	}
+}
diff --git a/Editor/Migration/MigrationUtils.cs.meta b/Editor/Migration/MigrationUtils.cs.meta
diff --git a/Editor/Migration/StateMachineMigrator.cs b/Editor/Migration/StateMachineMigrator.cs
@@ -0,0 +1,70 @@
+using Nonatomic.VSM2.StateGraph;
+using Nonatomic.VSM2.Utils;
+using UnityEditor;
+using UnityEngine;
+
+namespace Nonatomic.VSM2.Editor.Migration
+{
+	public static class StateMachineMigrator
+	{
+		public static void Migrate(StateMachineModel stateMachineModel)
+		{
+			if (GuardUtils.GuardAgainstRuntimeOperation()) return;
+
+			MigrateNodePorts(stateMachineModel);
+			MigrateTransitions(stateMachineModel);
+			SaveModel(stateMachineModel);
+		}
+
+		private static void SaveModel(StateMachineModel stateMachineModel)
+		{
+			Debug.Log($"Flag as dirty: {stateMachineModel.name}");
+			EditorUtility.SetDirty(stateMachineModel);
+		}
+
+		private static void MigrateTransitions(StateMachineModel stateMachineModel)
+		{
+			if (GuardUtils.GuardAgainstRuntimeOperation()) return;
+
+			for (var index = stateMachineModel.Transitions.Count - 1; index >= 0; index--)
+			{
+				var transition = stateMachineModel.Transitions[index];
+
+				// Handle migration (Older state machines had an OnEnterState method)
+				if (transition.DestinationNodeId == "OnEnterState")
+				{
+					transition.DestinationNodeId = "OnEnter";
+				}
+
+				if(transition.DestinationPort.Id == "OnEnterState")
+				{
+					transition.DestinationPort.Id = "OnEnter";
+				}
+			}
+		}
+
+		private static void MigrateNodePorts(StateMachineModel stateMachineModel)
+		{
+			if (GuardUtils.GuardAgainstRuntimeOperation()) return;
+
+			foreach (var node in stateMachineModel.Nodes)
+			{
+				foreach (var port in node.InputPorts)
+				{
+					if(port.Id == "OnEnterState")
+					{
+						port.Id = "OnEnter";
+					}
+				}
+
+				foreach (var port in node.OutputPorts)
+				{
+					if(port.Id == "OnEnterState")
+					{
+						port.Id = "OnEnter";
+					}
+				}
+			}
+		}
+	}
+}