using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using GlobalSettings;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using InControl;
using KIS;
using KIS.Utils;
using Knight;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMProOld;
using TeamCherry.Localization;
using ToJ;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyCompany("KIS")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.5.1.0")]
[assembly: AssemblyInformationalVersion("0.5.1+64444ccf756cfccbb45ca7f2199248fc167ee372")]
[assembly: AssemblyProduct("KIS")]
[assembly: AssemblyTitle("KnightInSilkSong")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class SendDreamImpact : FsmStateAction
{
	public FsmOwnerDefault target = new FsmOwnerDefault
	{
		ownerOption = (OwnerDefaultOption)1
	};

	private NeedolinTextOwner needolinTextOwner;

	public DreamHelper dreamHelper = ((Component)HeroController.instance).GetComponent<DreamHelper>();

	public override void Reset()
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Expected O, but got Unknown
		((FsmStateAction)this).Reset();
		target = new FsmOwnerDefault();
	}

	public override void OnEnter()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		((FsmStateAction)this).OnEnter();
		target.ownerOption = (OwnerDefaultOption)1;
		target.gameObject = base.fsm.GetVariable<FsmGameObject>("Collider");
		GameObject safe = FSMUtility.GetSafe(target, (FsmStateAction)(object)this);
		("ONENTER " + (object)safe).LogInfo();
		if ((Object)(object)safe != (Object)null)
		{
			HealthManager component = safe.GetComponent<HealthManager>();
			if ((Object)(object)component != (Object)null)
			{
				safe.LogInfo();
				if (!dreamHelper.Exist(component))
				{
					DoDreamImpact(safe);
					dreamHelper.Add(component);
				}
			}
		}
		((FsmStateAction)this).Finish();
	}

	public void DoDreamImpact(GameObject safe)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Expected O, but got Unknown
		int num = (PlayerData.instance.equippedCharm_30 ? 66 : 33);
		HeroController.instance.AddMPCharge(num);
		Recoil component = safe.GetComponent<Recoil>();
		if ((Object)(object)component != (Object)null)
		{
			bool flag = ((Component)HeroController.instance).transform.localScale.x <= 0f;
			component.RecoilByDirection((!flag) ? 2 : 0, 2f);
		}
		SpriteFlash component2 = safe.GetComponent<SpriteFlash>();
		if ((Object)(object)component2 != (Object)null)
		{
			component2.flashDreamImpact();
		}
		needolinTextOwner = safe.GetComponent<NeedolinTextOwner>();
		if ((Object)(object)needolinTextOwner != (Object)null)
		{
			needolinTextOwner.OnAddText.AddListener(new UnityAction(RemoveText));
			needolinTextOwner.AddNeedolinText();
		}
	}

	private void RemoveText()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		needolinTextOwner.RemoveNeedolinText();
		needolinTextOwner.OnAddText.RemoveListener(new UnityAction(RemoveText));
	}

	public IEnumerator DelayText(NeedolinTextOwner needolinTextOwner)
	{
		if (!((Object)(object)needolinTextOwner == (Object)null))
		{
			needolinTextOwner.AddNeedolinText();
			yield return (object)new WaitForSeconds(0.2f);
			NeedolinMsgBox._instance.ClearAllText();
		}
	}
}
public static class GameObjectUtils
{
	public static T GetAddComponent<T>(this GameObject go) where T : Component
	{
		T val = go.GetComponent<T>();
		if ((Object)(object)val == (Object)null)
		{
			val = go.AddComponent<T>();
		}
		return val;
	}

	public static bool RemoveComponent<T>(this GameObject go) where T : Component
	{
		T component = go.GetComponent<T>();
		if ((Object)(object)component != (Object)null)
		{
			Object.DestroyImmediate((Object)(object)component);
			return true;
		}
		return false;
	}

	public static T copyComponent<T>(this GameObject to, GameObject from) where T : Component
	{
		if ((Object)(object)from == (Object)null)
		{
			return default(T);
		}
		T component = from.GetComponent<T>();
		T addComponent = to.GetAddComponent<T>();
		if ((Object)(object)component == (Object)null)
		{
			return default(T);
		}
		FieldInfo[] fields = typeof(T).GetFields(BindingFlags.IgnoreCase | BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod | BindingFlags.CreateInstance | BindingFlags.GetField | BindingFlags.SetField | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty | BindingFlags.ExactBinding | BindingFlags.SuppressChangeType | BindingFlags.OptionalParamBinding | BindingFlags.IgnoreReturn);
		FieldInfo[] array = fields;
		foreach (FieldInfo fieldInfo in array)
		{
			fieldInfo.SetValue(addComponent, fieldInfo.GetValue(component));
		}
		return addComponent;
	}

	public static void SetScale(this GameObject gameObject, float scaleX, float scaleY)
	{
		//IL_0007: 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_0023: Unknown result type (might be due to invalid IL or missing references)
		Vector3 localScale = gameObject.transform.localScale;
		localScale.x = scaleX;
		localScale.y = scaleY;
		gameObject.transform.localScale = localScale;
	}

	public static GameObject FindGameObjectInChildren(this GameObject gameObject, string name, bool useBaseName = false)
	{
		if ((Object)(object)gameObject == (Object)null)
		{
			return null;
		}
		Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>(true);
		Transform[] array = componentsInChildren;
		foreach (Transform val in array)
		{
			if (val.GetName(useBaseName) == name)
			{
				return ((Component)val).gameObject;
			}
		}
		return null;
	}

	public static List<GameObject> FindGameObjectsInChildren(this GameObject gameObject, string name, bool useBaseName = false)
	{
		if ((Object)(object)gameObject == (Object)null)
		{
			return null;
		}
		List<GameObject> list = new List<GameObject>();
		Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>(true);
		Transform[] array = componentsInChildren;
		foreach (Transform val in array)
		{
			if (val.GetName(useBaseName) == name)
			{
				list.Add(((Component)val).gameObject);
			}
		}
		return list;
	}

	public static void Log(this GameObject gameObject)
	{
		//IL_0068: 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_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)gameObject == (Object)null)
		{
			return;
		}
		KnightInSilksong.logger.LogInfo((object)((Object)gameObject).GetName());
		KnightInSilksong.logger.LogInfo((object)gameObject.GetPath());
		KnightInSilksong.logger.LogInfo((object)("Layer : " + gameObject.layer));
		ManualLogSource logger = KnightInSilksong.logger;
		Vector3 val = gameObject.transform.position;
		logger.LogInfo((object)("Position : " + ((object)(Vector3)(ref val)).ToString()));
		ManualLogSource logger2 = KnightInSilksong.logger;
		Quaternion rotation = gameObject.transform.rotation;
		logger2.LogInfo((object)("Rotation : " + ((object)(Quaternion)(ref rotation)).ToString()));
		ManualLogSource logger3 = KnightInSilksong.logger;
		val = gameObject.transform.localScale;
		logger3.LogInfo((object)("Scale : " + ((object)(Vector3)(ref val)).ToString()));
		Component[] components = gameObject.GetComponents<Component>();
		Component[] array = components;
		foreach (Component val2 in array)
		{
			KnightInSilksong.logger.LogInfo((object)("Component : " + ((object)val2).GetType()));
			if (val2 is PlayMakerFSM)
			{
				KnightInSilksong.logger.LogInfo((object)("---- Fsm name :" + ((PlayMakerFSM)((val2 is PlayMakerFSM) ? val2 : null)).FsmName));
			}
		}
	}

	public static void LogWithChildren(this GameObject gameObject)
	{
		if (!((Object)(object)gameObject == (Object)null))
		{
			gameObject.Log();
			Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				((Component)componentsInChildren[i]).gameObject.Log();
			}
		}
	}

	public static void PrintAllActiveGameObjectsInScene()
	{
		GameObject[] array = Object.FindObjectsByType<GameObject>((FindObjectsSortMode)0);
		for (int i = 0; i < array.Length; i++)
		{
			array[i].Log();
		}
	}

	public static GameObject Find(this GameObject go, string name)
	{
		for (int i = 0; i < go.transform.childCount; i++)
		{
			GameObject gameObject = ((Component)go.transform.GetChild(i)).gameObject;
			if (((Object)gameObject).name == name)
			{
				return gameObject;
			}
		}
		for (int j = 0; j < go.transform.childCount; j++)
		{
			GameObject val = ((Component)go.transform.GetChild(j)).gameObject.Find(name);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
		}
		return null;
	}

	public static void FindAllChildren(this GameObject go, List<GameObject> allGoList)
	{
		for (int i = 0; i < go.transform.childCount; i++)
		{
			allGoList.Add(((Component)go.transform.GetChild(i)).gameObject);
		}
		for (int j = 0; j < go.transform.childCount; j++)
		{
			((Component)go.transform.GetChild(j)).gameObject.FindAllChildren(allGoList);
		}
	}

	public static void DisableChildren(this GameObject go)
	{
		for (int i = 0; i < go.transform.childCount; i++)
		{
			((Component)go.transform.GetChild(i)).gameObject.SetActive(false);
		}
	}

	public static List<GameObject> GetAllGameObjects(this Scene scene)
	{
		List<GameObject> list = new List<GameObject>();
		GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
		GameObject[] array = rootGameObjects;
		foreach (GameObject val in array)
		{
			list.Add(val);
			val.FindAllChildren(list);
		}
		return list;
	}

	public static GameObject GetGameObjectByName(this Scene scene, string name, bool useBaseName = false)
	{
		GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
		GameObject[] array = rootGameObjects;
		foreach (GameObject val in array)
		{
			if (val.GetName(useBaseName) == name)
			{
				return val;
			}
			GameObject val2 = val.FindGameObjectInChildren(name, useBaseName);
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
		}
		return null;
	}

	public static GameObject[] GetRootGameObjects()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		Scene activeScene = SceneManager.GetActiveScene();
		return ((Scene)(ref activeScene)).GetRootGameObjects();
	}

	public static GameObject GetGameObjectInScene(string name, bool useBaseName = false)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return SceneManager.GetActiveScene().GetGameObjectByName(name, useBaseName);
	}

	public static List<GameObject> GetAllGameObjectsInScene()
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return SceneManager.GetActiveScene().GetAllGameObjects();
	}

	public static string GetName(this Transform transform, bool useBaseName = false)
	{
		return ((Component)transform).gameObject.GetName(useBaseName);
	}

	public static string GetName(this GameObject go, bool useBaseName = false)
	{
		string text = ((Object)go).name;
		if (useBaseName)
		{
			text = text.ToLower();
			text.Replace("(clone)", "");
			text = text.Trim();
			text.Replace("cln", "");
			text = text.Trim();
			text = Regex.Replace(text, "\\([0-9+]+\\)", "");
			text = text.Trim();
			text = Regex.Replace(text, "[0-9+]+$", "");
			text = text.Trim();
			text.Replace("(clone)", "");
			text = text.Trim();
		}
		return text;
	}

	public static string GetPath(this GameObject go, bool useBaseName = false)
	{
		string text = go.GetName(useBaseName);
		GameObject val = go;
		while ((Object)(object)val.transform.parent != (Object)null && (Object)(object)((Component)val.transform.parent).gameObject != (Object)null)
		{
			val = ((Component)val.transform.parent).gameObject;
			text = val.GetName(useBaseName) + "/" + text;
		}
		return text;
	}
}
public static class HelperFun
{
	public static string GetPlayerDataPath()
	{
		return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "PlayerData.json");
	}

	public static void SavePlayerData()
	{
		PlayerData instance = PlayerData.instance;
		if (instance != null)
		{
			string contents = JsonUtility.ToJson((object)instance, true);
			File.WriteAllText(GetPlayerDataPath(), contents);
		}
	}

	public static bool LoadPlayerData()
	{
		string playerDataPath = GetPlayerDataPath();
		if (File.Exists(playerDataPath))
		{
			string text = File.ReadAllText(playerDataPath);
			try
			{
				PlayerData instance = PlayerData.instance;
				JsonUtility.FromJsonOverwrite(text, (object)instance);
				"Load OK".LogInfo();
			}
			catch (Exception msg)
			{
				msg.LogError();
				return false;
			}
			return true;
		}
		return false;
	}

	public static Texture2D LoadTexture(Stream stream)
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Expected O, but got Unknown
		byte[] array = new byte[stream.Length];
		stream.Read(array, 0, array.Length);
		stream.Close();
		Texture2D val = new Texture2D(2, 2);
		if (ImageConversion.LoadImage(val, array))
		{
			return val;
		}
		return null;
	}

	public static Texture2D LoadTexture(string path)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Expected O, but got Unknown
		FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
		byte[] array = new byte[fileStream.Length];
		fileStream.Read(array, 0, array.Length);
		fileStream.Close();
		Texture2D val = new Texture2D(2, 2);
		if (ImageConversion.LoadImage(val, array))
		{
			return val;
		}
		return null;
	}

	public static Component GetComponent(GameObject gameObject, string type)
	{
		return gameObject.GetComponent(type);
	}

	public static Component GetAnyComponent<T1, T2>(this GameObject gameObject) where T1 : Component where T2 : Component
	{
		T1 component = gameObject.GetComponent<T1>();
		if ((Object)(object)component != (Object)null)
		{
			return (Component)(object)component;
		}
		T2 component2 = gameObject.GetComponent<T2>();
		if ((Object)(object)component2 != (Object)null)
		{
			return (Component)(object)component2;
		}
		return null;
	}

	public static Component GetAnotherComponent(this Component monoBehaviour)
	{
		bool flag = false;
		string fullName = ((object)monoBehaviour).GetType().FullName;
		if (fullName.StartsWith("Knight"))
		{
			flag = true;
		}
		string text = fullName.Split(".").Last();
		if (!flag)
		{
			return ((Component)HeroController.instance).GetComponent(text);
		}
		return ((Component)HeroController.instance).GetComponent(text);
	}

	public static void LogInfo(this object msg)
	{
		if (KnightInSilksong.allowLog.Value)
		{
			KnightInSilksong.logger.LogInfo(msg);
		}
	}

	public static void LogWarning(this object msg)
	{
		if (KnightInSilksong.allowLog.Value)
		{
			KnightInSilksong.logger.LogWarning(msg);
		}
	}

	public static void LogError(this object msg)
	{
		if (KnightInSilksong.allowLog.Value)
		{
			KnightInSilksong.logger.LogError(msg);
		}
	}

	public static void LogDebug(this object msg)
	{
		if (KnightInSilksong.allowLog.Value)
		{
			KnightInSilksong.logger.LogDebug(msg);
		}
	}

	public static void LogFatal(this object msg)
	{
		if (KnightInSilksong.allowLog.Value)
		{
			KnightInSilksong.logger.LogFatal(msg);
		}
	}
}
public abstract class IModule
{
	public virtual void Init()
	{
	}

	public virtual void Unload()
	{
	}
}
internal static class ModuleManager
{
	private static Dictionary<Type, IModule> modules = new Dictionary<Type, IModule>();

	private static bool initialized = false;

	public static T GetInstance<T>() where T : IModule
	{
		if (modules.ContainsKey(typeof(T)))
		{
			return (T)modules[typeof(T)];
		}
		return null;
	}

	public static void Init()
	{
		if (!initialized)
		{
			IEnumerable<Type> enumerable = from t in Assembly.GetExecutingAssembly().GetTypes()
				where typeof(IModule).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract
				select t;
			foreach (Type item in enumerable)
			{
				try
				{
					modules.Add(item, (IModule)Activator.CreateInstance(item));
				}
				catch
				{
					KnightInSilksong.logger.LogError((object)("Fail to Create " + item.FullName));
				}
			}
			initialized = true;
		}
		foreach (KeyValuePair<Type, IModule> module in modules)
		{
			module.Value.Init();
		}
	}

	public static void Unload()
	{
		foreach (KeyValuePair<Type, IModule> module in modules)
		{
			module.Value.Unload();
		}
	}
}
public class MoreLanguge : IModule
{
	public static Dictionary<(string, string), string> langs = new Dictionary<(string, string), string>();

	public override void Init()
	{
		base.Init();
	}
}
internal class PreProcess : IModule
{
	public static PreProcess Instance;

	internal bool shader_initialized = false;

	private Dictionary<string, string> material_shader_map;

	private Dictionary<string, Shader> shaders = new Dictionary<string, Shader>();

	public Sprite charm_icon;

	public HashSet<AudioMixer> share_mixer_group = new HashSet<AudioMixer>();

	public PreProcess()
	{
		Instance = this;
	}

	public override void Init()
	{
		using (StreamReader streamReader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("KIS.Resources.MaterialShaderMap.json")))
		{
			string text = streamReader.ReadToEnd();
			material_shader_map = JsonConvert.DeserializeObject<Dictionary<string, string>>(text);
		}
		charm_icon = KnightInSilksong.Instance.hk.LoadAsset<Sprite>("GG_bound_charm_prompt");
		SceneManager.activeSceneChanged += CheckShaders;
		SSizeKnight();
		SSizeHud();
		SSizeCharm();
		SetAuidoVolume();
	}

	private void SSizeCharm()
	{
		if ((Object)(object)KnightInSilksong.Instance.charm == (Object)null)
		{
			return;
		}
		GameObject charm = KnightInSilksong.Instance.charm;
		Renderer[] componentsInChildren = charm.GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val in componentsInChildren)
		{
			val.sortingGroupID = 1048575;
			val.sortingLayerID = 59515797;
		}
		BuildEquippedCharms componentInChildren = charm.GetComponentInChildren<BuildEquippedCharms>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			foreach (GameObject gameObject in componentInChildren.gameObjectList)
			{
				Renderer[] componentsInChildren2 = gameObject.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer val2 in componentsInChildren2)
				{
					val2.sortingGroupID = 1048575;
					val2.sortingLayerID = 59515797;
				}
			}
		}
		GameObject val3 = KnightInSilksong.loaded_gos["Charm Equip Msg"];
		Renderer[] componentsInChildren3 = val3.GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val4 in componentsInChildren3)
		{
			val4.sortingGroupID = 1048575;
			val4.sortingLayerID = 59515797;
		}
	}

	private void SSizeHud()
	{
		if (!((Object)(object)KnightInSilksong.Instance.hud_canvas == (Object)null))
		{
			GameObject hud_canvas = KnightInSilksong.Instance.hud_canvas;
			((Behaviour)FSMUtility.LocateMyFSM(hud_canvas, "Globalise")).enabled = true;
			hud_canvas.FindGameObjectInChildren("Geo Counter").SetActive(false);
		}
	}

	private void SSizeKnight()
	{
		if (!((Object)(object)KnightInSilksong.Instance.knight == (Object)null))
		{
			GameObject knight = KnightInSilksong.Instance.knight;
			SetErrorCollider2D();
			SetErrorFsm();
			knight.GetComponent<Rigidbody2D>().constraints = (RigidbodyConstraints2D)4;
			if (!HelperFun.LoadPlayerData())
			{
				PlayerData.instance.AddGGPlayerDataOverrides();
				PlayerData.instance.royalCharmState = 4;
			}
			knight.AddComponent<KeepHornet>();
			knight.AddComponent<DreamHelper>();
			KnightInSilksong.loaded_gos["Grimmchild"].tag = "Grimmchild";
			KnightInSilksong.loaded_gos["Weaverling"].tag = "Weaverling";
			KnightInSilksong.loaded_gos["Knight Hatchling"].tag = "Knight Hatchling";
			KnightInSilksong.loaded_gos["Orbit Shield"].tag = "Orbit Shield";
		}
	}

	private void CheckShaders(Scene arg0, Scene arg1)
	{
		SetShaders();
		if (shaders.ContainsKey("Sprites/Default-ColorFlash") && !shader_initialized)
		{
			shader_initialized = true;
			KnightInSilksong.logger.LogInfo((object)"Shader Find OK");
			SceneManager.activeSceneChanged -= CheckShaders;
			SetErrorShaders();
		}
	}

	private void SetShaders()
	{
		Shader[] array = Resources.FindObjectsOfTypeAll<Shader>();
		foreach (Shader val in array)
		{
			if ((Object)(object)val != (Object)null && val.isSupported && !shaders.ContainsKey(((Object)val).name))
			{
				KnightInSilksong.logger.LogInfo((object)(((Object)val).name + " " + val.isSupported));
				shaders.Add(((Object)val).name, val);
			}
		}
	}

	public Shader GetShader(string name)
	{
		return shaders.ContainsKey(name) ? shaders[name] : null;
	}

	private void SetErrorShaders()
	{
		AssetBundle hk = KnightInSilksong.Instance.hk;
		HashSet<Material> hashSet = new HashSet<Material>();
		foreach (KeyValuePair<string, GameObject> loaded_go in KnightInSilksong.loaded_gos)
		{
			GameObject value = loaded_go.Value;
			SpriteRenderer[] componentsInChildren = value.GetComponentsInChildren<SpriteRenderer>(true);
			foreach (SpriteRenderer val in componentsInChildren)
			{
				hashSet.Add(((Renderer)val).sharedMaterial);
			}
			ParticleSystemRenderer[] componentsInChildren2 = value.GetComponentsInChildren<ParticleSystemRenderer>(true);
			foreach (ParticleSystemRenderer val2 in componentsInChildren2)
			{
				hashSet.Add(((Renderer)val2).sharedMaterial);
			}
			tk2dSpriteCollectionData[] componentsInChildren3 = value.GetComponentsInChildren<tk2dSpriteCollectionData>(true);
			foreach (tk2dSpriteCollectionData val3 in componentsInChildren3)
			{
				Material[] materials = val3.materials;
				foreach (Material item in materials)
				{
					hashSet.Add(item);
				}
			}
			ChangeFontByLanguage[] componentsInChildren4 = value.GetComponentsInChildren<ChangeFontByLanguage>(true);
			foreach (ChangeFontByLanguage val4 in componentsInChildren4)
			{
				if ((Object)(object)val4.fontJA != (Object)null)
				{
					hashSet.Add(((TMP_Asset)val4.fontJA).material);
				}
				if ((Object)(object)val4.fontKO != (Object)null)
				{
					hashSet.Add(((TMP_Asset)val4.fontKO).material);
				}
				if ((Object)(object)val4.fontRU != (Object)null)
				{
					hashSet.Add(((TMP_Asset)val4.fontRU).material);
				}
				if ((Object)(object)val4.fontZH != (Object)null)
				{
					hashSet.Add(((TMP_Asset)val4.fontZH).material);
				}
				if ((Object)(object)val4.defaultFont != (Object)null)
				{
					hashSet.Add(((TMP_Asset)val4.defaultFont).material);
				}
			}
			TextMeshPro[] componentsInChildren5 = value.GetComponentsInChildren<TextMeshPro>(true);
			foreach (TextMeshPro val5 in componentsInChildren5)
			{
				Material[] fontSharedMaterials = ((TMP_Text)val5).fontSharedMaterials;
				foreach (Material item2 in fontSharedMaterials)
				{
					hashSet.Add(item2);
				}
			}
		}
		foreach (Material item3 in hashSet)
		{
			if ((Object)(object)item3 == (Object)null)
			{
				"Null Material".LogInfo();
				continue;
			}
			if (!material_shader_map.ContainsKey(((Object)item3).name))
			{
				KnightInSilksong.logger.LogError((object)("Cant Find The Material " + ((Object)item3).name + " In Map"));
				continue;
			}
			Shader shader = GetShader(material_shader_map[((Object)item3).name]);
			if ((Object)(object)shader == (Object)null)
			{
				switch (material_shader_map[((Object)item3).name])
				{
				case "tk2d/BlendVertexColor":
					shader = GetShader("tk2d/BlendVertexColor (addressable)");
					break;
				case "UI/BlendModes/Lighten":
					shader = GetShader("UI/BlendModes/Screen");
					break;
				case "UI/BlendModes/Multiply":
					shader = GetShader("UI/BlendModes/Screen");
					break;
				case "UI/BlendModes/VividLight":
					shader = GetShader("UI/BlendModes/Screen");
					break;
				}
				if ((Object)(object)shader == (Object)null)
				{
					KnightInSilksong.logger.LogError((object)("Cant Find The Shader " + material_shader_map[((Object)item3).name] + " For " + ((Object)item3).name));
				}
			}
			item3.shader = shader;
		}
	}

	private void SetErrorCollider2D()
	{
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: 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)
		foreach (KeyValuePair<string, GameObject> loaded_go in KnightInSilksong.loaded_gos)
		{
			GameObject value = loaded_go.Value;
			Collider2D[] componentsInChildren = value.GetComponentsInChildren<Collider2D>(true);
			foreach (Collider2D val in componentsInChildren)
			{
				val.callbackLayers = LayerMask.op_Implicit(-1);
				val.contactCaptureLayers = LayerMask.op_Implicit(-1);
				val.forceReceiveLayers = LayerMask.op_Implicit(-1);
				val.forceSendLayers = LayerMask.op_Implicit(-1);
			}
		}
	}

	private void SetAuidoVolume()
	{
		foreach (KeyValuePair<string, GameObject> loaded_go in KnightInSilksong.loaded_gos)
		{
			GameObject value = loaded_go.Value;
			AudioSource[] componentsInChildren = value.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.outputAudioMixerGroup != (Object)null && (Object)(object)val.outputAudioMixerGroup.audioMixer != (Object)null)
				{
					share_mixer_group.Add(val.outputAudioMixerGroup.audioMixer);
				}
			}
		}
	}

	private void SetErrorFsm()
	{
		foreach (KeyValuePair<string, GameObject> loaded_go in KnightInSilksong.loaded_gos)
		{
			GameObject value = loaded_go.Value;
			PlayMakerFSM[] componentsInChildren = value.GetComponentsInChildren<PlayMakerFSM>(true);
			foreach (PlayMakerFSM val in componentsInChildren)
			{
				val.eventHandlerComponentsAdded = false;
				if (val.UsesTemplate)
				{
					val.fsmTemplate.fsm.GetAddVariable<FsmBool>("FromKnight", (object)true);
					val.fsmTemplate.fsm.preprocessed = false;
				}
				else
				{
					val.GetAddVariable<FsmBool>("FromKnight", (object)true);
					val.fsm.preprocessed = false;
				}
			}
		}
	}
}
[RequireComponent(typeof(SpriteRenderer))]
internal class CheckKnight : MonoBehaviour
{
	private SpriteRenderer render;

	private void Awake()
	{
		render = ((Component)this).GetComponent<SpriteRenderer>();
	}

	private void Update()
	{
		if (KnightInSilksong.IsKnight)
		{
			if ((Object)(object)render != (Object)null)
			{
				((Renderer)render).enabled = true;
			}
		}
		else if ((Object)(object)render != (Object)null)
		{
			((Renderer)render).enabled = false;
		}
	}
}
public class DoAction : MonoBehaviour
{
	public Action<DoAction> action;

	public void DoActionNow()
	{
		action?.Invoke(this);
	}
}
public class DreamHelper : MonoBehaviour
{
	public class DreamInfo
	{
		public HealthManager hm;

		public float cd;
	}

	public List<DreamInfo> dream_cds = new List<DreamInfo>();

	public const float general_cd = 0.2f;

	public bool Exist(HealthManager hm)
	{
		if ((Object)(object)hm == (Object)null)
		{
			return true;
		}
		foreach (DreamInfo dream_cd in dream_cds)
		{
			if ((Object)(object)dream_cd.hm == (Object)(object)hm)
			{
				return true;
			}
		}
		return false;
	}

	public void Add(HealthManager hm)
	{
		if (!((Object)(object)hm == (Object)null))
		{
			dream_cds.Add(new DreamInfo
			{
				hm = hm,
				cd = 0.2f
			});
		}
	}

	public void Update()
	{
		for (int num = dream_cds.Count - 1; num >= 0; num--)
		{
			if ((Object)(object)dream_cds[num].hm == (Object)null)
			{
				dream_cds.RemoveAt(num);
			}
			else
			{
				dream_cds[num].cd -= Time.deltaTime;
				if (dream_cds[num].cd < 0f)
				{
					dream_cds.RemoveAt(num);
				}
			}
		}
	}
}
internal class KeepHornet : MonoBehaviour
{
	private Vector3 offset;

	private Vector2 boxSize;

	private Vector2 boxOffset;

	internal GameObject Hornet => ((Component)HeroController.instance).gameObject;

	private void Awake()
	{
	}

	private void Start()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.position = Hornet.transform.position;
	}

	private void OnEnable()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: 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_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		((Component)this).transform.position = Hornet.transform.position;
		BoxCollider2D component = Hornet.GetComponent<BoxCollider2D>();
		offset = Vector2.op_Implicit(((Collider2D)component).offset);
		boxSize = component.size;
		component.size = ((Component)this).GetComponent<BoxCollider2D>().size;
		((Collider2D)component).offset = ((Collider2D)((Component)this).GetComponent<BoxCollider2D>()).offset;
		((Behaviour)Hornet.GetComponent<HeroWaterController>()).enabled = false;
		List<string> list = new List<string>(5) { "Slash", "AltSlash", "DownSlash", "UpSlash", "WallSlash" };
		foreach (string item in list)
		{
			((Component)this).gameObject.FindGameObjectInChildren("Attacks").FindGameObjectInChildren(item).FindGameObjectInChildren("Clash Tink")
				.tag = "Nail Attack";
		}
	}

	private void Update()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		Hornet.transform.position = ((Component)this).transform.position;
	}

	private void FixedUpdate()
	{
	}

	private void OnDisable()
	{
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: 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)
		BoxCollider2D component = Hornet.GetComponent<BoxCollider2D>();
		((Collider2D)component).offset = Vector2.op_Implicit(offset);
		component.size = boxSize;
		((Behaviour)Hornet.GetComponent<HeroWaterController>()).enabled = true;
	}
}
internal class TrueCharmDisable : MonoBehaviour
{
	private void OnDisable()
	{
		if (((Component)this).gameObject.activeSelf)
		{
			Patch_InventoryItemSelectableDirectional_Awake.ToggleCharm();
		}
	}
}
public class GeneralPatch
{
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_BuildEquippedCharms_BuildCharmList : GeneralPatch
{
	public static bool Prefix(BuildEquippedCharms __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			__instance.equippedCharms = PlayerData.instance.equippedCharms;
		}
		return true;
	}

	public static void Postfix(BuildEquippedCharms __instance)
	{
		if (KnightInSilksong.IsKnight && PlayerData.instance.charmSlotsFilled >= PlayerData.instance.charmSlots)
		{
			try
			{
				__instance.instanceList.Remove(__instance.nextDot);
			}
			catch
			{
			}
		}
	}
}
[HarmonyPatch(typeof(InventoryItemSelectableDirectional), "Awake")]
public class Patch_InventoryItemSelectableDirectional_Awake : GeneralPatch
{
	public static GameObject charmButton;

	private static DoAction button_action;

	public static bool Prefix(InventoryItemSelectableDirectional __instance)
	{
		return true;
	}

	public static void Postfix(InventoryItemSelectableDirectional __instance)
	{
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		if (!(((Object)((Component)__instance).gameObject).name == "Change Crest Button"))
		{
			return;
		}
		InventoryItemSelectableButtonEvent val = (InventoryItemSelectableButtonEvent)(object)((__instance is InventoryItemSelectableButtonEvent) ? __instance : null);
		if (val != null)
		{
			charmButton = Object.Instantiate<GameObject>(((Component)__instance).gameObject, ((Component)__instance).gameObject.transform.parent);
			Extensions.SetPosition2D(charmButton.transform, -7.8865f, -5.53f);
			((InventoryItemSelectableDirectional)val).Selectables[3] = (InventoryItemSelectable)(object)charmButton.GetComponent<InventoryItemSelectableDirectional>();
			charmButton.GetComponent<InventoryItemSelectableDirectional>().Selectables[2] = (InventoryItemSelectable)(object)__instance;
			Object.Destroy((Object)(object)charmButton.FindGameObjectInChildren("Change Crest Action"));
			GameObject gameObject = charmButton.FindGameObjectInChildren("Parent");
			GameObject val2 = gameObject.FindGameObjectInChildren("Button Icon Locked");
			GameObject val3 = gameObject.FindGameObjectInChildren("Button Icon Regular");
			Object.Destroy((Object)(object)val2);
			((Object)val3).name = "Charm Icon";
			Extensions.SetScale2D(val3.transform, new Vector2(0.5f, 0.5f));
			val3.GetComponent<SpriteRenderer>().sprite = ModuleManager.GetInstance<PreProcess>().charm_icon;
			InventoryItemSelectableDirectional component = charmButton.GetComponent<InventoryItemSelectableDirectional>();
			InventoryItemSelectableButtonEvent val4 = (InventoryItemSelectableButtonEvent)(object)((component is InventoryItemSelectableButtonEvent) ? component : null);
			if (val4 != null)
			{
				button_action = charmButton.AddComponent<DoAction>();
				DoAction doAction = button_action;
				doAction.action = (Action<DoAction>)Delegate.Combine(doAction.action, new Action<DoAction>(ToggleCharm));
				val4.ButtonActivated = (Action)Delegate.Combine(val4.ButtonActivated, new Action(button_action.DoActionNow));
			}
			charmButton.SetActive(KnightInSilksong.IsKnight);
			KnightInSilksong instance = KnightInSilksong.Instance;
			instance.OnToggleKnight = (Action<bool>)Delegate.Combine(instance.OnToggleKnight, (Action<bool>)delegate(bool value)
			{
				charmButton.SetActive(value);
			});
		}
	}

	public static void ToggleCharm(DoAction doAction = null)
	{
		DoAction doAction2 = ((!((Object)(object)doAction == (Object)null)) ? doAction : button_action);
		GameObject gameObject = ((Component)doAction2).gameObject;
		InventoryItemToolManager component = ((Component)gameObject.transform.parent.parent).GetComponent<InventoryItemToolManager>();
		bool activeSelf = KnightInSilksong.Instance.charm_instance.activeSelf;
		component.FadeToolGroup(activeSelf);
		((Component)component).gameObject.FindGameObjectInChildren("Crest List").SetActive(activeSelf);
		((Component)gameObject.transform.parent).gameObject.SetActive(activeSelf);
		KnightInSilksong.Instance.charm_instance.SetActive(!activeSelf);
		if (!activeSelf)
		{
			PlayMakerFSM val = FSMUtility.LocateMyFSM(KnightInSilksong.Instance.charm_instance, "UI Charms");
			if (val.GetValidState("Inventory Closed").actions.Length == 0)
			{
				val.AddCustomAction("Inventory Closed", (Action)delegate
				{
					"Try Toggle Charm from Inventory Closed".LogInfo();
					ToggleCharm();
				});
				val.RemoveTransition("Left", "TO LEFT");
				val.RemoveTransition("Right", "TO RIGHT");
				val.InsertCustomAction("Left", delegate(PlayMakerFSM fsm)
				{
					if (fsm.GetVariable<FsmInt>("Collection Pos").value == 1)
					{
						fsm.SendEvent("FINISHED");
					}
				}, 1);
				val.InsertCustomAction("Right", delegate(PlayMakerFSM fsm)
				{
					if (fsm.GetVariable<FsmInt>("Collection Pos").value == 40)
					{
						fsm.SendEvent("FINISHED");
					}
				}, 1);
				KnightInSilksong.Instance.charm_instance.AddComponent<TrueCharmDisable>();
				((Component)KnightInSilksong.Instance.charm_instance.transform.Find("Equipped Charms/Next Dot/Sprite Next")).gameObject.SetActive(false);
			}
			val.FsmVariables.GetFsmInt("New Charm ID").value = 1;
		}
		FSMUtility.SendEventToGameObject(KnightInSilksong.Instance.charm_instance, "UP", true);
		FSMUtility.SendEventToGameObject(KnightInSilksong.Instance.charm_instance, "ACTIVATE", true);
		((Behaviour)((Component)component).GetComponent<InventoryPaneInput>()).enabled = false;
	}
}
[HarmonyPatch(typeof(CallMethodProper), "PreCache")]
internal class PatchCallMethodProper : GeneralPatch
{
	public static bool Prefix(CallMethodProper __instance)
	{
		return true;
	}

	public static void Postfix(CallMethodProper __instance)
	{
	}

	private static void Log(object msg)
	{
		KnightInSilksong.logger.LogInfo(msg);
	}

	private static void Orig_PreCache(CallMethodProper __instance)
	{
		GameObject ownerDefaultTarget = ((FsmStateAction)__instance).Fsm.GetOwnerDefaultTarget(__instance.gameObject);
		if ((Object)(object)ownerDefaultTarget == (Object)null)
		{
			Log("ownerDefaultTarget is null ");
			return;
		}
		ref MonoBehaviour component = ref __instance.component;
		Component component2 = ownerDefaultTarget.GetComponent(__instance.behaviour.Value);
		component = (MonoBehaviour)(object)((component2 is MonoBehaviour) ? component2 : null);
		if ((Object)(object)__instance.component == (Object)null)
		{
			Log("component is null ");
			return;
		}
		__instance.cachedType = ((object)__instance.component).GetType();
		try
		{
			__instance.cachedMethodInfo = __instance.cachedType.GetMethod(__instance.methodName.Value);
		}
		catch (AmbiguousMatchException)
		{
			Type[] types = __instance.parameters.Select((FsmVar fsmVar) => fsmVar.RealType).ToArray();
			__instance.cachedMethodInfo = __instance.cachedType.GetMethod(__instance.methodName.Value, types);
		}
		if (__instance.cachedMethodInfo == null)
		{
			__instance.errorString = __instance.errorString + "Method Name is invalid: " + __instance.methodName.Value + "\n";
		}
		else
		{
			__instance.cachedParameterInfo = __instance.cachedMethodInfo.GetParameters();
		}
	}
}
[HarmonyPatch(typeof(CallMethodProper), "DoMethodCall")]
internal class PatchDoMethodCall : GeneralPatch
{
	public static bool Prefix(CallMethodProper __instance)
	{
		try
		{
			Modified_DoMethodCall(__instance);
		}
		catch (Exception msg)
		{
			Log(((Object)((FsmStateAction)__instance).fsm.GameObject).name + " " + ((FsmStateAction)__instance).fsm.name + " " + ((FsmStateAction)__instance).State.name + " " + __instance.behaviour.value + __instance.methodName.value);
			Log(msg);
		}
		return false;
	}

	public static void Postfix(CallMethodProper __instance)
	{
	}

	private static void Log(object msg)
	{
		KnightInSilksong.logger.LogInfo(msg);
	}

	public static void WarpToDreamGate(GameManager gm)
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0058: 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_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Expected O, but got Unknown
		gm.entryGateName = "dreamGate";
		gm.targetScene = PlayerData.instance.GetString("dreamGateScene");
		gm.entryDelay = 0f;
		gm.cameraCtrl.FreezeInPlace(false);
		gm.BeginSceneTransition(new SceneLoadInfo
		{
			AlwaysUnloadUnusedAssets = true,
			EntryGateName = "dreamGate",
			PreventCameraFadeOut = true,
			SceneName = PlayerData.instance.GetString("dreamGateScene"),
			Visualization = (SceneLoadVisualizations)2
		});
	}

	private static void Modified_DoMethodCall(CallMethodProper __instance)
	{
		//IL_0562: Unknown result type (might be due to invalid IL or missing references)
		//IL_0568: Invalid comparison between Unknown and I4
		if (string.IsNullOrEmpty(__instance.behaviour.Value) || string.IsNullOrEmpty(__instance.methodName.Value))
		{
			((FsmStateAction)__instance).Finish();
			return;
		}
		if (__instance.behaviour.value == "CharmIconList" && __instance.methodName.value == "GetSprite")
		{
			if ((Object)(object)CharmIconList.Instance != (Object)null)
			{
				__instance.parameters[0].UpdateValue();
				__instance.storeResult.SetValue((object)CharmIconList.Instance.GetSprite(__instance.parameters[0].intValue));
			}
			((FsmStateAction)__instance).Finish();
			return;
		}
		if (KnightInSilksong.IsKnight)
		{
			if (__instance.behaviour.value == "HeroController")
			{
				if (__instance.methodName.value == "TakeQuickDamage")
				{
					bool isInvincible = PlayerData.instance.isInvincible;
					PlayerData.instance.isInvincible = false;
					HeroController.instance.TakeDamage((GameObject)null, (CollisionSide)4, __instance.parameters[0].intValue, 4096);
					PlayerData.instance.isInvincible = isInvincible;
					((FsmStateAction)__instance).Finish();
					return;
				}
				if (__instance.methodName.value == "TakeQuickDamageSimple")
				{
					bool isInvincible2 = PlayerData.instance.isInvincible;
					PlayerData.instance.isInvincible = false;
					HeroController.instance.TakeDamage((GameObject)null, (CollisionSide)4, __instance.parameters[0].intValue, 4096);
					PlayerData.instance.isInvincible = isInvincible2;
					((FsmStateAction)__instance).Finish();
					return;
				}
				if (__instance.methodName.value == "WillDoBellBindHit")
				{
					__instance.storeResult.SetValue((object)false);
					((FsmStateAction)__instance).Finish();
					return;
				}
				if (__instance.methodName.value == "ActivateVoidAcid")
				{
					((FsmStateAction)__instance).Finish();
					return;
				}
				if (__instance.methodName.value == "CanTakeDamage")
				{
					bool flag = false;
					flag |= Traverse.Create((object)HeroController.instance).Method("CanTakeDamage", Array.Empty<object>()).GetValue<bool>();
					__instance.storeResult.SetValue((object)flag);
					((FsmStateAction)__instance).Finish();
					return;
				}
			}
			if (__instance.behaviour.value == "GameManager" && __instance.methodName.value == "WarpToDreamGate")
			{
				WarpToDreamGate(GameManager.instance);
				((FsmStateAction)__instance).Finish();
				return;
			}
		}
		GameObject ownerDefaultTarget = ((FsmStateAction)__instance).Fsm.GetOwnerDefaultTarget(__instance.gameObject);
		if ((Object)(object)ownerDefaultTarget == (Object)null)
		{
			return;
		}
		ref MonoBehaviour component = ref __instance.component;
		Component component2 = ownerDefaultTarget.GetComponent(__instance.behaviour.Value);
		component = (MonoBehaviour)(object)((component2 is MonoBehaviour) ? component2 : null);
		if ((Object)(object)__instance.component == (Object)null)
		{
			((FsmStateAction)__instance).LogWarning("CallMethodProper: " + ((Object)ownerDefaultTarget).name + " missing behaviour: " + __instance.behaviour.Value);
			return;
		}
		if (__instance.cachedMethodInfo == null || !__instance.cachedMethodInfo.Name.Equals(__instance.methodName.Value))
		{
			__instance.errorString = string.Empty;
			if (!__instance.DoCache())
			{
				Debug.LogError((object)__instance.errorString, (Object)(object)((FsmStateAction)__instance).Owner);
				((FsmStateAction)__instance).Finish();
				return;
			}
		}
		object value = null;
		if (__instance.cachedParameterInfo.Length == 0)
		{
			try
			{
				value = __instance.cachedMethodInfo.Invoke(__instance.component, null);
			}
			catch (TargetException)
			{
				value = __instance.cachedMethodInfo.Invoke(((Component)(object)__instance.component).GetAnotherComponent(), null);
			}
			catch (Exception ex2)
			{
				Debug.LogError((object)("CallMethodProper error on " + ((FsmStateAction)__instance).Fsm.OwnerName + " -> " + ex2), (Object)(object)((FsmStateAction)__instance).Owner);
			}
		}
		else
		{
			for (int i = 0; i < __instance.parameters.Length; i++)
			{
				FsmVar val = __instance.parameters[i];
				val.UpdateValue();
				__instance.parametersArray[i] = val.GetValue();
			}
			try
			{
				value = __instance.cachedMethodInfo.Invoke(__instance.component, __instance.parametersArray);
			}
			catch (TargetParameterCountException)
			{
				ParameterInfo[] parameters = __instance.cachedMethodInfo.GetParameters();
				Debug.LogErrorFormat((Object)(object)((FsmStateAction)__instance).Owner, "Count did not match. Required: {0}, Was: {1}, Method: {2}", new object[3]
				{
					parameters.Length,
					__instance.parametersArray.Length,
					__instance.cachedMethodInfo.Name
				});
			}
			catch (TargetException)
			{
				value = __instance.cachedMethodInfo.Invoke(((Component)(object)__instance.component).GetAnotherComponent(), __instance.parametersArray);
			}
			catch (Exception ex5)
			{
				Debug.LogError((object)("CallMethodProper error on " + ((FsmStateAction)__instance).Fsm.OwnerName + " -> " + ex5), (Object)(object)((FsmStateAction)__instance).Owner);
			}
		}
		if ((int)__instance.storeResult.Type != -1)
		{
			__instance.storeResult.SetValue(value);
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CameraController_DoPositionToHero : GeneralPatch
{
	public static bool Prefix(CameraController __instance, bool forceDirect)
	{
		return true;
	}

	public static void Postfix(CameraController __instance, bool forceDirect)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CameraController_LockToArea : GeneralPatch
{
	public static bool Prefix(CameraController __instance, CameraLockArea lockArea)
	{
		return true;
	}

	public static void Postfix(CameraController __instance, CameraLockArea lockArea)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CameraController_ReleaseLock : GeneralPatch
{
	public static bool Prefix(CameraController __instance, CameraLockArea lockarea)
	{
		return true;
	}

	public static void Postfix(CameraController __instance, CameraLockArea lockarea)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CameraLockArea_OnInsideStateChanged : GeneralPatch
{
	public static bool Prefix(CameraLockArea __instance, bool isInside)
	{
		return true;
	}

	public static void Postfix(CameraLockArea __instance, bool isInside)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CameraLockArea_IsInApplicableGameState : GeneralPatch
{
	public static bool Prefix(ref bool __result)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		if (KnightInSilksong.IsKnight && (Object)(object)GameManager.UnsafeInstance != (Object)null && (int)GameManager.UnsafeInstance.GameState == 6)
		{
			__result = true;
			return false;
		}
		return true;
	}

	public static void Postfix()
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CharmDisplay_Start : GeneralPatch
{
	public static bool Prefix(CharmDisplay __instance)
	{
		return true;
	}

	public static void Postfix(CharmDisplay __instance)
	{
		if (!KnightInSilksong.IsKnight)
		{
			return;
		}
		Sprite val = null;
		PlayerData instance = PlayerData.instance;
		switch (__instance.id)
		{
		case 23:
			if (instance.brokenCharm_23)
			{
				val = __instance.brokenGlassHP;
			}
			break;
		case 24:
			if (instance.brokenCharm_24)
			{
				val = __instance.brokenGlassGeo;
			}
			break;
		case 25:
			if (instance.brokenCharm_25)
			{
				val = __instance.brokenGlassAttack;
			}
			break;
		case 36:
			val = ((instance.royalCharmState <= 3) ? __instance.whiteCharm : __instance.blackCharm);
			break;
		}
		if ((Object)(object)val != (Object)null)
		{
			if (Object.op_Implicit((Object)(object)__instance.spriteRenderer))
			{
				__instance.spriteRenderer.sprite = val;
			}
			if (Object.op_Implicit((Object)(object)__instance.flashSpriteRenderer))
			{
				__instance.flashSpriteRenderer.sprite = val;
			}
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_CharmIconList_GetSprite : GeneralPatch
{
	public static bool Prefix(CharmIconList __instance, int id, ref Sprite __result)
	{
		if (KnightInSilksong.IsKnight)
		{
			PlayerData instance = PlayerData.instance;
			switch (id)
			{
			case 23:
				if (instance.fragileHealth_unbreakable)
				{
					__result = __instance.unbreakableHeart;
					return false;
				}
				break;
			case 24:
				if (instance.fragileGreed_unbreakable)
				{
					__result = __instance.unbreakableGreed;
					return false;
				}
				break;
			case 25:
				if (instance.fragileStrength_unbreakable)
				{
					__result = __instance.unbreakableStrength;
					return false;
				}
				break;
			case 40:
				switch (instance.grimmChildLevel)
				{
				case 1:
					__result = __instance.grimmchildLevel1;
					return false;
				case 2:
					__result = __instance.grimmchildLevel2;
					return false;
				case 3:
					__result = __instance.grimmchildLevel3;
					return false;
				case 4:
					__result = __instance.grimmchildLevel4;
					return false;
				case 5:
					__result = __instance.nymmCharm;
					return false;
				}
				break;
			}
		}
		return true;
	}

	public static void Postfix(CharmIconList __instance, int id)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_ConveyorZone_OnTriggerEnter2D : GeneralPatch
{
	public static bool Prefix(ConveyorZone __instance, Collider2D collision)
	{
		if (KnightInSilksong.IsKnight)
		{
			if (!__instance.activated)
			{
				return true;
			}
			__instance.hasEntered = true;
			__instance.conveyorMovement = ((Component)collision).GetComponent<ConveyorMovement>();
			if (Object.op_Implicit((Object)(object)__instance.conveyorMovement))
			{
				__instance.conveyorMovement.StartConveyorMove(__instance.speed, 0f);
			}
			HeroController component = ((Component)collision).GetComponent<HeroController>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (__instance.vertical)
				{
					((Component)component).GetComponent<ConveyorMovementHero>().StartConveyorMove(0f, __instance.speed);
					component.cState.onConveyorV = true;
				}
				else
				{
					component.SetConveyorSpeed(__instance.speed);
					component.cState.inConveyorZone = true;
				}
			}
			return false;
		}
		return true;
	}

	public static void Postfix(ConveyorZone __instance, Collider2D collision)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_ConveyorZone_OnTriggerExit2D : GeneralPatch
{
	public static bool Prefix(ConveyorZone __instance, Collider2D collision)
	{
		if (KnightInSilksong.IsKnight)
		{
			if (__instance.activated)
			{
				__instance.hasEntered = false;
				ConveyorMovement component = ((Component)collision).GetComponent<ConveyorMovement>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.StopConveyorMove();
				}
				HeroController component2 = ((Component)collision).GetComponent<HeroController>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					((Component)component2).GetComponent<ConveyorMovementHero>().StopConveyorMove();
					component2.cState.inConveyorZone = false;
					component2.cState.onConveyorV = false;
				}
			}
			return false;
		}
		return true;
	}

	public static void Postfix(ConveyorZone __instance, Collider2D collision)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_ConveyorZone_OnDisable : GeneralPatch
{
	public static bool Prefix(ConveyorZone __instance)
	{
		if (KnightInSilksong.IsKnight && __instance.hasEntered)
		{
			if (Object.op_Implicit((Object)(object)__instance.conveyorMovement))
			{
				__instance.conveyorMovement.StopConveyorMove();
			}
			HeroController instance = HeroController.instance;
			if (Object.op_Implicit((Object)(object)instance))
			{
				((Component)instance).GetComponent<ConveyorMovementHero>().StopConveyorMove();
				instance.cState.inConveyorZone = false;
				instance.cState.onConveyorV = false;
			}
			__instance.hasEntered = false;
			__instance.conveyorMovement = null;
			__instance.hc = null;
		}
		return true;
	}

	public static void Postfix(ConveyorZone __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_DamageEffectTicker_DoFlashOnEnemy : GeneralPatch
{
	public static bool Prefix(DamageEffectTicker __instance, GameObject enemy)
	{
		return true;
	}

	public static void Postfix(DamageEffectTicker __instance, GameObject enemy)
	{
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Invalid comparison between Unknown and I4
		if (!KnightInSilksong.IsKnight || (int)__instance.enemySpriteFlash != 0)
		{
			return;
		}
		string name = ((Object)__instance).name;
		SpriteFlash component = enemy.GetComponent<SpriteFlash>();
		if ((Object)(object)component != (Object)null)
		{
			if (name.Contains("Spore"))
			{
				component.flashSporeQuick();
			}
			else if (name.Contains("Dung"))
			{
				component.flashDungQuick();
			}
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_DamageHero_TryClashTinkCollider : GeneralPatch
{
	public static bool Prefix(DamageHero __instance, Collider2D collision)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		if (KnightInSilksong.IsKnight)
		{
			string tag = ((Component)collision).gameObject.tag;
			Transform transform = ((Component)collision).transform;
			Vector3 position = transform.position;
			Transform parent = transform.parent;
			if (!Object.op_Implicit((Object)(object)parent))
			{
				return true;
			}
			if (tag == "Nail Attack")
			{
				if (!__instance.canClashTink || __instance.nailClashRoutine != null || __instance.preventClashTink || ((Component)collision).gameObject.layer != 16)
				{
					("Cant Clash " + ((Object)((Component)collision).gameObject).name + " " + ((Object)__instance).name).LogInfo();
					(!__instance.canClashTink + " " + (__instance.nailClashRoutine != null) + " " + __instance.preventClashTink).LogInfo();
					return false;
				}
				("Clash yes" + ((Object)((Component)collision).gameObject).name + " " + ((Object)__instance).name).LogInfo();
				HeroController instance = HeroController.instance;
				if (tag == "Nail Attack" && !__instance.noClashFreeze && instance.parryInvulnTimer < Mathf.Epsilon)
				{
					("try freeze " + ((Object)((Component)collision).gameObject).name).LogInfo();
					GameManager.instance.FreezeMoment((FreezeMomentTypes)3, (Action)null);
				}
				float num = 0f;
				PlayMakerFSM val = FSMUtility.LocateMyFSM(((Component)((Component)collision).gameObject.transform.parent).gameObject, "damages_enemy");
				if ((Object)(object)val != (Object)null)
				{
					num = val.GetVariable<FsmFloat>("direction").Value;
				}
				__instance.nailClashRoutine = ((MonoBehaviour)__instance).StartCoroutine(__instance.NailClash(num, tag, position));
				return false;
			}
		}
		return true;
	}

	public static void Postfix(DamageHero __instance, Collider2D collision)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_DamageHero_OnDamaged : GeneralPatch
{
	public static bool Prefix(DamageHero __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			return false;
		}
		return true;
	}

	public static void Postfix(DamageHero __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_DamageHeroDirectly_OnEnter : GeneralPatch
{
	public static bool Prefix(DamageHeroDirectly __instance)
	{
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Expected I4, but got Unknown
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Expected I4, but got Unknown
		if (KnightInSilksong.IsKnight)
		{
			GameObject ownerDefaultTarget = ((FsmStateAction)__instance).Fsm.GetOwnerDefaultTarget(__instance.damager);
			if ((Object)(object)ownerDefaultTarget == (Object)null)
			{
				((FsmStateAction)__instance).Finish();
				return false;
			}
			PlayerData.instance.isInvincible = false;
			HazardType val = (HazardType)1;
			if (__instance.spikeHazard)
			{
				val = (HazardType)2;
			}
			else if (__instance.sinkHazard)
			{
				val = (HazardType)9;
			}
			if (ownerDefaultTarget.transform.position.x > ((Component)HeroController.instance).gameObject.transform.position.x)
			{
				HeroController.instance.TakeDamage(ownerDefaultTarget.gameObject, (CollisionSide)2, __instance.damageAmount.Value, (int)val);
			}
			else
			{
				HeroController.instance.TakeDamage(ownerDefaultTarget.gameObject, (CollisionSide)1, __instance.damageAmount.Value, (int)val);
			}
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(DamageHeroDirectly __instance)
	{
	}
}
[HarmonyPatch(typeof(Extensions), "SetPosition2D", new Type[]
{
	typeof(Transform),
	typeof(float),
	typeof(float)
})]
public class Patch_Extensions_SetPosition2D : GeneralPatch
{
	public static bool Prefix(Transform t, float x, float y)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		if (KnightInSilksong.IsKnight && (Object)(object)t == (Object)(object)HeroController.instance.transform)
		{
			Transform transform = ((Component)HeroController.instance).transform;
			transform.position = new Vector3(x, y, transform.position.z);
		}
		return true;
	}

	public static void Postfix(Transform t, float x, float y)
	{
	}
}
[HarmonyPatch(typeof(Extensions), "SetPosition2D", new Type[]
{
	typeof(Transform),
	typeof(Vector2)
})]
public class Patch_Extensions_SetPosition2D2 : GeneralPatch
{
	public static bool Prefix(Transform t, ref Vector2 position)
	{
		//IL_0039: 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)
		if (KnightInSilksong.IsKnight && (Object)(object)t == (Object)(object)HeroController.instance.transform)
		{
			Transform transform = ((Component)HeroController.instance).transform;
			transform.position = new Vector3(position.x, position.y, transform.position.z);
		}
		return true;
	}

	public static void Postfix(Transform t, Vector2 position)
	{
	}
}
[HarmonyPatch(typeof(FSMUtility), "SendEventToGameObject", new Type[]
{
	typeof(GameObject),
	typeof(FsmEvent),
	typeof(bool)
})]
public class Patch_FSMUtility_SendEventToGameObject : GeneralPatch
{
	public static bool Prefix(GameObject go, FsmEvent ev, bool isRecursive = false)
	{
		if (KnightInSilksong.IsKnight && (Object)(object)HeroController.instance != (Object)null && (Object)(object)go == (Object)(object)((Component)HeroController.instance).gameObject)
		{
			FSMUtility.SendEventToGameObject(((Component)HeroController.instance).gameObject, ev, isRecursive);
			return false;
		}
		return true;
	}

	public static void Postfix(GameObject go, FsmEvent ev, bool isRecursive = false)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GameCameras_HUDOut : GeneralPatch
{
	public static bool Prefix(GameCameras __instance)
	{
		return true;
	}

	public static void Postfix(GameCameras __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			FSMUtility.SendEventToGameObject(KnightInSilksong.Instance.hud_instance, "OUT", false);
			"Hud OUT".LogInfo();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GameCameras_HUDIn : GeneralPatch
{
	public static bool Prefix(GameCameras __instance)
	{
		return true;
	}

	public static void Postfix(GameCameras __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			FSMUtility.SendEventToGameObject(KnightInSilksong.Instance.hud_instance, "IN", false);
			"Hud IN".LogInfo();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GameManager_PositionHeroAtSceneEntrance : GeneralPatch
{
	public static bool Prefix(GameManager __instance)
	{
		return true;
	}

	public static void Postfix(GameManager __instance)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		if (KnightInSilksong.IsKnight)
		{
			((Component)HeroController.instance).transform.position = HeroController.instance.transform.position;
		}
	}
}
[HarmonyPatch(typeof(GameManager), "SetIsInventoryOpen", new Type[] { typeof(bool) })]
public class Patch_GameManager_SetIsInventoryOpen : GeneralPatch
{
	public static bool Prefix(GameManager __instance, bool value)
	{
		return true;
	}

	public static void Postfix(GameManager __instance, bool value)
	{
		if (KnightInSilksong.IsKnight)
		{
			if (value)
			{
				__instance.SetTimeScale(1f);
				HeroController.instance.RelinquishControl();
			}
			else
			{
				HeroController.instance.RegainControl();
			}
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GameManager_ReturnToMainMenu : GeneralPatch
{
	public static bool Prefix(GameManager __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			KnightInSilksong.Instance.ToggleKnight();
			KnightInSilksong.return_to_main_menu = true;
			"return to Main Menu".LogInfo();
		}
		return true;
	}

	public static void Postfix(GameManager __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GameSettings_LoadAudioSettings : GeneralPatch
{
	public static bool Prefix(GameSettings __instance)
	{
		return true;
	}

	public static void Postfix(GameSettings __instance)
	{
		AudioMixer master = KnightInSilksong.Master;
		float masterVolume = __instance.masterVolume;
		float soundVolume = __instance.soundVolume;
		float num = Helper.LinearToDecibel(masterVolume / 10f);
		master.SetFloat("MasterVolume", num);
		num = Helper.LinearToDecibel(soundVolume / 10f);
		master.SetFloat("SFXVolume", num);
		"LoadAudioSettings OK".LogInfo();
	}
}
[HarmonyPatch(typeof(GameObject), "GetComponentByName")]
internal class PatchGetComponent : GeneralPatch
{
	public static bool Prefix(GameObject __instance, ref Component __result, ref string type)
	{
		switch (type)
		{
		case "HeroController":
			__result = __instance.GetAnyComponent<HeroController, HeroController>();
			return false;
		case "HeroAudioController":
			__result = __instance.GetAnyComponent<HeroAudioController, HeroAudioController>();
			return false;
		case "HeroAnimationController":
			__result = __instance.GetAnyComponent<HeroAnimationController, HeroAnimationController>();
			return false;
		case "HeroBox":
			__result = __instance.GetAnyComponent<HeroBox, HeroBox>();
			return false;
		case "NailSlash":
			__result = __instance.GetAnyComponent<NailSlash, NailSlash>();
			return false;
		default:
			return true;
		}
	}

	public static void Postfix(GameObject __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetHeroCState_DoAction : GeneralPatch
{
	public static bool Prefix(GetHeroCState __instance)
	{
		if (KnightInSilksong.IsKnight && !((NamedVariable)__instance.VariableName).IsNone && !((NamedVariable)__instance.StoreValue).IsNone && __instance.VariableName.Value == "parrying")
		{
			bool flag = false;
			HeroController instance = HeroController.instance;
			flag = instance.playerData.equippedCharm_5 && instance.playerData.blockerHits > 0 && instance.cState.focusing;
			__instance.StoreValue.Value = flag;
			return false;
		}
		return true;
	}

	public static void Postfix(GetHeroCState __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetNailDamage_OnEnter : GeneralPatch
{
	public static bool Prefix(GetNailDamage __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			KnightOnEnter(__instance);
			return false;
		}
		return true;
	}

	public static void Postfix(GetNailDamage __instance)
	{
	}

	public static void KnightOnEnter(GetNailDamage __instance)
	{
		if (!((NamedVariable)__instance.storeValue).IsNone)
		{
			if (BossSequenceController.BoundNail)
			{
				__instance.storeValue.Value = Mathf.Min(PlayerData.instance.nailDamage, BossSequenceController.BoundNailDamage);
			}
			else
			{
				__instance.storeValue.Value = PlayerData.instance.nailDamage;
			}
		}
		((FsmStateAction)__instance).Finish();
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetPlayerDataBool_OnEnter : GeneralPatch
{
	public static bool Prefix(GetPlayerDataBool __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			if (__instance.boolName.value == "EncounteredLostLace")
			{
				(((FsmStateAction)__instance).fsm.name + " " + ((FsmStateAction)__instance).State.name + " GetPlayerDataBool").LogInfo();
			}
			__instance.storeValue.Value = PlayerData.instance.GetBool(__instance.boolName.Value);
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(GetPlayerDataBool __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetPlayerDataFloat_OnEnter : GeneralPatch
{
	public static bool Prefix(GetPlayerDataFloat __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			__instance.storeValue.Value = PlayerData.instance.GetFloat(__instance.floatName.Value);
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(GetPlayerDataFloat __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetPlayerDataInt_OnEnter : GeneralPatch
{
	public static bool Prefix(GetPlayerDataInt __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			__instance.storeValue.Value = PlayerData.instance.GetInt(__instance.intName.Value);
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(GetPlayerDataInt __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetPlayerDataString_OnEnter : GeneralPatch
{
	public static bool Prefix(GetPlayerDataString __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			__instance.storeValue.Value = PlayerData.instance.GetString(__instance.stringName.Value);
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(GetPlayerDataString __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GetPlayerDataVector3_OnEnter : GeneralPatch
{
	public static bool Prefix(GetPlayerDataVector3 __instance)
	{
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			__instance.storeValue.Value = PlayerData.instance.GetVector3(__instance.vector3Name.Value);
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(GetPlayerDataVector3 __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_PlayerDataBoolTest_OnEnter : GeneralPatch
{
	private static List<string> in_knight_bool = new List<string> { "isInvincible" };

	public static bool Prefix(PlayerDataBoolTest __instance)
	{
		if (KnightInSilksong.IsKnight && (((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null || Extensions.IsAny(__instance.boolName.Value, in_knight_bool.ToArray())))
		{
			bool @bool = PlayerData.instance.GetBool(__instance.boolName.Value);
			((FsmStateAction)__instance).fsm.Event(@bool ? __instance.isTrue : __instance.isFalse);
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(PlayerDataBoolTest __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_PlayerDataBoolAllTrue_DoAllTrue : GeneralPatch
{
	public static bool Prefix(PlayerDataBoolAllTrue __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			bool flag = true;
			for (int i = 0; i < __instance.stringVariables.Length; i++)
			{
				if (!PlayerData.instance.GetBool(__instance.stringVariables[i].Value))
				{
					flag = false;
					break;
				}
			}
			if (flag)
			{
				((FsmStateAction)__instance).Fsm.Event(__instance.trueEvent);
			}
			else
			{
				((FsmStateAction)__instance).Fsm.Event(__instance.falseEvent);
			}
			__instance.storeResult.Value = flag;
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(PlayerDataBoolAllTrue __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_PlayerDataBoolTrueAndFalse_OnEnter : GeneralPatch
{
	public static bool Prefix(PlayerDataBoolTrueAndFalse __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			if (PlayerData.instance.GetBool(__instance.trueBool.Value) && !PlayerData.instance.GetBool(__instance.falseBool.Value))
			{
				((FsmStateAction)__instance).Fsm.Event(__instance.isTrue);
			}
			else
			{
				((FsmStateAction)__instance).Fsm.Event(__instance.isFalse);
			}
			((FsmStateAction)__instance).Finish();
			return false;
		}
		return true;
	}

	public static void Postfix(PlayerDataBoolTrueAndFalse __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_GrassCut_ShouldCut : GeneralPatch
{
	public static bool Prefix(Collider2D collision, ref bool __result)
	{
		if (KnightInSilksong.IsKnight)
		{
			if (!(((Component)collision).tag == "Nail Attack") && (!(((Component)collision).tag == "HeroBox") || !HeroController.instance.cState.superDashing))
			{
				__result = ((Component)collision).tag == "Sharp Shadow";
			}
			else
			{
				__result = true;
			}
			if (!__result)
			{
				return true;
			}
			return false;
		}
		return true;
	}

	public static void Postfix(Collider2D collision)
	{
	}
}
[HarmonyPatch(typeof(HealthManager), "Hit", new Type[] { typeof(HitInstance) })]
public class Patch_HealthManager_Hit : GeneralPatch
{
	public static bool Prefix(HealthManager __instance, HitInstance hitInstance)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance, HitInstance hitInstance, ref HitResponse __result)
	{
	}
}
[HarmonyPatch(typeof(HealthManager), "Invincible", new Type[] { typeof(HitInstance) })]
public class Patch_HealthManager_Invincible : GeneralPatch
{
	public static bool Prefix(HealthManager __instance, ref HitInstance hitInstance)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance, ref HitInstance hitInstance)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Invalid comparison between Unknown and I4
		if ((hitInstance.SpecialType & KnightInSilksong.KnightDamage) > 0)
		{
			__instance.evasionByHitRemaining = 0.15f;
		}
	}
}
public class Patch_HealthManager_TakeDamage
{
	public static bool Prefix(HealthManager __instance, ref HitInstance hitInstance)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance, ref HitInstance hitInstance)
	{
	}
}
[HarmonyPatch(typeof(HealthManager), "NonFatalHit", new Type[] { typeof(bool) })]
public class Patch_HealthManager_NonFatalHit : GeneralPatch
{
	public static bool Prefix(HealthManager __instance, bool ignoreEvasion)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance, bool ignoreEvasion)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		if ((__instance.lastHitInstance.SpecialType & KnightInSilksong.KnightDamage) > 0 && !ignoreEvasion && !__instance.hasAlternateHitAnimation)
		{
			__instance.evasionByHitRemaining = 0.2f;
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HealthManager_IsBlockingByDirection : GeneralPatch
{
	public static bool Prefix(HealthManager __instance, int cardinalDirection, AttackTypes attackType, ref SpecialTypes specialType)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance, int cardinalDirection, AttackTypes attackType, SpecialTypes specialType, ref bool __result)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HealthManager_IsInvincible : GeneralPatch
{
	public static bool Prefix(HealthManager __instance, bool value)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HealthManager_InvincibleFromDirection : GeneralPatch
{
	public static bool Prefix(HealthManager __instance, int value)
	{
		return true;
	}

	public static void Postfix(HealthManager __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroAnimationController_StartControl : GeneralPatch
{
	public static bool Prefix(HeroAnimationController __instance)
	{
		return true;
	}

	public static void Postfix(HeroAnimationController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			((Component)HeroController.instance).GetComponent<HeroAnimationController>().StartControl();
		}
	}
}
[HarmonyPatch(typeof(HeroAnimationController), "StartControlToIdle", new Type[] { typeof(bool) })]
public class Patch_HeroAnimationController_StartControlToIdle : GeneralPatch
{
	public static bool Prefix(HeroAnimationController __instance, bool forcePlay)
	{
		return true;
	}

	public static void Postfix(HeroAnimationController __instance, bool forcePlay)
	{
		if (KnightInSilksong.IsKnight)
		{
			((Component)HeroController.instance).GetComponent<HeroAnimationController>().StartControl();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroAnimationController_StopControl : GeneralPatch
{
	public static bool Prefix(HeroAnimationController __instance)
	{
		return true;
	}

	public static void Postfix(HeroAnimationController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			((Component)HeroController.instance).GetComponent<HeroAnimationController>().StopControl();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_RelinquishControl : GeneralPatch
{
	public static HeroController hero;

	public static bool Prefix()
	{
		return true;
	}

	public static void Postfix()
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.RelinquishControl();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_AffectedByGravity : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance, bool gravityApplies)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Invalid comparison between Unknown and I4
		if (KnightInSilksong.IsKnight && (int)HeroController.instance.transitionState != 2 && !HeroController.instance.cState.swimming && FSMUtility.LocateMyFSM(((Component)HeroController.instance).gameObject, "Surface Water").ActiveStateName == "Inactive")
		{
			HeroController.instance.AffectedByGravity(gravityApplies);
			("AffectedByGravity Patch " + gravityApplies).LogInfo();
		}
	}
}
[HarmonyPatch(typeof(HeroController), "RegainControl", new Type[] { typeof(bool) })]
public class Patch_HeroController_RegainControl : GeneralPatch
{
	public static bool Prefix(HeroController __instance, bool allowInput)
	{
		return true;
	}

	public static void Postfix(HeroController __instance, bool allowInput)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.RegainControl();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_StopAnimationControl : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.StopAnimationControl();
		}
	}
}
[HarmonyPatch(typeof(HeroController), "StartAnimationControl", new Type[] { })]
public class Patch_HeroController_StartAnimationControl : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.StartAnimationControl();
		}
	}
}
[HarmonyPatch(typeof(MonoBehaviour), "StartCoroutine", new Type[] { typeof(IEnumerator) })]
public class Patch_MonoBehaviour_StartCoroutine : GeneralPatch
{
	public static bool Prefix(MonoBehaviour __instance, IEnumerator routine)
	{
		if ((Object)(object)__instance == (Object)(object)HeroController.instance && KnightInSilksong.IsKnight && !((Component)HeroController.instance).gameObject.activeSelf)
		{
			routine.LogInfo();
			((MonoBehaviour)HeroController.instance).StartCoroutine(routine);
			return false;
		}
		return true;
	}

	public static void Postfix(MonoBehaviour __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_LeavingScene : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_LeaveScene : GeneralPatch
{
	public static bool Prefix(HeroController __instance, GatePosition? gate)
	{
		//IL_0019: 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_0021: 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_0036: Invalid comparison between Unknown and I4
		if (KnightInSilksong.IsKnight)
		{
			"Leave Scene Patch".LogInfo();
			if (gate == (GatePosition?)0 || (int)gate.GetValueOrDefault() == 3)
			{
				gate.LogInfo();
			}
			HeroController.instance.LeaveScene(gate);
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance, ref GatePosition? gate)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_EnterScene : GeneralPatch
{
	public static bool Prefix(HeroController __instance, TransitionPoint enterGate, float delayBeforeEnter)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		if (KnightInSilksong.IsKnight)
		{
			if (HeroController.instance.cState.superDashing)
			{
				HeroController.instance.SetSuperDashExit();
			}
			if (HeroController.instance.cState.spellQuake)
			{
				HeroController.instance.SetQuakeExit();
			}
			((MonoBehaviour)GameManager.instance).StartCoroutine(HeroController.instance.EnterScene(enterGate, delayBeforeEnter));
			enterGate.GetGatePosition().LogInfo();
			"EnterScene Patch".LogInfo();
			PlayMakerFSM.BroadcastEvent("LEVEL LOADED");
			Time.time.LogInfo();
		}
		return true;
	}

	public static void Postfix(HeroController __instance, TransitionPoint enterGate, float delayBeforeEnter)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_EnterSceneDreamGate : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.EnterSceneDreamGate();
			((Renderer)((Component)HeroController.instance).gameObject.GetComponent<MeshRenderer>()).enabled = false;
			PlayMakerFSM.BroadcastEvent("LEVEL LOADED");
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_SceneInit : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.SceneInit();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_Respawn : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			((MonoBehaviour)GameManager.instance).StartCoroutine(HeroController.instance.Respawn());
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_HazardRespawn : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			((MonoBehaviour)GameManager.instance).StartCoroutine(HeroController.instance.HazardRespawn());
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_MaxHealth : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.MaxHealth();
			EventRegister.SendEvent("UPDATE BLUE HEALTH", (GameObject)null);
		}
	}
}
[HarmonyPatch(typeof(HeroController), "AddSilk", new Type[]
{
	typeof(int),
	typeof(bool),
	typeof(SilkAddSource),
	typeof(bool)
})]
public class Patch_HeroController_AddSilk : GeneralPatch
{
	public static bool Prefix(HeroController __instance, int amount, bool heroEffect, SilkAddSource source, bool forceCanBindEffect)
	{
		return true;
	}

	public static void Postfix(HeroController __instance, int amount, bool heroEffect, SilkAddSource source, bool forceCanBindEffect)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.SoulGain();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_IgnoreInput : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.IgnoreInput();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_IgnoreInputWithoutReset : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.IgnoreInputWithoutReset();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_AcceptInput : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.AcceptInput();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_Pause : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.Pause();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_UnPause : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.UnPause();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_RecoilRight : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.RecoilRight();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_RecoilLeft : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.RecoilLeft();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_RecoilDown : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.RecoilDown();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_DownspikeBounce : GeneralPatch
{
	public static bool Prefix(HeroController __instance, bool harpoonRecoil, HeroSlashBounceConfig bounceConfig = null)
	{
		if (KnightInSilksong.IsKnight)
		{
			Traverse.Create((object)HeroController.instance).Method("CancelBounce", Array.Empty<object>()).GetValue();
			HeroController.instance.Bounce();
			"ShroomBounce".LogInfo();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance, bool harpoonRecoil, HeroSlashBounceConfig bounceConfig = null)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_FinishedEnteringScene : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		"Hornet FinishedEnteringScene Patch".LogInfo();
		Time.time.LogInfo();
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_Awake : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		KnightInSilksong.Instance.InstKnight();
		((Component)HeroController.instance).gameObject.SetActive(false);
		"Create Knight".LogInfo();
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_OnDestroy : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		Object.DestroyImmediate((Object)(object)((Component)HeroController.instance).gameObject);
		"Destroy Knight".LogInfo();
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_IsSwimming : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			"IsSwimming Patch".LogInfo();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_NotSwimming : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (!KnightInSilksong.IsKnight)
		{
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_StartAnimationControlToIdle : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.StartAnimationControl();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_StartAnimationControlToIdleForcePlay : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.StartAnimationControl();
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_CanTakeDamage : GeneralPatch
{
	public static bool Prefix(HeroController __instance, ref bool __result)
	{
		if (KnightInSilksong.IsKnight)
		{
			bool flag = false;
			flag |= Traverse.Create((object)HeroController.instance).Method("CanTakeDamage", Array.Empty<object>()).GetValue<bool>();
			__result = flag;
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_NailParry : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.NailParry();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_NailParryRecover : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.NailParryRecover();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(typeof(SetPosition), "DoSetPosition")]
internal class Patch_SetPosition_DoSetPosition : GeneralPatch
{
	private static void Postfix(SetPosition __instance)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Invalid comparison between Unknown and I4
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		if (KnightInSilksong.IsKnight && (Object)(object)((ComponentAction<Transform>)(object)__instance).cachedTransform == (Object)(object)HeroController.instance.transform)
		{
			Vector3 val = ((!((NamedVariable)__instance.vector).IsNone) ? __instance.vector.Value : (((int)__instance.space == 0) ? ((ComponentAction<Transform>)(object)__instance).cachedTransform.position : ((ComponentAction<Transform>)(object)__instance).cachedTransform.localPosition));
			if (!((NamedVariable)__instance.x).IsNone)
			{
				val.x = __instance.x.Value;
			}
			if (!((NamedVariable)__instance.y).IsNone)
			{
				val.y = __instance.y.Value;
			}
			if (!((NamedVariable)__instance.z).IsNone)
			{
				val.z = __instance.z.Value;
			}
			if ((int)__instance.space == 0)
			{
				((Component)HeroController.instance).transform.position = val;
			}
			else
			{
				((Component)HeroController.instance).transform.localPosition = val;
			}
		}
	}
}
[HarmonyPatch(typeof(SetPosition2D), "DoSetPosition")]
internal class Patch_SetPosition2D_DoSetPosition : GeneralPatch
{
	private static void Postfix(SetPosition2D __instance)
	{
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		if (!KnightInSilksong.IsKnight)
		{
			return;
		}
		GameObject val = null;
		try
		{
			val = ((FsmStateAction)__instance).Fsm.GetOwnerDefaultTarget(__instance.GameObject);
		}
		catch (NullReferenceException)
		{
			string text = "";
			text = text + ((FsmStateAction)__instance).fsm.name + " ";
			text = text + ((FsmStateAction)__instance).fsmState.name + " ";
			text = text + ((Object)((FsmStateAction)__instance).fsm.GameObject).name + " ";
			if (__instance != null)
			{
				if (__instance.GameObject != null)
				{
					text = text + ((object)__instance.GameObject)?.ToString() + " ";
				}
			}
			else
			{
				text += "null";
			}
			text.LogInfo();
		}
		if ((Object)(object)val == (Object)(object)((Component)HeroController.instance).gameObject)
		{
			((Component)HeroController.instance).transform.position = HeroController.instance.transform.position;
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroWaterController_EnterWaterRegion : GeneralPatch
{
	public static bool Prefix(HeroWaterController __instance, SurfaceWaterRegion surfaceWater)
	{
		return true;
	}

	public static void Postfix(HeroWaterController __instance, SurfaceWaterRegion surfaceWater)
	{
		if (!KnightInSilksong.IsKnight)
		{
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HitInstance_GetActualDirection : GeneralPatch
{
	public static bool Prefix(ref HitInstance __instance, Transform target, TargetType targetType)
	{
		return true;
	}

	public static void Postfix(ref HitInstance __instance, Transform target, TargetType targetType)
	{
	}
}
[HarmonyPatch(typeof(HitTaker), "Hit", new Type[]
{
	typeof(GameObject),
	typeof(HitInstance),
	typeof(int)
})]
public class Patch_HitTaker_Hit : GeneralPatch
{
	public static bool Prefix(GameObject targetGameObject, HitInstance damageInstance, int recursionDepth = 3)
	{
		return true;
	}

	public static void Postfix(GameObject targetGameObject, ref HitInstance damageInstance, int recursionDepth = 3)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_InstaDeath_OnEnter : GeneralPatch
{
	public static bool Prefix(InstaDeath __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			ModifyOnEnter(__instance);
			return false;
		}
		return true;
	}

	public static void Postfix(InstaDeath __instance)
	{
	}

	public static void ModifyOnEnter(InstaDeath __instance)
	{
		GameObject safe = FSMUtility.GetSafe(__instance.target, (FsmStateAction)(object)__instance);
		if ((Object)(object)safe != (Object)null)
		{
			HealthManager component = safe.GetComponent<HealthManager>();
			if ((Object)(object)component != (Object)null)
			{
				if (!component.isDead)
				{
					float value = (((NamedVariable)__instance.direction).IsNone ? DirectionUtils.GetAngle(component.GetAttackDirection()) : __instance.direction.Value);
					component.Die((float?)value, (AttackTypes)1, (NailElements)0, (GameObject)null, false, 1f, true, false);
				}
			}
			else if ((Object)(object)safe.GetComponent<EnemyDeathEffects>() != (Object)null)
			{
				safe.GetComponent<EnemyDeathEffects>().ReceiveDeathEvent((float?)DirectionUtils.GetAngle(1), (AttackTypes)1, 0f, false);
			}
		}
		((FsmStateAction)__instance).Finish();
	}
}
[HarmonyPatch(typeof(iTweenFsmAction), "OnEnteriTween", new Type[] { typeof(FsmOwnerDefault) })]
public class Patch_iTweenFsmAction_OnEnteriTween
{
	public static bool Prefix(iTweenFsmAction __instance)
	{
		return true;
	}

	public static void Postfix(iTweenFsmAction __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null)
		{
			__instance.realTime = FsmBool.op_Implicit(true);
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_Wait_OnEnter
{
	public static bool Prefix(Wait __instance)
	{
		return true;
	}

	public static void Postfix(Wait __instance)
	{
		if (KnightInSilksong.IsKnight && ((FsmStateAction)__instance).fsm.GetVariable<FsmBool>("FromKnight") != null && !(__instance.time.Value <= 0f) && ((FsmStateAction)__instance).fsm.GameObject.layer == LayerMask.NameToLayer("UI"))
		{
			__instance.realTime = true;
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_KnightHatchling_OnEnable : GeneralPatch
{
	public static bool Prefix(KnightHatchling __instance)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Expected O, but got Unknown
		if (KnightInSilksong.IsKnight && (Object)(object)__instance.openEffect == (Object)null)
		{
			__instance.openEffect = new GameObject("openEffect");
			__instance.openEffect.transform.SetParent(((Component)__instance).transform);
		}
		return true;
	}

	public static void Postfix(KnightHatchling __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_LocateSpawnPoint : GeneralPatch
{
	public static bool Prefix(HeroController __instance, ref Transform __result)
	{
		if (KnightInSilksong.IsKnight)
		{
			__result = HeroController.instance.LocateSpawnPoint();
			return false;
		}
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_CharmUpdate : GeneralPatch
{
	public static bool Prefix(HeroController __instance)
	{
		return true;
	}

	public static void Postfix(HeroController __instance)
	{
		if (KnightInSilksong.IsKnight)
		{
			PlayMakerFSM.BroadcastEvent("CHARM EQUIP CHECK");
			PlayMakerFSM.BroadcastEvent("CHARM INDICATOR CHECK");
			EventRegister.SendEvent("UPDATE BLUE HEALTH", (GameObject)null);
		}
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_HeroController_Attack : GeneralPatch
{
	public static bool Prefix(HeroController __instance, AttackDirection attackDir)
	{
		if (KnightInSilksong.IsKnight)
		{
			HeroController.instance.IncrementAttackCounter();
		}
		return true;
	}

	public static void Postfix(HeroController __instance, AttackDirection attackDir)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_Knight_HeroController_FinishedEnteringScene : GeneralPatch
{
	public static bool Prefix()
	{
		return true;
	}

	public static void Postfix()
	{
		"Knight FinishedEnteringScene Patch".LogInfo();
		Time.time.LogInfo();
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_Knight_HeroController_TakeDamage : GeneralPatch
{
	public static bool Prefix(HeroController __instance, GameObject go, CollisionSide damageSide, int damageAmount, ref int hazardType)
	{
		if (KnightInSilksong.IsKnight)
		{
			if (hazardType == 4)
			{
				hazardType = 2;
			}
			else if (hazardType == 4096)
			{
				hazardType = 4;
			}
			else if (hazardType != 1 && hazardType != 8)
			{
				hazardType = 2;
			}
		}
		return true;
	}

	public static void Postfix(HeroController __instance, GameObject go, CollisionSide damageSide, int damageAmount, int hazardType)
	{
	}
}
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class Patch_Knight_HeroController_Die