using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using RoR2;
using UnityEngine;
using UnityEngine.AddressableAssets;

[assembly: IgnoresAccessChecksTo("RoR2")]
[assembly: IgnoresAccessChecksTo("HGCSharpUtils")]
[assembly: IgnoresAccessChecksTo("HGUnityUtils")]
[assembly: IgnoresAccessChecksTo("com.unity.multiplayer-hlapi.Runtime")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: UnverifiableCode]
namespace UnifiedStagePool
{
	[BepInPlugin("custom.UnifiedStagePool", "UnifiedStagePool", "2.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class UnifiedStagePoolPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Log;

		private ConfigEntry<bool> addReformedAltar;

		private ConfigEntry<bool> addTreebornColony;

		private ConfigEntry<bool> addConduitCanyon;

		private ConfigEntry<bool> mergeLoopVariants;

		private ConfigEntry<bool> routeNormalExit;

		private ConfigEntry<float> addedWeight;

		private ConfigEntry<string> extraStages;

		private static readonly FieldInfo entriesField = typeof(SceneCollection).GetField("_sceneEntries", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			addReformedAltar = ((BaseUnityPlugin)this).Config.Bind<bool>("Stages", "ReformedAltar", true, "Add Reformed Altar (lemuriantemple) to the stage 2 pool, before and after looping.");
			addTreebornColony = ((BaseUnityPlugin)this).Config.Bind<bool>("Stages", "TreebornColony", true, "Add Treeborn Colony (habitat) and its loop variant (habitatfall) to the stage 3 pool, before and after looping.");
			addConduitCanyon = ((BaseUnityPlugin)this).Config.Bind<bool>("Stages", "ConduitCanyon", true, "Add Conduit Canyon (conduitcanyon) to the stage 4 pool, before and after looping.");
			extraStages = ((BaseUnityPlugin)this).Config.Bind<string>("Stages", "ExtraStages", string.Empty, "Extra scenes as name:stage pairs, comma separated (e.g. mymap:3).");
			mergeLoopVariants = ((BaseUnityPlugin)this).Config.Bind<bool>("Loops", "MergeLoopVariants", true, "Every stage pool contains both the normal and the loop-variant stages, before and after looping (villagenight, lakesnight, etc.).");
			addedWeight = ((BaseUnityPlugin)this).Config.Bind<float>("Stages", "AddedStageWeight", 1f, "Selection weight for added stages (vanilla stages are 1).");
			routeNormalExit = ((BaseUnityPlugin)this).Config.Bind<bool>("Routes", "RouteStagesUseNormalExit", true, "Added route stages lead into the normal pool of the next stage instead of continuing their route.");
			try
			{
				Apply();
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private static SceneEntry[] Raw(SceneCollection c)
		{
			if ((Object)(object)c == (Object)null || entriesField == null)
			{
				return (SceneEntry[])(object)new SceneEntry[0];
			}
			return (SceneEntry[])(((object)(SceneEntry[])entriesField.GetValue(c)) ?? ((object)new SceneEntry[0]));
		}

		private static T Load<T>(string path) where T : Object
		{
			//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)
			try
			{
				return Addressables.LoadAssetAsync<T>((object)path).WaitForCompletion();
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Could not load " + path + ": " + ex.Message));
				return (T)(object)null;
			}
		}

		private static SceneDef Scene(string name)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			dictionary.Add("lemuriantemple", "RoR2/DLC2/lemuriantemple/lemuriantemple.asset");
			dictionary.Add("habitat", "RoR2/DLC2/habitat/habitat.asset");
			dictionary.Add("habitatfall", "RoR2/DLC2/habitatfall/habitatfall.asset");
			dictionary.Add("conduitcanyon", "RoR2/DLC3/conduitcanyon/conduitcanyon.asset");
			Dictionary<string, string> dictionary2 = dictionary;
			if (dictionary2.TryGetValue(name, out var value))
			{
				SceneDef val = Load<SceneDef>(value);
				if (Object.op_Implicit((Object)(object)val))
				{
					return val;
				}
			}
			SceneDef val2 = SceneCatalog.FindSceneDef(name);
			if (Object.op_Implicit((Object)(object)val2))
			{
				return val2;
			}
			string[] array = new string[5] { "Base", "DLC1", "DLC2", "DLC3", "DLC4" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				SceneDef val3 = null;
				try
				{
					val3 = Addressables.LoadAssetAsync<SceneDef>((object)("RoR2/" + text + "/" + name + "/" + name + ".asset")).WaitForCompletion();
				}
				catch
				{
				}
				if (Object.op_Implicit((Object)(object)val3))
				{
					return val3;
				}
			}
			Log.LogWarning((object)("Scene not found: " + name));
			return null;
		}

		private void Apply()
		{
			SceneCollection[] array = (SceneCollection[])(object)new SceneCollection[6];
			SceneCollection[] array2 = (SceneCollection[])(object)new SceneCollection[6];
			for (int i = 1; i <= 5; i++)
			{
				array[i] = Load<SceneCollection>("RoR2/Base/SceneGroups/sgStage" + i + ".asset");
				array2[i] = Load<SceneCollection>("RoR2/Base/SceneGroups/loopSgStage" + i + ".asset");
			}
			if (mergeLoopVariants.Value)
			{
				for (int j = 1; j <= 5; j++)
				{
					if (!Object.op_Implicit((Object)(object)array[j]) || !Object.op_Implicit((Object)(object)array2[j]))
					{
						continue;
					}
					List<SceneDef> list = (from e in Raw(array[j])
						select e.sceneDef into d
						where (Object)(object)d != (Object)null
						select d).ToList();
					List<SceneDef> list2 = (from e in Raw(array2[j])
						select e.sceneDef into d
						where (Object)(object)d != (Object)null
						select d).ToList();
					foreach (SceneDef item in list2)
					{
						Add(item, array[j]);
					}
					foreach (SceneDef item2 in list)
					{
						Add(item2, array2[j]);
					}
				}
			}
			List<KeyValuePair<SceneDef, int>> list3 = new List<KeyValuePair<SceneDef, int>>();
			if (addReformedAltar.Value)
			{
				list3.Add(new KeyValuePair<SceneDef, int>(Scene("lemuriantemple"), 2));
			}
			if (addTreebornColony.Value)
			{
				list3.Add(new KeyValuePair<SceneDef, int>(Scene("habitat"), 3));
				list3.Add(new KeyValuePair<SceneDef, int>(Scene("habitatfall"), 3));
			}
			if (addConduitCanyon.Value)
			{
				list3.Add(new KeyValuePair<SceneDef, int>(Scene("conduitcanyon"), 4));
			}
			string[] array3 = extraStages.Value.Split(new char[1] { ',' });
			foreach (string text in array3)
			{
				string[] array4 = text.Trim().Split(new char[1] { ':' });
				if (array4.Length == 2 && int.TryParse(array4[1], out var result) && result >= 1 && result <= 5)
				{
					list3.Add(new KeyValuePair<SceneDef, int>(Scene(array4[0].Trim()), result));
				}
			}
			foreach (KeyValuePair<SceneDef, int> item3 in list3)
			{
				if ((Object)(object)item3.Key == (Object)null || !Object.op_Implicit((Object)(object)item3.Key))
				{
					Log.LogWarning((object)"Skipping a stage that failed to load.");
					continue;
				}
				Add(item3.Key, array[item3.Value]);
				Add(item3.Key, array2[item3.Value]);
				if (!routeNormalExit.Value || item3.Value >= 5)
				{
					continue;
				}
				if (Object.op_Implicit((Object)(object)array[item3.Value + 1]))
				{
					item3.Key.destinationsGroup = array[item3.Value + 1];
				}
				if (Object.op_Implicit((Object)(object)array2[item3.Value + 1]))
				{
					FieldInfo field = typeof(SceneDef).GetField("loopedDestinationsGroup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null)
					{
						field.SetValue(item3.Key, array2[item3.Value + 1]);
					}
				}
			}
			for (int num2 = 1; num2 <= 5; num2++)
			{
				if (Object.op_Implicit((Object)(object)array[num2]))
				{
					Log.LogInfo((object)("sgStage" + num2 + ": " + string.Join(", ", from e in Raw(array[num2])
						select (!((Object)(object)e.sceneDef != (Object)null)) ? "NULL" : ((Object)e.sceneDef).name)));
				}
				if (Object.op_Implicit((Object)(object)array2[num2]))
				{
					Log.LogInfo((object)("loopSgStage" + num2 + ": " + string.Join(", ", from e in Raw(array2[num2])
						select (!((Object)(object)e.sceneDef != (Object)null)) ? "NULL" : ((Object)e.sceneDef).name)));
				}
			}
		}

		private void Add(SceneDef scene, SceneCollection collection)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scene == (Object)null || (Object)(object)collection == (Object)null || entriesField == null)
			{
				return;
			}
			SceneEntry[] array = (SceneEntry[])(((object)(SceneEntry[])entriesField.GetValue(collection)) ?? ((object)new SceneEntry[0]));
			SceneEntry[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				SceneEntry val = array2[i];
				if (object.ReferenceEquals(val.sceneDef, scene))
				{
					return;
				}
			}
			SceneEntry item = new SceneEntry
			{
				sceneDef = scene
			};
			((SceneEntry)(ref item)).weight = addedWeight.Value;
			List<SceneEntry> list = array.Where((SceneEntry e) => (Object)(object)e.sceneDef != (Object)null).ToList();
			list.Add(item);
			entriesField.SetValue(collection, list.ToArray());
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public string AssemblyName { get; }

		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
			AssemblyName = assemblyName;
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using RoR2;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;

[assembly: IgnoresAccessChecksTo("RoR2")]
[assembly: IgnoresAccessChecksTo("HGCSharpUtils")]
[assembly: IgnoresAccessChecksTo("HGUnityUtils")]
[assembly: IgnoresAccessChecksTo("com.unity.multiplayer-hlapi.Runtime")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: UnverifiableCode]
namespace AlloyEncounters
{
	public class AlloyMarker : MonoBehaviour
	{
		public enum Kind
		{
			Stage2Hunter,
			SirenHunter,
			ConduitHunter,
			WorshipUnit
		}

		public Kind kind;

		public bool invulnerable;

		public bool statsApplied;

		public bool dropsGiven;
	}
	[BepInPlugin("custom.AlloyEncounters", "AlloyEncounters", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class AlloyEncountersPlugin : BaseUnityPlugin
	{
		public const string QualityGUID = "com.Gorakh.ItemQualities";

		private const string SirenScene = "shipgraveyard";

		private const string ConduitScene = "conduitcanyon";

		internal static AlloyEncountersPlugin Instance;

		internal static ManualLogSource Log;

		internal static ConfigEntry<bool> Stage2Hunter;

		internal static ConfigEntry<bool> Stage2ApplyOnLoops;

		internal static ConfigEntry<bool> SirenForceTeleporter;

		internal static ConfigEntry<bool> SirenWorshipRequired;

		internal static ConfigEntry<bool> SirenForceSolusBoss;

		internal static ConfigEntry<bool> SirenHunter;

		internal static ConfigEntry<bool> SirenChat;

		internal static ConfigEntry<bool> SirenDisableDescent;

		internal static ConfigEntry<float> SirenHunterFallbackSeconds;

		internal static ConfigEntry<bool> SirenHunterInvulnerable;

		internal static ConfigEntry<string> DescentCardNames;

		internal static ConfigEntry<float> WorshipDamageMult;

		internal static ConfigEntry<float> ConduitHunterHpMult;

		internal static ConfigEntry<float> SirenHunterHpMult;

		internal static ConfigEntry<bool> ConduitDrops;

		internal static ConfigEntry<bool> SirenDrops;

		internal static ConfigEntry<bool> WorshipDrops;

		internal static ConfigEntry<bool> WorshipLegendaryReds;

		internal static ConfigEntry<float> RedConversionWindow;

		internal static ConfigEntry<int> RedConversionCount;

		private static CharacterSpawnCard hunterCard;

		private static CharacterSpawnCard solusControlCard;

		private static BodyIndex hunterBody = (BodyIndex)(-1);

		private static BodyIndex worshipBody = (BodyIndex)(-1);

		private static BodyIndex solusControlBody = (BodyIndex)(-1);

		private static float redWindowEnd = -1f;

		private static int redConversionsLeft;

		private static readonly FieldInfo monstersClearedField = AccessTools.Field(typeof(TeleporterInteraction), "monstersCleared");

		private static readonly FieldInfo defeatedServerField = AccessTools.Field(typeof(CombatSquad), "defeatedServer");

		private static bool QualityInstalled
		{
			[CompilerGenerated]
			get
			{
				return Chainloader.PluginInfos.ContainsKey("com.Gorakh.ItemQualities");
			}
		}

		private void Awake()
		{
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Expected O, but got Unknown
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Expected O, but got Unknown
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Expected O, but got Unknown
			//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e7: Expected O, but got Unknown
			//IL_04db: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e9: Expected O, but got Unknown
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Stage2Hunter = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage2", "InvincibleOverloadingHunter", true, "Spawn one unkillable Overloading Alloy Hunter when any stage 2 teleporter starts. It is despawned once the teleporter finishes and its boss is dead.");
			Stage2ApplyOnLoops = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage2", "ApplyOnLoops", true, "Also apply on stage 2 of later loops (stage 7, 12, ...).");
			SirenForceTeleporter = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "WorshipUnitActivatesTeleporter", true, "Spawning the Alloy Worship Unit forces the teleporter to activate.");
			SirenWorshipRequired = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "WorshipUnitRequiredForTeleporter", true, "The Alloy Worship Unit must be killed before the teleporter can finish.");
			SirenForceSolusBoss = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "ForceSolusControlUnitBoss", true, "The teleporter boss is always Solus Control Units, even during family events.");
			SirenHunter = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "OverloadingHunterBoss", true, "Spawn an Overloading Alloy Hunter as an extra teleporter boss. It is unkillable until all Solus Control Units are dead.");
			SirenHunterInvulnerable = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "HunterInvulnerableUntilSolusDead", false, "If true, the Siren's Call hunter cannot be damaged until all Solus Control Units are dead. If false, it is a normal teleporter boss from the start.");
			SirenHunterFallbackSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("SirensCall", "HunterVulnerableFallbackSeconds", 60f, "If no Solus Control Unit has spawned after this many seconds, the hunter becomes vulnerable anyway.");
			SirenChat = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "SirenChatMessage", true, "Broadcast 'Siren: Awoooooooooo' when the teleporter activates.");
			SirenDisableDescent = ((BaseUnityPlugin)this).Config.Bind<bool>("SirensCall", "DisableShrineOfDescent", true, "Prevent the Shrine of Descent from spawning on Siren's Call.");
			DescentCardNames = ((BaseUnityPlugin)this).Config.Bind<string>("SirensCall", "DescentSpawnCardNames", "Descent,Descend", "Comma-separated name fragments of spawn cards blocked on Siren's Call when DisableShrineOfDescent is on.");
			WorshipDamageMult = ((BaseUnityPlugin)this).Config.Bind<float>("Stats", "WorshipUnitDamageMultiplier", 2f, "Damage multiplier for the Alloy Worship Unit.");
			ConduitHunterHpMult = ((BaseUnityPlugin)this).Config.Bind<float>("Stats", "ConduitCanyonHunterHealthMultiplier", 2f, "Health multiplier for the Alloy Hunter in Conduit Canyon.");
			SirenHunterHpMult = ((BaseUnityPlugin)this).Config.Bind<float>("Stats", "SirensCallHunterHealthMultiplier", 2f, "Health multiplier for the Overloading Alloy Hunter on Siren's Call.");
			ConduitDrops = ((BaseUnityPlugin)this).Config.Bind<bool>("Drops", "ConduitCanyonHunterDrops", true, "Conduit Canyon Alloy Hunter drops Faulty Conductor (Epic with Quality) + Polylute.");
			SirenDrops = ((BaseUnityPlugin)this).Config.Bind<bool>("Drops", "SirensCallHunterDrops", true, "Siren's Call Overloading Alloy Hunter drops Faulty Conductor (Legendary with Quality) + Polylute + Unstable Tesla Coil + Silence Between Two Strikes.");
			WorshipDrops = ((BaseUnityPlugin)this).Config.Bind<bool>("Drops", "WorshipUnitDropsEmpathyCores", true, "Alloy Worship Unit drops Empathy Cores (Legendary with Quality).");
			WorshipLegendaryReds = ((BaseUnityPlugin)this).Config.Bind<bool>("Drops", "WorshipUnitRedsLegendary", true, "With Quality installed, red items dropped when the Alloy Worship Unit dies become Legendary.");
			RedConversionWindow = ((BaseUnityPlugin)this).Config.Bind<float>("Drops", "RedConversionWindowSeconds", 30f, "How long after the Worship Unit dies its red reward drops are converted.");
			RedConversionCount = ((BaseUnityPlugin)this).Config.Bind<int>("Drops", "RedConversionCount", 0, "How many red drops to convert. 0 = one per player (matches the vanilla reward count).");
			AsyncOperationHandle<CharacterSpawnCard> val = Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/DLC3/VultureHunter/cscVultureHunter.asset");
			val.Completed += delegate(AsyncOperationHandle<CharacterSpawnCard> h)
			{
				hunterCard = h.Result;
			};
			AsyncOperationHandle<CharacterSpawnCard> val2 = Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/RoboBallBoss/cscRoboBallBoss.asset");
			val2.Completed += delegate(AsyncOperationHandle<CharacterSpawnCard> h)
			{
				solusControlCard = h.Result;
			};
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, (Action)delegate
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: 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_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				hunterBody = BodyCatalog.FindBodyIndex("VultureHunterBody");
				worshipBody = BodyCatalog.FindBodyIndex("SuperRoboBallBossBody");
				solusControlBody = BodyCatalog.FindBodyIndex("RoboBallBossBody");
			});
			Harmony val3 = new Harmony("custom.AlloyEncounters");
			PatchPrefix(val3, typeof(HealthComponent), "TakeDamage", "BlockDamagePrefix");
			PatchPrefix(val3, typeof(HealthComponent), "TakeDamageProcess", "BlockDamagePrefix");
			PatchPrefix(val3, typeof(HealthComponent), "Suicide", "BlockDamagePrefix");
			MethodInfo[] methods = typeof(CharacterMaster).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == "TrueKill")
				{
					val3.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(AlloyEncountersPlugin), "BlockTrueKillPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CombatDirector), "SetNextSpawnAsBoss", (Type[])null, (Type[])null);
			HarmonyMethod val4 = new HarmonyMethod(typeof(AlloyEncountersPlugin), "SetNextSpawnAsBossPostfix", (Type[])null);
			val3.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, val4, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			val3.Patch((MethodBase)AccessTools.Method(typeof(GenericPickupController), "CreatePickup", (Type[])null, (Type[])null), new HarmonyMethod(typeof(AlloyEncountersPlugin), "CreatePickupPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo3 = AccessTools.Method(typeof(DLC4SacrificeZoneSpawner), "OnPrePopulateSceneServer", (Type[])null, (Type[])null);
			if (methodInfo3 != null)
			{
				val3.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(AlloyEncountersPlugin), "SacrificeZonePrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			val3.Patch((MethodBase)AccessTools.Method(typeof(DirectorCore), "TrySpawnObject", (Type[])null, (Type[])null), new HarmonyMethod(typeof(AlloyEncountersPlugin), "TrySpawnObjectPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			TeleporterInteraction.onTeleporterBeginChargingGlobal += OnTeleporterBeginCharging;
			CharacterBody.onBodyStartGlobal += OnBodyStart;
			GlobalEventManager.onCharacterDeathServer += OnCharacterDeath;
		}

		private static void PatchPrefix(Harmony h, Type t, string name, string prefix)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			MethodInfo[] methods = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == name)
				{
					h.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(AlloyEncountersPlugin), prefix, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static string SceneName()
		{
			SceneDef mostRecentSceneDef = SceneCatalog.mostRecentSceneDef;
			return (!Object.op_Implicit((Object)(object)mostRecentSceneDef)) ? string.Empty : mostRecentSceneDef.cachedName;
		}

		private static PickupIndex ToQuality(PickupIndex idx, int tier)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			if (!QualityInstalled || idx == PickupIndex.none)
			{
				return idx;
			}
			try
			{
				Type type = Type.GetType("ItemQualities.QualityCatalog, ItemQualities");
				Type type2 = Type.GetType("ItemQualities.QualityTier, ItemQualities");
				if (type == null || type2 == null)
				{
					return idx;
				}
				MethodInfo method = type.GetMethod("GetPickupIndexOfQuality", new Type[2]
				{
					typeof(PickupIndex),
					type2
				});
				if (method == null)
				{
					return idx;
				}
				return (PickupIndex)method.Invoke(null, new object[2]
				{
					idx,
					Enum.ToObject(type2, tier)
				});
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
				return idx;
			}
		}

		private static PickupIndex ItemPickup(string itemName)
		{
			//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_0009: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			ItemIndex val = ItemCatalog.FindItemIndex(itemName);
			return ((int)val != -1) ? PickupCatalog.FindPickupIndex(val) : PickupIndex.none;
		}

		private static PickupIndex EquipmentPickup(string name)
		{
			//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_0009: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			EquipmentIndex val = EquipmentCatalog.FindEquipmentIndex(name);
			return ((int)val != -1) ? PickupCatalog.FindPickupIndex(val) : PickupIndex.none;
		}

		private static void DropAll(List<PickupIndex> pickups, Vector3 pos)
		{
			//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_0053: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			pickups.RemoveAll((PickupIndex p) => p == PickupIndex.none);
			if (pickups.Count != 0)
			{
				float num = 360f / (float)pickups.Count;
				for (int num2 = 0; num2 < pickups.Count; num2++)
				{
					Vector3 val = Quaternion.AngleAxis(num * (float)num2, Vector3.up) * Vector3.forward;
					PickupDropletController.CreatePickupDroplet(new UniquePickup(pickups[num2]), pos + Vector3.up * 2f, Vector3.up * 20f + val * 8f, false, false);
				}
			}
		}

		private static void MultiplyStat(Inventory inv, ItemDef boostItem, float mult)
		{
			if (Object.op_Implicit((Object)(object)inv) && Object.op_Implicit((Object)(object)boostItem) && !(mult <= 1f))
			{
				int itemCountPermanent = inv.GetItemCountPermanent(boostItem);
				float num = 1f + 0.1f * (float)itemCountPermanent;
				int num2 = Mathf.RoundToInt((num * mult - num) * 10f);
				if (num2 > 0)
				{
					inv.GiveItemPermanent(boostItem, num2);
				}
			}
		}

		private static void ApplyOverloading(Inventory inv)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			EliteDef lightning = Elites.Lightning;
			if (Object.op_Implicit((Object)(object)inv) && Object.op_Implicit((Object)(object)lightning) && Object.op_Implicit((Object)(object)lightning.eliteEquipmentDef))
			{
				inv.SetEquipmentIndex(lightning.eliteEquipmentDef.equipmentIndex);
				int num = Mathf.RoundToInt((lightning.healthBoostCoefficient - 1f) * 10f);
				int num2 = Mathf.RoundToInt((lightning.damageBoostCoefficient - 1f) * 10f);
				if (num > 0)
				{
					inv.GiveItemPermanent(Items.BoostHp, num);
				}
				if (num2 > 0)
				{
					inv.GiveItemPermanent(Items.BoostDamage, num2);
				}
			}
		}

		private static AlloyMarker MarkerOf(CharacterMaster master)
		{
			return (!Object.op_Implicit((Object)(object)master)) ? null : ((Component)master).GetComponent<AlloyMarker>();
		}

		private static AlloyMarker MarkerOfBodyObject(GameObject bodyObj)
		{
			if (!Object.op_Implicit((Object)(object)bodyObj))
			{
				return null;
			}
			CharacterBody component = bodyObj.GetComponent<CharacterBody>();
			return (!Object.op_Implicit((Object)(object)component) || !Object.op_Implicit((Object)(object)component.master)) ? null : ((Component)component.master).GetComponent<AlloyMarker>();
		}

		private static void Despawn(CharacterMaster master)
		{
			if (!Object.op_Implicit((Object)(object)master))
			{
				return;
			}
			try
			{
				master.DestroyBody();
				NetworkServer.Destroy(((Component)master).gameObject);
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private static bool BlockDamagePrefix(HealthComponent __instance)
		{
			if (!Object.op_Implicit((Object)(object)__instance))
			{
				return true;
			}
			AlloyMarker alloyMarker = MarkerOfBodyObject(((Component)__instance).gameObject);
			return !Object.op_Implicit((Object)(object)alloyMarker) || !alloyMarker.invulnerable;
		}

		private static bool BlockTrueKillPrefix(CharacterMaster __instance)
		{
			AlloyMarker alloyMarker = MarkerOf(__instance);
			return !Object.op_Implicit((Object)(object)alloyMarker) || !alloyMarker.invulnerable;
		}

		private static void ProtectBody(CharacterBody body)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)body))
			{
				body.bodyFlags = (BodyFlags)(body.bodyFlags | 0x810);
			}
		}

		private static void SpawnHunter(TeleporterInteraction tp, AlloyMarker.Kind kind, Action<CharacterMaster> onReady)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)hunterCard) || !Object.op_Implicit((Object)(object)DirectorCore.instance))
			{
				Log.LogError((object)"Alloy Hunter spawn card not loaded.");
				return;
			}
			CharacterSpawnCard obj = hunterCard;
			DirectorPlacementRule val = new DirectorPlacementRule();
			val.placementMode = (PlacementMode)1;
			val.spawnOnTarget = ((Component)tp).transform;
			val.position = ((Component)tp).transform.position;
			val.minDistance = 15f;
			val.maxDistance = 60f;
			DirectorSpawnRequest val2 = new DirectorSpawnRequest((SpawnCard)(object)obj, val, new Xoroshiro128Plus(Run.instance.stageRng.nextUlong));
			val2.teamIndexOverride = (TeamIndex)2;
			val2.ignoreTeamMemberLimit = true;
			DirectorSpawnRequest val3 = val2;
			val3.onSpawnedServer = delegate(SpawnResult result)
			{
				if (result.success && Object.op_Implicit((Object)(object)result.spawnedInstance))
				{
					CharacterMaster component = result.spawnedInstance.GetComponent<CharacterMaster>();
					if (Object.op_Implicit((Object)(object)component))
					{
						AlloyMarker alloyMarker = ((Component)component).gameObject.AddComponent<AlloyMarker>();
						alloyMarker.kind = kind;
						alloyMarker.invulnerable = kind == AlloyMarker.Kind.Stage2Hunter || SirenHunterInvulnerable.Value;
						ApplyOverloading(component.inventory);
						if (kind == AlloyMarker.Kind.SirenHunter)
						{
							MultiplyStat(component.inventory, Items.BoostHp, SirenHunterHpMult.Value);
						}
						alloyMarker.statsApplied = true;
						CharacterBody body = component.GetBody();
						if (Object.op_Implicit((Object)(object)body))
						{
							ProtectBody(body);
						}
						component.onBodyStart += ProtectBody;
						onReady?.Invoke(component);
					}
				}
			};
			GameObject val4 = DirectorCore.instance.TrySpawnObject(val3);
			if (!Object.op_Implicit((Object)(object)val4))
			{
				Log.LogWarning((object)string.Concat("Failed to place Alloy Hunter (", kind, ")."));
			}
		}

		private void OnTeleporterBeginCharging(TeleporterInteraction tp)
		{
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)tp) || !Object.op_Implicit((Object)(object)Run.instance))
			{
				return;
			}
			try
			{
				int stageClearCount = Run.instance.stageClearCount;
				bool flag = stageClearCount % 5 == 1 && (stageClearCount == 1 || Stage2ApplyOnLoops.Value);
				string text = SceneName();
				if (Stage2Hunter.Value && flag && text != "shipgraveyard")
				{
					SpawnHunter(tp, AlloyMarker.Kind.Stage2Hunter, delegate(CharacterMaster master)
					{
						((MonoBehaviour)this).StartCoroutine(Stage2Watcher(tp, master));
					});
				}
				if (!(text == "shipgraveyard"))
				{
					return;
				}
				if (SirenChat.Value)
				{
					BroadcastSiren();
				}
				if (SirenHunter.Value)
				{
					SpawnHunter(tp, AlloyMarker.Kind.SirenHunter, delegate(CharacterMaster master)
					{
						master.isBoss = true;
						((MonoBehaviour)this).StartCoroutine(SirenHunterWatcher(tp, master));
					});
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private IEnumerator Stage2Watcher(TeleporterInteraction tp, CharacterMaster master)
		{
			WaitForSeconds wait = new WaitForSeconds(0.5f);
			while (Object.op_Implicit((Object)(object)master) && Object.op_Implicit((Object)(object)tp))
			{
				CombatSquad squad = ((!Object.op_Implicit((Object)(object)tp.bossGroup)) ? null : tp.bossGroup.combatSquad);
				bool bossDead = !Object.op_Implicit((Object)(object)squad) || squad.memberCount == 0;
				if (tp.isCharged && bossDead)
				{
					break;
				}
				yield return wait;
			}
			Despawn(master);
		}

		private static void SetMonstersCleared(TeleporterInteraction tp, bool value)
		{
			try
			{
				if (Object.op_Implicit((Object)(object)tp) && monstersClearedField != null)
				{
					monstersClearedField.SetValue(tp, value);
				}
			}
			catch
			{
			}
		}

		private static bool SquadDefeated(CombatSquad squad)
		{
			try
			{
				return Object.op_Implicit((Object)(object)squad) && defeatedServerField != null && (bool)defeatedServerField.GetValue(squad);
			}
			catch
			{
				return false;
			}
		}

		private static CombatSquad TeleporterSquad(TeleporterInteraction tp)
		{
			if (!Object.op_Implicit((Object)(object)tp))
			{
				return null;
			}
			CombatSquad val = null;
			try
			{
				if (Object.op_Implicit((Object)(object)tp.bossGroup))
				{
					val = tp.bossGroup.combatSquad;
				}
			}
			catch
			{
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				try
				{
					if (Object.op_Implicit((Object)(object)tp.bossDirector))
					{
						val = tp.bossDirector.combatSquad;
					}
				}
				catch
				{
				}
			}
			if (!Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)tp.bossGroup))
			{
				val = ((Component)tp.bossGroup).GetComponent<CombatSquad>();
			}
			return val;
		}

		private static int CountAliveSolusControlUnits()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			int num = 0;
			foreach (CharacterBody readOnlyInstances in CharacterBody.readOnlyInstancesList)
			{
				if (Object.op_Implicit((Object)(object)readOnlyInstances) && readOnlyInstances.bodyIndex == solusControlBody && Object.op_Implicit((Object)(object)readOnlyInstances.healthComponent) && readOnlyInstances.healthComponent.alive && Object.op_Implicit((Object)(object)readOnlyInstances.teamComponent) && (int)readOnlyInstances.teamComponent.teamIndex != 1)
				{
					num++;
				}
			}
			return num;
		}

		private IEnumerator SirenHunterWatcher(TeleporterInteraction tp, CharacterMaster master)
		{
			WaitForSeconds wait = new WaitForSeconds(0.25f);
			float start = Time.time;
			bool seenSolus = false;
			bool added = false;
			while (Object.op_Implicit((Object)(object)master) && Object.op_Implicit((Object)(object)tp))
			{
				CharacterBody body = master.GetBody();
				if (Object.op_Implicit((Object)(object)body) && Object.op_Implicit((Object)(object)body.healthComponent) && !body.healthComponent.alive)
				{
					break;
				}
				AlloyMarker marker = MarkerOf(master);
				if (!added)
				{
					CombatSquad val = TeleporterSquad(tp);
					if (Object.op_Implicit((Object)(object)val) && val.memberCount > 0 && !SquadDefeated(val))
					{
						try
						{
							val.AddMember(master);
							added = true;
							Log.LogInfo((object)"Siren hunter added to teleporter boss group.");
						}
						catch (Exception ex)
						{
							Log.LogError((object)ex);
							added = true;
						}
					}
				}
				if (Object.op_Implicit((Object)(object)marker) && marker.invulnerable)
				{
					int num = CountAliveSolusControlUnits();
					if (num > 0)
					{
						seenSolus = true;
					}
					if ((seenSolus && num == 0) || (!seenSolus && Time.time - start > SirenHunterFallbackSeconds.Value))
					{
						marker.invulnerable = false;
						Log.LogInfo((object)"Siren hunter is now vulnerable.");
					}
				}
				SetMonstersCleared(tp, value: false);
				yield return wait;
			}
			if (Object.op_Implicit((Object)(object)tp))
			{
				CombatSquad val2 = TeleporterSquad(tp);
				SetMonstersCleared(tp, !Object.op_Implicit((Object)(object)val2) || SquadDefeated(val2) || val2.memberCount == 0);
			}
		}

		private IEnumerator RequireBossManually(TeleporterInteraction tp, CharacterMaster master)
		{
			WaitForSeconds wait = new WaitForSeconds(0.1f);
			while (Object.op_Implicit((Object)(object)master) && Object.op_Implicit((Object)(object)tp))
			{
				CharacterBody b = master.GetBody();
				if (Object.op_Implicit((Object)(object)b) && Object.op_Implicit((Object)(object)b.healthComponent) && !b.healthComponent.alive)
				{
					break;
				}
				SetMonstersCleared(tp, value: false);
				yield return wait;
			}
			if (Object.op_Implicit((Object)(object)tp))
			{
				CombatSquad val = ((!Object.op_Implicit((Object)(object)tp.bossGroup)) ? null : tp.bossGroup.combatSquad);
				SetMonstersCleared(tp, !Object.op_Implicit((Object)(object)val) || SquadDefeated(val) || val.memberCount == 0);
			}
		}

		private static void BroadcastSiren()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			string text = null;
			try
			{
				string text2 = Language.GetString("BROTHER_DIALOGUE_FORMAT");
				if (!string.IsNullOrEmpty(text2) && text2.Contains("{0}") && text2.Contains("Mithrix"))
				{
					text = string.Format(text2.Replace("Mithrix", "Siren"), "Awoooooooooo");
				}
			}
			catch
			{
			}
			if (text == null)
			{
				text = "<color=#c6d5ff><size=120%>Siren: Awoooooooooo</color></size>";
			}
			SimpleChatMessage val = new SimpleChatMessage();
			val.baseToken = text;
			Chat.SendBroadcastChat((ChatMessageBase)(object)val);
		}

		private void OnBodyStart(CharacterBody body)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Invalid comparison between Unknown and I4
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)body) || !Object.op_Implicit((Object)(object)body.master))
			{
				return;
			}
			try
			{
				CharacterMaster master = body.master;
				string text = SceneName();
				if (body.bodyIndex == worshipBody && (int)worshipBody != -1)
				{
					AlloyMarker alloyMarker = MarkerOf(master);
					if (!Object.op_Implicit((Object)(object)alloyMarker))
					{
						alloyMarker = ((Component)master).gameObject.AddComponent<AlloyMarker>();
						alloyMarker.kind = AlloyMarker.Kind.WorshipUnit;
						MultiplyStat(master.inventory, Items.BoostDamage, WorshipDamageMult.Value);
						alloyMarker.statsApplied = true;
						if (text == "shipgraveyard")
						{
							((MonoBehaviour)this).StartCoroutine(HandleWorshipOnSiren(master));
						}
					}
				}
				else if (body.bodyIndex == hunterBody && (int)hunterBody != -1 && text == "conduitcanyon" && !Object.op_Implicit((Object)(object)MarkerOf(master)))
				{
					AlloyMarker alloyMarker2 = ((Component)master).gameObject.AddComponent<AlloyMarker>();
					alloyMarker2.kind = AlloyMarker.Kind.ConduitHunter;
					MultiplyStat(master.inventory, Items.BoostHp, ConduitHunterHpMult.Value);
					alloyMarker2.statsApplied = true;
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private IEnumerator HandleWorshipOnSiren(CharacterMaster worship)
		{
			yield return null;
			TeleporterInteraction tp = TeleporterInteraction.instance;
			if (!Object.op_Implicit((Object)(object)tp) || !Object.op_Implicit((Object)(object)worship))
			{
				yield break;
			}
			if (SirenForceTeleporter.Value && tp.isIdle)
			{
				Interactor val = null;
				foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
				{
					CharacterBody val2 = ((!Object.op_Implicit((Object)(object)instance) || !Object.op_Implicit((Object)(object)instance.master)) ? null : instance.master.GetBody());
					if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)(val = ((Component)val2).GetComponent<Interactor>())))
					{
						break;
					}
				}
				try
				{
					tp.OnInteractionBegin(val);
				}
				catch (Exception ex)
				{
					Log.LogError((object)ex);
				}
			}
			if (SirenWorshipRequired.Value && !tp.isCharged)
			{
				((MonoBehaviour)this).StartCoroutine(RequireBossManually(tp, worship));
			}
		}

		private static void SetNextSpawnAsBossPostfix(CombatDirector __instance)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			try
			{
				if (SirenForceSolusBoss.Value && NetworkServer.active && Object.op_Implicit((Object)(object)solusControlCard) && !(SceneName() != "shipgraveyard"))
				{
					TeleporterInteraction instance = TeleporterInteraction.instance;
					if (Object.op_Implicit((Object)(object)instance) && !((Object)(object)instance.bossDirector != (Object)(object)__instance))
					{
						DirectorCard val = new DirectorCard();
						val.spawnCard = (SpawnCard)(object)solusControlCard;
						val.selectionWeight = 1;
						__instance.OverrideCurrentMonsterCard(val);
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private void OnCharacterDeath(DamageReport report)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || report == null || !Object.op_Implicit((Object)(object)report.victimMaster))
			{
				return;
			}
			try
			{
				AlloyMarker alloyMarker = MarkerOf(report.victimMaster);
				if (!Object.op_Implicit((Object)(object)alloyMarker) || alloyMarker.dropsGiven)
				{
					return;
				}
				Vector3 pos = ((!Object.op_Implicit((Object)(object)report.victimBody)) ? ((Component)report.victimMaster).transform.position : report.victimBody.corePosition);
				List<PickupIndex> list = new List<PickupIndex>();
				switch (alloyMarker.kind)
				{
				default:
					return;
				case AlloyMarker.Kind.ConduitHunter:
					if (!ConduitDrops.Value)
					{
						return;
					}
					list.Add(ToQuality(ItemPickup("ShockDamageAura"), 2));
					list.Add(ItemPickup("ChainLightningVoid"));
					break;
				case AlloyMarker.Kind.SirenHunter:
					if (!SirenDrops.Value)
					{
						return;
					}
					list.Add(ToQuality(ItemPickup("ShockDamageAura"), 3));
					list.Add(ItemPickup("ChainLightningVoid"));
					list.Add(ItemPickup("ShockNearby"));
					list.Add(EquipmentPickup("AffixBlue"));
					break;
				case AlloyMarker.Kind.WorshipUnit:
					if (WorshipLegendaryReds.Value && QualityInstalled)
					{
						redWindowEnd = Time.time + RedConversionWindow.Value;
						redConversionsLeft = ((RedConversionCount.Value <= 0) ? Math.Max(1, PlayerCharacterMasterController.instances.Count) : RedConversionCount.Value);
					}
					if (!WorshipDrops.Value)
					{
						return;
					}
					list.Add(ToQuality(ItemPickup("RoboBallBuddy"), 3));
					break;
				}
				alloyMarker.dropsGiven = true;
				DropAll(list, pos);
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private static void CreatePickupPrefix(ref CreatePickupInfo createPickupInfo)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Time.time > redWindowEnd || redConversionsLeft <= 0 || !NetworkServer.active || SceneName() != "shipgraveyard")
				{
					return;
				}
				PickupDef pickupDef = PickupCatalog.GetPickupDef(((CreatePickupInfo)(ref createPickupInfo)).pickupIndex);
				if (pickupDef != null && (int)pickupDef.itemIndex != -1 && (int)pickupDef.itemTier == 2)
				{
					((CreatePickupInfo)(ref createPickupInfo)).pickupIndex = ToQuality(((CreatePickupInfo)(ref createPickupInfo)).pickupIndex, 3);
					if (--redConversionsLeft <= 0)
					{
						redWindowEnd = -1f;
					}
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)ex);
			}
		}

		private static bool SacrificeZonePrefix()
		{
			return !SirenDisableDescent.Value || !(SceneName() == "shipgraveyard");
		}

		private static bool TrySpawnObjectPrefix(DirectorSpawnRequest directorSpawnRequest, ref GameObject __result)
		{
			if (!SirenDisableDescent.Value || directorSpawnRequest == null || !Object.op_Implicit((Object)(object)directorSpawnRequest.spawnCard))
			{
				return true;
			}
			if (SceneName() != "shipgraveyard")
			{
				return true;
			}
			string name = ((Object)directorSpawnRequest.spawnCard).name;
			string[] array = DescentCardNames.Value.Split(new char[1] { ',' });
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length > 0 && name.IndexOf(text2, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					__result = null;
					return false;
				}
			}
			return true;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public string AssemblyName { get; }

		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
			AssemblyName = assemblyName;
		}
	}
}