using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("CrawlBossKit")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CrawlBossKit")]
[assembly: AssemblyTitle("CrawlBossKit")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BossKit
{
	public static class KitArt
	{
		public sealed class Sheet
		{
			private readonly string m_name;

			private readonly List<Texture2D> m_frames = new List<Texture2D>();

			private readonly Dictionary<string, int[]> m_strips = new Dictionary<string, int[]>();

			public exAtlas Atlas { get; private set; }

			public string Name => m_name;

			public Sheet(string name)
			{
				m_name = name;
			}

			private void CheckOpen(string key)
			{
				if ((Object)(object)Atlas != (Object)null)
				{
					throw new InvalidOperationException("sheet " + m_name + " is already built; cannot add " + key);
				}
				if (m_strips.ContainsKey(key))
				{
					throw new ArgumentException("sheet " + m_name + " already has a strip " + key);
				}
			}

			public void AddStrip(string key, Texture2D strip, int frames)
			{
				CheckOpen(key);
				List<Texture2D> collection = Slice(strip, frames);
				int count = m_frames.Count;
				m_frames.AddRange(collection);
				m_strips[key] = Enumerable.Range(count, frames).ToArray();
			}

			public void AddStrip(string key, BossAssets assets, string logicalName, int frames)
			{
				AddStrip(key, assets.Png(logicalName), frames);
			}

			public void AddGrid(string key, BossAssets assets, string logicalName, int cols, int rows)
			{
				//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)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Expected O, but got Unknown
				CheckOpen(key);
				Texture2D val = assets.Png(logicalName);
				if (cols < 1 || rows < 1 || ((Texture)val).width % cols != 0 || ((Texture)val).height % rows != 0)
				{
					throw new FormatException(logicalName + " (" + ((Texture)val).width + "x" + ((Texture)val).height + ") does not divide into " + cols + "x" + rows + " tiles");
				}
				int num = ((Texture)val).width / cols;
				int num2 = ((Texture)val).height / rows;
				int count = m_frames.Count;
				for (int i = 0; i < rows; i++)
				{
					for (int j = 0; j < cols; j++)
					{
						Texture2D val2 = new Texture2D(num, num2, (TextureFormat)5, false)
						{
							filterMode = (FilterMode)0,
							wrapMode = (TextureWrapMode)1
						};
						val2.SetPixels(val.GetPixels(j * num, ((Texture)val).height - (i + 1) * num2, num, num2));
						val2.Apply();
						m_frames.Add(val2);
					}
				}
				m_strips[key] = Enumerable.Range(count, cols * rows).ToArray();
			}

			public int[] Frames(string key)
			{
				if (!m_strips.TryGetValue(key, out var value))
				{
					throw new KeyNotFoundException("no strip " + key + " in sheet " + m_name);
				}
				return value;
			}

			public bool Has(string key)
			{
				return m_strips.ContainsKey(key);
			}

			public void Build(Material baseMaterial)
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Expected O, but got Unknown
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b6: 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_01c6: Expected O, but got Unknown
				//IL_0214: Unknown result type (might be due to invalid IL or missing references)
				//IL_0219: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0266: Unknown result type (might be due to invalid IL or missing references)
				//IL_0297: Unknown result type (might be due to invalid IL or missing references)
				//IL_029c: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b7: Expected O, but got Unknown
				if ((Object)(object)Atlas != (Object)null)
				{
					throw new InvalidOperationException("sheet " + m_name + " is already built");
				}
				if ((Object)(object)baseMaterial == (Object)null)
				{
					throw new ArgumentNullException("baseMaterial", "sheet " + m_name + " needs a base material");
				}
				if (m_frames.Count == 0)
				{
					throw new InvalidOperationException("sheet " + m_name + " has no frames");
				}
				Texture2D val = new Texture2D(1, 1, (TextureFormat)5, false);
				Rect[] array = val.PackTextures(m_frames.ToArray(), 2, 4096, false);
				if (array == null || array.Length != m_frames.Count)
				{
					throw new InvalidOperationException("PackTextures failed for " + m_name);
				}
				((Texture)val).filterMode = (FilterMode)0;
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Object)val).name = m_name + "_tex";
				((Object)val).hideFlags = (HideFlags)32;
				for (int i = 0; i < array.Length; i++)
				{
					float num = ((Rect)(ref array[i])).width * (float)((Texture)val).width;
					float num2 = ((Rect)(ref array[i])).height * (float)((Texture)val).height;
					if (Mathf.Abs(num - (float)((Texture)m_frames[i]).width) > 0.5f || Mathf.Abs(num2 - (float)((Texture)m_frames[i]).height) > 0.5f)
					{
						throw new InvalidOperationException(m_name + ": frame " + i + " was resized by the packer");
					}
				}
				Material material = new Material(baseMaterial)
				{
					name = m_name + "_mat",
					mainTexture = (Texture)(object)val,
					hideFlags = (HideFlags)32
				};
				exAtlas val2 = ScriptableObject.CreateInstance<exAtlas>();
				((Object)val2).name = m_name;
				((Object)val2).hideFlags = (HideFlags)32;
				val2.texture = val;
				val2.material = material;
				val2.elements = (Element[])(object)new Element[m_frames.Count];
				for (int j = 0; j < m_frames.Count; j++)
				{
					val2.elements[j] = new Element
					{
						name = m_name + "_" + j,
						originalWidth = ((Texture)m_frames[j]).width,
						originalHeight = ((Texture)m_frames[j]).height,
						trimRect = new Rect(0f, 0f, (float)((Texture)m_frames[j]).width, (float)((Texture)m_frames[j]).height),
						coords = array[j],
						rotated = false
					};
				}
				Atlas = val2;
			}

			public exSpriteAnimClip Clip(string clipName, string key, float fps, WrapMode wrap, IEnumerable<EventInfo> events = null, int[] order = null)
			{
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)Atlas == (Object)null)
				{
					throw new InvalidOperationException("sheet " + m_name + " must be built before cutting clip " + clipName);
				}
				if (fps <= 0f)
				{
					throw new ArgumentOutOfRangeException("fps", clipName + ": fps must be positive");
				}
				int[] frames = Frames(key);
				if (order != null)
				{
					for (int i = 0; i < order.Length; i++)
					{
						int num = order[i];
						if (num < 0 || num >= frames.Length)
						{
							throw new ArgumentOutOfRangeException("order", clipName + ": frame " + num + " is outside strip " + key + " (" + frames.Length + " frames)");
						}
					}
					frames = order.Select((int num3) => frames[num3]).ToArray();
				}
				exSpriteAnimClip val = ScriptableObject.CreateInstance<exSpriteAnimClip>();
				((Object)val).name = clipName;
				((Object)val).hideFlags = (HideFlags)32;
				val.wrapMode = wrap;
				val.stopAction = (StopAction)0;
				val.speed = 1f;
				val.sampleRate = 60f;
				float num2 = (val.length = (float)frames.Length / fps);
				val.frameInfos = ((IEnumerable<int>)frames).Select((Func<int, FrameInfo>)((int index) => new FrameInfo
				{
					atlas = Atlas,
					index = index,
					length = 1f / fps
				})).ToList();
				val.eventInfos = (from e in events ?? Enumerable.Empty<EventInfo>()
					where e != null
					orderby e.time
					select e).ToList();
				foreach (EventInfo eventInfo in val.eventInfos)
				{
					if (eventInfo.time < 0f || eventInfo.time > num2 + 0.0001f)
					{
						throw new ArgumentOutOfRangeException(clipName + ": event " + eventInfo.methodName + " at " + eventInfo.time + " is outside the clip (" + num2 + " s)");
					}
				}
				return val;
			}
		}

		private sealed class RefEq : IEqualityComparer<object>
		{
			public new bool Equals(object a, object b)
			{
				return a == b;
			}

			public int GetHashCode(object o)
			{
				return RuntimeHelpers.GetHashCode(o);
			}
		}

		public static readonly string[] TrapStates = new string[6] { "inactive", "activate", "active", "action", "deactivate", "greyedOut" };

		private static readonly float[] TrapStateFps = new float[6] { 4f, 8f, 6f, 10f, 8f, 6f };

		private static readonly FieldInfo s_finalHeight = typeof(DepthHandler).GetField("m_finalHeightOffset", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		public static List<Texture2D> Slice(Texture2D strip, int frames)
		{
			//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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			if (frames < 1 || ((Texture)strip).width % frames != 0)
			{
				throw new FormatException(((Object)strip).name + " is " + ((Texture)strip).width + " px wide, which does not divide into " + frames + " frames");
			}
			int num = ((Texture)strip).width / frames;
			List<Texture2D> list = new List<Texture2D>(frames);
			for (int i = 0; i < frames; i++)
			{
				Texture2D val = new Texture2D(num, ((Texture)strip).height, (TextureFormat)5, false)
				{
					filterMode = (FilterMode)0,
					wrapMode = (TextureWrapMode)1
				};
				val.SetPixels(strip.GetPixels(i * num, 0, num, ((Texture)strip).height));
				val.Apply();
				list.Add(val);
			}
			return list;
		}

		public static Material MaterialOf(string prefabName)
		{
			GameObject obj = Util.Prefab(prefabName);
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("prefab " + prefabName + " is not loaded");
			}
			exSprite component = obj.GetComponent<exSprite>();
			if ((Object)(object)component == (Object)null || (Object)(object)component.atlas == (Object)null || (Object)(object)component.atlas.material == (Object)null)
			{
				throw new InvalidOperationException(prefabName + " has no exSprite atlas material");
			}
			return component.atlas.material;
		}

		public static EventInfo Event(float time, string method)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new EventInfo
			{
				time = time,
				methodName = method,
				paramType = (ParamType)0,
				msgOptions = (SendMessageOptions)1
			};
		}

		public static EventInfo Event(float time, string method, int value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			EventInfo obj = Event(time, method);
			obj.paramType = (ParamType)3;
			obj.intParam = value;
			return obj;
		}

		public static EventInfo Event(float time, string method, float value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			EventInfo obj = Event(time, method);
			obj.paramType = (ParamType)2;
			obj.floatParam = value;
			return obj;
		}

		public static EventInfo Event(float time, string method, string value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			EventInfo obj = Event(time, method);
			obj.paramType = (ParamType)1;
			obj.stringParam = value ?? string.Empty;
			return obj;
		}

		public static EventInfo Sound(float time, AudioCue cue)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cue == (Object)null)
			{
				return null;
			}
			EventInfo obj = Event(time, "AnimSound");
			obj.paramType = (ParamType)5;
			obj.objectParam = (Object)(object)((Component)cue).gameObject;
			return obj;
		}

		public static int SwapClips(GameObject root, Func<exSpriteAnimClip, exSpriteAnimClip> map)
		{
			int num = 0;
			HashSet<object> seen = new HashSet<object>(new RefEq());
			Component[] componentsInChildren = root.GetComponentsInChildren<Component>(true);
			foreach (Component val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !(val is Transform))
				{
					num += Walk(val, map, seen, 0);
				}
			}
			return num;
		}

		private static int Walk(object o, Func<exSpriteAnimClip, exSpriteAnimClip> map, HashSet<object> seen, int depth)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			if (o == null || depth > 7 || !seen.Add(o))
			{
				return 0;
			}
			int num = 0;
			Type type = o.GetType();
			while ((object)type != null && (object)type != typeof(MonoBehaviour) && (object)type != typeof(Component) && (object)type != typeof(object))
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo.IsStatic || fieldInfo.IsLiteral)
					{
						continue;
					}
					Type fieldType = fieldInfo.FieldType;
					if ((object)fieldType == typeof(exSpriteAnimClip))
					{
						object? value = fieldInfo.GetValue(o);
						exSpriteAnimClip val = (exSpriteAnimClip)((value is exSpriteAnimClip) ? value : null);
						if ((Object)(object)val != (Object)null)
						{
							exSpriteAnimClip val2 = map(val);
							if ((Object)(object)val2 != (Object)null && (Object)(object)val2 != (Object)(object)val)
							{
								fieldInfo.SetValue(o, val2);
								num++;
							}
						}
					}
					else if (typeof(IList).IsAssignableFrom(fieldType))
					{
						if (!(fieldInfo.GetValue(o) is IList list))
						{
							continue;
						}
						for (int j = 0; j < list.Count; j++)
						{
							object obj = list[j];
							if (obj is exSpriteAnimClip)
							{
								exSpriteAnimClip val3 = map((exSpriteAnimClip)obj);
								if ((Object)(object)val3 != (Object)null && val3 != obj)
								{
									list[j] = val3;
									num++;
								}
							}
							else if (obj != null && IsWalkable(obj.GetType()))
							{
								num += Walk(obj, map, seen, depth + 1);
							}
						}
					}
					else if (IsWalkable(fieldType))
					{
						num += Walk(fieldInfo.GetValue(o), map, seen, depth + 1);
					}
				}
				type = type.BaseType;
			}
			return num;
		}

		private static bool IsWalkable(Type t)
		{
			if (t.IsClass && !typeof(Object).IsAssignableFrom(t) && (object)t != typeof(string))
			{
				return t.IsDefined(typeof(SerializableAttribute), inherit: false);
			}
			return false;
		}

		public static int StripSoundEvents(GameObject root, string namePrefix)
		{
			Dictionary<exSpriteAnimClip, exSpriteAnimClip> copies = new Dictionary<exSpriteAnimClip, exSpriteAnimClip>();
			return SwapClips(root, (exSpriteAnimClip clip) => WithoutSoundEvents(clip, namePrefix, copies));
		}

		private static exSpriteAnimClip WithoutSoundEvents(exSpriteAnimClip clip, string prefix, Dictionary<exSpriteAnimClip, exSpriteAnimClip> copies)
		{
			if ((Object)(object)clip == (Object)null || clip.eventInfos == null || !clip.eventInfos.Any((EventInfo e) => e != null && e.methodName == "AnimSound"))
			{
				return clip;
			}
			if (!copies.TryGetValue(clip, out var value))
			{
				value = Object.Instantiate<exSpriteAnimClip>(clip);
				((Object)value).name = prefix + ((Object)clip).name;
				((Object)value).hideFlags = (HideFlags)32;
				value.eventInfos.RemoveAll((EventInfo e) => e != null && e.methodName == "AnimSound");
				copies[clip] = value;
			}
			return value;
		}

		public static GameObject CloneSilent(BossContext ctx, string prefabName, string newName)
		{
			GameObject obj = KitTemplates.Clone(prefabName, newName, ctx.Holder);
			StripSoundEvents(obj, newName);
			return obj;
		}

		public static bool HasSoundEvents(exSpriteAnimClip clip)
		{
			if ((Object)(object)clip != (Object)null && clip.eventInfos != null)
			{
				return clip.eventInfos.Any((EventInfo e) => e != null && e.methodName == "AnimSound");
			}
			return false;
		}

		public static AudioCueSource EnsureSoundReceiver(GameObject go, out bool added)
		{
			added = false;
			if ((Object)(object)go == (Object)null)
			{
				return null;
			}
			AudioCueSource val = go.GetComponent<AudioCueSource>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<AudioCueSource>();
				val.m_playOnSpawn = null;
				val.m_stopOnDestroy = false;
				val.m_cues = new List<AudioCue>();
				added = true;
			}
			return val;
		}

		public static AudioCueSource EnsureSoundReceiver(GameObject go)
		{
			bool added;
			return EnsureSoundReceiver(go, out added);
		}

		internal static HashSet<exSpriteAnimClip> ClipsUnder(GameObject root)
		{
			HashSet<exSpriteAnimClip> set = new HashSet<exSpriteAnimClip>();
			if ((Object)(object)root != (Object)null)
			{
				SwapClips(root, delegate(exSpriteAnimClip c)
				{
					set.Add(c);
					return c;
				});
			}
			return set;
		}

		internal static int AddReceiversForKitSounds(GameObject root, HashSet<exSpriteAnimClip> vanillaClips, string namePrefix)
		{
			if ((Object)(object)root == (Object)null)
			{
				return 0;
			}
			List<GameObject> list = new List<GameObject>();
			exSpriteAnimation[] componentsInChildren = root.GetComponentsInChildren<exSpriteAnimation>(true);
			foreach (exSpriteAnimation val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).GetComponent<AudioCueSource>() != (Object)null) && val.animations != null && val.animations.Any((exSpriteAnimClip c) => (Object)(object)c != (Object)null && (vanillaClips == null || !vanillaClips.Contains(c)) && HasSoundEvents(c)))
				{
					list.Add(((Component)val).gameObject);
				}
			}
			if (list.Count == 0)
			{
				return 0;
			}
			SilenceVanillaClips(root, vanillaClips, namePrefix);
			foreach (GameObject item in list)
			{
				EnsureSoundReceiver(item);
			}
			return list.Count;
		}

		internal static int SilenceVanillaClips(GameObject root, HashSet<exSpriteAnimClip> vanillaClips, string namePrefix)
		{
			if ((Object)(object)root == (Object)null || vanillaClips == null || vanillaClips.Count == 0)
			{
				return 0;
			}
			Dictionary<exSpriteAnimClip, exSpriteAnimClip> copies = new Dictionary<exSpriteAnimClip, exSpriteAnimClip>();
			return SwapClips(root, (exSpriteAnimClip c) => (!vanillaClips.Contains(c)) ? c : WithoutSoundEvents(c, namePrefix, copies));
		}

		public static Dictionary<string, exSpriteAnimClip> TrapStateClips(Sheet sheet, string clipPrefix, float[] fps = null)
		{
			return TrapStateClips(sheet, clipPrefix, fps, null);
		}

		public static Dictionary<string, exSpriteAnimClip> TrapStateClips(Sheet sheet, string clipPrefix, float[] fps, IEnumerable<EventInfo> actionEvents)
		{
			if (sheet == null)
			{
				throw new ArgumentNullException("sheet");
			}
			if (fps != null && fps.Length != TrapStates.Length)
			{
				throw new ArgumentException("TrapStateClips needs " + TrapStates.Length + " fps values");
			}
			Dictionary<string, exSpriteAnimClip> dictionary = new Dictionary<string, exSpriteAnimClip>();
			for (int i = 0; i < TrapStates.Length; i++)
			{
				string text = TrapStates[i];
				string key = (sheet.Has(clipPrefix + "_" + text) ? (clipPrefix + "_" + text) : text);
				bool flag = text == "inactive" || text == "active";
				dictionary[text] = sheet.Clip(clipPrefix + "_" + text, key, (fps != null) ? fps[i] : TrapStateFps[i], (WrapMode)((!flag) ? 1 : 2), (text == "action") ? actionEvents : null);
			}
			return dictionary;
		}

		public static Dictionary<string, exSpriteAnimClip> TrapStateClips(ClipLibrary lib, string station)
		{
			if (lib == null)
			{
				throw new ArgumentNullException("lib");
			}
			Dictionary<string, exSpriteAnimClip> dictionary = new Dictionary<string, exSpriteAnimClip>();
			string[] trapStates = TrapStates;
			foreach (string text in trapStates)
			{
				dictionary[text] = lib[station + "_" + text];
			}
			return dictionary;
		}

		public static exSprite CreateSprite(Transform parent, Sheet sheet, string key, int frame, Vector3 world, Anchor anchor = (Anchor)7, bool depthSorted = true, float heightOffset = 0f)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			//IL_0087: 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_00a4: 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)
			if (sheet == null || (Object)(object)sheet.Atlas == (Object)null)
			{
				throw new InvalidOperationException("CreateSprite needs a built sheet");
			}
			int[] array = sheet.Frames(key);
			if (frame < 0 || frame >= array.Length)
			{
				throw new ArgumentOutOfRangeException("frame", key + " has " + array.Length + " frames");
			}
			GameObject val = new GameObject(sheet.Name + "_" + key);
			if ((Object)(object)parent != (Object)null)
			{
				val.transform.SetParent(parent, false);
			}
			val.transform.position = new Vector3(Mathf.Round(world.x), Mathf.Round(world.y), 0f);
			val.AddComponent<MeshFilter>();
			val.AddComponent<MeshRenderer>();
			exSprite obj = val.AddComponent<exSprite>();
			((exPlane)obj).anchor = anchor;
			obj.SetSprite(sheet.Atlas, array[frame], false);
			if (depthSorted)
			{
				DepthHandler val2 = val.AddComponent<DepthHandler>();
				val2.m_heightOffset = heightOffset;
				if ((object)s_finalHeight != null)
				{
					s_finalHeight.SetValue(val2, heightOffset);
				}
			}
			Room val3 = (((Object)(object)parent != (Object)null) ? ((Component)parent).GetComponentInParent<Room>() : null);
			if ((Object)(object)val3 != (Object)null)
			{
				KitRoom.MatchHidden(val3, val);
			}
			return obj;
		}

		public static exSpriteAnimation Animate(exSprite sprite, IEnumerable<exSpriteAnimClip> clips, exSpriteAnimClip defaultClip, bool play = true)
		{
			exSpriteAnimation val = ((Component)sprite).GetComponent<exSpriteAnimation>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)sprite).gameObject.AddComponent<exSpriteAnimation>();
			}
			List<exSpriteAnimClip> given = new List<exSpriteAnimClip>();
			if (clips != null)
			{
				given.AddRange(clips.Where((exSpriteAnimClip c) => (Object)(object)c != (Object)null));
			}
			if ((Object)(object)defaultClip != (Object)null)
			{
				given.Add(defaultClip);
			}
			if ((Object)(object)((Component)sprite).GetComponent<AudioCueSource>() == (Object)null && given.Any(HasSoundEvents))
			{
				List<string> list = ((val.animations != null) ? (from c in val.animations
					where (Object)(object)c != (Object)null && !given.Contains(c) && HasSoundEvents(c)
					select ((Object)c).name).ToList() : new List<string>());
				if (list.Count > 0)
				{
					Kit.Log.WarnOnce("animate receiver " + ((Object)sprite).name, ((Object)sprite).name + ": a sound receiver was added for the new clips, so the sound events of " + string.Join(", ", list.ToArray()) + " now play too");
				}
				EnsureSoundReceiver(((Component)sprite).gameObject);
			}
			foreach (exSpriteAnimClip item in given)
			{
				if ((Object)(object)item != (Object)(object)defaultClip)
				{
					val.AddAnimation(item);
				}
			}
			if ((Object)(object)defaultClip != (Object)null)
			{
				val.AddAnimation(defaultClip);
				val.defaultAnimation = defaultClip;
				if (play)
				{
					val.Play(defaultClip);
				}
			}
			return val;
		}

		public static void SetDepthOffset(GameObject go, float heightOffset)
		{
			DepthHandler val = (((Object)(object)go != (Object)null) ? go.GetComponent<DepthHandler>() : null);
			if (!((Object)(object)val == (Object)null))
			{
				val.m_heightOffset = heightOffset;
				if ((object)s_finalHeight != null)
				{
					s_finalHeight.SetValue(val, heightOffset);
				}
			}
		}

		public static void AddTint(GameObject go, Color c)
		{
			//IL_0000: 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)
			if (c.a > 0.6f)
			{
				throw new ArgumentException("tint alpha " + c.a + " is above 0.6 and would paint a flat silhouette");
			}
			ColorTinterBase val = go.GetComponent<ColorTinterBase>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<ColorTinterBase>();
			}
			val.AddTint(c);
		}

		public static void RemoveTint(GameObject go, Color c)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			ColorTinterBase val = (((Object)(object)go != (Object)null) ? go.GetComponent<ColorTinterBase>() : null);
			if ((Object)(object)val != (Object)null)
			{
				val.RemoveTint(c);
			}
		}
	}
	public sealed class ClipLibrary
	{
		private sealed class Meta
		{
			public string Name;

			public int Frames;

			public float Fps;

			public WrapMode Wrap;

			public List<EventInfo> Events = new List<EventInfo>();
		}

		private readonly string m_prefix;

		private readonly Dictionary<string, Meta> m_meta = new Dictionary<string, Meta>();

		private readonly Dictionary<string, exSpriteAnimClip> m_clips = new Dictionary<string, exSpriteAnimClip>();

		private readonly List<string> m_order = new List<string>();

		public KitArt.Sheet Sheet { get; private set; }

		public exSpriteAnimClip this[string name]
		{
			get
			{
				if (!m_clips.TryGetValue(name, out var value))
				{
					throw new KeyNotFoundException("no clip " + name + " in " + m_prefix + ".clips.json (it has " + string.Join(", ", m_order.ToArray()) + ")");
				}
				return value;
			}
		}

		public IEnumerable<exSpriteAnimClip> All => m_order.Select((string n) => m_clips[n]);

		private ClipLibrary(string prefix)
		{
			m_prefix = prefix;
		}

		public static ClipLibrary Load(BossContext ctx, string prefix, Material baseMaterial, Func<string, AudioCue> cueFor)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			if (ctx == null)
			{
				throw new ArgumentNullException("ctx");
			}
			ClipLibrary clipLibrary = new ClipLibrary(prefix);
			if (!(MiniJson.Parse(ctx.Assets.Text(prefix + ".clips.json")) is MiniJson.JsonObject jsonObject))
			{
				throw new FormatException(prefix + ".clips.json: the top level must be an object");
			}
			foreach (string item in jsonObject.Keys2)
			{
				if (!(jsonObject[item] is MiniJson.JsonObject jsonObject2))
				{
					throw new FormatException(prefix + ".clips.json: " + item + " is not an object");
				}
				Meta meta = new Meta
				{
					Name = item
				};
				meta.Frames = (int)Num(jsonObject2, "frames", item, prefix);
				meta.Fps = (float)Num(jsonObject2, "fps", item, prefix);
				if (meta.Frames < 1 || meta.Fps <= 0f)
				{
					throw new FormatException(prefix + ".clips.json: " + item + " needs frames >= 1 and fps > 0");
				}
				meta.Wrap = (WrapMode)((!jsonObject2.TryGetValue("wrap", out var value) || value == null) ? 1 : ((int)ParseWrap(value.ToString(), item)));
				if (jsonObject2.TryGetValue("events", out var value2) && value2 != null)
				{
					foreach (object item2 in (value2 as List<object>) ?? throw new FormatException(prefix + ".clips.json: " + item + ".events must be an array"))
					{
						EventInfo val = ParseEvent(ctx, item2, item, prefix, cueFor);
						if (val != null)
						{
							meta.Events.Add(val);
						}
					}
				}
				clipLibrary.m_meta[item] = meta;
				clipLibrary.m_order.Add(item);
			}
			KitArt.Sheet sheet = new KitArt.Sheet(prefix);
			foreach (string item3 in clipLibrary.m_order)
			{
				sheet.AddStrip(item3, ctx.Assets, prefix + "." + item3 + ".png", clipLibrary.m_meta[item3].Frames);
			}
			sheet.Build(baseMaterial);
			clipLibrary.Sheet = sheet;
			foreach (string item4 in clipLibrary.m_order)
			{
				Meta meta2 = clipLibrary.m_meta[item4];
				clipLibrary.m_clips[item4] = sheet.Clip(prefix + item4, item4, meta2.Fps, meta2.Wrap, meta2.Events);
			}
			return clipLibrary;
		}

		private static double Num(MiniJson.JsonObject body, string field, string clip, string prefix)
		{
			if (!body.TryGetValue(field, out var value) || !(value is double))
			{
				throw new FormatException(prefix + ".clips.json: " + clip + " is missing the number " + field);
			}
			return (double)value;
		}

		private static WrapMode ParseWrap(string s, string clip)
		{
			return (WrapMode)(s.ToLowerInvariant() switch
			{
				"loop" => 2, 
				"once" => 1, 
				"pingpong" => 4, 
				"clampforever" => 8, 
				_ => throw new FormatException("clips.json: " + clip + " has an unknown wrap " + s), 
			});
		}

		private static EventInfo ParseEvent(BossContext ctx, object row, string clip, string prefix, Func<string, AudioCue> cueFor)
		{
			if (!(row is List<object> { Count: >=3 } list) || !(list[0] is double) || !(list[1] is string) || !(list[2] is string))
			{
				throw new FormatException(prefix + ".clips.json: " + clip + " has an event that is not [time, method, kind, value]");
			}
			float time = (float)(double)list[0];
			string text = (string)list[1];
			string text2 = ((string)list[2]).ToLowerInvariant();
			object obj = ((list.Count > 3) ? list[3] : null);
			switch (text2)
			{
			case "none":
				return KitArt.Event(time, text);
			case "int":
				if (!(obj is double))
				{
					throw new FormatException(prefix + ".clips.json: " + clip + " event " + text + " needs an int value");
				}
				return KitArt.Event(time, text, (int)Math.Round((double)obj));
			case "float":
				if (!(obj is double))
				{
					throw new FormatException(prefix + ".clips.json: " + clip + " event " + text + " needs a float value");
				}
				return KitArt.Event(time, text, (float)(double)obj);
			case "string":
				return KitArt.Event(time, text, (obj != null) ? obj.ToString() : string.Empty);
			case "sound":
			{
				string text3 = obj?.ToString();
				AudioCue val = null;
				try
				{
					val = ((text3 != null && cueFor != null) ? cueFor(text3) : null);
				}
				catch (Exception e)
				{
					ctx.Log.WarnOnce("cue " + text3, e);
				}
				if ((Object)(object)val == (Object)null)
				{
					ctx.Log.WarnOnce("nocue " + prefix + clip + text3, prefix + clip + ": no cue " + text3 + ", its sound event is dropped");
					return null;
				}
				EventInfo obj2 = KitArt.Sound(time, val);
				obj2.methodName = text;
				return obj2;
			}
			default:
				throw new FormatException(prefix + ".clips.json: " + clip + " event " + text + " has an unknown kind " + text2);
			}
		}

		public bool Has(string name)
		{
			return m_clips.ContainsKey(name);
		}

		public float Length(string name)
		{
			return this[name].length;
		}

		public exSpriteAnimClip Rebuild(string name, float? fps = null, WrapMode? wrap = null, IEnumerable<EventInfo> events = null, int[] order = null)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!m_meta.TryGetValue(name, out var value))
			{
				throw new KeyNotFoundException("no clip " + name + " in " + m_prefix + ".clips.json");
			}
			exSpriteAnimClip val = Sheet.Clip(m_prefix + name, name, fps ?? value.Fps, (WrapMode)(((??)wrap) ?? value.Wrap), events ?? value.Events, order);
			m_clips[name] = val;
			return val;
		}
	}
	public sealed class BossAssets
	{
		private readonly Assembly m_asm;

		private readonly string[] m_names;

		public Assembly Assembly => m_asm;

		public BossAssets(Assembly asm)
		{
			if ((object)asm == null)
			{
				throw new ArgumentNullException("asm");
			}
			m_asm = asm;
			m_names = asm.GetManifestResourceNames();
		}

		private string Resolve(string logicalName, bool throwIfMissing)
		{
			if (m_names.Contains(logicalName))
			{
				return logicalName;
			}
			string[] array = m_names.Where((string n) => n.EndsWith("." + logicalName, StringComparison.OrdinalIgnoreCase)).ToArray();
			if (array.Length == 1)
			{
				return array[0];
			}
			if (!throwIfMissing)
			{
				return null;
			}
			if (array.Length > 1)
			{
				throw new FileNotFoundException("embedded resource " + logicalName + " is ambiguous in " + m_asm.GetName().Name + ": " + string.Join(", ", array));
			}
			throw new FileNotFoundException("embedded resource " + logicalName + " not found in " + m_asm.GetName().Name + " (it has " + m_names.Length + " resources" + ((m_names.Length != 0) ? (", e.g. " + string.Join(", ", m_names.Take(8).ToArray())) : "") + ")");
		}

		internal int Count(Func<string, bool> test)
		{
			return m_names.Count(test);
		}

		public bool Has(string logicalName)
		{
			return Resolve(logicalName, throwIfMissing: false) != null;
		}

		public byte[] Bytes(string logicalName)
		{
			string text = Resolve(logicalName, throwIfMissing: true);
			using Stream stream = m_asm.GetManifestResourceStream(text);
			if (stream == null)
			{
				throw new FileNotFoundException("embedded resource " + text + " could not be opened");
			}
			using MemoryStream memoryStream = new MemoryStream();
			byte[] array = new byte[8192];
			int count;
			while ((count = stream.Read(array, 0, array.Length)) > 0)
			{
				memoryStream.Write(array, 0, count);
			}
			return memoryStream.ToArray();
		}

		public string Text(string logicalName)
		{
			byte[] array = Bytes(logicalName);
			int num = ((array.Length >= 3 && array[0] == 239 && array[1] == 187 && array[2] == 191) ? 3 : 0);
			return Encoding.UTF8.GetString(array, num, array.Length - num);
		}

		public Texture2D Png(string logicalName)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_0047: Expected O, but got Unknown
			Texture2D val = new Texture2D(2, 2, (TextureFormat)5, false);
			if (!val.LoadImage(Bytes(logicalName)))
			{
				throw new FormatException("could not decode " + logicalName);
			}
			((Texture)val).filterMode = (FilterMode)0;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Object)val).name = logicalName;
			((Object)val).hideFlags = (HideFlags)32;
			return val;
		}

		public string[] Names(string prefix)
		{
			string p = prefix + ".";
			return m_names.Where((string n) => n.StartsWith(p, StringComparison.Ordinal)).ToArray();
		}
	}
	internal static class MiniJson
	{
		internal sealed class JsonObject : Dictionary<string, object>
		{
			public readonly List<string> Keys2 = new List<string>();
		}

		public static object Parse(string text)
		{
			int i = 0;
			object result = Value(text, ref i);
			Skip(text, ref i);
			if (i != text.Length)
			{
				throw new FormatException("json: unexpected text at " + i);
			}
			return result;
		}

		private static void Skip(string s, ref int i)
		{
			while (i < s.Length && char.IsWhiteSpace(s[i]))
			{
				i++;
			}
		}

		private static object Value(string s, ref int i)
		{
			Skip(s, ref i);
			if (i >= s.Length)
			{
				throw new FormatException("json: unexpected end");
			}
			switch (s[i])
			{
			case '{':
				return Obj(s, ref i);
			case '[':
				return Arr(s, ref i);
			case '"':
				return Str(s, ref i);
			case 't':
				Word(s, ref i, "true");
				return true;
			case 'f':
				Word(s, ref i, "false");
				return false;
			case 'n':
				Word(s, ref i, "null");
				return null;
			default:
				return Num(s, ref i);
			}
		}

		private static void Word(string s, ref int i, string w)
		{
			if (string.CompareOrdinal(s, i, w, 0, w.Length) != 0)
			{
				throw new FormatException("json: bad literal at " + i);
			}
			i += w.Length;
		}

		private static JsonObject Obj(string s, ref int i)
		{
			JsonObject jsonObject = new JsonObject();
			i++;
			Skip(s, ref i);
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return jsonObject;
			}
			while (true)
			{
				Skip(s, ref i);
				if (i >= s.Length || s[i] != '"')
				{
					throw new FormatException("json: expected a key at " + i);
				}
				string text = Str(s, ref i);
				Skip(s, ref i);
				if (i >= s.Length || s[i] != ':')
				{
					throw new FormatException("json: expected ':' at " + i);
				}
				i++;
				object value = Value(s, ref i);
				if (!jsonObject.ContainsKey(text))
				{
					jsonObject.Keys2.Add(text);
				}
				jsonObject[text] = value;
				Skip(s, ref i);
				if (i >= s.Length || s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return jsonObject;
			}
			throw new FormatException("json: expected ',' or '}' at " + i);
		}

		private static List<object> Arr(string s, ref int i)
		{
			List<object> list = new List<object>();
			i++;
			Skip(s, ref i);
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			while (true)
			{
				list.Add(Value(s, ref i));
				Skip(s, ref i);
				if (i >= s.Length || s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			throw new FormatException("json: expected ',' or ']' at " + i);
		}

		private static string Str(string s, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
					break;
				}
				if (i >= s.Length)
				{
					break;
				}
				char c2 = s[i++];
				switch (c2)
				{
				case '"':
					stringBuilder.Append('"');
					break;
				case '\\':
					stringBuilder.Append('\\');
					break;
				case '/':
					stringBuilder.Append('/');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'u':
					if (i + 4 > s.Length)
					{
						throw new FormatException("json: bad \\u escape");
					}
					stringBuilder.Append((char)int.Parse(s.Substring(i, 4), NumberStyles.HexNumber, CultureInfo.InvariantCulture));
					i += 4;
					break;
				default:
					throw new FormatException("json: bad escape \\" + c2);
				}
			}
			throw new FormatException("json: unterminated string");
		}

		private static double Num(string s, ref int i)
		{
			int num = i;
			while (i < s.Length && "+-0123456789.eE".IndexOf(s[i]) >= 0)
			{
				i++;
			}
			if (i == num)
			{
				throw new FormatException("json: unexpected character '" + s[i] + "' at " + i);
			}
			return double.Parse(s.Substring(num, i - num), NumberStyles.Float, CultureInfo.InvariantCulture);
		}
	}
	public sealed class BodySpec
	{
		public ClipLibrary Clips;

		public string Idle;

		public string Run;

		public string Dead;

		public string Statue;

		public float HealthMax;

		public float Resistance = 1f;

		public float VulnerableMult = 1f;

		public float MaxDamagePerHit;

		public eAllowedDamageSource AllowedDamage;

		public float Speed;

		public float Mass = 600f;

		public float KnockbackSpeed;

		public AudioCue DieSound;

		public Vector2 AttackSpawnNode;

		public List<AttackData> Attacks;

		public List<DamageEffectData> Effects;

		public int CapsuleDirection;

		public float CapsuleRadius;

		public float CapsuleHeight;

		public Vector3 CapsuleCenter;

		public Vector3 HitZoneScale;

		public Vector3 HitZonePos;

		public Vector2 SpriteOffset;

		public Anchor Anchor = (Anchor)7;
	}
	public static class KitBodies
	{
		private static readonly Dictionary<int, BodySpec> s_specs = new Dictionary<int, BodySpec>();

		internal static readonly Dictionary<int, KitBoss> KeptInRoom = new Dictionary<int, KitBoss>();

		internal static BodySpec SpecOf(GameObject template)
		{
			if (!((Object)(object)template != (Object)null) || !s_specs.TryGetValue(((Object)template).GetInstanceID(), out var value))
			{
				return null;
			}
			return value;
		}

		public static GameObject CloneBody(BossContext ctx, string vanillaEnemy, string newName, BodySpec spec)
		{
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0381: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Unknown result type (might be due to invalid IL or missing references)
			//IL_0559: Unknown result type (might be due to invalid IL or missing references)
			if (ctx == null || spec == null)
			{
				throw new ArgumentNullException((ctx == null) ? "ctx" : "spec");
			}
			if (spec.Clips == null || string.IsNullOrEmpty(spec.Idle) || string.IsNullOrEmpty(spec.Run) || string.IsNullOrEmpty(spec.Dead))
			{
				throw new ArgumentException(newName + ": BodySpec needs Clips, Idle, Run and Dead");
			}
			if (spec.HealthMax <= 0f)
			{
				throw new ArgumentException(newName + ": BodySpec.HealthMax must be positive");
			}
			if (spec.Resistance <= 0f)
			{
				throw new ArgumentException(newName + ": BodySpec.Resistance must be positive (damage is divided by it)");
			}
			if (spec.Effects != null && spec.AttackSpawnNode.x != 0f && spec.Effects.Any((DamageEffectData e) => e != null && !e.m_rotateOffsetX))
			{
				throw new ArgumentException(newName + ": an effect with m_rotateOffsetX false needs AttackSpawnNode.x 0 (Attacks.cs:623-640)");
			}
			exSpriteAnimClip val = spec.Clips[spec.Idle];
			exSpriteAnimClip value = spec.Clips[spec.Run];
			exSpriteAnimClip value2 = spec.Clips[spec.Dead];
			exSpriteAnimClip value3 = (string.IsNullOrEmpty(spec.Statue) ? val : spec.Clips[spec.Statue]);
			if (val.frameInfos == null || val.frameInfos.Count == 0)
			{
				throw new InvalidOperationException(newName + ": the Idle clip has no frames");
			}
			GameObject val2 = KitTemplates.Clone(vanillaEnemy, newName, ctx.Holder);
			Player o = Need<Player>(val2, vanillaEnemy);
			Health o2 = Need<Health>(val2, vanillaEnemy);
			PlayerMovement o3 = Need<PlayerMovement>(val2, vanillaEnemy);
			Rigidbody val3 = Need<Rigidbody>(val2, vanillaEnemy);
			exSprite val4 = Need<exSprite>(val2, vanillaEnemy);
			exSpriteAnimation val5 = Need<exSpriteAnimation>(val2, vanillaEnemy);
			HashSet<exSpriteAnimClip> vanillaClips = KitArt.ClipsUnder(val2);
			PlayerAI[] components = val2.GetComponents<PlayerAI>();
			for (int num = 0; num < components.Length; num++)
			{
				Object.DestroyImmediate((Object)(object)components[num]);
			}
			if ((Object)(object)val2.GetComponent<PlayerAI>() != (Object)null)
			{
				throw new InvalidOperationException(vanillaEnemy + ": its PlayerAI could not be removed");
			}
			Util.Set(o, "m_animationIdle", val);
			Util.Set(o, "m_animationRun", value);
			Util.Set(o, "m_animationDead", value2);
			Util.Set(o, "m_animationStatue", value3);
			Util.Set(o, "m_animationKnockback", null);
			Util.Set(o, "m_animationSpawn", null);
			Util.Set(o, "m_hasSpecialAttack", false);
			Util.Set(o, "m_spawnOnDeath", new DamageEffectData[0]);
			Util.Set(o, "m_knockbackSpeed", spec.KnockbackSpeed);
			Util.Set(o, "m_knockbackCancelsAttack", false);
			Util.Set(o, "m_soundHit", null);
			Util.Set(o, "m_soundDie", spec.DieSound);
			Util.Set(o, "m_attackSpawnNode", spec.AttackSpawnNode);
			Util.Set(o, "m_attacks", (spec.Attacks != null) ? new List<AttackData>(spec.Attacks) : new List<AttackData>());
			Util.Set(o, "m_attackDamageEffects", (spec.Effects != null) ? new List<DamageEffectData>(spec.Effects) : new List<DamageEffectData>());
			Util.Set(o2, "m_healthMax", spec.HealthMax);
			Util.Set(o2, "m_damageResistance", spec.Resistance);
			Util.Set(o2, "m_vulnerableDamageMult", spec.VulnerableMult);
			Util.Set(o2, "m_vulnerableState", string.Empty);
			Util.Set(o2, "m_allowedDamageSource", spec.AllowedDamage);
			if (spec.Speed > 0f)
			{
				Util.Set(o3, "m_speedMax", spec.Speed);
			}
			val3.mass = spec.Mass;
			if (spec.CapsuleRadius > 0f)
			{
				CapsuleCollider obj = Need<CapsuleCollider>(val2, vanillaEnemy);
				obj.direction = spec.CapsuleDirection;
				obj.radius = spec.CapsuleRadius;
				obj.height = spec.CapsuleHeight;
				obj.center = spec.CapsuleCenter;
			}
			if (spec.HitZoneScale != Vector3.zero)
			{
				Transform obj2 = val2.transform.Find("HitZone");
				if ((Object)(object)obj2 == (Object)null)
				{
					throw new InvalidOperationException(vanillaEnemy + " has no HitZone child");
				}
				BoxCollider component = ((Component)obj2).GetComponent<BoxCollider>();
				if ((Object)(object)component == (Object)null)
				{
					throw new InvalidOperationException(vanillaEnemy + ": its HitZone has no BoxCollider, so HitZoneScale has no defined size");
				}
				component.size = new Vector3((component.size.x < 0f) ? (-1f) : 1f, 1f, component.size.z);
				component.center = new Vector3(0f, 0f, component.center.z);
				Vector3 localScale = obj2.localScale;
				Vector3 localPosition = obj2.localPosition;
				obj2.localScale = new Vector3(spec.HitZoneScale.x, spec.HitZoneScale.y, (spec.HitZoneScale.z != 0f) ? spec.HitZoneScale.z : localScale.z);
				obj2.localPosition = new Vector3(spec.HitZonePos.x, spec.HitZonePos.y, (spec.HitZonePos.z != 0f) ? spec.HitZonePos.z : localPosition.z);
			}
			((exPlane)val4).anchor = spec.Anchor;
			((exPlane)val4).offset = spec.SpriteOffset;
			exAtlas atlas = val.frameInfos[0].atlas;
			val4.SetSprite(atlas, val.frameInfos[0].index, true);
			val5.animations = new List<exSpriteAnimClip>();
			foreach (exSpriteAnimClip item in spec.Clips.All)
			{
				if (item.frameInfos.Count > 0 && (Object)(object)item.frameInfos[0].atlas == (Object)(object)atlas)
				{
					val5.AddAnimation(item);
				}
			}
			val5.defaultAnimation = val;
			val5.playAutomatically = false;
			AudioCueSource[] componentsInChildren = val2.GetComponentsInChildren<AudioCueSource>(true);
			for (int num = 0; num < componentsInChildren.Length; num++)
			{
				componentsInChildren[num].m_playOnSpawn = null;
			}
			if ((Object)(object)val2.GetComponent<AudioCueSource>() == (Object)null && spec.Clips.All.Any(KitArt.HasSoundEvents))
			{
				KitArt.SilenceVanillaClips(val2, vanillaClips, newName + "_");
				KitArt.EnsureSoundReceiver(val2);
			}
			s_specs[((Object)val2).GetInstanceID()] = spec;
			ctx.BodySpecs.Add(spec);
			return val2;
		}

		private static T Need<T>(GameObject go, string what) where T : Component
		{
			T component = go.GetComponent<T>();
			if ((Object)(object)component == (Object)null)
			{
				throw new InvalidOperationException(what + " has no " + typeof(T).Name);
			}
			return component;
		}

		public static KitBody Spawn<TBrain>(KitBoss boss, GameObject bodyTemplate, Vector2 roomLocal, string name) where TBrain : KitBrain
		{
			//IL_006c: 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)
			if ((Object)(object)boss == (Object)null || (Object)(object)boss.Arena == (Object)null)
			{
				throw new InvalidOperationException("KitBodies.Spawn needs a live KitBoss in its arena");
			}
			if ((Object)(object)SystemLevel.GetCurrentRoom() != (Object)(object)boss.Arena)
			{
				throw new InvalidOperationException("KitBodies.Spawn(" + name + ") while the arena is not the current room: the body would despawn (R7)");
			}
			BodySpec bodySpec = SpecOf(bodyTemplate);
			if (bodySpec == null)
			{
				throw new InvalidOperationException("KitBodies.Spawn(" + name + "): the template was not made by KitBodies.CloneBody");
			}
			GameObject val = ExtentionsMethodsPool.Spawn(bodyTemplate, boss.World(roomLocal), Quaternion.identity);
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("spawning " + name + " failed");
			}
			((Object)val).name = name;
			if ((Object)(object)val.transform.parent != (Object)null)
			{
				val.transform.SetParent((Transform)null, true);
			}
			TBrain val2 = val.AddComponent<TBrain>();
			if ((Object)(object)val.GetComponent<PlayerAI>() != (Object)(object)val2)
			{
				Object.Destroy((Object)(object)val2);
				ExtentionsMethodsPool.Despawn(val);
				throw new InvalidOperationException("KitBodies.Spawn(" + name + "): the body carries another PlayerAI, the brain would be ignored");
			}
			KitBody kitBody = val.AddComponent<KitBody>();
			kitBody.Setup(boss, bodySpec, val2);
			val.GetComponent<Player>().InitAsAI((GameObject)null);
			kitBody.AfterInit();
			boss.TrackRoot(val);
			return kitBody;
		}
	}
	public sealed class KitBody : MonoBehaviour
	{
		internal static readonly Dictionary<int, KitBody> ByPlayer = new Dictionary<int, KitBody>();

		internal static readonly Dictionary<int, KitBody> ByMovement = new Dictionary<int, KitBody>();

		internal static readonly Dictionary<int, KitBody> ByGameObject = new Dictionary<int, KitBody>();

		private bool m_dead;

		private bool m_registered;

		public bool KeepInRoom = true;

		public bool GuardStuns = true;

		public bool RefuseStatuses;

		internal bool AllowStun;

		private bool m_holdVulnerable;

		private readonly Dictionary<string, float> m_scales = new Dictionary<string, float>();

		private AudioCue m_hurt;

		private float m_hurtGap = 0.25f;

		private float m_lastHurt = -10f;

		public Func<Vector3?> VelocityOverride;

		private int m_cutsceneId;

		public KitBoss Boss { get; private set; }

		public Player Player { get; private set; }

		public Health Health { get; private set; }

		public PlayerMovement Movement { get; private set; }

		public KitBrain Brain { get; private set; }

		public exSpriteAnimation Anim { get; private set; }

		public Rigidbody Body { get; private set; }

		public bool IsLife { get; internal set; }

		internal BodySpec Spec { get; private set; }

		public bool Alive
		{
			get
			{
				if (!m_dead && (Object)(object)Health != (Object)null)
				{
					return Health.IsAlive();
				}
				return false;
			}
		}

		public bool HoldVulnerable
		{
			get
			{
				return m_holdVulnerable;
			}
			set
			{
				if (m_holdVulnerable != value)
				{
					m_holdVulnerable = value;
					SetVulnerable(value);
				}
			}
		}

		public event Action<DamageInfo> Damaged;

		public event Action<DamageInfo> Died;

		public void Stun(float time, exSpriteAnimClip loopClip = null)
		{
			if (Alive)
			{
				AllowStun = true;
				try
				{
					Player.Stun(time, false);
				}
				finally
				{
					AllowStun = false;
				}
				if ((Object)(object)loopClip != (Object)null && (Object)(object)Anim != (Object)null)
				{
					Anim.Play(loopClip);
				}
			}
		}

		public void SetVulnerable(bool on)
		{
			if (!((Object)(object)Health == (Object)null) && (!on || Alive))
			{
				if (on)
				{
					Health.AnimVulnerableOn();
				}
				else
				{
					Health.AnimVulnerableOff();
				}
			}
		}

		public void ScaleEffect(GameObject fxTemplate, float scale)
		{
			if (!((Object)(object)fxTemplate == (Object)null))
			{
				if (scale <= 0f || Mathf.Approximately(scale, 1f))
				{
					m_scales.Remove(((Object)fxTemplate).name);
				}
				else
				{
					m_scales[((Object)fxTemplate).name] = scale;
				}
			}
		}

		public void SetHurtSound(AudioCue cue, float gap = 0.25f)
		{
			m_hurt = cue;
			m_hurtGap = gap;
		}

		internal void Setup(KitBoss boss, BodySpec spec, KitBrain brain)
		{
			Boss = boss;
			Spec = spec;
			Player = ((Component)this).GetComponent<Player>();
			Health = ((Component)this).GetComponent<Health>();
			Movement = ((Component)this).GetComponent<PlayerMovement>();
			Brain = brain;
			Anim = ((Component)this).GetComponent<exSpriteAnimation>();
			Body = ((Component)this).GetComponent<Rigidbody>();
			if ((Object)(object)Player != (Object)null)
			{
				ByPlayer[((Object)Player).GetInstanceID()] = this;
			}
			if ((Object)(object)Movement != (Object)null)
			{
				ByMovement[((Object)Movement).GetInstanceID()] = this;
			}
			ByGameObject[((Object)((Component)this).gameObject).GetInstanceID()] = this;
			m_registered = true;
		}

		internal void AfterInit()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (Spec != null && Spec.MaxDamagePerHit > 0f)
			{
				Health.SetMaxDamagePerHit(Spec.MaxDamagePerHit);
			}
			float multiplier = 1f;
			try
			{
				multiplier = SystemBalance.BossResistanceMultiplier;
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss resistance multiplier", e);
			}
			Health.ModifyDamageResistance(Util.BossStack(multiplier));
			Player.CallbackOnDie = (Action<Player, DamageInfo>)Delegate.Combine(Player.CallbackOnDie, new Action<Player, DamageInfo>(OnDie));
			if ((Object)(object)Brain != (Object)null)
			{
				Brain.SetMove(Vector2.right, 0f);
			}
		}

		private void OnDie(Player p, DamageInfo info)
		{
			if (m_dead)
			{
				return;
			}
			m_dead = true;
			m_holdVulnerable = false;
			try
			{
				((MonoBehaviour)this).StopAllCoroutines();
				if ((Object)(object)Movement != (Object)null)
				{
					Movement.ResetInputOverride();
					Movement.ResetSpeedMultiplier();
				}
				if ((Object)(object)Brain != (Object)null)
				{
					Brain.Stop();
				}
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("body die " + ((Object)this).name, e);
			}
			Action<DamageInfo> action = this.Died;
			if (action == null)
			{
				return;
			}
			try
			{
				action(info);
			}
			catch (Exception e2)
			{
				Kit.Log.WarnOnce("body died event " + ((Object)this).name, e2);
			}
		}

		private void OnDamaged(DamageInfo info)
		{
			if (m_dead || (Object)(object)Health == (Object)null)
			{
				return;
			}
			try
			{
				if ((Object)(object)m_hurt != (Object)null && info != null && info.m_source != null && info.m_source.m_sourcePlayer != null && (info.m_amount != 0f || (Object)(object)info.m_status != (Object)null || info.m_stunTime > 0f) && Time.time - m_lastHurt >= m_hurtGap)
				{
					m_lastHurt = Time.time;
					Util.PlaySound(m_hurt, ((Component)this).transform);
				}
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("hurt sound " + ((Object)this).name, e);
			}
			Action<DamageInfo> action = this.Damaged;
			if (action == null)
			{
				return;
			}
			try
			{
				action(info);
			}
			catch (Exception e2)
			{
				Kit.Log.WarnOnce("body damaged event " + ((Object)this).name, e2);
			}
		}

		private void MsgOnObjectSpawn(GameObject obj)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)obj == (Object)null) && m_scales.Count != 0 && m_scales.TryGetValue(Util.StripClone(((Object)obj).name), out var value))
			{
				Vector3 localScale = obj.transform.localScale;
				obj.transform.localScale = new Vector3(Mathf.Sign((localScale.x == 0f) ? 1f : localScale.x) * value, value, 1f);
			}
		}

		private void Update()
		{
			if (m_holdVulnerable && Alive && (Object)(object)Health != (Object)null)
			{
				try
				{
					Health.AnimVulnerableOn();
				}
				catch (Exception e)
				{
					Kit.Log.WarnOnce("hold vulnerable " + ((Object)this).name, e);
				}
			}
		}

		public void Freeze(bool frozen)
		{
			if (frozen && (Object)(object)Brain != (Object)null)
			{
				Brain.Stop();
			}
		}

		public void PlayStatus(exSpriteAnimClip clip)
		{
			if (Alive && (Object)(object)clip != (Object)null)
			{
				Player.StartStatusAnimation(clip);
			}
		}

		public void PlayCutscene(exSpriteAnimClip clip, bool collisionOff = false)
		{
			if (Alive && !((Object)(object)clip == (Object)null))
			{
				HoldCutscene(clip, clip.length, collisionOff);
			}
		}

		public void HoldCutscene(exSpriteAnimClip clip, float holdSeconds, bool collisionOff = false)
		{
			if (Alive && !((Object)(object)clip == (Object)null))
			{
				int id = ++m_cutsceneId;
				Player.StartCutscene(clip, collisionOff, 0f);
				if (holdSeconds > 0f)
				{
					((MonoBehaviour)this).StartCoroutine(EndCutsceneAfter(holdSeconds, id));
				}
			}
		}

		public void CancelCutsceneEnd()
		{
			m_cutsceneId++;
		}

		private IEnumerator EndCutsceneAfter(float t, int id)
		{
			IEnumerator wait = KitBoss.WaitGameTime(t);
			while (wait.MoveNext())
			{
				yield return wait.Current;
			}
			if (id == m_cutsceneId && Alive && (int)Player.GetState() == 13)
			{
				Player.EndCutscene();
			}
		}

		public void EndAction()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			m_cutsceneId++;
			if (Alive)
			{
				ePlayerState state = Player.GetState();
				if ((int)state == 15 || (int)state == 13)
				{
					Player.EndCutscene();
				}
			}
		}

		private void OnDestroy()
		{
			if (m_registered)
			{
				if ((Object)(object)Player != (Object)null)
				{
					ByPlayer.Remove(((Object)Player).GetInstanceID());
				}
				if ((Object)(object)Movement != (Object)null)
				{
					ByMovement.Remove(((Object)Movement).GetInstanceID());
				}
				ByGameObject.Remove(((Object)((Component)this).gameObject).GetInstanceID());
				m_registered = false;
			}
		}
	}
	public class KitBrain : PlayerAI
	{
		private static readonly FieldRef<PlayerAI, Vector2> s_face = AccessTools.FieldRefAccess<PlayerAI, Vector2>("m_faceDirection");

		private static readonly FieldRef<PlayerAI, float> s_move = AccessTools.FieldRefAccess<PlayerAI, float>("m_moveRatio");

		public int RequestedAttack = -1;

		public void SetMove(Vector2 dir, float ratio)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (((Vector2)(ref dir)).sqrMagnitude > 0.0001f)
			{
				s_face.Invoke((PlayerAI)(object)this) = ((Vector2)(ref dir)).normalized;
			}
			s_move.Invoke((PlayerAI)(object)this) = Mathf.Clamp01(ratio);
		}

		public void Face(Vector2 dir)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			SetMove(dir, 0f);
			if (((Vector2)(ref dir)).sqrMagnitude > 0.0001f)
			{
				PlayerMovement component = ((Component)this).GetComponent<PlayerMovement>();
				if ((Object)(object)component != (Object)null)
				{
					component.SetDirection(((Vector2)(ref dir)).normalized);
				}
			}
		}

		public void Stop()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SetMove(Vector2.zero, 0f);
			RequestedAttack = -1;
		}

		public bool RequestAttack(int index)
		{
			Player component = ((Component)this).GetComponent<Player>();
			Health component2 = ((Component)this).GetComponent<Health>();
			if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || !component2.IsAlive())
			{
				return false;
			}
			List<AttackData> list;
			try
			{
				list = Util.Get<List<AttackData>>(component, "m_attacks");
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("request attack", e);
				return false;
			}
			if (list == null || index < 0 || index >= list.Count)
			{
				return false;
			}
			RequestedAttack = index;
			return true;
		}

		public override int GetAttackToStart()
		{
			return RequestedAttack;
		}

		public override void OnAttack()
		{
			RequestedAttack = -1;
		}

		private void Update()
		{
		}
	}
	public static class KitFx
	{
		public static GameObject CloneDamage(BossContext ctx, string prefabName, string newName, bool stripSounds = true)
		{
			GameObject obj = (stripSounds ? KitArt.CloneSilent(ctx, prefabName, newName) : KitTemplates.Clone(prefabName, newName, ctx.Holder));
			if ((Object)(object)obj.GetComponent<DamageEffect>() == (Object)null)
			{
				throw new InvalidOperationException(prefabName + " has no DamageEffect");
			}
			return obj;
		}

		public static GameObject TuneDamage(GameObject fx, float damage, float rate, float knockback, float stun)
		{
			DamageEffect obj = (((Object)(object)fx != (Object)null) ? fx.GetComponent<DamageEffect>() : null);
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException((((Object)(object)fx != (Object)null) ? ((Object)fx).name : "null") + " has no DamageEffect");
			}
			Util.Set(obj, "m_damage", damage);
			Util.Set(obj, "m_damageRate", rate);
			Util.Set(obj, "m_knockbackMultiplier", knockback);
			Util.Set(obj, "m_stunTime", stun);
			return fx;
		}

		public static void SetLifetime(GameObject fx, float destroyAfter, bool destroyOnAnimEnd)
		{
			Effect obj = (((Object)(object)fx != (Object)null) ? fx.GetComponent<Effect>() : null);
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException((((Object)(object)fx != (Object)null) ? ((Object)fx).name : "null") + " has no Effect");
			}
			Util.Set(obj, "m_destroyAfterTime", destroyAfter);
			Util.Set(obj, "m_destroyOnAnimEnd", destroyOnAnimEnd);
		}

		public static void SetNullifyable(GameObject fx, bool on)
		{
			DamageEffect obj = (((Object)(object)fx != (Object)null) ? fx.GetComponent<DamageEffect>() : null);
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException((((Object)(object)fx != (Object)null) ? ((Object)fx).name : "null") + " has no DamageEffect");
			}
			Util.Set(obj, "m_nullifyable", on);
		}

		public static DamageEffectData EffectData(GameObject obj, bool attach, float offsetX, float offsetY)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0039: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			return new DamageEffectData
			{
				m_object = obj,
				m_attach = attach,
				m_detatchOnAnimEnd = false,
				m_destroyOnAnimEnd = attach,
				m_offsetX = new MinMaxRange(offsetX),
				m_offsetY = new MinMaxRange(offsetY),
				m_rotateOffsetX = true,
				m_spawnPoint = (eSpawnPoint)0
			};
		}

		public static AttackData Attack(exSpriteAnimClip clip, float cooldown, float botInner, float botOuter)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_005c: Expected O, but got Unknown
			return new AttackData
			{
				m_animationFront = clip,
				m_sound = null,
				m_cooldown = cooldown,
				m_moveInputRatioMin = 0f,
				m_moveInputRatioMax = 0f,
				m_pushOnContact = 0f,
				m_stopOnContact = false,
				m_botData = new BotAttackData
				{
					m_rangeInner = botInner,
					m_rangeOuter = botOuter
				}
			};
		}

		public static GameObject SpawnOwned(GameObject fxPrefab, Vector2 world, float angleDeg, GameObject owner, bool bossDamage = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			if ((Object)(object)fxPrefab == (Object)null)
			{
				return null;
			}
			try
			{
				GameObject val = ExtentionsMethodsPool.SpawnBegin(fxPrefab, new Vector3(world.x, world.y, 0f), Quaternion.Euler(0f, 0f, angleDeg));
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				ValueModifierStack val2 = null;
				if (bossDamage)
				{
					val2 = Util.BossStack(SystemBalance.BossDamageMultiplier);
				}
				val.SendMessage(Constants.MSG_SETSPAWNER, (object)new DamageSource(val, owner, (PlayerData)null, -1, -1, val2, false), (SendMessageOptions)1);
				ExtentionsMethodsPool.SpawnFinalize(val);
				return val;
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("spawn owned " + ((Object)fxPrefab).name, e);
				return null;
			}
		}

		public static GameObject SpawnFx(GameObject prefab, Vector2 world, float angleDeg = 0f)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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)
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			try
			{
				return ExtentionsMethodsPool.Spawn(prefab, new Vector3(world.x, world.y, 0f), Quaternion.Euler(0f, 0f, angleDeg));
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("fx " + ((Object)prefab).name, e);
				return null;
			}
		}
	}
	public sealed class BossBar : MonoBehaviour
	{
		public const float Z = -100f;

		public const float HalfHeight = 3.5f;

		private static readonly FieldInfo s_showTimer = typeof(GUIHealthBar).GetField("m_showTimer", BindingFlags.Instance | BindingFlags.NonPublic);

		public static GameObject Template { get; private set; }

		public GUIHealthBar Gui { get; private set; }

		public float BottomWorld => ((Component)this).transform.position.y - 3.5f;

		internal static void BuildTemplate(Transform holder)
		{
			try
			{
				GameObject val = Util.Prefab("BossHydra");
				Transform val2 = (((Object)(object)val != (Object)null) ? val.transform.Find("GUIHealthBar") : null);
				if ((Object)(object)val2 == (Object)null || (Object)(object)((Component)val2).GetComponent<GUIHealthBar>() == (Object)null)
				{
					throw new InvalidOperationException("BossHydra has no GUIHealthBar child");
				}
				GameObject obj = KitTemplates.CloneObject(((Component)val2).gameObject, "KitBossBar", holder);
				GUIHealthBar component = obj.GetComponent<GUIHealthBar>();
				component.m_health = null;
				if ((Object)(object)component.m_container != (Object)null)
				{
					component.m_container.SetActive(false);
				}
				Template = obj;
			}
			catch (Exception ex)
			{
				Template = null;
				Kit.Log.Warn("No top boss bar for kit bosses, they keep the bar over their heads: " + ex.Message);
			}
		}

		public static BossBar Spawn(KitBoss owner, Health health, Vector2 roomLocal)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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_00a5: 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_00b2: 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)
			if ((Object)(object)Template == (Object)null || (Object)(object)owner == (Object)null || (Object)(object)health == (Object)null)
			{
				return null;
			}
			try
			{
				GameObject obj = Object.Instantiate<GameObject>(Template);
				((Object)obj).name = ((owner.Ctx != null) ? (owner.Ctx.Info.TemplateName + "Bar") : "KitBossBar");
				obj.transform.SetParent(((Component)owner).transform, false);
				Vector3 val = (((Object)(object)owner.Arena != (Object)null) ? ((Component)owner.Arena).transform.position : ((Component)owner).transform.position);
				obj.transform.position = new Vector3(val.x + roomLocal.x, val.y + roomLocal.y, -100f);
				GUIHealthBar component = obj.GetComponent<GUIHealthBar>();
				component.SetHealthComponent(health);
				BossBar bossBar = obj.AddComponent<BossBar>();
				bossBar.Gui = component;
				Player component2 = ((Component)health).GetComponent<Player>();
				GUIHealthBar val2 = (((Object)(object)component2 != (Object)null) ? component2.GetGUIHealthBar() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetForceHidden(true);
				}
				return bossBar;
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss bar", e);
				return null;
			}
		}

		public void KeepLit()
		{
			if (!((Object)(object)Gui == (Object)null) && (object)s_showTimer != null)
			{
				s_showTimer.SetValue(Gui, Gui.m_showTime + 0.1f);
			}
		}

		public void Hide()
		{
			if ((Object)(object)Gui != (Object)null)
			{
				Gui.SetForceHidden(true);
			}
		}
	}
	public enum HitVerdict
	{
		Allow,
		Cancel
	}
	public delegate HitVerdict HitFilter(Health health, DamageInfo info, bool hitFriendly);
	public static class KitHealth
	{
		private static readonly Dictionary<int, HitFilter> s_filters = new Dictionary<int, HitFilter>();

		internal static bool HasFilters => s_filters.Count > 0;

		public static void SetFilter(Health health, HitFilter filter)
		{
			if (!((Object)(object)health == (Object)null))
			{
				if (filter == null)
				{
					ClearFilter(health);
				}
				else
				{
					s_filters[((Object)health).GetInstanceID()] = filter;
				}
			}
		}

		public static void ClearFilter(Health health)
		{
			if ((Object)(object)health != (Object)null)
			{
				s_filters.Remove(((Object)health).GetInstanceID());
			}
		}

		internal static HitFilter FilterOf(Health health)
		{
			if (!((Object)(object)health != (Object)null) || !s_filters.TryGetValue(((Object)health).GetInstanceID(), out var value))
			{
				return null;
			}
			return value;
		}

		public static bool IsHeroHit(DamageInfo info)
		{
			if (info == null || info.m_source == null || (Object)(object)info.m_source.m_sourceOwnerPlayer == (Object)null)
			{
				return false;
			}
			PlayerData heroPlayerData = SystemLevel.GetHeroPlayerData();
			if (heroPlayerData != null && (Object)(object)heroPlayerData.GameObject != (Object)null)
			{
				return (Object)(object)heroPlayerData.GameObject == (Object)(object)info.m_source.m_sourceOwnerPlayer;
			}
			return false;
		}

		public static Health AddHealth(GameObject inactiveGo, float max, eAllowedDamageSource allowed, bool flashOnHit = true, float spawnInvulnerable = 0f)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)inactiveGo == (Object)null)
			{
				throw new ArgumentNullException("inactiveGo");
			}
			if (inactiveGo.activeInHierarchy)
			{
				throw new InvalidOperationException("AddHealth needs an inactive object: Health.Awake copies m_healthMax at once");
			}
			Health val = inactiveGo.GetComponent<Health>();
			if ((Object)(object)val == (Object)null)
			{
				val = inactiveGo.AddComponent<Health>();
			}
			Util.Set(val, "m_healthMax", max);
			Util.Set(val, "m_allowedDamageSource", allowed);
			Util.Set(val, "m_flashOnHit", flashOnHit);
			Util.Set(val, "m_spawnInvulnerableTime", spawnInvulnerable);
			Util.Set(val, "m_damageResistance", 1f);
			Util.Set(val, "m_vulnerableState", string.Empty);
			return val;
		}
	}
	public sealed class Hittable : MonoBehaviour
	{
		private Action<Hittable, DamageInfo> m_onHit;

		private bool m_immortal;

		private float m_lastHit = -100f;

		public float MinGap;

		public Health Health { get; private set; }

		public BoxCollider Collider { get; private set; }

		public bool FlashOnHit
		{
			get
			{
				if ((Object)(object)Health != (Object)null)
				{
					return Util.Get<bool>(Health, "m_flashOnHit");
				}
				return false;
			}
			set
			{
				if ((Object)(object)Health != (Object)null)
				{
					Util.Set(Health, "m_flashOnHit", value);
				}
			}
		}

		public static Hittable Create(Transform parent, string name, Vector3 world, Vector2 size, eAllowedDamageSource allowed, Action<Hittable, DamageInfo> onHit, bool immortal = true, int layer = 25, float mortalMax = 1f)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.SetActive(false);
			val.layer = layer;
			if ((Object)(object)parent != (Object)null)
			{
				val.transform.SetParent(parent, false);
			}
			val.transform.position = new Vector3(world.x, world.y, 0f);
			BoxCollider val2 = val.AddComponent<BoxCollider>();
			((Collider)val2).isTrigger = false;
			val2.size = new Vector3(size.x, size.y, 50f);
			Rigidbody obj = val.AddComponent<Rigidbody>();
			obj.isKinematic = true;
			obj.useGravity = false;
			Health health = KitHealth.AddHealth(val, immortal ? 10000f : Mathf.Max(0.01f, mortalMax), allowed);
			Hittable hittable = val.AddComponent<Hittable>();
			hittable.m_onHit = onHit;
			hittable.m_immortal = immortal;
			hittable.Health = health;
			hittable.Collider = val2;
			val.SetActive(true);
			return hittable;
		}

		public void SetActive(bool on)
		{
			((Component)this).gameObject.SetActive(on);
		}

		private void OnDamaged(DamageInfo info)
		{
			Count(info);
			if (m_immortal && (Object)(object)Health != (Object)null && Health.IsAlive())
			{
				Health.Heal(Health.GetHealthMax());
			}
		}

		private void OnKilled(DamageInfo info)
		{
			Count(info);
		}

		private void Count(DamageInfo info)
		{
			if (info == null || info.m_isDamageFromStatus || m_onHit == null || Time.time - m_lastHit < MinGap)
			{
				return;
			}
			m_lastHit = Time.time;
			try
			{
				m_onHit(this, info);
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("hittable " + ((Object)this).name, e);
			}
		}
	}
	public abstract class KitBoss : Boss
	{
		private BossContext m_ctx;

		private Room m_room;

		private KitBody m_life;

		private BossBar m_bar;

		private int m_phase = 1;

		private bool m_spawned;

		private bool m_lifeWasSpawned;

		private bool m_introDone;

		private bool m_frozen;

		private bool m_killed;

		private bool m_arenaFailed;

		private bool m_inBuildArena;

		private bool m_noLife;

		private bool m_enterDone;

		private float m_introClock;

		private const float EnterTimeout = 3f;

		private readonly List<KitStation> m_stations = new List<KitStation>();

		private readonly List<GameObject> m_roots = new List<GameObject>();

		private readonly List<int> m_kept = new List<int>();

		private float[] m_thresholds;

		private static readonly FieldInfo s_waitSeconds = typeof(WaitForSeconds).GetField("m_Seconds", BindingFlags.Instance | BindingFlags.NonPublic);

		protected virtual float[] PhaseThresholds => new float[2]
		{
			2f / 3f,
			1f / 3f
		};

		protected virtual Vector2 BarLocal => new Vector2(0f, 98f);

		protected virtual float IntroMinimum => 0.35f;

		public Room Arena => m_room;

		public BossContext Ctx => m_ctx;

		public KitBody LifeBody => m_life;

		public Health LifeHealth
		{
			get
			{
				if (!((Object)(object)m_life != (Object)null))
				{
					return null;
				}
				return m_life.Health;
			}
		}

		public BossBar Bar => m_bar;

		public int Phase => m_phase;

		public bool Fighting
		{
			get
			{
				if (m_introDone && !m_frozen && !base.m_won)
				{
					return !m_killed;
				}
				return false;
			}
		}

		public bool Frozen => m_frozen;

		public bool Killed => m_killed;

		public bool Won => base.m_won;

		public bool ArenaFailed => m_arenaFailed;

		public IList<KitStation> Stations => m_stations.AsReadOnly();

		public float UnpausedTime { get; private set; }

		public float PromptCeilingWorld
		{
			get
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				if ((Object)(object)m_bar != (Object)null)
				{
					return m_bar.BottomWorld - 6f;
				}
				float num = (((Object)(object)m_room != (Object)null) ? ((Component)m_room).transform.position.y : ((Component)this).transform.position.y);
				float yMax;
				if (!((Object)(object)m_room != (Object)null))
				{
					Rect cameraBounds = KitArena.CameraBounds;
					yMax = ((Rect)(ref cameraBounds)).yMax;
				}
				else
				{
					yMax = ((Rect)(ref m_room.m_cameraBounds)).yMax;
				}
				return num + yMax - 8f;
			}
		}

		public event Action<int> PhaseChanged;

		public static void Configure(KitBoss b)
		{
			if ((Object)(object)b == (Object)null)
			{
				throw new ArgumentNullException("b");
			}
			BossContext bossContext = Kit.ContextOf(((object)b).GetType());
			if (bossContext == null)
			{
				throw new InvalidOperationException(((object)b).GetType().Name + " is not a registered boss type");
			}
			Configure(b, bossContext);
		}

		internal static void Configure(KitBoss b, BossContext ctx)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ctx.ArenaTemplate == (Object)null)
			{
				throw new InvalidOperationException(ctx.Info.TemplateName + " has no arena template");
			}
			b.m_ctx = ctx;
			Util.Set(b, "m_displayName", ctx.Info.DisplayName);
			Util.Set(b, "m_bossUnleashedSceneName", "SceneMenuLose");
			Util.Set(b, "m_bossRoom", ctx.ArenaTemplate);
			Util.Set(b, "m_entryRoom", HydraConfig.EntryRoom);
			Util.Set(b, "m_bossPosition", ctx.BossPositionLocal);
			Util.Set(b, "m_entryRoomProps", HydraConfig.EntryRoomProps);
			Util.Set(b, "m_bossRoomProps", null);
			Util.Set(b, "m_playerEntryRoomOffset", HydraConfig.PlayerEntryRoomOffset);
			Util.Set(b, "m_heroWinPauseTime", 4.3f);
			Util.Set(b, "m_heroWinRunAroundTime", 6.25f);
			Util.Set(b, "m_roomDoorSealPrefab", HydraConfig.DoorSeal);
			Util.Set(b, "m_minPlayersRequired", 0);
			Util.Set(b, "m_heroWinEffect", HydraConfig.HeroWinEffect);
			Util.Set(b, "m_heroWinEffectDelay", HydraConfig.HeroWinEffectDelay);
			Util.Set(b, "m_bossWinEffect", HydraConfig.BossWinEffect);
			Util.Set(b, "m_bossWinEffectDelay", HydraConfig.BossWinEffectDelay);
			Util.Set(b, "m_musicBossOverride", null);
		}

		internal float[] ThresholdsSorted()
		{
			if (m_thresholds != null)
			{
				return m_thresholds;
			}
			float[] source = PhaseThresholds ?? new float[0];
			m_thresholds = (from x in source.Where((float x) => x > 0f && x < 1f).Distinct()
				orderby x descending
				select x).ToArray();
			return m_thresholds;
		}

		internal static float SmallestGap(float[] sortedDesc)
		{
			float num = 1f;
			float num2 = 1f;
			foreach (float num3 in sortedDesc)
			{
				num = Mathf.Min(num, num2 - num3);
				num2 = num3;
			}
			return Mathf.Min(num, num2);
		}

		protected abstract void BuildArena(Room room);

		protected abstract KitBody SpawnBodies(Room room);

		protected virtual IEnumerator Intro()
		{
			yield return WaitGameTime(2f);
		}

		protected virtual void OnFightStart()
		{
		}

		protected virtual void OnPhase(int phase)
		{
		}

		protected virtual void OnBossDying(DamageInfo info)
		{
		}

		protected virtual void OnHeroKilledKit(Player hero)
		{
		}

		protected virtual void OnFrozen(bool frozen)
		{
		}

		protected virtual void KitUpdate()
		{
		}

		protected virtual void KitLateUpdate()
		{
		}

		protected virtual void KitFixedUpdate()
		{
		}

		protected virtual void OnCleanup()
		{
		}

		private void Awake()
		{
			try
			{
				BossContext bossContext = (m_ctx = Kit.ContextOf(((object)this).GetType()));
				if (bossContext != null && (Object)(object)bossContext.ArenaTemplate != (Object)null)
				{
					Configure(this, bossContext);
				}
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss configure " + ((object)this).GetType().Name, e);
			}
		}

		private void Start()
		{
			if ((Object)(object)((Component)this).transform.parent == (Object)null || m_ctx == null || !m_ctx.Ready)
			{
				return;
			}
			m_room = ((Component)((Component)this).transform.parent).GetComponent<Room>();
			if ((Object)(object)m_room == (Object)null)
			{
				m_ctx.Log.Warn("The boss controller is not under a room");
				return;
			}
			KitRoom.RegisterArena(m_room);
			m_ctx.ApplyBossDamage();
			m_inBuildArena = true;
			try
			{
				BuildArena(m_room);
				m_ctx.Log.Info("Arena built (" + m_stations.Count + " stations)");
				KitSelfTest.Note("arena built");
			}
			catch (Exception ex)
			{
				m_arenaFailed = true;
				m_ctx.Log.Error("Arena build failed: " + ex);
				KitSelfTest.Note("arena build failed: " + ex.Message);
			}
			finally
			{
				m_inBuildArena = false;
			}
			KitRoom.MarkPathfinderDirty(m_room);
		}

		private void Update()
		{
			UnpausedTime += Time.deltaTime;
			if ((Object)(object)m_room == (Object)null || !m_spawned)
			{
				return;
			}
			if (!m_introDone)
			{
				m_introClock += Time.deltaTime;
			}
			try
			{
				if ((Object)(object)m_bar != (Object)null && Fighting && (Object)(object)m_life != (Object)null && m_life.Alive)
				{
					m_bar.KeepLit();
				}
				if (!m_killed && m_lifeWasSpawned)
				{
					if ((Object)(object)m_life == (Object)null)
					{
						m_ctx.Log.Error("The life body was removed without dying; the boss counts as killed so the run can go on");
						Win();
					}
					else if ((Object)(object)m_life.Health != (Object)null && !m_life.Health.IsAlive())
					{
						Win();
					}
					else
					{
						CheckPhase();
					}
				}
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss update " + ((object)this).GetType().Name, e);
			}
			try
			{
				KitUpdate();
			}
			catch (Exception e2)
			{
				Kit.Log.WarnOnce("boss KitUpdate " + ((object)this).GetType().Name, e2);
			}
		}

		private void FixedUpdate()
		{
			if ((Object)(object)m_room == (Object)null || !m_spawned)
			{
				return;
			}
			try
			{
				KitFixedUpdate();
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss KitFixedUpdate " + ((object)this).GetType().Name, e);
			}
		}

		private void LateUpdate()
		{
			if ((Object)(object)m_room == (Object)null)
			{
				return;
			}
			try
			{
				KitLateUpdate();
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss KitLateUpdate " + ((object)this).GetType().Name, e);
			}
		}

		private void OnDestroy()
		{
			try
			{
				if ((Object)(object)m_room != (Object)null)
				{
					KitRoom.UnregisterArena(m_room);
				}
				foreach (KitStation station in m_stations)
				{
					if ((Object)(object)station != (Object)null)
					{
						KitStations.Unregister(station);
					}
				}
				foreach (GameObject root in m_roots)
				{
					if ((Object)(object)root == (Object)null)
					{
						continue;
					}
					try
					{
						KitBody component = root.GetComponent<KitBody>();
						if ((Object)(object)component == (Object)null || component.Alive)
						{
							ExtentionsMethodsPool.Despawn(root);
						}
					}
					catch (Exception e)
					{
						Kit.Log.WarnOnce("despawn root " + ((Object)root).name, e);
					}
				}
				m_roots.Clear();
				foreach (int item in m_kept)
				{
					if (KitBodies.KeptInRoom.TryGetValue(item, out var value) && ((Object)(object)value == (Object)(object)this || (Object)(object)value == (Object)null))
					{
						KitBodies.KeptInRoom.Remove(item);
					}
				}
				m_kept.Clear();
			}
			catch (Exception e2)
			{
				Kit.Log.WarnOnce("boss destroy", e2);
			}
			try
			{
				OnCleanup();
			}
			catch (Exception e3)
			{
				Kit.Log.WarnOnce("boss OnCleanup " + ((object)this).GetType().Name, e3);
			}
		}

		public sealed override void OnEnterBossRoom()
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (SystemLevel.GetHeroPlayerData() == null || (Object)(object)SystemLevel.GetHeroObject() == (Object)null || (Object)(object)m_room == (Object)null)
			{
				return;
			}
			((Boss)this).OnEnterBossRoom();
			if (!m_spawned)
			{
				m_spawned = true;
				try
				{
					m_life = SpawnBodies(m_room);
				}
				catch (Exception ex)
				{
					m_life = null;
					m_ctx.Log.Error("SpawnBodies failed: " + ex);
				}
				if ((Object)(object)m_life != (Object)null)
				{
					m_life.IsLife = true;
					m_lifeWasSpawned = true;
					m_life.Damaged += OnLifeDamaged;
					m_life.Died += OnLifeDied;
					CheckLifeCap();
					m_bar = BossBar.Spawn(this, m_life.Health, BarLocal);
				}
				else
				{
					m_noLife = true;
					m_ctx.Log.Error("No life body: the fight is forfeited after the intro so the run can go on");
				}
				((MonoBehaviour)this).StartCoroutine(IntroRunner());
				return;
			}
			m_frozen = false;
			try
			{
				OnFrozen(frozen: false);
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss OnFrozen", e);
			}
		}

		public sealed override void OnExitBossRoom()
		{
			try
			{
				((Boss)this).OnExitBossRoom();
				m_frozen = true;
				OnFrozen(frozen: true);
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss exit room", e);
			}
		}

		public sealed override void OnHeroKilled(Player killed, DamageInfo damage)
		{
			((Boss)this).OnHeroKilled(killed, damage);
			try
			{
				((Boss)this).StopKillingBlowEffects(killed, damage);
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("stop killing blow", e);
			}
			try
			{
				if ((Object)(object)m_life != (Object)null && m_life.Alive)
				{
					m_life.Health.StartInvincibility("WON");
				}
				SetStationsSuspended(suspended: true);
				OnHeroKilledKit(killed);
			}
			catch (Exception e2)
			{
				Kit.Log.WarnOnce("boss hero killed", e2);
			}
			KitSelfTest.Note("hero killed");
		}

		private IEnumerator EnterSequenceTracked()
		{
			yield return ((MonoBehaviour)this).StartCoroutine(((Boss)this).CoroutineHeroEnterSequence());
			m_enterDone = true;
		}

		public static IEnumerator WaitGameTime(float seconds)
		{
			float left = seconds;
			while (left > 0f)
			{
				yield return null;
				if (!SystemTime.Paused)
				{
					left -= Time.deltaTime;
				}
			}
		}

		private static bool TryReadSeconds(WaitForSeconds w, out float seconds)
		{
			seconds = 0f;
			if (w == null || (object)s_waitSeconds == null)
			{
				return false;
			}
			try
			{
				seconds = (float)s_waitSeconds.GetValue(w);
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private IEnumerator IntroRunner()
		{
			m_introClock = 0f;
			m_enterDone = false;
			((MonoBehaviour)this).StartCoroutine(EnterSequenceTracked());
			Stack<IEnumerator> stack = new Stack<IEnumerator>();
			try
			{
				IEnumerator enumerator = (m_noLife ? null : Intro());
				if (enumerator != null)
				{
					stack.Push(enumerator);
				}
			}
			catch (Exception ex)
			{
				m_ctx.Log.Error("Intro failed: " + ex);
			}
			while (stack.Count > 0)
			{
				if (SystemTime.Paused)
				{
					yield return null;
					continue;
				}
				object current;
				try
				{
					IEnumerator enumerator2 = stack.Peek();
					if (!enumerator2.MoveNext())
					{
						stack.Pop();
						continue;
					}
					current = enumerator2.Current;
				}
				catch (Exception ex2)
				{
					m_ctx.Log.Error("Intro failed, the fight starts now: " + ex2);
					stack.Clear();
					break;
				}
				if (current is IEnumerator item)
				{
					stack.Push(item);
					continue;
				}
				WaitForSeconds val = (WaitForSeconds)((current is WaitForSeconds) ? current : null);
				if (val != null && TryReadSeconds(val, out var seconds))
				{
					stack.Push(WaitGameTime(seconds));
				}
				else
				{
					yield return current;
				}
			}
			while (m_introClock < IntroMinimum || (!m_enterDone && m_introClock < IntroMinimum + 3f))
			{
				yield return null;
			}
			if (!m_enterDone)
			{
				m_ctx.Log.Warn("The game's hero enter sequence did not finish within " + 3f + " s of unpaused time; the fight starts anyway");
			}
			try
			{
				((Boss)this).OnSpawnComplete();
			}
			catch (Exception ex3)
			{
				m_ctx.Log.Error("OnSpawnComplete failed: " + ex3);
			}
			m_introDone = true;
			if (m_noLife)
			{
				Win();
				yield break;
			}
			if (!base.m_won && !m_killed)
			{
				try
				{
					if ((Object)(object)m_bar != (Object)null && (Object)(object)m_bar.Gui != (Object)null)
					{
						m_bar.Gui.Show(false);
					}
					else if ((Object)(object)m_life != (Object)null && (Object)(object)m_life.Player != (Object)null && (Object)(object)m_life.Player.GetGUIHealthBar() != (Object)null)
					{
						m_life.Player.GetGUIHealthBar().Show(false);
					}
				}
				catch (Exception e)
				{
					Kit.Log.WarnOnce("bar show", e);
				}
				try
				{
					OnFightStart();
				}
				catch (Exception ex4)
				{
					m_ctx.Log.Error("OnFightStart failed: " + ex4);
				}
			}
			KitSelfTest.Note("fight started");
		}

		private void OnLifeDamaged(DamageInfo info)
		{
			CheckPhase();
		}

		private void OnLifeDied(DamageInfo info)
		{
			Win(info);
		}

		private void CheckPhase()
		{
			if (m_killed || (Object)(object)m_life == (Object)null || (Object)(object)m_life.Health == (Object)null || !m_life.Health.IsAlive())
			{
				return;
			}
			float healthRatio = m_life.Health.GetHealthRatio();
			float[] array = ThresholdsSorted();
			int num = 1;
			float[] array2 = array;
			foreach (float num2 in array2)
			{
				if (healthRatio <= num2)
				{
					num++;
				}
			}
			while (m_phase < num && !m_killed)
			{
				m_phase++;
				foreach (KitStation station in m_stations)
				{
					if ((Object)(object)station == (Object)null)
					{
						continue;
					}
					try
					{
						if (station.Spec.RetirePhase > 0 && station.Spec.RetirePhase <= m_phase)
						{
							station.Retire();
						}
						else if (station.Dormant && !station.Spec.WakeByBoss && station.Spec.WakePhase == m_phase && (!station.IsFollower || station.Group == null || !station.Group.Seat.Dormant))
						{
							station.SetDormant(dormant: false);
						}
					}
					catch (Exception e)
					{
						Kit.Log.WarnOnce("phase stations", e);
					}
				}
				KitRoom.MarkPathfinderDirty(m_room);
				KitSelfTest.Note("phase " + m_phase);
				try
				{
					OnPhase(m_phase);
				}
				catch (Exception ex)
				{
					m_ctx.Log.Error("OnPhase(" + m_phase + ") failed: " + ex);
				}
				Action<int> action = this.PhaseChanged;
				if (action != null)
				{
					try
					{
						action(m_phase);
					}
					catch (Exception e2)
					{
						Kit.Log.WarnOnce("PhaseChanged", e2);
					}
				}
			}
		}

		private void CheckLifeCap()
		{
			try
			{
				float[] array = ThresholdsSorted();
				if (array.Length != 0 && m_life.Spec != null)
				{
					float num = SmallestGap(array) * m_life.Spec.HealthMax;
					if (m_life.Spec.MaxDamagePerHit <= 0f || m_life.Spec.MaxDamagePerHit >= num)
					{
						m_ctx.Log.Error("The life body's MaxDamagePerHit (" + m_life.Spec.MaxDamagePerHit + ") is not below the smallest phase gap (" + num + "): one hit can skip a phase");
					}
				}
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("life cap check", e);
			}
		}

		public void Win(DamageInfo info = null)
		{
			if (m_killed)
			{
				return;
			}
			m_killed = true;
			try
			{
				foreach (KitStation station in m_stations)
				{
					if ((Object)(object)station != (Object)null)
					{
						station.ShutDown();
					}
				}
				OnBossDying(info);
			}
			catch (Exception e)
			{
				Kit.Log.WarnOnce("boss dying " + ((object)this).GetType().Name, e);
			}
			finally
			{
				Singleton<SystemLevel>.Get.OnBossKilled();
			}
			KitSelfTest.Note("boss killed");
		}

		public KitStation SpawnStation(GameObject template, Vector2 roomLocal, StationSpec spec)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!m_inBuildArena)
			{
				throw new InvalidOperationException("SpawnStation is only valid inside BuildArena (bot caches)");
			}
			if ((Object)(object)template == (Object)null)
			{
				throw new ArgumentNullException("template");
			}
			GameObject val = m_room.SpawnInRoom(template, World(roomLocal));
			if ((Object)(object)val == (Object)null)
			{
				throw new InvalidOperationException("spawning station " + ((Object)template).name + " failed");
			}
			KitRoom.MatchHidden(m_room, val);
			KitStation kitStation = val.AddComponent<KitStation>();
			kitStation.Init(this, spec ?? new StationSpec());
			m_stations.Add(kitStation);
			if (kitStation.Spec.WakePhase > 1)
			{
				kitStation.SetDormant(dormant: true);
			}
			return kitStation;
		}

		public StationGroup CreateGroup(KitStation seat, IList<KitStation> followers, GroupMode mode)
		{
			return new StationGroup(this, seat, followers, mode);
		}

		public void SetStationsSuspended(bool suspended)
		{
			if (!suspended && base.m_won)
			{
				Kit.Log.Info("stations stay suspended: the hero is dead (end of a beat after the hero died)");
				return;
			}
			foreach (KitStation station in m_stations)
			{
				if ((Object)(object)station != (Object)null)
				{
					station.SetArenaSuspended(suspended);
				}
			}
		}

		public void WakeStations(int phase)
		{
			for (int i = 0; i < 2; i++)
			{
				bool flag = i == 1;
				foreach (KitStation station in m_stations)
				{
					if ((Object)(object)station == (Object)null || station.IsFollower != flag)
					{
						continue;
					}
					try
					{
						if (station.Dormant && !station.Retired && station.Spec.WakePhase <= phase && (!station.IsFollower || station.Group == null || !station.Group.Seat.Dormant))
						{
							station.SetDormant(dormant: false);
						}
					}
					catch (Exception e)
					{
						Kit.Log.WarnOnce("wake stations", e);
					}
				}
			}
			KitRoom.MarkPathfinderDirty(m_room);
		}

		public void KeepInRoom(Player player, bool keep = true)
		{
			if ((Object)(object)player == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)player).GetInstanceID();
			if (keep)
			{
				KitBodies.KeptInRoom[instanceID] = this;
				if (!m_kept.Contains(instanceID))
				{
					m_kept.Add(instanceID);
				}
			}
			else
			{
				if (KitBodies.KeptInRoom.TryGetValue(instanceID, out var value) && ((Object)(object)value == (Object)(object)this || (Object)(object)value == (Object)null))
				{
					KitBodies.KeptInRoom.Remove(instanceID);
				}
				m_kept.Remove(instanceID);
			}
		}

		public void TrackRoot(GameObject go)
		{
			if ((Object)(object)go != (Object)null && !m_roots.Contains(go))
			{
				m_roots.Add(go);
			}
		}

		public Vector2 RoomLocal(Vector3 world)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)m_room != (Object)null))
			{
				return Vector2.op_Implicit(world - ((Component)this).transform.position);
			}
			return KitRoom.Local(m_room, world);
		}

		public Vector3 World(Vector2 roomLocal)
		{
			//IL_0021: Unknown result type (might be due to inval