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.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Captain.Weapon;
using EntityStates.Destructible;
using EntityStates.LunarGolem;
using GrooveSaladSpikestripContent.Content;
using HG;
using HG.Reflection;
using IL.RoR2;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MysticsItems.Items;
using On.RoR2;
using On.RoR2.Artifacts;
using On.RoR2.CharacterAI;
using On.RoR2.PostProcessing;
using On.RoR2.Projectile;
using On.RoR2.UI;
using On.RoR2.UI.LogBook;
using R2API;
using R2API.Networking;
using R2API.Networking.Interfaces;
using R2API.Utils;
using Rewired.ComponentControls.Effects;
using RoR2;
using RoR2.Achievements;
using RoR2.Audio;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.EntitlementManagement;
using RoR2.ExpansionManagement;
using RoR2.Hologram;
using RoR2.Navigation;
using RoR2.Orbs;
using RoR2.PostProcessing;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.UI;
using RoR2.UI.SkinControllers;
using TMPro;
using ThreeEyedGames;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("GrooveSaladSpikestripContent")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("GrooveSaladSpikestripContent")]
[assembly: AssemblyTitle("GrooveSaladSpikestripContent")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
}
namespace GrooveSaladSpikestripContent
{
	public abstract class SpikestripAltSkillsBase<T> : SpikestripContentBase<T> where T : SpikestripAltSkillsBase<T>
	{
		public struct SkillResetInfo
		{
			public int skillSlotIndex;

			public BodyIndex bodyIndex;

			public uint defaultVariantIndex;
		}

		public List<SkillResetInfo> skillResetInfos = new List<SkillResetInfo>();

		public SkillDef SkillDef;

		public override string ConfigSection => "Alternate Skills";

		public override string ConfigName => SkillName;

		public abstract string SkillName { get; }

		public abstract string SkillDescription { get; }

		public abstract string SkillToken { get; }

		public abstract Sprite SkillIcon { get; }

		public abstract GameObject OwnerBodyPrefab { get; }

		public abstract SkillFamily[] SkillFamilies { get; }

		public abstract Type[] EntityStateTypes { get; }

		public virtual UnlockableDef UnlockableDef { get; } = null;


		public override void Init()
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: 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_0186: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			base.Init();
			SkillDef = GetSkillDef();
			SkillDef.skillName = "SPIKESTRIPSKILL_" + SkillToken;
			SkillDef.skillNameToken = "SPIKESTRIPSKILL_" + SkillToken + "_NAME";
			SkillDef.skillDescriptionToken = "SPIKESTRIPSKILL_" + SkillToken + "_DESCRIPTION";
			SkillDef.icon = SkillIcon;
			LanguageAPI.Add(SkillDef.skillNameToken, SkillName);
			LanguageAPI.Add(SkillDef.skillDescriptionToken, SkillDescription);
			SpikestripContentBase.skillDefContent.Add(SkillDef);
			for (int i = 0; i < SkillFamilies.Length; i++)
			{
				SkillFamily val = SkillFamilies[i];
				Variant val2 = default(Variant);
				val2.skillDef = SkillDef;
				val2.unlockableDef = UnlockableDef;
				((Variant)(ref val2)).viewableNode = new Node(SkillDef.skillName, false, (Node)null);
				Variant val3 = val2;
				ArrayUtils.ArrayAppend<Variant>(ref val.variants, ref val3);
			}
			for (int j = 0; j < EntityStateTypes.Length; j++)
			{
				SpikestripContentBase.entityStateTypeContent.Add(EntityStateTypes[j]);
			}
			if ((Object)(object)RequiredExpansionHolder != (Object)null)
			{
				UnlockableCatalog.GenerateUnlockableMetaData += new hook_GenerateUnlockableMetaData(UnlockableCatalog_GenerateUnlockableMetaData);
				PreGameController.onPreGameControllerSetRuleBookGlobal += PreGameController_onPreGameControllerSetRuleBookGlobal;
				NetworkUser.onLoadoutChangedGlobal += NetworkUser_onLoadoutChangedGlobal;
				BodyLoadout.IsSkillVariantLocked += new hook_IsSkillVariantLocked(BodyLoadout_IsSkillVariantLocked);
				Row.FromSkillSlot += new hook_FromSkillSlot(Row_FromSkillSlot);
				BodyCatalog.Init += new hook_Init(BodyCatalog_Init);
			}
		}

		private void UnlockableCatalog_GenerateUnlockableMetaData(orig_GenerateUnlockableMetaData orig, UnlockableDef[] unlockableDefs)
		{
			orig.Invoke(unlockableDefs);
			UnlockableCatalog.TryAddExpansionMapping(UnlockableDef, RequiredExpansionHolder);
		}

		private void NetworkUser_onLoadoutChangedGlobal(NetworkUser networkUser)
		{
			LocalUser val = (Object.op_Implicit((Object)(object)networkUser) ? networkUser.localUser : null);
			if (val == null)
			{
				return;
			}
			RuleBook val2 = (Object.op_Implicit((Object)(object)PreGameController.instance) ? PreGameController.instance.readOnlyRuleBook : (Object.op_Implicit((Object)(object)Run.instance) ? Run.instance.ruleBook : null));
			bool flag = val2 != null && val2.IsChoiceActive(RequiredExpansionHolder.enabledChoice);
			bool flag2 = !Object.op_Implicit((Object)(object)RequiredExpansionHolder.requiredEntitlement) || ((BaseUserEntitlementTracker<LocalUser>)(object)EntitlementManager.localUserEntitlementTracker).UserHasEntitlement(val, RequiredExpansionHolder.requiredEntitlement);
			if (!flag || !flag2)
			{
				UserProfile val3 = ((val != null) ? val.userProfile : null);
				if (val3 != null)
				{
					EnforceExpansionResets(val3);
				}
			}
		}

		private void PreGameController_onPreGameControllerSetRuleBookGlobal(PreGameController preGameController, RuleBook ruleBook)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			LocalUser localUser = ((MPEventSystem)EventSystem.current).localUser;
			bool flag = ruleBook != null && ruleBook.IsChoiceActive(RequiredExpansionHolder.enabledChoice);
			bool flag2 = !Object.op_Implicit((Object)(object)RequiredExpansionHolder.requiredEntitlement) || ((BaseUserEntitlementTracker<LocalUser>)(object)EntitlementManager.localUserEntitlementTracker).UserHasEntitlement(localUser, RequiredExpansionHolder.requiredEntitlement);
			if ((!flag || !flag2) && localUser != null && localUser.userProfile != null)
			{
				EnforceExpansionResets(localUser.userProfile);
			}
		}

		public void EnforceExpansionResets(UserProfile userProfile)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_002b: 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)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			Loadout val = new Loadout();
			userProfile.CopyLoadout(val);
			for (int i = 0; i < skillResetInfos.Count; i++)
			{
				SkillResetInfo skillResetInfo = skillResetInfos[i];
				uint skillVariant = val.bodyLoadoutManager.GetSkillVariant(skillResetInfo.bodyIndex, skillResetInfo.skillSlotIndex);
				SkillFamily skillFamily = BodyCatalog.GetBodyPrefabSkillSlots(skillResetInfo.bodyIndex)[skillResetInfo.skillSlotIndex].skillFamily;
				if (Object.op_Implicit((Object)(object)skillFamily) && (Object)(object)skillFamily.variants[skillVariant].skillDef == (Object)(object)SkillDef)
				{
					val.bodyLoadoutManager.SetSkillVariant(skillResetInfo.bodyIndex, skillResetInfo.skillSlotIndex, skillResetInfo.defaultVariantIndex);
				}
			}
			userProfile.SetLoadout(val);
		}

		private void BodyCatalog_Init(orig_Init orig)
		{
			//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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_006e: 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)
			orig.Invoke();
			BodyIndex val = BodyCatalog.FindBodyIndex(OwnerBodyPrefab);
			if ((int)val == -1)
			{
				return;
			}
			GenericSkill[] components = OwnerBodyPrefab.GetComponents<GenericSkill>();
			for (int i = 0; i < components.Length; i++)
			{
				GenericSkill val2 = components[i];
				for (int j = 0; j < SkillFamilies.Length; j++)
				{
					SkillFamily val3 = SkillFamilies[j];
					if ((Object)(object)val2.skillFamily == (Object)(object)val3)
					{
						skillResetInfos.Add(new SkillResetInfo
						{
							bodyIndex = val,
							skillSlotIndex = i,
							defaultVariantIndex = val3.defaultVariantIndex
						});
					}
				}
			}
		}

		private object Row_FromSkillSlot(orig_FromSkillSlot orig, LoadoutPanelController owner, BodyIndex bodyIndex, int skillSlotIndex, GenericSkill skillSlot)
		{
			//IL_0003: 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)
			//IL_001d: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			object obj = orig.Invoke(owner, bodyIndex, skillSlotIndex, skillSlot);
			SkillFamily skillFamily = skillSlot.skillFamily;
			Row val = (Row)obj;
			if (val != null)
			{
				for (int i = 0; i < skillFamily.variants.Length; i++)
				{
					if ((Object)(object)skillFamily.variants[i].skillDef == (Object)(object)SkillDef)
					{
						HGButton val2 = (HGButton)val.buttons[i];
						if (Object.op_Implicit((Object)(object)val2))
						{
							LockSkillFromExpansion lockSkillFromExpansion = ((Component)val2).gameObject.AddComponent<LockSkillFromExpansion>();
							lockSkillFromExpansion.requiredExpansion = RequiredExpansionHolder;
						}
					}
				}
			}
			return obj;
		}

		private bool BodyLoadout_IsSkillVariantLocked(orig_IsSkillVariantLocked orig, object self, int skillSlotIndex, UserProfile userProfile)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			BodyLoadout val = (BodyLoadout)self;
			SkillFamily skillFamily = val.GetSkillFamily(skillSlotIndex);
			if (Object.op_Implicit((Object)(object)skillFamily))
			{
				uint skillVariant = val.GetSkillVariant(skillSlotIndex);
				if (Object.op_Implicit((Object)(object)SkillDef) && (Object)(object)skillFamily.variants[skillVariant].skillDef == (Object)(object)SkillDef)
				{
					RuleBook val2 = (Object.op_Implicit((Object)(object)PreGameController.instance) ? PreGameController.instance.readOnlyRuleBook : (Object.op_Implicit((Object)(object)Run.instance) ? Run.instance.ruleBook : null));
					bool flag = val2 != null && val2.IsChoiceActive(RequiredExpansionHolder.enabledChoice);
					LocalUser firstLocalUser = LocalUserManager.GetFirstLocalUser();
					bool flag2 = !Object.op_Implicit((Object)(object)RequiredExpansionHolder.requiredEntitlement) || ((BaseUserEntitlementTracker<LocalUser>)(object)EntitlementManager.localUserEntitlementTracker).UserHasEntitlement(firstLocalUser, RequiredExpansionHolder.requiredEntitlement);
					return orig.Invoke(self, skillSlotIndex, userProfile) && flag && flag2;
				}
			}
			return orig.Invoke(self, skillSlotIndex, userProfile);
		}

		public abstract SkillDef GetSkillDef();
	}
	public class LockSkillFromExpansion : MonoBehaviour
	{
		public ExpansionDef requiredExpansion;

		private bool isLocked = false;

		private HGButton hgButton;

		private TooltipProvider tooltipProvider;

		private Image image;

		private bool cachedDisableGamepadClick;

		private bool cachedDisablePointerClick;

		private string cachedHoverToken;

		private Sprite cachedIcon;

		private string cachedOverrideTitleText;

		private string cachedOverrideBodyText;

		private Color cachedTitleColor;

		public void Start()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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)
			hgButton = ((Component)this).GetComponent<HGButton>();
			tooltipProvider = ((Component)this).GetComponent<TooltipProvider>();
			object obj = this;
			obj = (object)((!Object.op_Implicit((Object)(object)hgButton)) ? ((Image)null) : ((Image)((Selectable)hgButton).targetGraphic));
			((LockSkillFromExpansion)obj).image = (Image)obj;
			if (Object.op_Implicit((Object)(object)hgButton))
			{
				cachedDisableGamepadClick = ((MPButton)hgButton).disableGamepadClick;
				cachedDisablePointerClick = ((MPButton)hgButton).disablePointerClick;
				cachedHoverToken = hgButton.hoverToken;
			}
			if (Object.op_Implicit((Object)(object)tooltipProvider))
			{
				cachedOverrideTitleText = tooltipProvider.overrideTitleText;
				cachedOverrideBodyText = tooltipProvider.overrideBodyText;
				cachedTitleColor = tooltipProvider.titleColor;
			}
			if (Object.op_Implicit((Object)(object)image))
			{
				cachedIcon = image.sprite;
			}
		}

		public void Update()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)requiredExpansion))
			{
				RuleBook val = (Object.op_Implicit((Object)(object)PreGameController.instance) ? PreGameController.instance.readOnlyRuleBook : (Object.op_Implicit((Object)(object)Run.instance) ? Run.instance.ruleBook : null));
				bool flag = val != null && val.IsChoiceActive(requiredExpansion.enabledChoice);
				LocalUser localUser = ((MPEventSystem)EventSystem.current).localUser;
				bool flag2 = !Object.op_Implicit((Object)(object)requiredExpansion.requiredEntitlement) || ((BaseUserEntitlementTracker<LocalUser>)(object)EntitlementManager.localUserEntitlementTracker).UserHasEntitlement(localUser, requiredExpansion.requiredEntitlement);
				bool flag3 = flag && flag2;
				if (isLocked == flag3)
				{
					isLocked = !flag3;
					RebuildButton();
				}
			}
		}

		public void RebuildButton()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			string @string = Language.GetString("UNIDENTIFIED");
			string text = GenerateLockedTitleText();
			string stringFormatted = Language.GetStringFormatted("LOGBOOK_HOVER_DESCRIPTION_FORMAT", new object[3]
			{
				@string,
				text,
				ColorUtility.ToHtmlStringRGBA(new Color(0.5f, 0.5f, 0.5f, 0.2f))
			});
			if (Object.op_Implicit((Object)(object)hgButton))
			{
				((MPButton)hgButton).disableGamepadClick = isLocked || cachedDisableGamepadClick;
				((MPButton)hgButton).disablePointerClick = isLocked || cachedDisablePointerClick;
				hgButton.hoverToken = (isLocked ? stringFormatted : cachedHoverToken);
			}
			if (Object.op_Implicit((Object)(object)tooltipProvider))
			{
				tooltipProvider.overrideTitleText = (isLocked ? @string : cachedOverrideTitleText);
				tooltipProvider.overrideBodyText = (isLocked ? text : cachedOverrideBodyText);
				tooltipProvider.titleColor = (isLocked ? Color.gray : cachedTitleColor);
			}
			if (Object.op_Implicit((Object)(object)image))
			{
				image.sprite = (isLocked ? LoadoutPanelController.lockedIcon : cachedIcon);
			}
		}

		public string GenerateLockedTitleText()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)requiredExpansion.requiredEntitlement))
			{
				LocalUser localUser = ((MPEventSystem)EventSystem.current).localUser;
				if (!((BaseUserEntitlementTracker<LocalUser>)(object)EntitlementManager.localUserEntitlementTracker).UserHasEntitlement(localUser, requiredExpansion.requiredEntitlement))
				{
					return Language.GetStringFormatted("EXPANSION_PURCHASED_REQUIRED_FORMAT", new object[1] { Language.GetString(requiredExpansion.requiredEntitlement.nameToken) });
				}
			}
			return Language.GetStringFormatted("EXPANSION_ENABLED_REQUIRED_FORMAT", new object[1] { Language.GetString(requiredExpansion.nameToken) });
		}
	}
	public abstract class SpikestripVoidAltSkillsBase<T> : SpikestripAltSkillsBase<T> where T : SpikestripVoidAltSkillsBase<T>
	{
		public class SpecificVoidEndingAchievement<A> : BaseAchievement where A : SpikestripVoidAltSkillsBase<A>
		{
			public class SpecificCompleteWave50ServerAchievement : BaseServerAchievement
			{
				public override void OnInstall()
				{
					((BaseServerAchievement)this).OnInstall();
					InfiniteTowerRun.onAllEnemiesDefeatedServer += OnAllEnemiesDefeatedServer;
				}

				public override void OnUninstall()
				{
					InfiniteTowerRun.onAllEnemiesDefeatedServer -= OnAllEnemiesDefeatedServer;
					((BaseServerAchievement)this).OnUninstall();
				}

				private void OnAllEnemiesDefeatedServer(InfiniteTowerWaveController waveController)
				{
					Run instance = Run.instance;
					InfiniteTowerRun val = (InfiniteTowerRun)(object)((instance is InfiniteTowerRun) ? instance : null);
					if (Object.op_Implicit((Object)(object)val) && val.waveIndex >= 50)
					{
						((BaseServerAchievement)this).Grant();
					}
				}
			}

			public override BodyIndex LookUpRequiredBodyIndex()
			{
				//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_0018: Unknown result type (might be due to invalid IL or missing references)
				return BodyCatalog.FindBodyIndex(SpikestripContentBase<A>.instance.OwnerBodyPrefab);
			}

			public override void OnBodyRequirementMet()
			{
				((BaseAchievement)this).OnBodyRequirementMet();
				((BaseAchievement)this).SetServerTracked(true);
				Run.onClientGameOverGlobal += OnClientGameOverGlobal;
			}

			public override void OnBodyRequirementBroken()
			{
				Run.onClientGameOverGlobal -= OnClientGameOverGlobal;
				((BaseAchievement)this).SetServerTracked(false);
				((BaseAchievement)this).OnBodyRequirementBroken();
			}

			private void OnClientGameOverGlobal(Run run, RunReport runReport)
			{
				if (Object.op_Implicit((Object)(object)runReport.gameEnding) && (Object)(object)runReport.gameEnding == (Object)(object)GameEndings.VoidEnding)
				{
					((BaseAchievement)this).Grant();
				}
			}
		}

		public static Color voidSkillColor = SpikestripContentBase.ColorRGB(176f, 72f, 214f);

		public UnlockableDef VoidUnlockableDef;

		public AchievementDef VoidAchievementDef;

		public override string ConfigSection => "Alternate Skills";

		public override string ConfigName => SkillName;

		public abstract string PrerequisiteIdentifier { get; }

		public abstract string CharacterName { get; }

		public abstract string AchievementName { get; }

		public virtual string ChildLocatorString { get; }

		public override UnlockableDef UnlockableDef => VoidUnlockableDef;

		public override void Init()
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			VoidUnlockableDef = ScriptableObject.CreateInstance<UnlockableDef>();
			base.Init();
			string text = "Spikestrip" + CharacterName + "DefeatVoid";
			string achievementNameToken = "ACHIEVEMENT_" + text.ToUpper() + "_NAME";
			string achievementDescriptionToken = "ACHIEVEMENT_" + text.ToUpper() + "_DESCRIPTION";
			VoidUnlockableDef.cachedName = "SpikestripSkills." + CharacterName + "." + SkillName;
			VoidUnlockableDef.achievementIcon = null;
			VoidUnlockableDef.nameToken = SkillDef.skillNameToken;
			VoidUnlockableDef.displayModelPrefab = SpikestripContentBase.nullModel;
			VoidUnlockableDef.achievementIcon = SkillIcon;
			VoidUnlockableDef.getHowToUnlockString = () => Language.GetStringFormatted("UNLOCK_VIA_ACHIEVEMENT_FORMAT", new object[2]
			{
				Language.GetString(achievementNameToken),
				Language.GetString(achievementDescriptionToken)
			});
			VoidUnlockableDef.getUnlockedString = () => Language.GetStringFormatted("UNLOCKED_FORMAT", new object[2]
			{
				Language.GetString(achievementNameToken),
				Language.GetString(achievementDescriptionToken)
			});
			SpikestripContentBase.unlockableDefContent.Add(VoidUnlockableDef);
			AchievementDef val = new AchievementDef();
			val.identifier = text;
			val.unlockableRewardIdentifier = VoidUnlockableDef.cachedName;
			val.prerequisiteAchievementIdentifier = PrerequisiteIdentifier;
			val.nameToken = achievementNameToken;
			val.descriptionToken = achievementDescriptionToken;
			val.type = typeof(SpecificVoidEndingAchievement<T>);
			val.serverTrackerType = typeof(SpecificVoidEndingAchievement<T>.SpecificCompleteWave50ServerAchievement);
			val.achievedIcon = SkillIcon;
			VoidAchievementDef = val;
			UnlockableAPI.AddAchievement(VoidAchievementDef);
			LanguageAPI.Add(achievementNameToken, CharacterName + ": " + AchievementName);
			LanguageAPI.Add(achievementDescriptionToken, $"As {CharacterName}, escape the Planetarium or complete wave 50 in Simulacrum.");
			CharacterSelectController.RebuildLocal += new hook_RebuildLocal(CharacterSelectController_RebuildLocal);
			SkillIcon.Update += new hook_Update(SkillIcon_Update);
			Row.AddButton += new hook_AddButton(Row_AddButton);
		}

		private void CharacterSelectController_RebuildLocal(orig_RebuildLocal orig, CharacterSelectController self)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			for (int i = 0; i < self.skillStripAllocator.elements.Count; i++)
			{
				RectTransform val = self.skillStripAllocator.elements[i];
				if (Object.op_Implicit((Object)(object)val))
				{
					HGTextMeshProUGUI component = ((Component)((Transform)val).Find("Inner/SkillDescriptionPanel/SkillName")).GetComponent<HGTextMeshProUGUI>();
					HGTextMeshProUGUI component2 = ((Component)((Transform)val).Find("Inner/SkillDescriptionPanel/SkillDescription")).GetComponent<HGTextMeshProUGUI>();
					if (((TMP_Text)component).text == Language.GetString(SkillDef.skillNameToken) && ((TMP_Text)component2).text == Language.GetString(SkillDef.skillDescriptionToken))
					{
						((Graphic)component).color = voidSkillColor;
					}
				}
			}
		}

		private void SkillIcon_Update(orig_Update orig, SkillIcon self)
		{
			//IL_0041: 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)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			if (Object.op_Implicit((Object)(object)self.targetSkill) && (Object)(object)self.targetSkill.skillDef == (Object)(object)SkillDef && Object.op_Implicit((Object)(object)self.tooltipProvider))
			{
				float num = default(float);
				float num2 = default(float);
				float num3 = default(float);
				Color.RGBToHSV(voidSkillColor, ref num, ref num2, ref num3);
				num3 = ((num3 > 0.7f) ? 0.7f : num3);
				Color titleColor = Color.HSVToRGB(num, num2, num3);
				self.tooltipProvider.titleColor = titleColor;
			}
		}

		private void Row_AddButton(orig_AddButton orig, object self, LoadoutPanelController owner, Sprite icon, string titleToken, string bodyToken, Color tooltipColor, UnityAction callback, string unlockableName, Node viewableNode, bool isWIP)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (titleToken == SkillDef.skillNameToken)
			{
				tooltipColor = voidSkillColor;
			}
			orig.Invoke(self, owner, icon, titleToken, bodyToken, tooltipColor, callback, unlockableName, viewableNode, isWIP);
		}
	}
	public abstract class SpikestripArtifactBase<T> : SpikestripContentBase<T> where T : SpikestripArtifactBase<T>
	{
		public ArtifactDef artifactDef;

		public override string ConfigSection => "Artifacts";

		public override string ConfigName => GetFullName();

		public abstract string Name { get; }

		public abstract string Description { get; }

		public abstract Sprite EnabledIcon { get; }

		public abstract Sprite DisabledIcon { get; }

		public virtual string OverrideFullName { get; } = null;


		public override void Init()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			base.Init();
			RunArtifactManager.onArtifactEnabledGlobal += new ArtifactStateChangeDelegate(RunArtifactManager_onArtifactEnabledGlobal);
			RunArtifactManager.onArtifactDisabledGlobal += new ArtifactStateChangeDelegate(RunArtifactManager_onArtifactDisabledGlobal);
			artifactDef = ScriptableObject.CreateInstance<ArtifactDef>();
			artifactDef.cachedName = Name;
			artifactDef.nameToken = "SPIKESTRIPARTIFACT_" + Name.ToUpper() + "_NAME";
			artifactDef.descriptionToken = "SPIKESTRIPARTIFACT_" + Name.ToUpper() + "_DESCRIPTION";
			artifactDef.smallIconSelectedSprite = EnabledIcon;
			artifactDef.smallIconDeselectedSprite = DisabledIcon;
			artifactDef.requiredExpansion = RequiredExpansionHolder;
			SpikestripContentBase.artifactDefContent.Add(artifactDef);
			LanguageAPI.Add(artifactDef.nameToken, GetFullName());
			LanguageAPI.Add(artifactDef.descriptionToken, Description);
		}

		private void RunArtifactManager_onArtifactEnabledGlobal([NotNull] RunArtifactManager runArtifactManager, [NotNull] ArtifactDef theArtifactDef)
		{
			if ((Object)(object)theArtifactDef == (Object)(object)artifactDef)
			{
				SetHooks();
			}
		}

		private void RunArtifactManager_onArtifactDisabledGlobal([NotNull] RunArtifactManager runArtifactManager, [NotNull] ArtifactDef theArtifactDef)
		{
			if ((Object)(object)theArtifactDef == (Object)(object)artifactDef)
			{
				UnsetHooks();
			}
		}

		public abstract void SetHooks();

		public abstract void UnsetHooks();

		public bool ArtifactActive()
		{
			return Object.op_Implicit((Object)(object)RunArtifactManager.instance) && RunArtifactManager.instance.IsArtifactEnabled(artifactDef);
		}

		public string GetFullName()
		{
			if (!string.IsNullOrEmpty(OverrideFullName))
			{
				return OverrideFullName;
			}
			return "Artifact of " + Name;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.groovesalad.GrooveSaladSpikestripContent", "GrooveSaladSpikestripContent", "1.0.1")]
	[R2APISubmoduleDependency(new string[] { "LanguageAPI", "PrefabAPI", "ItemAPI", "NetworkingAPI", "RecalculateStatsAPI", "DeployableAPI", "OrbAPI", "UnlockableAPI", "DotAPI", "CommandHelper" })]
	public class Base : BaseUnityPlugin
	{
		public static ManualLogSource groovyLogger;

		public static AssetBundle GroovyAssetBundle;

		public static ConfigFile SpikestripContentConfig;

		public static ExpansionDef SpikestripContentExpansionDef;

		public static GameObject SpikestripContentRunBehaviourPrefab;

		public static List<Type> processedContentTypes = new List<Type>();

		public static List<Type> enabledContentTypes = new List<Type>();

		public static List<SpikestripContentBase> waitingDependentContent = new List<SpikestripContentBase>();

		private static readonly char[] invalidConfigChars = new char[8] { '=', '\n', '\t', '\\', '"', '\'', '[', ']' };

		public void CreateExpansionDef()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			ExpansionDef val = LegacyResourcesAPI.Load<ExpansionDef>("ExpansionDefs/DLC1");
			SpikestripContentExpansionDef = ScriptableObject.CreateInstance<ExpansionDef>();
			GameObject val2 = Addressables.LoadAssetAsync<GameObject>((object)"12bf89dabb4bb914382a0e31546446cc").WaitForCompletion();
			SpikestripContentRunBehaviourPrefab = PrefabAPI.InstantiateClone(val2, "SpikestripContentRunBehaviour", true);
			Object.DestroyImmediate((Object)(object)SpikestripContentRunBehaviourPrefab.GetComponent<GlobalDeathRewards>());
			ExpansionRequirementComponent component = SpikestripContentRunBehaviourPrefab.GetComponent<ExpansionRequirementComponent>();
			component.requiredExpansion = SpikestripContentExpansionDef;
			SpikestripContentRunBehaviourPrefab.AddComponent<SpikestripVisuals>();
			SpikestripContentRunBehaviourPrefab.AddComponent<SpikestripBuffBehaviours>();
			SpikestripContentRunBehaviourPrefab.AddComponent<SpikestripEliteRamps>();
			SpikestripContentRunBehaviourPrefab.AddComponent<SpikestripDamageColors>();
			SpikestripContentRunBehaviourPrefab.AddComponent<SpikestripExpansionDirectorHelper>();
			PrefabAPI.RegisterNetworkPrefab(SpikestripContentRunBehaviourPrefab);
			SpikestripContentBase.networkedObjectContent.Add(SpikestripContentRunBehaviourPrefab);
			((Object)SpikestripContentExpansionDef).name = "SPIKESTRIPCONTENT_EXPANSION";
			SpikestripContentExpansionDef.nameToken = "SPIKESTRIPCONTENT_EXPANSION_NAME";
			SpikestripContentExpansionDef.descriptionToken = "SPIKESTRIPCONTENT_EXPANSION_DESCRIPTION";
			SpikestripContentExpansionDef.iconSprite = GroovyAssetBundle.LoadAsset<Sprite>("texSpikestripExpansionIcon.png");
			SpikestripContentExpansionDef.disabledIconSprite = val.disabledIconSprite;
			SpikestripContentExpansionDef.requiredEntitlement = val.requiredEntitlement;
			SpikestripContentExpansionDef.runBehaviorPrefab = SpikestripContentRunBehaviourPrefab;
			SpikestripContentBase.expansionDefContent.Add(SpikestripContentExpansionDef);
			LanguageAPI.Add(SpikestripContentExpansionDef.nameToken, "Spikestrip 2.0");
			LanguageAPI.Add(SpikestripContentExpansionDef.descriptionToken, "Adds content from the 'Spikestrip 2.0' mod to the game.");
		}

		public void Awake()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			groovyLogger = ((BaseUnityPlugin)this).Logger;
			SpikestripContentConfig = new ConfigFile(Paths.ConfigPath + "\\Spikestrip 2.0.cfg", true);
			GroovyAssetBundle = AssetBundle.LoadFromFile(Assembly.GetExecutingAssembly().Location.Replace("GrooveSaladSpikestripContent.dll", "groovesaladspikestripcontentassets"));
			CreateExpansionDef();
			string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			DirectoryInfo directoryInfo = new DirectoryInfo(directoryName);
			FileInfo[] files = directoryInfo.GetFiles("*.dll");
			FileInfo[] array = files;
			foreach (FileInfo fileInfo in array)
			{
				Assembly assembly = Assembly.LoadFrom(fileInfo.FullName);
				groovyLogger.LogInfo((object)("Scanning Assembly: " + assembly.GetName()));
				IEnumerable<Type> enumerable = from type in assembly.GetTypes()
					where !type.IsAbstract && type.IsSubclassOf(typeof(SpikestripContentBase))
					select type;
				foreach (Type item in enumerable)
				{
					SpikestripContentBase spikestripContentBase = (SpikestripContentBase)Activator.CreateInstance(item);
					if (!processedContentTypes.Contains(spikestripContentBase.GetType()))
					{
						ProcessInitialContent(spikestripContentBase, enumerable);
					}
				}
			}
			while (waitingDependentContent.Count > 0)
			{
				int count = waitingDependentContent.Count;
				for (int num = waitingDependentContent.Count - 1; num >= 0; num--)
				{
					ProcessDependentContent(waitingDependentContent[num]);
				}
				if (count == waitingDependentContent.Count)
				{
					groovyLogger.LogError((object)"Infinite recursion while loading detected!");
					break;
				}
			}
			new ContentPacks().Initialize();
		}

		public void ProcessInitialContent(SpikestripContentBase initialContent, IEnumerable<Type> allInitialContentTypes)
		{
			if (initialContent.IsEnabled)
			{
				if (!(initialContent.DependsOn == null) && allInitialContentTypes.Contains(initialContent.DependsOn))
				{
					waitingDependentContent.Add(initialContent);
					return;
				}
				if (SpikestripContentConfig.Bind<bool>(SafeForConfig(initialContent.ConfigSection), "Enable " + SafeForConfig(initialContent.ConfigName), true, "Enable/Disable : " + SafeForConfig(initialContent.ConfigName)).Value)
				{
					initialContent.Init();
				}
			}
			processedContentTypes.Add(initialContent.GetType());
		}

		public void ProcessDependentContent(SpikestripContentBase waitingDependentcontent)
		{
			if (processedContentTypes.Contains(waitingDependentcontent.DependsOn))
			{
				if (enabledContentTypes.Contains(waitingDependentcontent.DependsOn))
				{
					waitingDependentcontent.Init();
				}
				waitingDependentContent.Remove(waitingDependentcontent);
				processedContentTypes.Add(waitingDependentcontent.GetType());
			}
		}

		public string SafeForConfig(string original)
		{
			return new string(original.Where(IsCharacterSafe).ToArray());
		}

		public static bool IsCharacterSafe(char character)
		{
			return !invalidConfigChars.Contains(character);
		}
	}
	public class SpikestripBuffBehaviours : SpikestripContentRunBehaviour
	{
		public struct BuffBehaviourPair
		{
			public Type buffBehaviour;

			public BuffDef buffDef;

			public bool serverOnly;
		}

		public class SyncUpdateBuffBehaviour : INetMessage, ISerializableObject
		{
			private int Index;

			private int Count;

			private NetworkInstanceId GameObjectID;

			public SyncUpdateBuffBehaviour()
			{
			}

			public SyncUpdateBuffBehaviour(int index, int count, NetworkInstanceId gameObjectID)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				Index = index;
				Count = count;
				GameObjectID = gameObjectID;
			}

			public void Serialize(NetworkWriter writer)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				writer.Write(Index);
				writer.Write(Count);
				writer.Write(GameObjectID);
			}

			public void Deserialize(NetworkReader reader)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Index = reader.ReadInt32();
				Count = reader.ReadInt32();
				GameObjectID = reader.ReadNetworkId();
			}

			public void OnReceived()
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				if (NetworkServer.active)
				{
					return;
				}
				GameObject val = Util.FindNetworkObject(GameObjectID);
				if (Object.op_Implicit((Object)(object)val))
				{
					CharacterBody component = val.GetComponent<CharacterBody>();
					if (Object.op_Implicit((Object)(object)component))
					{
						UpdateBuffBehaviour(component, buffBehaviours[Index], Count);
					}
				}
			}
		}

		public static List<BuffBehaviourPair> buffBehaviours = new List<BuffBehaviourPair>();

		public static bool hookActive;

		[SystemInitializer(new Type[] { })]
		public static void Init()
		{
			NetworkingAPI.RegisterMessageType<SyncUpdateBuffBehaviour>();
		}

		private void OnEnable()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (SetHook(ref hookActive, buffBehaviours.Count != 0))
			{
				CharacterBody.SetBuffCount += new hook_SetBuffCount(CharacterBody_SetBuffCount);
			}
		}

		private void OnDisable()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (UnsetHook(ref hookActive))
			{
				CharacterBody.SetBuffCount -= new hook_SetBuffCount(CharacterBody_SetBuffCount);
			}
		}

		public static void RegisterBuffBehaviour(BuffDef buffDef, Type behaviour, bool serverOnly = true)
		{
			BuffBehaviourPair item = default(BuffBehaviourPair);
			item.buffDef = buffDef;
			item.buffBehaviour = behaviour;
			item.serverOnly = serverOnly;
			buffBehaviours.Add(item);
		}

		private static void CharacterBody_SetBuffCount(orig_SetBuffCount orig, CharacterBody self, BuffIndex buffType, int newCount)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self, buffType, newCount);
			if (!NetworkServer.active || !Object.op_Implicit((Object)(object)self))
			{
				return;
			}
			for (int i = 0; i < buffBehaviours.Count; i++)
			{
				int buffCount = self.GetBuffCount(buffBehaviours[i].buffDef);
				UpdateBuffBehaviour(self, buffBehaviours[i], buffCount);
				if (!buffBehaviours[i].serverOnly)
				{
					NetworkIdentity component = ((Component)self).GetComponent<NetworkIdentity>();
					if (Object.op_Implicit((Object)(object)component))
					{
						NetMessageExtensions.Send((INetMessage)(object)new SyncUpdateBuffBehaviour(i, buffCount, component.netId), (NetworkDestination)1);
					}
				}
			}
		}

		public static void UpdateBuffBehaviour(CharacterBody characterBody, BuffBehaviourPair behaviourPair, int stack)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			ItemBehavior val = (ItemBehavior)((Component)characterBody).gameObject.GetComponent(behaviourPair.buffBehaviour);
			if (stack > 0)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = (ItemBehavior)((Component)characterBody).gameObject.AddComponent(behaviourPair.buffBehaviour);
					val.body = characterBody;
					((Behaviour)val).enabled = true;
				}
				val.stack = stack;
			}
			else if (Object.op_Implicit((Object)(object)val))
			{
				Object.Destroy((Object)(object)val);
			}
		}
	}
	public class ContentPacks : IContentPackProvider
	{
		internal ContentPack contentPack = new ContentPack();

		public string identifier => "com.groovesalad.GrooveSaladSpikestripContent";

		public void Initialize()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			ContentManager.collectContentPackProviders += new CollectContentPackProvidersDelegate(ContentManager_collectContentPackProviders);
		}

		private void ContentManager_collectContentPackProviders(AddContentPackProviderDelegate addContentPackProvider)
		{
			addContentPackProvider.Invoke((IContentPackProvider)(object)this);
		}

		public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
		{
			contentPack.identifier = identifier;
			contentPack.networkedObjectPrefabs.Add(SpikestripContentBase.networkedObjectContent.ToArray());
			contentPack.itemDefs.Add(SpikestripContentBase.itemContent.ToArray());
			contentPack.entityStateTypes.Add(SpikestripContentBase.entityStateTypeContent.ToArray());
			contentPack.masterPrefabs.Add(SpikestripContentBase.masterPrefabContent.ToArray());
			contentPack.bodyPrefabs.Add(SpikestripContentBase.bodyPrefabContent.ToArray());
			contentPack.skillDefs.Add(SpikestripContentBase.skillDefContent.ToArray());
			contentPack.artifactDefs.Add(SpikestripContentBase.artifactDefContent.ToArray());
			contentPack.buffDefs.Add(SpikestripContentBase.buffDefContent.ToArray());
			contentPack.effectDefs.Add(SpikestripContentBase.effectDefContent.ToArray());
			contentPack.eliteDefs.Add(SpikestripContentBase.eliteDefContent.ToArray());
			contentPack.entityStateConfigurations.Add(SpikestripContentBase.entityStateConfigurationContent.ToArray());
			contentPack.equipmentDefs.Add(SpikestripContentBase.equipmentDefContent.ToArray());
			contentPack.gameEndingDefs.Add(SpikestripContentBase.gameEndingDefContent.ToArray());
			contentPack.gameModePrefabs.Add(SpikestripContentBase.gameModePrefabContent.ToArray());
			contentPack.musicTrackDefs.Add(SpikestripContentBase.musicTrackDefContent.ToArray());
			contentPack.networkSoundEventDefs.Add(SpikestripContentBase.networkSoundEventDefContent.ToArray());
			contentPack.projectilePrefabs.Add(SpikestripContentBase.projectilePrefabContent.ToArray());
			contentPack.sceneDefs.Add(SpikestripContentBase.sceneDefContent.ToArray());
			contentPack.skillFamilies.Add(SpikestripContentBase.skillFamilyContent.ToArray());
			contentPack.surfaceDefs.Add(SpikestripContentBase.surfaceDefContent.ToArray());
			contentPack.survivorDefs.Add(SpikestripContentBase.survivorDefContent.ToArray());
			contentPack.unlockableDefs.Add(SpikestripContentBase.unlockableDefContent.ToArray());
			contentPack.expansionDefs.Add(SpikestripContentBase.expansionDefContent.ToArray());
			contentPack.entitlementDefs.Add(SpikestripContentBase.entitlementDefContent.ToArray());
			contentPack.itemRelationshipProviders.Add(SpikestripContentBase.itemRelationshipProviderContent.ToArray());
			contentPack.itemRelationshipTypes.Add(SpikestripContentBase.itemRelationshipTypeContent.ToArray());
			contentPack.miscPickupDefs.Add(SpikestripContentBase.miscPickupDefContent.ToArray());
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
		{
			ContentPack.Copy(contentPack, args.output);
			args.ReportProgress(1f);
			yield break;
		}

		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			args.ReportProgress(1f);
			yield break;
		}
	}
	public class SpikestripDamageColors : SpikestripContentRunBehaviour
	{
		public static List<DamageColorIndex> customColorIndices = new List<DamageColorIndex>();

		public static bool hookActive;

		private void OnEnable()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (SetHook(ref hookActive, customColorIndices.Count != 0))
			{
				DamageColor.FindColor += new hook_FindColor(DamageColor_FindColor);
			}
		}

		private void OnDisable()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (UnsetHook(ref hookActive))
			{
				DamageColor.FindColor -= new hook_FindColor(DamageColor_FindColor);
			}
		}

		private static Color DamageColor_FindColor(orig_FindColor orig, DamageColorIndex colorIndex)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (colorIndex >= customColorIndices[0] && colorIndex <= customColorIndices[customColorIndices.Count - 1])
			{
				return DamageColor.colors[colorIndex];
			}
			return orig.Invoke(colorIndex);
		}

		public static DamageColorIndex RegisterDamageColor(Color color)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected I4, but got Unknown
			//IL_003d: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			ArrayUtils.ArrayAppend<Color>(ref DamageColor.colors, ref color);
			DamageColorIndex val = (DamageColorIndex)(byte)((byte)DamageColor.colors.Length - 1);
			Base.groovyLogger.LogInfo((object)("Registered new damage color with index: " + (int)val));
			customColorIndices.Add(val);
			return val;
		}
	}
	public class SpikestripExpansionDirectorHelper : SpikestripContentRunBehaviour
	{
		public struct ResetDccs
		{
			public DirectorCardCategorySelection targetDccs;

			public DirectorCard directorCardToRemove;

			public string categoryName;
		}

		public struct AllStagesCardRequest
		{
			public DirectorCard directorCard;

			public string categoryName;
		}

		public struct FamilyEventAddition
		{
			public DirectorCard directorCard;

			public DirectorCardCategorySelection eventDccs;

			public string categoryName;
		}

		public static bool hookActive;

		public static Dictionary<string, Dictionary<string, List<DirectorCard>>> interactableRequestDictionary = new Dictionary<string, Dictionary<string, List<DirectorCard>>>();

		public static Dictionary<string, Dictionary<string, List<DirectorCard>>> monsterRequestDictionary = new Dictionary<string, Dictionary<string, List<DirectorCard>>>();

		public static List<AllStagesCardRequest> allStagesInteractableCards = new List<AllStagesCardRequest>();

		public static List<AllStagesCardRequest> allStagesMonsterCards = new List<AllStagesCardRequest>();

		public static List<FamilyEventAddition> familyEventAdditions = new List<FamilyEventAddition>();

		public List<ResetDccs> resetDccsOnDisabled = new List<ResetDccs>();

		[SystemInitializer(new Type[] { typeof(SceneCatalog) })]
		public unsafe static void Init()
		{
			//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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			for (int i = 0; i < SceneCatalog.sceneDefCount; i++)
			{
				SceneDef val = (SceneDef)Unsafe.Read<object>((void*)SceneCatalog.allSceneDefs[i]);
				if ((int)val.sceneType != 0 && (int)val.sceneType != 3)
				{
					for (int j = 0; j < allStagesInteractableCards.Count; j++)
					{
						AllStagesCardRequest allStagesCardRequest = allStagesInteractableCards[j];
						RegisterSpikestripInteractable(allStagesCardRequest.directorCard, allStagesCardRequest.categoryName, val.baseSceneName);
					}
					for (int k = 0; k < allStagesMonsterCards.Count; k++)
					{
						AllStagesCardRequest allStagesCardRequest2 = allStagesMonsterCards[k];
						RegisterSpikestripMonster(allStagesCardRequest2.directorCard, allStagesCardRequest2.categoryName, val.baseSceneName);
					}
				}
			}
		}

		private void OnEnable()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			if (SetHook(ref hookActive, interactableRequestDictionary.Count != 0 || monsterRequestDictionary.Count != 0))
			{
				ClassicStageInfo.RebuildCards += new hook_RebuildCards(ClassicStageInfo_RebuildCards);
			}
			UpdateFamilyEventAdditions(active: true);
		}

		private void OnDisable()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (UnsetHook(ref hookActive))
			{
				ClassicStageInfo.RebuildCards -= new hook_RebuildCards(ClassicStageInfo_RebuildCards);
			}
			UpdateFamilyEventAdditions(active: false);
			if (resetDccsOnDisabled.Count != 0)
			{
				for (int num = resetDccsOnDisabled.Count - 1; num >= 0; num--)
				{
					HandleResetDccs(resetDccsOnDisabled[num]);
					resetDccsOnDisabled.RemoveAt(num);
				}
			}
		}

		private void HandleResetDccs(ResetDccs resetDccs)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!FindDccsCategoryFromName(resetDccs.targetDccs, resetDccs.categoryName, out var foundCategoryIndex))
			{
				return;
			}
			Category val = resetDccs.targetDccs.categories[foundCategoryIndex];
			for (int i = 0; i < val.cards.Length; i++)
			{
				if (val.cards[i] == resetDccs.directorCardToRemove)
				{
					ArrayUtils.ArrayRemoveAtAndResize<DirectorCard>(ref val.cards, i, 1);
					break;
				}
			}
		}

		private void ClassicStageInfo_RebuildCards(orig_RebuildCards orig, ClassicStageInfo self)
		{
			SceneDef mostRecentSceneDef = SceneCatalog.mostRecentSceneDef;
			if (Object.op_Implicit((Object)(object)mostRecentSceneDef))
			{
				if (interactableRequestDictionary.TryGetValue(mostRecentSceneDef.baseSceneName, out var value))
				{
					if (Object.op_Implicit((Object)(object)self.interactableDccsPool))
					{
						HandleDccsPool(self.interactableDccsPool, value);
					}
					if (Object.op_Implicit((Object)(object)self.interactableCategories))
					{
						HandleDccs(self.interactableCategories, value);
					}
				}
				if (monsterRequestDictionary.TryGetValue(mostRecentSceneDef.baseSceneName, out var value2))
				{
					if (Object.op_Implicit((Object)(object)self.monsterDccsPool))
					{
						HandleDccsPool(self.monsterDccsPool, value2, new string[1] { "Standard" });
					}
					if (Object.op_Implicit((Object)(object)self.monsterCategories))
					{
						HandleDccs(self.monsterCategories, value2);
					}
				}
			}
			orig.Invoke(self);
		}

		private void HandleDccsPool(DccsPool dccsPool, Dictionary<string, List<DirectorCard>> categoryToCard, string[] specificNames = null)
		{
			for (int i = 0; i < dccsPool.poolCategories.Length; i++)
			{
				Category val = dccsPool.poolCategories[i];
				if (specificNames == null || specificNames.Contains(val.name))
				{
					HandleDccsPoolEntries(val.alwaysIncluded, categoryToCard);
					PoolEntry[] includedIfConditionsMet = (PoolEntry[])(object)val.includedIfConditionsMet;
					HandleDccsPoolEntries(includedIfConditionsMet, categoryToCard);
					HandleDccsPoolEntries(val.includedIfNoConditionsMet, categoryToCard);
				}
			}
		}

		private void HandleDccsPoolEntries(PoolEntry[] entries, Dictionary<string, List<DirectorCard>> categoryToCard)
		{
			foreach (PoolEntry val in entries)
			{
				HandleDccs(val.dccs, categoryToCard);
			}
		}

		private void HandleDccs(DirectorCardCategorySelection dccs, Dictionary<string, List<DirectorCard>> categoryToCard)
		{
			for (int i = 0; i < dccs.categories.Length; i++)
			{
				ref Category reference = ref dccs.categories[i];
				if (!categoryToCard.TryGetValue(reference.name, out var value))
				{
					continue;
				}
				ref DirectorCard[] cards = ref reference.cards;
				for (int j = 0; j < value.Count; j++)
				{
					DirectorCard val = value[j];
					if (!cards.Contains(val))
					{
						ArrayUtils.ArrayAppend<DirectorCard>(ref cards, ref val);
						resetDccsOnDisabled.Add(new ResetDccs
						{
							targetDccs = dccs,
							directorCardToRemove = val,
							categoryName = reference.name
						});
					}
				}
			}
		}

		public static void RegisterSpikestripInteractable(DirectorCard directorCard, string categoryName, string stageName = null)
		{
			if (string.IsNullOrEmpty(stageName))
			{
				allStagesInteractableCards.Add(new AllStagesCardRequest
				{
					directorCard = directorCard,
					categoryName = categoryName
				});
				return;
			}
			if (!interactableRequestDictionary.TryGetValue(stageName, out var value))
			{
				value = new Dictionary<string, List<DirectorCard>>();
				interactableRequestDictionary.Add(stageName, value);
			}
			if (!value.TryGetValue(categoryName, out var value2))
			{
				value2 = new List<DirectorCard>();
				value.Add(categoryName, value2);
			}
			value2.Add(directorCard);
		}

		public static void RegisterSpikestripMonster(DirectorCard directorCard, string categoryName, string stageName)
		{
			if (string.IsNullOrEmpty(stageName))
			{
				allStagesMonsterCards.Add(new AllStagesCardRequest
				{
					directorCard = directorCard,
					categoryName = categoryName
				});
				return;
			}
			if (!monsterRequestDictionary.TryGetValue(stageName, out var value))
			{
				value = new Dictionary<string, List<DirectorCard>>();
				monsterRequestDictionary.Add(stageName, value);
			}
			if (!value.TryGetValue(categoryName, out var value2))
			{
				value2 = new List<DirectorCard>();
				value.Add(categoryName, value2);
			}
			value2.Add(directorCard);
		}

		public void UpdateFamilyEventAdditions(bool active)
		{
			if (familyEventAdditions.Count == 0)
			{
				return;
			}
			for (int i = 0; i < familyEventAdditions.Count; i++)
			{
				FamilyEventAddition familyEventAddition = familyEventAdditions[i];
				DirectorCardCategorySelection eventDccs = familyEventAddition.eventDccs;
				if (FindDccsCategoryFromName(eventDccs, familyEventAddition.categoryName, out var foundCategoryIndex))
				{
					ref Category reference = ref eventDccs.categories[foundCategoryIndex];
					if (active)
					{
						ArrayUtils.ArrayAppend<DirectorCard>(ref reference.cards, ref familyEventAddition.directorCard);
					}
					else
					{
						SpikestripContentBase.RemoveFromArray(ref reference.cards, in familyEventAddition.directorCard);
					}
				}
			}
		}

		public static void RegisterSpikestripFamilyAddition(DirectorCard directorCard, DirectorCardCategorySelection eventDccs, string categoryName)
		{
			familyEventAdditions.Add(new FamilyEventAddition
			{
				directorCard = directorCard,
				eventDccs = eventDccs,
				categoryName = categoryName
			});
		}

		public static bool FindDccsCategoryFromName(DirectorCardCategorySelection dccs, string idealName, out int foundCategoryIndex)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: 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)
			for (int i = 0; i < dccs.categories.Length; i++)
			{
				Category val = dccs.categories[i];
				if (val.name == idealName)
				{
					foundCategoryIndex = i;
					return true;
				}
			}
			foundCategoryIndex = -1;
			return false;
		}
	}
	public static class CommonInteractableCategories
	{
		public const string Chests = "Chests";

		public const string Barrels = "Barrels";

		public const string Shrines = "Shrines";

		public const string Drones = "Drones";

		public const string Misc = "Misc";

		public const string Rare = "Rare";

		public const string Duplicator = "Duplicator";
	}
	public static class CommonMonsterCategories
	{
		public const string Champions = "Champions";

		public const string Minibosses = "Minibosses";

		public const string BasicMonsters = "Basic Monsters";

		public const string Special = "Special";
	}
	public static class CommonStages
	{
		public const string AphelianSanctuary = "ancientloft";

		public const string VoidFields = "arena";

		public const string ArtifactReliquary = "artifactworld";

		public const string DistantRoost = "blackbeach";

		public const string DistantRoostAlt = "blackbeach2";

		public const string AbyssalDepths = "dampcavesimple";

		public const string WetlandAspect = "foggyswamp";

		public const string RallypointDelta = "frozenwall";

		public const string GoldenCoast = "goldshores";

		public const string TitanicPlains = "golemplains";

		public const string TitanicPlainsAlt = "golemplains2";

		public const string AbandonedAqueduct = "goolake";

		public const string Commencement = "moon2";

		public const string SunderedGrove = "rootjungle";

		public const string SirensCall = "shipgraveyard";

		public const string SkyMeadow = "skymeadow";

		public const string SiphonedForest = "snowyforest";

		public const string SulfurPools = "sulfurpools";

		public const string VoidLocus = "voidstage";

		public const string ScorchedAcres = "wispgraveyard";

		public static string Simulacrum(string baseStageName)
		{
			return "it" + baseStageName;
		}
	}
	public abstract class SpikestripEliteBase<T> : SpikestripEquipBase<T> where T : SpikestripEliteBase<T>
	{
		public enum TierType
		{
			TierOne = 1,
			TierTwo = 3,
			Honor = 2,
			Lunar = 4
		}

		public struct EliteTierDefinition
		{
			public TierType tierType;

			public float healthBoostCoefficient;

			public float damageBoostCoefficient;
		}

		public struct EliteDefTierPair
		{
			public EliteDef eliteDef;

			public TierType tierType;
		}

		public struct ItemDisplayParent
		{
			public Object parentAsset;

			public GameObject prefab;
		}

		public static EliteTierDefinition tierOneEliteDefault = new EliteTierDefinition
		{
			tierType = TierType.TierOne,
			healthBoostCoefficient = 4f,
			damageBoostCoefficient = 2f
		};

		public static EliteTierDefinition tierTwoEliteDefault = new EliteTierDefinition
		{
			tierType = TierType.TierTwo,
			healthBoostCoefficient = 18f,
			damageBoostCoefficient = 6f
		};

		public static EliteTierDefinition honorEliteDefault = new EliteTierDefinition
		{
			tierType = TierType.Honor,
			healthBoostCoefficient = 2.5f,
			damageBoostCoefficient = 1.5f
		};

		public BuffDef AffixBuff;

		public EliteDef MainEliteDef;

		public List<ItemDisplayParent> itemDisplayParents = new List<ItemDisplayParent>();

		private List<EliteDefTierPair> eliteDefTierPairsInternal = new List<EliteDefTierPair>();

		public abstract string EliteName { get; }

		public abstract string AffixDescriptionMainWord { get; }

		public abstract Color EliteColor { get; }

		public abstract Sprite AffixBuffSprite { get; }

		public abstract EliteTierDefinition MainEliteTierDefinition { get; }

		public abstract Texture2D EliteRampTexture { get; }

		public virtual Type AffixBuffBehaviour { get; } = null;


		public virtual bool ServerOnlyAffixBuffBehaviour { get; } = true;


		public virtual bool HookOnHitEnemy { get; } = true;


		public virtual EliteTierDefinition[] ExtraEliteTierDefitions { get; } = Array.Empty<EliteTierDefinition>();


		public override string ConfigName => EliteName;

		public override string ConfigSection => "Elites";

		public override bool CanActivate => false;

		public override bool EnigmaCompatible => false;

		public override BuffDef PassiveBuff => AffixBuff;

		public override bool CanDrop => false;

		public override string EquipmentPickup => "Become an aspect of " + AffixDescriptionMainWord + ".";

		public override string EquipmentDescription => "Become an aspect of " + AffixDescriptionMainWord + ".";

		public override string EquipmentLore => null;

		public override string EquipmentToken => "AFFIX" + EliteName.ToUpper();

		public override bool CanBeRandomlyTriggered => false;

		public override float DropOnDeathChance => 0.00025f;

		public override void Init()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			MainEliteDef = ScriptableObject.CreateInstance<EliteDef>();
			AffixBuff = ScriptableObject.CreateInstance<BuffDef>();
			base.Init();
			MainEliteDef.color = Color32.op_Implicit(EliteColor);
			MainEliteDef.eliteEquipmentDef = EquipmentDef;
			MainEliteDef.modifierToken = "ELITE_MODIFIER_" + EliteName.ToUpper();
			MainEliteDef.shaderEliteRampIndex = 0;
			MainEliteDef.healthBoostCoefficient = MainEliteTierDefinition.healthBoostCoefficient;
			MainEliteDef.damageBoostCoefficient = MainEliteTierDefinition.damageBoostCoefficient;
			SpikestripContentBase.eliteDefContent.Add(MainEliteDef);
			LanguageAPI.Add(MainEliteDef.modifierToken, EliteName + " {0}");
			eliteDefTierPairsInternal.Add(new EliteDefTierPair
			{
				eliteDef = MainEliteDef,
				tierType = MainEliteTierDefinition.tierType
			});
			if (ExtraEliteTierDefitions.Length != 0)
			{
				for (int i = 0; i < ExtraEliteTierDefitions.Length; i++)
				{
					EliteTierDefinition eliteTierDefinition = ExtraEliteTierDefitions[i];
					EliteDef val = ScriptableObject.CreateInstance<EliteDef>();
					val.color = MainEliteDef.color;
					val.eliteEquipmentDef = MainEliteDef.eliteEquipmentDef;
					val.modifierToken = MainEliteDef.modifierToken;
					val.shaderEliteRampIndex = MainEliteDef.shaderEliteRampIndex;
					val.healthBoostCoefficient = eliteTierDefinition.healthBoostCoefficient;
					val.damageBoostCoefficient = eliteTierDefinition.damageBoostCoefficient;
					SpikestripContentBase.eliteDefContent.Add(val);
					eliteDefTierPairsInternal.Add(new EliteDefTierPair
					{
						eliteDef = val,
						tierType = eliteTierDefinition.tierType
					});
				}
			}
			AffixBuff.buffColor = EliteColor;
			AffixBuff.canStack = false;
			AffixBuff.eliteDef = MainEliteDef;
			AffixBuff.iconSprite = AffixBuffSprite;
			AffixBuff.isDebuff = false;
			SpikestripContentBase.buffDefContent.Add(AffixBuff);
			if (AffixBuffBehaviour != null)
			{
				SpikestripBuffBehaviours.RegisterBuffBehaviour(AffixBuff, AffixBuffBehaviour, ServerOnlyAffixBuffBehaviour);
			}
			SpikestripEliteRamps.SpikestripEliteRamp item = default(SpikestripEliteRamps.SpikestripEliteRamp);
			item.eliteDef = MainEliteDef;
			item.rampTexture = (Texture)(object)EliteRampTexture;
			SpikestripEliteRamps.eliteRamps.Add(item);
			if (itemDisplayParents.Count != 0)
			{
				BodyCatalog.SetBodyPrefabs += new hook_SetBodyPrefabs(CopyItemDisplayRules);
			}
			if (HookOnHitEnemy)
			{
				GlobalEventManager.OnHitEnemy += new hook_OnHitEnemy(OnHitEffect);
			}
			CombatDirector.Init += new hook_Init(AddToEliteTiers);
		}

		private void AddToEliteTiers(orig_Init orig)
		{
			orig.Invoke();
			for (int i = 0; i < eliteDefTierPairsInternal.Count; i++)
			{
				EliteDefTierPair eliteDefTierPair = eliteDefTierPairsInternal[i];
				ArrayUtils.ArrayAppend<EliteDef>(ref CombatDirector.eliteTiers[(int)eliteDefTierPair.tierType].eliteTypes, ref eliteDefTierPair.eliteDef);
			}
		}

		private void OnHitEffect(orig_OnHitEnemy orig, GlobalEventManager self, DamageInfo damageInfo, GameObject victim)
		{
			orig.Invoke(self, damageInfo, victim);
			if (damageInfo.procCoefficient != 0f && !damageInfo.rejected && NetworkServer.active && Object.op_Implicit((Object)(object)damageInfo.attacker) && damageInfo.procCoefficient > 0f)
			{
				OnHitEnemyServer(damageInfo, victim);
			}
		}

		public virtual void OnHitEnemyServer(DamageInfo damageInfo, GameObject victim)
		{
		}

		private void CopyItemDisplayRules(orig_SetBodyPrefabs orig, GameObject[] newBodyPrefabs)
		{
			foreach (GameObject val in newBodyPrefabs)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					CopyIDRFrom(val);
				}
			}
			orig.Invoke(newBodyPrefabs);
		}

		public void CopyIDRFrom(GameObject bodyPrefab)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: 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_00b8: 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_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_011e: 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_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: 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_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: 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_015d: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			ModelLocator component = bodyPrefab.GetComponent<ModelLocator>();
			if (!Object.op_Implicit((Object)(object)component))
			{
				return;
			}
			Transform modelTransform = component.modelTransform;
			if (!Object.op_Implicit((Object)(object)modelTransform))
			{
				return;
			}
			CharacterModel component2 = ((Component)modelTransform).GetComponent<CharacterModel>();
			if (!Object.op_Implicit((Object)(object)component2))
			{
				return;
			}
			ItemDisplayRuleSet itemDisplayRuleSet = component2.itemDisplayRuleSet;
			if (!Object.op_Implicit((Object)(object)itemDisplayRuleSet))
			{
				return;
			}
			List<ItemDisplayParent> list = new List<ItemDisplayParent>(itemDisplayParents);
			List<ItemDisplayRule> list2 = new List<ItemDisplayRule>();
			for (int i = 0; i < itemDisplayRuleSet.keyAssetRuleGroups.Length; i++)
			{
				if (list.Count <= 0)
				{
					break;
				}
				KeyAssetRuleGroup val = itemDisplayRuleSet.keyAssetRuleGroups[i];
				for (int num = list.Count - 1; num >= 0; num--)
				{
					if (Object.op_Implicit(val.keyAsset) && val.keyAsset == list[num].parentAsset)
					{
						for (int j = 0; j < val.displayRuleGroup.rules.Length; j++)
						{
							ItemDisplayRule val2 = val.displayRuleGroup.rules[j];
							list2.Add(new ItemDisplayRule
							{
								followerPrefab = list[num].prefab,
								localPos = val2.localPos,
								localAngles = val2.localAngles,
								localScale = val2.localScale,
								childName = val2.childName,
								limbMask = val2.limbMask,
								ruleType = val2.ruleType
							});
						}
						list.RemoveAt(num);
					}
				}
			}
			if (list2.Count != 0)
			{
				DisplayRuleGroup empty = DisplayRuleGroup.empty;
				empty.rules = list2.ToArray();
				ref KeyAssetRuleGroup[] keyAssetRuleGroups = ref itemDisplayRuleSet.keyAssetRuleGroups;
				KeyAssetRuleGroup val3 = new KeyAssetRuleGroup
				{
					keyAsset = (Object)(object)EquipmentDef,
					displayRuleGroup = empty
				};
				ArrayUtils.ArrayAppend<KeyAssetRuleGroup>(ref keyAssetRuleGroups, ref val3);
			}
		}

		public GameObject CreateAffixModel(Color color)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = PrefabAPI.InstantiateClone(LegacyResourcesAPI.Load<GameObject>("prefabs/pickupmodels/PickupAffixRed"), "PickupAffix" + EliteName, false);
			Material val2 = Object.Instantiate<Material>(((Renderer)val.GetComponentInChildren<MeshRenderer>()).material);
			val2.color = color;
			Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>();
			foreach (Renderer val3 in componentsInChildren)
			{
				val3.material = val2;
			}
			return val;
		}

		public void RegisterDisplayParent(Object parent, GameObject prefab = null)
		{
			ItemDisplayParent item = default(ItemDisplayParent);
			item.parentAsset = parent;
			item.prefab = (Object.op_Implicit((Object)(object)prefab) ? prefab : EquipmentDisplayModel);
			itemDisplayParents.Add(item);
		}

		public ItemDisplayRule[] AffixIDR(string childName, Vector3 position, Vector3 angles, Vector3 scale)
		{
			//IL_000b: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			return (ItemDisplayRule[])(object)new ItemDisplayRule[1]
			{
				new ItemDisplayRule
				{
					ruleType = (ItemDisplayRuleType)0,
					followerPrefab = EquipmentDisplayModel,
					childName = childName,
					localPos = position,
					localAngles = angles,
					localScale = scale
				}
			};
		}
	}
	public class SpikestripEliteRamps : SpikestripContentRunBehaviour
	{
		public struct SpikestripEliteRamp
		{
			public Texture rampTexture;

			public EliteDef eliteDef;
		}

		public static List<SpikestripEliteRamp> eliteRamps = new List<SpikestripEliteRamp>();

		public static bool hookActive;

		public static int EliteRampPropertyID => Shader.PropertyToID("_EliteRamp");

		private void OnEnable()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (SetHook(ref hookActive, eliteRamps.Count != 0))
			{
				CharacterModel.UpdateMaterials += new Manipulator(CopyMSU);
			}
		}

		private void OnDisable()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (UnsetHook(ref hookActive))
			{
				CharacterModel.UpdateMaterials -= new Manipulator(CopyMSU);
			}
		}

		private static void CopyMSU(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdarg(x, 0),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld<CharacterModel>(x, "propertyStorage"),
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(CommonShaderProperties), "_EliteIndex")
			});
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<MaterialPropertyBlock>(x, "SetFloat")
			});
			val.Emit(OpCodes.Ldarg, 0);
			val.EmitDelegate<Action<CharacterModel>>((Action<CharacterModel>)delegate(CharacterModel model)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				for (int i = 0; i < eliteRamps.Count; i++)
				{
					SpikestripEliteRamp spikestripEliteRamp = eliteRamps[i];
					if (model.myEliteIndex == spikestripEliteRamp.eliteDef.eliteIndex)
					{
						model.propertyStorage.SetTexture(EliteRampPropertyID, spikestripEliteRamp.rampTexture);
						break;
					}
					if ((Object)(object)model.propertyStorage.GetTexture(EliteRampPropertyID) == (Object)(object)spikestripEliteRamp.rampTexture)
					{
						model.propertyStorage.Clear();
					}
				}
			});
		}
	}
	public abstract class SpikestripMonsterBase<T> : SpikestripContentBase<T> where T : SpikestripMonsterBase<T>
	{
		public CharacterSpawnCard CharacterSpawnCard;

		public DirectorCard DirectorCard;

		public GameObject MasterPrefab;

		public GameObject BodyPrefab;

		public override string ConfigSection => "Monsters";

		public override string ConfigName => MonsterName;

		public abstract string MonsterName { get; }

		public virtual bool UsesDirector { get; } = true;


		public override void Init()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			base.Init();
			SetHooks();
			AssignPrefab();
			if (Object.op_Implicit((Object)(object)BodyPrefab))
			{
				SpikestripContentBase.bodyPrefabContent.Add(BodyPrefab);
				PrefabAPI.RegisterNetworkPrefab(BodyPrefab);
			}
			if (Object.op_Implicit((Object)(object)MasterPrefab))
			{
				SpikestripContentBase.masterPrefabContent.Add(MasterPrefab);
				PrefabAPI.RegisterNetworkPrefab(MasterPrefab);
			}
			if (UsesDirector)
			{
				CharacterSpawnCard = ScriptableObject.CreateInstance<CharacterSpawnCard>();
				ModifySpawnCard();
				DirectorCard = new DirectorCard();
				ModifyDirectorCardAndAddInteractable();
			}
		}

		public abstract void AssignPrefab();

		public abstract void SetHooks();

		public virtual void ModifySpawnCard()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			((Object)CharacterSpawnCard).name = "csc" + MonsterName.Replace(" ", "");
			((SpawnCard)CharacterSpawnCard).prefab = MasterPrefab;
			((SpawnCard)CharacterSpawnCard).sendOverNetwork = true;
			((SpawnCard)CharacterSpawnCard).nodeGraphType = (GraphType)0;
			((SpawnCard)CharacterSpawnCard).requiredFlags = (NodeFlags)0;
			((SpawnCard)CharacterSpawnCard).forbiddenFlags = (NodeFlags)4;
		}

		public virtual void ModifyDirectorCardAndAddInteractable()
		{
			DirectorCard.spawnCard = (SpawnCard)(object)CharacterSpawnCard;
		}

		public void AddMonster(string categoryName, string stageName = null)
		{
			SpikestripExpansionDirectorHelper.RegisterSpikestripMonster(DirectorCard, categoryName, stageName);
		}

		public void AddMonsterToFamily(DirectorCardCategorySelection dccs, string categoryName)
		{
			SpikestripExpansionDirectorHelper.RegisterSpikestripFamilyAddition(DirectorCard, dccs, categoryName);
		}
	}
	public static class CommonDisplayReferences
	{
		public static EquipmentDef AffixRed = LegacyResourcesAPI.Load<EquipmentDef>("EquipmentDefs/AffixRed");

		public static GameObject AffixRedHornDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("880352d2f519466409abd39061d75b79");

		public static EquipmentDef AffixWhite = LegacyResourcesAPI.Load<EquipmentDef>("EquipmentDefs/AffixWhite");

		public static GameObject AffixWhiteCrownDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("767a76f115c24384498eb6bed7decc4d");

		public static EquipmentDef AffixBlue = LegacyResourcesAPI.Load<EquipmentDef>("EquipmentDefs/AffixBlue");

		public static GameObject AffixBlueHornDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("01c99be16781ea64cb7c24f1ff1354d4");

		public static EquipmentDef AffixPoison = LegacyResourcesAPI.Load<EquipmentDef>("EquipmentDefs/AffixPoison");

		public static GameObject AffixPoisonCrownDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("5071e940404ac11438977d61b4f37e5c");

		public static EquipmentDef AffixHaunted = LegacyResourcesAPI.Load<EquipmentDef>("EquipmentDefs/AffixHaunted");

		public static GameObject AffixHauntedCrownDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("f75c662c5bc0d744d8919219eeba482d");

		public static EquipmentDef AffixEarth = SpikestripContentBase.AdressablesLoad<EquipmentDef>("463f8f6917dd8af40860b023a520f051");

		public static GameObject AffixEarthAntlersDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("f76a390c2ffbf9645862f81533eafc69");

		public static EquipmentDef AffixVoid = SpikestripContentBase.AdressablesLoad<EquipmentDef>("118960de11f213c45806f7f0d2aef4d6");

		public static GameObject AffixVoidDisplay = SpikestripContentBase.AdressablesLoad<GameObject>("a5888055b2e8dfe479af511631631c0a");
	}
	public abstract class SpikestripEquipBase<T> : SpikestripContentBase<T> where T : SpikestripEquipBase<T>
	{
		public class EquipmentTargetBase : ItemBehavior
		{
			public enum TargetOption
			{
				Enemy,
				Ally
			}

			public EquipmentSlot equipmentSlot;

			public BullseyeSearch targetFinder = new BullseyeSearch();

			public virtual float MaxDistance { get; } = 0f;


			public virtual float MaxAngleFilter { get; } = 10f;


			public virtual SortMode SortMode { get; } = (SortMode)2;


			public virtual TargetOption TargetType { get; } = TargetOption.Enemy;


			public virtual GameObject GetTargetIndicatorPrefab(UserTargetInfo info)
			{
				return LegacyResourcesAPI.Load<GameObject>("Prefabs/LightningIndicator");
			}

			public void Awake()
			{
				OnAwake();
			}

			public virtual void OnAwake()
			{
			}

			public void OnDestroy()
			{
				OnOnDestroy();
			}

			public virtual void OnOnDestroy()
			{
			}

			public void Update()
			{
				OnUpdate();
			}

			public virtual void OnUpdate()
			{
			}

			public void ConfigureTargetFinderBase()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: 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_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				targetFinder.teamMaskFilter = TeamMask.allButNeutral;
				((TeamMask)(ref targetFinder.teamMaskFilter)).RemoveTeam(equipmentSlot.teamComponent.teamIndex);
				targetFinder.sortMode = SortMode;
				targetFinder.filterByLoS = true;
				float num = default(float);
				Ray val = CameraRigController.ModifyAimRayIfApplicable(equipmentSlot.GetAimRay(), ((Component)this).gameObject, ref num);
				targetFinder.searchOrigin = ((Ray)(ref val)).origin;
				targetFinder.searchDirection = ((Ray)(ref val)).direction;
				targetFinder.maxAngleFilter = MaxAngleFilter;
				targetFinder.maxDistanceFilter = MaxDistance;
				targetFinder.viewer = equipmentSlot.characterBody;
			}

			public void ConfigureTargetFinderForEnemies()
			{
				//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_0023: Unknown result type (might be due to invalid IL or missing references)
				ConfigureTargetFinderBase();
				targetFinder.teamMaskFilter = TeamMask.GetUnprotectedTeams(equipmentSlot.teamComponent.teamIndex);
				targetFinder.RefreshCandidates();
				targetFinder.FilterOutGameObject(((Component)this).gameObject);
			}

			public void ConfigureTargetFinderForFriendlies()
			{
				//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_002e: Unknown result type (might be due to invalid IL or missing references)
				ConfigureTargetFinderBase();
				targetFinder.teamMaskFilter = TeamMask.none;
				((TeamMask)(ref targetFinder.teamMaskFilter)).AddTeam(equipmentSlot.teamComponent.teamIndex);
				targetFinder.RefreshCandidates();
				targetFinder.FilterOutGameObject(((Component)this).gameObject);
			}
		}

		public class EquipmentSingleTargetBehaviour : EquipmentTargetBase
		{
			public Indicator targetIndicator;

			public UserTargetInfo currentTarget;

			public override void OnAwake()
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				base.OnAwake();
				targetIndicator = new Indicator(((Component)this).gameObject, (GameObject)null);
				targetIndicator.active = false;
			}

			public override void OnUpdate()
			{
				base.OnUpdate();
				if (Object.op_Implicit((Object)(object)equipmentSlot))
				{
					UpdateTargets();
				}
			}

			public override void OnOnDestroy()
			{
				base.OnOnDestroy();
				targetIndicator.active = false;
			}

			public void UpdateTargets()
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				if (equipmentSlot.stock > 0)
				{
					switch (TargetType)
					{
					case TargetOption.Enemy:
						ConfigureTargetFinderForEnemies();
						break;
					case TargetOption.Ally:
						ConfigureTargetFinderForFriendlies();
						break;
					}
					currentTarget = new UserTargetInfo(targetFinder.GetResults().FirstOrDefault());
				}
				else
				{
					InvalidateCurrentTarget();
				}
				bool flag = Object.op_Implicit((Object)(object)currentTarget.transformToIndicateAt);
				if (flag)
				{
					targetIndicator.visualizerPrefab = GetTargetIndicatorPrefab(currentTarget);
				}
				targetIndicator.active = flag;
				targetIndicator.targetTransform = (flag ? currentTarget.transformToIndicateAt : null);
			}

			public void InvalidateCurrentTarget()
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				currentTarget = default(UserTargetInfo);
			}
		}

		public class EquipmentMultiTargetBehaviour : EquipmentTargetBase
		{
			public List<Indicator> indicators = new List<Indicator>();

			public List<UserTargetInfo> currentTargets = new List<UserTargetInfo>();

			public float updateStopwatch;

			public virtual float UpdateInterval { get; } = 0.05f;


			public override void OnAwake()
			{
				base.OnAwake();
			}

			public override void OnUpdate()
			{
				base.OnUpdate();
				if (Object.op_Implicit((Object)(object)equipmentSlot))
				{
					updateStopwatch += Time.fixedDeltaTime;
					if (updateStopwatch >= UpdateInterval)
					{
						updateStopwatch -= UpdateInterval;
						UpdateTargets();
					}
				}
			}

			public override void OnOnDestroy()
			{
				base.OnOnDestroy();
				for (int num = indicators.Count - 1; num >= 0; num--)
				{
					indicators[num].active = false;
				}
			}

			public Indicator NewIndicator()
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Expected O, but got Unknown
				Indicator val = new Indicator(((Component)this).gameObject, (GameObject)null);
				val.active = false;
				indicators.Add(val);
				return val;
			}

			public void UpdateTargets()
			{
				//IL_0079: 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_00b9: Unknown result type (might be due to invalid IL or missing references)
				InvalidateCurrentTargets();
				if (equipmentSlot.stock > 0)
				{
					switch (TargetType)
					{
					case TargetOption.Enemy:
						ConfigureTargetFinderForEnemies();
						break;
					case TargetOption.Ally:
						ConfigureTargetFinderForFriendlies();
						break;
					}
					List<HurtBox> list = targetFinder.GetResults().Reverse().ToList();
					UserTargetInfo val = default(UserTargetInfo);
					for (int i = 0; i < list.Count; i++)
					{
						((UserTargetInfo)(ref val))..ctor(list[i]);
						currentTargets.Add(val);
						Indicator val2 = ((i < indicators.Count) ? indicators[i] : NewIndicator());
						val2.visualizerPrefab = GetTargetIndicatorPrefab(val);
						val2.targetTransform = val.transformToIndicateAt;
						val2.active = true;
					}
				}
				for (int num = indicators.Count - 1; num >= currentTargets.Count; num--)
				{
					indicators[num].active = false;
					indicators.RemoveAt(num);
				}
			}

			public void InvalidateCurrentTargets()
			{
				for (int num = currentTargets.Count - 1; num >= 0; num--)
				{
					currentTargets.Clear();
				}
			}
		}

		public EquipmentDef EquipmentDef;

		public GameObject EquipmentPickupModel;

		public GameObject EquipmentDisplayModel;

		public ItemDisplayRuleDict idrs = new ItemDisplayRuleDict(Array.Empty<ItemDisplayRule>());

		public override string ConfigName => EquipmentName;

		public override string ConfigSection => "Equipment";

		public abstract string EquipmentName { get; }

		public abstract string EquipmentToken { get; }

		public abstract string EquipmentPickup { get; }

		public abstract string EquipmentDescription { get; }

		public abstract string EquipmentLore { get; }

		public abstract Sprite EquipmentIcon { get; }

		public virtual bool AppearsInSinglePlayer { get; } = true;


		public virtual bool AppearsInMultiPlayer { get; } = true;


		public virtual bool CanDrop { get; } = true;


		public virtual float Cooldown { get; } = 60f;


		public virtual bool EnigmaCompatible { get; } = true;


		public virtual bool CanBeRandomlyTriggered { get; } = true;


		public virtual bool IsBoss { get; } = false;


		public virtual bool IsLunar { get; } = false;


		public virtual BuffDef PassiveBuff { get; } = null;


		public virtual bool CanActivate { get; } = true;


		public virtual float DropOnDeathChance { get; } = 0f;


		public virtual Type EquipmentBehaviour { get; } = null;


		public virtual bool ServerOnlyEquipmentBehaviour { get; } = false;


		public abstract void PopulateItemDisplayRules(ItemDisplayRuleDict itemDisplayRuleDict);

		public abstract void AssignEquipmentValues();

		public virtual bool OnActivationServer(EquipmentSlot equipmentSlot)
		{
			return false;
		}

		public override void Init()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_01e9: 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_0048: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			base.Init();
			if (CanActivate)
			{
				EquipmentSlot.PerformEquipmentAction += new hook_PerformEquipmentAction(ActivationEffect);
			}
			if (EquipmentBehaviour != null)
			{
				CharacterBody.OnInventoryChanged += new hook_OnInventoryChanged(UpdateEquipmentBehaviour);
			}
			AssignEquipmentValues();
			PopulateItemDisplayRules(idrs);
			EquipmentDef = ScriptableObject.CreateInstance<EquipmentDef>();
			((Object)EquipmentDef).name = "EQUIPMENT_" + EquipmentToken;
			EquipmentDef.nameToken = "EQUIPMENT_" + EquipmentToken + "_NAME";
			EquipmentDef.pickupToken = "EQUIPMENT_" + EquipmentToken + "_PICKUP";
			EquipmentDef.descriptionToken = "EQUIPMENT_" + EquipmentToken + "_DESCRIPTION";
			EquipmentDef.loreToken = "EQUIPMENT_" + EquipmentToken + "_LORE";
			EquipmentDef.pickupModelPrefab = EquipmentPickupModel;
			EquipmentDef.pickupIconSprite = EquipmentIcon;
			EquipmentDef.appearsInSinglePlayer = AppearsInSinglePlayer;
			EquipmentDef.appearsInMultiPlayer = AppearsInMultiPlayer;
			EquipmentDef.canDrop = CanDrop;
			EquipmentDef.cooldown = Cooldown;
			EquipmentDef.enigmaCompatible = EnigmaCompatible;
			EquipmentDef.passiveBuffDef = PassiveBuff;
			EquipmentDef.isBoss = IsBoss;
			EquipmentDef.isLunar = IsLunar;
			EquipmentDef.canBeRandomlyTriggered = CanBeRandomlyTriggered;
			EquipmentDef.dropOnDeathChance = DropOnDeathChance;
			EquipmentDef.requiredExpansion = RequiredExpansionHolder;
			EquipmentDef.colorIndex = (ColorIndex)5;
			if (IsBoss)
			{
				EquipmentDef.colorIndex = (ColorIndex)13;
			}
			if (IsLunar)
			{
				EquipmentDef.colorIndex = (ColorIndex)4;
			}
			ItemAPI.Add(new CustomEquipment(EquipmentDef, idrs));
			LanguageAPI.Add("EQUIPMENT_" + EquipmentToken + "_NAME", EquipmentName);
			LanguageAPI.Add("EQUIPMENT_" + EquipmentToken + "_PICKUP", EquipmentPickup);
			LanguageAPI.Add("EQUIPMENT_" + EquipmentToken + "_DESCRIPTION", EquipmentDescription);
			if (!string.IsNullOrEmpty(EquipmentLore))
			{
				LanguageAPI.Add("EQUIPMENT_" + EquipmentToken + "_LORE", EquipmentLore);
			}
		}

		private bool ActivationEffect(orig_PerformEquipmentAction orig, EquipmentSlot self, EquipmentDef equipmentDef)
		{
			if (NetworkServer.active && (Object)(object)equipmentDef == (Object)(object)EquipmentDef)
			{
				return OnActivationServer(self);
			}
			return orig.Invoke(self, equipmentDef);
		}

		private void UpdateEquipmentBehaviour(orig_OnInventoryChanged orig, CharacterBody self)
		{
			orig.Invoke(self);
			if (NetworkServer.active || !ServerOnlyEquipmentBehaviour)
			{
				AddEquipBehaviour(self);
			}
		}

		public void AddEquipBehaviour(CharacterBody characterBody)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: 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
			bool flag = (Object)(object)characterBody.inventory.GetEquipment((uint)characterBody.inventory.activeEquipmentSlot).equipmentDef == (Object)(object)EquipmentDef;
			ItemBehavior val = (ItemBehavior)((Component)characterBody).gameObject.GetComponent(EquipmentBehaviour);
			if (flag)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					val = (ItemBehavior)((Component)characterBody).gameObject.AddComponent(EquipmentBehaviour);
					if (val is EquipmentTargetBase)
					{
						(val as EquipmentTargetBase).equipmentSlot = (Object.op_Implicit((Object)(object)((Component)characterBody).GetComponent<EquipmentSlot>()) ? ((Component)characterBody).GetComponent<EquipmentSlot>() : null);
					}
					val.body = characterBody;
					((Behaviour)val).enabled = true;
				}
			}
			else if (Object.op_Implicit((Object)(object)val))
			{
				Object.Destroy((Object)(object)val);
			}
		}
	}
	public abstract class SpikestripGasolineBase<T> : SpikestripItemBase<T> where T : SpikestripGasolineBase<T>
	{
		public static GameObject igniteExplosionVFX = LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/ImpactEffects/IgniteExplosionVFX");

		private static readonly SphereSearch gasolineSphereSearch = new SphereSearch();

		private static readonly List<HurtBox> gasolineHurtBoxBuffer = new List<HurtBox>();

		public GameObject GasolineEffectPrefab;

		public virtual float RadiusBase { get; } = 12f;


		public virtual float RadiusStack { get; } = 4f;


		public virtual float ExplosionDamageBase { get; } = 1.5f;


		public virtual float ExplosionDamageStack { get; } = 0f;


		public virtual float ProcChanceBase { get; } = 100f;


		public virtual float ProcChanceStack { get; } = 0f;


		public virtual DamageType DamageType { get; } = (DamageType)0;


		public virtual float ProcCoefficient { get; } = 0f;


		public virtual FalloffModel FalloffModel { get; } = (FalloffModel)0;


		public virtual bool InvertTeamFilter { get; } = false;


		public override string ItemToken => "IGNITEONKILL";

		public override Type DependsOn => typeof(Arson);

		public abstract void AssignEffectPrefab();

		public virtual void OnProcServer(HurtBox hurtBox, Vector3 procOrigin, int stack)
		{
		}

		public override void PopulateItemDisplayRules(ItemDisplayRuleDict itemDisplayRuleDict)
		{
		}

		public bool ShouldProc(int stack, CharacterMaster master)
		{
			float num = SpikestripContentBase.StackScaling(ProcChanceBase, ProcChanceStack, stack);
			if (num >= 100f)
			{
				return true;
			}
			if (num <= 0f)
			{
				return false;
			}
			return Util.CheckRoll(num, master);
		}

		public override void Init()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			base.Init();
			AssignEffectPrefab();
			Arson.gasolineItemDefs.Add(ItemDef);
			GlobalEventManager.onCharacterDeathGlobal += ProcItem;
			LogBookController.CanSelectItemEntry += new hook_CanSelectItemEntry(LogBookController_CanSelectItemEntry);
		}

		private bool LogBookController_CanSelectItemEntry(orig_CanSelectItemEntry orig, ItemDef itemDef, Dictionary<ExpansionDef, bool> expansionAvailability)
		{
			return !((Object)(object)itemDef == (Object)(object)ItemDef) && orig.Invoke(itemDef, expansionAvailability);
		}

		private void ProcItem(DamageReport damageReport)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			CharacterBody attackerBody = damageReport.attackerBody;
			CharacterBody victimBody = damageReport.victimBody;
			CharacterMaster attackerMaster = damageReport.attackerMaster;
			TeamIndex attackerTeamIndex = damageReport.attackerTeamIndex;
			if (!Object.op_Implicit((Object)(object)attackerBody) || !Object.op_Implicit((Object)(object)victim