Decompiled source of BananasDifficulty v1.2.5

BananaDifficulty.dll

Decompiled a week ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BananaDifficulty;
using BananaDifficulty.Patches;
using BananaDifficulty.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Discord;
using HarmonyLib;
using NewBananaWeapons;
using Sandbox;
using TMPro;
using ULTRAKILL.Enemy;
using ULTRAKILL.Portal;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BananaDifficulty")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BananaDifficulty")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b7996125-3626-439e-a969-9dd238d5335f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public class RodentBoss : MonoBehaviour
{
	[CompilerGenerated]
	private sealed class <PhaseTransitionRoutine>d__25 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public Transform escapePoint;

		public Transform arenaPoint;

		public RodentBoss <>4__this;

		private Vector3 <startPos>5__1;

		private Vector3 <endPos>5__2;

		private float <duration>5__3;

		private float <t>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <PhaseTransitionRoutine>d__25(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.isTransitioning = true;
				<startPos>5__1 = ((Component)<>4__this).transform.position;
				<endPos>5__2 = escapePoint.position;
				<duration>5__3 = 0.5f;
				<t>5__4 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<t>5__4 < <duration>5__3)
			{
				<t>5__4 += Time.deltaTime;
				((Component)<>4__this).transform.position = Vector3.Lerp(<startPos>5__1, <endPos>5__2, <t>5__4 / <duration>5__3);
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			((Component)<>4__this).transform.position = <endPos>5__2;
			((Component)escapePoint.parent).gameObject.SetActive(false);
			Object.Instantiate<GameObject>(BananaDifficultyPlugin.rubbleBig, <endPos>5__2, Quaternion.identity);
			((Component)<>4__this).transform.position = arenaPoint.position;
			MonoSingleton<HudMessageReceiver>.Instance.SendHudMessage("<color=orange>[WARNING]</color> Increased radiation detected.", "", "", 0, false, false, true);
			<>4__this.isTransitioning = false;
			<>4__this.canExecute = false;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <SpawnBeamCoroutine>d__42 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private float <distance>5__1;

		private int <num>5__2;

		private int <i>5__3;

		private Vector3 <vector>5__4;

		private GameObject <result>5__5;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <SpawnBeamCoroutine>d__42(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<result>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<distance>5__1 = 100f;
				<i>5__3 = 0;
				goto IL_027f;
			case 1:
				<>1__state = -1;
				<num>5__2 = <i>5__3;
				<result>5__5 = null;
				<i>5__3 = <num>5__2 + 1;
				goto IL_027f;
			case 2:
				{
					<>1__state = -1;
					return false;
				}
				IL_027f:
				if (<i>5__3 < 5)
				{
					<vector>5__4 = new Vector3(((Component)<>4__this._rodent).transform.position.x + Random.Range(<distance>5__1, 0f - <distance>5__1), ((Component)<>4__this._rodent).transform.position.y, ((Component)<>4__this._rodent).transform.position.z + Random.Range(<distance>5__1, 0f - <distance>5__1));
					if (Vector3.Distance(((Component)<>4__this._rodent).transform.position, <vector>5__4) > <distance>5__1)
					{
						Vector3 position = ((Component)<>4__this._rodent).transform.position;
						Vector3 val = <vector>5__4 - ((Component)<>4__this._rodent).transform.position;
						<vector>5__4 = position + ((Vector3)(ref val)).normalized * <distance>5__1;
					}
					<vector>5__4.y -= 5f;
					<result>5__5 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.upArrow, (Vector3)((<i>5__3 == 0) ? new Vector3(<>4__this._rodent.eid.target.position.x, ((Component)<>4__this._rodent).transform.position.y - 5f, <>4__this._rodent.eid.target.position.z) : <vector>5__4), Quaternion.LookRotation(Vector3.up));
					<result>5__5.transform.SetParent(((Component)<>4__this._rodent).transform.parent, true);
					<result>5__5.GetComponentInChildren<HurtZone>(true).ignoredEnemyTypes.Add(<>4__this._rodent.eid.enemyType);
					<>2__current = (object)new WaitForSecondsRealtime(0.25f);
					<>1__state = 1;
					return true;
				}
				<>2__current = null;
				<>1__state = 2;
				return true;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <beamSpin>d__34 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private GameObject <beam>5__1;

		private ContinuousBeam <abeam>5__2;

		private float <t>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <beamSpin>d__34(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<beam>5__1 = null;
			<abeam>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(Random.Range(0f, 0.75f));
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<beam>5__1 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.mindBeam, ((Component)<>4__this._rodent).transform.position, Quaternion.identity);
				<beam>5__1.transform.parent = ((Component)<>4__this._rodent).transform;
				if (<beam>5__1.TryGetComponent<ContinuousBeam>(ref <abeam>5__2))
				{
					<abeam>5__2.safeEnemyType = <>4__this._rodent.eid.enemyType;
				}
				<t>5__3 = 0f;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (<t>5__3 < 4f)
			{
				<t>5__3 += Time.deltaTime;
				<beam>5__1.transform.Rotate(Vector3.up * 220f * Time.deltaTime);
				<>2__current = null;
				<>1__state = 2;
				return true;
			}
			Object.Destroy((Object)(object)<beam>5__1);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <blackHoleTrap>d__40 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private Vector3 <pos>5__1;

		private GameObject <black>5__2;

		private BlackHoleProjectile <bl>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <blackHoleTrap>d__40(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<black>5__2 = null;
			<bl>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<pos>5__1 = <>4__this.GetGroundPosition(<>4__this._rodent.eid.target.position);
				Object.Instantiate<GameObject>(BananaDifficultyPlugin.blackHoleExplosion, <pos>5__1, Quaternion.identity);
				<>2__current = (object)new WaitForSeconds(0.4f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<black>5__2 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.blackHole, <pos>5__1, Quaternion.identity);
				if (<black>5__2.TryGetComponent<BlackHoleProjectile>(ref <bl>5__3))
				{
					<bl>5__3.enemy = true;
					<bl>5__3.safeType = <>4__this._rodent.eid.enemyType;
					<bl>5__3.target = <>4__this._rodent.eid.target;
					BlackHoleProjectile obj = <bl>5__3;
					obj.speed *= 3f;
					<bl>5__3.Activate();
				}
				Object.Destroy((Object)(object)<black>5__2, 18f);
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <dashAttack>d__43 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private Vector3 <dir>5__1;

		private float <t>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <dashAttack>d__43(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_0103: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				Object.Instantiate<GameObject>(BananaDifficultyPlugin.v2FlashUnpariable, ((Component)<>4__this._rodent).transform.position, Quaternion.identity);
				Vector3 val = <>4__this._rodent.eid.target.PredictTargetPosition(0.5f, false, false) - ((Component)<>4__this._rodent).transform.position;
				<dir>5__1 = ((Vector3)(ref val)).normalized;
				<dir>5__1.y = 0f;
				<>2__current = (object)new WaitForSeconds(0.35f);
				<>1__state = 1;
				return true;
			}
			case 1:
				<>1__state = -1;
				<t>5__2 = 0f;
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			if (<t>5__2 < 0.5f)
			{
				<t>5__2 += Time.deltaTime;
				Transform transform = ((Component)<>4__this._rodent).transform;
				transform.position += <dir>5__1 * 100f * Time.deltaTime;
				if (Vector3.Distance(((Component)<>4__this._rodent).transform.position, <>4__this._rodent.eid.target.position) <= 0.5f)
				{
					if (<>4__this._rodent.eid.target.isPlayer)
					{
						MonoSingleton<NewMovement>.Instance.GetHurt(15, false, 1f, false, false, 0.35f, false);
					}
					if (<>4__this._rodent.eid.target.isEnemy)
					{
						<>4__this._rodent.eid.target.enemyIdentifier.hitter = "rat";
						<>4__this._rodent.eid.target.enemyIdentifier.SimpleDamage(15f);
					}
				}
				<>2__current = null;
				<>1__state = 2;
				return true;
			}
			Object.Instantiate<GameObject>(BananaDifficultyPlugin.bigExplosion, ((Component)<>4__this._rodent).transform.position, Quaternion.identity);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <goMyRats>d__27 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <amount>5__1;

		private int <i>5__2;

		private GameObject <rat>5__3;

		private Projectile <proj>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <goMyRats>d__27(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<rat>5__3 = null;
			<proj>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//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)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<amount>5__1 = Random.Range(0, 15);
				<i>5__2 = 0;
				break;
			case 1:
				<>1__state = -1;
				<rat>5__3 = null;
				<proj>5__4 = null;
				<i>5__2++;
				break;
			}
			if (<i>5__2 < <amount>5__1)
			{
				<rat>5__3 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.ratAttack, ((Component)<>4__this).transform.position, Quaternion.identity);
				if (<rat>5__3.TryGetComponent<Projectile>(ref <proj>5__4))
				{
					<proj>5__4.safeEnemyType = <>4__this._rodent.eid.enemyType;
				}
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <growSize>d__39 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public GameObject increase;

		public RodentBoss <>4__this;

		private float <t>5__1;

		private GameObject <result>5__2;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <growSize>d__39(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<result>5__2 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<t>5__1 = 0f;
				<result>5__2 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.fallAttack, increase.transform.position + Vector3.up * 500f, BananaDifficultyPlugin.fallAttack.transform.rotation);
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<t>5__1 <= 1f)
			{
				increase.transform.localScale = Vector3.Lerp(Vector3.zero, Vector3.one * 10f, <t>5__1);
				<result>5__2.transform.position = Vector3.Lerp(increase.transform.position + Vector3.up * 500f, increase.transform.position, <t>5__1);
				<t>5__1 += Time.deltaTime / 2f;
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			Object.Instantiate<GameObject>(BananaDifficultyPlugin.rubbleBig, increase.transform.position, BananaDifficultyPlugin.rubbleBig.transform.rotation);
			<result>5__2.AddComponent<ShakyRock>();
			Object.Destroy((Object)(object)increase);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <homingBarrage>d__41 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <amount>5__1;

		private int <i>5__2;

		private Vector3 <spawn>5__3;

		private GameObject <proj>5__4;

		private Projectile <porj>5__5;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <homingBarrage>d__41(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<proj>5__4 = null;
			<porj>5__5 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<amount>5__1 = Random.Range(5, 15);
				<i>5__2 = 0;
				break;
			case 1:
				<>1__state = -1;
				<proj>5__4 = null;
				<porj>5__5 = null;
				<i>5__2++;
				break;
			}
			if (<i>5__2 < <amount>5__1)
			{
				<spawn>5__3 = ((Component)<>4__this._rodent).transform.position + new Vector3((float)Random.Range(-10, 10), (float)Random.Range(5, 10), (float)Random.Range(-10, 10));
				<proj>5__4 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.projHoming, <spawn>5__3, Quaternion.identity);
				if (<proj>5__4.TryGetComponent<Projectile>(ref <porj>5__5))
				{
					<porj>5__5.safeEnemyType = <>4__this._rodent.eid.enemyType;
				}
				<>2__current = (object)new WaitForSeconds(0.15f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <lightningBarrage>d__29 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <count>5__1;

		private Vector3[] <positions>5__2;

		private GameObject[] <lightnings>5__3;

		private int <i>5__4;

		private Vector3 <pos>5__5;

		private int <i>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <lightningBarrage>d__29(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<positions>5__2 = null;
			<lightnings>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<count>5__1 = Random.Range(3, 6);
				<positions>5__2 = (Vector3[])(object)new Vector3[<count>5__1];
				<lightnings>5__3 = (GameObject[])(object)new GameObject[<count>5__1];
				<i>5__4 = 0;
				goto IL_0144;
			case 1:
				<>1__state = -1;
				<i>5__4++;
				goto IL_0144;
			case 2:
				<>1__state = -1;
				<i>5__6 = 0;
				break;
			case 3:
				{
					<>1__state = -1;
					<i>5__6++;
					break;
				}
				IL_0144:
				if (<i>5__4 < <count>5__1)
				{
					<pos>5__5 = <>4__this._rodent.eid.target.position + new Vector3(Random.Range(-12f, 12f), 0f, Random.Range(-12f, 12f));
					<pos>5__5 = <>4__this.GetGroundPosition(<pos>5__5);
					<positions>5__2[<i>5__4] = <pos>5__5;
					<lightnings>5__3[<i>5__4] = Object.Instantiate<GameObject>(BananaDifficultyPlugin.lightningWindup, <pos>5__5, Quaternion.identity);
					<>2__current = (object)new WaitForSeconds(0.18f);
					<>1__state = 1;
					return true;
				}
				<>2__current = (object)new WaitForSeconds(0.6f);
				<>1__state = 2;
				return true;
			}
			if (<i>5__6 < <count>5__1)
			{
				Object.Instantiate<GameObject>(BananaDifficultyPlugin.lightningExplosion, <positions>5__2[<i>5__6], Quaternion.identity);
				Object.Destroy((Object)(object)<lightnings>5__3[<i>5__6]);
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 3;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <mirrorReaperSlam>d__33 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private Vector3 <targetPos>5__1;

		private Vector3 <dir>5__2;

		private int <i>5__3;

		private Vector3 <spreadDir>5__4;

		private GameObject <wave>5__5;

		private GroundWave <gw>5__6;

		private HurtZone[] <>s__7;

		private int <>s__8;

		private HurtZone <hz>5__9;

		private Breakable <componentInChildren>5__10;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <mirrorReaperSlam>d__33(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<wave>5__5 = null;
			<gw>5__6 = null;
			<>s__7 = null;
			<hz>5__9 = null;
			<componentInChildren>5__10 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
			{
				<>1__state = -1;
				<targetPos>5__1 = <>4__this._rodent.eid.target.position;
				Vector3 val = <targetPos>5__1 - ((Component)<>4__this._rodent).transform.position;
				<dir>5__2 = ((Vector3)(ref val)).normalized;
				<dir>5__2.y = 0f;
				<i>5__3 = -1;
				break;
			}
			case 1:
				<>1__state = -1;
				<wave>5__5 = null;
				<gw>5__6 = null;
				<i>5__3++;
				break;
			}
			if (<i>5__3 <= 1)
			{
				<spreadDir>5__4 = Quaternion.Euler(0f, (float)<i>5__3 * 20f, 0f) * <dir>5__2;
				<wave>5__5 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.mirrorReaperWave, ((Component)<>4__this._rodent).transform.position + Vector3.up * 0.1f, Quaternion.LookRotation(<spreadDir>5__4));
				<>s__7 = <wave>5__5.GetComponentsInChildren<HurtZone>(true);
				for (<>s__8 = 0; <>s__8 < <>s__7.Length; <>s__8++)
				{
					<hz>5__9 = <>s__7[<>s__8];
					<hz>5__9.ignoredEnemyTypes.Add(<>4__this._rodent.eid.enemyType);
					<hz>5__9 = null;
				}
				<>s__7 = null;
				if (<wave>5__5.TryGetComponent<GroundWave>(ref <gw>5__6))
				{
					<gw>5__6.target = <>4__this._rodent.eid.target;
					<gw>5__6.eid = <>4__this._rodent.eid;
					<componentInChildren>5__10 = ((Component)<gw>5__6).GetComponentInChildren<Breakable>();
					if (Object.op_Implicit((Object)(object)<componentInChildren>5__10))
					{
						<componentInChildren>5__10.durability = 5f;
					}
					((Component)<gw>5__6).transform.SetParent(Object.op_Implicit((Object)(object)((Component)<>4__this._rodent).transform.parent) ? ((Component)<>4__this._rodent).transform.parent : ((Component)GoreZone.ResolveGoreZone(((Component)<>4__this._rodent).transform)).transform);
					<componentInChildren>5__10 = null;
				}
				<wave>5__5.AddComponent<MoveForward>();
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <mithrixSlam>d__28 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private Vector3 <orPos>5__1;

		private Vector3 <highPos>5__2;

		private float <t>5__3;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <mithrixSlam>d__28(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.isSlamming = true;
				<orPos>5__1 = ((Component)<>4__this).transform.position;
				<highPos>5__2 = <orPos>5__1 + Vector3.up * 1000f;
				<t>5__3 = 0f;
				goto IL_00dc;
			case 1:
				<>1__state = -1;
				goto IL_00dc;
			case 2:
				<>1__state = -1;
				<t>5__3 = 0f;
				break;
			case 3:
				{
					<>1__state = -1;
					break;
				}
				IL_00dc:
				if (<t>5__3 < 1f)
				{
					<t>5__3 += Time.deltaTime;
					((Component)<>4__this).transform.position = Vector3.Lerp(<orPos>5__1, <highPos>5__2, <t>5__3);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Component)<>4__this).transform.position = <highPos>5__2;
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 2;
				return true;
			}
			if (<t>5__3 < 1f)
			{
				<t>5__3 += Time.deltaTime;
				((Component)<>4__this).transform.position = Vector3.Lerp(<highPos>5__2, <orPos>5__1, <t>5__3);
				<>2__current = null;
				<>1__state = 3;
				return true;
			}
			((Component)<>4__this).transform.position = <orPos>5__1;
			Object.Instantiate<GameObject>(BananaDifficultyPlugin.shockwave, <orPos>5__1, Quaternion.identity);
			<>4__this.isSlamming = false;
			<>4__this.timeBeforePizza = 8f;
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <pizza>d__26 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <rep>5__1;

		private float <rotationDir>5__2;

		private GameObject <pivot>5__3;

		private GameObject[] <pillars>5__4;

		private float <t>5__5;

		private Vector3[] <strikePositions>5__6;

		private int <i>5__7;

		private float <angle>5__8;

		private Vector3 <offset>5__9;

		private Vector3 <pos>5__10;

		private int <i>5__11;

		private Vector3[] <>s__12;

		private int <>s__13;

		private Vector3 <pos>5__14;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <pizza>d__26(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<pivot>5__3 = null;
			<pillars>5__4 = null;
			<strikePositions>5__6 = null;
			<>s__12 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>4__this.isSlamming = true;
				<rep>5__1 = 0;
				goto IL_0385;
			case 1:
				<>1__state = -1;
				goto IL_01ef;
			case 2:
				{
					<>1__state = -1;
					goto IL_035f;
				}
				IL_0385:
				if (<rep>5__1 < 5)
				{
					<rotationDir>5__2 = ((Random.value > 0.5f) ? 1f : (-1f));
					<pivot>5__3 = new GameObject("PizzaPivot");
					<pivot>5__3.transform.position = ((Component)<>4__this._rodent).transform.position;
					<pillars>5__4 = (GameObject[])(object)new GameObject[9];
					<i>5__7 = 0;
					while (<i>5__7 < 9)
					{
						<angle>5__8 = (float)<i>5__7 * 40f;
						<offset>5__9 = Quaternion.Euler(0f, <angle>5__8, 0f) * Vector3.forward * 10f;
						<pos>5__10 = <>4__this.GetGroundPosition(((Component)<>4__this._rodent).transform.position + <offset>5__9);
						<pillars>5__4[<i>5__7] = Object.Instantiate<GameObject>(BananaDifficultyPlugin.pizzaAttack, <pos>5__10, Quaternion.Euler(0f, <angle>5__8, 0f), <pivot>5__3.transform);
						<i>5__7++;
					}
					<t>5__5 = 0f;
					goto IL_01ef;
				}
				<>4__this.isSlamming = false;
				return false;
				IL_01ef:
				if (<t>5__5 < 2f)
				{
					<t>5__5 += Time.deltaTime;
					<pivot>5__3.transform.Rotate(0f, <rotationDir>5__2 * 25f * Time.deltaTime, 0f);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<strikePositions>5__6 = (Vector3[])(object)new Vector3[9];
				<i>5__11 = 0;
				while (<i>5__11 < 9)
				{
					<strikePositions>5__6[<i>5__11] = <pillars>5__4[<i>5__11].GetComponentInChildren<Collider>().ClosestPoint(((Component)MonoSingleton<NewMovement>.Instance).transform.position);
					<i>5__11++;
				}
				Object.Destroy((Object)(object)<pivot>5__3);
				<>s__12 = <strikePositions>5__6;
				for (<>s__13 = 0; <>s__13 < <>s__12.Length; <>s__13++)
				{
					<pos>5__14 = <>s__12[<>s__13];
					Object.Instantiate<GameObject>(BananaDifficultyPlugin.lightningExplosion, <pos>5__14, Quaternion.identity);
					if (Vector3.Distance(((Component)MonoSingleton<NewMovement>.Instance).transform.position, <pos>5__14) <= 2.5f)
					{
						MonoSingleton<NewMovement>.Instance.GetHurt(50, false, 1f, false, false, 0.35f, false);
					}
				}
				<>s__12 = null;
				if (<rep>5__1 < 4)
				{
					<>2__current = (object)new WaitForSeconds(0.75f);
					<>1__state = 2;
					return true;
				}
				goto IL_035f;
				IL_035f:
				<pivot>5__3 = null;
				<pillars>5__4 = null;
				<strikePositions>5__6 = null;
				<rep>5__1++;
				goto IL_0385;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <rocketSummon>d__36 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <i>5__1;

		private Vector3 <spawn>5__2;

		private GameObject <rocket>5__3;

		private Grenade <greg>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <rocketSummon>d__36(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<rocket>5__3 = null;
			<greg>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				<rocket>5__3 = null;
				<greg>5__4 = null;
				<i>5__1++;
				break;
			}
			if (<i>5__1 < 3)
			{
				<spawn>5__2 = ((Component)<>4__this._rodent).transform.position + new Vector3((float)Random.Range(-6, 6), 10f, (float)Random.Range(-6, 6));
				<spawn>5__2 = <>4__this.GetGroundPosition(<spawn>5__2) + Vector3.up * 1.5f;
				<rocket>5__3 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.RocketEnemy, <spawn>5__2, Quaternion.identity);
				if (<rocket>5__3.TryGetComponent<Grenade>(ref <greg>5__4))
				{
					<greg>5__4.enemy = true;
					<greg>5__4.ignoreEnemyType.Add(<>4__this._rodent.eid.enemyType);
				}
				Transform transform = <rocket>5__3.transform;
				Vector3 val = <>4__this._rodent.eid.target.PredictTargetPosition(0.5f, false, false) - ((Component)<>4__this._rodent).transform.position;
				transform.forward = ((Vector3)(ref val)).normalized;
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <shockwaveRing>d__30 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <i>5__1;

		private float <angle>5__2;

		private Quaternion <rot>5__3;

		private GameObject <wave>5__4;

		private HurtZone[] <>s__5;

		private int <>s__6;

		private HurtZone <hz>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <shockwaveRing>d__30(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<wave>5__4 = null;
			<>s__5 = null;
			<hz>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Object.Instantiate<GameObject>(BananaDifficultyPlugin.bigExplosion, ((Component)<>4__this._rodent).transform.position, Quaternion.identity);
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				<wave>5__4 = null;
				<i>5__1++;
				break;
			}
			if (<i>5__1 < 8)
			{
				<angle>5__2 = (float)<i>5__1 * 45f;
				<rot>5__3 = Quaternion.Euler(0f, <angle>5__2, 0f);
				<wave>5__4 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.shockwave, ((Component)<>4__this._rodent).transform.position, <rot>5__3);
				<>s__5 = <wave>5__4.GetComponentsInChildren<HurtZone>(true);
				for (<>s__6 = 0; <>s__6 < <>s__5.Length; <>s__6++)
				{
					<hz>5__7 = <>s__5[<>s__6];
					<hz>5__7.ignoredEnemyTypes.Add(<>4__this._rodent.eid.enemyType);
					<hz>5__7 = null;
				}
				<>s__5 = null;
				<>2__current = (object)new WaitForSeconds(0.05f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <spawnFalls>d__38 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private float <distance>5__1;

		private int <num>5__2;

		private int <amount>5__3;

		private int <i>5__4;

		private Vector3 <vector>5__5;

		private GameObject <warning>5__6;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <spawnFalls>d__38(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<warning>5__6 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: 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_00d7: 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)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: 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_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<distance>5__1 = 100f;
				<amount>5__3 = Random.Range(3, 8);
				<i>5__4 = 0;
				break;
			case 1:
				<>1__state = -1;
				<num>5__2 = <i>5__4;
				<warning>5__6 = null;
				<i>5__4 = <num>5__2 + 1;
				break;
			}
			if (<i>5__4 < <amount>5__3)
			{
				<vector>5__5 = new Vector3(((Component)<>4__this._rodent).transform.position.x + Random.Range(<distance>5__1, 0f - <distance>5__1), ((Component)<>4__this._rodent).transform.position.y, ((Component)<>4__this._rodent).transform.position.z + Random.Range(<distance>5__1, 0f - <distance>5__1));
				if (Vector3.Distance(((Component)<>4__this._rodent).transform.position, <vector>5__5) > <distance>5__1)
				{
					Vector3 position = ((Component)<>4__this._rodent).transform.position;
					Vector3 val = <vector>5__5 - ((Component)<>4__this._rodent).transform.position;
					<vector>5__5 = position + ((Vector3)(ref val)).normalized * <distance>5__1;
				}
				<vector>5__5 = <>4__this.GetGroundPosition(<vector>5__5);
				<warning>5__6 = GameObject.CreatePrimitive((PrimitiveType)0);
				Object.Destroy((Object)(object)<warning>5__6.GetComponent<Collider>());
				<warning>5__6.GetComponent<Renderer>().material = BananaDifficultyPlugin.fallAttack.GetComponent<Renderer>().material;
				<warning>5__6.transform.position = <vector>5__5;
				((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.growSize(<warning>5__6));
				<>2__current = (object)new WaitForSecondsRealtime(0.25f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <spearPincer>d__32 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private Vector3 <center>5__1;

		private Vector3[] <directions>5__2;

		private Vector3[] <>s__3;

		private int <>s__4;

		private Vector3 <dir>5__5;

		private Vector3 <spawnPos>5__6;

		private Vector3 <aimDir>5__7;

		private GameObject <spear>5__8;

		private Projectile <proj>5__9;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <spearPincer>d__32(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<directions>5__2 = null;
			<>s__3 = null;
			<spear>5__8 = null;
			<proj>5__9 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				Object.Instantiate<GameObject>(BananaDifficultyPlugin.v2FlashUnpariable, <>4__this._rodent.eid.target.position, Quaternion.identity);
				<>2__current = (object)new WaitForSeconds(0.5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<center>5__1 = <>4__this._rodent.eid.target.position;
				<directions>5__2 = (Vector3[])(object)new Vector3[4]
				{
					Vector3.forward,
					Vector3.back,
					Vector3.left,
					Vector3.right
				};
				<>s__3 = <directions>5__2;
				for (<>s__4 = 0; <>s__4 < <>s__3.Length; <>s__4++)
				{
					<dir>5__5 = <>s__3[<>s__4];
					<spawnPos>5__6 = <center>5__1 + <dir>5__5 * 14f + Vector3.up * 1.2f;
					Vector3 val = <center>5__1 - <spawnPos>5__6;
					<aimDir>5__7 = ((Vector3)(ref val)).normalized;
					<spear>5__8 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.gabrielThrownSpear, <spawnPos>5__6, Quaternion.LookRotation(<aimDir>5__7));
					if (<spear>5__8.TryGetComponent<Projectile>(ref <proj>5__9))
					{
						<proj>5__9.target = <>4__this._rodent.eid.target;
						<proj>5__9.safeEnemyType = <>4__this._rodent.eid.enemyType;
						Projectile obj = <proj>5__9;
						obj.damage *= <>4__this._rodent.eid.totalDamageModifier;
						Projectile obj2 = <proj>5__9;
						obj2.speed *= <>4__this._rodent.eid.totalSpeedModifier;
					}
					<spear>5__8 = null;
					<proj>5__9 = null;
				}
				<>s__3 = null;
				return false;
			}
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <spinnyForwardArrow>d__35 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private GameObject <newSpin>5__1;

		private float <t>5__2;

		private int <i>5__3;

		private GameObject <arrow>5__4;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <spinnyForwardArrow>d__35(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<newSpin>5__1 = null;
			<arrow>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_004e: 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)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<newSpin>5__1 = new GameObject("SPIUIIINNNNN");
				<newSpin>5__1.transform.position = ((Component)<>4__this._rodent).transform.position;
				<i>5__3 = 0;
				while (<i>5__3 < 4)
				{
					<arrow>5__4 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.forwardArrow, <newSpin>5__1.transform);
					<arrow>5__4.transform.Rotate(0f, (float)(90 * <i>5__3), 0f);
					<arrow>5__4.GetComponentInChildren<HurtZone>(true).ignoredEnemyTypes.Add(<>4__this._rodent.eid.enemyType);
					<arrow>5__4 = null;
					<i>5__3++;
				}
				<t>5__2 = 0f;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			if (<t>5__2 <= 15f)
			{
				<t>5__2 += Time.deltaTime;
				<newSpin>5__1.transform.Rotate(0f, 50f * Time.deltaTime, 0f);
				<>2__current = null;
				<>1__state = 1;
				return true;
			}
			Object.Destroy((Object)(object)<newSpin>5__1);
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <swordRain>d__37 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <i>5__1;

		private Vector3 <pos>5__2;

		private GameObject <currentSwords>5__3;

		private SummonedSwords <summonedSwords>5__4;

		private Projectile[] <>s__5;

		private int <>s__6;

		private Projectile <projectile>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <swordRain>d__37(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<currentSwords>5__3 = null;
			<summonedSwords>5__4 = null;
			<>s__5 = null;
			<projectile>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<i>5__1 = 0;
				break;
			case 1:
				<>1__state = -1;
				<currentSwords>5__3 = null;
				<summonedSwords>5__4 = null;
				<i>5__1++;
				break;
			}
			if (<i>5__1 < 4)
			{
				<pos>5__2 = <>4__this._rodent.eid.target.position + new Vector3((float)Random.Range(-8, 8), 12f, (float)Random.Range(-8, 8));
				<currentSwords>5__3 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.summonedSwords, <pos>5__2, Quaternion.identity);
				if (<currentSwords>5__3.TryGetComponent<SummonedSwords>(ref <summonedSwords>5__4))
				{
					<summonedSwords>5__4.target = new EnemyTarget(((Component)<>4__this._rodent).transform);
					SummonedSwords obj = <summonedSwords>5__4;
					obj.speed *= <>4__this._rodent.eid.totalSpeedModifier;
					<summonedSwords>5__4.targetEnemy = <>4__this._rodent.eid.target;
				}
				<>s__5 = <currentSwords>5__3.GetComponentsInChildren<Projectile>();
				for (<>s__6 = 0; <>s__6 < <>s__5.Length; <>s__6++)
				{
					<projectile>5__7 = <>s__5[<>s__6];
					<projectile>5__7.target = <>4__this._rodent.eid.target;
					<projectile>5__7.safeEnemyType = <>4__this._rodent.eid.enemyType;
					if (<>4__this._rodent.eid.totalDamageModifier != 1f)
					{
						Projectile obj2 = <projectile>5__7;
						obj2.damage *= <>4__this._rodent.eid.totalDamageModifier;
					}
					<projectile>5__7 = null;
				}
				<>s__5 = null;
				<>2__current = (object)new WaitForSeconds(0.08f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	[CompilerGenerated]
	private sealed class <thrownSwordBarrage>d__31 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public RodentBoss <>4__this;

		private int <count>5__1;

		private int <i>5__2;

		private Vector3 <spawnOffset>5__3;

		private Vector3 <spawnPos>5__4;

		private Vector3 <dir>5__5;

		private GameObject <sword>5__6;

		private ThrownSword <tSword>5__7;

		object IEnumerator<object>.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return <>2__current;
			}
		}

		[DebuggerHidden]
		public <thrownSwordBarrage>d__31(int <>1__state)
		{
			this.<>1__state = <>1__state;
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<sword>5__6 = null;
			<tSword>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<count>5__1 = Random.Range(5, 9);
				<i>5__2 = 0;
				break;
			case 1:
				<>1__state = -1;
				<sword>5__6 = null;
				<i>5__2++;
				break;
			}
			if (<i>5__2 < <count>5__1)
			{
				<spawnOffset>5__3 = Quaternion.Euler(0f, (float)<i>5__2 * (360f / (float)<count>5__1), 0f) * Vector3.forward * 8f;
				<spawnPos>5__4 = ((Component)<>4__this._rodent).transform.position + <spawnOffset>5__3 + Vector3.up * 1.5f;
				Vector3 val = <>4__this._rodent.eid.target.PredictTargetPosition(0.3f, false, false) - <spawnPos>5__4;
				<dir>5__5 = ((Vector3)(ref val)).normalized;
				<sword>5__6 = Object.Instantiate<GameObject>(BananaDifficultyPlugin.thrownSwordH, <spawnPos>5__4, Quaternion.LookRotation(<dir>5__5));
				if (Object.op_Implicit((Object)(object)<sword>5__6.GetComponentInChildren<ThrownSword>()))
				{
					<tSword>5__7 = <sword>5__6.GetComponentInChildren<ThrownSword>();
					<tSword>5__7.targetPos = <>4__this._rodent.eid.target.PredictTargetPosition(0.6f, false, false);
					<tSword>5__7.thrownBy = <>4__this._rodent.eid;
					<tSword>5__7.difficulty = <>4__this._rodent.eid.difficulty;
					<tSword>5__7 = null;
				}
				<>2__current = (object)new WaitForSeconds(0.12f);
				<>1__state = 1;
				return true;
			}
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
			throw new NotSupportedException();
		}
	}

	public Transform phase1Escape;

	public Transform phase1ArenaStart;

	public Transform phase2Escape;

	public Transform phase2ArenaStart;

	private CancerousRodent _rodent;

	public bool isTransitioning = false;

	public bool canExecute = true;

	public bool isSlamming = false;

	private float attackCooldown = 0f;

	private int previousPhase = 1;

	private static readonly Dictionary<int, float> AttackCooldownDurations = new Dictionary<int, float>
	{
		{ 0, 3f },
		{ 1, 5f },
		{ 2, 3f },
		{ 3, 4f },
		{ 4, 10f },
		{ 5, 5f },
		{ 6, 4.5f },
		{ 7, 6f },
		{ 8, 7f },
		{ 9, 5.5f },
		{ 10, 14f },
		{ 11, 6f },
		{ 12, 9f },
		{ 13, 7f },
		{ 14, 5f },
		{ 15, 2.5f }
	};

	private Dictionary<int, float> _attackCooldowns = new Dictionary<int, float>();

	private float timeBeforePizza = 0f;

	private float tiem;

	public bool shouldBeDoingStuff => !isTransitioning && canExecute && !isSlamming;

	private void Awake()
	{
		_rodent = ((Component)this).GetComponent<CancerousRodent>();
		foreach (int key in AttackCooldownDurations.Keys)
		{
			_attackCooldowns[key] = 0f;
		}
	}

	public void BossUpdate()
	{
		if (_rodent.harmless && shouldBeDoingStuff)
		{
			HandleAttacks();
		}
	}

	private void HandleAttacks()
	{
		//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Expected O, but got Unknown
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		int num = ((_rodent.enemy.health >= 466f) ? 1 : ((!(_rodent.enemy.health <= 234f)) ? 2 : 3));
		if (previousPhase != num)
		{
			DoPhaseTransition(num);
		}
		if (previousPhase != 3 && num == 3)
		{
			GameObject enrage = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.enrageEffect, ((Component)this).transform);
			_rodent.eid.onDeath.AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)enrage);
			});
			GameObject val = Object.Instantiate<GameObject>(MonoSingleton<DefaultReferenceManager>.Instance.GetEnemyPrefab((EnemyType)21), ((Component)this).transform);
			val.GetComponent<Idol>().target = _rodent.eid;
			val.transform.localPosition = Vector3.up * 5f;
			((Object)val).name = ((Object)val).name + "DontRadiant";
		}
		previousPhase = num;
		List<int> list = new List<int>(_attackCooldowns.Keys);
		foreach (int item in list)
		{
			if (_attackCooldowns[item] > 0f)
			{
				_attackCooldowns[item] -= Time.deltaTime;
			}
		}
		attackCooldown -= Time.deltaTime;
		if (attackCooldown <= 0f)
		{
			ExecuteAttack(num);
			attackCooldown = Random.Range(0f, (num == 3) ? 2f : 4.5f);
		}
		if (timeBeforePizza > 0f)
		{
			timeBeforePizza -= Time.deltaTime;
			if (timeBeforePizza < 0f)
			{
				((MonoBehaviour)this).StartCoroutine(pizza());
			}
		}
	}

	private bool IsAttackReady(int attack)
	{
		return !_attackCooldowns.ContainsKey(attack) || _attackCooldowns[attack] <= 0f;
	}

	private void SetAttackCooldown(int attack)
	{
		if (AttackCooldownDurations.TryGetValue(attack, out var value))
		{
			_attackCooldowns[attack] = value;
		}
	}

	private void ExecuteAttack(int phase)
	{
		int num = phase switch
		{
			2 => 10, 
			1 => 5, 
			_ => 16, 
		};
		List<int> list = new List<int>();
		for (int i = 0; i < num; i++)
		{
			if (IsAttackReady(i))
			{
				list.Add(i);
			}
		}
		if (list.Count == 0)
		{
			return;
		}
		int num2 = list[Random.Range(0, list.Count)];
		SetAttackCooldown(num2);
		switch (num2)
		{
		case 0:
			((MonoBehaviour)this).StartCoroutine(dashAttack());
			break;
		case 1:
			((MonoBehaviour)this).StartCoroutine(goMyRats());
			break;
		case 2:
			((MonoBehaviour)this).StartCoroutine(rocketSummon());
			break;
		case 3:
			((MonoBehaviour)this).StartCoroutine(spinnyForwardArrow());
			break;
		case 4:
			((MonoBehaviour)this).StartCoroutine(lightningBarrage());
			break;
		case 5:
			((MonoBehaviour)this).StartCoroutine(mithrixSlam());
			break;
		case 6:
			((MonoBehaviour)this).StartCoroutine(shockwaveRing());
			break;
		case 7:
			((MonoBehaviour)this).StartCoroutine(homingBarrage());
			break;
		case 8:
			((MonoBehaviour)this).StartCoroutine(SpawnBeamCoroutine());
			break;
		case 9:
			((MonoBehaviour)this).StartCoroutine(spawnFalls());
			break;
		case 10:
			((MonoBehaviour)this).StartCoroutine(thrownSwordBarrage());
			break;
		case 11:
			((MonoBehaviour)this).StartCoroutine(blackHoleTrap());
			break;
		case 12:
			((MonoBehaviour)this).StartCoroutine(swordRain());
			break;
		case 13:
		{
			for (int j = 0; j < 3; j++)
			{
				((MonoBehaviour)this).StartCoroutine(beamSpin());
			}
			break;
		}
		case 14:
			((MonoBehaviour)this).StartCoroutine(spearPincer());
			break;
		case 15:
			((MonoBehaviour)this).StartCoroutine(mirrorReaperSlam());
			break;
		}
	}

	public void DoPhaseTransition(int newPhase)
	{
		Transform val = ((newPhase == 2) ? phase1Escape : phase2Escape);
		Transform arenaPoint = ((newPhase == 2) ? phase1ArenaStart : phase2ArenaStart);
		if ((Object)(object)val != (Object)null)
		{
			((MonoBehaviour)this).StartCoroutine(PhaseTransitionRoutine(val, arenaPoint));
		}
	}

	public void PlayerReachedArena()
	{
		BananaDifficultyPlugin.Log.LogInfo((object)"Alright goody :D");
		canExecute = true;
	}

	private void Update()
	{
		if (!canExecute)
		{
			tiem += Time.deltaTime;
			if (tiem > 1f)
			{
				MonoSingleton<NewMovement>.Instance.GetHurt(5, false, 1f, false, false, 0.35f, false);
				tiem = 0f;
			}
		}
	}

	[IteratorStateMachine(typeof(<PhaseTransitionRoutine>d__25))]
	private IEnumerator PhaseTransitionRoutine(Transform escapePoint, Transform arenaPoint)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <PhaseTransitionRoutine>d__25(0)
		{
			<>4__this = this,
			escapePoint = escapePoint,
			arenaPoint = arenaPoint
		};
	}

	[IteratorStateMachine(typeof(<pizza>d__26))]
	private IEnumerator pizza()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <pizza>d__26(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<goMyRats>d__27))]
	private IEnumerator goMyRats()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <goMyRats>d__27(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<mithrixSlam>d__28))]
	private IEnumerator mithrixSlam()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <mithrixSlam>d__28(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<lightningBarrage>d__29))]
	private IEnumerator lightningBarrage()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <lightningBarrage>d__29(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<shockwaveRing>d__30))]
	private IEnumerator shockwaveRing()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <shockwaveRing>d__30(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<thrownSwordBarrage>d__31))]
	private IEnumerator thrownSwordBarrage()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <thrownSwordBarrage>d__31(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<spearPincer>d__32))]
	private IEnumerator spearPincer()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <spearPincer>d__32(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<mirrorReaperSlam>d__33))]
	private IEnumerator mirrorReaperSlam()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <mirrorReaperSlam>d__33(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<beamSpin>d__34))]
	private IEnumerator beamSpin()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <beamSpin>d__34(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<spinnyForwardArrow>d__35))]
	private IEnumerator spinnyForwardArrow()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <spinnyForwardArrow>d__35(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<rocketSummon>d__36))]
	private IEnumerator rocketSummon()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <rocketSummon>d__36(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<swordRain>d__37))]
	private IEnumerator swordRain()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <swordRain>d__37(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<spawnFalls>d__38))]
	private IEnumerator spawnFalls()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <spawnFalls>d__38(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<growSize>d__39))]
	private IEnumerator growSize(GameObject increase)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <growSize>d__39(0)
		{
			<>4__this = this,
			increase = increase
		};
	}

	[IteratorStateMachine(typeof(<blackHoleTrap>d__40))]
	private IEnumerator blackHoleTrap()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <blackHoleTrap>d__40(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<homingBarrage>d__41))]
	private IEnumerator homingBarrage()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <homingBarrage>d__41(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<SpawnBeamCoroutine>d__42))]
	private IEnumerator SpawnBeamCoroutine()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SpawnBeamCoroutine>d__42(0)
		{
			<>4__this = this
		};
	}

	[IteratorStateMachine(typeof(<dashAttack>d__43))]
	private IEnumerator dashAttack()
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <dashAttack>d__43(0)
		{
			<>4__this = this
		};
	}

	private Vector3 GetGroundPosition(Vector3 pos)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		RaycastHit val = default(RaycastHit);
		if (Physics.Raycast(pos + Vector3.up * 50f, Vector3.down, ref val, 200f))
		{
			return ((RaycastHit)(ref val)).point + Vector3.up * 0.25f;
		}
		return pos;
	}
}
public class PlayerPhaseReacher : MonoBehaviour
{
	private void OnTriggerEnter(Collider other)
	{
		if (Object.op_Implicit((Object)(object)Object.FindAnyObjectByType<RodentBoss>()))
		{
			Object.FindAnyObjectByType<RodentBoss>().PlayerReachedArena();
		}
	}
}
namespace NewBananaWeapons
{
	public static class ShaderManager
	{
		public class ShaderInfo
		{
			public string Name { get; set; }
		}

		[CompilerGenerated]
		private sealed class <ApplyShaderToGameObject>d__4 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject gameObject;

			private Renderer[] <>s__1;

			private int <>s__2;

			private Renderer <renderer>5__3;

			private Material[] <shared>5__4;

			private Material[] <newMats>5__5;

			private bool <changed>5__6;

			private int <i>5__7;

			private Material <mat>5__8;

			private Shader <replacement>5__9;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ApplyShaderToGameObject>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = null;
				<renderer>5__3 = null;
				<shared>5__4 = null;
				<newMats>5__5 = null;
				<mat>5__8 = null;
				<replacement>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => LoadedShaders));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((Object)(object)gameObject == (Object)null)
					{
						return false;
					}
					<>s__1 = gameObject.GetComponentsInChildren<Renderer>(true);
					for (<>s__2 = 0; <>s__2 < <>s__1.Length; <>s__2++)
					{
						<renderer>5__3 = <>s__1[<>s__2];
						if (!((Object)(object)<renderer>5__3 == (Object)null))
						{
							<shared>5__4 = <renderer>5__3.sharedMaterials;
							<newMats>5__5 = null;
							<changed>5__6 = false;
							<i>5__7 = 0;
							while (<i>5__7 < <shared>5__4.Length)
							{
								<mat>5__8 = <shared>5__4[<i>5__7];
								if (!((Object)(object)<mat>5__8 == (Object)null) && !((Object)(object)<mat>5__8.shader == (Object)null) && !modifiedMaterials.Contains(<mat>5__8) && !(((Object)<mat>5__8.shader).name == "ULTRAKILL/PostProcessV2"))
								{
									if (shaderDictionary.TryGetValue(((Object)<mat>5__8.shader).name, out <replacement>5__9))
									{
										if (!<changed>5__6)
										{
											<newMats>5__5 = (Material[])<shared>5__4.Clone();
											<changed>5__6 = true;
										}
										<newMats>5__5[<i>5__7] = new Material(<mat>5__8);
										<newMats>5__5[<i>5__7].shader = <replacement>5__9;
										modifiedMaterials.Add(<newMats>5__5[<i>5__7]);
									}
									<mat>5__8 = null;
									<replacement>5__9 = null;
								}
								<i>5__7++;
							}
							if (<changed>5__6)
							{
								<renderer>5__3.materials = <newMats>5__5;
							}
							<shared>5__4 = null;
							<newMats>5__5 = null;
							<renderer>5__3 = null;
						}
					}
					<>s__1 = null;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <ApplyShadersAsync>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public GameObject[] allGameObjects;

			private bool <flag>5__1;

			private GameObject[] <array3>5__2;

			private GameObject[] <>s__3;

			private int <>s__4;

			private GameObject <gameObject>5__5;

			private bool <flag2>5__6;

			private Renderer[] <array4>5__7;

			private Renderer[] <>s__8;

			private int <>s__9;

			private Renderer <renderer>5__10;

			private bool <flag3>5__11;

			private Material[] <array2>5__12;

			private int <num>5__13;

			private int <i>5__14;

			private Material <material>5__15;

			private Shader <shader>5__16;

			private bool <flag4>5__17;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ApplyShadersAsync>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<array3>5__2 = null;
				<>s__3 = null;
				<gameObject>5__5 = null;
				<array4>5__7 = null;
				<>s__8 = null;
				<renderer>5__10 = null;
				<array2>5__12 = null;
				<material>5__15 = null;
				<shader>5__16 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => LoadedShaders));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<flag>5__1 = allGameObjects == null;
					if (<flag>5__1)
					{
						return false;
					}
					<>s__3 = allGameObjects;
					<>s__4 = 0;
					goto IL_0313;
				case 2:
					{
						<>1__state = -1;
						<array4>5__7 = null;
						goto IL_02fd;
					}
					IL_02fd:
					<gameObject>5__5 = null;
					<>s__4++;
					goto IL_0313;
					IL_0313:
					if (<>s__4 < <>s__3.Length)
					{
						<gameObject>5__5 = <>s__3[<>s__4];
						<flag2>5__6 = !((Object)(object)<gameObject>5__5 == (Object)null);
						if (<flag2>5__6)
						{
							<>s__8 = <gameObject>5__5.GetComponentsInChildren<Renderer>(true);
							for (<>s__9 = 0; <>s__9 < <>s__8.Length; <>s__9++)
							{
								<renderer>5__10 = <>s__8[<>s__9];
								<flag3>5__11 = !((Object)(object)<renderer>5__10 == (Object)null);
								if (<flag3>5__11)
								{
									<array2>5__12 = (Material[])(object)new Material[<renderer>5__10.sharedMaterials.Length];
									for (<i>5__14 = 0; <i>5__14 < <renderer>5__10.sharedMaterials.Length; <i>5__14 = <num>5__13 + 1)
									{
										<material>5__15 = <renderer>5__10.sharedMaterials[<i>5__14];
										<array2>5__12[<i>5__14] = <material>5__15;
										<shader>5__16 = null;
										<flag4>5__17 = !((Object)(object)<material>5__15 == (Object)null) && !((Object)(object)<material>5__15.shader == (Object)null) && !modifiedMaterials.Contains(<material>5__15) && !(((Object)<material>5__15.shader).name == "ULTRAKILL/PostProcessV2") && shaderDictionary.TryGetValue(((Object)<material>5__15.shader).name, out <shader>5__16);
										if (<flag4>5__17)
										{
											<array2>5__12[<i>5__14].shader = <shader>5__16;
											modifiedMaterials.Add(<material>5__15);
										}
										<material>5__15 = null;
										<shader>5__16 = null;
										<num>5__13 = <i>5__14;
										<material>5__15 = null;
										<shader>5__16 = null;
									}
									<renderer>5__10.materials = <array2>5__12;
									<array2>5__12 = null;
									<array2>5__12 = null;
								}
								<renderer>5__10 = null;
							}
							<>s__8 = null;
							<array4>5__7 = null;
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						goto IL_02fd;
					}
					<>s__3 = null;
					<array3>5__2 = null;
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <LoadShadersAsync>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private AsyncOperationHandle<IResourceLocator> <handle>5__1;

			private bool <flag>5__2;

			private IResourceLocator <result>5__3;

			private IEnumerator<object> <enumerator>5__4;

			private IEnumerator<object> <>s__5;

			private object <obj>5__6;

			private string <text>5__7;

			private bool <flag2>5__8;

			private AsyncOperationHandle<Shader> <shaderHandle>5__9;

			private bool <flag3>5__10;

			private Shader <result2>5__11;

			private bool <flag4>5__12;

			private string <str>5__13;

			private Exception <operationException>5__14;

			private string <str2>5__15;

			private Exception <operationException2>5__16;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadShadersAsync>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num == -3 || num == 2)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<handle>5__1 = default(AsyncOperationHandle<IResourceLocator>);
				<result>5__3 = null;
				<enumerator>5__4 = null;
				<>s__5 = null;
				<obj>5__6 = null;
				<text>5__7 = null;
				<shaderHandle>5__9 = default(AsyncOperationHandle<Shader>);
				<result2>5__11 = null;
				<str>5__13 = null;
				<operationException>5__14 = null;
				<str2>5__15 = null;
				<operationException2>5__16 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Invalid comparison between Unknown and I4
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Invalid comparison between Unknown and I4
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0278: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<handle>5__1 = Addressables.InitializeAsync();
						goto IL_005e;
					case 1:
						<>1__state = -1;
						goto IL_005e;
					case 2:
						{
							<>1__state = -3;
							goto IL_0147;
						}
						IL_005e:
						if (!<handle>5__1.IsDone)
						{
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
						<flag>5__2 = (int)<handle>5__1.Status == 1;
						if (<flag>5__2)
						{
							<result>5__3 = <handle>5__1.Result;
							<>s__5 = ((ResourceLocationMap)<result>5__3).Keys.GetEnumerator();
							<>1__state = -3;
							goto IL_02ad;
						}
						<str2>5__15 = "Addressables initialization failed: ";
						<operationException2>5__16 = <handle>5__1.OperationException;
						Debug.LogError((object)(<str2>5__15 + ((<operationException2>5__16 != null) ? <operationException2>5__16.ToString() : null)));
						<str2>5__15 = null;
						<operationException2>5__16 = null;
						<str2>5__15 = null;
						<operationException2>5__16 = null;
						break;
						IL_0297:
						<text>5__7 = null;
						<text>5__7 = null;
						<obj>5__6 = null;
						goto IL_02ad;
						IL_0147:
						if (!<shaderHandle>5__9.IsDone)
						{
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						<flag3>5__10 = (int)<shaderHandle>5__9.Status == 1;
						if (<flag3>5__10)
						{
							<result2>5__11 = <shaderHandle>5__9.Result;
							<flag4>5__12 = (Object)(object)<result2>5__11 != (Object)null && ((Object)<result2>5__11).name != "ULTRAKILL/PostProcessV2" && !shaderDictionary.ContainsKey(((Object)<result2>5__11).name);
							if (<flag4>5__12)
							{
								shaderDictionary[((Object)<result2>5__11).name] = <result2>5__11;
							}
							<result2>5__11 = null;
							<result2>5__11 = null;
						}
						else
						{
							<str>5__13 = "Failed to load shader: ";
							<operationException>5__14 = <shaderHandle>5__9.OperationException;
							Debug.LogError((object)(<str>5__13 + ((<operationException>5__14 != null) ? <operationException>5__14.ToString() : null)));
							<str>5__13 = null;
							<operationException>5__14 = null;
							<str>5__13 = null;
							<operationException>5__14 = null;
						}
						<shaderHandle>5__9 = default(AsyncOperationHandle<Shader>);
						<shaderHandle>5__9 = default(AsyncOperationHandle<Shader>);
						<shaderHandle>5__9 = default(AsyncOperationHandle<Shader>);
						goto IL_0297;
						IL_02ad:
						if (<>s__5.MoveNext())
						{
							<obj>5__6 = <>s__5.Current;
							<text>5__7 = (string)<obj>5__6;
							<flag2>5__8 = <text>5__7.EndsWith(".shader");
							if (<flag2>5__8)
							{
								<shaderHandle>5__9 = Addressables.LoadAssetAsync<Shader>((object)<text>5__7);
								goto IL_0147;
							}
							goto IL_0297;
						}
						<>m__Finally1();
						<>s__5 = null;
						LoadedShaders = true;
						<enumerator>5__4 = null;
						<result>5__3 = null;
						<result>5__3 = null;
						<enumerator>5__4 = null;
						break;
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>s__5 != null)
				{
					<>s__5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static bool LoadedShaders = false;

		public static Dictionary<string, Shader> shaderDictionary = new Dictionary<string, Shader>();

		private static HashSet<Material> modifiedMaterials = new HashSet<Material>();

		[IteratorStateMachine(typeof(<LoadShadersAsync>d__1))]
		public static IEnumerator LoadShadersAsync()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadShadersAsync>d__1(0);
		}

		public static string ModPath()
		{
			return Assembly.GetExecutingAssembly().Location.Substring(0, Assembly.GetExecutingAssembly().Location.LastIndexOf(Path.DirectorySeparatorChar));
		}

		[IteratorStateMachine(typeof(<ApplyShadersAsync>d__3))]
		public static IEnumerator ApplyShadersAsync(GameObject[] allGameObjects)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyShadersAsync>d__3(0)
			{
				allGameObjects = allGameObjects
			};
		}

		[IteratorStateMachine(typeof(<ApplyShaderToGameObject>d__4))]
		public static IEnumerator ApplyShaderToGameObject(GameObject gameObject)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyShaderToGameObject>d__4(