using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using FinalBossHoward;
using HarmonyLib;
using MelonLoader;
using RUMBLE.Environment.Howard;
using RUMBLE.Managers;
using RUMBLE.MoveSystem;
using UnhollowerBaseLib;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(main), "Final Boss Howard", "1.1.0", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: AssemblyTitle("FinalBossHoward")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("FinalBossHoward")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("f848df1a-abb5-447b-837e-aa52cf9b4f4d")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace FinalBossHoward;

[HarmonyPatch(typeof(Howard), "OnActivationLeverChanged")]
public static class Patch
{
	private static void Prefix(int step)
	{
		switch (step)
		{
		case 0:
			if (main.instance.howard.currentLogicIndex == 2)
			{
				main.instance.howard.incomingStructureCheckDelay = 0f;
				main.instance.howard.knockoutRegenDelay = 0f;
				main.instance.howard.lookAtSpeed = 100f;
				main.instance.howard.minIncomingStructureDistance = 10f;
				main.instance.howard.incomingStructureFrameCount = 1;
				main.instance.howard.currentHp = 40f;
				main.instance.checkStructuresTimer = DateTime.Now;
				main.instance.howardActive = true;
			}
			break;
		case 1:
			main.instance.howard.incomingStructureCheckDelay = 0.5f;
			main.instance.howard.knockoutRegenDelay = 3f;
			main.instance.howard.lookAtSpeed = 30f;
			main.instance.howard.minIncomingStructureDistance = 3f;
			main.instance.howard.incomingStructureFrameCount = 7;
			main.instance.howardActive = false;
			break;
		}
	}
}
public class main : MelonMod
{
	public static main instance;

	public Howard howard;

	private string currentScene = "";

	private bool sceneChanged = false;

	public bool howardActive = false;

	private PoolManager poolManager;

	private GameObject discPool;

	private GameObject ballPool;

	private GameObject pillarPool;

	private GameObject cubePool;

	private GameObject wallPool;

	private GameObject smallRockPool;

	private GameObject largeRockPool;

	private DateTime[] discPoolTimer;

	private DateTime[] ballPoolTimer;

	private DateTime[] pillarPoolTimer;

	private DateTime[] cubePoolTimer;

	private DateTime[] wallPoolTimer;

	private DateTime[] smallRockPoolTimer;

	private DateTime[] largeRockPoolTimer;

	private bool[] discPoolTimerActive;

	private bool[] ballPoolTimerActive;

	private bool[] pillarPoolTimerActive;

	private bool[] cubePoolTimerActive;

	private bool[] wallPoolTimerActive;

	private bool[] smallRockPoolTimerActive;

	private bool[] largeRockPoolTimerActive;

	public DateTime checkStructuresTimer;

	public override void OnEarlyInitializeMelon()
	{
		instance = this;
	}

	public override void OnFixedUpdate()
	{
		if (sceneChanged)
		{
			try
			{
				if (currentScene == "Gym")
				{
					poolManager = GameObject.Find("Game Instance/Pre-Initializable/PoolManager").GetComponent<PoolManager>();
					SetupPoolArrays();
					BuffHowardLevel2();
					sceneChanged = false;
				}
			}
			catch
			{
				return;
			}
		}
		if (!(currentScene != "Gym") && howardActive && checkStructuresTimer <= DateTime.Now)
		{
			ClearRails();
			checkStructuresTimer = DateTime.Now.AddSeconds(1.0);
		}
	}

	public override void OnSceneWasLoaded(int buildIndex, string sceneName)
	{
		currentScene = sceneName;
		sceneChanged = true;
	}

	private void SetupPoolArrays()
	{
		discPool = ((Component)((Component)poolManager).transform.GetChild(43)).gameObject;
		pillarPool = ((Component)((Component)poolManager).transform.GetChild(42)).gameObject;
		ballPool = ((Component)((Component)poolManager).transform.GetChild(51)).gameObject;
		cubePool = ((Component)((Component)poolManager).transform.GetChild(50)).gameObject;
		wallPool = ((Component)((Component)poolManager).transform.GetChild(49)).gameObject;
		smallRockPool = ((Component)((Component)poolManager).transform.GetChild(16)).gameObject;
		largeRockPool = ((Component)((Component)poolManager).transform.GetChild(17)).gameObject;
		discPoolTimer = new DateTime[discPool.transform.childCount];
		pillarPoolTimer = new DateTime[pillarPool.transform.childCount];
		ballPoolTimer = new DateTime[ballPool.transform.childCount];
		cubePoolTimer = new DateTime[cubePool.transform.childCount];
		wallPoolTimer = new DateTime[wallPool.transform.childCount];
		smallRockPoolTimer = new DateTime[smallRockPool.transform.childCount];
		largeRockPoolTimer = new DateTime[largeRockPool.transform.childCount];
		discPoolTimerActive = new bool[discPool.transform.childCount];
		pillarPoolTimerActive = new bool[pillarPool.transform.childCount];
		ballPoolTimerActive = new bool[ballPool.transform.childCount];
		cubePoolTimerActive = new bool[cubePool.transform.childCount];
		wallPoolTimerActive = new bool[wallPool.transform.childCount];
		smallRockPoolTimerActive = new bool[smallRockPool.transform.childCount];
		largeRockPoolTimerActive = new bool[largeRockPool.transform.childCount];
	}

	private void ClearRails()
	{
		if (discPool.transform.childCount > discPoolTimerActive.Length)
		{
			IncreaseArraySizes("Disc");
		}
		if (pillarPool.transform.childCount > pillarPoolTimerActive.Length)
		{
			IncreaseArraySizes("Pillar");
		}
		if (ballPool.transform.childCount > ballPoolTimerActive.Length)
		{
			IncreaseArraySizes("Ball");
		}
		if (cubePool.transform.childCount > cubePoolTimerActive.Length)
		{
			IncreaseArraySizes("Cube");
		}
		if (wallPool.transform.childCount > wallPoolTimerActive.Length)
		{
			IncreaseArraySizes("Wall");
		}
		if (smallRockPool.transform.childCount > smallRockPoolTimerActive.Length)
		{
			IncreaseArraySizes("SmallRock");
		}
		if (largeRockPool.transform.childCount > largeRockPoolTimerActive.Length)
		{
			IncreaseArraySizes("LargeRock");
		}
		CheckPools(discPool, "Disc");
		CheckPools(pillarPool, "Pillar");
		CheckPools(ballPool, "Ball");
		CheckPools(cubePool, "Cube");
		CheckPools(wallPool, "Wall");
		CheckPools(smallRockPool, "SmallRock");
		CheckPools(largeRockPool, "LargeRock");
		CheckTimersIfDone();
	}

	private void CheckTimersIfDone()
	{
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		//IL_0269: Unknown result type (might be due to invalid IL or missing references)
		//IL_034e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0433: Unknown result type (might be due to invalid IL or missing references)
		//IL_0518: Unknown result type (might be due to invalid IL or missing references)
		//IL_05fd: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < discPoolTimer.Length; i++)
		{
			if (discPoolTimerActive[i] && discPoolTimer[i] <= DateTime.Now)
			{
				if (((Component)discPool.transform.GetChild(i)).gameObject.active && ((Component)discPool.transform.GetChild(i)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)discPool.transform.GetChild(i)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				discPoolTimerActive[i] = false;
			}
		}
		for (int j = 0; j < pillarPoolTimer.Length; j++)
		{
			if (pillarPoolTimerActive[j] && pillarPoolTimer[j] <= DateTime.Now)
			{
				if (((Component)pillarPool.transform.GetChild(j)).gameObject.active && ((Component)pillarPool.transform.GetChild(j)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)pillarPool.transform.GetChild(j)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				pillarPoolTimerActive[j] = false;
			}
		}
		for (int k = 0; k < ballPoolTimer.Length; k++)
		{
			if (ballPoolTimerActive[k] && ballPoolTimer[k] <= DateTime.Now)
			{
				if (((Component)ballPool.transform.GetChild(k)).gameObject.active && ((Component)ballPool.transform.GetChild(k)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)ballPool.transform.GetChild(k)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				ballPoolTimerActive[k] = false;
			}
		}
		for (int l = 0; l < cubePoolTimer.Length; l++)
		{
			if (cubePoolTimerActive[l] && cubePoolTimer[l] <= DateTime.Now)
			{
				if (((Component)cubePool.transform.GetChild(l)).gameObject.active && ((Component)cubePool.transform.GetChild(l)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)cubePool.transform.GetChild(l)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				cubePoolTimerActive[l] = false;
			}
		}
		for (int m = 0; m < wallPoolTimer.Length; m++)
		{
			if (wallPoolTimerActive[m] && wallPoolTimer[m] <= DateTime.Now)
			{
				if (((Component)wallPool.transform.GetChild(m)).gameObject.active && ((Component)wallPool.transform.GetChild(m)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)wallPool.transform.GetChild(m)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				wallPoolTimerActive[m] = false;
			}
		}
		for (int n = 0; n < smallRockPoolTimer.Length; n++)
		{
			if (smallRockPoolTimerActive[n] && smallRockPoolTimer[n] <= DateTime.Now)
			{
				if (((Component)smallRockPool.transform.GetChild(n)).gameObject.active && ((Component)smallRockPool.transform.GetChild(n)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)smallRockPool.transform.GetChild(n)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				smallRockPoolTimerActive[n] = false;
			}
		}
		for (int num = 0; num < largeRockPoolTimer.Length; num++)
		{
			if (largeRockPoolTimerActive[num] && largeRockPoolTimer[num] <= DateTime.Now)
			{
				if (((Component)largeRockPool.transform.GetChild(num)).gameObject.active && ((Component)largeRockPool.transform.GetChild(num)).GetComponent<Structure>().CurrentSpeed == 0f)
				{
					((Component)largeRockPool.transform.GetChild(num)).GetComponent<Structure>().Kill(new Vector3(0f, 0f, 0f), true, true, true);
				}
				largeRockPoolTimerActive[num] = false;
			}
		}
	}

	private void IncreaseArraySizes(string poolName)
	{
		switch (poolName)
		{
		case "Disc":
		{
			DateTime[] array = new DateTime[discPool.transform.childCount];
			bool[] array2 = new bool[discPool.transform.childCount];
			for (int j = 0; j < discPoolTimer.Length; j++)
			{
				array[j] = discPoolTimer[j];
				array2[j] = discPoolTimerActive[j];
			}
			try
			{
				discPoolTimer = array;
				discPoolTimerActive = array2;
				break;
			}
			catch (Exception ex2)
			{
				MelonLogger.Msg((object)ex2);
				break;
			}
		}
		case "Pillar":
		{
			DateTime[] array = new DateTime[pillarPool.transform.childCount];
			bool[] array2 = new bool[pillarPool.transform.childCount];
			for (int n = 0; n < pillarPoolTimer.Length; n++)
			{
				array[n] = pillarPoolTimer[n];
				array2[n] = pillarPoolTimerActive[n];
			}
			try
			{
				pillarPoolTimer = array;
				pillarPoolTimerActive = array2;
				break;
			}
			catch (Exception ex6)
			{
				MelonLogger.Msg((object)ex6);
				break;
			}
		}
		case "Ball":
		{
			DateTime[] array = new DateTime[ballPool.transform.childCount];
			bool[] array2 = new bool[ballPool.transform.childCount];
			for (int k = 0; k < ballPoolTimer.Length; k++)
			{
				array[k] = ballPoolTimer[k];
				array2[k] = ballPoolTimerActive[k];
			}
			try
			{
				ballPoolTimer = array;
				ballPoolTimerActive = array2;
				break;
			}
			catch (Exception ex3)
			{
				MelonLogger.Msg((object)ex3);
				break;
			}
		}
		case "Cube":
		{
			DateTime[] array = new DateTime[cubePool.transform.childCount];
			bool[] array2 = new bool[cubePool.transform.childCount];
			for (int m = 0; m < cubePoolTimer.Length; m++)
			{
				array[m] = cubePoolTimer[m];
				array2[m] = cubePoolTimerActive[m];
			}
			try
			{
				cubePoolTimer = array;
				cubePoolTimerActive = array2;
				break;
			}
			catch (Exception ex5)
			{
				MelonLogger.Msg((object)ex5);
				break;
			}
		}
		case "Wall":
		{
			DateTime[] array = new DateTime[wallPool.transform.childCount];
			bool[] array2 = new bool[wallPool.transform.childCount];
			for (int num = 0; num < wallPoolTimer.Length; num++)
			{
				array[num] = wallPoolTimer[num];
				array2[num] = wallPoolTimerActive[num];
			}
			try
			{
				wallPoolTimer = array;
				wallPoolTimerActive = array2;
				break;
			}
			catch (Exception ex7)
			{
				MelonLogger.Msg((object)ex7);
				break;
			}
		}
		case "SmallRock":
		{
			DateTime[] array = new DateTime[smallRockPool.transform.childCount];
			bool[] array2 = new bool[smallRockPool.transform.childCount];
			for (int l = 0; l < smallRockPoolTimer.Length; l++)
			{
				array[l] = smallRockPoolTimer[l];
				array2[l] = smallRockPoolTimerActive[l];
			}
			try
			{
				smallRockPoolTimer = array;
				smallRockPoolTimerActive = array2;
				break;
			}
			catch (Exception ex4)
			{
				MelonLogger.Msg((object)ex4);
				break;
			}
		}
		case "LargeRock":
		{
			DateTime[] array = new DateTime[largeRockPool.transform.childCount];
			bool[] array2 = new bool[largeRockPool.transform.childCount];
			for (int i = 0; i < largeRockPoolTimer.Length; i++)
			{
				array[i] = largeRockPoolTimer[i];
				array2[i] = largeRockPoolTimerActive[i];
			}
			try
			{
				largeRockPoolTimer = array;
				largeRockPoolTimerActive = array2;
				break;
			}
			catch (Exception ex)
			{
				MelonLogger.Msg((object)ex);
				break;
			}
		}
		}
	}

	private void CheckPools(GameObject pool, string poolName)
	{
		for (int i = 0; i < pool.transform.GetChildCount(); i++)
		{
			if (!((Component)pool.transform.GetChild(i)).gameObject.active || ((Component)pool.transform.GetChild(i)).GetComponent<Structure>().CurrentSpeed != 0f || !CheckIfCloseToRails(pool.transform.GetChild(i)))
			{
				continue;
			}
			switch (poolName)
			{
			case "Disc":
				if (!discPoolTimerActive[i])
				{
					discPoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					discPoolTimerActive[i] = true;
				}
				break;
			case "Pillar":
				if (!pillarPoolTimerActive[i])
				{
					pillarPoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					pillarPoolTimerActive[i] = true;
				}
				break;
			case "Ball":
				if (!ballPoolTimerActive[i])
				{
					ballPoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					ballPoolTimerActive[i] = true;
				}
				break;
			case "Cube":
				if (!cubePoolTimerActive[i])
				{
					cubePoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					cubePoolTimerActive[i] = true;
				}
				break;
			case "Wall":
				if (!wallPoolTimerActive[i])
				{
					wallPoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					wallPoolTimerActive[i] = true;
				}
				break;
			case "SmallRock":
				if (!smallRockPoolTimerActive[i])
				{
					smallRockPoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					smallRockPoolTimerActive[i] = true;
				}
				break;
			case "LargeRock":
				if (!largeRockPoolTimerActive[i])
				{
					largeRockPoolTimer[i] = DateTime.Now.AddSeconds(1.0);
					largeRockPoolTimerActive[i] = true;
				}
				break;
			}
		}
	}

	private bool CheckIfCloseToRails(Transform structure)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		if (Vector3.Distance(((Component)structure).transform.position, new Vector3(13.5198f, -2.9653f, -19.7457f)) < 4f)
		{
			return true;
		}
		if (Vector3.Distance(((Component)structure).transform.position, new Vector3(6.7449f, -2.5501f, -25.282f)) < 4f)
		{
			return true;
		}
		if (Vector3.Distance(((Component)structure).transform.position, new Vector3(11.7203f, -2.9645f, -22.255f)) < 4f)
		{
			return true;
		}
		return false;
	}

	private void BuffHowardLevel2()
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_018e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_035c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0366: Expected O, but got Unknown
		//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03fe: Expected O, but got Unknown
		//IL_0535: Unknown result type (might be due to invalid IL or missing references)
		//IL_0609: Unknown result type (might be due to invalid IL or missing references)
		//IL_06dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_07f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a69: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b56: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cc7: Unknown result type (might be due to invalid IL or missing references)
		howard = GameObject.Find("--------------LOGIC--------------/Heinhouser products/Howard root").GetComponent<Howard>();
		howard.howardAnimator.changeLevelAnimationWaitTime = 1f;
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].MinMaxDecisionTime = new Vector2(0f, 0f);
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].standStillReactiontime = 0f;
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].DodgeBehaviour.AnglePerSecond = 40f;
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].maxHealth = 40f;
		ReactionChance val = ((Il2CppArrayBase<ReactionChance>)(object)((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].reactions)[0];
		val.Weight = 10f;
		((Il2CppArrayBase<ReactionChance>)(object)((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].reactions)[0] = val;
		val = ((Il2CppArrayBase<ReactionChance>)(object)((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].reactions)[1];
		val.Weight = 90f;
		((Il2CppArrayBase<ReactionChance>)(object)((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].reactions)[1] = val;
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].howardHeadlightColor = new Color(0.414f, 0f, 1f, 1f);
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].howardIdleLevelColor = new Color(0.414f, 0f, 1f, 1f);
		((Il2CppArrayBase<HowardLogic>)(object)howard.LogicLevels)[2].howardLevelColor = new Color(0.414f, 0f, 1f, 1f);
		HowardMoveBehaviour val2 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[3].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardMoveBehaviour>();
		HowardAttackBehaviour val3 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[0].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		HowardAttackBehaviour val4 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[1].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		HowardAttackBehaviour val5 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[2].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		HowardAttackBehaviour val6 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[4].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		HowardAttackBehaviour val7 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[5].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		HowardAttackBehaviour val8 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[6].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets.Add(new SequenceSet());
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[7].Sequence = ((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[6].Sequence;
		HowardAttackBehaviour val9 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[7].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets.Add(new SequenceSet());
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[8].Sequence = ((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[0].Sequence;
		HowardAttackBehaviour val10 = ((Il2CppObjectBase)((Il2CppArrayBase<HowardBehaviourTiming>)(object)((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[8].Sequence.BehaviourTimings)[0].Behaviour).Cast<HowardAttackBehaviour>();
		TimedStack[] array = (TimedStack[])(object)new TimedStack[8]
		{
			((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[0],
			((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[0],
			((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[0],
			((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[0],
			((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[0],
			((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[1],
			((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[1],
			((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[2]
		};
		val2.AnglePerSecond = 30f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[0].RequiredMinMaxRange = new Vector2(7f, 10f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[0].Weight = 50f;
		((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[0] = array[2];
		((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[0].PostWaitTime = 0.4f;
		((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[1] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[1].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val3.timedStacks)[1].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[1].RequiredMinMaxRange = new Vector2(5f, 7f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[1].Weight = 50f;
		((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[0] = array[2];
		((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[0].PostWaitTime = 0.4f;
		((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[1] = array[6];
		((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[1].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val4.timedStacks)[1].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[2].RequiredMinMaxRange = new Vector2(0f, 10f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[2].Weight = 50f;
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[0] = array[3];
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[0].PostWaitTime = 0.75f;
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[1] = array[6];
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[1].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[1].PostWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[2] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[2].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val5.timedStacks)[2].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[4].RequiredMinMaxRange = new Vector2(1f, 8f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[4].Weight = 50f;
		val6.timedStacks = Il2CppReferenceArray<TimedStack>.op_Implicit((TimedStack[])(object)new TimedStack[5]);
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[0] = array[4];
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[0].PostWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[1] = array[3];
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[1].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[1].PostWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[2] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[2].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[2].PostWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[3] = array[6];
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[3].PreWaitTime = 0.25f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[3].PostWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[4] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[4].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val6.timedStacks)[4].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[5].Weight = 50f;
		val7.timedStacks = Il2CppReferenceArray<TimedStack>.op_Implicit((TimedStack[])(object)new TimedStack[2]);
		((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[0] = array[0];
		((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[0].PostWaitTime = 0.001f;
		((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[1] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[1].PreWaitTime = 0.001f;
		((Il2CppArrayBase<TimedStack>)(object)val7.timedStacks)[1].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[6].RequiredMinMaxRange = new Vector2(0f, 6f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[6].Weight = 50f;
		val8.timedStacks = Il2CppReferenceArray<TimedStack>.op_Implicit((TimedStack[])(object)new TimedStack[2]);
		((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[0] = array[1];
		((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[0].PostWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[1] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[1].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val8.timedStacks)[1].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[7].RequiredMinMaxRange = new Vector2(3f, 6f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[7].Weight = 50f;
		val9.timedStacks = Il2CppReferenceArray<TimedStack>.op_Implicit((TimedStack[])(object)new TimedStack[4]);
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[0] = array[1];
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[0].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[0].PostWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[1] = array[1];
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[1].PreWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[1].PostWaitTime = 0.3f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[2] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[2].PreWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[2].PostWaitTime = 0.3f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[3] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[3].PreWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val9.timedStacks)[3].PostWaitTime = 0.3f;
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[8].RequiredMinMaxRange = new Vector2(2f, 7f);
		((Il2CppArrayBase<HowardLogic>)(object)Howard.currentActiveHoward.LogicLevels)[2].SequenceSets[8].Weight = 50f;
		val10.timedStacks = Il2CppReferenceArray<TimedStack>.op_Implicit((TimedStack[])(object)new TimedStack[3]);
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[0] = array[2];
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[0].PreWaitTime = 0.5f;
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[0].PostWaitTime = 0.75f;
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[1] = array[6];
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[1].PreWaitTime = 0.1f;
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[1].PostWaitTime = 0.05f;
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[2] = array[5];
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[2].PreWaitTime = 0.05f;
		((Il2CppArrayBase<TimedStack>)(object)val10.timedStacks)[2].PostWaitTime = 0.3f;
	}
}