using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using GlobalSettings;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("HKVoidsongMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HKVoidsongMod")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1d46aad1-ba46-46ed-ad7e-6a5ad731ed2e")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
[BepInPlugin("com.layeredone.SSVS", "SSVoidsong", "1.0.0")]
public class VoidSongMod : BaseUnityPlugin
{
	[CompilerGenerated]
	private sealed class <ActivateAttackRoutine>d__20 : IEnumerator<object>, IDisposable, IEnumerator
	{
		private int <>1__state;

		private object <>2__current;

		public BlackThreadState __instance;

		public GameObject attackObj;

		private GameObject <attackObjClone>5__1;

		private FieldInfo <atkField>5__2;

		private BlackThreadAttack <atk>5__3;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<attackObjClone>5__1 = null;
			<atkField>5__2 = null;
			<atk>5__3 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<attackObjClone>5__1 = Object.Instantiate<GameObject>(attackObj, ((Component)__instance).transform.position, Quaternion.identity);
				if ((Object)(object)<attackObjClone>5__1 == (Object)null)
				{
					return false;
				}
				<>2__current = (object)new WaitForSeconds(0.1f);
				<>1__state = 1;
				return true;
			case 1:
			{
				<>1__state = -1;
				<atkField>5__2 = typeof(BlackThreadState).GetField("chosenAttack", BindingFlags.Instance | BindingFlags.NonPublic);
				ref BlackThreadAttack reference = ref <atk>5__3;
				object? obj = <atkField>5__2?.GetValue(__instance);
				reference = (BlackThreadAttack)((obj is BlackThreadAttack) ? obj : null);
				<attackObjClone>5__1.SetActive(true);
				<>2__current = (object)new WaitForSeconds(1f);
				<>1__state = 2;
				return true;
			}
			case 2:
				<>1__state = -1;
				Object.Destroy((Object)(object)<attackObjClone>5__1, 3f);
				<>2__current = (object)new WaitForSeconds(3f);
				<>1__state = 3;
				return true;
			case 3:
				<>1__state = -1;
				return false;
			}
		}

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

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

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

		private object <>2__current;

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

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

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

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

		private bool MoveNext()
		{
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				break;
			case 1:
				<>1__state = -1;
				break;
			}
			<>2__current = null;
			<>1__state = 1;
			return true;
		}

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

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

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

		private object <>2__current;

		public BlackThreadState state;

		private MethodInfo <setVisiblyThreaded>5__1;

		private GameObject <startEffect>5__2;

		private MethodInfo <setBlackThreadAmount>5__3;

		private MethodInfo <startAttackTest>5__4;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<setVisiblyThreaded>5__1 = null;
			<startEffect>5__2 = null;
			<setBlackThreadAmount>5__3 = null;
			<startAttackTest>5__4 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<setVisiblyThreaded>5__1 = typeof(BlackThreadState).GetMethod("SetVisiblyThreaded", BindingFlags.Instance | BindingFlags.NonPublic);
				<setVisiblyThreaded>5__1?.Invoke(state, null);
				<startEffect>5__2 = Effects.BlackThreadEnemyStartEffect;
				if ((Object)(object)<startEffect>5__2 != (Object)null)
				{
					ObjectPoolExtensions.Spawn(<startEffect>5__2, ((Component)state).transform, Vector2.op_Implicit(Vector2.zero));
				}
				<setBlackThreadAmount>5__3 = typeof(BlackThreadState).GetMethod("SetBlackThreadAmount", BindingFlags.Instance | BindingFlags.NonPublic);
				<setBlackThreadAmount>5__3?.Invoke(state, new object[1] { 1f });
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				<startAttackTest>5__4 = typeof(BlackThreadState).GetMethod("StartAttackTest", BindingFlags.Instance | BindingFlags.NonPublic);
				break;
			case 2:
				<>1__state = -1;
				break;
			}
			<startAttackTest>5__4?.Invoke(state, null);
			<>2__current = (object)new WaitForSeconds(Random.Range(3f, 10f));
			<>1__state = 2;
			return true;
		}

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

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

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

		private object <>2__current;

		public VoidSongMod <>4__this;

		private IEnumerable<AssetBundle> <existingBundles>5__1;

		private string <markedAsset>5__2;

		private IEnumerator<AssetBundle> <>s__3;

		private AssetBundle <ab>5__4;

		private string[] <>s__5;

		private int <>s__6;

		private string <assetName>5__7;

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

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

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

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
			<existingBundles>5__1 = null;
			<markedAsset>5__2 = null;
			<>s__3 = null;
			<ab>5__4 = null;
			<>s__5 = null;
			<assetName>5__7 = null;
			<>1__state = -2;
		}

		private bool MoveNext()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			switch (<>1__state)
			{
			default:
				return false;
			case 0:
				<>1__state = -1;
				<>2__current = (object)new WaitForSeconds(5f);
				<>1__state = 1;
				return true;
			case 1:
				<>1__state = -1;
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)">>>VoidHelper>>>Loading Void Attacks AssetBundle...");
				<existingBundles>5__1 = AssetBundle.GetAllLoadedAssetBundles();
				<markedAsset>5__2 = "Assets/Data Assets/Black Thread Attacks/Ball.asset";
				voidAttacksBundle = null;
				<>s__3 = <existingBundles>5__1.GetEnumerator();
				try
				{
					while (<>s__3.MoveNext())
					{
						<ab>5__4 = <>s__3.Current;
						if (<ab>5__4.Contains(<markedAsset>5__2))
						{
							voidAttacksBundle = <ab>5__4;
							((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)(">>>VoidHelper>>>Found VoidAttacksBundle: " + ((Object)<ab>5__4).name));
							break;
						}
						<ab>5__4 = null;
					}
				}
				finally
				{
					if (<>s__3 != null)
					{
						<>s__3.Dispose();
					}
				}
				<>s__3 = null;
				if ((Object)(object)voidAttacksBundle == (Object)null)
				{
					voidAttacksBundle = <>4__this.LoadBundleHelper("blackthread_assets_all.bundle");
				}
				<>s__5 = voidAttacksBundle.GetAllAssetNames();
				for (<>s__6 = 0; <>s__6 < <>s__5.Length; <>s__6++)
				{
					<assetName>5__7 = <>s__5[<>s__6];
					Debug.Log((object)(">>>VoidSong:AssetLogger>>>Asset in bundle: " + <assetName>5__7));
					<assetName>5__7 = null;
				}
				<>s__5 = null;
				((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)">>>VoidHelper>>>AssetBundle Load Attempt Finished.");
				Harmony.CreateAndPatchAll(typeof(VoidSongMod), (string)null);
				return false;
			}
		}

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

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

	private static AssetBundle voidAttacksBundle;

	private static bool canRandomizeAttacks = true;

	private static Dictionary<AssetBundle, string> bundlePaths = new Dictionary<AssetBundle, string>();

	private static GameObject cachedWorkingAttackPrefab = new GameObject();

	private static string GetPlatformFolderName()
	{
		//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)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Invalid comparison between Unknown and I4
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Invalid comparison between Unknown and I4
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Invalid comparison between Unknown and I4
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Invalid comparison between Unknown and I4
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Invalid comparison between Unknown and I4
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Invalid comparison between Unknown and I4
		RuntimePlatform platform = Application.platform;
		RuntimePlatform val = platform;
		if ((int)val <= 2)
		{
			if ((int)val <= 1)
			{
				return "StandaloneOSX";
			}
			if ((int)val == 2)
			{
				goto IL_002d;
			}
		}
		else
		{
			if ((int)val == 7)
			{
				goto IL_002d;
			}
			if ((int)val == 13 || (int)val == 16)
			{
				return "StandaloneLinux64";
			}
		}
		Debug.LogWarning((object)"Didnt find platform, going to default StandaloneWindows64");
		return "StandaloneWindows64";
		IL_002d:
		return "StandaloneWindows64";
	}

	private AssetBundle LoadBundleHelper(string bundleName)
	{
		if ((Object)(object)voidAttacksBundle != (Object)null)
		{
			return voidAttacksBundle;
		}
		string text = Path.Combine(Application.dataPath, "StreamingAssets", "aa", GetPlatformFolderName(), bundleName);
		if (File.Exists(text))
		{
			AssetBundle val = AssetBundle.LoadFromFile(text);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogWarning((object)"Failed to load AssetBundle!");
				return null;
			}
			Debug.Log((object)"AssetBundle loaded successfully.");
			string[] allAssetNames = val.GetAllAssetNames();
			foreach (string text2 in allAssetNames)
			{
				Debug.Log((object)(">>>VoidSong:AssetLogger>>>Asset in bundle: " + text2));
			}
			if (bundleName == "blackthread_assets_all.bundle")
			{
				voidAttacksBundle = val;
			}
			return val;
		}
		Debug.LogWarning((object)("AssetBundle file not found at path: " + text));
		return null;
	}

	private static GameObject LoadPref(string prefName)
	{
		if ((Object)(object)voidAttacksBundle == (Object)null)
		{
			return null;
		}
		return voidAttacksBundle.LoadAsset<GameObject>(prefName);
	}

	private static BlackThreadAttack LoadAttackAsset(string assetName)
	{
		if ((Object)(object)voidAttacksBundle == (Object)null)
		{
			return null;
		}
		return voidAttacksBundle.LoadAsset<BlackThreadAttack>(assetName);
	}

	private void Awake()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin loaded and initialized.");
		((MonoBehaviour)this).StartCoroutine(WaitFix());
	}

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

	[HarmonyPatch(typeof(PlayMakerFSM), "Awake")]
	private static void PostFix(PlayMakerFSM __instance)
	{
		GameObject gameObject = ((Component)__instance).gameObject;
		if ((Object)(object)gameObject == (Object)null || (Object)(object)__instance == (Object)null || __instance.Fsm == null)
		{
			return;
		}
		FsmState state = __instance.Fsm.GetState("P1");
		if (state != null)
		{
			safeSet<SetFloatValue>(state.Actions.OfType<SetFloatValue>().FirstOrDefault((Func<SetFloatValue, bool>)((SetFloatValue a) => a.floatVariable != null && ((NamedVariable)a.floatVariable).Name == "Idle Time")), delegate(SetFloatValue a)
			{
				a.floatValue = FsmFloat.op_Implicit(0f);
			});
			safeSet<SetFloatValue>(state.Actions.OfType<SetFloatValue>().FirstOrDefault((Func<SetFloatValue, bool>)((SetFloatValue a) => a.floatVariable != null && ((NamedVariable)a.floatVariable).Name == "Time Between Attacks")), delegate(SetFloatValue a)
			{
				a.floatValue = FsmFloat.op_Implicit(0f);
			});
			safeSet<SetStringValue>(state.Actions.OfType<SetStringValue>().FirstOrDefault((Func<SetStringValue, bool>)((SetStringValue a) => a.stringVariable != null && ((NamedVariable)a.stringVariable).Name == "isFalse")), delegate(SetStringValue a)
			{
				a.stringValue = FsmString.op_Implicit("");
			});
			safeSet<SetFloatValue>(state.Actions.OfType<SetFloatValue>().FirstOrDefault((Func<SetFloatValue, bool>)((SetFloatValue a) => a.floatVariable != null && ((NamedVariable)a.floatVariable).Name == "time")), delegate(SetFloatValue a)
			{
				a.floatValue = FsmFloat.op_Implicit(0f);
			});
			safeSet<SetFloatValue>(state.Actions.OfType<SetFloatValue>().FirstOrDefault((Func<SetFloatValue, bool>)((SetFloatValue a) => a.floatVariable != null && ((NamedVariable)a.floatVariable).Name == "delay")), delegate(SetFloatValue a)
			{
				a.floatValue = FsmFloat.op_Implicit(0f);
			});
			safeSet<SetFloatValue>(state.Actions.OfType<SetFloatValue>().FirstOrDefault((Func<SetFloatValue, bool>)((SetFloatValue a) => a.floatVariable != null && ((NamedVariable)a.floatVariable).Name == "Delay")), delegate(SetFloatValue a)
			{
				a.floatValue = FsmFloat.op_Implicit(0f);
			});
			safeSet<SetIntValue>(state.Actions.OfType<SetIntValue>().FirstOrDefault((Func<SetIntValue, bool>)((SetIntValue a) => a.intVariable != null && ((NamedVariable)a.intVariable).Name == "damageAmount")), delegate(SetIntValue a)
			{
				a.intValue = FsmInt.op_Implicit(3);
			});
			safeSet<SetColorValue>(state.Actions.OfType<SetColorValue>().FirstOrDefault((Func<SetColorValue, bool>)((SetColorValue a) => a.colorVariable != null && ((NamedVariable)a.colorVariable).Name == "color")), delegate(SetColorValue a)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				a.color = FsmColor.op_Implicit(new Color(23f / 85f, 1f / 85f, 0.47843137f, 1f));
			});
		}
		static void safeSet<T>(T action, Action<T> setter) where T : class
		{
			if (action != null)
			{
				setter(action);
			}
		}
	}

	[HarmonyPatch(typeof(PlayerData), "Awake")]
	private static void PlayerData_PostFix(PlayerData __instance)
	{
		if (__instance != null)
		{
			__instance.blackThreadWorld = true;
			__instance.defeatedCloverDancers = false;
			__instance.cloverDancerRegrowth = false;
			__instance.pilbyKilled = false;
			Debug.Log((object)"PlayerData modified to allow access to verdania again and other qol.");
		}
	}

	[HarmonyPatch(typeof(HealthManager), "Start")]
	[HarmonyPostfix]
	private static void HealthManager_PostFix(HealthManager __instance)
	{
		if ((Object)(object)__instance != (Object)null)
		{
			GameObject gameObject = ((Component)__instance).gameObject;
			__instance.hp *= 3;
			if ((Object)(object)gameObject.GetComponent<BlackThreadState>() == (Object)null)
			{
				gameObject.AddComponent<BlackThreadState>();
				Debug.Log((object)("Added CustomEnemyBlackThreadState to " + ((Object)gameObject).name));
			}
		}
	}

	[HarmonyPatch(typeof(BlackThreadState), "Start")]
	[HarmonyPrefix]
	private static void InjectCustomAttacksToBlackThreadAttack_PreFix(BlackThreadState __instance)
	{
		GameObject gameObject = ((Component)__instance).gameObject;
		if ((Object)(object)__instance == (Object)null)
		{
			__instance = gameObject.AddComponent<BlackThreadState>();
		}
		if (!((Object)(object)__instance != (Object)null))
		{
			return;
		}
		FieldInfo field = typeof(BlackThreadState).GetField("attacks", BindingFlags.Instance | BindingFlags.NonPublic);
		if (field != null)
		{
			Debug.Log((object)"Found BlackThreadAttack.attacks field");
			BlackThreadAttack val = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Ball.asset");
			BlackThreadAttack val2 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Grand Vomit.asset");
			BlackThreadAttack val3 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Heavy Vomit.asset");
			BlackThreadAttack val4 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/MachineGun Shot Garmond.asset");
			BlackThreadAttack val5 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/MachineGun Shot.asset");
			BlackThreadAttack val6 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Shot.asset");
			BlackThreadAttack val7 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Vomit Drop.asset");
			BlackThreadAttack val8 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Vomit.asset");
			BlackThreadAttack val9 = LoadAttackAsset("Assets/Data Assets/Black Thread Attacks/Whip.asset");
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
			{
				Debug.Log((object)">>>VoidHelper>>>One or more BlackThreadAttack assets failed to load!");
			}
			field.SetValue(__instance, new BlackThreadAttack[9] { val, val2, val3, val4, val5, val6, val7, val8, val9 });
			Debug.Log((object)(">>>VoidHelper>>>3 BlackThreadAttacks Added for: " + ((Object)__instance).name));
		}
	}

	[HarmonyPatch(typeof(BlackThreadState), "Start")]
	[HarmonyPostfix]
	private static void BlackThreadState_Start_Postfix(BlackThreadState __instance)
	{
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		EnsureValidPrefabs(__instance);
		BlackThreadAttack[] array = typeof(BlackThreadState).GetField("attacks", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance) as BlackThreadAttack[];
		Dictionary<BlackThreadAttack, GameObject> dictionary = typeof(BlackThreadState).GetField("spawnedAttackObjs", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance) as Dictionary<BlackThreadAttack, GameObject>;
		if (array != null && dictionary != null)
		{
			BlackThreadAttack[] array2 = array;
			foreach (BlackThreadAttack val in array2)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.Prefab != (Object)null && !dictionary.ContainsKey(val))
				{
					GameObject val2 = Object.Instantiate<GameObject>(val.Prefab, ((Component)__instance).transform);
					val2.transform.localPosition = Vector3.zero;
					val2.SetActive(false);
					dictionary[val] = val2;
					Debug.Log((object)("VoidSong: Spawned prefab for " + ((Object)val).name));
				}
			}
		}
		__instance.BecomeThreadedNoSing();
	}

	private static void EnsureValidPrefabs(BlackThreadState state)
	{
		if (!(typeof(BlackThreadState).GetField("attacks", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(state) is BlackThreadAttack[] array))
		{
			return;
		}
		BlackThreadAttack[] array2 = array;
		foreach (BlackThreadAttack val in array2)
		{
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			FieldInfo field = typeof(BlackThreadAttack).GetField("Prefab", BindingFlags.Instance | BindingFlags.Public);
			object? obj = field?.GetValue(val);
			GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val2 == (Object)null)
			{
				GameObject val3 = null;
				if ((Object)(object)cachedWorkingAttackPrefab != (Object)null)
				{
					val3 = Object.Instantiate<GameObject>(cachedWorkingAttackPrefab);
					Debug.Log((object)("VoidSong_FallbackManager: Using cached working prefab " + ((Object)val3).name + " for attack " + ((Object)val).name));
				}
				else
				{
					val3 = LoadPref("Assets/Prefabs/Props/Thread Spines/thread_spines_standard.prefab");
				}
				if ((Object)(object)val3 != (Object)null)
				{
					field?.SetValue(val, val3);
					((Object)val).name = ((Object)val).name + "_VsFallbackFix";
					Debug.Log((object)("VoidSong_FallbackManager: Assigned real prefab " + ((Object)val3).name + " to attack " + ((Object)val).name));
				}
			}
			else
			{
				Debug.Log((object)("VoidSong_FallbackManager: Attack " + ((Object)val).name + " already has a valid prefab: " + ((Object)val2).name));
				Debug.Log((object)"VoidSong_FallbackManager: This prefab will be new fallback obj");
				cachedWorkingAttackPrefab = val2;
			}
		}
	}

	[HarmonyPatch(typeof(BlackThreadState), "ChooseAttack")]
	[HarmonyPrefix]
	private static bool ForceChooseAttack_Prefix(BlackThreadState __instance, bool force)
	{
		if (typeof(BlackThreadState).GetField("attacks", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance) is BlackThreadAttack[] array && array.Length != 0)
		{
			BlackThreadAttack val = array[Random.Range(0, array.Length)];
			typeof(BlackThreadState).GetField("chosenAttack", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(__instance, val);
			typeof(BlackThreadState).GetField("hasChosenAttack", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(__instance, true);
			Debug.Log((object)("Forced attack: " + ((Object)val).name + " | for: " + ((Object)__instance).name));
			return false;
		}
		return true;
	}

	[HarmonyPatch(typeof(BlackThreadState), "BecomeThreadedRoutine")]
	[HarmonyPrefix]
	private static bool BecomeThreadedRoutine_Prefix(BlackThreadState __instance, ref IEnumerator __result, bool waitForSing)
	{
		FieldInfo field = typeof(BlackThreadState).GetField("singFsm", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(BlackThreadState).GetField("stunControlFsm", BindingFlags.Instance | BindingFlags.NonPublic);
		object? obj = field?.GetValue(__instance);
		PlayMakerFSM val = (PlayMakerFSM)((obj is PlayMakerFSM) ? obj : null);
		object? obj2 = field2?.GetValue(__instance);
		PlayMakerFSM val2 = (PlayMakerFSM)((obj2 is PlayMakerFSM) ? obj2 : null);
		if ((Object)(object)val != (Object)null || (Object)(object)val2 != (Object)null)
		{
			Debug.Log((object)(">>>VoidSong_EnemyVoidSkipper>>>: " + ((Object)__instance).name + " has no sing/stun FSM, using Simple threading that avoids waits."));
			__result = SimpleThreadRoutine(__instance);
			return false;
		}
		return true;
	}

	[IteratorStateMachine(typeof(<SimpleThreadRoutine>d__18))]
	private static IEnumerator SimpleThreadRoutine(BlackThreadState state)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <SimpleThreadRoutine>d__18(0)
		{
			state = state
		};
	}

	[HarmonyPatch(typeof(BlackThreadState), "ThreadAttackTest")]
	[HarmonyPrefix]
	private static bool ThreadAttackTest_Prefix(BlackThreadState __instance, ref IEnumerator __result)
	{
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		object? obj = typeof(BlackThreadState).GetField("chosenAttack", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
		BlackThreadAttack val = (BlackThreadAttack)((obj is BlackThreadAttack) ? obj : null);
		BlackThreadAttack[] array = typeof(BlackThreadState).GetField("attacks", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance) as BlackThreadAttack[];
		Dictionary<BlackThreadAttack, GameObject> dictionary = typeof(BlackThreadState).GetField("spawnedAttackObjs", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance) as Dictionary<BlackThreadAttack, GameObject>;
		if ((Object)(object)val == (Object)null)
		{
			Debug.LogWarning((object)("VoidSong: " + ((Object)__instance).name + " has no chosenAttack, skipping."));
			__result = DummyIdleRoutine();
			return false;
		}
		if (canRandomizeAttacks)
		{
			val = array[Random.Range(0, array.Length)];
		}
		GameObject val2 = null;
		if (dictionary != null && dictionary.ContainsKey(val))
		{
			val2 = dictionary[val];
		}
		if ((Object)(object)val2 == (Object)null)
		{
			object? obj2 = typeof(BlackThreadAttack).GetField("Prefab", BindingFlags.Instance | BindingFlags.Public)?.GetValue(val);
			GameObject val3 = (GameObject)((obj2 is GameObject) ? obj2 : null);
			if (!((Object)(object)val3 != (Object)null))
			{
				Debug.LogWarning((object)("VoidSong: " + ((Object)__instance).name + " has no prefab for " + ((Object)val).name + ", skipping."));
				__result = DummyIdleRoutine();
				return false;
			}
			val2 = Object.Instantiate<GameObject>(val3, ((Component)__instance).transform.position, Quaternion.identity);
			val2.SetActive(true);
			Debug.Log((object)("VoidSong: Fallback-spawned prefab " + ((Object)val3).name + " for " + ((Object)__instance).name));
		}
		__result = ActivateAttackRoutine(__instance, val2);
		return false;
	}

	[IteratorStateMachine(typeof(<ActivateAttackRoutine>d__20))]
	private static IEnumerator ActivateAttackRoutine(BlackThreadState __instance, GameObject attackObj)
	{
		//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
		return new <ActivateAttackRoutine>d__20(0)
		{
			__instance = __instance,
			attackObj = attackObj
		};
	}

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