using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using GlobalEnums;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using LostAndChained.Components;
using LostAndChained.GMSPhases.Attacks;
using LostAndChained.GMSPhases.Three;
using LostAndChained.GMSPhases.Two;
using LostAndChained.LacePhases.Attacks;
using LostAndChained.LacePhases.Awaits;
using LostAndChained.LacePhases.Extras;
using LostAndChained.LacePhases.Movement;
using LostAndChained.LacePhases.One;
using LostAndChained.LacePhases.Three;
using LostAndChained.LacePhases.Two;
using LostAndChained.LacePhases._4;
using LostAndChained.Patches;
using LostAndChained.Phases.Attacks;
using LostAndChained.Phases.One;
using Microsoft.CodeAnalysis;
using Silksong.AssetHelper.ManagedAssets;
using Silksong.FsmUtil;
using TMProOld;
using TeamCherry.Localization;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LostAndChained")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.1.4.0")]
[assembly: AssemblyInformationalVersion("0.1.4+7a2edf4535c187befba4671713138b19e181216a")]
[assembly: AssemblyProduct("LostAndChained")]
[assembly: AssemblyTitle("LostAndChained")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Samihamer1/Silksong-LostAndChained")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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")]
	[Microsoft.CodeAnalysis.Embedded]
	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")]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace LostAndChained
{
	internal class Constants
	{
		internal static class PhaseNames
		{
			public static readonly string Idle1 = "IDLE1";

			public static readonly string Idle2 = "IDLE2";

			public static readonly string Idle3 = "IDLE3";

			public static readonly string Idle4 = "IDLE4";
		}

		internal static class PhaseValues
		{
			public static readonly int Phase1HP = 500;

			public static readonly int Phase2HP = 600;

			public static readonly int Phase3HP = 800;

			public static readonly int Phase4HP = 1000;
		}

		internal static class Constraints
		{
			public static float GMSMinX = 7f;

			public static float GMSMaxX = 52f;

			public static float ArenaCenterX = 33.5f;

			public static float ArenaCenterY = 10.5f;

			public static float GroundY = 4.5f;

			public static float LaceLandY = 6.4f;
		}
	}
	public static class Helper
	{
		public static GameObject Child(this GameObject go, string name)
		{
			return ((Component)go.transform.Find(name)).gameObject;
		}

		public static List<GameObject> GetAllDescendants(GameObject root)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			List<GameObject> list = new List<GameObject>();
			Stack<Transform> stack = new Stack<Transform>();
			stack.Push(root.transform);
			while (stack.Count > 0)
			{
				Transform val = stack.Pop();
				foreach (Transform item in val)
				{
					Transform val2 = item;
					list.Add(((Component)val2).gameObject);
					stack.Push(val2);
				}
			}
			return list;
		}

		public static void CreateTempRoar(GameObject spawnpoint)
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)((Component)((Component)GameManager.instance.gameCams).gameObject.transform.Find("Roar Wave Emitter")).gameObject == (Object)null))
			{
				GameObject val = Object.Instantiate<GameObject>(((Component)((Component)GameManager.instance.gameCams).gameObject.transform.Find("Roar Wave Emitter")).gameObject);
				((Object)val).name = "Temp Roar";
				PlayMakerFSM fsmPreprocessed = FsmUtil.GetFsmPreprocessed(val, "Control");
				fsmPreprocessed.SetState("Init");
				FsmUtil.RemoveGlobalTransition(fsmPreprocessed, "ROAR WAVE END");
				val.transform.parent = spawnpoint.transform;
				val.transform.localPosition = Vector3.zeroVector;
			}
		}

		public static void StartTempRoar(GameObject spawnpoint)
		{
			GameObject val = spawnpoint.Child("Temp Roar");
			if (!((Object)(object)val == (Object)null))
			{
				PlayMakerFSM fsmPreprocessed = FsmUtil.GetFsmPreprocessed(val, "Control");
				fsmPreprocessed.SetState("Emit Start");
			}
		}

		public static void EndTempRoar(GameObject spawnpoint)
		{
			GameObject val = spawnpoint.Child("Temp Roar");
			if ((Object)(object)val != (Object)null)
			{
				PlayMakerFSM val2 = FSMUtility.LocateMyFSM(val, "Control");
				val2.SendEvent("END");
			}
		}

		public static void CloneAnimation(tk2dSpriteAnimation library, string originalName, string newName, float fpsModifier)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			tk2dSpriteAnimationClip clipByName = library.GetClipByName(originalName);
			tk2dSpriteAnimationClip val = new tk2dSpriteAnimationClip();
			val.CopyFrom(clipByName);
			val.fps = clipByName.fps * fpsModifier;
			val.name = newName;
			List<tk2dSpriteAnimationClip> list = library.clips.ToList();
			list.Add(val);
			library.clips = list.ToArray();
			library.isValid = false;
			library.ValidateLookup();
		}
	}
	public static class Log
	{
		private static bool debug;

		public static void Info(object message)
		{
			if ((Object)(object)LostAndChainedPlugin.Instance != (Object)null)
			{
				LostAndChainedPlugin.Instance.LogInfo(message);
			}
		}

		public static void Error(object message)
		{
			if ((Object)(object)LostAndChainedPlugin.Instance != (Object)null)
			{
				LostAndChainedPlugin.Instance.LogError(message);
			}
		}

		public static void Debug(object message)
		{
			if ((Object)(object)LostAndChainedPlugin.Instance != (Object)null && debug)
			{
				LostAndChainedPlugin.Instance.LogDebug(message);
			}
		}

		public static void Warn(object message)
		{
			if ((Object)(object)LostAndChainedPlugin.Instance != (Object)null)
			{
				LostAndChainedPlugin.Instance.LogWarn(message);
			}
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("io.github.samihamer1.lostandchained", "LostAndChained", "0.1.4")]
	public class LostAndChainedPlugin : BaseUnityPlugin
	{
		private static Harmony _harmony;

		public static LostAndChainedPlugin? Instance;

		public ManagedAsset<GameObject> SilkBossScene;

		public ManagedAsset<AudioClip> SilkNeedleAntic;

		public ManagedAsset<AudioClip> SilkNeedleThrow1;

		public ManagedAsset<AudioClip> SilkNeedleThrow2;

		public ManagedAsset<AudioClip> SilkNeedleImpact1;

		public ManagedAsset<AudioClip> SilkNeedleImpact2;

		public ManagedAsset<AudioClip> SilkNeedleImpact3;

		public ManagedAsset<MusicCue> hornetTheme;

		public const string Id = "io.github.samihamer1.lostandchained";

		public static string Name => "LostAndChained";

		public static string Version => "0.1.4";

		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			_harmony = new Harmony("io.github.samihamer1.lostandchained");
			Instance = this;
			_harmony.PatchAll(typeof(LostLacePatches));
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin " + Name + " (io.github.samihamer1.lostandchained) has loaded!"));
			SilkBossScene = ManagedAsset<GameObject>.FromSceneAsset("Cradle_03", "Boss Scene");
			SilkNeedleAntic = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/SFX/HornetEnemy/Silk Boss/silk_boss_needle_antic.wav", "sfxstatic_assets_areacradle");
			SilkNeedleThrow1 = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/SFX/HornetEnemy/Silk Boss/silk_boss_needle_throw_1.wav", "sfxstatic_assets_areacradle");
			SilkNeedleThrow2 = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/SFX/HornetEnemy/Silk Boss/silk_boss_needle_throw_2.wav", "sfxstatic_assets_areacradle");
			SilkNeedleImpact1 = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/SFX/HornetEnemy/Silk Boss/silk_boss_needle_impact_1.wav", "sfxstatic_assets_areacradle");
			SilkNeedleImpact2 = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/SFX/HornetEnemy/Silk Boss/silk_boss_needle_impact_2.wav", "sfxstatic_assets_areacradle");
			SilkNeedleImpact3 = ManagedAsset<AudioClip>.FromNonSceneAsset("Assets/Audio/SFX/HornetEnemy/Silk Boss/silk_boss_needle_impact_3.wav", "sfxstatic_assets_areacradle");
			hornetTheme = ManagedAsset<MusicCue>.FromNonSceneAsset("Assets/Audio/MusicCues/Cloak Battle.asset", "audiocuesdynamic_assets_areaslab");
		}

		public void UpdateEvolvedHP(int newHP)
		{
			GameObject val = ((Component)HudCanvas.instance).gameObject.Child("Thread");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject val2 = val.Child("Spool");
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			GameObject val3 = val2.Child("Bind Orb");
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			GameObject val4 = val3.Child("Evolved");
			if ((Object)(object)val4 == (Object)null)
			{
				return;
			}
			GameObject val5 = val4.Child("Fake Health");
			if ((Object)(object)val5 == (Object)null || !val4.activeSelf)
			{
				return;
			}
			IconCounter component = val5.GetComponent<IconCounter>();
			int currentValue = component.currentValue;
			for (int i = 1; i < val5.transform.childCount; i++)
			{
				GameObject gameObject = ((Component)val5.transform.GetChild(i)).gameObject;
				IconCounterItem component2 = gameObject.GetComponent<IconCounterItem>();
				if (i <= newHP && i > currentValue && newHP > currentValue)
				{
					gameObject.SetActive(false);
				}
			}
			component.SetCurrent(newHP);
		}

		public void ModifyEvolvedHPBar()
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = ((Component)HudCanvas.instance).gameObject.Child("Thread");
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameObject val2 = val.Child("Spool");
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			GameObject val3 = val2.Child("Bind Orb");
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			GameObject val4 = val3.Child("Evolved");
			if (!((Object)(object)val4 == (Object)null))
			{
				GameObject val5 = val4.Child("Fake Health");
				if (!((Object)(object)val5 == (Object)null))
				{
					GameObject val6 = val5.Child("Health");
					IconCounterItem component = val6.GetComponent<IconCounterItem>();
					component.inactiveDisable = false;
					component.inactiveState.Color = new Color(0f, 0f, 0f, 1f);
				}
			}
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
		}

		public void LogInfo(object message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)("[" + Name + "][Info]: " + message));
		}

		public void LogError(object message)
		{
			((BaseUnityPlugin)this).Logger.LogError((object)("[" + Name + "][Error]: " + message));
		}

		public void LogDebug(object message)
		{
			((BaseUnityPlugin)this).Logger.LogDebug((object)("[" + Name + "][Debug]: " + message));
		}

		public void LogWarn(object message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)("[" + Name + "][Warning]: " + message));
		}
	}
}
namespace LostAndChained.Patches
{
	internal static class LostLacePatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayMakerFSM), "Start")]
		private static void ModifyBoss(PlayMakerFSM __instance)
		{
			if (((Object)__instance).name == "Lost Lace Boss" && __instance.FsmName == "Control" && ((Component)__instance).gameObject.layer == LayerMask.NameToLayer("Enemies"))
			{
				((Component)((Component)__instance).gameObject.transform.parent).gameObject.AddComponent<LaceBossScene>();
				LostAndChainedPlugin.Instance.ModifyEvolvedHPBar();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameManager), "Awake")]
		private static void InitResourceLoader(GameManager __instance)
		{
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FsmState), "OnEnter")]
		private static void LogLaceState(FsmState __instance)
		{
			if (((Object)__instance.fsm.GameObject).name == "Lost Lace Boss" && __instance.fsm.name == "Control")
			{
				Log.Debug("Entered state: " + __instance.Name + " , layer " + __instance.fsm.GameObject.layer + ", splashed in " + (object)__instance.fsm.GetFsmBool("Splashed In"));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerData), "AddHealth")]
		private static void UpdateEvolvedOnAdd(PlayerData __instance)
		{
			LostAndChainedPlugin.Instance.UpdateEvolvedHP(__instance.health);
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerData), "TakeHealth")]
		private static void UpdateEvolvedOnTake(PlayerData __instance)
		{
			LostAndChainedPlugin.Instance.UpdateEvolvedHP(__instance.health);
		}
	}
}
namespace LostAndChained.LacePhases.Two
{
	internal class LaceIdle2 : BasePhase
	{
		public LaceIdle2(PlayMakerFSM controlFSM)
			: base(controlFSM)
		{
		}

		public override string GetControlStateName()
		{
			return Constants.PhaseNames.Idle2;
		}

		public override void Init()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Expected O, but got Unknown
			bool activateTransition = true;
			FsmState val = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle2 + " Attack");
			SendRandomEventV4 val2 = new SendRandomEventV4();
			val2.events = (FsmEvent[])(object)new FsmEvent[3]
			{
				FsmEvent.GetFsmEvent("JUMPSLASHCOMBO"),
				FsmEvent.GetFsmEvent("PURSUER"),
				FsmEvent.GetFsmEvent("SLASHCOMBO")
			};
			val2.weights = (FsmFloat[])(object)new FsmFloat[3]
			{
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f))
			};
			val2.eventMax = (FsmInt[])(object)new FsmInt[3]
			{
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2))
			};
			val2.missedMax = (FsmInt[])(object)new FsmInt[3]
			{
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4))
			};
			val2.activeBool = FsmBool.op_Implicit(true);
			FsmUtil.AddAction(val, (FsmStateAction)(object)val2);
			FsmUtil.AddTransition(val, "JUMPSLASHCOMBO", LaceAttackList.JumpslashTendrilDive.GetStartStateName());
			FsmUtil.AddTransition(val, "PURSUER", LaceAttackList.PursuerChargeDive.GetStartStateName());
			FsmUtil.AddTransition(val, "SLASHCOMBO", LaceAttackList.SlashChargeTendrilDive.GetStartStateName());
			FsmState val3 = FsmUtil.CopyState(_controlFSM, "Idle", Constants.PhaseNames.Idle2);
			FsmUtil.RemoveAction(val3, 0);
			FsmUtil.RemoveFirstActionOfType<Tk2dPlayAnimation>(val3);
			FsmUtil.InsertMethod(val3, 0, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = false;
				if (activateTransition)
				{
					activateTransition = false;
					LaceBossScene.Instance.phaseActive = true;
					((Component)_controlFSM).gameObject.GetComponent<HealthManager>().hp = Constants.PhaseValues.Phase2HP;
					_controlFSM.SendEvent("PHASE2");
				}
				if (!FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					((Component)_controlFSM).gameObject.GetComponent<tk2dSpriteAnimator>().Play("Idle");
					if (Random.Range(0, 3) == 0)
					{
						FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = true;
					}
				}
			});
			FsmUtil.AddAction(val3, (FsmStateAction)new Wait
			{
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("ATTACK"),
				time = FsmFloat.op_Implicit(0.7f)
			});
			FsmUtil.ChangeTransition(val3, "ATTACK", val.name);
			FsmUtil.AddTransition(val3, "PHASE2", LaceAttackList.Phase2Shift.GetStartStateName());
			FsmUtil.ChangeTransition(val3, "COUNTER", LaceAttackList.Counter.GetStartStateName());
			FsmUtil.ChangeTransition(val3, "TOOK DAMAGE", val.name);
			FsmUtil.RemoveTransition(val3, "EVADE");
		}
	}
	internal class LacePhase2Shift : BaseAttack
	{
		public LacePhase2Shift(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Phase 2 Shift";
		}

		public override string GetStartStateNamePure()
		{
			return "P2 Shift 1-2";
		}

		public override void Init()
		{
			FsmState val = CopyState("P2 Shift 1", "P2 Shift 1-2");
			FsmState val2 = CopyState("P2 Shift 2", "P2 Shift 2-2");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", _endStateName);
		}
	}
}
namespace LostAndChained.LacePhases.Three
{
	internal class LaceIdle3 : BasePhase
	{
		public LaceIdle3(PlayMakerFSM controlFSM)
			: base(controlFSM)
		{
		}

		public override string GetControlStateName()
		{
			return Constants.PhaseNames.Idle3;
		}

		public override void Init()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Expected O, but got Unknown
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Expected O, but got Unknown
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Expected O, but got Unknown
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Expected O, but got Unknown
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Expected O, but got Unknown
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Expected O, but got Unknown
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Expected O, but got Unknown
			bool activateTransition = true;
			FsmState val = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle3 + " Attack");
			FsmState val2 = FsmUtil.CopyState(_controlFSM, "Idle", Constants.PhaseNames.Idle3);
			FsmState val3 = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle3 + " Combo Attack Choice");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				if (HeroController.instance.transform.position.y >= 16f)
				{
					_controlFSM.SendEvent("HEIGHTSNIPE");
				}
			});
			SendRandomEventV4 val4 = new SendRandomEventV4();
			val4.events = (FsmEvent[])(object)new FsmEvent[5]
			{
				FsmEvent.GetFsmEvent("JUMPSLASHCOMBO"),
				FsmEvent.GetFsmEvent("PURSUER"),
				FsmEvent.GetFsmEvent("SLASHCOMBO"),
				FsmEvent.GetFsmEvent("COMBOATTACK"),
				FsmEvent.GetFsmEvent("PULLUPCOUNTER")
			};
			val4.weights = (FsmFloat[])(object)new FsmFloat[5]
			{
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(2f)),
				new FsmFloat(FsmFloat.op_Implicit(1f))
			};
			val4.eventMax = (FsmInt[])(object)new FsmInt[5]
			{
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(1)),
				new FsmInt(FsmInt.op_Implicit(1))
			};
			val4.missedMax = (FsmInt[])(object)new FsmInt[5]
			{
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4))
			};
			val4.activeBool = FsmBool.op_Implicit(true);
			FsmUtil.AddAction(val, (FsmStateAction)(object)val4);
			FsmUtil.AddTransition(val, "JUMPSLASHCOMBO", LaceAttackList.JumpslashTendrilDive.GetStartStateName());
			FsmUtil.AddTransition(val, "PURSUER", LaceAttackList.ChargeJumpslashHold.GetStartStateName());
			FsmUtil.AddTransition(val, "SLASHCOMBO", LaceAttackList.SlashChargeTendrilDive.GetStartStateName());
			FsmUtil.AddTransition(val, "COMBOATTACK", val3.name);
			FsmUtil.AddTransition(val, "PULLUPCOUNTER", LaceAttackList.PullUpCounter.GetStartStateName());
			FsmUtil.AddTransition(val, "HEIGHTSNIPE", LaceAttackList.PullUpRapidStab.GetStartStateName());
			FsmUtil.RemoveAction(val2, 0);
			FsmUtil.RemoveFirstActionOfType<Tk2dPlayAnimation>(val2);
			FsmUtil.InsertMethod(val2, 0, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = false;
				if (activateTransition)
				{
					activateTransition = false;
					LaceBossScene.Instance.phaseActive = true;
					((Component)_controlFSM).gameObject.GetComponent<HealthManager>().hp = Constants.PhaseValues.Phase3HP;
				}
				if (!FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					((Component)_controlFSM).gameObject.GetComponent<tk2dSpriteAnimator>().Play("Idle");
					if (Random.Range(0, 3) == 0)
					{
						FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = true;
					}
				}
			});
			FsmUtil.AddAction(val2, (FsmStateAction)new Wait
			{
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("ATTACK"),
				time = FsmFloat.op_Implicit(0.85f)
			});
			FsmUtil.ChangeTransition(val2, "ATTACK", val.name);
			FsmUtil.ChangeTransition(val2, "COUNTER", LaceAttackList.Counter.GetStartStateName());
			FsmUtil.ChangeTransition(val2, "TOOK DAMAGE", val.name);
			FsmUtil.RemoveTransition(val2, "EVADE");
			val4 = new SendRandomEventV4();
			val4.events = (FsmEvent[])(object)new FsmEvent[2]
			{
				FsmEvent.GetFsmEvent("WEB"),
				FsmEvent.GetFsmEvent("CLAW")
			};
			val4.weights = (FsmFloat[])(object)new FsmFloat[2]
			{
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f))
			};
			val4.eventMax = (FsmInt[])(object)new FsmInt[2]
			{
				new FsmInt(FsmInt.op_Implicit(1)),
				new FsmInt(FsmInt.op_Implicit(1))
			};
			val4.missedMax = (FsmInt[])(object)new FsmInt[2]
			{
				new FsmInt(FsmInt.op_Implicit(3)),
				new FsmInt(FsmInt.op_Implicit(3))
			};
			val4.activeBool = FsmBool.op_Implicit(true);
			FsmUtil.AddAction(val3, (FsmStateAction)(object)val4);
			FsmUtil.AddTransition(val3, "WEB", LaceAttackList.ComboWeb.GetStartStateName());
			FsmUtil.AddTransition(val3, "CLAW", LaceAttackList.ComboClawShot.GetStartStateName());
		}
	}
}
namespace LostAndChained.LacePhases.One
{
	internal class LaceIdle1 : BasePhase
	{
		public LaceIdle1(PlayMakerFSM controlFSM)
			: base(controlFSM)
		{
		}

		public override string GetControlStateName()
		{
			return Constants.PhaseNames.Idle1;
		}

		public override void Init()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			FsmState val = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle1 + " Attack");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (Random.Range(0, 2) == 0)
				{
					_controlFSM.SendEvent("TENDRIL");
				}
				_controlFSM.SendEvent("CHARGE");
			});
			FsmUtil.AddTransition(val, "TENDRIL", LaceAttackList.TendrilIntoDive.GetStartStateName());
			FsmUtil.AddTransition(val, "CHARGE", LaceAttackList.ChargeIntoDive.GetStartStateName());
			FsmState val2 = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle1);
			FsmUtil.AddTransition(val2, "SPLASHIN", LaceAttackList.SplashIn.GetStartStateName());
			FsmUtil.AddMethod(val2, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Can Tendril Emerge").value = false;
				FsmUtil.GetBoolVariable(_controlFSM, "Can Hop Up").value = false;
				FsmUtil.GetBoolVariable(_controlFSM, "Did Thread Roar").value = false;
				if (!FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					_controlFSM.SendEvent("SPLASHIN");
				}
			});
			FsmUtil.AddAction(val2, (FsmStateAction)new Wait
			{
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("ATTACK"),
				time = FsmFloat.op_Implicit(2.5f)
			});
			FsmUtil.AddTransition(val2, "ATTACK", val.name);
		}
	}
}
namespace LostAndChained.LacePhases.Movement
{
	internal abstract class LaceBaseSplashOut : BaseAttack
	{
		private FsmState _configState;

		private FsmState _overrideState;

		public LaceBaseSplashOut(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public void SetTeleportConfig(LaceTeleportConfig config)
		{
			FsmUtil.GetFloatVariable(_controlFSM, "Distance Min").value = config.distanceMin;
			FsmUtil.GetFloatVariable(_controlFSM, "Distance Max").value = config.distanceMax;
			FsmUtil.GetFloatVariable(_controlFSM, "Distance Fail Max").value = config.distanceFailMax;
			FsmUtil.GetFloatVariable(_controlFSM, "Hop Stop Distance").value = config.hopStopDistance;
			FsmUtil.GetFloatVariable(_controlFSM, "Tele Y").value = config.teleY;
		}

		public FsmState GetConfigState()
		{
			return _configState;
		}

		public FsmState GetOverrideState()
		{
			return _overrideState;
		}

		public override string GetStartStateNamePure()
		{
			return "Set Teleport Config";
		}

		public abstract void PostInit();

		public override void Init()
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			FsmState val = (_configState = AddState("Set Teleport Config"));
			FsmState val2 = AddState("Check Teleport Type");
			FsmState val3 = CopyState("Set Self Distance", "Self Distance-2");
			FsmState val4 = CopyState("Tele Init", "Tele Init-2");
			FsmState val5 = CopyState("Tele Pos", "Tele Pos-2");
			FsmState val6 = CopyState("Retry Check", "Retry Check-2");
			FsmState val7 = (_overrideState = AddState("Override Check"));
			FsmState val8 = AddState("Tele Telegraph");
			FsmState val9 = CopyState("Emerge Type", "Emerge Type-2");
			FsmState val10 = CopyState("Dive Out G", "Dive Out G-2");
			FsmState val11 = CopyState("Dive Out A", "Dive Out A-2");
			FsmState val12 = CopyState("Dive Out A 2", "Dive Out A2-2");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (!FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					_controlFSM.SendEvent("CANCEL");
				}
			});
			FsmUtil.InsertMethod(val9, 0, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = false;
				((Renderer)((Component)_controlFSM).gameObject.GetComponent<MeshRenderer>()).enabled = true;
				((Behaviour)((Component)_controlFSM).gameObject.GetComponent<DamageHero>()).enabled = true;
				((Behaviour)((Component)_controlFSM).gameObject.GetComponent<BoxCollider2D>()).enabled = true;
				((Component)_controlFSM).gameObject.layer = 11;
				Log.Debug("SPLASHED OUT");
				LaceBossScene.Instance.LaceMain.DeactivateTeleportTelegraph();
			});
			FsmUtil.AddMethod(val8, (Action<FsmStateAction>)delegate
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				LaceBossScene.Instance.LaceMain.ActivateTeleportTelegraph(new Vector3(FsmUtil.GetFloatVariable(_controlFSM, "Tele X").value, Constants.Constraints.LaceLandY, 0f));
			});
			FsmUtil.AddAction(val8, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.5f),
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("FINISHED")
			});
			FsmUtil.RemoveAction(val4, 0);
			FsmUtil.AddTransition(val, "FINISHED", val2.name);
			FsmUtil.AddTransition(val, "CANCEL", "Idle Choice");
			FsmUtil.AddTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.RemoveTransition(val4, "ABYSS WAVE");
			FsmUtil.ChangeTransition(val5, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val5, "RETRY", val6.name);
			FsmUtil.AddTransition(val7, "FINISHED", val8.name);
			FsmUtil.AddTransition(val8, "FINISHED", val9.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val6, "RETRY", val5.name);
			FsmUtil.ChangeTransition(val6, "CANCEL", "Idle Choice");
			FsmUtil.ChangeTransition(val9, "GROUND", val10.name);
			FsmUtil.ChangeTransition(val9, "AIR", val11.name);
			FsmUtil.ChangeTransition(val10, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val11, "FINISHED", val12.name);
			FsmUtil.ChangeTransition(val12, "FINISHED", _endStateName);
			PostInit();
		}
	}
	internal class LaceCounterTele : BaseAttack
	{
		public LaceCounterTele(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Counter Tele";
		}

		public override string GetStartStateNamePure()
		{
			return "Counter TeleOut 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Counter TeleOut", "Counter TeleOut 2");
			FsmState CounterTeleIn = CopyState("Counter TeleIn", "Counter TeleIn 2");
			FsmState val2 = AddState("Counter Tele Post");
			FsmUtil.InsertMethod(CounterTeleIn, 0, (Action<FsmStateAction>)delegate
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				FsmUtil.GetFirstActionOfType<SetPosition>(CounterTeleIn).y = FsmFloat.op_Implicit(HeroController.instance.transform.position.y + 2.5f);
			});
			FsmUtil.AddMethod(val2, (Action<FsmStateAction>)delegate
			{
				((Component)_controlFSM).gameObject.layer = 11;
				((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			});
			FsmUtil.ChangeTransition(val, "FINISHED", CounterTeleIn.name);
			FsmUtil.ChangeTransition(CounterTeleIn, "FINISHED", val2.name);
			FsmUtil.AddTransition(val2, "FINISHED", _endStateName);
		}
	}
	internal class LaceEvade : BaseAttack
	{
		public LaceEvade(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Evade";
		}

		public override string GetStartStateNamePure()
		{
			return "Evade 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Evade", "Evade 2");
			FsmState val2 = CopyState("Evade Recover", "Evade Recover 2");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", _endStateName);
		}
	}
	internal class LaceForceSplashIn : BaseAttack
	{
		public LaceForceSplashIn(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Force Splash In";
		}

		public override string GetStartStateNamePure()
		{
			return "Bounce Back 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Bounce Back", "Bounce Back 2");
			FsmState val2 = CopyState("Dive In 1", "Dive In 1 2");
			FsmState val3 = CopyState("Dive In 2", "Dive In 2 2");
			FsmState val4 = AddState("Dive In 3");
			FsmUtil.AddMethod(val3, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Force Tele").value = true;
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = true;
				((Behaviour)((Component)_controlFSM).gameObject.GetComponent<DamageHero>()).enabled = false;
				Log.Debug("FORCE SPLASHED IN");
			});
			FsmUtil.InsertMethod(val, 0, (Action<FsmStateAction>)delegate
			{
				Extensions.SetVelocity(((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>(), (float?)0f, (float?)0f);
				((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			});
			FsmUtil.AddMethod(val4, (Action<FsmStateAction>)delegate
			{
				((Renderer)((Component)_controlFSM).gameObject.GetComponent<MeshRenderer>()).enabled = false;
			});
			FsmUtil.RemoveTransition(val, "TELE");
			FsmUtil.ChangeTransition(val, "LAND", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.AddTransition(val4, "FINISHED", _endStateName);
		}
	}
	internal class LaceForceSplashOutFar : BaseAttack
	{
		private FsmState _configState;

		public LaceForceSplashOutFar(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public void SetTeleportConfig(LaceTeleportConfig config)
		{
			FsmUtil.GetFloatVariable(_controlFSM, "Distance Min").value = config.distanceMin;
			FsmUtil.GetFloatVariable(_controlFSM, "Distance Max").value = config.distanceMax;
			FsmUtil.GetFloatVariable(_controlFSM, "Distance Fail Max").value = config.distanceFailMax;
			FsmUtil.GetFloatVariable(_controlFSM, "Hop Stop Distance").value = config.hopStopDistance;
			FsmUtil.GetFloatVariable(_controlFSM, "Tele Y").value = config.teleY;
		}

		public FsmState GetConfigState()
		{
			return _configState;
		}

		public override string GetStartStateNamePure()
		{
			return "Set Teleport Config";
		}

		public override void Init()
		{
			FsmState val = (_configState = AddState("Set Teleport Config"));
			FsmState val2 = AddState("Check Teleport Type");
			FsmState val3 = CopyState("Set Self Distance", "Self Distance-2");
			FsmState val4 = CopyState("Tele Init", "Tele Init-2");
			FsmState val5 = CopyState("Tele Pos", "Tele Pos-2");
			FsmState val6 = CopyState("Retry Check", "Retry Check-2");
			FsmState val7 = CopyState("Emerge Type", "Emerge Type-2");
			FsmState val8 = CopyState("Dive Out G", "Dive Out G-2");
			FsmState val9 = CopyState("Dive Out A", "Dive Out A-2");
			FsmState val10 = CopyState("Dive Out A 2", "Dive Out A2-2");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (!FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					_controlFSM.SendEvent("CANCEL");
				}
			});
			FsmUtil.InsertMethod(val7, 0, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = false;
				Log.Debug("FORCE SPLASHED OUT");
				LaceBossScene.Instance.LaceMain.DeactivateTeleportTelegraph();
			});
			FsmUtil.AddMethod(val7, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = false;
				((Renderer)((Component)_controlFSM).gameObject.GetComponent<MeshRenderer>()).enabled = true;
				((Behaviour)((Component)_controlFSM).gameObject.GetComponent<DamageHero>()).enabled = true;
				((Behaviour)((Component)_controlFSM).gameObject.GetComponent<BoxCollider2D>()).enabled = true;
				((Component)_controlFSM).gameObject.layer = 11;
				if (FsmUtil.GetFloatVariable(_controlFSM, "Tele Y").value > Constants.Constraints.LaceLandY)
				{
					_controlFSM.SendEvent("AIR");
				}
			});
			FsmState val11 = AddState("Fail Safe Teleport");
			FsmUtil.AddMethod(val11, (Action<FsmStateAction>)delegate
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				FsmUtil.GetFloatVariable(_controlFSM, "Tele Y").value = Constants.Constraints.LaceLandY;
				FsmUtil.GetFloatVariable(_controlFSM, "Tele X").value = Constants.Constraints.ArenaCenterX;
				((Component)_controlFSM).gameObject.transform.position = Vector2.op_Implicit(new Vector2(Constants.Constraints.ArenaCenterX, Constants.Constraints.LaceLandY));
			});
			FsmUtil.AddTransition(val, "FINISHED", val2.name);
			FsmUtil.AddTransition(val, "CANCEL", "Idle Choice");
			FsmUtil.AddTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.RemoveTransition(val4, "ABYSS WAVE");
			FsmUtil.ChangeTransition(val5, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val5, "RETRY", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val6, "RETRY", val5.name);
			FsmUtil.ChangeTransition(val6, "CANCEL", val11.name);
			FsmUtil.ChangeTransition(val7, "GROUND", val8.name);
			FsmUtil.ChangeTransition(val7, "AIR", val9.name);
			FsmUtil.ChangeTransition(val8, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val9, "FINISHED", val10.name);
			FsmUtil.ChangeTransition(val10, "FINISHED", _endStateName);
			FsmUtil.AddTransition(val11, "FINISHED", val7.name);
			FsmUtil.AddMethod(_configState, (Action<FsmStateAction>)delegate
			{
				SetTeleportConfig(new LaceTeleportConfig
				{
					distanceMin = 6f,
					distanceMax = 7f,
					distanceFailMax = 15f,
					hopStopDistance = 7f,
					teleY = Constants.Constraints.LaceLandY
				});
			});
		}

		public override string GetAttackName()
		{
			return "Lace Force Splash Out Far";
		}
	}
	internal class LaceLand : BaseAttack
	{
		public LaceLand(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Land";
		}

		public override string GetStartStateNamePure()
		{
			return "Bounce Back Land";
		}

		public override void Init()
		{
			FsmState val = CopyState("Bounce Back", "Bounce Back Land");
			FsmState val2 = CopyState("Land", "Land 2");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			});
			FsmUtil.RemoveTransition(val, "TELE");
			FsmUtil.ChangeTransition(val, "LAND", val2.name);
			FsmUtil.RemoveTransition(val2, "TELE");
			FsmUtil.ChangeTransition(val2, "FINISHED", _endStateName);
		}
	}
	internal class LaceSplashIn : BaseAttack
	{
		public LaceSplashIn(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash In";
		}

		public override string GetStartStateNamePure()
		{
			return "Bounce Back 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Bounce Back", "Bounce Back 2");
			FsmState val2 = CopyState("Dive In 1", "Dive In 1 2");
			FsmState val3 = CopyState("Dive In 2", "Dive In 2 2");
			FsmState val4 = AddState("Dive In 3");
			FsmUtil.AddMethod(val3, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Force Tele").value = true;
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = true;
				((Behaviour)((Component)_controlFSM).gameObject.GetComponent<DamageHero>()).enabled = false;
				Log.Debug("SPLASHED IN");
			});
			FsmUtil.InsertMethod(val, 0, (Action<FsmStateAction>)delegate
			{
				if (FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					_controlFSM.SendEvent("CANCEL");
				}
				Extensions.SetVelocity(((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>(), (float?)0f, (float?)0f);
				((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
			});
			FsmUtil.AddMethod(val4, (Action<FsmStateAction>)delegate
			{
				((Renderer)((Component)_controlFSM).gameObject.GetComponent<MeshRenderer>()).enabled = false;
			});
			FsmUtil.RemoveTransition(val, "TELE");
			FsmUtil.ChangeTransition(val, "LAND", val2.name);
			FsmUtil.AddTransition(val, "CANCEL", _endStateName);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.AddTransition(val4, "FINISHED", _endStateName);
		}
	}
	internal class LaceSplashOutAirCloseFollow : LaceBaseSplashOut
	{
		public LaceSplashOutAirCloseFollow(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash Out Air Close";
		}

		public override void PostInit()
		{
			FsmUtil.AddMethod(GetConfigState(), (Action<FsmStateAction>)delegate
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				SetTeleportConfig(new LaceTeleportConfig
				{
					distanceMin = 5f,
					distanceMax = 8f,
					distanceFailMax = 10f,
					hopStopDistance = 5f,
					teleY = HeroController.instance.transform.position.y + 3f
				});
			});
		}
	}
	internal class LaceSplashOutAirMiddle : LaceBaseSplashOut
	{
		public LaceSplashOutAirMiddle(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash Out Air Middle";
		}

		public override void PostInit()
		{
			FsmUtil.AddMethod(GetOverrideState(), (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetFloatVariable(_controlFSM, "Tele X").value = Constants.Constraints.ArenaCenterX;
				FsmUtil.GetFloatVariable(_controlFSM, "Tele Y").value = 14f;
			});
		}
	}
	internal class LaceSplashOutGroundClose : LaceBaseSplashOut
	{
		public LaceSplashOutGroundClose(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash Out Ground Close";
		}

		public override void PostInit()
		{
			FsmUtil.AddMethod(GetConfigState(), (Action<FsmStateAction>)delegate
			{
				SetTeleportConfig(new LaceTeleportConfig
				{
					distanceMin = 0f,
					distanceMax = 6f,
					distanceFailMax = 10f,
					hopStopDistance = 5f,
					teleY = Constants.Constraints.LaceLandY
				});
			});
		}
	}
	internal class LaceSplashOutGroundFar : LaceBaseSplashOut
	{
		public LaceSplashOutGroundFar(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash Out Ground";
		}

		public override void PostInit()
		{
			FsmUtil.AddMethod(GetConfigState(), (Action<FsmStateAction>)delegate
			{
				SetTeleportConfig(new LaceTeleportConfig
				{
					distanceMin = 6f,
					distanceMax = 7f,
					distanceFailMax = 15f,
					hopStopDistance = 7f,
					teleY = Constants.Constraints.LaceLandY
				});
			});
		}
	}
	internal class LaceSplashOutRandom : LaceBaseSplashOut
	{
		public LaceSplashOutRandom(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash Out Random";
		}

		public override void PostInit()
		{
			FsmUtil.AddMethod(GetConfigState(), (Action<FsmStateAction>)delegate
			{
				SetTeleportConfig(new LaceTeleportConfig
				{
					distanceMin = 10f,
					distanceMax = 12f,
					distanceFailMax = 18f,
					hopStopDistance = 11f,
					teleY = Constants.Constraints.LaceLandY
				});
				if (Random.Range(0, 2) == 0)
				{
					SetTeleportConfig(new LaceTeleportConfig
					{
						distanceMin = 6f,
						distanceMax = 8f,
						distanceFailMax = 999999f,
						hopStopDistance = 11f,
						teleY = 14f
					});
				}
			});
		}
	}
	public struct LaceTeleportConfig
	{
		public float distanceMin;

		public float distanceMax;

		public float distanceFailMax;

		public float hopStopDistance;

		public float teleY;
	}
}
namespace LostAndChained.LacePhases._4
{
	internal class LaceIdle4 : BasePhase
	{
		public LaceIdle4(PlayMakerFSM controlFSM)
			: base(controlFSM)
		{
		}

		public override string GetControlStateName()
		{
			return Constants.PhaseNames.Idle4;
		}

		public override void Init()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected O, but got Unknown
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Expected O, but got Unknown
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Expected O, but got Unknown
			bool activateTransition = true;
			FsmState val = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle4 + " Attack");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (!LaceBlackThreads.OnCooldown())
				{
					_controlFSM.SendEvent("BLACK");
				}
			});
			SendRandomEventV4 val2 = new SendRandomEventV4();
			val2.events = (FsmEvent[])(object)new FsmEvent[8]
			{
				FsmEvent.GetFsmEvent("JUMPSLASHHOLD"),
				FsmEvent.GetFsmEvent("CHARGE"),
				FsmEvent.GetFsmEvent("PULLUPDEFLECT"),
				FsmEvent.GetFsmEvent("SLASHCOMBO"),
				FsmEvent.GetFsmEvent("TENDRILHARASS"),
				FsmEvent.GetFsmEvent("CIRCLESLASHES"),
				FsmEvent.GetFsmEvent("BULLETDIVE"),
				FsmEvent.GetFsmEvent("JUMPSLASHSTAB")
			};
			val2.weights = (FsmFloat[])(object)new FsmFloat[8]
			{
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f))
			};
			val2.eventMax = (FsmInt[])(object)new FsmInt[8]
			{
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(1)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(1)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2))
			};
			val2.missedMax = (FsmInt[])(object)new FsmInt[8]
			{
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8)),
				new FsmInt(FsmInt.op_Implicit(8))
			};
			val2.activeBool = FsmBool.op_Implicit(true);
			FsmUtil.AddAction(val, (FsmStateAction)(object)val2);
			FsmUtil.AddTransition(val, "JUMPSLASHHOLD", LaceAttackList.PullUpJumpslashHold.GetStartStateName());
			FsmUtil.AddTransition(val, "CHARGE", LaceAttackList.FastCharge.GetStartStateName());
			FsmUtil.AddTransition(val, "PULLUPDEFLECT", LaceAttackList.PullUpDeflectCharge.GetStartStateName());
			FsmUtil.AddTransition(val, "SLASHCOMBO", LaceAttackList.FastTripleSlashJumpSlashHold.GetStartStateName());
			FsmUtil.AddTransition(val, "TENDRILHARASS", LaceAttackList.FastWhipHarass.GetStartStateName());
			FsmUtil.AddTransition(val, "CIRCLESLASHES", LaceAttackList.CircleSlashes.GetStartStateName());
			FsmUtil.AddTransition(val, "BULLETDIVE", LaceAttackList.BulletDive.GetStartStateName());
			FsmUtil.AddTransition(val, "JUMPSLASHSTAB", LaceAttackList.JumpSlashRapidStab.GetStartStateName());
			FsmUtil.AddTransition(val, "BLACK", LaceAttackList.BlackThreads.GetStartStateName());
			FsmState val3 = FsmUtil.CopyState(_controlFSM, "Idle", Constants.PhaseNames.Idle4);
			FsmUtil.RemoveAction(val3, 0);
			FsmUtil.RemoveFirstActionOfType<Tk2dPlayAnimation>(val3);
			FsmUtil.InsertMethod(val3, 0, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = false;
				if (activateTransition)
				{
					activateTransition = false;
					LaceBossScene.Instance.phaseActive = true;
					((Component)_controlFSM).gameObject.GetComponent<HealthManager>().hp = Constants.PhaseValues.Phase4HP;
				}
				if (!FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					((Component)_controlFSM).gameObject.GetComponent<tk2dSpriteAnimator>().Play("Idle");
					if (Random.Range(0, 3) == 0)
					{
						FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = true;
					}
				}
			});
			FsmUtil.AddAction(val3, (FsmStateAction)new Wait
			{
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("ATTACK"),
				time = FsmFloat.op_Implicit(0.2f)
			});
			FsmUtil.ChangeTransition(val3, "ATTACK", val.name);
			FsmUtil.ChangeTransition(val3, "COUNTER", LaceAttackList.DeflectCharge.GetStartStateName());
			FsmUtil.ChangeTransition(val3, "TOOK DAMAGE", val.name);
			FsmUtil.RemoveTransition(val3, "EVADE");
		}
	}
}
namespace LostAndChained.LacePhases.Extras
{
	internal class LaceCrossSlashDamageless : BaseAttack
	{
		public LaceCrossSlashDamageless(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "CS Damageless";
		}

		public override string GetStartStateNamePure()
		{
			return "CS Damageless Do Cross Slash";
		}

		public override void Init()
		{
			FsmState val = CopyState("Do CrossSlash", "CS Damageless Do Cross Slash");
			FsmState val2 = CopyState("CS Slam", "CS Damageless Slam");
			FsmState val3 = CopyState("CS Flip Back", "CS Damageless Flip Back");
			FsmUtil.RemoveActionsOfType<ActivateGameObject>(val);
			FsmUtil.RemoveActionsOfType<SendMessageDelay>(val);
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				LaceBossScene.Instance.LaceMain.ActivateAltCrossSlash();
			});
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "LAND", _endStateName);
		}
	}
	internal class LaceLaugh : BaseAttack
	{
		public LaceLaugh(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Lace Laugh";
		}

		public override string GetStartStateNamePure()
		{
			return "Laugh";
		}

		public override void Init()
		{
			//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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			FsmState val = CopyState("Death Pose", "Laugh");
			FsmUtil.AddAction(val, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(3f),
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("FINISHED")
			});
			FsmUtil.AddTransition(val, "FINISHED", _endStateName);
		}
	}
	internal class LaceP4Lunge : BaseAttack
	{
		public LaceP4Lunge(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "P4 Lunge";
		}

		public override string GetStartStateNamePure()
		{
			return "P4 Charge Antic";
		}

		public override void Init()
		{
			FsmState val = CopyState("Charge Antic", "P4 Charge Antic");
			FsmState val2 = CopyState("Charge Break", "P4 Charge Break");
			FsmState val3 = CopyState("Charge", "P4 Charge");
			((FsmStateAction)FsmUtil.GetFirstActionOfType<PlayParticleEmitterInState>(val3)).enabled = false;
			((FsmStateAction)FsmUtil.GetAction<ActivateGameObject>(val3, 5)).enabled = false;
			((FsmStateAction)FsmUtil.GetAction<SetDamageHero>(val3, 13)).enabled = false;
			((FsmStateAction)FsmUtil.GetAction<ActivateGameObject>(val3, 14)).enabled = false;
			((FsmStateAction)FsmUtil.GetAction<SpawnObjectFromGlobalPoolOverTime>(val3, 16)).enabled = false;
			FsmUtil.AddMethod(val3, (Action<FsmStateAction>)delegate
			{
				LaceBossScene.Instance.GMSMain.PromptParry();
			});
			FsmUtil.ChangeTransition(val, "NEXT", val2.name);
			FsmUtil.ChangeTransition(val2, "NEXT", val3.name);
			FsmUtil.RemoveTransition(val3, "J SLASH");
			FsmUtil.RemoveTransition(val3, "MULTI HIT CONNECT");
			FsmUtil.RemoveTransition(val3, "NEXT");
			FsmUtil.AddTransition(val3, "CONTINUE", _endStateName);
		}
	}
	internal class LaceP4Parry : BaseAttack
	{
		public LaceP4Parry(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "P4 Parry";
		}

		public override string GetStartStateNamePure()
		{
			return "P4 Counter Antic";
		}

		public override void Init()
		{
			FsmState val = CopyState("Counter Antic", "P4 Counter Antic");
			FsmState val2 = CopyState("Counter Stance", "P4 Counter Stance");
			FsmState val3 = CopyState("Counter End", "P4 Counter End");
			((FsmStateAction)FsmUtil.GetFirstActionOfType<ActivateGameObject>(val2)).enabled = false;
			((FsmStateAction)FsmUtil.GetFirstActionOfType<SendMessage>(val2)).enabled = false;
			FsmUtil.GetFirstActionOfType<Wait>(val2).time = FsmFloat.op_Implicit(3f);
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.RemoveTransition(val, "BLOCKED HIT");
			FsmUtil.ChangeTransition(val2, "END", val3.name);
			FsmUtil.RemoveTransition(val2, "BLOCKED HIT");
			FsmUtil.ChangeTransition(val3, "FINISHED", _endStateName);
		}
	}
	internal class LaceP4Wait : BaseAttack
	{
		public LaceP4Wait(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Lace P4 Wait";
		}

		public override string GetStartStateNamePure()
		{
			return "P4 Wait";
		}

		public override void Init()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			FsmState val = AddState("P4 Wait");
			FsmUtil.AddAction(val, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(0.75f),
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("FINISHED")
			});
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				((Component)_controlFSM).gameObject.GetComponent<tk2dSpriteAnimator>().Play("Idle");
			});
			FsmUtil.AddTransition(val, "FINISHED", _endStateName);
		}
	}
	internal class LaceSplashInPerma : BaseAttack
	{
		public LaceSplashInPerma(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Splash In Perma";
		}

		public override string GetStartStateNamePure()
		{
			return "Bounce Back 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Bounce Back", "Bounce Back 2");
			FsmState val2 = CopyState("Dive In 1", "Dive In 1 2");
			FsmState val3 = CopyState("Dive In 2", "Dive In 2 2");
			FsmUtil.AddMethod(val3, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Force Tele").value = true;
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = true;
				Log.Debug("SPLASHED IN");
			});
			FsmUtil.InsertMethod(val, 0, (Action<FsmStateAction>)delegate
			{
				Extensions.SetVelocity(((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>(), (float?)0f, (float?)0f);
				((Component)_controlFSM).gameObject.GetComponent<Rigidbody2D>().bodyType = (RigidbodyType2D)0;
				if (FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value)
				{
					_controlFSM.SendEvent("CANCEL");
				}
			});
			FsmState val4 = AddState("Perma Wait");
			FsmUtil.RemoveTransition(val, "TELE");
			FsmUtil.ChangeTransition(val, "LAND", val2.name);
			FsmUtil.AddTransition(val, "CANCEL", val4.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
		}
	}
	internal class LaceSplashOutP4Shift : BaseAttack
	{
		public LaceSplashOutP4Shift(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetStartStateNamePure()
		{
			return "Override Check";
		}

		public override void Init()
		{
			FsmState val = AddState("Override Check");
			FsmState val2 = CopyState("Dive Out G", "Dive Out G-2");
			FsmUtil.InsertMethod(val2, 0, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Splashed In").value = false;
			});
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetFloatVariable(_controlFSM, "Tele X").value = 39f;
				FsmUtil.GetFloatVariable(_controlFSM, "Tele Y").value = Constants.Constraints.LaceLandY;
			});
			FsmUtil.AddTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", _endStateName);
		}

		public override string GetAttackName()
		{
			return "Splash Out P4";
		}
	}
	internal class LaceThreadCheck : BaseAttack
	{
		public LaceThreadCheck(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Thread Check";
		}

		public override string GetStartStateNamePure()
		{
			return "Thread Check";
		}

		public override void Init()
		{
			FsmState val = AddState("Thread Check");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (LaceBlackThreads.PreventCircles())
				{
					_controlFSM.SendEvent("CANCEL");
				}
			});
			FsmUtil.AddTransition(val, "FINISHED", _endStateName);
			FsmUtil.AddTransition(val, "CANCEL", "Idle Choice");
		}
	}
}
namespace LostAndChained.LacePhases.Awaits
{
	internal abstract class LaceAwaitBase : BaseAttack
	{
		public LaceAwaitBase(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetStartStateNamePure()
		{
			return "Await GMS";
		}

		public override void Init()
		{
			FsmState val = AddState("Await GMS");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				LaceBossScene.Instance.laceAttemptingCombo = true;
			});
			FsmState val2 = AddState("End Await GMS");
			FsmUtil.AddMethod(val2, (Action<FsmStateAction>)delegate
			{
				LaceBossScene.Instance.laceAttemptingCombo = false;
				FSMUtility.LocateMyFSM(LaceBossScene.Instance.GMSMain._bossObject, "Attack Control").SendEvent(GetAttackName());
			});
			FsmUtil.AddTransition(val, "READY", val2.name);
			FsmUtil.AddTransition(val2, "FINISHED", _endStateName);
		}
	}
	internal class LaceAwaitClaw : LaceAwaitBase
	{
		public LaceAwaitClaw(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "CLAW";
		}
	}
	internal class LaceAwaitRubble : LaceAwaitBase
	{
		public LaceAwaitRubble(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "RUBBLE";
		}
	}
	internal class LaceAwaitWeb : LaceAwaitBase
	{
		public LaceAwaitWeb(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "WEB";
		}
	}
}
namespace LostAndChained.LacePhases.Attacks
{
	internal class BaseAttackString
	{
		internal PlayMakerFSM _controlFSM;

		internal string _endStateName;

		internal List<Type> _attackChain = new List<Type>();

		internal string _attackName;

		internal string _startingStateName = "";

		public BaseAttackString(PlayMakerFSM controlFSM, string EndStateName, string attackName, List<Type> attackChain)
		{
			_controlFSM = controlFSM;
			_endStateName = EndStateName;
			_attackChain = attackChain;
			_attackName = attackName;
			Init();
		}

		public BaseAttackString(PlayMakerFSM controlFSM, string attackName, List<Type> attackChain)
			: this(controlFSM, "Idle Choice", attackName, attackChain)
		{
		}

		public void Init()
		{
			string text = _endStateName;
			Dictionary<Type, int> dictionary = new Dictionary<Type, int>();
			for (int num = _attackChain.Count - 1; num >= 0; num--)
			{
				Type type = _attackChain[num];
				if (dictionary.ContainsKey(type))
				{
					dictionary[type]++;
				}
				else
				{
					dictionary.Add(type, 1);
				}
				int num2 = dictionary[type];
				BaseAttack baseAttack = (BaseAttack)Activator.CreateInstance(type, _controlFSM, text, _attackName + num2);
				text = baseAttack.GetStartStateName();
			}
			_startingStateName = text;
		}

		public string GetStartStateName()
		{
			return _startingStateName;
		}
	}
	internal class LaceBlackThreads : BaseAttack
	{
		private static float lastUsedTime = 0f;

		private static float useCooldown = 8f;

		public static bool OnCooldown()
		{
			return Time.time - lastUsedTime < useCooldown;
		}

		public static bool PreventCircles()
		{
			return Time.time - lastUsedTime <= 1.5f;
		}

		public LaceBlackThreads(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Black Threads";
		}

		public override string GetStartStateNamePure()
		{
			return "Threads Summon";
		}

		public override void Init()
		{
			FsmState val = AddState("Threads Summon");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (!OnCooldown())
				{
					lastUsedTime = Time.time;
					LaceBossScene.Instance.LaceMain.ActivateBlackThreads();
				}
			});
			FsmUtil.AddTransition(val, "FINISHED", _endStateName);
		}
	}
	internal class LaceBulletCastAir : BaseAttack
	{
		public LaceBulletCastAir(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Bullet Cast";
		}

		public override string GetStartStateNamePure()
		{
			return "Bullet Type Air";
		}

		public override void Init()
		{
			FsmState val = CopyState("Bullet S Type", "Bullet Type Air");
			FsmState val2 = CopyState("Bullet S Air", "Bullet Cast Air");
			FsmState val3 = CopyState("Bullet S Air 2", "Bullet Cast Air 2");
			FsmState val4 = CopyState("Cast To Air", "Cast To Air 2");
			FsmUtil.RemoveTransition(val, "AIR");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", _endStateName);
		}
	}
	internal class LaceCircleSlashes : BaseAttack
	{
		public LaceCircleSlashes(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Circle Slashes";
		}

		public override string GetStartStateNamePure()
		{
			return "Circle Slashes Antic";
		}

		public override void Init()
		{
			FsmState val = CopyState("CS Antic", "Circle Slashes Antic");
			FsmState val2 = CopyState("CS Summon", "Circle Slashes Summon");
			FsmState val3 = CopyState("CS Thwip Out", "Circle Slashes Thwhip Out");
			FsmState val4 = CopyState("Stomp Antic", "Circle Slashes Stomp Antic");
			FsmState val5 = CopyState("Stomp", "Circle Slashes Stomp");
			FsmState val6 = CopyState("Slam", "Circle Slashes Slam");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "NEXT", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "LAND", val6.name);
			FsmUtil.AddTransition(val6, "FINISHED", _endStateName);
		}
	}
	internal class LaceCounter : BaseAttack
	{
		public LaceCounter(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Counter";
		}

		public override string GetStartStateNamePure()
		{
			return "Counter Antic 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Counter Antic", "Counter Antic 2");
			FsmState val2 = CopyState("Counter Stance", "Counter Stance 2");
			FsmState val3 = CopyState("Counter End", "Counter End 2");
			FsmState val4 = CopyState("Counter Hit", "Counter Hit 2");
			FsmState val5 = CopyState("Counter Type", "Counter Type 2");
			FsmState val6 = CopyState("RapidSlash Charge", "RapidSlash Charge 2");
			FsmState val7 = CopyState("RapidSlash Loop", "RapidSlash Loop 2");
			FsmState val8 = CopyState("RapidSlash End", "RapidSlash End 2");
			FsmState val9 = CopyState("Collide Cancel", "Collide Cancel 2");
			FsmState val10 = CopyState("Collide To Multihit", "Collide To MultiHit 2");
			FsmState val11 = CopyState("Hero Facing", "Hero Facing 2");
			FsmState val12 = CopyState("Multihitting", "Multihitting 2");
			FsmState val13 = CopyState("Multihit Slash", "Multihit Slash 2");
			FsmState val14 = CopyState("Counter TeleOut", "Counter TeleOut 2");
			FsmState val15 = CopyState("Counter TeleIn", "Counter TeleIn 2");
			FsmState val16 = CopyState("RapidSlashAir Antic", "RapidSlashAir Antic 2");
			FsmState val17 = CopyState("RapidSlash Air", "RapidSlash Air 2");
			FsmState val18 = CopyState("Slash End", "Slash End 2");
			FsmState val19 = CopyState("Hero Facing 2", "Hero Facing 2-2");
			FsmState val20 = CopyState("Multihitting 2", "Multihitting 2-2");
			FsmState val21 = CopyState("Multihit Slash 2", "Multihit Slash 2-2");
			FsmState val22 = CopyState("Multihit Slash End", "Multihit Slash End-2");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				FsmUtil.GetBoolVariable(_controlFSM, "Will Counter").value = false;
			});
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val, "BLOCKED HIT", val4.name);
			FsmUtil.ChangeTransition(val2, "END", val3.name);
			FsmUtil.ChangeTransition(val2, "BLOCKED HIT", val4.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "GROUND", val6.name);
			FsmUtil.ChangeTransition(val5, "AIR", val14.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val6, "HERO COLLIDE", val10.name);
			FsmUtil.ChangeTransition(val10, "FINISHED", val11.name);
			FsmUtil.ChangeTransition(val10, "CANCEL", val9.name);
			FsmUtil.ChangeTransition(val9, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", val8.Name);
			FsmUtil.ChangeTransition(val7, "MULTI HIT CONNECT", val11.name);
			FsmUtil.ChangeTransition(val8, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val11, "FINISHED", val12.name);
			FsmUtil.ChangeTransition(val12, "FINISHED", val13.name);
			FsmUtil.ChangeTransition(val13, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val14, "FINISHED", val15.name);
			FsmUtil.ChangeTransition(val15, "FINISHED", val16.name);
			FsmUtil.ChangeTransition(val16, "FINISHED", val17.name);
			FsmUtil.ChangeTransition(val17, "FINISHED", val18.name);
			FsmUtil.ChangeTransition(val17, "MULTI HIT CONNECT", val19.name);
			FsmUtil.ChangeTransition(val19, "FINISHED", val20.name);
			FsmUtil.ChangeTransition(val20, "FINISHED", val21.name);
			FsmUtil.ChangeTransition(val21, "FINISHED", val22.name);
			FsmUtil.ChangeTransition(val18, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val22, "FINISHED", _endStateName);
		}
	}
	internal class LaceDeflect : BaseAttack
	{
		public LaceDeflect(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Deflect";
		}

		public override string GetStartStateNamePure()
		{
			return "Deflect Antic";
		}

		public override void Init()
		{
			FsmState val = CopyState("Counter Antic", "Deflect Antic");
			FsmState val2 = CopyState("Counter Stance", "Deflect Stance");
			FsmState val3 = CopyState("Counter End", "Deflect End");
			FsmState val4 = CopyState("Counter Hit", "Deflect Hit");
			FsmState val5 = CopyState("Evade", "Evade 2");
			FsmState val6 = CopyState("Evade Recover", "Evade Recover 2");
			FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val4).clipName = FsmString.op_Implicit("Antic");
			((FsmStateAction)FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val4)).enabled = false;
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val, "BLOCKED HIT", val4.name);
			FsmUtil.ChangeTransition(val2, "END", val3.name);
			FsmUtil.ChangeTransition(val2, "BLOCKED HIT", val4.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", "Idle Choice");
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", _endStateName);
		}
	}
	internal class LaceDownstabFast : BaseAttack
	{
		public LaceDownstabFast(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Downstab Fast";
		}

		public override string GetStartStateNamePure()
		{
			return "Downstab Antic Fast";
		}

		public override void Init()
		{
			FsmState val = CopyState("Downstab Antic", "Downstab Antic Fast");
			FsmState val2 = CopyState("Dstab Angle", "Dstab Angle Fast");
			FsmState val3 = CopyState("Downstab", "Downstab Fast");
			FsmState val4 = CopyState("Downstab Land", "Downstab Land Fast");
			FsmState val5 = CopyState("Dstab Multihit", "Dstab Multihit Fast");
			FsmState val6 = CopyState("Dstab Strike", "Dstab Strike Fast");
			FsmState val7 = CopyState("Multihit Slash End", "Dstab Multihit End");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.RemoveTransition(val3, "WALL");
			FsmUtil.ChangeTransition(val3, "LAND", val4.name);
			FsmUtil.ChangeTransition(val3, "MULTI HIT CONNECT", val5.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", _endStateName);
		}
	}
	internal class LaceJumpSlash : BaseAttack
	{
		public LaceJumpSlash(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Jump Slash";
		}

		public override string GetStartStateNamePure()
		{
			return "Jump Slash Antic";
		}

		public override void Init()
		{
			FsmState val = CopyState("J Slash M Antic", "Jump Slash Antic");
			FsmState val2 = CopyState("J Slash Multi", "Jump Slash Multi");
			FsmState val3 = CopyState("J Slash Followup", "Jump Slash Followup");
			FsmState val4 = CopyState("J Slash Multihit", "Jump Slash Multihit");
			FsmState val5 = CopyState("J Slash Strike", "Jump Slash Strike");
			FsmState val6 = CopyState("Multihit Slash End", "Jump Slash Multihit End");
			FsmState val7 = CopyState("Bounce Back", "Bounce Back Land");
			FsmState val8 = CopyState("Land", "Land 2");
			FsmUtil.ChangeTransition(val, "NEXT", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val2, "MULTI HIT CONNECT", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", _endStateName);
			FsmUtil.RemoveTransition(val3, "TENDRIL");
			FsmUtil.RemoveTransition(val7, "TELE");
			FsmUtil.ChangeTransition(val7, "LAND", val8.name);
			FsmUtil.RemoveTransition(val8, "TELE");
			FsmUtil.ChangeTransition(val8, "FINISHED", "Idle Choice");
		}
	}
	internal class LaceRapidStabAir : BaseAttack
	{
		public LaceRapidStabAir(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Rapid Stab Air";
		}

		public override string GetStartStateNamePure()
		{
			return "Counter TeleOut 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Counter TeleOut", "Counter TeleOut 2");
			FsmState CounterTeleIn = CopyState("Counter TeleIn", "Counter TeleIn 2");
			FsmState val2 = CopyState("RapidSlashAir Antic", "RapidSlashAir Antic 2");
			FsmState val3 = CopyState("RapidSlash Air", "RapidSlash Air 2");
			FsmState val4 = CopyState("Slash End", "Slash End 2");
			FsmState val5 = CopyState("Hero Facing 2", "Hero Facing 2-2");
			FsmState val6 = CopyState("Multihitting 2", "Multihitting 2-2");
			FsmState val7 = CopyState("Multihit Slash 2", "Multihit Slash 2-2");
			FsmState val8 = CopyState("Multihit Slash End", "Multihit Slash End-2");
			FsmUtil.InsertMethod(CounterTeleIn, 0, (Action<FsmStateAction>)delegate
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				FsmUtil.GetFirstActionOfType<SetPosition>(CounterTeleIn).y = FsmFloat.op_Implicit(HeroController.instance.transform.position.y + 2.5f);
			});
			FsmUtil.AddMethod(val2, (Action<FsmStateAction>)delegate
			{
				Extensions.SetVelocity(LaceBossScene.Instance.LaceMain._bossObject.GetComponent<Rigidbody2D>(), (float?)0f, (float?)0f);
			});
			FsmUtil.ChangeTransition(val, "FINISHED", CounterTeleIn.name);
			FsmUtil.ChangeTransition(CounterTeleIn, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val3, "MULTI HIT CONNECT", val5.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", val8.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val8, "FINISHED", _endStateName);
		}
	}
	internal class LaceSingleCharge : BaseAttack
	{
		public LaceSingleCharge(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Single Charge";
		}

		public override string GetStartStateNamePure()
		{
			return "Single Charge Antic";
		}

		public override void Init()
		{
			FsmState val = CopyState("Charge Antic", "Single Charge Antic");
			FsmState val2 = CopyState("Charge Break", "Single Charge Break");
			FsmState val3 = CopyState("Charge", "Single Charge");
			FsmState val4 = CopyState("Charge Recover", "Single Charge Recover");
			FsmState val5 = CopyState("Charge Strike", "Single Charge Strike");
			FsmState val6 = CopyState("Combo Strike Finisher", "Single Charge Finisher");
			FsmUtil.ChangeTransition(val, "NEXT", val2.name);
			FsmUtil.ChangeTransition(val2, "NEXT", val3.name);
			FsmUtil.RemoveTransition(val3, "J SLASH");
			FsmUtil.ChangeTransition(val3, "MULTI HIT CONNECT", val5.name);
			FsmUtil.ChangeTransition(val3, "NEXT", val4.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", "Idle Choice");
			FsmUtil.ChangeTransition(val4, "FINISHED", _endStateName);
		}
	}
	internal class LaceSingleChargeFast : BaseAttack
	{
		public LaceSingleChargeFast(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Single Charge Fast";
		}

		public override string GetStartStateNamePure()
		{
			return "Single Charge Antic Fast";
		}

		public override void Init()
		{
			FsmState val = CopyState("Charge Antic", "Single Charge Antic Fast");
			FsmState val2 = CopyState("Charge Break", "Single Charge Break Fast");
			FsmState val3 = CopyState("Charge", "Single Charge Fast");
			FsmState val4 = CopyState("Charge Recover", "Single Charge Recover Fast");
			FsmState val5 = CopyState("Charge Strike", "Single Charge Strike Fast");
			FsmState val6 = CopyState("Combo Strike Finisher", "Single Charge Finisher Fast");
			FsmUtil.GetFirstActionOfType<Wait>(val2).time = FsmFloat.op_Implicit(0.25f);
			FsmUtil.ChangeTransition(val, "NEXT", val2.name);
			FsmUtil.ChangeTransition(val2, "NEXT", val3.name);
			FsmUtil.RemoveTransition(val3, "J SLASH");
			FsmUtil.ChangeTransition(val3, "MULTI HIT CONNECT", val5.name);
			FsmUtil.ChangeTransition(val3, "NEXT", val4.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", "Idle Choice");
			FsmUtil.ChangeTransition(val4, "FINISHED", _endStateName);
		}
	}
	internal class LaceTendrilAttack2 : BaseAttack
	{
		public LaceTendrilAttack2(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Tendril Attack";
		}

		public override string GetStartStateNamePure()
		{
			return "Tendril Type 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Tendril Type", "Tendril Type 2");
			FsmState val2 = CopyState("Tendril G Antic", "Tendril G Antic 2");
			FsmState val3 = CopyState("Tendril G Dash", "Tendril G Dash 2");
			FsmState val4 = CopyState("Tendril G Whip", "Tendril G Whip 2");
			FsmState val5 = CopyState("Tendril G Whip End", "Tendril G Whip End 2");
			FsmState val6 = CopyState("Tendril A Antic", "Tendril A Antic 2");
			FsmState val7 = CopyState("Tendril A Whip", "Tendril A Whip 2");
			FsmState val8 = CopyState("Tendril A End", "Tendril A End 2");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val, "AIR", val6.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", val8.name);
			FsmUtil.ChangeTransition(val8, "FINISHED", _endStateName);
		}
	}
	internal class LaceTendrilAttackFast : BaseAttack
	{
		public LaceTendrilAttackFast(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Tendril Attack Fast";
		}

		public override string GetStartStateNamePure()
		{
			return "Tendril Type 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Tendril Type", "Tendril Type 2");
			FsmState val2 = CopyState("Tendril G Antic", "Tendril G Antic 2");
			FsmState val3 = CopyState("Tendril G Dash", "Tendril G Dash 2");
			FsmState val4 = CopyState("Tendril G Whip", "Tendril G Whip 2");
			FsmState val5 = CopyState("Tendril G Whip End", "Tendril G Whip End 2");
			FsmState val6 = CopyState("Tendril A Antic", "Tendril A Antic 2");
			FsmState val7 = CopyState("Tendril A Whip", "Tendril A Whip 2");
			FsmState val8 = CopyState("Tendril A End", "Tendril A End 2");
			FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val2).clipName = FsmString.op_Implicit("Tendril Whip G Fast");
			FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val5).clipName = FsmString.op_Implicit("Tendril Whip End G Fast");
			FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val6).clipName = FsmString.op_Implicit("Tendril Whip A Fast");
			FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val8).clipName = FsmString.op_Implicit("Tendril Whip End A Fast");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val, "AIR", val6.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", val8.name);
			FsmUtil.ChangeTransition(val8, "FINISHED", _endStateName);
		}
	}
	internal class LaceTripleSlash : BaseAttack
	{
		public LaceTripleSlash(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Triple Slash";
		}

		public override string GetStartStateNamePure()
		{
			return "TripleSlash 1";
		}

		public override void Init()
		{
			FsmState val = CopyState("ComboSlash 1", "TripleSlash 1");
			FsmState val2 = CopyState("ComboSlash 2", "TripleSlash 2");
			FsmState val3 = CopyState("ComboSlash 3", "TripleSlash 3");
			FsmState val4 = CopyState("ComboSlash 4", "TripleSlash 4");
			FsmState val5 = CopyState("ComboSlash 5", "TripleSlash 5");
			FsmState val6 = CopyState("ComboSlash 6", "TripleSlash 6");
			FsmState val7 = CopyState("ComboSlash 7", "TripleSlash 7");
			FsmState val8 = CopyState("Combo Strike 1", "Combo Strike 1-2");
			FsmState val9 = CopyState("Combo Strike 2", "Combo Strike 2-2");
			FsmState val10 = CopyState("Combo Strike", "Combo Strike 2");
			FsmState val11 = CopyState("Combo Strike Finisher", "Combo Strike Finisher 2");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val2, "MULTI HIT CONNECT", val8.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val3, "MULTI HIT CONNECT", val9.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val4, "MULTI HIT CONNECT", val9.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val5, "MULTI HIT CONNECT", val8.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val6, "MULTI HIT CONNECT", val8.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val8, "FINISHED", val10.name);
			FsmUtil.ChangeTransition(val9, "FINISHED", val10.name);
			FsmUtil.ChangeTransition(val10, "FINISHED", val11.name);
			FsmUtil.ChangeTransition(val11, "FINISHED", "Idle Choice");
		}
	}
	internal class LaceTripleSlashFast : BaseAttack
	{
		public LaceTripleSlashFast(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Triple Slash Fast";
		}

		public override string GetStartStateNamePure()
		{
			return "TripleSlash 1";
		}

		public override void Init()
		{
			FsmState val = CopyState("ComboSlash 1", "TripleSlash 1");
			FsmState val2 = CopyState("ComboSlash 2", "TripleSlash 2");
			FsmState val3 = CopyState("ComboSlash 3", "TripleSlash 3");
			FsmState val4 = CopyState("ComboSlash 4", "TripleSlash 4");
			FsmState val5 = CopyState("ComboSlash 5", "TripleSlash 5");
			FsmState val6 = CopyState("ComboSlash 6", "TripleSlash 6");
			FsmState val7 = CopyState("ComboSlash 7", "TripleSlash 7");
			FsmState val8 = CopyState("Combo Strike 1", "Combo Strike 1-2");
			FsmState val9 = CopyState("Combo Strike 2", "Combo Strike 2-2");
			FsmState val10 = CopyState("Combo Strike", "Combo Strike 2");
			FsmState val11 = CopyState("Combo Strike Finisher", "Combo Strike Finisher 2");
			FsmUtil.GetFirstActionOfType<Tk2dPlayAnimationWithEvents>(val).clipName = FsmString.op_Implicit("Combo Slash Triple Fast");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val2, "MULTI HIT CONNECT", val8.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val3, "MULTI HIT CONNECT", val9.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val4, "MULTI HIT CONNECT", val9.name);
			FsmUtil.ChangeTransition(val5, "FINISHED", val6.name);
			FsmUtil.ChangeTransition(val5, "MULTI HIT CONNECT", val8.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val6, "MULTI HIT CONNECT", val8.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", _endStateName);
			FsmUtil.ChangeTransition(val8, "FINISHED", val10.name);
			FsmUtil.ChangeTransition(val9, "FINISHED", val10.name);
			FsmUtil.ChangeTransition(val10, "FINISHED", val11.name);
			FsmUtil.ChangeTransition(val11, "FINISHED", "Idle Choice");
		}
	}
	internal class LaceVomitAir : BaseAttack
	{
		public LaceVomitAir(PlayMakerFSM controlFSM, string EndStateName, string parentAttackString)
			: base(controlFSM, EndStateName, parentAttackString)
		{
		}

		public override string GetAttackName()
		{
			return "Vomit Air";
		}

		public override string GetStartStateNamePure()
		{
			return "Vomit Air 2";
		}

		public override void Init()
		{
			FsmState val = CopyState("Vomit Air", "Vomit Air 2");
			FsmState val2 = CopyState("Vomit Antic", "Vomit Antic 2");
			FsmState val3 = CopyState("Vomit Start", "Vomit Start 2");
			FsmState val4 = CopyState("Vomit Fire", "Vomit Fire 2");
			FsmState val5 = CopyState("Vomit Repeat?", "Vomit Repeat 2");
			FsmState val6 = CopyState("Vomit Cooldown", "Vomit Cooldown 2");
			FsmState val7 = CopyState("Vomit End", "Vomit End 2");
			FsmState val8 = CopyState("Cast To Air", "Cast To Air 2");
			FsmUtil.ChangeTransition(val, "FINISHED", val2.name);
			FsmUtil.ChangeTransition(val2, "FINISHED", val3.name);
			FsmUtil.ChangeTransition(val3, "FINISHED", val4.name);
			FsmUtil.ChangeTransition(val4, "FINISHED", val5.name);
			FsmUtil.ChangeTransition(val5, "REPEAT", val4.name);
			FsmUtil.ChangeTransition(val5, "END", val6.name);
			FsmUtil.ChangeTransition(val6, "FINISHED", val7.name);
			FsmUtil.ChangeTransition(val7, "FINISHED", val8.name);
			FsmUtil.RemoveTransition(val7, "AIR");
			FsmUtil.ChangeTransition(val8, "FINISHED", _endStateName);
		}
	}
}
namespace LostAndChained.GMSPhases.Two
{
	internal class GMSIdle2 : BasePhase
	{
		public GMSIdle2(PlayMakerFSM controlFSM)
			: base(controlFSM)
		{
		}

		public override string GetControlStateName()
		{
			return Constants.PhaseNames.Idle2;
		}

		public override void Init()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			bool flag = true;
			FsmState val = FsmUtil.AddState(_controlFSM, "Idle 2 Attack Choice");
			FsmUtil.AddMethod(val, (Action<FsmStateAction>)delegate
			{
				if (LaceBossScene.Instance.phaseNumber != 3)
				{
					_controlFSM.SendEvent("ATTACK");
				}
				if (LaceBossScene.Instance.phaseNumber == 3)
				{
					_controlFSM.SetState("Idle Choice");
				}
			});
			FsmUtil.AddTransition(val, "ATTACK", "Set Primary Hand");
			FsmState val2 = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle2);
			FsmUtil.AddAction(val2, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(4f),
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("FINISHED")
			});
			FsmUtil.AddTransition(val2, "FINISHED", "Idle 2 Attack Choice");
		}
	}
}
namespace LostAndChained.GMSPhases.Three
{
	internal class GMSIdle3 : BasePhase
	{
		public GMSIdle3(PlayMakerFSM controlFSM)
			: base(controlFSM)
		{
		}

		public override string GetControlStateName()
		{
			return Constants.PhaseNames.Idle3;
		}

		public override void Init()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			bool flag = true;
			FsmState val = FsmUtil.AddState(_controlFSM, "Idle 3 Attack Choice");
			FsmState val2 = FsmUtil.AddState(_controlFSM, "Idle 3 Attack Combo Await");
			FsmState val3 = FsmUtil.AddState(_controlFSM, Constants.PhaseNames.Idle3);
			SendRandomEventV4 val4 = new SendRandomEventV4();
			val4.events = (FsmEvent[])(object)new FsmEvent[4]
			{
				FsmEvent.GetFsmEvent("DASHSLASH"),
				FsmEvent.GetFsmEvent("NEEDLESRANDOM"),
				FsmEvent.GetFsmEvent("SPIKELIFT"),
				FsmEvent.GetFsmEvent("RUBBLE")
			};
			val4.weights = (FsmFloat[])(object)new FsmFloat[4]
			{
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f)),
				new FsmFloat(FsmFloat.op_Implicit(1f))
			};
			val4.eventMax = (FsmInt[])(object)new FsmInt[4]
			{
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(2)),
				new FsmInt(FsmInt.op_Implicit(1)),
				new FsmInt(FsmInt.op_Implicit(1))
			};
			val4.missedMax = (FsmInt[])(object)new FsmInt[4]
			{
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4)),
				new FsmInt(FsmInt.op_Implicit(4))
			};
			val4.activeBool = FsmBool.op_Implicit(true);
			FsmUtil.AddAction(val, (FsmStateAction)(object)val4);
			FsmUtil.AddTransition(val, "DASHSLASH", GMSAttackList.DashSlash.GetStartStateName());
			FsmUtil.AddTransition(val, "NEEDLESRANDOM", "Set Primary Hand");
			FsmUtil.AddTransition(val, "SPIKELIFT", GMSAttackList.SpikeLift.GetStartStateName());
			FsmUtil.AddTransition(val, "RUBBLE", GMSAttackList.RubblePull.GetStartStateName());
			FsmUtil.AddMethod(val3, (Action<FsmStateAction>)delegate
			{
				if (LaceBossScene.Instance.laceAttemptingCombo)
				{
					_controlFSM.SendEvent("COMBO");
				}
			});
			FsmUtil.AddAction(val3, (FsmStateAction)new Wait
			{
				time = FsmFloat.op_Implicit(1.5f),
				realTime = false,
				finishEvent = FsmEvent.GetFsmEvent("FINISHED")
			});
			FsmUtil.AddTransition(val3, "FINISHED", "Idle 3 Attack Choice");
			FsmUtil.AddTransition(val3, "COMBO", val2.name);
			FsmUtil.AddMethod(val2, (Action<FsmStateAction>)delegate
			{
				LaceBos