Decompiled source of EnemiesReturns v0.7.18

plugins/Risky_Sleeps-EnemiesReturns/EnemiesReturns.dll

Decompiled 2 days ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AdvancedPrediction.Prediction;
using AncientScepter;
using Assets.RoR2.Scripts.Platform;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EliteReworks2.Elites.Malachite;
using EnemiesReturns.Achievements;
using EnemiesReturns.Behaviors;
using EnemiesReturns.Behaviors.JitterBonesStuff;
using EnemiesReturns.Behaviors.Judgement.MithrixWeaponDrop;
using EnemiesReturns.Behaviors.Judgement.Newt;
using EnemiesReturns.Behaviors.Judgement.WaveInteractable;
using EnemiesReturns.Components;
using EnemiesReturns.Components.BodyComponents;
using EnemiesReturns.Components.BodyComponents.CharacterMotor;
using EnemiesReturns.Components.BodyComponents.NetworkedEntityStateMachine;
using EnemiesReturns.Components.BodyComponents.Skills;
using EnemiesReturns.Components.GeneralComponents;
using EnemiesReturns.Components.MasterComponents;
using EnemiesReturns.Components.ModelComponents;
using EnemiesReturns.Components.ModelComponents.Hitboxes;
using EnemiesReturns.Components.ModelComponents.Hurtboxes;
using EnemiesReturns.Components.ModelComponents.Skins;
using EnemiesReturns.Configuration;
using EnemiesReturns.Configuration.Judgement;
using EnemiesReturns.Configuration.LynxTribe;
using EnemiesReturns.EditorHelpers;
using EnemiesReturns.Enemies.ArcherBug;
using EnemiesReturns.Enemies.Colossus;
using EnemiesReturns.Enemies.Ifrit;
using EnemiesReturns.Enemies.Ifrit.Pillar;
using EnemiesReturns.Enemies.Judgement;
using EnemiesReturns.Enemies.Judgement.Arraign;
using EnemiesReturns.Enemies.LynxTribe;
using EnemiesReturns.Enemies.LynxTribe.Archer;
using EnemiesReturns.Enemies.LynxTribe.Hunter;
using EnemiesReturns.Enemies.LynxTribe.Scout;
using EnemiesReturns.Enemies.LynxTribe.Shaman;
using EnemiesReturns.Enemies.LynxTribe.Storm;
using EnemiesReturns.Enemies.LynxTribe.Totem;
using EnemiesReturns.Enemies.MechanicalSpider;
using EnemiesReturns.Enemies.MechanicalSpider.Drone;
using EnemiesReturns.Enemies.MechanicalSpider.Enemy;
using EnemiesReturns.Enemies.MechanicalSpider.Turret;
using EnemiesReturns.Enemies.SandCrab;
using EnemiesReturns.Enemies.Spitter;
using EnemiesReturns.Enemies.Swift;
using EnemiesReturns.Equipment.MithrixHammer;
using EnemiesReturns.Equipment.VoidlingWeapon;
using EnemiesReturns.Items.ColossalKnurl;
using EnemiesReturns.Items.LunarFlower;
using EnemiesReturns.Items.LynxFetish;
using EnemiesReturns.Items.PartyHat;
using EnemiesReturns.Items.SpawnPillarOnChampionKill;
using EnemiesReturns.Junk.ModdedEntityStates.Colossus.HeadLaser;
using EnemiesReturns.Junk.ModdedEntityStates.Ifrit;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Hunter;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Shaman;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Shaman.Teleport;
using EnemiesReturns.Junk.ModdedEntityStates.LynxTribe.Totem;
using EnemiesReturns.Junk.ModdedEntityStates.Spitter;
using EnemiesReturns.ModCompats;
using EnemiesReturns.ModdedEntityStates.ArcherBugs;
using EnemiesReturns.ModdedEntityStates.Colossus;
using EnemiesReturns.ModdedEntityStates.Colossus.Death;
using EnemiesReturns.ModdedEntityStates.Colossus.HeadLaserBarrage;
using EnemiesReturns.ModdedEntityStates.Colossus.RockClap;
using EnemiesReturns.ModdedEntityStates.Colossus.Stomp;
using EnemiesReturns.ModdedEntityStates.Engi;
using EnemiesReturns.ModdedEntityStates.Ifrit;
using EnemiesReturns.ModdedEntityStates.Ifrit.FlameCharge;
using EnemiesReturns.ModdedEntityStates.Ifrit.Hellzone;
using EnemiesReturns.ModdedEntityStates.Ifrit.Pillar;
using EnemiesReturns.ModdedEntityStates.Ifrit.Pillar.Enemy;
using EnemiesReturns.ModdedEntityStates.Ifrit.Pillar.Player;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.BaseSkyLeap;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Beam;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase1;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase1.SkyLeap;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase1.ThreeHitCombo;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase2;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase2.LeapingDash;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Phase2.ThreeHitCombo;
using EnemiesReturns.ModdedEntityStates.Judgement.Arraign.Slide;
using EnemiesReturns.ModdedEntityStates.Judgement.Mission;
using EnemiesReturns.ModdedEntityStates.Judgement.MithrixHammer;
using EnemiesReturns.ModdedEntityStates.Judgement.SkyLaser;
using EnemiesReturns.ModdedEntityStates.Judgement.VoidlingWeapon;
using EnemiesReturns.ModdedEntityStates.LynxTribe;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Archer;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Hunter;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Hunter.Lunge;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Scout;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Shaman;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Storm;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Totem;
using EnemiesReturns.ModdedEntityStates.LynxTribe.Totem.Burrow;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.Dash;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.Death;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.DoubleShot;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.DoubleShot.Drone;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.DoubleShot.Enemy;
using EnemiesReturns.ModdedEntityStates.MechanicalSpider.DoubleShot.Turret;
using EnemiesReturns.ModdedEntityStates.SandCrab;
using EnemiesReturns.ModdedEntityStates.SandCrab.Bubbles;
using EnemiesReturns.ModdedEntityStates.SandCrab.Snip;
using EnemiesReturns.ModdedEntityStates.Spitter;
using EnemiesReturns.ModdedEntityStates.Swift;
using EnemiesReturns.ModdedEntityStates.Swift.Dive;
using EnemiesReturns.PrefabSetupComponents.BodyComponents;
using EnemiesReturns.PrefabSetupComponents.MasterComponents;
using EnemiesReturns.PrefabSetupComponents.ModelComponents;
using EnemiesReturns.Projectiles;
using EnemiesReturns.Reflection;
using EnemiesReturns.Skills.Engi.MechanicalSpiderTurret;
using EnemiesReturns.zJunk.ModdedEntityStates.Judgement.Arraign;
using EntityStates;
using EntityStates.AI.Walker;
using EntityStates.BrotherMonster;
using EntityStates.Commando.CommandoWeapon;
using EntityStates.Engi.EngiWeapon;
using EntityStates.FlyingVermin.Mode;
using EntityStates.GameOver;
using EntityStates.MeridianEvent;
using EntityStates.Missions.BrotherEncounter;
using EntityStates.Vulture;
using Grumpy;
using HG;
using HG.Reflection;
using IL.RoR2;
using IL.RoR2.UI;
using JetBrains.Annotations;
using KinematicCharacterController;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MoreStats;
using On.EntityStates;
using On.EntityStates.BrotherMonster;
using On.EntityStates.MeridianEvent;
using On.EntityStates.Missions.BrotherEncounter;
using On.RoR2;
using On.RoR2.SurvivorMannequins;
using On.RoR2.UI;
using R2API;
using R2API.Networking;
using Rewired.Utils;
using Rewired.Utils.Classes.Utility;
using Risky_Artifacts.Artifacts;
using RoR2;
using RoR2.Achievements;
using RoR2.AddressableAssets;
using RoR2.Audio;
using RoR2.CharacterAI;
using RoR2.CharacterSpeech;
using RoR2.ContentManagement;
using RoR2.EntityLogic;
using RoR2.ExpansionManagement;
using RoR2.Hologram;
using RoR2.Mecanim;
using RoR2.Navigation;
using RoR2.Networking;
using RoR2.Orbs;
using RoR2.Projectile;
using RoR2.Skills;
using RoR2.SurvivorMannequins;
using RoR2.UI;
using RoR2BepInExPack.GameAssetPathsBetter;
using RoR2BepInExPack.Utilities;
using TMPro;
using ThreeEyedGames;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Bindings;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.Rendering.PostProcessing;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.Serialization;
using UnityEngine.UI;

[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EnemiesReturns")]
[assembly: AssemblyTitle("EnemiesReturns")]
[assembly: AssemblyCompany("EnemiesReturns")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[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
{
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace EnemiesReturns
{
	public static class ConsoleCommands
	{
		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnTitans(ConCommandArgs args)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: 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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanBlackBeach.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanDampCave.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanGolemPlains.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanGooLake.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(Addressables.LoadAssetAsync<CharacterSpawnCard>((object)"RoR2/Base/Titan/cscTitanGold.asset").WaitForCompletion(), cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnSpitters(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterLakes, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterDepths, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SpitterBody.SpawnCards.cscSpitterSulfur, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnColossi(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(ColossusBody.SpawnCards.cscColossusDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusGrassy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusSnowy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusSandy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusSkyMeadow, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ColossusBody.SpawnCards.cscColossusCastle, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCPocketSpiders(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(MechanicalSpiderEnemyBody.SpawnCards.cscMechanicalSpiderSnowy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(MechanicalSpiderEnemyBody.SpawnCards.cscMechanicalSpiderDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(MechanicalSpiderEnemyBody.SpawnCards.cscMechanicalSpiderGrassy, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnLynx(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(ArcherBody.SpawnCards.cscLynxArcherDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ArcherBodyAlly.SpawnCards.cscLynxArcherAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ScoutBody.SpawnCards.cscLynxScoutDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ScoutBodyAlly.SpawnCards.cscLynxScoutAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(HunterBody.SpawnCards.cscLynxHunterDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(HunterBodyAlly.SpawnCards.cscLynxHunterAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ShamanBody.SpawnCards.cscLynxShamanDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ShamanBodyAlly.SpawnCards.cscLynxShamanAlly, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(TotemBody.SpawnCards.cscLynxTotemDefault, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnArcherBugs(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(ArcherBugBody.SpawnCards.cscArcherBugDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(ArcherBugBody.SpawnCards.cscArcherBugJungle, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnSwifts(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(SwiftBody.SpawnCards.cscSwiftDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SwiftBody.SpawnCards.cscSwiftRallypoint, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCSpawnCrabs(ConCommandArgs args)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			CharacterBody cachedBody = LocalUserManager.readOnlyLocalUsersList[0].cachedBody;
			SpawnMonster(SandCrabBody.SpawnCards.cscSandCrabDefault, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SandCrabBody.SpawnCards.cscSandCrabSandy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SandCrabBody.SpawnCards.cscSandCrabGrassy, cachedBody.modelLocator.modelBaseTransform.position);
			SpawnMonster(SandCrabBody.SpawnCards.cscSandCrabSulfur, cachedBody.modelLocator.modelBaseTransform.position);
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCOutOfTimeTest(ConCommandArgs args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			NetworkUser sender = args.sender;
			InvokeCMD(sender, "fixed_time", Random.Range(4200, 5100).ToString());
			InvokeCMD(sender, "run_set_stages_cleared", "11");
			InvokeCMD(sender, "team_set_level", "1", Random.Range(27, 31).ToString());
			InvokeCMD(sender, "random_items", Random.Range(78, 119).ToString(), "Tier1:100");
			InvokeCMD(sender, "random_items", Random.Range(43, 58).ToString(), "Tier2:100");
			InvokeCMD(sender, "random_items", Random.Range(8, 18).ToString(), "Tier3:100");
			InvokeCMD(sender, "random_items", Random.Range(3, 4).ToString(), "Boss:100");
			InvokeCMD(sender, "give_equip", "MithrixHammer");
			InvokeCMD(sender, "set_scene", "enemiesreturns_outoftime");
		}

		[ConCommand(/*Could not decode attribute arguments.*/)]
		private static void CCContactLightTest(ConCommandArgs args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			NetworkUser sender = args.sender;
			InvokeCMD(sender, "fixed_time", Random.Range(1500, 1800).ToString());
			InvokeCMD(sender, "run_set_stages_cleared", "6");
			InvokeCMD(sender, "team_set_level", "1", Random.Range(15, 20).ToString());
			InvokeCMD(sender, "random_items", Random.Range(20, 30).ToString(), "Tier1:100");
			InvokeCMD(sender, "random_items", Random.Range(10, 15).ToString(), "Tier2:100");
			InvokeCMD(sender, "random_items", Random.Range(1, 4).ToString(), "Tier3:100");
			InvokeCMD(sender, "random_items", Random.Range(1, 3).ToString(), "Boss:100");
			InvokeCMD(sender, "set_scene", "enemiesreturns_contactlight");
		}

		public static void InvokeCMD(NetworkUser user, string commandName, params string[] arguments)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = arguments.ToList();
			CmdSender val = default(CmdSender);
			((CmdSender)(ref val))..ctor(user);
			if (Object.op_Implicit((Object)(object)Console.instance))
			{
				Console.instance.RunCmd(val, commandName, list);
			}
			else
			{
				Log.Message("InvokeCMD called whilst no console instance exists");
			}
		}

		private static void SpawnMonster(CharacterSpawnCard card, Vector3 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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_001e: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			DirectorSpawnRequest val = new DirectorSpawnRequest((SpawnCard)(object)card, new DirectorPlacementRule
			{
				placementMode = (PlacementMode)3,
				position = position
			}, RoR2Application.rng);
			val.teamIndexOverride = (TeamIndex)2;
			val.ignoreTeamMemberLimit = true;
			DirectorCore.instance.TrySpawnObject(val);
		}
	}
	public static class Content
	{
		public static class Stages
		{
			public static SceneDef OutOfTime;

			public static SceneDef JudgementOutro;
		}

		public static class MusicTracks
		{
			public static MusicTrackDef Unknown;

			public static MusicTrackDef UnknownBoss;

			public static MusicTrackDef TheOrigin;
		}

		public static class GameEndings
		{
			public static GameEndingDef SurviveJudgement;
		}

		public static class ItemTiers
		{
			public static ItemTierDef HiddenInLogbook;
		}

		public static class Items
		{
			public static ItemDef ColossalCurl;

			public static ItemDef SpawnPillarOnChampionKill;

			public static ItemDef LynxFetish;

			public static ItemDef TradableRock;

			public static ItemDef LunarFlower;

			public static ItemDef VoidFlower;

			public static ItemDef HiddenAnointed;

			public static ItemDef PartyHat;

			public static ItemDef MechanicalSpiderTurretScepterHelper;
		}

		public static class ItemRelationshipProviders
		{
			public static ItemRelationshipProvider ModdedContagiousItemProvider;
		}

		public static class Equipment
		{
			public static EquipmentDef MithrixHammer;

			public static EquipmentDef EliteAeonian;

			public static EquipmentDef VoidlingWeapon;
		}

		public static class Buffs
		{
			public static BuffDef LynxArcherDamage;

			public static BuffDef LynxHunterArmor;

			public static BuffDef LynxScoutSpeed;

			public static BuffDef LynxShamanSpecialDamage;

			public static BuffDef ReduceHealing;

			public static BuffDef LynxStormImmunity;

			public static BuffDef AffixAeoninan;

			public static BuffDef ImmuneToAllDamageExceptHammer;

			public static BuffDef ImmuneToHammer;
		}

		public static class Elites
		{
			public static EliteDef Aeonian;
		}

		public static class DamageTypes
		{
			public static ModdedDamageType EndGameBossWeapon;

			public static ModdedDamageType CanStunArraign;
		}

		public static class ProcChainTypes
		{
			public static ModdedProcType ColossalFist;
		}

		public static class Deployables
		{
			public static DeployableSlot PylonDeployable;

			public static DeployableSlot SummonLynxTribeDeployable;

			public static DeployableSlot LynxFetishDeployable;
		}
	}
	public class ContentProvider : IContentPackProvider
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		public struct MonsterCategories
		{
			public const string Champions = "Champions";

			public const string Minibosses = "Minibosses";

			public const string BasicMonsters = "Basic Monsters";

			public const string Special = "Special";
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<GameObject, bool> <>9__0_0;

			public static Func<GameObject, bool> <>9__0_1;

			public static Func<GameObject, bool> <>9__0_2;

			public static Func<GameObject, bool> <>9__1_0;

			public static Func<GameObject, bool> <>9__1_1;

			public static Func<GameObject, bool> <>9__2_0;

			public static Func<GameObject, bool> <>9__2_1;

			public static Func<GameObject, bool> <>9__2_2;

			public static Func<Texture2D, bool> <>9__33_7;

			public static Func<Texture2D, bool> <>9__33_8;

			public static Func<Texture2D, string> <>9__33_9;

			public static Func<Texture2D, Texture2D> <>9__33_10;

			public static Func<AnimationCurveDef, string> <>9__33_11;

			public static Func<Type, bool> <>9__33_6;

			public static Func<GameObject, bool> <>9__42_0;

			public static Func<GameObject, bool> <>9__42_1;

			public static Func<GameObject, bool> <>9__42_2;

			public static Func<GameObject, bool> <>9__42_3;

			public static Func<GameObject, bool> <>9__42_4;

			public static Func<GameObject, bool> <>9__42_5;

			public static Func<GameObject, bool> <>9__42_6;

			public static Func<GameObject, bool> <>9__43_0;

			public static Func<GameObject, bool> <>9__44_0;

			public static Func<GameObject, bool> <>9__44_1;

			public static Func<Texture2D, bool> <>9__45_17;

			public static Func<Texture2D, string> <>9__45_18;

			public static Func<Texture2D, Texture2D> <>9__45_19;

			public static Func<AnimationCurveDef, bool> <>9__45_20;

			public static Func<AnimationCurveDef, bool> <>9__45_21;

			public static Func<AnimationCurveDef, bool> <>9__45_22;

			public static Func<AnimationCurveDef, bool> <>9__45_23;

			public static Func<AnimationCurveDef, bool> <>9__45_24;

			public static Func<AnimationCurveDef, bool> <>9__45_25;

			public static Func<AnimationCurveDef, bool> <>9__45_26;

			public static Func<AnimationCurveDef, bool> <>9__45_27;

			public static Func<AnimationCurveDef, bool> <>9__45_28;

			public static Func<EliteDef, bool> <>9__45_29;

			public static Func<SceneDef, bool> <>9__45_30;

			public static Func<SceneDef, bool> <>9__45_31;

			public static Func<SkillDef, bool> <>9__45_32;

			public static Func<SkillDef, bool> <>9__45_33;

			public static Func<SkillDef, bool> <>9__45_34;

			public static Func<SkillDef, bool> <>9__45_35;

			public static Func<SkillDef, bool> <>9__45_36;

			public static Func<SkillDef, bool> <>9__45_37;

			public static Func<SkillDef, bool> <>9__45_38;

			public static Func<SkillDef, bool> <>9__45_39;

			public static Func<SkillDef, bool> <>9__45_40;

			public static Func<SkillDef, bool> <>9__45_41;

			public static Func<SkillDef, bool> <>9__45_42;

			public static Func<SkillDef, bool> <>9__45_43;

			public static Action<SkillDef[]> <>9__45_6;

			public static Func<BuffDef, bool> <>9__45_44;

			public static Func<BuffDef, bool> <>9__45_45;

			public static Func<BuffDef, bool> <>9__45_46;

			public static Func<GameObject, bool> <>9__45_47;

			public static Func<GameObject, bool> <>9__45_48;

			public static Func<GameObject, bool> <>9__45_49;

			public static Func<GameObject, bool> <>9__45_50;

			public static Converter<GameObject, EffectDef> <>9__45_51;

			public static Func<GameObject, bool> <>9__45_52;

			public static Func<GameObject, bool> <>9__45_53;

			public static Func<GameObject, bool> <>9__45_54;

			public static Func<GameObject, bool> <>9__45_55;

			public static Func<GameObject, bool> <>9__45_56;

			public static Func<GameObject, bool> <>9__45_57;

			public static Func<GameObject, bool> <>9__45_58;

			public static Func<GameObject, bool> <>9__45_59;

			public static Func<GameObject, bool> <>9__45_60;

			public static Func<GameObject, bool> <>9__45_61;

			public static Func<GameObject, bool> <>9__45_62;

			public static Func<GameObject, bool> <>9__45_63;

			public static Func<GameObject, bool> <>9__45_64;

			public static Func<GameObject, bool> <>9__45_65;

			public static Func<GameObject, bool> <>9__45_66;

			public static Func<GameObject, bool> <>9__45_67;

			public static Func<GameObject, bool> <>9__45_68;

			public static Func<GameObject, bool> <>9__45_69;

			public static Func<GameObject, bool> <>9__45_70;

			public static Func<GameObject, bool> <>9__45_71;

			public static Func<GameObject, bool> <>9__45_72;

			public static Func<GameObject, bool> <>9__45_73;

			public static Func<GameObject, bool> <>9__45_74;

			public static Func<GameObject, bool> <>9__45_75;

			public static Func<GameObject, bool> <>9__45_76;

			public static Func<GameObject, bool> <>9__45_77;

			public static Func<GameObject, bool> <>9__45_78;

			public static Func<GameObject, bool> <>9__45_79;

			public static Func<GameObject, bool> <>9__45_80;

			public static Func<GameObject, bool> <>9__45_81;

			public static Func<ItemDef, bool> <>9__45_82;

			public static Func<ItemDef, bool> <>9__45_83;

			public static Func<ItemDef, bool> <>9__45_84;

			public static Func<ItemDef, bool> <>9__45_85;

			public static Func<GameEndingDef, bool> <>9__45_86;

			public static Func<ItemTierDef, bool> <>9__45_87;

			public static Func<EquipmentDef, bool> <>9__45_88;

			public static Func<EquipmentDef, bool> <>9__45_89;

			public static Func<EquipmentDef, bool> <>9__45_90;

			public static Func<CharacterSpawnCard, bool> <>9__45_91;

			public static Func<CharacterSpawnCard, bool> <>9__45_92;

			public static Func<CharacterSpawnCard, bool> <>9__45_93;

			public static Func<CharacterSpawnCard, bool> <>9__45_94;

			public static Action<CharacterSpawnCard[]> <>9__45_14;

			public static Func<ModdedSkinDefParams, bool> <>9__45_95;

			public static Action<ModdedSkinDefParams[]> <>9__45_15;

			public static Func<GameObject, bool> <>9__51_0;

			public static Func<GameObject, bool> <>9__52_0;

			public static Func<GameObject, bool> <>9__52_1;

			public static Func<GameObject, bool> <>9__52_2;

			public static Func<GameObject, bool> <>9__52_3;

			public static Func<GameObject, bool> <>9__54_0;

			public static Func<GameObject, bool> <>9__54_1;

			public static Func<GameObject, bool> <>9__54_2;

			public static Func<GameObject, bool> <>9__54_3;

			public static Func<GameObject, bool> <>9__54_4;

			public static Func<GameObject, bool> <>9__54_5;

			public static Func<GameObject, bool> <>9__54_6;

			public static Func<GameObject, bool> <>9__55_0;

			public static Func<GameObject, bool> <>9__55_1;

			public static Func<GameObject, bool> <>9__55_2;

			public static Func<GameObject, bool> <>9__55_3;

			public static Func<GameObject, bool> <>9__55_4;

			public static Func<GameObject, bool> <>9__55_5;

			public static Func<GameObject, bool> <>9__56_0;

			public static Func<GameObject, bool> <>9__56_1;

			public static Func<GameObject, bool> <>9__56_2;

			public static Func<GameObject, bool> <>9__56_3;

			public static Func<GameObject, bool> <>9__56_4;

			public static Func<GameObject, bool> <>9__56_5;

			public static Func<GameObject, bool> <>9__57_0;

			public static Func<GameObject, bool> <>9__57_1;

			public static Func<GameObject, bool> <>9__57_2;

			public static Func<GameObject, bool> <>9__57_3;

			public static Func<GameObject, bool> <>9__57_4;

			public static Func<GameObject, bool> <>9__57_5;

			public static Func<GameObject, bool> <>9__57_6;

			public static Func<GameObject, bool> <>9__57_7;

			public static Func<GameObject, bool> <>9__57_8;

			public static Func<GameObject, bool> <>9__57_9;

			public static Func<GameObject, bool> <>9__57_10;

			public static Func<GameObject, bool> <>9__57_11;

			public static Func<GameObject, bool> <>9__58_0;

			public static Func<GameObject, bool> <>9__59_0;

			public static Func<GameObject, bool> <>9__59_1;

			public static Func<GameObject, bool> <>9__59_2;

			public static Func<GameObject, bool> <>9__59_3;

			public static Func<GameObject, bool> <>9__59_4;

			public static Func<GameObject, bool> <>9__59_5;

			public static EffectCondition <>9__59_6;

			public static Func<GameObject, bool> <>9__59_7;

			public static Func<GameObject, bool> <>9__59_8;

			public static Func<GameObject, bool> <>9__59_9;

			public static Func<GameObject, bool> <>9__59_10;

			public static Func<GameObject, bool> <>9__59_11;

			public static Func<GameObject, bool> <>9__59_12;

			public static Func<GameObject, bool> <>9__60_0;

			public static Func<GameObject, bool> <>9__60_1;

			public static Func<GameObject, bool> <>9__62_0;

			public static Func<GameObject, bool> <>9__62_1;

			public static Func<GameObject, bool> <>9__62_2;

			public static Func<GameObject, bool> <>9__63_0;

			public static Func<GameObject, bool> <>9__63_1;

			public static Func<GameObject, bool> <>9__64_0;

			public static Func<GameObject, bool> <>9__64_1;

			public static Func<GameObject, bool> <>9__64_2;

			public static Func<GameObject, bool> <>9__65_0;

			public static Func<GameObject, bool> <>9__66_0;

			public static Func<GameObject, bool> <>9__66_1;

			public static Func<GameObject, bool> <>9__66_2;

			public static Func<GameObject, bool> <>9__66_3;

			public static Func<GameObject, bool> <>9__66_4;

			public static Func<GameObject, bool> <>9__67_0;

			public static Func<GameObject, bool> <>9__67_1;

			public static Func<GameObject, bool> <>9__68_0;

			public static Func<GameObject, bool> <>9__68_1;

			public static Func<GameObject, bool> <>9__68_2;

			internal bool <CreateArcherBug>b__0_0(GameObject asset)
			{
				return ((Object)asset).name == "ArcherBug_stadiajungle";
			}

			internal bool <CreateArcherBug>b__0_1(GameObject body)
			{
				return ((Object)body).name == "ArcherBugBody";
			}

			internal bool <CreateArcherBug>b__0_2(GameObject master)
			{
				return ((Object)master).name == "ArcherBugMaster";
			}

			internal bool <CreateColossus>b__1_0(GameObject body)
			{
				return ((Object)body).name == "ColossusBody";
			}

			internal bool <CreateColossus>b__1_1(GameObject master)
			{
				return ((Object)master).name == "ColossusMaster";
			}

			internal bool <CreateColossusItem>b__2_0(GameObject item)
			{
				return ((Object)item).name == "PickupColossalCurl";
			}

			internal bool <CreateColossusItem>b__2_1(GameObject item)
			{
				return ((Object)item).name == "ColossalKnurlFistProjectileGhost";
			}

			internal bool <CreateColossusItem>b__2_2(GameObject item)
			{
				return ((Object)item).name == "ColossalKnurlFistProjectile";
			}

			internal bool <LoadStaticContentAsync>b__33_7(Texture2D texture)
			{
				return ((Object)texture).name == "texLavaCrackRound";
			}

			internal bool <LoadStaticContentAsync>b__33_8(Texture2D texture)
			{
				return ((Object)texture).name.StartsWith("texRamp");
			}

			internal string <LoadStaticContentAsync>b__33_9(Texture2D texture)
			{
				return ((Object)texture).name;
			}

			internal Texture2D <LoadStaticContentAsync>b__33_10(Texture2D texture)
			{
				return texture;
			}

			internal string <LoadStaticContentAsync>b__33_11(AnimationCurveDef item)
			{
				return ((Object)item).name;
			}

			internal bool <LoadStaticContentAsync>b__33_6(Type type)
			{
				if (!type.IsAbstract && !type.IsInterface)
				{
					return type.GetCustomAttribute<RegisterEntityState>(inherit: false) != null;
				}
				return false;
			}

			internal bool <CreateIfrit>b__42_0(GameObject effect)
			{
				return ((Object)effect).name == "IfritSpawnPortal";
			}

			internal bool <CreateIfrit>b__42_1(GameObject projectile)
			{
				return ((Object)projectile).name == "IfritHellzonePillarProjectile";
			}

			internal bool <CreateIfrit>b__42_2(GameObject projectile)
			{
				return ((Object)projectile).name == "IfritHellzonePillarProjectileGhost";
			}

			internal bool <CreateIfrit>b__42_3(GameObject projectile)
			{
				return ((Object)projectile).name == "IfritHellzoneVolcanoEffect";
			}

			internal bool <CreateIfrit>b__42_4(GameObject body)
			{
				return ((Object)body).name == "IfritBody";
			}

			internal bool <CreateIfrit>b__42_5(GameObject mane)
			{
				return ((Object)mane).name == "IfritManeFireParticle";
			}

			internal bool <CreateIfrit>b__42_6(GameObject master)
			{
				return ((Object)master).name == "IfritMaster";
			}

			internal bool <CreateIfritItem>b__43_0(GameObject item)
			{
				return ((Object)item).name == "IfritItem";
			}

			internal bool <CreateIfritPillar>b__44_0(GameObject body)
			{
				return ((Object)body).name == "IfritPylonBody";
			}

			internal bool <CreateIfritPillar>b__44_1(GameObject master)
			{
				return ((Object)master).name == "IfritPylonMaster";
			}

			internal bool <CreateJudgementAsync>b__45_17(Texture2D texture)
			{
				return ((Object)texture).name.StartsWith("texRamp");
			}

			internal string <CreateJudgementAsync>b__45_18(Texture2D texture)
			{
				return ((Object)texture).name;
			}

			internal Texture2D <CreateJudgementAsync>b__45_19(Texture2D texture)
			{
				return texture;
			}

			internal bool <CreateJudgementAsync>b__45_20(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdMoveSpeed";
			}

			internal bool <CreateJudgementAsync>b__45_21(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdPreSlashMaterialAlpha";
			}

			internal bool <CreateJudgementAsync>b__45_22(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash1";
			}

			internal bool <CreateJudgementAsync>b__45_23(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash2";
			}

			internal bool <CreateJudgementAsync>b__45_24(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash3";
			}

			internal bool <CreateJudgementAsync>b__45_25(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash1P2";
			}

			internal bool <CreateJudgementAsync>b__45_26(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash2P2";
			}

			internal bool <CreateJudgementAsync>b__45_27(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdSlash3P2";
			}

			internal bool <CreateJudgementAsync>b__45_28(AnimationCurveDef acd)
			{
				return ((Object)acd).name == "acdMithrixDash";
			}

			internal bool <CreateJudgementAsync>b__45_29(EliteDef elitedef)
			{
				return ((Object)elitedef).name == "EliteAeonian";
			}

			internal bool <CreateJudgementAsync>b__45_30(SceneDef sd)
			{
				return sd.cachedName == "enemiesreturns_outoftime";
			}

			internal bool <CreateJudgementAsync>b__45_31(SceneDef sd)
			{
				return sd.cachedName == "enemiesreturns_judgementoutro";
			}

			internal void <CreateJudgementAsync>b__45_6(SkillDef[] assets)
			{
				ArraignBody.P1Skills.ThreeHitCombo = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraign3HitCombo");
				ArraignBody.P1Skills.ThreeHitCombo.baseRechargeInterval = ArraignP1.ThreeHitComboCooldown.Value;
				ArraignBody.P1Skills.LeftRightSwing = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignRightLeftSwing");
				ArraignBody.P1Skills.LeftRightSwing.baseRechargeInterval = ArraignP1.LeftRightSwingCooldown.Value;
				ArraignBody.P1Skills.SwordBeam = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSwordBeam");
				ArraignBody.P1Skills.SwordBeam.baseRechargeInterval = ArraignP1.SwordBeamCooldown.Value;
				ArraignBody.P1Skills.SkyDrop = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSkyDrop");
				ArraignBody.P1Skills.SkyDrop.baseRechargeInterval = ArraignP1.SkyDropCooldown.Value;
				ArraignBody.P1Skills.SwordThrow = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSwordThrow");
				ArraignBody.P1Skills.SwordThrow.baseRechargeInterval = ArraignP1.SwordBeamCooldown.Value;
				ArraignBody.P1Skills.LightningStrikes = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignLightningStrikes");
				ArraignBody.P1Skills.LightningStrikes.baseRechargeInterval = ArraignP1.LightningStrikesCooldown.Value;
				ArraignBody.P2Skills.ThreeHitCombo = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraign3HitComboP2");
				ArraignBody.P2Skills.ThreeHitCombo.baseRechargeInterval = ArraignP2.ThreeHitComboCooldown.Value;
				ArraignBody.P2Skills.LeftRightSwing = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignRightLeftSwingP2");
				ArraignBody.P2Skills.LeftRightSwing.baseRechargeInterval = ArraignP2.LeftRightSwingCooldown.Value;
				ArraignBody.P2Skills.DashLeap = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignDashAttackP2");
				ArraignBody.P2Skills.DashLeap.baseRechargeInterval = ArraignP2.DashLeapCooldown.Value;
				ArraignBody.P2Skills.SpearThrow = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignSpearThrow");
				ArraignBody.P2Skills.SpearThrow.baseRechargeInterval = ArraignP2.SpearThrowCooldown.Value;
				ArraignBody.HauntSkills.ClockAttack = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignaHauntClockAttack");
				ArraignBody.HauntSkills.ClockAttack.baseRechargeInterval = ArraignP2.ClockAttackCooldown.Value;
				ArraignBody.HauntSkills.SummonSkyLaser = assets.First((SkillDef asset) => ((Object)asset).name == "sdArraignHauntSkyLaser");
				ArraignBody.HauntSkills.SummonSkyLaser.baseRechargeInterval = ArraignP2.SkyLaserCooldown.Value;
			}

			internal bool <CreateJudgementAsync>b__45_32(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraign3HitCombo";
			}

			internal bool <CreateJudgementAsync>b__45_33(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignRightLeftSwing";
			}

			internal bool <CreateJudgementAsync>b__45_34(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSwordBeam";
			}

			internal bool <CreateJudgementAsync>b__45_35(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSkyDrop";
			}

			internal bool <CreateJudgementAsync>b__45_36(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSwordThrow";
			}

			internal bool <CreateJudgementAsync>b__45_37(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignLightningStrikes";
			}

			internal bool <CreateJudgementAsync>b__45_38(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraign3HitComboP2";
			}

			internal bool <CreateJudgementAsync>b__45_39(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignRightLeftSwingP2";
			}

			internal bool <CreateJudgementAsync>b__45_40(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignDashAttackP2";
			}

			internal bool <CreateJudgementAsync>b__45_41(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignSpearThrow";
			}

			internal bool <CreateJudgementAsync>b__45_42(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignaHauntClockAttack";
			}

			internal bool <CreateJudgementAsync>b__45_43(SkillDef asset)
			{
				return ((Object)asset).name == "sdArraignHauntSkyLaser";
			}

			internal bool <CreateJudgementAsync>b__45_44(BuffDef buff)
			{
				return ((Object)buff).name == "bdAeonian";
			}

			internal bool <CreateJudgementAsync>b__45_45(BuffDef buff)
			{
				return ((Object)buff).name == "bdImmuneToHammer";
			}

			internal bool <CreateJudgementAsync>b__45_46(BuffDef buff)
			{
				return ((Object)buff).name == "bdImmuneToAllDamageExceptHammer";
			}

			internal bool <CreateJudgementAsync>b__45_47(GameObject asset)
			{
				CharacterBody val = default(CharacterBody);
				return asset.TryGetComponent<CharacterBody>(ref val);
			}

			internal bool <CreateJudgementAsync>b__45_48(GameObject asset)
			{
				CharacterMaster val = default(CharacterMaster);
				return asset.TryGetComponent<CharacterMaster>(ref val);
			}

			internal bool <CreateJudgementAsync>b__45_49(GameObject asset)
			{
				ProjectileController val = default(ProjectileController);
				return asset.TryGetComponent<ProjectileController>(ref val);
			}

			internal bool <CreateJudgementAsync>b__45_50(GameObject asset)
			{
				EffectComponent val = default(EffectComponent);
				return asset.TryGetComponent<EffectComponent>(ref val);
			}

			internal EffectDef <CreateJudgementAsync>b__45_51(GameObject item)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Expected O, but got Unknown
				return new EffectDef(item);
			}

			internal bool <CreateJudgementAsync>b__45_52(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP1Body";
			}

			internal bool <CreateJudgementAsync>b__45_53(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP2Body";
			}

			internal bool <CreateJudgementAsync>b__45_54(GameObject asset)
			{
				return ((Object)asset).name == "JudgementInteractable";
			}

			internal bool <CreateJudgementAsync>b__45_55(GameObject asset)
			{
				return ((Object)asset).name == "PileOfDirtInteractable";
			}

			internal bool <CreateJudgementAsync>b__45_56(GameObject asset)
			{
				return ((Object)asset).name == "BrokenTeleporterInteractable";
			}

			internal bool <CreateJudgementAsync>b__45_57(GameObject asset)
			{
				return ((Object)asset).name == "VoidMegaTeleporter";
			}

			internal bool <CreateJudgementAsync>b__45_58(GameObject asset)
			{
				return ((Object)asset).name == "VoidlingWeaponController";
			}

			internal bool <CreateJudgementAsync>b__45_59(GameObject asset)
			{
				return ((Object)asset).name == "VoidWeaponPrefab";
			}

			internal bool <CreateJudgementAsync>b__45_60(GameObject asset)
			{
				return ((Object)asset).name == "PortalJudgement";
			}

			internal bool <CreateJudgementAsync>b__45_61(GameObject asset)
			{
				return ((Object)asset).name == "MithrixHammerController";
			}

			internal bool <CreateJudgementAsync>b__45_62(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP1SpeechController";
			}

			internal bool <CreateJudgementAsync>b__45_63(GameObject asset)
			{
				return ((Object)asset).name == "ArraignP2SpeechController";
			}

			internal bool <CreateJudgementAsync>b__45_64(GameObject asset)
			{
				return ((Object)asset).name == "MithrixHammerSwingEffect";
			}

			internal bool <CreateJudgementAsync>b__45_65(GameObject asset)
			{
				return ((Object)asset).name == "ArraignRemoveSwordEffect";
			}

			internal bool <CreateJudgementAsync>b__45_66(GameObject asset)
			{
				return ((Object)asset).name == "ArraignSlash3Wave";
			}

			internal bool <CreateJudgementAsync>b__45_67(GameObject asset)
			{
				return ((Object)asset).name == "ArraignPreLightningProjectile";
			}

			internal bool <CreateJudgementAsync>b__45_68(GameObject asset)
			{
				return ((Object)asset).name == "ArraignPreClockAttackProjectile";
			}

			internal bool <CreateJudgementAsync>b__45_69(GameObject asset)
			{
				return ((Object)asset).name == "ArraignSwordProjectile";
			}

			internal bool <CreateJudgementAsync>b__45_70(GameObject asset)
			{
				return ((Object)asset).name == "ArraignSpearProjectile";
			}

			internal bool <CreateJudgementAsync>b__45_71(GameObject asset)
			{
				return ((Object)asset).name == "ClockZoneEffect";
			}

			internal bool <CreateJudgementAsync>b__45_72(GameObject asset)
			{
				return ((Object)asset).name == "DropPositionEffect";
			}

			internal bool <CreateJudgementAsync>b__45_73(GameObject asset)
			{
				return ((Object)asset).name == "ArraignPreBeamGroundIndicator";
			}

			internal bool <CreateJudgementAsync>b__45_74(GameObject asset)
			{
				return ((Object)asset).name == "LanceStapEffect";
			}

			internal bool <CreateJudgementAsync>b__45_75(GameObject asset)
			{
				return ((Object)asset).name == "ArraignArmorBreakEffect";
			}

			internal bool <CreateJudgementAsync>b__45_76(GameObject asset)
			{
				return ((Object)asset).name == "SkyLaserBodySpawnEffect";
			}

			internal bool <CreateJudgementAsync>b__45_77(GameObject asset)
			{
				return ((Object)asset).name == "BeamPostProccess";
			}

			internal bool <CreateJudgementAsync>b__45_78(GameObject asset)
			{
				return ((Object)asset).name == "ArraignBeamPushbackEffect";
			}

			internal bool <CreateJudgementAsync>b__45_79(GameObject asset)
			{
				return ((Object)asset).name == "ArraignBeamPushbackEffectNoMuzzleParticles";
			}

			internal bool <CreateJudgementAsync>b__45_80(GameObject asset)
			{
				return ((Object)asset).name == "DisplayAeonian";
			}

			internal bool <CreateJudgementAsync>b__45_81(GameObject asset)
			{
				return ((Object)asset).name == "EnemiesReturnsCreditsAdditions";
			}

			internal bool <CreateJudgementAsync>b__45_82(ItemDef item)
			{
				return ((Object)item).name == "TradableRock";
			}

			internal bool <CreateJudgementAsync>b__45_83(ItemDef item)
			{
				return ((Object)item).name == "LunarFlower";
			}

			internal bool <CreateJudgementAsync>b__45_84(ItemDef item)
			{
				return ((Object)item).name == "VoidFlower";
			}

			internal bool <CreateJudgementAsync>b__45_85(ItemDef item)
			{
				return ((Object)item).name == "HiddenAnointed";
			}

			internal bool <CreateJudgementAsync>b__45_86(GameEndingDef item)
			{
				return item.cachedName == "SurviveJudgement";
			}

			internal bool <CreateJudgementAsync>b__45_87(ItemTierDef item)
			{
				return ((Object)item).name == "HiddenInLogbook";
			}

			internal bool <CreateJudgementAsync>b__45_88(EquipmentDef equipment)
			{
				return ((Object)equipment).name == "MithrixHammer";
			}

			internal bool <CreateJudgementAsync>b__45_89(EquipmentDef equipment)
			{
				return ((Object)equipment).name == "EliteAeonianEquipment";
			}

			internal bool <CreateJudgementAsync>b__45_90(EquipmentDef equipment)
			{
				return ((Object)equipment).name == "VoidlingWeapon";
			}

			internal void <CreateJudgementAsync>b__45_14(CharacterSpawnCard[] assets)
			{
				ArraignBody.cscArraignP1 = assets.First((CharacterSpawnCard asset) => ((Object)asset).name == "cscArraignP1");
				ArraignBody.cscArraignP2 = assets.First((CharacterSpawnCard asset) => ((Object)asset).name == "cscArraignP2");
				SummonSkyLasers.cscSkyLaser = assets.First((CharacterSpawnCard asset) => ((Object)asset).name == "cscSkyLaser");
				Phase3.cscArraignHaunt = assets.First((CharacterSpawnCard asset) => ((Object)asset).name == "cscArraignHaunt");
			}

			internal bool <CreateJudgementAsync>b__45_91(CharacterSpawnCard asset)
			{
				return ((Object)asset).name == "cscArraignP1";
			}

			internal bool <CreateJudgementAsync>b__45_92(CharacterSpawnCard asset)
			{
				return ((Object)asset).name == "cscArraignP2";
			}

			internal bool <CreateJudgementAsync>b__45_93(CharacterSpawnCard asset)
			{
				return ((Object)asset).name == "cscSkyLaser";
			}

			internal bool <CreateJudgementAsync>b__45_94(CharacterSpawnCard asset)
			{
				return ((Object)asset).name == "cscArraignHaunt";
			}

			internal void <CreateJudgementAsync>b__45_15(ModdedSkinDefParams[] assets)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				ModdedSkinDefParams[] array = assets.Where((ModdedSkinDefParams item) => ((Object)item).name.Contains("Judgement")).ToArray();
				foreach (ModdedSkinDefParams moddedSkinDefParams in array)
				{
					if (Object.op_Implicit((Object)(object)moddedSkinDefParams.CreateSkinDef()))
					{
						GameObject obj = AssetAsyncReferenceManager<GameObject>.LoadAsset(moddedSkinDefParams.bodyPrefab, (AsyncReferenceHandleUnloadType)2).WaitForCompletion();
						SkinDef val = AnointedSkins.CreateAnointedSkin(((Object)obj).name, moddedSkinDefParams.CreateSkinDef(), addEliteRamp: false);
						ArrayUtils.ArrayAppend<SkinDef>(ref ((Component)obj.GetComponent<ModelLocator>().modelTransform).gameObject.GetComponent<ModelSkinController>().skins, ref val);
					}
				}
			}

			internal bool <CreateJudgementAsync>b__45_95(ModdedSkinDefParams item)
			{
				return ((Object)item).name.Contains("Judgement");
			}

			internal bool <CreateLynxTrap>b__51_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTrapPrefab";
			}

			internal bool <CreateLynxShrine>b__52_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTribeRetreatEffect";
			}

			internal bool <CreateLynxShrine>b__52_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShrinePrefab";
			}

			internal bool <CreateLynxShrine>b__52_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShrinePrefab2";
			}

			internal bool <CreateLynxShrine>b__52_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShrinePrefab3";
			}

			internal bool <CreateLynxArcher>b__54_0(GameObject prefab)
			{
				return ((Object)prefab).name == "ArrowProjectile";
			}

			internal bool <CreateLynxArcher>b__54_1(GameObject prefab)
			{
				return ((Object)prefab).name == "ArrowProjectileGhost";
			}

			internal bool <CreateLynxArcher>b__54_2(GameObject prefab)
			{
				return ((Object)prefab).name == "ArrowProjectileGhost";
			}

			internal bool <CreateLynxArcher>b__54_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherBody";
			}

			internal bool <CreateLynxArcher>b__54_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherMaster";
			}

			internal bool <CreateLynxArcher>b__54_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherAllyBody";
			}

			internal bool <CreateLynxArcher>b__54_6(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxArcherAllyMaster";
			}

			internal bool <CreateLynxHunter>b__55_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterAttackEffect";
			}

			internal bool <CreateLynxHunter>b__55_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterSpearTipEffect";
			}

			internal bool <CreateLynxHunter>b__55_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterBody";
			}

			internal bool <CreateLynxHunter>b__55_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterMaster";
			}

			internal bool <CreateLynxHunter>b__55_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterAllyBody";
			}

			internal bool <CreateLynxHunter>b__55_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxHunterAllyMaster";
			}

			internal bool <CreateLynxScout>b__56_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutClawEffectLeft";
			}

			internal bool <CreateLynxScout>b__56_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutClawEffectRight";
			}

			internal bool <CreateLynxScout>b__56_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutBody";
			}

			internal bool <CreateLynxScout>b__56_3(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutMaster";
			}

			internal bool <CreateLynxScout>b__56_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutAllyBody";
			}

			internal bool <CreateLynxScout>b__56_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxScoutAllyMaster";
			}

			internal bool <CreateLynxTotem>b__57_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxSpawnParticles";
			}

			internal bool <CreateLynxTotem>b__57_1(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxSpawnParticles";
			}

			internal bool <CreateLynxTotem>b__57_2(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemFireWallProjectile";
			}

			internal bool <CreateLynxTotem>b__57_3(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemShakeParticles";
			}

			internal bool <CreateLynxTotem>b__57_4(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemSingleStoneParticle";
			}

			internal bool <CreateLynxTotem>b__57_5(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemEyeGlowSummonTribe";
			}

			internal bool <CreateLynxTotem>b__57_6(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemEyeGlowSummonStorm";
			}

			internal bool <CreateLynxTotem>b__57_7(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemEyeGlowGroundpound";
			}

			internal bool <CreateLynxTotem>b__57_8(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemGroundpoundProjectile";
			}

			internal bool <CreateLynxTotem>b__57_9(GameObject prefab)
			{
				return ((Object)prefab).name == "TotemSummonStormOrb";
			}

			internal bool <CreateLynxTotem>b__57_10(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemBody";
			}

			internal bool <CreateLynxTotem>b__57_11(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxTotemMaster";
			}

			internal bool <CreateLynxTotemItem>b__58_0(GameObject item)
			{
				return ((Object)item).name == "PickupLynxFetish";
			}

			internal bool <CreateLynxShaman>b__59_0(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxSpawnParticles";
			}

			internal bool <CreateLynxShaman>b__59_1(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanSummonStormParticle";
			}

			internal bool <CreateLynxShaman>b__59_2(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanMask";
			}

			internal bool <CreateLynxShaman>b__59_3(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanTeleportEffectOut";
			}

			internal bool <CreateLynxShaman>b__59_4(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanPushBackSummon";
			}

			internal bool <CreateLynxShaman>b__59_5(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanPushBackExplosion";
			}

			internal bool <CreateLynxShaman>b__59_6(CharacterBody body)
			{
				return body.HasBuff(Content.Buffs.ReduceHealing);
			}

			internal bool <CreateLynxShaman>b__59_7(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanProjectileImpactEffect";
			}

			internal bool <CreateLynxShaman>b__59_8(GameObject prefab)
			{
				return ((Object)prefab).name == "ShamanTrackingProjectile";
			}

			internal bool <CreateLynxShaman>b__59_9(GameObject body)
			{
				return ((Object)body).name == "LynxShamanBody";
			}

			internal bool <CreateLynxShaman>b__59_10(GameObject master)
			{
				return ((Object)master).name == "LynxShamanMaster";
			}

			internal bool <CreateLynxShaman>b__59_11(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanAllyBody";
			}

			internal bool <CreateLynxShaman>b__59_12(GameObject prefab)
			{
				return ((Object)prefab).name == "LynxShamanAllyMaster";
			}

			internal bool <CreateLynxStorm>b__60_0(GameObject body)
			{
				return ((Object)body).name == "StormBody";
			}

			internal bool <CreateLynxStorm>b__60_1(GameObject master)
			{
				return ((Object)master).name == "StormMaster";
			}

			internal bool <CreateMechanichalSpiderDrone>b__62_0(GameObject body)
			{
				return ((Object)body).name == "MechanicalSpiderDroneBody";
			}

			internal bool <CreateMechanichalSpiderDrone>b__62_1(GameObject master)
			{
				return ((Object)master).name == "MechanicalSpiderDroneMaster";
			}

			internal bool <CreateMechanichalSpiderDrone>b__62_2(GameObject interactable)
			{
				return ((Object)interactable).name == "MechanicalSpiderBroken";
			}

			internal bool <CreateMechanicalSpiderEnemy>b__63_0(GameObject body)
			{
				return ((Object)body).name == "MechanicalSpiderBody";
			}

			internal bool <CreateMechanicalSpiderEnemy>b__63_1(GameObject master)
			{
				return ((Object)master).name == "MechanicalSpiderMaster";
			}

			internal bool <SetupMechanicalSpiderEngiSkill>b__64_0(GameObject body)
			{
				return ((Object)body).name == "MechanicalSpiderTurretBody";
			}

			internal bool <SetupMechanicalSpiderEngiSkill>b__64_1(GameObject master)
			{
				return ((Object)master).name == "MechanicalSpiderTurretMaster";
			}

			internal bool <SetupMechanicalSpiderEngiSkill>b__64_2(GameObject asset)
			{
				return ((Object)asset).name == "MechanicalSpiderTurretBlueprints";
			}

			internal bool <CreatePartyHat>b__65_0(GameObject assets)
			{
				return ((Object)assets).name == "ReturnsPartyHat";
			}

			internal bool <CreateSandCrab>b__66_0(GameObject effect)
			{
				return ((Object)effect).name == "SandCrabBubbleImpactEffect";
			}

			internal bool <CreateSandCrab>b__66_1(GameObject projectile)
			{
				return ((Object)projectile).name == "SandCrabBubbleProjectile";
			}

			internal bool <CreateSandCrab>b__66_2(GameObject ghost)
			{
				return ((Object)ghost).name == "SandCrabBubbleGhost";
			}

			internal bool <CreateSandCrab>b__66_3(GameObject body)
			{
				return ((Object)body).name == "SandCrabBody";
			}

			internal bool <CreateSandCrab>b__66_4(GameObject master)
			{
				return ((Object)master).name == "SandCrabMaster";
			}

			internal bool <CreateSpitter>b__67_0(GameObject body)
			{
				return ((Object)body).name == "SpitterBody";
			}

			internal bool <CreateSpitter>b__67_1(GameObject master)
			{
				return ((Object)master).name == "SpitterMaster";
			}

			internal bool <CreateSwift>b__68_0(GameObject effect)
			{
				return ((Object)effect).name == "SwiftChargeDiveEffect";
			}

			internal bool <CreateSwift>b__68_1(GameObject body)
			{
				return ((Object)body).name == "SwiftBody";
			}

			internal bool <CreateSwift>b__68_2(GameObject master)
			{
				return ((Object)master).name == "SwiftMaster";
			}
		}

		private readonly ContentPack _contentPack = new ContentPack();

		public const string AssetBundleName = "enemiesreturns";

		public const string AssetBundleStagesName = "enemiesreturnsstagesscenes";

		public const string AssetBundleStagesAssetsName = "enemiesreturnsstagesassets";

		public const string AssetBundleFolder = "AssetBundles";

		public const string SoundbankFolder = "Soundbanks";

		public const string SoundsSoundBankFileName = "EnemiesReturnsSounds";

		public const string MusicSoundBankFileName = "EnemiesReturnsMusic";

		public const string InitSoundBankFileName = "EnemiesReturnsInit";

		private readonly List<GameObject> bodyList = new List<GameObject>();

		private readonly List<GameObject> masterList = new List<GameObject>();

		private readonly List<Type> stateList = new List<Type>();

		private readonly List<SkillFamily> sfList = new List<SkillFamily>();

		private readonly List<SkillDef> sdList = new List<SkillDef>();

		private readonly List<EffectDef> effectsList = new List<EffectDef>();

		private readonly List<GameObject> projectilesList = new List<GameObject>();

		private readonly List<UnlockableDef> unlockablesList = new List<UnlockableDef>();

		private readonly List<ItemDef> itemList = new List<ItemDef>();

		private readonly List<NetworkSoundEventDef> nseList = new List<NetworkSoundEventDef>();

		private readonly List<GameObject> nopList = new List<GameObject>();

		private readonly List<BuffDef> bdList = new List<BuffDef>();

		private readonly List<CraftableDef> craftableList = new List<CraftableDef>();

		public static readonly Dictionary<string, string> ShaderLookup = new Dictionary<string, string>
		{
			{ "stubbedror2/base/shaders/hgstandard", "RoR2/Base/Shaders/HGStandard.shader" },
			{ "stubbedror2/base/shaders/hgsnowtopped", "RoR2/Base/Shaders/HGSnowTopped.shader" },
			{ "stubbedror2/base/shaders/hgtriplanarterrainblend", "RoR2/Base/Shaders/HGTriplanarTerrainBlend.shader" },
			{ "stubbedror2/base/shaders/hgintersectioncloudremap", "RoR2/Base/Shaders/HGIntersectionCloudRemap.shader" },
			{ "stubbedror2/base/shaders/hgcloudremap", "RoR2/Base/Shaders/HGCloudRemap.shader" },
			{ "stubbedror2/base/shaders/hgopaquecloudremap", "RoR2/Base/Shaders/HGOpaqueCloudRemap.shader" },
			{ "stubbedror2/base/shaders/hgdistortion", "RoR2/Base/Shaders/HGDistortion.shader" },
			{ "stubbedcalm water/calmwater - dx11 - doublesided", "Calm Water/CalmWater - DX11 - DoubleSided.shader" },
			{ "stubbedcalm water/calmwater - dx11", "Calm Water/CalmWater - DX11.shader" },
			{ "stubbednature/speedtree", "RoR2/Base/Shaders/SpeedTreeCustom.shader" },
			{ "stubbeddecalicious/decaliciousdeferreddecal", "Decalicious/DecaliciousDeferredDecal.shader" },
			{ "stubbedror2/base/shaders/hgdamagenumber", "RoR2/Base/Shaders/HGDamageNumber.shader" },
			{ "stubbedror2/base/shaders/hguianimatealpha", "RoR2/Base/Shaders/HGUIAnimateAlpha.shader" }
		};

		public static Dictionary<string, Material> MaterialCache = new Dictionary<string, Material>();

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

		public string identifier => "com.Viliger.EnemiesReturns.ContentProvider";

		private void CreateArcherBug(GameObject[] assets, Dictionary<string, Sprite> iconLookup)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Expected O, but got Unknown
			//IL_01eb: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Expected O, but got Unknown
			//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_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			if (ArcherBug.Enabled.Value)
			{
				ArcherBugBody.StadiaJungleMeshPrefab = assets.First((GameObject asset) => ((Object)asset).name == "ArcherBug_stadiajungle");
				ArcherBugStuff archerBugStuff = new ArcherBugStuff();
				GameObject item = (FireCausticSpit.projectilePrefab = archerBugStuff.CreateCausticSpitProjectile());
				projectilesList.Add(item);
				UnlockableDef val = Utils.CreateUnlockableDef("Logs.ArcherBugBody.0", "ENEMIES_RETURNS_UNLOCKABLE_LOG_ARCHERBUG");
				unlockablesList.Add(val);
				GameObject val2 = archerBugStuff.CreateDeathEffect();
				effectsList.Add(new EffectDef(val2));
				EnemiesReturns.ModdedEntityStates.ArcherBugs.DeathState.deathEffectPrefab = val2;
				FireCausticSpit.chargeEffect = archerBugStuff.CreateCausticSpitChargeEffect();
				effectsList.Add(new EffectDef(FireCausticSpit.chargeEffect));
				ArcherBugBody archerBugBody = new ArcherBugBody();
				ArcherBugBody.Skills.CausticSpit = archerBugBody.CreateCausticSpitSkill();
				sdList.Add(ArcherBugBody.Skills.CausticSpit);
				ArcherBugBody.SkillFamilies.Primary = Utils.CreateSkillFamily("ArcherBugPrimaryFamily", ArcherBugBody.Skills.CausticSpit);
				sfList.Add(ArcherBugBody.SkillFamilies.Primary);
				ArcherBugBody.BodyPrefab = archerBugBody.AddBodyComponents(assets.First((GameObject body) => ((Object)body).name == "ArcherBugBody"), iconLookup["texArcherBugIcon"], val);
				bodyList.Add(ArcherBugBody.BodyPrefab);
				ArcherBugMaster.MasterPrefab = new ArcherBugMaster().AddMasterComponents(assets.First((GameObject master) => ((Object)master).name == "ArcherBugMaster"), ArcherBugBody.BodyPrefab);
				masterList.Add(ArcherBugMaster.MasterPrefab);
				ArcherBugBody.SpawnCards.cscArcherBugDefault = archerBugBody.CreateCard("cscArcherBugDefault", ArcherBugMaster.MasterPrefab, ArcherBugBody.SkinDefs.Default, ArcherBugBody.BodyPrefab);
				DirectorCard card = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ArcherBugBody.SpawnCards.cscArcherBugDefault,
					selectionWeight = ArcherBug.SelectionWeight.Value,
					preventOverhead = true,
					minimumStageCompletions = ArcherBug.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard = new DirectorCardHolder
				{
					Card = card,
					MonsterCategory = (MonsterCategory)2
				};
				Utils.AddMonsterToStages(ArcherBug.DefaultStageList.Value, directorCard);
				ArcherBugBody.SpawnCards.cscArcherBugJungle = archerBugBody.CreateCard("cscArhcerBugJungle", ArcherBugMaster.MasterPrefab, ArcherBugBody.SkinDefs.Jungle, ArcherBugBody.BodyPrefab);
				DirectorCard card2 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ArcherBugBody.SpawnCards.cscArcherBugJungle,
					selectionWeight = ArcherBug.SelectionWeight.Value,
					preventOverhead = true,
					minimumStageCompletions = ArcherBug.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard2 = new DirectorCardHolder
				{
					Card = card2,
					MonsterCategory = (MonsterCategory)2
				};
				Utils.AddMonsterToStages(ArcherBug.JungleStageList.Value, directorCard2);
			}
		}

		private void CreateColossus(GameObject[] assets, Dictionary<string, Sprite> iconLookup, Dictionary<string, AnimationCurveDef> acdLookup)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Expected O, but got Unknown
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0412: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Expected O, but got Unknown
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Unknown result type (might be due to invalid IL or missing references)
			//IL_043a: Expected O, but got Unknown
			//IL_046b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0470: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Expected O, but got Unknown
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Expected O, but got Unknown
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0511: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Expected O, but got Unknown
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Expected O, but got Unknown
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Expected O, but got Unknown
			//IL_05d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ee: Expected O, but got Unknown
			//IL_05fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_063e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0643: Unknown result type (might be due to invalid IL or missing references)
			//IL_064e: Unknown result type (might be due to invalid IL or missing references)
			//IL_065e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_0665: Unknown result type (might be due to invalid IL or missing references)
			//IL_066c: Unknown result type (might be due to invalid IL or missing references)
			//IL_067e: Expected O, but got Unknown
			//IL_067e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_068b: Unknown result type (might be due to invalid IL or missing references)
			//IL_068d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0694: Expected O, but got Unknown
			//IL_06a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a5: Unknown result type (might be due to invalid IL or missing references)
			ExplicitPickupDropTable droptable = CreateColossusItem(assets, iconLookup);
			if (Colossus.Enabled.Value)
			{
				ColossusStuff colossusStuff = new ColossusStuff();
				GameObject val = (StompBase.stompEffectPrefab = colossusStuff.CreateStompEffect());
				effectsList.Add(new EffectDef(val));
				GameObject item = (StompBase.projectilePrefab = colossusStuff.CreateStompProjectile());
				projectilesList.Add(item);
				GameObject val2 = colossusStuff.CreateDeathFallEffect();
				effectsList.Add(new EffectDef(val2));
				BaseDeath.fallEffect = val2;
				GameObject val3 = colossusStuff.CreateDeath2Effect();
				effectsList.Add(new EffectDef(val3));
				Death2.deathEffect = val3;
				RockClapEnd.clapEffect = colossusStuff.CreateClapEffect();
				GameObject val4 = colossusStuff.CreateFlyingRocksGhost();
				GameObject obj = PrefabAPI.InstantiateClone(val4, "ColossusFlyingRockRotating", false);
				Object.DestroyImmediate((Object)(object)obj.GetComponent<ProjectileGhostController>());
				FloatingRocksController.flyingRockPrefab = obj;
				GameObject item2 = (RockClapEnd.projectilePrefab = colossusStuff.CreateFlyingRockProjectile(val4));
				projectilesList.Add(item2);
				GameObject item3 = (HeadLaserBarrageAttack.projectilePrefab = colossusStuff.CreateLaserBarrageProjectile());
				projectilesList.Add(item3);
				GameObject val5 = (EnemiesReturns.ModdedEntityStates.Colossus.SpawnState.burrowPrefab = colossusStuff.CreateSpawnEffect());
				effectsList.Add(new EffectDef(val5));
				HeadLaserBarrageAttack.intencityGraph = acdLookup["LaserBarrageLightIntencity"].curve;
				UnlockableDef val6 = Utils.CreateUnlockableDef("Logs.ColossusBody.0", "ENEMIES_RETURNS_UNLOCKABLE_LOG_COLOSSUS");
				unlockablesList.Add(val6);
				HeadLaserAttack.beamPrefab = colossusStuff.CreateLaserEffect();
				ColossusBody colossusBody = new ColossusBody();
				ColossusBody.Skills.Stomp = colossusBody.CreateStompSkill();
				ColossusBody.Skills.StoneClap = colossusBody.CreateStoneClapSkill();
				ColossusBody.Skills.LaserBarrage = colossusBody.CreateLaserBarrageSkill();
				ColossusBody.Skills.HeadLaser = colossusBody.CreateHeadLaserSkill();
				sdList.Add(ColossusBody.Skills.Stomp);
				sdList.Add(ColossusBody.Skills.StoneClap);
				sdList.Add(ColossusBody.Skills.LaserBarrage);
				sdList.Add(ColossusBody.Skills.HeadLaser);
				ColossusBody.SkillFamilies.Primary = Utils.CreateSkillFamily("ColossusPrimaryFamily", ColossusBody.Skills.Stomp);
				ColossusBody.SkillFamilies.Secondary = Utils.CreateSkillFamily("ColossusSecondaryFamily", ColossusBody.Skills.StoneClap);
				ColossusBody.SkillFamilies.Utility = Utils.CreateSkillFamily("ColossusUtilityFamily", ColossusBody.Skills.LaserBarrage);
				ColossusBody.SkillFamilies.Special = Utils.CreateSkillFamily("ColossusSpecialFamily", ColossusBody.Skills.HeadLaser);
				sfList.Add(ColossusBody.SkillFamilies.Primary);
				sfList.Add(ColossusBody.SkillFamilies.Secondary);
				sfList.Add(ColossusBody.SkillFamilies.Utility);
				sfList.Add(ColossusBody.SkillFamilies.Special);
				ColossusBody.BodyPrefab = colossusBody.AddBodyComponents(assets.First((GameObject body) => ((Object)body).name == "ColossusBody"), iconLookup["texColossusIcon"], val6, droptable);
				bodyList.Add(ColossusBody.BodyPrefab);
				ColossusMaster.MasterPrefab = new ColossusMaster().AddMasterComponents(assets.First((GameObject master) => ((Object)master).name == "ColossusMaster"), ColossusBody.BodyPrefab);
				masterList.Add(ColossusMaster.MasterPrefab);
				ColossusBody.SpawnCards.cscColossusDefault = colossusBody.CreateCard("cscColossusDefault", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Default, ColossusBody.BodyPrefab);
				DirectorCard card = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusDefault,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard = new DirectorCardHolder
				{
					Card = card,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)"RoR2/Base/Common/dccsGolemFamily.asset").WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.DefaultStageList.Value, directorCard);
				ColossusBody.SpawnCards.cscColossusSkyMeadow = colossusBody.CreateCard("cscColossusSkyMeadow", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.SkyMeadow, ColossusBody.BodyPrefab);
				DirectorCard card2 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusSkyMeadow,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard2 = new DirectorCardHolder
				{
					Card = card2,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToStages(Colossus.SkyMeadowStageList.Value, directorCard2);
				ColossusBody.SpawnCards.cscColossusGrassy = colossusBody.CreateCard("cscColossusGrassy", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Grassy, ColossusBody.BodyPrefab);
				DirectorCard card3 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusGrassy,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard3 = new DirectorCardHolder
				{
					Card = card3,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card3, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)RoR2_Base_Common.dccsGolemFamilyNature_asset).WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.GrassyStageList.Value, directorCard3);
				ColossusBody.SpawnCards.cscColossusCastle = colossusBody.CreateCard("cscColossusCastle", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Castle, ColossusBody.BodyPrefab);
				DirectorCard card4 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusCastle,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard4 = new DirectorCardHolder
				{
					Card = card4,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToStages(Colossus.CastleStageList.Value, directorCard4);
				ColossusBody.SpawnCards.cscColossusSandy = colossusBody.CreateCard("cscColossusSandy", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Sandy, ColossusBody.BodyPrefab);
				DirectorCard card5 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusSandy,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard5 = new DirectorCardHolder
				{
					Card = card5,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card5, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)"RoR2/Base/Common/dccsGolemFamilySandy.asset").WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.SandyStageList.Value, directorCard5);
				ColossusBody.SpawnCards.cscColossusSnowy = colossusBody.CreateCard("cscColossusSnowy", ColossusMaster.MasterPrefab, ColossusBody.SkinDefs.Snowy, ColossusBody.BodyPrefab);
				DirectorCard card6 = new DirectorCard
				{
					spawnCard = (SpawnCard)(object)ColossusBody.SpawnCards.cscColossusSnowy,
					selectionWeight = Colossus.SelectionWeight.Value,
					spawnDistance = (MonsterSpawnDistance)0,
					preventOverhead = true,
					minimumStageCompletions = Colossus.MinimumStageCompletion.Value
				};
				DirectorCardHolder directorCard6 = new DirectorCardHolder
				{
					Card = card6,
					MonsterCategory = (MonsterCategory)4
				};
				Utils.AddMonsterToCardCategory(card6, "Champions", (DirectorCardCategorySelection)(object)Addressables.LoadAssetAsync<FamilyDirectorCardCategorySelection>((object)"RoR2/Base/Common/dccsGolemFamilySnowy.asset").WaitForCompletion());
				Utils.AddMonsterToStages(Colossus.SnowyStageList.Value, directorCard6);
				if (Colossus.AddToArtifactOfOrigin.Value && RiskyArtifafactsCompat.enabled)
				{
					RiskyArtifafactsCompat.AddMonsterToArtifactOfOrigin((SpawnCard)(object)ColossusBody.SpawnCards.cscColossusGrassy, 3);
				}
			}
		}

		private ExplicitPickupDropTable CreateColossusItem(GameObject[] assets, Dictionary<string, Sprite> iconLookup)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			ExplicitPickupDropTable val = null;
			if (Colossus.ItemEnabled.Value)
			{
				ColossalKnurlFactory colossalKnurlFactory = new ColossalKnurlFactory();
				Content.Items.ColossalCurl = colossalKnurlFactory.CreateItem(assets.First((GameObject item) => ((Object)item).name == "PickupColossalCurl"), iconLookup["texColossalKnurlIcon"]);
				itemList.Add(Content.Items.ColossalCurl);
				val = ScriptableObject.CreateInstance<ExplicitPickupDropTable>();
				((Object)val).name = "epdtColossus";
				((PickupDropTable)val).canDropBeReplaced = true;
				val.pickupEntries = (PickupDefEntry[])(object)new PickupDefEntry[1]
				{
					new PickupDefEntry
					{
						pickupWeight = 1f,
						pickupDef = (Object)(object)Content.Items.ColossalCurl
					}
				};
				GameObject prefab = assets.First((GameObject item) => ((Object)item).name == "ColossalKnurlFistProjectileGhost");
				prefab = colossalKnurlFactory.CreateFistGhostPrefab(prefab);
				GameObject fistPrefab = assets.First((GameObject item) => ((Object)item).name == "ColossalKnurlFistProjectile");
				ColossalKnurlFactory.projectilePrefab = colossalKnurlFactory.CreateFistProjectile(fistPrefab, prefab);
				projectilesList.Add(ColossalKnurlFactory.projectilePrefab);
				ref Pair[] relationships = ref Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationships;
				Pair val2 = new Pair
				{
					itemDef1 = Content.Items.ColossalCurl,
					itemDef2 = VoidMegaCrabItem
				};
				ArrayUtils.ArrayAppend<Pair>(ref relationships, ref val2);
			}
			return val;
		}

		public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
		{
			args.ReportProgress(1f);
			yield break;
		}

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

		public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
		{
			Stopwatch totalStopwatch = new Stopwatch();
			((StopwatchBase)totalStopwatch).Start();
			_contentPack.identifier = identifier;
			Content.ItemRelationshipProviders.ModdedContagiousItemProvider = ScriptableObject.CreateInstance<ItemRelationshipProvider>();
			((Object)Content.ItemRelationshipProviders.ModdedContagiousItemProvider).name = "EnemiesReturnsContagiousItemProvider";
			Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationshipType = Addressables.LoadAssetAsync<ItemRelationshipType>((object)"RoR2/DLC1/Common/ContagiousItem.asset").WaitForCompletion();
			Content.ItemRelationshipProviders.ModdedContagiousItemProvider.relationships = Array.Empty<Pair>();
			Stopwatch val = new Stopwatch();
			((StopwatchBase)val).Start();
			string soundbanksFolderPath = Path.Combine(Path.GetDirectoryName(typeof(ContentProvider).Assembly.Location), "Soundbanks");
			LoadSoundBanks(soundbanksFolderPath);
			((StopwatchBase)val).Stop();
			Log.Info("Soundbanks loaded in " + ((StopwatchBase)val).elapsedSeconds);
			string assetBundleFolderPath = Path.Combine(Path.GetDirectoryName(typeof(ContentProvider).Assembly.Location), "AssetBundles");
			AssetBundle assetbundle = null;
			yield return LoadAssetBundle(Path.Combine(assetBundleFolderPath, "enemiesreturns"), args.progressReceiver, delegate(AssetBundle resultAssetBundle)
			{
				assetbundle = resultAssetBundle;
			});
			yield return LoadAllAssetsAsync<Material>(assetbundle, args.progressReceiver, (Action<Material[]>)delegate(Material[] assets)
			{
				SwapMaterials(assets);
			});
			Dictionary<string, Sprite> iconLookup = new Dictionary<string, Sprite>();
			Dictionary<string, Texture2D> rampLookups = new Dictionary<string, Texture2D>();
			Texture2D texLavaCrackRound = null;
			yield return LoadAllAssetsAsync<Texture2D>(assetbundle, args.progressReceiver, (Action<Texture2D[]>)delegate(Texture2D[] textures)
			{
				texLavaCrackRound = textures.First((Texture2D texture) => ((Object)texture).name == "texLavaCrackRound");
				rampLookups = textures.Where((Texture2D texture) => ((Object)texture).name.StartsWith("texRamp")).ToDictionary((Texture2D texture) => ((Object)texture).name, (Texture2D texture) => texture);
			});
			yield return LoadAllAssetsAsync<Sprite>(assetbundle, args.progressReceiver, (Action<Sprite[]>)delegate(Sprite[] assets)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				Stopwatch val3 = new Stopwatch();
				((StopwatchBase)val3).Start();
				foreach (Sprite val4 in assets)
				{
					iconLookup.Add(((Object)val4).name, val4);
				}
				((StopwatchBase)val3).Stop();
				Log.Info("Icons loaded in " + ((StopwatchBase)val3).elapsedSeconds);
			});
			Dictionary<string, AnimationCurveDef> acdLookup = new Dictionary<string, AnimationCurveDef>();
			yield return LoadAllAssetsAsync<AnimationCurveDef>(assetbundle, args.progressReceiver, (Action<AnimationCurveDef[]>)delegate(AnimationCurveDef[] assets)
			{
				acdLookup = assets.ToDictionary((AnimationCurveDef item) => ((Object)item).name);
			});
			yield return CreateJudgementAsync(args, iconLookup, rampLookups, acdLookup, assetBundleFolderPath);
			yield return LoadAllAssetsAsync<GameObject>(assetbundle, args.progressReceiver, (Action<GameObject[]>)delegate(GameObject[] assets)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				Stopwatch val2 = new Stopwatch();
				((StopwatchBase)val2).Start();
				CreatePartyHat(assets);
				CreateSpitter(assets, iconLookup);
				CreateColossus(assets, iconLookup, acdLookup);
				CreateIfrit(assets, iconLookup, texLavaCrackRound, acdLookup);
				CreateMechanicalSpider(assets, iconLookup, acdLookup);
				CreateLynxTribe(assets, iconLookup, acdLookup, rampLookups);
				CreateArcherBug(assets, iconLookup);
				CreateSwift(assets, iconLookup, acdLookup);
				CreateSandCrab(assets, iconLookup, acdLookup);
				((StopwatchBase)val2).Stop();
				Log.Info("Characters created in " + ((StopwatchBase)val2).elapsedSeconds);
			});
			Type[] array = (from type in Assembly.GetExecutingAssembly().GetTypes()
				where !type.IsAbstract && !type.IsInterface && type.GetCustomAttribute<RegisterEntityState>(inherit: false) != null
				select type).ToArray();
			_contentPack.entityStateTypes.Add(array);
			_contentPack.bodyPrefabs.Add(bodyList.ToArray());
			_contentPack.masterPrefabs.Add(masterList.ToArray());
			_contentPack.skillDefs.Add(sdList.ToArray());
			_contentPack.skillFamilies.Add(sfList.ToArray());
			_contentPack.entityStateTypes.Add(stateList.ToArray());
			_contentPack.effectDefs.Add(effectsList.ToArray());
			_contentPack.projectilePrefabs.Add(projectilesList.ToArray());
			_contentPack.unlockableDefs.Add(unlockablesList.ToArray());
			_contentPack.itemDefs.Add(itemList.ToArray());
			_contentPack.networkSoundEventDefs.Add(nseList.ToArray());
			_contentPack.networkedObjectPrefabs.Add(nopList.ToArray());
			_contentPack.itemRelationshipProviders.Add((ItemRelationshipProvider[])(object)new ItemRelationshipProvider[1] { Content.ItemRelationshipProviders.ModdedContagiousItemProvider });
			_contentPack.buffDefs.Add(bdList.ToArray());
			_contentPack.craftableDefs.Add(craftableList.ToArray());
			((StopwatchBase)totalStopwatch).Stop();
			Log.Info("Total loading time: " + ((StopwatchBase)totalStopwatch).elapsedSeconds);
		}

		private void SwapMaterials(Material[] assets)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Stopwatch val = new Stopwatch();
			((StopwatchBase)val).Start();
			if (assets != null)
			{
				Material[] array = assets;
				foreach (Material val2 in array)
				{
					if (!ShaderLookup.TryGetValue(((Object)val2.shader).name.ToLower(), out var value))
					{
						Log.Info("Couldn't find replacement shader for " + ((Object)val2.shader).name.ToLower() + " in dictionary.");
						continue;
					}
					Shader val3 = Addressables.LoadAssetAsync<Shader>((object)value).WaitForCompletion();
					if (Object.op_Implicit((Object)(object)val3))
					{
						val2.shader = val3;
					}
					else
					{
						Log.Info("Couldn't find replacement shader for " + ((Object)val2.shader).name.ToLower());
					}
					MaterialCache.Add(((Object)val2).name, val2);
				}
			}
			((StopwatchBase)val).Stop();
			Log.Info("Materials swapped in " + ((StopwatchBase)val).elapsedSeconds);
		}

		private IEnumerator LoadAssetBundle(string assetBundleFullPath, IProgress<float> progress, Action<AssetBundle> onAssetBundleLoaded)
		{
			Stopwatch stopwatch = new Stopwatch();
			((StopwatchBase)stopwatch).Start();
			AssetBundleCreateRequest assetBundleCreateRequest = AssetBundle.LoadFromFileAsync(assetBundleFullPath);
			while (!((AsyncOperation)assetBundleCreateRequest).isDone)
			{
				progress.Report(((AsyncOperation)assetBundleCreateRequest).progress);
				yield return null;
			}
			onAssetBundleLoaded(assetBundleCreateRequest.assetBundle);
			((StopwatchBase)stopwatch).Stop();
			Log.Info("Asset bundle " + assetBundleFullPath + " loaded in " + ((StopwatchBase)stopwatch).elapsedSeconds);
		}

		private static IEnumerator LoadAllAssetsAsync<T>(AssetBundle assetBundle, IProgress<float> progress, Action<T[]> onAssetsLoaded) where T : Object
		{
			AssetBundleRequest sceneDefsRequest = assetBundle.LoadAllAssetsAsync<T>();
			while (!((AsyncOperation)sceneDefsRequest).isDone)
			{
				progress.Report(((AsyncOperation)sceneDefsRequest).progress);
				yield return null;
			}
			onAssetsLoaded(sceneDefsRequest.allAssets.Cast<T>().ToArray());
		}

		public static Material CreateAndReplaceMaterial(string materialName, Func<Material, Material> materialCreateFunc)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				Log.Warning("There is no material with name " + materialName + " to replace in MaterialCache!");
				return null;
			}
			Material val = materialCreateFunc(value);
			MaterialCache[materialName] = val;
			return val;
		}

		public static Material GetOrCreateMaterial(string materialName, Func<Material> materialCreateFunc)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				value = materialCreateFunc();
				MaterialCache.Add(materialName, value);
			}
			return value;
		}

		public static Material GetOrCreateMaterial(string materialName, Func<Texture2D, Material> materialCreateFunc, Texture2D texture)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				value = materialCreateFunc(texture);
				MaterialCache.Add(materialName, value);
			}
			return value;
		}

		public static Material GetOrCreateMaterial(string materialName, Func<Material, Material> materialCreateFunc, Material materialOrig)
		{
			if (!MaterialCache.TryGetValue(materialName, out var value))
			{
				value = materialCreateFunc(materialOrig);
				MaterialCache.Add(materialName, value);
			}
			return value;
		}

		private void LoadSoundBanks(string soundbanksFolderPath)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Invalid comparison between Unknown and I4
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			AKRESULT val = AkSoundEngine.AddBasePath(soundbanksFolderPath);
			if ((int)val == 1)
			{
				Log.Info("Added bank base path : " + soundbanksFolderPath);
			}
			else
			{
				Log.Error("Error adding base path : " + soundbanksFolderPath + " " + $"Error code : {val}");
			}
			uint num = default(uint);
			val = AkSoundEngine.LoadBank("EnemiesReturnsInit", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : EnemiesReturnsInit");
			}
			else
			{
				Log.Error("Error loading bank : EnemiesReturnsInit " + $"Error code : {val}");
			}
			val = AkSoundEngine.LoadBank("EnemiesReturnsMusic", ref num);
			if ((int)val == 1)
			{
				Log.Info("Added bank : EnemiesReturnsMusic");
			}
			else
			{
				Log.Error("Error loading bank : EnemiesReturnsMusic " + $"Error code : {