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.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.InfiniteTowerSafeWard;
using EntityStates.MeridianEvent;
using EntityStates.Missions.BrotherEncounter;
using EntityStates.SolusHeart;
using EntityStates.SolusWing2;
using HG;
using HG.Reflection;
using IL.RoR2;
using IL.RoR2.Networking;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using Newtonsoft.Json.Utilities;
using On.EntityStates.MeridianEvent;
using On.EntityStates.Missions.BrotherEncounter;
using On.EntityStates.SolusHeart;
using On.EntityStates.SolusWing2;
using On.RoR2;
using On.RoR2.EntitlementManagement;
using On.RoR2.Networking;
using On.RoR2.UI;
using On.RoR2.UI.LogBook;
using R2API;
using R2API.Utils;
using RoR2;
using RoR2.EntitlementManagement;
using RoR2.ExpansionManagement;
using RoR2.Hologram;
using RoR2.Items;
using RoR2.Networking;
using RoR2.Stats;
using RoR2.UI;
using RoR2.UI.LogBook;
using RoR2.UI.MainMenu;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;
using WolfoLibrary.Testing;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Wolfo")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A fix and library mod with various commands, methods and classes")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+76a4841cea7c75fa2c02e0fdd7fa6881f20c39f5")]
[assembly: AssemblyProduct("WolfoLibrary")]
[assembly: AssemblyTitle("WolfoLibrary")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace WolfoLibrary
{
	internal static class FixesAlways
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__MoreValuesForClients;
		}

		public static void Start()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			object obj = <>O.<0>__MoreValuesForClients;
			if (obj == null)
			{
				hook_Start val = MoreValuesForClients;
				<>O.<0>__MoreValuesForClients = val;
				obj = (object)val;
			}
			HalcyoniteShrineInteractable.Start += (hook_Start)obj;
		}

		private static void MoreValuesForClients(orig_Start orig, HalcyoniteShrineInteractable self)
		{
			orig.Invoke(self);
			if (!NetworkServer.active && self.automaticallyScaleCostWithDifficulty)
			{
				self.lowGoldCost = Run.instance.GetDifficultyScaledCost(self.lowGoldCost);
				self.midGoldCost = Run.instance.GetDifficultyScaledCost(self.midGoldCost);
				self.maxGoldCost = Run.instance.GetDifficultyScaledCost(self.maxGoldCost);
				self.goldDrainValue = Run.instance.GetDifficultyScaledCost(self.goldDrainValue);
			}
		}
	}
	internal static class Log
	{
		public static ManualLogSource log;

		public static void LogMessage(object message)
		{
			log.LogMessage(message);
		}

		public static void LogWarning(object message)
		{
			log.LogWarning(message);
		}

		public static void LogError(object message)
		{
			log.LogError(message);
		}
	}
	public static class Networker
	{
		public static readonly Dictionary<Type, byte> message_to_index = new Dictionary<Type, byte>();

		public static readonly Dictionary<byte, Type> index_to_message = new Dictionary<byte, Type>();

		public static byte wqol_startByte = 0;

		public static byte artifacts_startByte = 32;

		public static void SendWQoLMessage(ChatMessageBase message)
		{
			SendBroadcastChat(message, QosChannelIndex.chat.intVal);
		}

		public static void SendBroadcastChat(ChatMessageBase message, int channelIndex)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (WConfig.cfgTestMultiplayer.Value)
			{
				Debug.Log((object)"SendBroadcastChat");
			}
			NetworkWriter val = new NetworkWriter();
			val.StartMessage((short)20024);
			val.Write(message_to_index[((object)message).GetType()]);
			val.Write((MessageBase)(object)message);
			val.FinishMessage();
			foreach (NetworkConnection connection in NetworkServer.connections)
			{
				if (connection != null)
				{
					connection.SendWriter(val, channelIndex);
				}
			}
		}

		public static ChatMessageBase InstantiateMessage(byte typeIndex)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Type type = index_to_message[typeIndex];
			if (ChatMessageBase.cvChatDebug.value)
			{
				Debug.LogFormat("Received chat message typeIndex={0} type={1}", new object[2]
				{
					typeIndex,
					(type != null) ? type.Name : null
				});
			}
			if (type != null)
			{
				return (ChatMessageBase)Activator.CreateInstance(type);
			}
			return null;
		}

		[NetworkMessageHandler(msgType = 20024, client = true)]
		public static void HandleBroadcastChat(NetworkMessage netMsg)
		{
			if (WConfig.cfgTestMultiplayer.Value)
			{
				Debug.Log((object)"HandleBroadcastChat");
			}
			ChatMessageBase val = InstantiateMessage(netMsg.reader.ReadByte());
			if (val != null)
			{
				((MessageBase)val).Deserialize(netMsg.reader);
				Chat.AddMessage(val);
			}
		}
	}
	internal static class VoidElite
	{
		public static void VoidAffix()
		{
			//IL_0006: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			EquipmentDef val = Addressables.LoadAssetAsync<EquipmentDef>((object)"RoR2/DLC1/EliteVoid/EliteVoidEquipment.asset").WaitForCompletion();
			GameObject val2 = PrefabAPI.InstantiateClone(Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/EliteVoid/DisplayAffixVoid.prefab").WaitForCompletion(), "PickupAffixVoidW", false);
			val2.transform.GetChild(0).GetChild(2).SetAsFirstSibling();
			val2.transform.GetChild(1).localPosition = new Vector3(0f, 0.7f, 0f);
			val2.transform.GetChild(1).GetChild(0).localPosition = new Vector3(0f, -0.5f, -0.6f);
			val2.transform.GetChild(1).GetChild(0).localScale = new Vector3(1.5f, 1.5f, 1.5f);
			((Component)val2.transform.GetChild(1).GetChild(1)).gameObject.SetActive(false);
			((Component)val2.transform.GetChild(1).GetChild(3)).gameObject.SetActive(false);
			val2.transform.GetChild(0).eulerAngles = new Vector3(310f, 0f, 0f);
			val2.transform.GetChild(0).localScale = new Vector3(0.75f, 0.75f, 0.75f);
			ItemDisplay component = val2.GetComponent<ItemDisplay>();
			ArrayUtils.ArrayRemoveAtAndResize<RendererInfo>(ref component.rendererInfos, 4, 1);
			val2.AddComponent<ModelPanelParameters>();
			val.pickupModelReference = new AssetReferenceT<GameObject>("");
			val.pickupModelPrefab = val2;
		}
	}
	internal class VoidSuppressor
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Init <0>__MakeTiered;

			public static Action<Run> <1>__MakeTieredAgain;

			public static hook_ctor <2>__RemoveFromCompletion;

			public static hook_PreStartClient <3>__AddPriceHologram;

			public static hook_RefreshPickupDisplays <4>__FixPickupDisplayTooSmallDueToLossyScale;
		}

		public static void SuppresedScrap()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			MissedContent.Items.ScrapWhiteSuppressed.pickupToken = "ITEM_SCRAPWHITE_PICKUP";
			MissedContent.Items.ScrapGreenSuppressed.pickupToken = "ITEM_SCRAPGREEN_PICKUP";
			MissedContent.Items.ScrapRedSuppressed.pickupToken = "ITEM_SCRAPRED_PICKUP";
			MissedContent.Items.ScrapWhiteSuppressed.descriptionToken = "ITEM_SCRAPWHITE_DESC";
			MissedContent.Items.ScrapGreenSuppressed.descriptionToken = "ITEM_SCRAPGREEN_DESC";
			MissedContent.Items.ScrapRedSuppressed.descriptionToken = "ITEM_SCRAPRED_DESC";
			object obj = <>O.<0>__MakeTiered;
			if (obj == null)
			{
				hook_Init val = MakeTiered;
				<>O.<0>__MakeTiered = val;
				obj = (object)val;
			}
			PickupCatalog.Init += (hook_Init)obj;
			Run.onRunStartGlobal += MakeTieredAgain;
			object obj2 = <>O.<2>__RemoveFromCompletion;
			if (obj2 == null)
			{
				hook_ctor val2 = RemoveFromCompletion;
				<>O.<2>__RemoveFromCompletion = val2;
				obj2 = (object)val2;
			}
			GameCompletionStatsHelper.ctor += (hook_ctor)obj2;
		}

		public static void FixInteractable()
		{
			//IL_0006: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Expected O, but got Unknown
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			GameObject val = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/VoidSuppressor/VoidSuppressor.prefab").WaitForCompletion();
			VoidSuppressorBehavior component = val.GetComponent<VoidSuppressorBehavior>();
			component.useRefreshDelay = 1.05f;
			val.GetComponent<PurchaseInteraction>().isShrine = true;
			val.GetComponent<VoidSuppressorBehavior>().effectColor.a = 0.85f;
			Transform child = val.transform.GetChild(0);
			((Component)child.GetChild(7).GetChild(1).GetChild(1)).gameObject.SetActive(true);
			child.GetChild(7).localPosition = new Vector3(0f, -0.5f, -0.5f);
			child.GetChild(7).GetChild(1).GetChild(0)
				.localScale = new Vector3(1.2f, 1.2f, 1.2f);
			Renderer component2 = ((Component)child.GetChild(5)).GetComponent<Renderer>();
			Bounds localBounds = default(Bounds);
			((Bounds)(ref localBounds)).extents = new Vector3(5f, 5f, 5f);
			component2.localBounds = localBounds;
			GameObject val2 = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/UI/HUDSimple.prefab").WaitForCompletion();
			try
			{
				Transform val3 = val2.GetComponent<ChildLocator>().FindChild("ScoreboardPanel").Find("Container/SuppressedItems");
				((Component)val3).GetComponent<LayoutElement>().minHeight = 96f;
				((Component)val3).GetComponent<ItemInventoryDisplay>().verticalMargin = 16f;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			object obj = <>O.<3>__AddPriceHologram;
			if (obj == null)
			{
				hook_PreStartClient val4 = AddPriceHologram;
				<>O.<3>__AddPriceHologram = val4;
				obj = (object)val4;
			}
			VoidSuppressorBehavior.PreStartClient += (hook_PreStartClient)obj;
			object obj2 = <>O.<4>__FixPickupDisplayTooSmallDueToLossyScale;
			if (obj2 == null)
			{
				hook_RefreshPickupDisplays val5 = FixPickupDisplayTooSmallDueToLossyScale;
				<>O.<4>__FixPickupDisplayTooSmallDueToLossyScale = val5;
				obj2 = (object)val5;
			}
			VoidSuppressorBehavior.RefreshPickupDisplays += (hook_RefreshPickupDisplays)obj2;
		}

		private static void MakeTieredAgain(Run obj)
		{
			MissedContent.Items.ScrapWhiteSuppressed.tier = (ItemTier)0;
			MissedContent.Items.ScrapGreenSuppressed.tier = (ItemTier)1;
			MissedContent.Items.ScrapRedSuppressed.tier = (ItemTier)2;
			Run.onRunStartGlobal -= MakeTieredAgain;
		}

		private static IEnumerator MakeTiered(orig_Init orig)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			if ((int)MissedContent.Items.ScrapWhiteSuppressed.tier != 5)
			{
				return orig.Invoke();
			}
			MissedContent.Items.ScrapWhiteSuppressed.tier = (ItemTier)0;
			MissedContent.Items.ScrapGreenSuppressed.tier = (ItemTier)1;
			MissedContent.Items.ScrapRedSuppressed.tier = (ItemTier)2;
			IEnumerator result = orig.Invoke();
			MissedContent.Items.ScrapWhiteSuppressed.tier = (ItemTier)5;
			MissedContent.Items.ScrapGreenSuppressed.tier = (ItemTier)5;
			MissedContent.Items.ScrapRedSuppressed.tier = (ItemTier)5;
			return result;
		}

		private static void RemoveFromCompletion(orig_ctor orig, GameCompletionStatsHelper self)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			PickupDef pickupDef = PickupCatalog.GetPickupDef(PickupCatalog.FindPickupIndex(MissedContent.Items.ScrapWhiteSuppressed.itemIndex));
			PickupDef pickupDef2 = PickupCatalog.GetPickupDef(PickupCatalog.FindPickupIndex(MissedContent.Items.ScrapGreenSuppressed.itemIndex));
			PickupDef pickupDef3 = PickupCatalog.GetPickupDef(PickupCatalog.FindPickupIndex(MissedContent.Items.ScrapRedSuppressed.itemIndex));
			self.encounterablePickups.Remove(pickupDef);
			self.encounterablePickups.Remove(pickupDef2);
			self.encounterablePickups.Remove(pickupDef3);
		}

		private static void FixPickupDisplayTooSmallDueToLossyScale(orig_RefreshPickupDisplays orig, VoidSuppressorBehavior self)
		{
			//IL_001a: 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)
			Transform transform = ((Component)self.pickupDisplays[0]).transform;
			float num = 0.89628005f / transform.parent.localScale.x;
			transform.localScale = new Vector3(num, num, num);
			orig.Invoke(self);
		}

		private static void AddPriceHologram(orig_PreStartClient orig, VoidSuppressorBehavior self)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			GameObject val = new GameObject("PriceTransform");
			val.transform.SetParent(((Component)self).transform, false);
			val.transform.localPosition = new Vector3(0.2f, 1f, 2f);
			HologramProjector val2 = ((Component)self).GetComponent<HologramProjector>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)self).gameObject.AddComponent<HologramProjector>();
			}
			val2.disableHologramRotation = true;
			val.transform.localEulerAngles = new Vector3(0f, 180f, 0f);
			val2.hologramPivot = val.transform;
		}
	}
	public class WConfig
	{
		public static ConfigFile ConfigFile = new ConfigFile(Paths.ConfigPath + "\\Wolfo.WolfoFixes.cfg", true);

		public static ConfigEntry<bool> cfgTestMultiplayer;

		public static ConfigEntry<bool> cfgTestLogbook;

		public static ConfigEntry<bool> cfgLoadOrder;

		public static void Awake()
		{
			InitConfig();
		}

		public static void InitConfig()
		{
			cfgTestLogbook = ConfigFile.Bind<bool>("Testing", "Everything Logbook", false, "Add all items, equipments and mobs to logbook, including untiered and cut.");
			cfgTestMultiplayer = ConfigFile.Bind<bool>("Testing", "Multiplayer Test", false, "Allows you to join yourself via connect localhost:7777");
			cfgLoadOrder = ConfigFile.Bind<bool>("Testing", "Debugging", false, "Log prints when certain events happen");
		}
	}
	[BepInPlugin("com.Wolfo.WolfoLibrary", "WolfoLibrary", "1.3.4")]
	public class WolfoLib : BaseUnityPlugin
	{
		public void Awake()
		{
			Log.log = ((BaseUnityPlugin)this).Logger;
			Commands.Awake();
			Test.Awake();
			SkinStuff.Start();
		}

		public void Start()
		{
			//IL_006a: 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)
			Commands.cheatsEnabled = Chainloader.PluginInfos.ContainsKey("iHarbHD.DebugToolkit");
			WConfig.Awake();
			Test.Start();
			ExtraActions.Start();
			Tags.Start();
			FixesAlways.Start();
			VoidElite.VoidAffix();
			VoidSuppressor.SuppresedScrap();
			VoidSuppressor.FixInteractable();
			RoR2Application.onLoad = (Action)Delegate.Combine(RoR2Application.onLoad, new Action(CallLate));
			Addressables.LoadAssetAsync<GameObject>((object)"RoR2/DLC1/OptionPickup/OptionPickerPanel.prefab").WaitForCompletion().GetComponent<PickupPickerPanel>()
				.maxColumnCount = 3;
		}

		public void CallLate()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			Equipment.GroundEnemies.colorIndex = (ColorIndex)5;
		}
	}
	public static class ArrayUtil
	{
		public static T[] Remove<T>(this T[] array, params T[] items)
		{
			return (array ?? Enumerable.Empty<T>()).Except(items).ToArray();
		}
	}
	public class AssetUtils
	{
		public static string GetPathToFile(string assemblyDir, string modFolder, string assetFolder)
		{
			if (Directory.Exists(Path.Combine(assemblyDir, modFolder + assetFolder)))
			{
				return Path.Combine(assemblyDir, modFolder + assetFolder);
			}
			if (Directory.Exists(Path.Combine(assemblyDir, "plugins\\" + modFolder + assetFolder)))
			{
				return Path.Combine(assemblyDir, assetFolder);
			}
			Debug.LogError((object)("COULD NOT FIND " + assetFolder + " FOLDER"));
			return assemblyDir;
		}

		public static string GetPathToFile(string assemblyDir, string modFolder, string assetFolder, string fileName)
		{
			return Path.Combine(GetPathToFile(assemblyDir, modFolder, assetFolder), fileName);
		}
	}
	public static class ExtraActions
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnEnter <0>__BrotherPhase1;

			public static hook_Start <1>__VoidlingStart;

			public static hook_OnEnter <2>__FalseSonPhase1;

			public static hook_OnExit <3>__Mission1Tunnel_OnExit;

			public static hook_OnEnter <4>__CutsceneTransformation_OnEnter;

			public static hook_PreStartClient <5>__Stage_PreStartClient;

			public static Manipulator <6>__MonsterDCCSGenerateHook;

			public static hook_OnDisable <7>__ScoreboardController_OnDisable;
		}

		public static Action onMithrixPhase1;

		public static Action onVoidlingPhase1;

		public static Action onFalseSonPhase1;

		public static Action onSolusWing;

		public static Action onSolusHeart;

		public static Action onStagePreStartClient;

		public static Action<DirectorCardCategorySelection> onMonsterDCCS;

		[CompilerGenerated]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private static UnityAction m_onScoreboardClosed;

		public static event UnityAction onScoreboardClosed
		{
			[CompilerGenerated]
			add
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected O, but got Unknown
				UnityAction val = ExtraActions.m_onScoreboardClosed;
				UnityAction val2;
				do
				{
					val2 = val;
					UnityAction value2 = (UnityAction)Delegate.Combine((Delegate?)(object)val2, (Delegate?)(object)value);
					val = Interlocked.CompareExchange(ref ExtraActions.m_onScoreboardClosed, value2, val2);
				}
				while (val != val2);
			}
			[CompilerGenerated]
			remove
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Expected O, but got Unknown
				UnityAction val = ExtraActions.m_onScoreboardClosed;
				UnityAction val2;
				do
				{
					val2 = val;
					UnityAction value2 = (UnityAction)Delegate.Remove((Delegate?)(object)val2, (Delegate?)(object)value);
					val = Interlocked.CompareExchange(ref ExtraActions.m_onScoreboardClosed, value2, val2);
				}
				while (val != val2);
			}
		}

		public static void Start()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//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_005e: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			object obj = <>O.<0>__BrotherPhase1;
			if (obj == null)
			{
				hook_OnEnter val = BrotherPhase1;
				<>O.<0>__BrotherPhase1 = val;
				obj = (object)val;
			}
			Phase1.OnEnter += (hook_OnEnter)obj;
			object obj2 = <>O.<1>__VoidlingStart;
			if (obj2 == null)
			{
				hook_Start val2 = VoidlingStart;
				<>O.<1>__VoidlingStart = val2;
				obj2 = (object)val2;
			}
			VoidRaidGauntletController.Start += (hook_Start)obj2;
			object obj3 = <>O.<2>__FalseSonPhase1;
			if (obj3 == null)
			{
				hook_OnEnter val3 = FalseSonPhase1;
				<>O.<2>__FalseSonPhase1 = val3;
				obj3 = (object)val3;
			}
			Phase1.OnEnter += (hook_OnEnter)obj3;
			object obj4 = <>O.<3>__Mission1Tunnel_OnExit;
			if (obj4 == null)
			{
				hook_OnExit val4 = Mission1Tunnel_OnExit;
				<>O.<3>__Mission1Tunnel_OnExit = val4;
				obj4 = (object)val4;
			}
			Mission1Tunnel.OnExit += (hook_OnExit)obj4;
			object obj5 = <>O.<4>__CutsceneTransformation_OnEnter;
			if (obj5 == null)
			{
				hook_OnEnter val5 = CutsceneTransformation_OnEnter;
				<>O.<4>__CutsceneTransformation_OnEnter = val5;
				obj5 = (object)val5;
			}
			CutsceneTransformation.OnEnter += (hook_OnEnter)obj5;
			object obj6 = <>O.<5>__Stage_PreStartClient;
			if (obj6 == null)
			{
				hook_PreStartClient val6 = Stage_PreStartClient;
				<>O.<5>__Stage_PreStartClient = val6;
				obj6 = (object)val6;
			}
			Stage.PreStartClient += (hook_PreStartClient)obj6;
			object obj7 = <>O.<6>__MonsterDCCSGenerateHook;
			if (obj7 == null)
			{
				Manipulator val7 = MonsterDCCSGenerateHook;
				<>O.<6>__MonsterDCCSGenerateHook = val7;
				obj7 = (object)val7;
			}
			ClassicStageInfo.RebuildCards += (Manipulator)obj7;
			object obj8 = <>O.<7>__ScoreboardController_OnDisable;
			if (obj8 == null)
			{
				hook_OnDisable val8 = ScoreboardController_OnDisable;
				<>O.<7>__ScoreboardController_OnDisable = val8;
				obj8 = (object)val8;
			}
			ScoreboardController.OnDisable += (hook_OnDisable)obj8;
		}

		private static void ScoreboardController_OnDisable(orig_OnDisable orig, ScoreboardController self)
		{
			orig.Invoke(self);
			UnityAction val = ExtraActions.onScoreboardClosed;
			if (val != null)
			{
				val.Invoke();
			}
		}

		private static void Stage_PreStartClient(orig_PreStartClient orig, Stage self)
		{
			orig.Invoke(self);
			onStagePreStartClient?.Invoke();
		}

		private static void CutsceneTransformation_OnEnter(orig_OnEnter orig, CutsceneTransformation self)
		{
			orig.Invoke(self);
			onSolusHeart?.Invoke();
		}

		private static void Mission1Tunnel_OnExit(orig_OnExit orig, Mission1Tunnel self)
		{
			orig.Invoke(self);
			onSolusWing?.Invoke();
		}

		private static void VoidlingStart(orig_Start orig, VoidRaidGauntletController self)
		{
			orig.Invoke(self);
			onVoidlingPhase1?.Invoke();
		}

		public static void MonsterDCCSGenerateHook(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStfld(x, "RoR2.ClassicStageInfo", "modifiableMonsterCategories")
			}))
			{
				val.EmitDelegate<Func<DirectorCardCategorySelection, DirectorCardCategorySelection>>((Func<DirectorCardCategorySelection, DirectorCardCategorySelection>)delegate(DirectorCardCategorySelection dccs)
				{
					if (Object.op_Implicit((Object)(object)dccs) && !(dccs is FamilyDirectorCardCategorySelection))
					{
						onMonsterDCCS?.Invoke(dccs);
					}
					return dccs;
				});
			}
			else
			{
				Debug.LogWarning((object)"IL Failed: SotV_EnemyRemovals");
			}
		}

		private static void FalseSonPhase1(orig_OnEnter orig, Phase1 self)
		{
			orig.Invoke(self);
			onFalseSonPhase1?.Invoke();
		}

		private static void BrotherPhase1(orig_OnEnter orig, Phase1 self)
		{
			orig.Invoke(self);
			onMithrixPhase1?.Invoke();
		}
	}
	public class InstantiateModelParams : MonoBehaviour
	{
		public Vector3 CameraPosition = new Vector3(-1.5f, 1f, 3f);

		public Vector3 FocusPosition = new Vector3(0f, 1f, 0f);
	}
	public class DccsUtil
	{
		public static void RemoveCard(DirectorCardCategorySelection dccs, int cat, string card)
		{
			string text = "";
			switch (cat)
			{
			case 2:
				text = "Basic Monsters";
				break;
			case 1:
				text = "Minibosses";
				break;
			case 0:
				text = "Champions";
				break;
			}
			cat = dccs.FindCategoryIndexByName(text);
			if (cat != -1)
			{
				int num = FindSpawnCard(ref dccs.categories[cat].cards, card);
				if (num != -1)
				{
					Log.LogMessage("Removed " + card + " from " + (object)SceneInfo.instance.sceneDef);
					ArrayUtils.ArrayRemoveAtAndResize<DirectorCard>(ref dccs.categories[cat].cards, num, 1);
					return;
				}
			}
			Log.LogWarning("Failed to remove " + card + " from " + (object)SceneInfo.instance.sceneDef);
		}

		public static int FindSpawnCard(ref DirectorCard[] insert, string LookingFor)
		{
			for (int i = 0; i < insert.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)insert[i].GetSpawnCard()) && ((Object)insert[i].GetSpawnCard()).name.EndsWith(LookingFor))
				{
					return i;
				}
			}
			return -1;
		}

		public static DirectorCard GetDirectorCard(ref DirectorCard[] insert, string LookingFor)
		{
			for (int i = 0; i < insert.Length; i++)
			{
				if (Object.op_Implicit((Object)(object)insert[i].GetSpawnCard()) && ((Object)insert[i].GetSpawnCard()).name.EndsWith(LookingFor))
				{
					return insert[i];
				}
			}
			return null;
		}
	}
	public class HLang
	{
	}
	public class AdvancedPickupDropTable : BasicPickupDropTable
	{
		private bool generated;

		public bool clearAfterGenerating;

		public bool unbiasedByItemCount = false;

		public float eliteEquipmentWeight;

		public override UniquePickup GeneratePickupPreReplacement(Xoroshiro128Plus rng)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			RegenerateReal();
			return PickupDropTable.GeneratePickupFromWeightedSelection(rng, base.selector);
		}

		public override void GenerateDistinctPickupsPreReplacement(List<UniquePickup> dest, int desiredCount, Xoroshiro128Plus rng)
		{
			RegenerateReal();
			PickupDropTable.GenerateDistinctFromWeightedSelection<UniquePickup>(dest, desiredCount, rng, base.selector);
		}

		public override void Regenerate(Run run)
		{
			generated = false;
		}

		public void RegenerateReal()
		{
			if (!generated)
			{
				generated = true;
				if (unbiasedByItemCount)
				{
					GenerateUnbiased(Run.instance);
				}
				else
				{
					((BasicPickupDropTable)this).RegenerateDropTable(Run.instance);
				}
				AddEliteEquip(Run.instance);
			}
		}

		private void GenerateUnbiased(Run run)
		{
			base.selector.Clear();
			AddUnbiased(run.availableTier1DropList, base.tier1Weight);
			AddUnbiased(run.availableTier2DropList, base.tier2Weight);
			AddUnbiased(run.availableTier3DropList, base.tier3Weight);
			AddUnbiased(run.availableBossDropList, base.bossWeight);
			AddUnbiased(run.availableLunarItemDropList, base.lunarItemWeight);
			AddUnbiased(run.availableLunarEquipmentDropList, base.lunarEquipmentWeight);
			AddUnbiased(run.availableLunarCombinedDropList, base.lunarCombinedWeight);
			AddUnbiased(run.availableEquipmentDropList, base.equipmentWeight);
			AddUnbiased(run.availableVoidTier1DropList, base.voidTier1Weight);
			AddUnbiased(run.availableVoidTier2DropList, base.voidTier2Weight);
			AddUnbiased(run.availableVoidTier3DropList, base.voidTier3Weight);
			AddUnbiased(run.availableVoidBossDropList, base.voidBossWeight);
			AddUnbiased(run.availableFoodTierDropList, base.foodTierWeight);
		}

		private void AddUnbiased(List<PickupIndex> sourceDropList, float chance)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (chance <= 0f || sourceDropList.Count == 0)
			{
				return;
			}
			float num = chance / (float)sourceDropList.Count;
			foreach (PickupIndex sourceDrop in sourceDropList)
			{
				if (!((BasicPickupDropTable)this).IsFilterRequired() || ((BasicPickupDropTable)this).PassesFilter(sourceDrop))
				{
					base.selector.AddChoice(new UniquePickup
					{
						pickupIndex = sourceDrop
					}, chance);
				}
			}
		}

		private void AddEliteEquip(Run run)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: 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)
			if (eliteEquipmentWeight == 0f)
			{
				return;
			}
			List<EquipmentIndex> eliteEquipment = ModUtil.GetEliteEquipment();
			float num = (unbiasedByItemCount ? (eliteEquipmentWeight / (float)eliteEquipment.Count) : eliteEquipmentWeight);
			foreach (EquipmentIndex item in eliteEquipment)
			{
				base.selector.AddChoice(new UniquePickup
				{
					pickupIndex = PickupCatalog.FindPickupIndex(item)
				}, num);
			}
		}
	}
	public class ForcedTeamCSC : CharacterSpawnCard
	{
		public TeamIndex teamIndexOverride = (TeamIndex)2;

		public override void Spawn(Vector3 position, Quaternion rotation, DirectorSpawnRequest directorSpawnRequest, ref SpawnResult result)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			directorSpawnRequest.teamIndexOverride = teamIndexOverride;
			((CharacterSpawnCard)this).Spawn(position, rotation, directorSpawnRequest, ref result);
		}
	}
	public class SkinStuff
	{
		public static void Start()
		{
			//IL_0006: 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_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			SkinDefParams val = Addressables.LoadAssetAsync<SkinDefParams>((object)"6517af04dc3e7ce45a55f09e04c96772").WaitForCompletion();
			SkinDefParams val2 = Addressables.LoadAssetAsync<SkinDefParams>((object)"4c92b69e995926b46876ed3c644a2e81").WaitForCompletion();
			val.minionSkinReplacements = (MinionSkinReplacement[])(object)new MinionSkinReplacement[3]
			{
				new MinionSkinReplacement
				{
					minionBodyPrefab = Addressables.LoadAssetAsync<GameObject>((object)"2340146f44941cc45aa8edc354ad77ae").WaitForCompletion(),
					minionSkin = Addressables.LoadAssetAsync<SkinDef>((object)"510231c58a9944e45be8b90f5b41a4d0").WaitForCompletion()
				},
				new MinionSkinReplacement
				{
					minionBodyPrefab = Addressables.LoadAssetAsync<GameObject>((object)"521223397dd4da74694c073e63c3183b").WaitForCompletion(),
					minionSkin = Addressables.LoadAssetAsync<SkinDef>((object)"37af658961eb1d64b91d03d8098da0f2").WaitForCompletion()
				},
				new MinionSkinReplacement
				{
					minionBodyPrefab = Addressables.LoadAssetAsync<GameObject>((object)"442aea01d301dec41a4a7c28e112d737").WaitForCompletion(),
					minionSkin = Addressables.LoadAssetAsync<SkinDef>((object)"a725c698056caf04790c1f808f62d948").WaitForCompletion()
				}
			};
			val2.minionSkinReplacements = ArrayUtils.Clone<MinionSkinReplacement>(val.minionSkinReplacements);
			((Component)Addressables.LoadAssetAsync<GameObject>((object)"ff7711aebac29b148a7312a3cae20572").WaitForCompletion().transform.GetChild(0).GetChild(0)).gameObject.AddComponent<OperatorGunColorReplacer>();
			Addressables.LoadAssetAsync<GameObject>((object)"de1037cdfdf9bdc4f833708daffdf33d").WaitForCompletion().AddComponent<OperatorLobbySyncDroneSkinToMainSkin>();
		}
	}
	public class OperatorLobbySyncDroneSkinToMainSkin : MonoBehaviour
	{
		private Transform droneSlotL;

		private Transform droneSlotR;

		private ModelSkinController controller;

		private Material mat1 = Addressables.LoadAssetAsync<Material>((object)"a5e2282a0ad1c474696de2fe1ddd09d4").WaitForCompletion();

		private Material mat2 = Addressables.LoadAssetAsync<Material>((object)"4172ed2e16de6f04b8be2f6377521abb").WaitForCompletion();

		private Material mat3 = Addressables.LoadAssetAsync<Material>((object)"448eba93c01ca6046970593a3cc2d234").WaitForCompletion();

		public void OnEnable()
		{
			controller = ((Component)this).GetComponentInChildren<ModelSkinController>();
			controller.onSkinApplied += Controller_onSkinApplied;
			Transform child = ((Component)this).transform.GetChild(0).GetChild(0).GetChild(0)
				.GetChild(1);
			droneSlotL = child.GetChild(0).GetChild(0);
			droneSlotR = child.GetChild(1).GetChild(0);
		}

		public void OnDisable()
		{
			controller.onSkinApplied -= Controller_onSkinApplied;
		}

		private void Controller_onSkinApplied(int index)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			if (controller.skins[index]._runtimeSkin == null)
			{
				Debug.LogWarning((object)"No runtime skin");
				return;
			}
			Material material = mat1;
			Material material2 = mat2;
			Material material3 = mat3;
			if (controller.skins[index].runtimeSkin.minionSkinTemplates.Length != 0)
			{
				BodyIndex val = BodyCatalog.FindBodyIndex("DTGunnerDroneBody");
				BodyIndex val2 = BodyCatalog.FindBodyIndex("DTHealingDroneBody");
				BodyIndex val3 = BodyCatalog.FindBodyIndex("DTHaulerDroneBody");
				Enumerator<MinionSkinTemplate> enumerator = controller.skins[index].runtimeSkin.minionSkinTemplates.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						MinionSkinTemplate current = enumerator.Current;
						if (current.minionSkin._runtimeSkin == null)
						{
							current.minionSkin.Bake();
						}
						Material defaultMaterial = ((RendererInfoTemplate)current.minionSkin.runtimeSkin.rendererInfoTemplates[0]).data.defaultMaterial;
						if ((Object)(object)defaultMaterial != (Object)null)
						{
							if (current.minionBodyIndex == val)
							{
								material = defaultMaterial;
							}
							else if (current.minionBodyIndex == val2)
							{
								material2 = defaultMaterial;
							}
							else if (current.minionBodyIndex == val3)
							{
								material3 = defaultMaterial;
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
			((Renderer)((Component)droneSlotL.GetChild(2).GetChild(1)).GetComponent<SkinnedMeshRenderer>()).material = material;
			((Renderer)((Component)droneSlotR.GetChild(2).GetChild(1)).GetComponent<SkinnedMeshRenderer>()).material = material;
			((Renderer)((Component)droneSlotL.GetChild(1).GetChild(1)).GetComponent<SkinnedMeshRenderer>()).material = material2;
			((Renderer)((Component)droneSlotR.GetChild(1).GetChild(1)).GetComponent<SkinnedMeshRenderer>()).material = material2;
			((Renderer)((Component)droneSlotL.GetChild(3).GetChild(1)).GetComponent<SkinnedMeshRenderer>()).material = material3;
			((Renderer)((Component)droneSlotR.GetChild(3).GetChild(1)).GetComponent<SkinnedMeshRenderer>()).material = material3;
		}
	}
	public class OperatorGunColorReplacer : MonoBehaviour
	{
		public static Dictionary<SkinDef, Color> skinDefDic = new Dictionary<SkinDef, Color>();

		public ModelSkinController skinController;

		public void Awake()
		{
			skinController = ((Component)this).GetComponent<ModelSkinController>();
			skinController.onSkinApplied += Apply;
		}

		public void OnDisable()
		{
			skinController.onSkinApplied -= Apply;
		}

		public void Apply(int index)
		{
			//IL_0052: 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_00a0: 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)
			if (skinDefDic.TryGetValue(skinController.skins[index], out var value))
			{
				ChildLocator component = ((Component)this).GetComponent<ChildLocator>();
				Transform val = component.FindChild("ChargeVFX");
				Transform child = val.GetChild(0);
				((Component)child.GetChild(0)).GetComponent<ParticleSystem>().startColor = ((Color)(ref value)).AlphaMultiplied(0.2667f);
				((Component)child.GetChild(1)).GetComponent<ParticleSystem>().startColor = value;
				ParticleSystemRenderer component2 = ((Component)child.GetChild(2)).GetComponent<ParticleSystemRenderer>();
				((Renderer)component2).material = Object.Instantiate<Material>(((Renderer)component2).material);
				((Renderer)component2).material.SetColor("_TintColor", value);
				TrailRenderer component3 = ((Component)child.GetChild(2)).GetComponent<TrailRenderer>();
				((Renderer)component3).material = Object.Instantiate<Material>(((Renderer)component3).material);
				((Renderer)component3).material.SetColor("_TintColor", value);
			}
		}
	}
	public class SandyInteractableMaterialOverrider : MonoBehaviour
	{
		public SceneDef sceneDef;

		public Material material;

		public void OnEnable()
		{
			if (!((Object)(object)SceneCatalog.mostRecentSceneDef == (Object)(object)sceneDef))
			{
			}
		}
	}
	public static class Tags
	{
		public static ItemTag EvolutionBlacklist = (ItemTag)94;

		public static ItemTag ScavengerBlacklist = (ItemTag)95;

		public static BasicPickupDropTable dtMonsterTeamLunar;

		public static BasicPickupDropTable dtAISafeBoss;

		public static void AddTag(ItemDef def, ItemTag tag)
		{
			ArrayUtils.ArrayAppend<ItemTag>(ref def.tags, ref tag);
		}

		public static void RemoveTag(ItemDef def, ItemTag tag)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			int num = Array.IndexOf(def.tags, tag);
			if (num != -1)
			{
				ArrayUtils.ArrayRemoveAtAndResize<ItemTag>(ref def.tags, num, 1);
			}
		}

		public static void RemoveTag(ItemDef def, int index)
		{
			ArrayUtils.ArrayRemoveAtAndResize<ItemTag>(ref def.tags, index, 1);
		}

		public static void Start()
		{
			//IL_0006: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Expected I4, but got Unknown
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected I4, but got Unknown
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Expected I4, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected I4, but got Unknown
			BasicPickupDropTable val = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/MonsterTeamGainsItems/dtMonsterTeamTier1Item.asset").WaitForCompletion();
			BasicPickupDropTable val2 = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/MonsterTeamGainsItems/dtMonsterTeamTier2Item.asset").WaitForCompletion();
			BasicPickupDropTable val3 = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/MonsterTeamGainsItems/dtMonsterTeamTier3Item.asset").WaitForCompletion();
			dtMonsterTeamLunar = ScriptableObject.CreateInstance<BasicPickupDropTable>();
			((Object)dtMonsterTeamLunar).name = "dtMonsterTeamLunar";
			dtMonsterTeamLunar.tier1Weight = 0f;
			dtMonsterTeamLunar.tier2Weight = 0f;
			dtMonsterTeamLunar.tier3Weight = 0f;
			dtMonsterTeamLunar.lunarItemWeight = 1f;
			ArenaMonsterItemDropTable val4 = Addressables.LoadAssetAsync<ArenaMonsterItemDropTable>((object)"RoR2/Base/arena/dtArenaMonsterTier1.asset").WaitForCompletion();
			ArenaMonsterItemDropTable val5 = Addressables.LoadAssetAsync<ArenaMonsterItemDropTable>((object)"RoR2/Base/arena/dtArenaMonsterTier2.asset").WaitForCompletion();
			ArenaMonsterItemDropTable val6 = Addressables.LoadAssetAsync<ArenaMonsterItemDropTable>((object)"RoR2/Base/arena/dtArenaMonsterTier3.asset").WaitForCompletion();
			BasicPickupDropTable val7 = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/Common/dtAISafeTier1Item.asset").WaitForCompletion();
			BasicPickupDropTable val8 = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/Common/dtAISafeTier2Item.asset").WaitForCompletion();
			BasicPickupDropTable val9 = Addressables.LoadAssetAsync<BasicPickupDropTable>((object)"RoR2/Base/Common/dtAISafeTier3Item.asset").WaitForCompletion();
			dtAISafeBoss = ScriptableObject.CreateInstance<BasicPickupDropTable>();
			((Object)dtAISafeBoss).name = "dtAISafeBoss";
			dtAISafeBoss.tier1Weight = 0f;
			dtAISafeBoss.tier2Weight = 0f;
			dtAISafeBoss.tier3Weight = 0f;
			dtAISafeBoss.bossWeight = 1f;
			ItemTag[] array = new ItemTag[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			array[5] = (ItemTag)(int)ScavengerBlacklist;
			ItemTag[] bannedItemTags = (ItemTag[])(object)array;
			ItemTag[] array2 = new ItemTag[10];
			RuntimeHelpers.InitializeArray(array2, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			array2[4] = (ItemTag)(int)EvolutionBlacklist;
			array2[5] = (ItemTag)(int)ScavengerBlacklist;
			ItemTag[] bannedItemTags2 = (ItemTag[])(object)array2;
			ItemTag[] array3 = new ItemTag[9];
			RuntimeHelpers.InitializeArray(array3, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			array3[4] = (ItemTag)(int)ScavengerBlacklist;
			ItemTag[] bannedItemTags3 = (ItemTag[])(object)array3;
			val.bannedItemTags = bannedItemTags2;
			val2.bannedItemTags = bannedItemTags2;
			val3.bannedItemTags = bannedItemTags2;
			dtMonsterTeamLunar.bannedItemTags = bannedItemTags2;
			val4.bannedItemTags = bannedItemTags3;
			val5.bannedItemTags = bannedItemTags3;
			val6.bannedItemTags = bannedItemTags3;
			val7.bannedItemTags = bannedItemTags;
			val8.bannedItemTags = bannedItemTags;
			val9.bannedItemTags = bannedItemTags;
			dtAISafeBoss.bannedItemTags = bannedItemTags;
		}
	}
	public static class ModUtil
	{
		public enum SkinVariant
		{
			Default,
			Snow,
			Sand
		}

		public static List<EquipmentIndex> GetEliteEquipment(bool droppableOnly = true)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			List<EquipmentIndex> list = new List<EquipmentIndex>();
			try
			{
				for (int i = 0; i < EquipmentCatalog.equipmentDefs.Length; i++)
				{
					EquipmentDef val = EquipmentCatalog.equipmentDefs[i];
					if (Object.op_Implicit((Object)(object)val.passiveBuffDef) && Object.op_Implicit((Object)(object)val.passiveBuffDef.eliteDef) && ((val.dropOnDeathChance > 0f && (!Object.op_Implicit((Object)(object)Run.instance) || !Run.instance.expansionLockedEquipment.Contains(val.equipmentIndex))) || !droppableOnly))
					{
						list.Add(val.equipmentIndex);
					}
				}
				if (!droppableOnly)
				{
					list.Remove(Equipment.EliteYellowEquipment.equipmentIndex);
					list.Remove(Equipment.EliteGoldEquipment.equipmentIndex);
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)ex);
			}
			return list;
		}

		public static SkinVariant GetInteractableSkinFromStage(SceneDef scene)
		{
			switch (scene.baseSceneName)
			{
			case "snowyforest":
			case "nest":
			case "frozenwall":
			case "itfrozenwall":
				return SkinVariant.Snow;
			case "goolake":
			case "itgoolake":
			case "lemuriantemple":
			case "ironalluvium":
			case "ironalluvium2":
			case "repurposedcrater":
				return SkinVariant.Sand;
			default:
				return SkinVariant.Default;
			}
		}
	}
	public static class DLCS
	{
		public static ExpansionDef DLC1 = Addressables.LoadAssetAsync<ExpansionDef>((object)"d4f30c23b971a9b428e2796dc04ae099").WaitForCompletion();

		public static ExpansionDef DLC2 = Addressables.LoadAssetAsync<ExpansionDef>((object)"851f234056d389b42822523d1be6a167").WaitForCompletion();

		public static ExpansionDef DLC3 = Addressables.LoadAssetAsync<ExpansionDef>((object)"RoR2/DLC3/DLC3.asset").WaitForCompletion();

		public static ExpansionDef DLC4 = Addressables.LoadAssetAsync<ExpansionDef>((object)"RoR2/DLC4/DLC4.asset").WaitForCompletion();

		public static EntitlementDef entitlementDLC1 = Addressables.LoadAssetAsync<EntitlementDef>((object)"0166774839e0bd345bb11554aecbfd32").WaitForCompletion();

		public static EntitlementDef entitlementDLC2 = Addressables.LoadAssetAsync<EntitlementDef>((object)"68fcfaddae5157f4581a1fc209e4eac6").WaitForCompletion();

		public static EntitlementDef entitlementDLC3 = Addressables.LoadAssetAsync<EntitlementDef>((object)"6673dacf8c8aa87409fc73e6da34684b").WaitForCompletion();

		public static EntitlementDef entitlementDLC4 = Addressables.LoadAssetAsync<EntitlementDef>((object)"RoR2/DLC4/entitlementDLC4.asset").WaitForCompletion();
	}
	public static class SceneList
	{
		public static SceneDef Blackbeach = Addressables.LoadAssetAsync<SceneDef>((object)"c129d2b9e62c31b4ba165091d1ae2c50").WaitForCompletion();

		public static SceneDef Blackbeach2 = Addressables.LoadAssetAsync<SceneDef>((object)"f87198140bf9b5a4f82e206231df9091").WaitForCompletion();

		public static SceneDef Golemplains = Addressables.LoadAssetAsync<SceneDef>((object)"8ba24a95e46b3944280a4b66afd0c4dc").WaitForCompletion();

		public static SceneDef Golemplains2 = Addressables.LoadAssetAsync<SceneDef>((object)"657a62eb3e4c409429c91ba6fdb7d921").WaitForCompletion();

		public static SceneDef SulfurPools = Addressables.LoadAssetAsync<SceneDef>((object)"796f9b67682b3db4c8c5af7294d0490c").WaitForCompletion();

		public static SceneDef RootJungle = Addressables.LoadAssetAsync<SceneDef>((object)"ced489f798226594db0d115af2101a9b").WaitForCompletion();

		public static SceneDef Habitat = Addressables.LoadAssetAsync<SceneDef>((object)"0b33829c6cdfad34a8160c6ae17edfcc").WaitForCompletion();

		public static SceneDef HabitatFall = Addressables.LoadAssetAsync<SceneDef>((object)"962a6a8a56f584b468a4835c82c11951").WaitForCompletion();

		public static SceneDef itGolemPlains = Addressables.LoadAssetAsync<SceneDef>((object)"dda7dbdf013275747949dfc522842635").WaitForCompletion();

		public static SceneDef itGoolake = Addressables.LoadAssetAsync<SceneDef>((object)"0a35bec906d067941a8a378b963e9e9d").WaitForCompletion();

		public static SceneDef itAncientLoft = Addressables.LoadAssetAsync<SceneDef>((object)"568295b69af09c241968fa18ca37b56d").WaitForCompletion();

		public static SceneDef itFrozenwall = Addressables.LoadAssetAsync<SceneDef>((object)"0ab15976715ddd6438e2e5bd6ddbe224").WaitForCompletion();

		public static SceneDef itDampCave = Addressables.LoadAssetAsync<SceneDef>((object)"c33b24f6ebf27db49a5cfb88dbe9b8ff").WaitForCompletion();

		public static SceneDef itSkyMeadow = Addressables.LoadAssetAsync<SceneDef>((object)"6a2712b5c8cf36f44b34c128f2759522").WaitForCompletion();

		public static SceneDef itMoon = Addressables.LoadAssetAsync<SceneDef>((object)"RoR2/DLC1/itmoon/itmoon.asset").WaitForCompletion();

		public static SceneDef Moon2 = Addressables.LoadAssetAsync<SceneDef>((object)"5d69f3396feb7ba428d1e53a44479594").WaitForCompletion();

		public static SceneDef MysterySpace = Addressables.LoadAssetAsync<SceneDef>((object)"1303cd0450cbaf140970e7afd5162314").WaitForCompletion();

		public static SceneDef VoidStage = Addressables.LoadAssetAsync<SceneDef>((object)"66e0cfba315981a40afae481363ea0da").WaitForCompletion();

		public static SceneDef VoidRaid = Addressables.LoadAssetAsync<SceneDef>((object)"223a0f0a86052654a9e473d13f77cb41").WaitForCompletion();
	}
	public static class MissedContent
	{
		public static class Items
		{
			public static ItemDef ScrapWhiteSuppressed = Addressables.LoadAssetAsync<ItemDef>((object)"RoR2/DLC1/ScrapVoid/ScrapWhiteSuppressed.asset").WaitForCompletion();

			public static ItemDef ScrapGreenSuppressed = Addressables.LoadAssetAsync<ItemDef>((object)"RoR2/DLC1/ScrapVoid/ScrapGreenSuppressed.asset").WaitForCompletion();

			public static ItemDef ScrapRedSuppressed = Addressables.LoadAssetAsync<ItemDef>((object)"RoR2/DLC1/ScrapVoid/ScrapRedSuppressed.asset").WaitForCompletion();
		}

		public static class Equipment
		{
			public static EquipmentDef EliteEarthEquipment = Addressables.LoadAssetAsync<EquipmentDef>((object)"463f8f6917dd8af40860b023a520f051").WaitForCompletion();
		}

		public static class BodyPrefabs
		{
			public static CharacterBody SquidTurretBody = Addressables.LoadAssetAsync<GameObject>((object)"5290eaf612d386740ac26f289e06b62f").WaitForCompletion().GetComponent<CharacterBody>();

			public static CharacterBody BeetleGuardAllyBody = Addressables.LoadAssetAsync<GameObject>((object)"e21e3b9cdc2802148986eda1c923c9a1").WaitForCompletion().GetComponent<CharacterBody>();

			public static CharacterBody RoboBallGreenBuddyBody = Addressables.LoadAssetAsync<GameObject>((object)"d64335d9c1517cb4a8764a0de1d01a03").WaitForCompletion().GetComponent<CharacterBody>();

			public static CharacterBody RoboBallRedBuddyBody = Addressables.LoadAssetAsync<GameObject>((object)"e8a603acea1fa2249a83c0257a9f5f10").WaitForCompletion().GetComponent<CharacterBody>();
		}

		public static class GameEndings
		{
			public static GameEndingDef EscapeSequenceFailed = Addressables.LoadAssetAsync<GameEndingDef>((object)"RoR2/Base/ClassicRun/EscapeSequenceFailed.asset").WaitForCompletion();
		}

		public static class Survivors
		{
			public static SurvivorDef VoidSurvivor = Addressables.LoadAssetAsync<SurvivorDef>((object)"dc32bd426643dce478dd1b04fd07cdf6").WaitForCompletion();
		}

		public static class Elites
		{
			public static EliteDef edSecretSpeed = Addressables.LoadAssetAsync<EliteDef>((object)"9752d818bdea9b449845fc4df8aed07a").WaitForCompletion();

			public static EliteDef CollectiveWeak = Addressables.LoadAssetAsync<EliteDef>((object)"5834fbe05a0d4ce4eae57f87aae57920").WaitForCompletion();
		}
	}
}
namespace WolfoLibrary.Testing
{
	internal class Commands
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_VerifyLocalSteamUser <0>__EntitlementAbstractions_VerifyLocalSteamUser;

			public static Action<Inventory> <1>__OnInventoryChangedGlobal;
		}

		public static bool cheatsEnabled = false;

		public static List<EntitlementDef> disabledDefs;

		public static bool voidItems = true;

		public static void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			object obj = <>O.<0>__EntitlementAbstractions_VerifyLocalSteamUser;
			if (obj == null)
			{
				hook_VerifyLocalSteamUser val = EntitlementAbstractions_VerifyLocalSteamUser;
				<>O.<0>__EntitlementAbstractions_VerifyLocalSteamUser = val;
				obj = (object)val;
			}
			EntitlementAbstractions.VerifyLocalSteamUser += (hook_VerifyLocalSteamUser)obj;
		}

		private static bool EntitlementAbstractions_VerifyLocalSteamUser(orig_VerifyLocalSteamUser orig, EntitlementDef entitlementDef)
		{
			if (disabledDefs != null && disabledDefs.Contains(entitlementDef))
			{
				return false;
			}
			return orig.Invoke(entitlementDef);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCToggleVoidFiend(ConCommandArgs args)
		{
			if (!Object.op_Implicit((Object)(object)((ConCommandArgs)(ref args)).senderBody))
			{
				Debug.Log((object)"No Body");
				return;
			}
			VoidSurvivorController component = ((Component)((ConCommandArgs)(ref args)).senderBody).GetComponent<VoidSurvivorController>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				Debug.Log((object)"No Void Fiend");
				return;
			}
			component.corruptionPerCrit *= -1f;
			component.corruptionForFullDamage *= -1f;
			component.corruptionPerSecondOutOfCombat *= -1f;
			component.corruptionPerSecondInCombat *= -1f;
			component._corruption = 0f;
			Debug.Log((object)((component.corruptionPerCrit > 0f) ? "Enabled" : "DisabledVoid Fiend Corruption"));
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCToggleVoidItems(ConCommandArgs args)
		{
			if (voidItems)
			{
				Inventory.onInventoryChangedGlobal -= ContagiousItemManager.OnInventoryChangedGlobal;
			}
			else
			{
				Inventory.onInventoryChangedGlobal += ContagiousItemManager.OnInventoryChangedGlobal;
			}
			Debug.Log((object)(voidItems ? "Enabled" : "DisabledVoid Item Corruption"));
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCToggleDLC(ConCommandArgs args)
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			int num = ((ConCommandArgs)(ref args)).TryGetArgInt(0) ?? 0;
			num--;
			if (num == -1)
			{
				Debug.Log((object)"Need expansion number");
				return;
			}
			if (disabledDefs == null)
			{
				disabledDefs = new List<EntitlementDef>();
			}
			EntitlementDef entitlementDef = EntitlementCatalog.GetEntitlementDef((EntitlementIndex)num);
			if (disabledDefs.Contains(entitlementDef))
			{
				disabledDefs.Remove(entitlementDef);
				Debug.Log((object)("Reallowing" + Language.GetString(entitlementDef.nameToken)));
			}
			else
			{
				disabledDefs.Add(entitlementDef);
				Debug.Log((object)("Disabling" + Language.GetString(entitlementDef.nameToken)));
			}
			EntitlementManager.CCEntitlementForceRefresh(args);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCLoad(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			Debug.Log((object)("Loading: " + ((ConCommandArgs)(ref args)).TryGetArgString(0)));
			Debug.Log((object)Addressables.LoadAssetAsync<Object>((object)((ConCommandArgs)(ref args)).TryGetArgString(0)).WaitForCompletion());
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCRandomUnlock(ConCommandArgs args)
		{
			if (!cheatsEnabled)
			{
				Debug.Log((object)"WolfoLibrary commands are only available with DebugToolkit installed");
				return;
			}
			int num = ((ConCommandArgs)(ref args)).TryGetArgInt(0) ?? 1;
			int num2 = 0;
			while (num2 < num)
			{
				int num3 = Run.instance.runRNG.RangeInt(0, UnlockableCatalog.unlockableCount);
				UnlockableDef unlockableDef = UnlockableCatalog.GetUnlockableDef((UnlockableIndex)num3);
				if (unlockableDef.hidden)
				{
					continue;
				}
				num2++;
				foreach (NetworkUser readOnlyInstances in NetworkUser.readOnlyInstancesList)
				{
					if (readOnlyInstances.isParticipating)
					{
						readOnlyInstances.ServerHandleUnlock(unlockableDef);
						Debug.Log((object)("Granting " + Language.GetString(unlockableDef.nameToken)));
					}
				}
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CC_clear_notifs(ConCommandArgs args)
		{
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			UserProfile userProfile = firstLocalUser.userProfile;
			StatSheet statSheet = userProfile.statSheet;
			if (userProfile != null)
			{
				userProfile.ClearAllAchievementNotifications();
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CC_AllUnlocks(ConCommandArgs args)
		{
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			if (!cheatsEnabled)
			{
				Debug.Log((object)"WolfoLibrary commands are only available with DebugToolkit installed");
				return;
			}
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			UserProfile userProfile = firstLocalUser.userProfile;
			StatSheet statSheet = userProfile.statSheet;
			if (userProfile != null)
			{
				for (int i = 0; AchievementManager.achievementDefs.Length > i; i++)
				{
					userProfile.AddAchievement(AchievementManager.achievementDefs[i].identifier, false);
				}
				for (int j = 0; UnlockableCatalog.unlockableCount > j; j++)
				{
					statSheet.AddUnlockable((UnlockableIndex)j);
				}
				for (int k = 0; BodyCatalog.bodyCount > k; k++)
				{
					statSheet.PushStatValue(PerBodyStatDef.timesSummoned, (BodyIndex)k, 1uL);
				}
				for (int l = 0; SurvivorCatalog.survivorCount > l; l++)
				{
					statSheet.PushStatValue(PerBodyStatDef.totalWins, SurvivorCatalog.survivorIndexToBodyIndex[l], 1uL);
				}
				for (int m = 0; PickupCatalog.pickupCount > m; m++)
				{
					userProfile.SetPickupDiscovered(new PickupIndex(m), true);
				}
				userProfile.ClearAllAchievementNotifications();
				userProfile.RequestEventualSave();
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CC_RemoveUnlocks(ConCommandArgs args)
		{
			if (!cheatsEnabled)
			{
				Debug.Log((object)"WolfoLibrary commands are only available with DebugToolkit installed");
				return;
			}
			LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
			UserProfile userProfile = firstLocalUser.userProfile;
			StatSheet statSheet = userProfile.statSheet;
			if (userProfile != null)
			{
				for (int i = 0; UnlockableCatalog.unlockableCount > i; i++)
				{
					statSheet.RemoveUnlockable((UnlockableIndex)i);
				}
				int num = userProfile.achievementsList.Count - 1;
				while (0 <= num)
				{
					userProfile.RevokeAchievement(userProfile.achievementsList[num]);
					num--;
				}
				userProfile.RequestEventualSave();
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCSimuSoftlock(ConCommandArgs args)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			if (!cheatsEnabled)
			{
				Debug.Log((object)"WolfoLibrary commands are only available with DebugToolkit installed");
				return;
			}
			if (!Object.op_Implicit((Object)(object)Run.instance))
			{
				Debug.LogWarning((object)"No Run");
			}
			if (!(Run.instance is InfiniteTowerRun))
			{
				Debug.LogWarning((object)"No Simu Run");
			}
			InfiniteTowerRun val = (InfiniteTowerRun)Run.instance;
			try
			{
				if (Object.op_Implicit((Object)(object)val.waveController))
				{
					val.waveController.OnAllEnemiesDefeatedServer();
					val.waveController.ForceFinish();
				}
				else
				{
					val.OnWaveAllEnemiesDefeatedServer((InfiniteTowerWaveController)null);
					val.CleanUpCurrentWave();
					if (Object.op_Implicit((Object)(object)val.waveInstance))
					{
						Object.Destroy((Object)(object)val.waveInstance);
					}
					if (!val.IsStageTransitionWave())
					{
						val.BeginNextWave();
					}
				}
				if (Object.op_Implicit((Object)(object)val.safeWardController) && !(val.safeWardController.wardStateMachine.state is Active))
				{
					val.safeWardController.wardStateMachine.SetState((EntityState)new Active());
				}
			}
			catch (Exception ex)
			{
				((Run)val).PickNextStageSceneFromCurrentSceneDestinations();
				DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest((SpawnCard)(object)val.stageTransitionPortalCard, new DirectorPlacementRule
				{
					minDistance = 0f,
					maxDistance = val.stageTransitionPortalMaxDistance,
					placementMode = (PlacementMode)1,
					position = ((Component)val.safeWardController).transform.position,
					spawnOnTarget = ((Component)val.safeWardController).transform
				}, val.safeWardRng));
				Chat.AddMessage((ChatMessageBase)new SimpleChatMessage
				{
					baseToken = val.stageTransitionChatToken
				});
				if (Object.op_Implicit((Object)(object)val.safeWardController))
				{
					val.safeWardController.WaitForPortal();
				}
				Debug.LogWarning((object)ex.ToString());
			}
			Debug.LogWarning((object)"Report any errors");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCAllItems(ConCommandArgs args)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Invalid comparison between Unknown and I4
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Invalid comparison between Unknown and I4
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Invalid comparison between Unknown and I4
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Invalid comparison between Unknown and I4
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Invalid comparison between Unknown and I4
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Invalid comparison between Unknown and I4
			if (!cheatsEnabled)
			{
				Debug.Log((object)"WolfoLibrary commands are only available with DebugToolkit installed");
				return;
			}
			int num = ((ConCommandArgs)(ref args)).TryGetArgInt(0) ?? 0;
			if (!Object.op_Implicit((Object)(object)((ConCommandArgs)(ref args)).senderMaster) || !NetworkServer.active)
			{
				return;
			}
			if (num == 1)
			{
				for (int i = 0; i < ItemCatalog.itemCount; i++)
				{
					try
					{
						((ConCommandArgs)(ref args)).senderMaster.inventory.GiveItemPermanent((ItemIndex)i, 1);
					}
					catch (Exception)
					{
					}
				}
				((ConCommandArgs)(ref args)).senderMaster.inventory.GiveItemPermanent(Items.HealthDecay, 999999);
				ContagiousItemManager.originalToTransformed = Array.Empty<ItemIndex>();
				ContagiousItemManager.transformationInfos = ReadOnlyArray<TransformationInfo>.op_Implicit(Array.Empty<TransformationInfo>());
			}
			else
			{
				for (int j = 0; j < ItemCatalog.itemCount; j++)
				{
					ItemDef itemDef = ItemCatalog.GetItemDef((ItemIndex)j);
					if ((int)itemDef.tier == 5)
					{
						continue;
					}
					if (num != 2 && (int)itemDef.tier != 5 && (int)itemDef.tier != 9 && (int)itemDef.tier != 6 && (int)itemDef.tier != 7 && (int)itemDef.tier != 8)
					{
						try
						{
							((ConCommandArgs)(ref args)).senderMaster.inventory.GiveItemPermanent((ItemIndex)j, 1);
						}
						catch (Exception)
						{
						}
					}
					try
					{
						((ConCommandArgs)(ref args)).senderMaster.inventory.GiveItemPermanent((ItemIndex)j, 1);
					}
					catch (Exception)
					{
					}
				}
			}
			Object.Destroy((Object)(object)((Component)((ConCommandArgs)(ref args)).senderMaster).GetComponent<MasterSuicideOnTimer>());
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCALLBuffs(ConCommandArgs args)
		{
			if (!cheatsEnabled)
			{
				Debug.Log((object)"WolfoLibrary commands are only available with DebugToolkit installed");
			}
			else if (Object.op_Implicit((Object)(object)((ConCommandArgs)(ref args)).senderBody) && NetworkServer.active)
			{
				CharacterBody senderBody = ((ConCommandArgs)(ref args)).senderBody;
				for (int i = 0; i < BuffCatalog.buffCount; i++)
				{
					((ConCommandArgs)(ref args)).senderBody.AddBuff((BuffIndex)i);
				}
			}
		}
	}
	internal class Commands_Lists
	{
		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_CurrentStats(ConCommandArgs args)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Invalid comparison between Unknown and I4
			StatSheet val = null;
			if (PlayerCharacterMasterController.instances.Count != 0)
			{
				val = PlayerCharacterMasterController.instances[0].master.playerStatsComponent.currentStats;
			}
			else
			{
				LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
				UserProfile userProfile = firstLocalUser.userProfile;
				val = userProfile.statSheet;
			}
			if (val == null)
			{
				Debug.Log((object)"No Players");
				return;
			}
			string text = "";
			for (int i = 0; i < val.fields.Length; i++)
			{
				StatDef statDef = val.fields[i].statDef;
				if ((int)statDef.dataType == 0)
				{
					if (((StatField)(ref val.fields[i])).ulongValue != 0)
					{
						text += string.Format("\n[{0}] {1} | {2}", new object[3]
						{
							i,
							statDef.name,
							((StatField)(ref val.fields[i])).ulongValue
						});
					}
				}
				else if ((int)statDef.dataType == 1 && ((StatField)(ref val.fields[i])).doubleValue > 0.0)
				{
					text += string.Format("\n[{0}] {1} | {2}", new object[3]
					{
						i,
						statDef.name,
						((StatField)(ref val.fields[i])).doubleValue
					});
				}
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_StatDef(ConCommandArgs args)
		{
			//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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			string text = "";
			StatField[] fieldsTemplate = StatSheet.fieldsTemplate;
			foreach (StatField val in fieldsTemplate)
			{
				text = text + "\n" + val.statDef.name + " | " + Language.GetString(val.statDef.displayToken);
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public unsafe static void CCList_SceneDef(ConCommandArgs args)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			string text = "";
			Enumerator<SceneDef> enumerator = SceneCatalog.allSceneDefs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					SceneDef current = enumerator.Current;
					if (!current.isOfflineScene)
					{
						string[] obj = new string[5] { text, "\n", current.cachedName, " | ", null };
						Color environmentColor = current.environmentColor;
						obj[4] = ((object)(*(Color*)(&environmentColor))/*cast due to .constrained prefix*/).ToString();
						text = string.Concat(obj);
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCListCategoriesInPercent(ConCommandArgs args)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)ClassicStageInfo.instance))
			{
				Debug.Log((object)"Must be on stage");
			}
			DirectorCardCategorySelection interactableCategories = ClassicStageInfo.instance.interactableCategories;
			if (!Object.op_Implicit((Object)(object)interactableCategories))
			{
				Debug.Log((object)"No DCCS");
			}
			float num = interactableCategories.SumOfAllCategories();
			string text = "--" + SceneInfo.instance.sceneDef.cachedName + "--\n";
			Category[] categories = interactableCategories.categories;
			foreach (Category val in categories)
			{
				text = text + val.name + " | " + val.selectionWeight / num * 100f + "%\n";
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_RuleDef(ConCommandArgs args)
		{
			string text = "";
			foreach (RuleDef allRuleDef in RuleCatalog.allRuleDefs)
			{
				text = text + "\n" + allRuleDef.globalName;
				foreach (RuleChoiceDef choice in allRuleDef.choices)
				{
					text = text + "\n-" + choice.globalName;
				}
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_EffectDef(ConCommandArgs args)
		{
			string text = "";
			EffectDef[] entries = EffectCatalog.entries;
			foreach (EffectDef val in entries)
			{
				text = text + "\n" + val.prefabName;
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_CombatDirector(ConCommandArgs args)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			SceneDirector val = Object.FindFirstObjectByType<SceneDirector>();
			if (!Object.op_Implicit((Object)(object)ClassicStageInfo.instance))
			{
				Debug.Log((object)"No SceneDirector");
				return;
			}
			string text = string.Empty;
			float num = ClassicStageInfo.instance.modifiableMonsterCategories.SumOfAllCategories();
			for (int i = 0; i < ClassicStageInfo.instance.monsterSelection.Count; i++)
			{
				ChoiceInfo<DirectorCard> val2 = ClassicStageInfo.instance.monsterSelection.choices[i];
				text += string.Format("\n{0} | {1}", new object[2]
				{
					((Object)val2.value.spawnCard).name,
					val2.weight / num * 100f + "%"
				});
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_SceneDirector(ConCommandArgs args)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			SceneDirector val = Object.FindFirstObjectByType<SceneDirector>();
			if (!Object.op_Implicit((Object)(object)val))
			{
				Debug.Log((object)"No SceneDirector");
				return;
			}
			string text = string.Empty;
			float num = ClassicStageInfo.instance.interactableCategories.SumOfAllCategories();
			WeightedSelection<DirectorCard> val2 = val.GenerateInteractableCardSelection();
			for (int i = 0; i < val2.Count; i++)
			{
				ChoiceInfo<DirectorCard> val3 = val2.choices[i];
				text += string.Format("\n{0} | {1}", new object[2]
				{
					((Object)val3.value.spawnCard).name,
					val3.weight / num * 100f + "%"
				});
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_PickupDef(ConCommandArgs args)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			string text = "";
			for (int i = 0; i < PickupCatalog.entries.Length; i++)
			{
				PickupDef val = PickupCatalog.entries[i];
				text += string.Format("{3}|{0} | <color=#{2}>{1}</color>\n", val.internalName, Language.GetString(val.nameToken), ColorUtility.ToHtmlStringRGB(val.baseColor), i);
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_MusicDef(ConCommandArgs args)
		{
			string text = "";
			for (int i = 0; i < MusicTrackCatalog.musicTrackDefs.Length; i++)
			{
				MusicTrackDef val = MusicTrackCatalog.musicTrackDefs[i];
				text += string.Format("{0} | {1}\n", new object[2] { val.cachedName, val.comment });
			}
			Debug.Log((object)text);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_BuffDefFlags(ConCommandArgs args)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			string text = "\n--HiddenBuffs--";
			string text2 = "\n--IgnoredByNectar--";
			string text3 = "\n--IgnoredByNoxThorn--";
			BuffDef[] buffDefs = BuffCatalog.buffDefs;
			foreach (BuffDef val in buffDefs)
			{
				if (val.isHidden)
				{
					text = text + "\n" + ((Object)val).name;
					continue;
				}
				if (((Enum)val.flags).HasFlag((Enum)(object)(Flags)1))
				{
					text3 = text3 + "\n" + ((Object)val).name;
				}
				if (val.ignoreGrowthNectar && !val.isDebuff && !val.isCooldown && !val.isDOT)
				{
					text2 = text2 + "\n" + ((Object)val).name;
				}
			}
			Debug.Log((object)text);
			Debug.Log((object)text2);
			Debug.Log((object)text3);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_BodyFlags(ConCommandArgs args)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			string empty = string.Empty;
			CharacterBody[] bodyPrefabBodyComponents = BodyCatalog.bodyPrefabBodyComponents;
			foreach (CharacterBody val in bodyPrefabBodyComponents)
			{
				Debug.LogFormat("\n{0}\n{1}", new object[2]
				{
					((Object)val).name,
					val.bodyFlags
				});
			}
			Debug.LogFormat(empty, Array.Empty<object>());
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_SimuWaves(ConCommandArgs args)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			List<DetachParticleOnDestroyAndEndEmission> list = Resources.FindObjectsOfTypeAll<DetachParticleOnDestroyAndEndEmission>().ToList();
			foreach (DetachParticleOnDestroyAndEndEmission item in list)
			{
				if (Object.op_Implicit((Object)(object)((Component)item).GetComponent<EffectComponent>()))
				{
					if (((Behaviour)item).enabled && (Object)(object)item.particleSystem != (Object)null)
					{
						Debug.LogWarning((object)((Object)((Component)item).transform.root).name);
					}
					else
					{
						Debug.Log((object)((Object)((Component)item).transform.root).name);
					}
				}
			}
			List<InfiniteTowerWaveCategory> list2 = Resources.FindObjectsOfTypeAll<InfiniteTowerWaveCategory>().ToList();
			foreach (InfiniteTowerWaveCategory item2 in list2)
			{
				string text = "_____\n" + ((Object)item2).name;
				for (int i = 0; i < item2.wavePrefabs.Length; i++)
				{
					Transform child = item2.wavePrefabs[i].wavePrefab.GetComponent<InfiniteTowerWaveController>().overlayEntries[1].prefab.transform.GetChild(0).GetChild(1);
					text += string.Format("\n<color=#{2}>{0}</color>\n<color=#{3}>{1}</color>\nWeight:{4}", Language.GetString(((Component)child.GetChild(0)).GetComponent<InfiniteTowerWaveCounter>().token), Language.GetString(((Component)child.GetChild(1)).GetComponent<LanguageTextMeshController>().token), ColorUtility.ToHtmlStringRGB(((Graphic)((Component)child.GetChild(0)).GetComponent<TextMeshProUGUI>()).color), ColorUtility.ToHtmlStringRGB(((Graphic)((Component)child.GetChild(1)).GetComponent<TextMeshProUGUI>()).color), item2.wavePrefabs[i].weight);
				}
				Debug.Log((object)text);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public unsafe static void CCList_ItemTags(ConCommandArgs args)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < ItemCatalog.allItemDefs.Length; i++)
			{
				ItemDef val = (ItemDef)Unsafe.Read<object>((void*)ItemCatalog.allItemDefs[i]);
				string text = "\n__" + ((Object)val).name + " | " + Language.GetString(val.nameToken) + "__";
				for (int j = 0; j < val.tags.Length; j++)
				{
					text = text + "\n" + ((object)Unsafe.As<ItemTag, ItemTag>(ref val.tags[j])/*cast due to .constrained prefix*/).ToString();
				}
				Debug.Log((object)text);
			}
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public unsafe static void CCList_ItemCategory(ConCommandArgs args)
		{
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			string text = "______\nItems tagged as Damage";
			string text2 = "______\nItems tagged as Healing";
			string text3 = "______\nItems tagged as Utility";
			string text4 = "______\nItems tagged as AIBlacklist";
			string text5 = "______\nItems tagged as CannotDuplicate";
			for (int i = 0; i < ItemCatalog.allItemDefs.Length; i++)
			{
				ItemDef val = (ItemDef)Unsafe.Read<object>((void*)ItemCatalog.allItemDefs[i]);
				if ((int)val.tier != 5)
				{
					string text6 = string.Format("\n<color=#{1}>{0}</color>", new object[2]
					{
						Language.GetString(val.nameToken),
						ColorCatalog.GetColorHexString(val.colorIndex)
					});
					if (Array.IndexOf(val.tags, (ItemTag)1) != -1)
					{
						text += text6;
					}
					if (Array.IndexOf(val.tags, (ItemTag)2) != -1)
					{
						text2 += text6;
					}
					if (Array.IndexOf(val.tags, (ItemTag)3) != -1)
					{
						text3 += text6;
					}
					if (Array.IndexOf(val.tags, (ItemTag)4) != -1)
					{
						text4 += text6;
					}
					if (Array.IndexOf(val.tags, (ItemTag)15) != -1)
					{
						text5 += text6;
					}
				}
			}
			Debug.Log((object)text);
			Debug.Log((object)text2);
			Debug.Log((object)text3);
			Debug.Log((object)text4);
			Debug.Log((object)text5);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		public static void CCList_DCCS(ConCommandArgs args)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: 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)
			List<DirectorCardCategorySelection> list = new List<DirectorCardCategorySelection>();
			foreach (IResourceLocator resourceLocator in Addressables.ResourceLocators)
			{
				foreach (object key in resourceLocator.Keys)
				{
					DirectorCardCategorySelection val = Addressables.LoadAssetAsync<DirectorCardCategorySelection>(key).WaitForCompletion();
					if ((Object)(object)val != (Object)null)
					{
						CollectionUtils.AddDistinct<DirectorCardCategorySelection>((IList<DirectorCardCategorySelection>)list, val);
					}
					Addressables.LoadAssetAsync<SpawnCard>(key).WaitForCompletion();
					Addressables.LoadAssetAsync<DccsPool>(key).WaitForCompletion();
				}
			}
			List<DirectorCardCategorySelection> list2 = new List<DirectorCardCategorySelection>();
			List<DirectorCardCategorySelection> list3 = new List<DirectorCardCategorySelection>();
			List<DirectorCardCategorySelection> list4 = new List<DirectorCardCategorySelection>();
			List<DirectorCardCategorySelection> list5 = new List<DirectorCardCategorySelection>();
			List<DirectorCardCategorySelection> list6 = Resources.FindObjectsOfTypeAll<DirectorCardCategorySelection>().ToList();
			List<DccsPool> list7 = Resources.FindObjectsOfTypeAll<DccsPool>().OfType<DccsPool>().ToList();
			List<CharacterSpawnCard> list8 = Resources.FindObjectsOfTypeAll<CharacterSpawnCard>().OfType<CharacterSpawnCard>().ToList();
			List<InteractableSpawnCard> list9 = Resources.FindObjectsOfTypeAll<InteractableSpawnCard>().OfType<InteractableSpawnCard>().ToList();
			foreach (DirectorCardCategorySelection item in list)
			{
				list6.Remove(item);
				if (item is FamilyDirectorCardCategorySelection)
				{
					list4.Add(item);
				}
				else if (((Object)item).name.Contains("Interactables"))
				{
					list2.Add(item);
				}
				else if (((Object)item).name.Contains("Monsters"))
				{
					list3.Add(item);
				}
				else
				{
					list5.Add(item);
				}
			}
			list3.Sort((DirectorCardCategorySelection x, DirectorCardCategorySelection y) => string.Compare(((Object)x).name, ((Object)y).name));
			list2.Sort((DirectorCardCategorySelection x, DirectorCardCategorySelection y) => string.Compare(((Object)x).name, ((Object)y).name));
			list4.Sort((DirectorCardCategorySelection x, DirectorCardCategorySelection y) => string.Compare(((Object)x).name, ((Object)y).name));
			list5.Sort((DirectorCardCategorySelection x, DirectorCardCategorySelection y) => string.Compare(((Object)x).name, ((Object)y).name));
			list6.Sort((DirectorCardCategorySelection x, DirectorCardCategorySelection y) => string.Compare(((Object)x).name, ((Object)y).name));
			list7.Sort((DccsPool x, DccsPool y) => string.Compare(((Object)x).name, ((Object)y).name));
			list8.Sort((CharacterSpawnCard x, CharacterSpawnCard y) => string.Compare(((Object)x).name, ((Object)y).name));
			list9.Sort((InteractableSpawnCard x, InteractableSpawnCard y) => string.Compare(((Object)x).name, ((Object)y).name));
			Debug.Log((object)"\nDCCS | All Interactables");
			DumpDCCSList(list2);
			Debug.Log((object)"\nDCCS | All Monsters");
			DumpDCCSList(list3);
			Debug.Log((object)"\nDCCS | All Families");
			DumpDCCSList(list4);
			Debug.Log((object)"\nDCCS | Misc");
			DumpDCCSList(list5);
			Debug.Log((object)"\nDCCS | Not Vanilla");
			DumpDCCSList(list6);
			Debug.Log((object)"\nDP | All DccsPools");
			for (int num = 0; list7.Count > num; num++)
			{
				string text = "\n--------------------\n";
				text += ((Object)list7[num]).name;
				for (int num2 = 0; list7[num].poolCategories.Length > num2; num2++)
				{
					Category val2 = list7[num].poolCategories[num2];
					text = text + "\n--[" + num2 + "]--" + val2.name;
					for (int num3 = 0; val2.alwaysIncluded.Length > num3; num3++)
					{
						text = text + "\n[" + num3 + "] " + ((Object)val2.alwaysIncluded[num3].dccs).name + "  wt:" + val2.alwaysIncluded[num3].weight;
					}
					for (int num4 = 0; val2.includedIfConditionsMet.Length > num4; num4++)
					{
						text = text + "\n[" + num4 + "] " + ((Object)((PoolEntry)val2.includedIfConditionsMet[num4]).dccs).name + "  wt:" + ((PoolEntry)val2.includedIfConditionsMet[num4]).weight;
					}
					for (int num5 = 0; val2.includedIfNoConditionsMet.Length > num5; num5++)
					{
						text = text + "\n[" + num5 + "] " + ((Object)val2.includedIfNoConditionsMet[num5].dccs).name + "  wt:" + val2.includedIfNoConditionsMet[num5].weight;
					}
				}
				Debug.Log((object)text);
			}
			Debug.Log((object)"--\nCharacterSpawnCards\n--");
			for (int num6 = 0; list8.Count > num6; num6++)
			{
				Debug.Log((object)(((Object)list8[num6]).name + " Cost:" + ((SpawnCard)list8[num6]).directorCreditCost));
			}
			Debug.Log((object)"--\nInteractableSpawnCards\n--");
			for (int num7 = 0; list9.Count > num7; num7++)
			{
				Debug.Log((object)(((Object)list9[num7]).name + " Cost:" + ((SpawnCard)list9[num7]).directorCreditCost));
			}
		}

		public static void DumpDCCSList(List<DirectorCardCategorySelection> allDCCS)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: 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)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; allDCCS.Count > i; i++)
			{
				string text = "\n-------------------\n";
				text += ((Object)allDCCS[i]).name;
				DirectorCardCategorySelection obj = allDCCS[i];
				FamilyDirectorCardCategorySelection val = (FamilyDirectorCardCategorySelection)(object)((obj is FamilyDirectorCardCategorySelection) ? obj : null);
				if (Object.op_Implicit((Object)(object)val))
				{
					text = text + "\nfamilyStart: " + val.minimumStageCompletion;
					text = text + "\nfamilyEnd: " + val.maximumStageCompletion;
				}
				for (int j = 0; allDCCS[i].categories.Length > j; j++)
				{
					Category val2 = allDCCS[i].categories[j];
					text = text + "\n--[" + j + "]--" + val2.name + "--  wt:" + allDCCS[i].categories[j].selectionWeight;
					for (int k = 0; val2.cards.Length > k; k++)
					{
						text = text + "\n[" + k + "] ";
						text = (Object.op_Implicit((Object)(object)val2.cards[k].spawnCard) ? (text + ((Object)val2.cards[k].spawnCard).name) : (text + "NULL Spawn Card"));
						text = text + "  wt:" + val2.cards[k].selectionWeight + "  minStage:" + val2.cards[k].minimumStageCompletions;
						if (Object.op_Implicit((Object)(object)val2.cards[k].forbiddenUnlockableDef) || !string.IsNullOrEmpty(val2.cards[k].forbiddenUnlockable))
						{
							text = text + " forbiddenWhen: " + val2.cards[k].forbiddenUnlockable + (object)val2.cards[k].forbiddenUnlockableDef;
						}
					}
				}
				Debug.Log((object)text);
			}
		}
	}
	internal class Test
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_GetOptionsFromPickupState <0>__CommandWithEveryItem;

			public static Manipulator <1>__ServerAuthManager_HandleSetClientAuth;

			public static hook_GetUserMaster <2>__Run_GetUserMaster;

			public static hook_OnLobbyJoined_bool_string <3>__SteamworksLobbyManager_OnLobbyJoined_bool_string;
		}

		public static void Awake()
		{
		}

		public static void Start()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_007b: 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_0086: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			if (WConfig.cfgTestLogbook.Value)
			{
				Test_Logbook.CheatLogbook();
			}
			if (WConfig.cfgTestMultiplayer.Value)
			{
				object obj = <>O.<0>__CommandWithEveryItem;
				if (obj == null)
				{
					hook_GetOptionsFromPickupState val = CommandWithEveryItem;
					<>O.<0>__CommandWithEveryItem = val;
					obj = (object)val;
				}
				PickupPickerController.GetOptionsFromPickupState += (hook_GetOptionsFromPickupState)obj;
				object obj2 = <>O.<1>__ServerAuthManager_HandleSetClientAuth;
				if (obj2 == null)
				{
					Manipulator val2 = ServerAuthManager_HandleSetClientAuth;
					<>O.<1>__ServerAuthManager_HandleSetClientAuth = val2;
					obj2 = (object)val2;
				}
				ServerAuthManager.HandleSetClientAuth += (Manipulator)obj2;
				object obj3 = <>O.<2>__Run_GetUserMaster;
				if (obj3 == null)
				{
					hook_GetUserMaster val3 = Run_GetUserMaster;
					<>O.<2>__Run_GetUserMaster = val3;
					obj3 = (object)val3;
				}
				Run.GetUserMaster += (hook_GetUserMaster)obj3;
				object obj4 = <>O.<3>__SteamworksLobbyManager_OnLobbyJoined_bool_string;
				if (obj4 == null)
				{
					hook_OnLobbyJoined_bool_string val4 = SteamworksLobbyManager_OnLobbyJoined_bool_string;
					<>O.<3>__SteamworksLobbyManager_OnLobbyJoined_bool_string = val4;
					obj4 = (object)val4;
				}
				SteamworksLobbyManager.OnLobbyJoined_bool_string += (hook_OnLobbyJoined_bool_string)obj4;
			}
			if (WConfig.cfgLoadOrder.Value)
			{
				TestLoadOrder.Start();
			}
		}

		private static NetworkConnection ServerAuthManager_FindConnectionForSteamID(orig_FindConnectionForSteamID orig, PlatformID steamId)
		{
			throw new NotImplementedException();
		}

		private static void SteamworksLobbyManager_OnLobbyJoined_bool_string(orig_OnLobbyJoined_bool_string orig, SteamworksLobbyManager self, bool success, string tokenReasonFailed)
		{
			if (string.IsNullOrEmpty(tokenReasonFailed))
			{
				success = true;
			}
			orig.Invoke(self, success, tokenReasonFailed);
		}

		public static CharacterMaster Run_GetUserMaster(orig_GetUserMaster orig, Run self, NetworkUserId networkUserId)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (WConfig.cfgTestMultiplayer.Value)
			{
				return null;
			}
			return orig.Invoke(self, networkUserId);
		}

		public static void ServerAuthManager_HandleSetClientAuth(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchStloc(x, 3)
			}))