using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HutongGames.PlayMaker;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Silksong.FsmUtil.Actions;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("silksong-modding")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) silksong-modding 2025")]
[assembly: AssemblyDescription("This is a library for mods to make FSM edits easier.")]
[assembly: AssemblyFileVersion("0.3.1.0")]
[assembly: AssemblyInformationalVersion("0.3.1+9850887efe5ed2c55a0168aa7d872a9dda9dcf86")]
[assembly: AssemblyProduct("Silksong.FsmUtil")]
[assembly: AssemblyTitle("Silksong.FsmUtil")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/silksong-modding/Silksong.FsmUtil")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.3.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Silksong.FsmUtil
{
	public static class FsmUtil
	{
		[PublicAPI]
		public static PlayMakerFSM? GetFsmPreprocessed(this GameObject go, string fsmName)
		{
			PlayMakerFSM[] components = go.GetComponents<PlayMakerFSM>();
			foreach (PlayMakerFSM val in components)
			{
				if (val.FsmName == fsmName)
				{
					val.Preprocess();
					return val;
				}
			}
			return null;
		}

		private static TVal? GetItemFromArray<TVal>(TVal[] origArray, Func<TVal, bool> isItemCheck) where TVal : class
		{
			foreach (TVal val in origArray)
			{
				if (isItemCheck(val))
				{
					return val;
				}
			}
			return null;
		}

		private static TVal[] GetItemsFromArray<TVal>(TVal[] origArray, Func<TVal, bool> isItemCheck) where TVal : class
		{
			int num = 0;
			TVal[] array = origArray;
			foreach (TVal arg in array)
			{
				if (isItemCheck(arg))
				{
					num++;
				}
			}
			if (num == origArray.Length)
			{
				return origArray;
			}
			if (num == 0)
			{
				return Array.Empty<TVal>();
			}
			TVal[] array2 = new TVal[num];
			int num2 = 0;
			array = origArray;
			foreach (TVal val in array)
			{
				if (isItemCheck(val))
				{
					array2[num2] = val;
					num2++;
				}
			}
			return array2;
		}

		[PublicAPI]
		public static FsmState? GetState(this PlayMakerFSM fsm, string stateName)
		{
			string stateName2 = stateName;
			return GetItemFromArray(fsm.FsmStates, (FsmState x) => x.Name == stateName2);
		}

		[PublicAPI]
		public static FsmState? GetState(this Fsm fsm, string stateName)
		{
			string stateName2 = stateName;
			return GetItemFromArray(fsm.States, (FsmState x) => x.Name == stateName2);
		}

		[PublicAPI]
		public static FsmTransition? GetTransition(this PlayMakerFSM fsm, string stateName, string eventName)
		{
			return fsm.GetState(stateName).GetTransition(eventName);
		}

		[PublicAPI]
		public static FsmTransition? GetTransition(this Fsm fsm, string stateName, string eventName)
		{
			return fsm.GetState(stateName).GetTransition(eventName);
		}

		[PublicAPI]
		public static FsmTransition? GetTransition(this FsmState state, string eventName)
		{
			string eventName2 = eventName;
			return GetItemFromArray(state.Transitions, (FsmTransition x) => x.EventName == eventName2);
		}

		[PublicAPI]
		public static FsmTransition? GetGlobalTransition(this PlayMakerFSM fsm, string globalEventName)
		{
			return fsm.Fsm.GetGlobalTransition(globalEventName);
		}

		[PublicAPI]
		public static FsmTransition? GetGlobalTransition(this Fsm fsm, string globalEventName)
		{
			string globalEventName2 = globalEventName;
			return GetItemFromArray(fsm.GlobalTransitions, (FsmTransition x) => x.EventName == globalEventName2);
		}

		[PublicAPI]
		public static TAction? GetAction<TAction>(this PlayMakerFSM fsm, string stateName, int index) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetAction<TAction>(index);
		}

		[PublicAPI]
		public static TAction? GetAction<TAction>(this Fsm fsm, string stateName, int index) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetAction<TAction>(index);
		}

		[PublicAPI]
		public static TAction? GetAction<TAction>(this FsmState state, int index) where TAction : FsmStateAction
		{
			FsmStateAction obj = state.Actions[index];
			return (TAction)(object)((obj is TAction) ? obj : null);
		}

		[PublicAPI]
		public static FsmStateAction? GetStateAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.GetState(stateName).GetStateAction(index);
		}

		[PublicAPI]
		public static FsmStateAction? GetStateAction(this Fsm fsm, string stateName, int index)
		{
			return fsm.GetState(stateName).GetStateAction(index);
		}

		[PublicAPI]
		public static FsmStateAction? GetStateAction(this FsmState state, int index)
		{
			return state.Actions[index];
		}

		[PublicAPI]
		public static TAction[] GetActionsOfType<TAction>(this PlayMakerFSM fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetActionsOfType<TAction>();
		}

		[PublicAPI]
		public static TAction[] GetActionsOfType<TAction>(this Fsm fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetActionsOfType<TAction>();
		}

		[PublicAPI]
		public static TAction[] GetActionsOfType<TAction>(this FsmState state) where TAction : FsmStateAction
		{
			return GetItemsFromArray(state.Actions, (FsmStateAction x) => x is TAction) as TAction[];
		}

		[PublicAPI]
		public static TAction? GetFirstActionOfType<TAction>(this PlayMakerFSM fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetFirstActionOfType<TAction>(this Fsm fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetFirstActionOfType<TAction>(this FsmState state) where TAction : FsmStateAction
		{
			int num = -1;
			for (int i = 0; i < state.Actions.Length; i++)
			{
				if (state.Actions[i] is TAction)
				{
					num = i;
					break;
				}
			}
			if (num == -1)
			{
				return default(TAction);
			}
			return state.GetAction<TAction>(num);
		}

		[PublicAPI]
		public static TAction? GetLastActionOfType<TAction>(this PlayMakerFSM fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetLastActionOfType<TAction>(this Fsm fsm, string stateName) where TAction : FsmStateAction
		{
			return fsm.GetState(stateName).GetLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static TAction? GetLastActionOfType<TAction>(this FsmState state) where TAction : FsmStateAction
		{
			int num = -1;
			for (int num2 = state.Actions.Length - 1; num2 >= 0; num2--)
			{
				if (state.Actions[num2] is TAction)
				{
					num = num2;
					break;
				}
			}
			if (num == -1)
			{
				return default(TAction);
			}
			return state.GetAction<TAction>(num);
		}

		private static TVal[] AddItemToArray<TVal>(TVal[] origArray, TVal value)
		{
			TVal[] array = new TVal[origArray.Length + 1];
			origArray.CopyTo(array, 0);
			array[origArray.Length] = value;
			return array;
		}

		[PublicAPI]
		public static FsmState AddState(this PlayMakerFSM fsm, string stateName)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			return fsm.Fsm.AddState(new FsmState(fsm.Fsm)
			{
				Name = stateName
			});
		}

		[PublicAPI]
		public static FsmState AddState(this Fsm fsm, string stateName)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			return fsm.AddState(new FsmState(fsm)
			{
				Name = stateName
			});
		}

		[PublicAPI]
		public static FsmState AddState(this PlayMakerFSM fsm, FsmState state)
		{
			return fsm.Fsm.AddState(state);
		}

		[PublicAPI]
		public static FsmState AddState(this Fsm fsm, FsmState state)
		{
			FsmState[] states = fsm.States;
			FsmState[] array2 = (fsm.States = AddItemToArray(states, state));
			fsm.SaveActions();
			return array2[states.Length];
		}

		[PublicAPI]
		public static FsmState CopyState(this PlayMakerFSM fsm, string fromState, string toState)
		{
			return fsm.Fsm.CopyState(fromState, toState);
		}

		[PublicAPI]
		public static FsmState CopyState(this Fsm fsm, string fromState, string toState)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			FsmState state = fsm.GetState(fromState);
			if (state != null)
			{
				state.SaveActions();
			}
			FsmState val = new FsmState(state)
			{
				Name = toState
			};
			FsmTransition[] transitions = val.Transitions;
			foreach (FsmTransition val2 in transitions)
			{
				val2.ToFsmState = fsm.GetState(val2.ToState);
			}
			fsm.AddState(val);
			return val;
		}

		[PublicAPI]
		public static FsmEvent AddTransition(this PlayMakerFSM fsm, string stateName, string eventName, string toState)
		{
			return fsm.GetState(stateName).AddTransition(eventName, toState);
		}

		[PublicAPI]
		public static FsmEvent AddTransition(this Fsm fsm, string stateName, string eventName, string toState)
		{
			return fsm.GetState(stateName).AddTransition(eventName, toState);
		}

		[PublicAPI]
		public static FsmEvent AddTransition(this FsmState state, string eventName, string toState)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			FsmEvent fsmEvent = FsmEvent.GetFsmEvent(eventName);
			FsmTransition[] transitions = AddItemToArray(state.Transitions, new FsmTransition
			{
				ToState = toState,
				ToFsmState = state.Fsm.GetState(toState),
				FsmEvent = fsmEvent
			});
			state.Transitions = transitions;
			return fsmEvent;
		}

		[PublicAPI]
		public static FsmEvent AddGlobalTransition(this PlayMakerFSM fsm, string globalEventName, string toState)
		{
			return fsm.Fsm.AddGlobalTransition(globalEventName, toState);
		}

		[PublicAPI]
		public static FsmEvent AddGlobalTransition(this Fsm fsm, string globalEventName, string toState)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			FsmEvent val = new FsmEvent(globalEventName)
			{
				IsGlobal = true
			};
			FsmTransition[] globalTransitions = AddItemToArray(fsm.GlobalTransitions, new FsmTransition
			{
				ToState = toState,
				ToFsmState = fsm.GetState(toState),
				FsmEvent = val
			});
			fsm.GlobalTransitions = globalTransitions;
			return val;
		}

		[PublicAPI]
		public static void AddAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action)
		{
			fsm.GetState(stateName).AddAction(action);
		}

		[PublicAPI]
		public static void AddAction(this Fsm fsm, string stateName, FsmStateAction action)
		{
			fsm.GetState(stateName).AddAction(action);
		}

		[PublicAPI]
		public static void AddAction(this FsmState state, FsmStateAction action)
		{
			FsmStateAction[] actions = AddItemToArray(state.Actions, action);
			state.Actions = actions;
			action.Init(state);
		}

		[PublicAPI]
		public static void AddActions(this PlayMakerFSM fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.GetState(stateName).AddActions(actions);
		}

		[PublicAPI]
		public static void AddActions(this Fsm fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.GetState(stateName).AddActions(actions);
		}

		[PublicAPI]
		public static void AddActions(this FsmState state, params FsmStateAction[] actions)
		{
			foreach (FsmStateAction action in actions)
			{
				state.AddAction(action);
			}
		}

		[PublicAPI]
		public static void AddMethod(this PlayMakerFSM fsm, string stateName, Action<FsmStateAction> method)
		{
			fsm.GetState(stateName).AddMethod(method);
		}

		[PublicAPI]
		public static void AddMethod(this Fsm fsm, string stateName, Action<FsmStateAction> method)
		{
			fsm.GetState(stateName).AddMethod(method);
		}

		[PublicAPI]
		public static void AddMethod(this FsmState state, Action<FsmStateAction> method)
		{
			DelegateAction<FsmStateAction> delegateAction = new DelegateAction<FsmStateAction>
			{
				Method = method
			};
			delegateAction.Arg = (FsmStateAction?)(object)delegateAction;
			state.AddAction((FsmStateAction)(object)delegateAction);
		}

		[PublicAPI]
		public static void AddLambdaMethod(this PlayMakerFSM fsm, string stateName, Action<Action> method)
		{
			fsm.GetState(stateName).AddLambdaMethod(method);
		}

		[PublicAPI]
		public static void AddLambdaMethod(this Fsm fsm, string stateName, Action<Action> method)
		{
			fsm.GetState(stateName).AddLambdaMethod(method);
		}

		[PublicAPI]
		public static void AddLambdaMethod(this FsmState state, Action<Action> method)
		{
			DelegateAction<Action> delegateAction = new DelegateAction<Action>
			{
				Method = method
			};
			delegateAction.Arg = ((FsmStateAction)delegateAction).Finish;
			state.AddAction((FsmStateAction)(object)delegateAction);
		}

		private static TVal[] InsertItemIntoArray<TVal>(TVal[] origArray, TVal value, int index)
		{
			int num = origArray.Length;
			if (index < 0 || index > num + 1)
			{
				throw new ArgumentOutOfRangeException($"Index {index} was out of range for array with length {num}!");
			}
			TVal[] array = new TVal[num + 1];
			for (int i = 0; i < index; i++)
			{
				array[i] = origArray[i];
			}
			array[index] = value;
			for (int i = index; i < num; i++)
			{
				array[i + 1] = origArray[i];
			}
			return array;
		}

		[PublicAPI]
		public static void InsertAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.GetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this PlayMakerFSM fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.GetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this Fsm fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.GetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this Fsm fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.GetState(stateName).InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this FsmState state, FsmStateAction action, int index)
		{
			state.InsertAction(index, action);
		}

		[PublicAPI]
		public static void InsertAction(this FsmState state, int index, FsmStateAction action)
		{
			FsmStateAction[] actions = InsertItemIntoArray(state.Actions, action, index);
			state.Actions = actions;
			action.Init(state);
		}

		[PublicAPI]
		public static void InsertActions(this PlayMakerFSM fsm, string stateName, int index, params FsmStateAction[] actions)
		{
			fsm.GetState(stateName).InsertActions(index, actions);
		}

		[PublicAPI]
		public static void InsertActions(this Fsm fsm, string stateName, int index, params FsmStateAction[] actions)
		{
			fsm.GetState(stateName).InsertActions(index, actions);
		}

		[PublicAPI]
		public static void InsertActions(this FsmState state, int index, params FsmStateAction[] actions)
		{
			foreach (FsmStateAction action in actions)
			{
				state.InsertAction(action, index);
				index++;
			}
		}

		[PublicAPI]
		public static void InsertMethod(this PlayMakerFSM fsm, string stateName, Action<FsmStateAction> method, int index)
		{
			fsm.GetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this PlayMakerFSM fsm, string stateName, int index, Action<FsmStateAction> method)
		{
			fsm.GetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this Fsm fsm, string stateName, Action<FsmStateAction> method, int index)
		{
			fsm.GetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this Fsm fsm, string stateName, int index, Action<FsmStateAction> method)
		{
			fsm.GetState(stateName).InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this FsmState state, Action<FsmStateAction> method, int index)
		{
			state.InsertMethod(index, method);
		}

		[PublicAPI]
		public static void InsertMethod(this FsmState state, int index, Action<FsmStateAction> method)
		{
			DelegateAction<FsmStateAction> delegateAction = new DelegateAction<FsmStateAction>
			{
				Method = method
			};
			delegateAction.Arg = (FsmStateAction?)(object)delegateAction;
			state.InsertAction((FsmStateAction)(object)delegateAction, index);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this PlayMakerFSM fsm, string stateName, Action<Action> method, int index)
		{
			fsm.GetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this PlayMakerFSM fsm, string stateName, int index, Action<Action> method)
		{
			fsm.GetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this Fsm fsm, string stateName, Action<Action> method, int index)
		{
			fsm.GetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this Fsm fsm, string stateName, int index, Action<Action> method)
		{
			fsm.GetState(stateName).InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this FsmState state, Action<Action> method, int index)
		{
			state.InsertLambdaMethod(index, method);
		}

		[PublicAPI]
		public static void InsertLambdaMethod(this FsmState state, int index, Action<Action> method)
		{
			DelegateAction<Action> delegateAction = new DelegateAction<Action>
			{
				Method = method
			};
			delegateAction.Arg = ((FsmStateAction)delegateAction).Finish;
			state.InsertAction((FsmStateAction)(object)delegateAction, index);
		}

		[PublicAPI]
		public static void ReplaceAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.GetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this PlayMakerFSM fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.GetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this Fsm fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.GetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this Fsm fsm, string stateName, int index, FsmStateAction action)
		{
			fsm.GetState(stateName).ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this FsmState state, FsmStateAction action, int index)
		{
			state.ReplaceAction(index, action);
		}

		[PublicAPI]
		public static void ReplaceAction(this FsmState state, int index, FsmStateAction action)
		{
			state.Actions[index] = action;
			action.Init(state);
		}

		[PublicAPI]
		public static void ReplaceAllActions(this PlayMakerFSM fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.GetState(stateName).ReplaceAllActions(actions);
		}

		[PublicAPI]
		public static void ReplaceAllActions(this Fsm fsm, string stateName, params FsmStateAction[] actions)
		{
			fsm.GetState(stateName).ReplaceAllActions(actions);
		}

		[PublicAPI]
		public static void ReplaceAllActions(this FsmState state, params FsmStateAction[] actions)
		{
			state.Actions = actions;
			for (int i = 0; i < actions.Length; i++)
			{
				actions[i].Init(state);
			}
		}

		[PublicAPI]
		public static bool ChangeTransition(this PlayMakerFSM fsm, string stateName, string eventName, string toState)
		{
			return fsm.GetState(stateName).ChangeTransition(eventName, toState);
		}

		[PublicAPI]
		public static bool ChangeTransition(this Fsm fsm, string stateName, string eventName, string toState)
		{
			return fsm.GetState(stateName).ChangeTransition(eventName, toState);
		}

		[PublicAPI]
		public static bool ChangeTransition(this FsmState state, string eventName, string toState)
		{
			FsmTransition transition = state.GetTransition(eventName);
			if (transition == null)
			{
				return false;
			}
			transition.ToState = toState;
			transition.ToFsmState = state.Fsm.GetState(toState);
			return true;
		}

		[PublicAPI]
		public static bool ChangeGlobalTransition(this PlayMakerFSM fsm, string globalEventName, string toState)
		{
			return fsm.Fsm.ChangeGlobalTransition(globalEventName, toState);
		}

		[PublicAPI]
		public static bool ChangeGlobalTransition(this Fsm fsm, string globalEventName, string toState)
		{
			FsmTransition globalTransition = fsm.GetGlobalTransition(globalEventName);
			if (globalTransition == null)
			{
				return false;
			}
			globalTransition.ToState = toState;
			globalTransition.ToFsmState = fsm.GetState(toState);
			return true;
		}

		private static TVal[] RemoveItemsFromArray<TVal>(TVal[] origArray, Func<TVal, bool> shouldBeRemovedCallback)
		{
			int num = 0;
			foreach (TVal arg in origArray)
			{
				if (shouldBeRemovedCallback(arg))
				{
					num++;
				}
			}
			if (num == 0)
			{
				return origArray;
			}
			TVal[] array = new TVal[origArray.Length - num];
			for (int num2 = origArray.Length - 1; num2 >= 0; num2--)
			{
				TVal val = origArray[num2];
				if (shouldBeRemovedCallback(val))
				{
					num--;
				}
				else
				{
					array[num2 - num] = val;
				}
			}
			return array;
		}

		[PublicAPI]
		public static void RemoveState(this PlayMakerFSM fsm, string stateName)
		{
			fsm.Fsm.RemoveState(stateName);
		}

		[PublicAPI]
		public static void RemoveState(this Fsm fsm, string stateName)
		{
			string stateName2 = stateName;
			fsm.States = RemoveItemsFromArray(fsm.States, (FsmState x) => x.Name == stateName2);
		}

		[PublicAPI]
		public static void RemoveTransition(this PlayMakerFSM fsm, string stateName, string eventName)
		{
			fsm.GetState(stateName).RemoveTransition(eventName);
		}

		[PublicAPI]
		public static void RemoveTransition(this Fsm fsm, string stateName, string eventName)
		{
			fsm.GetState(stateName).RemoveTransition(eventName);
		}

		[PublicAPI]
		public static void RemoveTransition(this FsmState state, string eventName)
		{
			string eventName2 = eventName;
			state.Transitions = RemoveItemsFromArray(state.Transitions, (FsmTransition x) => x.EventName == eventName2);
		}

		[PublicAPI]
		public static void RemoveGlobalTransition(this PlayMakerFSM fsm, string globalEventName)
		{
			fsm.Fsm.RemoveGlobalTransition(globalEventName);
		}

		[PublicAPI]
		public static void RemoveGlobalTransition(this Fsm fsm, string globalEventName)
		{
			string globalEventName2 = globalEventName;
			fsm.GlobalTransitions = RemoveItemsFromArray(fsm.GlobalTransitions, (FsmTransition x) => x.EventName == globalEventName2);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this PlayMakerFSM fsm, string toState)
		{
			fsm.Fsm.RemoveTransitionsTo(toState);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this Fsm fsm, string toState)
		{
			FsmState[] states = fsm.States;
			for (int i = 0; i < states.Length; i++)
			{
				states[i].RemoveTransitionsTo(toState);
			}
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this PlayMakerFSM fsm, string stateName, string toState)
		{
			fsm.GetState(stateName).RemoveTransitionsTo(toState);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this Fsm fsm, string stateName, string toState)
		{
			fsm.GetState(stateName).RemoveTransitionsTo(toState);
		}

		[PublicAPI]
		public static void RemoveTransitionsTo(this FsmState state, string toState)
		{
			string toState2 = toState;
			state.Transitions = RemoveItemsFromArray(state.Transitions, (FsmTransition x) => x.ToState == toState2);
		}

		[PublicAPI]
		public static void RemoveTransitions(this PlayMakerFSM fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveTransitions();
		}

		[PublicAPI]
		public static void RemoveTransitions(this Fsm fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveTransitions();
		}

		[PublicAPI]
		public static void RemoveTransitions(this FsmState state)
		{
			state.Transitions = Array.Empty<FsmTransition>();
		}

		[PublicAPI]
		public static bool RemoveAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.GetState(stateName).RemoveAction(index);
		}

		[PublicAPI]
		public static bool RemoveAction(this Fsm fsm, string stateName, int index)
		{
			return fsm.GetState(stateName).RemoveAction(index);
		}

		[PublicAPI]
		public static bool RemoveAction(this FsmState state, int index)
		{
			FsmStateAction[] actions = state.Actions;
			if (index < 0 || index >= actions.Length)
			{
				return false;
			}
			FsmStateAction[] array = (FsmStateAction[])(object)new FsmStateAction[actions.Length - 1];
			int num = array.Length;
			for (int i = 0; i < index; i++)
			{
				array[i] = actions[i];
			}
			for (int i = index; i < num; i++)
			{
				array[i] = actions[i + 1];
			}
			state.Actions = array;
			return true;
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this PlayMakerFSM fsm)
		{
			fsm.Fsm.RemoveActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this Fsm fsm)
		{
			FsmState[] states = fsm.States;
			for (int i = 0; i < states.Length; i++)
			{
				states[i].RemoveActionsOfType<TAction>();
			}
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveActionsOfType<TAction>(this FsmState state)
		{
			state.Actions = RemoveItemsFromArray(state.Actions, (FsmStateAction x) => x is TAction);
		}

		[PublicAPI]
		public static void RemoveFirstActionOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveFirstActionOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveFirstActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveFirstActionOfType<TAction>(this FsmState state)
		{
			int num = -1;
			for (int i = 0; i < state.Actions.Length; i++)
			{
				if (state.Actions[i] is TAction)
				{
					num = i;
					break;
				}
			}
			if (num != -1)
			{
				state.RemoveAction(num);
			}
		}

		[PublicAPI]
		public static void RemoveLastActionOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveLastActionOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.GetState(stateName).RemoveLastActionOfType<TAction>();
		}

		[PublicAPI]
		public static void RemoveLastActionOfType<TAction>(this FsmState state)
		{
			int num = -1;
			for (int num2 = state.Actions.Length - 1; num2 >= 0; num2--)
			{
				if (state.Actions[num2] is TAction)
				{
					num = num2;
					break;
				}
			}
			if (num != -1)
			{
				state.RemoveAction(num);
			}
		}

		[PublicAPI]
		public static bool DisableAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.GetState(stateName).DisableAction(index);
		}

		[PublicAPI]
		public static bool DisableAction(this Fsm fsm, string stateName, int index)
		{
			return fsm.GetState(stateName).DisableAction(index);
		}

		[PublicAPI]
		public static bool DisableAction(this FsmState state, int index)
		{
			if (index < 0 || index >= state.Actions.Length)
			{
				return false;
			}
			state.Actions[index].Enabled = false;
			return true;
		}

		[PublicAPI]
		public static bool DisableActions(this PlayMakerFSM fsm, string stateName, params int[] indices)
		{
			return fsm.GetState(stateName).DisableActions(indices);
		}

		[PublicAPI]
		public static bool DisableActions(this Fsm fsm, string stateName, params int[] indices)
		{
			return fsm.GetState(stateName).DisableActions(indices);
		}

		[PublicAPI]
		public static bool DisableActions(this FsmState state, params int[] indices)
		{
			bool flag = true;
			foreach (int index in indices)
			{
				flag = flag && state.DisableAction(index);
			}
			return flag;
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this PlayMakerFSM fsm)
		{
			fsm.Fsm.DisableActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this Fsm fsm)
		{
			FsmState[] states = fsm.States;
			for (int i = 0; i < states.Length; i++)
			{
				states[i].DisableActionsOfType<TAction>();
			}
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this PlayMakerFSM fsm, string stateName)
		{
			fsm.GetState(stateName).DisableActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this Fsm fsm, string stateName)
		{
			fsm.GetState(stateName).DisableActionsOfType<TAction>();
		}

		[PublicAPI]
		public static void DisableActionsOfType<TAction>(this FsmState state)
		{
			FsmStateAction[] actions = state.Actions;
			foreach (FsmStateAction val in actions)
			{
				if (val is TAction)
				{
					val.Enabled = false;
				}
			}
		}

		private static TVar[] MakeNewVariableArray<TVar>(TVar[] orig, string name) where TVar : NamedVariable, new()
		{
			TVar[] array = new TVar[orig.Length + 1];
			orig.CopyTo(array, 0);
			int num = orig.Length;
			TVar val = new TVar();
			((NamedVariable)val).name = name;
			array[num] = val;
			return array;
		}

		[PublicAPI]
		public static FsmFloat AddFloatVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddFloatVariable(name);
		}

		[PublicAPI]
		public static FsmFloat AddFloatVariable(this Fsm fsm, string name)
		{
			FsmFloat[] array = MakeNewVariableArray<FsmFloat>(fsm.Variables.FloatVariables, name);
			fsm.Variables.FloatVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmInt AddIntVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddIntVariable(name);
		}

		[PublicAPI]
		public static FsmInt AddIntVariable(this Fsm fsm, string name)
		{
			FsmInt[] array = MakeNewVariableArray<FsmInt>(fsm.Variables.IntVariables, name);
			fsm.Variables.IntVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmBool AddBoolVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddBoolVariable(name);
		}

		[PublicAPI]
		public static FsmBool AddBoolVariable(this Fsm fsm, string name)
		{
			FsmBool[] array = MakeNewVariableArray<FsmBool>(fsm.Variables.BoolVariables, name);
			fsm.Variables.BoolVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmString AddStringVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddStringVariable(name);
		}

		[PublicAPI]
		public static FsmString AddStringVariable(this Fsm fsm, string name)
		{
			FsmString[] array = MakeNewVariableArray<FsmString>(fsm.Variables.StringVariables, name);
			fsm.Variables.StringVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmVector2 AddVector2Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector2 AddVector2Variable(this Fsm fsm, string name)
		{
			FsmVector2[] array = MakeNewVariableArray<FsmVector2>(fsm.Variables.Vector2Variables, name);
			fsm.Variables.Vector2Variables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmVector3 AddVector3Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddVector3Variable(name);
		}

		[PublicAPI]
		public static FsmVector3 AddVector3Variable(this Fsm fsm, string name)
		{
			FsmVector3[] array = MakeNewVariableArray<FsmVector3>(fsm.Variables.Vector3Variables, name);
			fsm.Variables.Vector3Variables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmColor AddColorVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddColorVariable(name);
		}

		[PublicAPI]
		public static FsmColor AddColorVariable(this Fsm fsm, string name)
		{
			FsmColor[] array = MakeNewVariableArray<FsmColor>(fsm.Variables.ColorVariables, name);
			fsm.Variables.ColorVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmRect AddRectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddRectVariable(name);
		}

		[PublicAPI]
		public static FsmRect AddRectVariable(this Fsm fsm, string name)
		{
			FsmRect[] array = MakeNewVariableArray<FsmRect>(fsm.Variables.RectVariables, name);
			fsm.Variables.RectVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmQuaternion AddQuaternionVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion AddQuaternionVariable(this Fsm fsm, string name)
		{
			FsmQuaternion[] array = MakeNewVariableArray<FsmQuaternion>(fsm.Variables.QuaternionVariables, name);
			fsm.Variables.QuaternionVariables = array;
			return array[^1];
		}

		[PublicAPI]
		public static FsmGameObject AddGameObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.AddGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject AddGameObjectVariable(this Fsm fsm, string name)
		{
			FsmGameObject[] array = MakeNewVariableArray<FsmGameObject>(fsm.Variables.GameObjectVariables, name);
			fsm.Variables.GameObjectVariables = array;
			return array[^1];
		}

		private static TVar? FindInVariableArray<TVar>(TVar[] orig, string name) where TVar : NamedVariable, new()
		{
			foreach (TVar val in orig)
			{
				if (((NamedVariable)val).Name == name)
				{
					return val;
				}
			}
			return default(TVar);
		}

		[PublicAPI]
		public static FsmFloat? FindFloatVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindFloatVariable(name);
		}

		[PublicAPI]
		public static FsmFloat? FindFloatVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmFloat>(fsm.Variables.FloatVariables, name);
		}

		[PublicAPI]
		public static FsmInt? FindIntVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindIntVariable(name);
		}

		[PublicAPI]
		public static FsmInt? FindIntVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmInt>(fsm.Variables.IntVariables, name);
		}

		[PublicAPI]
		public static FsmBool? FindBoolVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindBoolVariable(name);
		}

		[PublicAPI]
		public static FsmBool? FindBoolVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmBool>(fsm.Variables.BoolVariables, name);
		}

		[PublicAPI]
		public static FsmString? FindStringVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindStringVariable(name);
		}

		[PublicAPI]
		public static FsmString? FindStringVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmString>(fsm.Variables.StringVariables, name);
		}

		[PublicAPI]
		public static FsmVector2? FindVector2Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector2? FindVector2Variable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmVector2>(fsm.Variables.Vector2Variables, name);
		}

		[PublicAPI]
		public static FsmVector3? FindVector3Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindVector3Variable(name);
		}

		[PublicAPI]
		public static FsmVector3? FindVector3Variable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmVector3>(fsm.Variables.Vector3Variables, name);
		}

		[PublicAPI]
		public static FsmColor? FindColorVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindColorVariable(name);
		}

		[PublicAPI]
		public static FsmColor? FindColorVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmColor>(fsm.Variables.ColorVariables, name);
		}

		[PublicAPI]
		public static FsmRect? FindRectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindRectVariable(name);
		}

		[PublicAPI]
		public static FsmRect? FindRectVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmRect>(fsm.Variables.RectVariables, name);
		}

		[PublicAPI]
		public static FsmQuaternion? FindQuaternionVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion? FindQuaternionVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmQuaternion>(fsm.Variables.QuaternionVariables, name);
		}

		[PublicAPI]
		public static FsmGameObject? FindGameObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.FindGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject? FindGameObjectVariable(this Fsm fsm, string name)
		{
			return FindInVariableArray<FsmGameObject>(fsm.Variables.GameObjectVariables, name);
		}

		[PublicAPI]
		public static FsmFloat GetFloatVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetFloatVariable(name);
		}

		[PublicAPI]
		public static FsmFloat GetFloatVariable(this Fsm fsm, string name)
		{
			FsmFloat val = fsm.FindFloatVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddFloatVariable(name);
		}

		[PublicAPI]
		public static FsmInt GetIntVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetIntVariable(name);
		}

		[PublicAPI]
		public static FsmInt GetIntVariable(this Fsm fsm, string name)
		{
			FsmInt val = fsm.FindIntVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddIntVariable(name);
		}

		[PublicAPI]
		public static FsmBool GetBoolVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetBoolVariable(name);
		}

		[PublicAPI]
		public static FsmBool GetBoolVariable(this Fsm fsm, string name)
		{
			FsmBool val = fsm.FindBoolVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddBoolVariable(name);
		}

		[PublicAPI]
		public static FsmString GetStringVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetStringVariable(name);
		}

		[PublicAPI]
		public static FsmString GetStringVariable(this Fsm fsm, string name)
		{
			FsmString val = fsm.FindStringVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddStringVariable(name);
		}

		[PublicAPI]
		public static FsmVector2 GetVector2Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector2 GetVector2Variable(this Fsm fsm, string name)
		{
			FsmVector2 val = fsm.FindVector2Variable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddVector2Variable(name);
		}

		[PublicAPI]
		public static FsmVector3 GetVector3Variable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetVector3Variable(name);
		}

		[PublicAPI]
		public static FsmVector3 GetVector3Variable(this Fsm fsm, string name)
		{
			FsmVector3 val = fsm.FindVector3Variable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddVector3Variable(name);
		}

		[PublicAPI]
		public static FsmColor GetColorVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetColorVariable(name);
		}

		[PublicAPI]
		public static FsmColor GetColorVariable(this Fsm fsm, string name)
		{
			FsmColor val = fsm.FindColorVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddColorVariable(name);
		}

		[PublicAPI]
		public static FsmRect GetRectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetRectVariable(name);
		}

		[PublicAPI]
		public static FsmRect GetRectVariable(this Fsm fsm, string name)
		{
			FsmRect val = fsm.FindRectVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddRectVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion GetQuaternionVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmQuaternion GetQuaternionVariable(this Fsm fsm, string name)
		{
			FsmQuaternion val = fsm.FindQuaternionVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddQuaternionVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject GetGameObjectVariable(this PlayMakerFSM fsm, string name)
		{
			return fsm.Fsm.GetGameObjectVariable(name);
		}

		[PublicAPI]
		public static FsmGameObject GetGameObjectVariable(this Fsm fsm, string name)
		{
			FsmGameObject val = fsm.FindGameObjectVariable(name);
			if (val != null)
			{
				return val;
			}
			return fsm.AddGameObjectVariable(name);
		}

		[PublicAPI]
		public static void MakeLog(this PlayMakerFSM fsm, bool additionalLogging = false)
		{
			fsm.Fsm.MakeLog(additionalLogging);
		}

		[PublicAPI]
		public static void MakeLog(this Fsm fsm, bool additionalLogging = false)
		{
			Fsm fsm2 = fsm;
			FsmState[] states = fsm2.States;
			foreach (FsmState val in states)
			{
				for (int num = val.Actions.Length - 1; num >= 0; num--)
				{
					fsm2.InsertAction(val.Name, (FsmStateAction)(object)new LogAction
					{
						Text = FsmString.op_Implicit($"{num}")
					}, num);
					if (additionalLogging)
					{
						fsm2.InsertMethod(val.Name, delegate
						{
							//IL_018c: Unknown result type (might be due to invalid IL or missing references)
							//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
							//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
							//IL_0212: Unknown result type (might be due to invalid IL or missing references)
							//IL_0226: Unknown result type (might be due to invalid IL or missing references)
							//IL_0276: Unknown result type (might be due to invalid IL or missing references)
							//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
							//IL_030a: Unknown result type (might be due to invalid IL or missing references)
							FsmVariables variables = fsm2.Variables;
							FsmFloat[] floatVariables = variables.FloatVariables;
							foreach (FsmFloat val2 in floatVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[FloatVariables] - '{((NamedVariable)val2).Name}': '{val2.Value}'");
							}
							FsmInt[] intVariables = variables.IntVariables;
							foreach (FsmInt val3 in intVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[IntVariables] - '{((NamedVariable)val3).Name}': '{val3.Value}'");
							}
							FsmBool[] boolVariables = variables.BoolVariables;
							foreach (FsmBool val4 in boolVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[BoolVariables] - '{((NamedVariable)val4).Name}': '{val4.Value}'");
							}
							FsmString[] stringVariables = variables.StringVariables;
							foreach (FsmString val5 in stringVariables)
							{
								InternalLogger.Log("[" + fsm2.Name + "]:[StringVariables] - '" + ((NamedVariable)val5).Name + "': '" + val5.Value + "'");
							}
							FsmVector2[] vector2Variables = variables.Vector2Variables;
							foreach (FsmVector2 val6 in vector2Variables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[Vector2Variables] - '{((NamedVariable)val6).Name}': '({val6.Value.x}, {val6.Value.y})'");
							}
							FsmVector3[] vector3Variables = variables.Vector3Variables;
							foreach (FsmVector3 val7 in vector3Variables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[Vector3Variables] - '{((NamedVariable)val7).Name}': '({val7.Value.x}, {val7.Value.y}, {val7.Value.z})'");
							}
							FsmColor[] colorVariables = variables.ColorVariables;
							foreach (FsmColor val8 in colorVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[ColorVariables] - '{((NamedVariable)val8).Name}': '{val8.Value}'");
							}
							FsmRect[] rectVariables = variables.RectVariables;
							foreach (FsmRect val9 in rectVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[RectVariables] - '{((NamedVariable)val9).Name}': '{val9.Value}'");
							}
							FsmQuaternion[] quaternionVariables = variables.QuaternionVariables;
							foreach (FsmQuaternion val10 in quaternionVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[QuaternionVariables] - '{((NamedVariable)val10).Name}': '{val10.Value}'");
							}
							FsmGameObject[] gameObjectVariables = variables.GameObjectVariables;
							foreach (FsmGameObject val11 in gameObjectVariables)
							{
								InternalLogger.Log($"[{fsm2.Name}]:[GameObjectVariables] - '{((NamedVariable)val11).Name}': '{val11.Value}'");
							}
						}, num + 1);
					}
				}
			}
		}

		[PublicAPI]
		public static void Log(this PlayMakerFSM fsm)
		{
			fsm.Fsm.Log();
		}

		[PublicAPI]
		public static void Log(this Fsm fsm)
		{
			Log("FSM \"" + fsm.Name + "\"");
			Log($"{fsm.States.Length} States");
			FsmState[] states = fsm.States;
			FsmTransition[] transitions;
			foreach (FsmState val in states)
			{
				Log("\tState \"" + val.Name + "\"");
				transitions = val.Transitions;
				foreach (FsmTransition val2 in transitions)
				{
					Log("\t\t-> \"" + val2.ToState + "\" via \"" + val2.EventName + "\"");
				}
			}
			Log($"{fsm.GlobalTransitions.Length} Global Transitions");
			transitions = fsm.GlobalTransitions;
			foreach (FsmTransition val3 in transitions)
			{
				Log("\tGlobal Transition \"" + val3.EventName + "\" to \"" + val3.ToState + "\"");
			}
		}

		private static void Log(string msg)
		{
			InternalLogger.Log("[Core]:[FsmUtil]:[FsmUtil] - " + msg);
		}
	}
	internal static class InternalLogger
	{
		internal static ManualLogSource? Logger;

		internal static void LogFine(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogDebug((object)message);
			}
		}

		internal static void LogDebug(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogInfo((object)message);
			}
			Debug.Log((object)message);
		}

		internal static void Log(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogMessage((object)message);
			}
			Debug.Log((object)message);
		}

		internal static void LogWarn(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogWarning((object)message);
			}
			Debug.LogWarning((object)message);
		}

		internal static void LogError(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogError((object)message);
			}
			Debug.LogError((object)message);
		}

		internal static void LogFatal(string message)
		{
			ManualLogSource? logger = Logger;
			if (logger != null)
			{
				logger.LogFatal((object)message);
			}
			Debug.LogError((object)message);
		}
	}
	[BepInPlugin("org.silksong-modding.fsmutil", "Silksong.FsmUtil", "0.3.1")]
	public class Plugin : BaseUnityPlugin
	{
		public const string Id = "org.silksong-modding.fsmutil";

		public static string Name => "Silksong.FsmUtil";

		public static string Version => "0.3.1";

		private void Awake()
		{
			InternalLogger.Logger = ((BaseUnityPlugin)this).Logger;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (org.silksong-modding.fsmutil) has loaded!"));
		}
	}
}
namespace Silksong.FsmUtil.Actions
{
	public class DelegateAction<TArg> : FsmStateAction
	{
		public Action<TArg>? Method;

		public TArg? Arg;

		public override void Reset()
		{
			Method = null;
			((FsmStateAction)this).Reset();
		}

		public override void OnEnter()
		{
			if (Method != null && Arg != null)
			{
				Method(Arg);
			}
			if (!((object)Arg is Action action) || action != new Action(base.Finish))
			{
				((FsmStateAction)this).Finish();
			}
		}
	}
	public class LogAction : SimpleLogAction
	{
		public override void OnEnter()
		{
			if (Text.Value != null)
			{
				Log(Text.Value ?? "");
			}
			((FsmStateAction)this).Finish();
		}

		private void Log(string message)
		{
			string text = ((FsmStateAction)this).Fsm.GameObjectName;
			Transform parent = ((FsmStateAction)this).Fsm.GameObject.transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)((Component)parent).gameObject).name + "/" + text;
				parent = parent.parent;
			}
			InternalLogger.Log("[" + text + "]:[" + ((FsmStateAction)this).Fsm.Name + "]:[" + ((FsmStateAction)this).State.Name + "] - " + message);
		}
	}
	public class SimpleLogAction : FsmStateAction
	{
		public FsmString Text;

		public override void Reset()
		{
			Text = FsmString.op_Implicit(string.Empty);
			((FsmStateAction)this).Reset();
		}

		public override void OnEnter()
		{
			if (Text.Value != null)
			{
				Log("FSM Log: \"" + Text.Value + "\"");
			}
			((FsmStateAction)this).Finish();
		}

		private static void Log(string message)
		{
			InternalLogger.Log("[Core]:[FsmUtil]:[LogAction] - " + message);
		}
	}
}