using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using REPOLib.Modules;
using REPOLib.Objects.Sdk;
using TMPro;
using Unity.AI.Navigation;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Empress")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EmpressSuperHotArena")]
[assembly: AssemblyTitle("EmpressSuperHotArena")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Empress.REPO.SuperHotArena
{
	internal static class ArenaAccess
	{
		private delegate void ModuleSetAllChecklistDelegate(Module module);

		private delegate void LevelGeneratorGenerateDoneDelegate(LevelGenerator instance, PhotonMessageInfo info);

		private static readonly FieldInfo EnvironmentSetupDoneField = AccessTools.Field(typeof(EnvironmentDirector), "SetupDone");

		private static readonly FieldInfo EnvironmentMainCameraField = AccessTools.Field(typeof(EnvironmentDirector), "MainCamera");

		private static readonly FieldInfo EnvironmentAmbientColorField = AccessTools.Field(typeof(EnvironmentDirector), "AmbientColor");

		private static readonly FieldInfo EnvironmentAmbientColorNewField = AccessTools.Field(typeof(EnvironmentDirector), "AmbientColorNew");

		private static readonly FieldInfo EnvironmentAmbientColorPreviousField = AccessTools.Field(typeof(EnvironmentDirector), "AmbientColorPrevious");

		private static readonly FieldInfo EnvironmentAmbientColorAdaptationField = AccessTools.Field(typeof(EnvironmentDirector), "AmbientColorAdaptation");

		private static readonly FieldInfo EnvironmentAmbientColorAdaptationNewField = AccessTools.Field(typeof(EnvironmentDirector), "AmbientColorAdaptationNew");

		private static readonly FieldInfo EnvironmentAmbientColorAdaptationPreviousField = AccessTools.Field(typeof(EnvironmentDirector), "AmbientColorAdaptationPrevious");

		private static readonly FieldInfo EnvironmentDarkAdaptationLerpField = AccessTools.Field(typeof(EnvironmentDirector), "DarkAdaptationLerp");

		private static readonly FieldInfo EnvironmentFogColorField = AccessTools.Field(typeof(EnvironmentDirector), "FogColor");

		private static readonly FieldInfo EnvironmentFogColorNewField = AccessTools.Field(typeof(EnvironmentDirector), "FogColorNew");

		private static readonly FieldInfo EnvironmentFogColorPreviousField = AccessTools.Field(typeof(EnvironmentDirector), "FogColorPrevious");

		private static readonly FieldInfo EnvironmentFogStartDistanceField = AccessTools.Field(typeof(EnvironmentDirector), "FogStartDistance");

		private static readonly FieldInfo EnvironmentFogStartDistanceNewField = AccessTools.Field(typeof(EnvironmentDirector), "FogStartDistanceNew");

		private static readonly FieldInfo EnvironmentFogStartDistancePreviousField = AccessTools.Field(typeof(EnvironmentDirector), "FogStartDistancePrevious");

		private static readonly FieldInfo EnvironmentFogEndDistanceField = AccessTools.Field(typeof(EnvironmentDirector), "FogEndDistance");

		private static readonly FieldInfo EnvironmentFogEndDistanceNewField = AccessTools.Field(typeof(EnvironmentDirector), "FogEndDistanceNew");

		private static readonly FieldInfo EnvironmentFogEndDistancePreviousField = AccessTools.Field(typeof(EnvironmentDirector), "FogEndDistancePrevious");

		private static readonly FieldInfo LevelGeneratorAllPlayersReadyField = AccessTools.Field(typeof(LevelGenerator), "AllPlayersReady");

		private static readonly FieldInfo LevelGeneratorEnemyReadyField = AccessTools.Field(typeof(LevelGenerator), "EnemyReady");

		private static readonly FieldInfo LevelGeneratorModulesSpawnedField = AccessTools.Field(typeof(LevelGenerator), "ModulesSpawned");

		private static readonly FieldInfo LevelGeneratorPlayerSpawnedField = AccessTools.Field(typeof(LevelGenerator), "playerSpawned");

		private static readonly FieldInfo RunManagerLevelPreviousField = AccessTools.Field(typeof(RunManager), "levelPrevious");

		private static readonly FieldInfo PlayerControllerInputDisableTimerField = AccessTools.Field(typeof(PlayerController), "InputDisableTimer");

		private static readonly FieldInfo PlayerAvatarIsDisabledField = AccessTools.Field(typeof(PlayerAvatar), "isDisabled");

		private static readonly FieldInfo PlayerAvatarDeadSetField = AccessTools.Field(typeof(PlayerAvatar), "deadSet");

		private static readonly FieldInfo ValuableDirectorSetupCompleteField = AccessTools.Field(typeof(ValuableDirector), "setupComplete");

		private static readonly FieldInfo ValuableDirectorValuablesSpawnedField = AccessTools.Field(typeof(ValuableDirector), "valuablesSpawned");

		private static readonly FieldInfo RoundDirectorExtractionPointsField = AccessTools.Field(typeof(RoundDirector), "extractionPoints");

		private static readonly FieldInfo RoundDirectorExtractionPointsCompletedField = AccessTools.Field(typeof(RoundDirector), "extractionPointsCompleted");

		private static readonly FieldInfo RoundDirectorExtractionPointListField = AccessTools.Field(typeof(RoundDirector), "extractionPointList");

		private static readonly FieldInfo LoadingUiLevelAnimationCompletedField = AccessTools.Field(typeof(LoadingUI), "levelAnimationCompleted");

		private static readonly FieldInfo LevelPointInStartRoomField = AccessTools.Field(typeof(LevelPoint), "inStartRoom");

		private static readonly FieldInfo PlayerAvatarSteamIdField = AccessTools.Field(typeof(PlayerAvatar), "steamID");

		private static readonly FieldInfo PlayerAvatarIsLocalField = AccessTools.Field(typeof(PlayerAvatar), "isLocal");

		private static readonly FieldInfo ItemAttributesInstanceNameField = AccessTools.Field(typeof(ItemAttributes), "instanceName");

		private static readonly FieldInfo ItemAttributesHasIconField = AccessTools.Field(typeof(ItemAttributes), "hasIcon");

		private static readonly FieldInfo ItemBatteryLifeIntField = AccessTools.Field(typeof(ItemBattery), "batteryLifeInt");

		private static readonly FieldInfo ItemGunBatteryField = AccessTools.Field(typeof(ItemGun), "itemBattery");

		private static readonly FieldInfo ModuleSetupDoneField = AccessTools.Field(typeof(Module), "SetupDone");

		private static readonly FieldInfo ModuleStartRoomField = AccessTools.Field(typeof(Module), "StartRoom");

		private static readonly FieldInfo ModuleGridXField = AccessTools.Field(typeof(Module), "GridX");

		private static readonly FieldInfo ModuleGridYField = AccessTools.Field(typeof(Module), "GridY");

		private static readonly MethodInfo ModuleSetAllChecklistMethod = AccessTools.Method(typeof(Module), "SetAllChecklist", (Type[])null, (Type[])null);

		private static readonly MethodInfo LevelGeneratorGenerateDoneMethod = AccessTools.Method(typeof(LevelGenerator), "GenerateDone", new Type[1] { typeof(PhotonMessageInfo) }, (Type[])null);

		private static readonly ModuleSetAllChecklistDelegate ModuleSetAllChecklistCall = CreateDelegate<ModuleSetAllChecklistDelegate>(ModuleSetAllChecklistMethod);

		private static readonly LevelGeneratorGenerateDoneDelegate LevelGeneratorGenerateDoneCall = CreateDelegate<LevelGeneratorGenerateDoneDelegate>(LevelGeneratorGenerateDoneMethod);

		public static void SetEnvironmentFog(EnvironmentDirector director, Color color, float startDistance, float endDistance)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			SetField(EnvironmentFogColorField, director, color);
			SetField(EnvironmentFogColorNewField, director, color);
			SetField(EnvironmentFogColorPreviousField, director, color);
			SetField(EnvironmentFogStartDistanceField, director, startDistance);
			SetField(EnvironmentFogStartDistanceNewField, director, startDistance);
			SetField(EnvironmentFogStartDistancePreviousField, director, startDistance);
			SetField(EnvironmentFogEndDistanceField, director, endDistance);
			SetField(EnvironmentFogEndDistanceNewField, director, endDistance);
			SetField(EnvironmentFogEndDistancePreviousField, director, endDistance);
		}

		public static void SetEnvironmentAmbient(EnvironmentDirector director, Color ambient, Color adaptation)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			SetField(EnvironmentAmbientColorField, director, ambient);
			SetField(EnvironmentAmbientColorNewField, director, ambient);
			SetField(EnvironmentAmbientColorPreviousField, director, ambient);
			SetField(EnvironmentAmbientColorAdaptationField, director, adaptation);
			SetField(EnvironmentAmbientColorAdaptationNewField, director, adaptation);
			SetField(EnvironmentAmbientColorAdaptationPreviousField, director, adaptation);
		}

		public static void SetEnvironmentDarkAdaptation(EnvironmentDirector director, float value)
		{
			SetField(EnvironmentDarkAdaptationLerpField, director, value);
		}

		public static Camera GetEnvironmentMainCamera(EnvironmentDirector director)
		{
			return Get<Camera>(EnvironmentMainCameraField, director);
		}

		public static void SetEnvironmentMainCamera(EnvironmentDirector director, Camera camera)
		{
			SetField(EnvironmentMainCameraField, director, camera);
		}

		public static void SetEnvironmentSetupDone(EnvironmentDirector director, bool value)
		{
			SetField(EnvironmentSetupDoneField, director, value);
		}

		public static void SetAllPlayersReady(LevelGenerator generator, bool value)
		{
			SetField(LevelGeneratorAllPlayersReadyField, generator, value);
		}

		public static bool GetAllPlayersReady(LevelGenerator generator)
		{
			return GetBool(LevelGeneratorAllPlayersReadyField, generator);
		}

		public static void SetEnemyReady(LevelGenerator generator, bool value)
		{
			SetField(LevelGeneratorEnemyReadyField, generator, value);
		}

		public static void SetModulesSpawned(LevelGenerator generator, int value)
		{
			SetField(LevelGeneratorModulesSpawnedField, generator, value);
		}

		public static void SetPlayerSpawnedCount(LevelGenerator generator, int value)
		{
			SetField(LevelGeneratorPlayerSpawnedField, generator, value);
		}

		public static int GetPlayerSpawnedCount(LevelGenerator generator)
		{
			return GetInt(LevelGeneratorPlayerSpawnedField, generator);
		}

		public static void SetLevelPrevious(RunManager manager, Level level)
		{
			SetField(RunManagerLevelPreviousField, manager, level);
		}

		public static float GetInputDisableTimer(PlayerController controller)
		{
			return GetFloat(PlayerControllerInputDisableTimerField, controller);
		}

		public static bool GetIsDisabled(PlayerAvatar avatar)
		{
			return GetBool(PlayerAvatarIsDisabledField, avatar);
		}

		public static bool GetDeadSet(PlayerAvatar avatar)
		{
			return GetBool(PlayerAvatarDeadSetField, avatar);
		}

		public static void SetValuableSetupComplete(ValuableDirector director, bool value)
		{
			SetField(ValuableDirectorSetupCompleteField, director, value);
		}

		public static void SetValuableValuablesSpawned(ValuableDirector director, bool value)
		{
			SetField(ValuableDirectorValuablesSpawnedField, director, value);
		}

		public static void ResetRoundExtraction(RoundDirector director)
		{
			SetField(RoundDirectorExtractionPointsField, director, 0);
			SetField(RoundDirectorExtractionPointsCompletedField, director, 0);
			Get<List<GameObject>>(RoundDirectorExtractionPointListField, director)?.Clear();
		}

		public static bool GetLevelAnimationCompleted(LoadingUI ui)
		{
			return GetBool(LoadingUiLevelAnimationCompletedField, ui);
		}

		public static void ConfigureStartRoomModule(Module module, int gridX, int gridY)
		{
			ModuleSetAllChecklistCall?.Invoke(module);
			SetField(ModuleSetupDoneField, module, true);
			SetField(ModuleStartRoomField, module, true);
			SetField(ModuleGridXField, module, gridX);
			SetField(ModuleGridYField, module, gridY);
		}

		public static void MarkLevelPointInStartRoom(LevelPoint point, bool value)
		{
			SetField(LevelPointInStartRoomField, point, value);
		}

		public static bool GetIsLocal(PlayerAvatar avatar)
		{
			return GetBool(PlayerAvatarIsLocalField, avatar);
		}

		public static string GetSteamId(PlayerAvatar avatar)
		{
			if (PlayerAvatarSteamIdField == null || (Object)(object)avatar == (Object)null)
			{
				return string.Empty;
			}
			return (PlayerAvatarSteamIdField.GetValue(avatar) as string) ?? string.Empty;
		}

		public static string GetItemInstanceName(ItemAttributes attributes)
		{
			if (ItemAttributesInstanceNameField == null || (Object)(object)attributes == (Object)null)
			{
				return string.Empty;
			}
			return (ItemAttributesInstanceNameField.GetValue(attributes) as string) ?? string.Empty;
		}

		public static bool GetItemHasIcon(ItemAttributes attributes)
		{
			return GetBool(ItemAttributesHasIconField, attributes);
		}

		public static void SetItemBatteryLifeInt(ItemBattery battery, int value)
		{
			SetField(ItemBatteryLifeIntField, battery, value);
		}

		public static ItemBattery GetGunBattery(ItemGun gun)
		{
			return Get<ItemBattery>(ItemGunBatteryField, gun);
		}

		public static void GenerateDone(LevelGenerator generator)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (LevelGeneratorGenerateDoneCall != null)
			{
				LevelGeneratorGenerateDoneCall(generator, default(PhotonMessageInfo));
			}
		}

		private static T Get<T>(FieldInfo field, object instance) where T : class
		{
			if (field == null || instance == null)
			{
				return null;
			}
			return field.GetValue(instance) as T;
		}

		private static bool GetBool(FieldInfo field, object instance)
		{
			if (field == null || instance == null)
			{
				return false;
			}
			object value = field.GetValue(instance);
			bool flag = default(bool);
			int num;
			if (value is bool)
			{
				flag = (bool)value;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}

		private static int GetInt(FieldInfo field, object instance)
		{
			if (field == null || instance == null)
			{
				return 0;
			}
			object value = field.GetValue(instance);
			if (value is int)
			{
				return (int)value;
			}
			return 0;
		}

		private static float GetFloat(FieldInfo field, object instance)
		{
			if (field == null || instance == null)
			{
				return 0f;
			}
			object value = field.GetValue(instance);
			if (value is float)
			{
				return (float)value;
			}
			return 0f;
		}

		private static void SetField(FieldInfo field, object instance, object value)
		{
			if (!(field == null) && instance != null)
			{
				field.SetValue(instance, value);
			}
		}

		private static TDelegate CreateDelegate<TDelegate>(MethodInfo method) where TDelegate : Delegate
		{
			if (method == null)
			{
				return null;
			}
			return AccessTools.MethodDelegate<TDelegate>(method, (object)null, true);
		}
	}
	internal static class ArenaAssets
	{
		private const string BundleName = "empresssuperhotassets";

		private const string MusicBundleName = "empresssuperhotarenamusic";

		private static readonly Dictionary<string, AudioClip> Clips = new Dictionary<string, AudioClip>();

		private static readonly Dictionary<string, AudioClip> MusicClips = new Dictionary<string, AudioClip>();

		private static AssetBundle _bundle;

		private static AssetBundle _musicBundle;

		private static GameObject _pistolEnemy;

		private static GameObject _shotgunEnemy;

		private static bool _initialized;

		private static bool _musicInitialized;

		public static bool HasPrefabs
		{
			get
			{
				if (!((Object)(object)_pistolEnemy != (Object)null))
				{
					return (Object)(object)_shotgunEnemy != (Object)null;
				}
				return true;
			}
		}

		public static bool HasMusic => MusicClips.Count > 0;

		public static void Initialize(string pluginDirectory, ManualLogSource log)
		{
			if (_initialized)
			{
				return;
			}
			_initialized = true;
			string text = ResolveBundlePath(pluginDirectory);
			if (text == null || !File.Exists(text))
			{
				log.LogWarning((object)"Empress SuperHot Arena asset bundle not found beside DLL. Falling back to procedural enemies.");
				return;
			}
			_bundle = AssetBundle.LoadFromFile(text);
			if ((Object)(object)_bundle == (Object)null)
			{
				log.LogWarning((object)("Empress SuperHot Arena could not load asset bundle at " + text));
				return;
			}
			_pistolEnemy = _bundle.LoadAsset<GameObject>("EmpressSuperHotPistolEnemy");
			_shotgunEnemy = _bundle.LoadAsset<GameObject>("EmpressSuperHotShotgunEnemy");
			string[] allAssetNames = _bundle.GetAllAssetNames();
			foreach (string text2 in allAssetNames)
			{
				AudioClip val = _bundle.LoadAsset<AudioClip>(text2);
				if (!((Object)(object)val == (Object)null))
				{
					RegisterClip(text2, val);
					RegisterClip(Path.GetFileNameWithoutExtension(text2), val);
					RegisterClip(((Object)val).name, val);
				}
			}
			int num = (((Object)(object)_pistolEnemy != (Object)null) ? 1 : 0) + (((Object)(object)_shotgunEnemy != (Object)null) ? 1 : 0);
			log.LogInfo((object)("Empress SuperHot Arena loaded " + num + " enemy prefab(s) and " + Clips.Count + " audio entries."));
		}

		public static void InitializeMusic(string pluginDirectory, ManualLogSource log)
		{
			if (_musicInitialized)
			{
				return;
			}
			_musicInitialized = true;
			string text = ResolveMusicBundlePath(pluginDirectory);
			if (text == null || !File.Exists(text))
			{
				log.LogWarning((object)"Empress SuperHot Arena music bundle (empresssuperhotarenamusic) not found beside DLL. Level will be silent.");
				return;
			}
			_musicBundle = AssetBundle.LoadFromFile(text);
			if ((Object)(object)_musicBundle == (Object)null)
			{
				log.LogWarning((object)("Empress SuperHot Arena could not load music bundle at " + text));
				return;
			}
			string[] allAssetNames = _musicBundle.GetAllAssetNames();
			foreach (string text2 in allAssetNames)
			{
				AudioClip val = _musicBundle.LoadAsset<AudioClip>(text2);
				if (!((Object)(object)val == (Object)null))
				{
					RegisterMusic(text2, val);
					RegisterMusic(Path.GetFileNameWithoutExtension(text2), val);
					RegisterMusic(((Object)val).name, val);
				}
			}
			log.LogInfo((object)("Empress SuperHot Arena loaded " + MusicClips.Count + " music entries."));
		}

		public static GameObject GetEnemyPrefab(int id)
		{
			if ((Object)(object)_shotgunEnemy != (Object)null && id % 4 == 3)
			{
				return _shotgunEnemy;
			}
			if ((Object)(object)_pistolEnemy != (Object)null)
			{
				return _pistolEnemy;
			}
			return _shotgunEnemy;
		}

		public static AudioClip GetClip(string name)
		{
			if (!Clips.TryGetValue(Key(name), out var value))
			{
				return null;
			}
			return value;
		}

		public static AudioClip GetMusicClip(string name)
		{
			if (!MusicClips.TryGetValue(Key(name), out var value))
			{
				return null;
			}
			return value;
		}

		public static void Play(string name, Vector3 position, float volume = 1f)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			AudioClip clip = GetClip(name);
			if (!((Object)(object)clip == (Object)null))
			{
				AudioSource.PlayClipAtPoint(clip, position, Mathf.Clamp01(volume));
			}
		}

		private static string ResolveBundlePath(string pluginDirectory)
		{
			string[] array = new string[3]
			{
				Path.Combine(pluginDirectory, "empresssuperhotassets"),
				Path.Combine(pluginDirectory ?? string.Empty, "SuperHot", "empresssuperhotassets"),
				Path.Combine(Path.GetDirectoryName(pluginDirectory) ?? pluginDirectory ?? string.Empty, "empresssuperhotassets")
			};
			for (int i = 0; i < array.Length; i++)
			{
				if (File.Exists(array[i]))
				{
					return array[i];
				}
			}
			return array[0];
		}

		private static string ResolveMusicBundlePath(string pluginDirectory)
		{
			string[] array = new string[3]
			{
				Path.Combine(pluginDirectory, "empresssuperhotarenamusic"),
				Path.Combine(pluginDirectory ?? string.Empty, "Music", "empresssuperhotarenamusic"),
				Path.Combine(Path.GetDirectoryName(pluginDirectory) ?? pluginDirectory ?? string.Empty, "empresssuperhotarenamusic")
			};
			for (int i = 0; i < array.Length; i++)
			{
				if (File.Exists(array[i]))
				{
					return array[i];
				}
			}
			return array[0];
		}

		private static void RegisterClip(string name, AudioClip clip)
		{
			string text = Key(name);
			if (!string.IsNullOrEmpty(text) && !Clips.ContainsKey(text))
			{
				Clips.Add(text, clip);
			}
		}

		private static void RegisterMusic(string name, AudioClip clip)
		{
			string text = Key(name);
			if (!string.IsNullOrEmpty(text) && !MusicClips.ContainsKey(text))
			{
				MusicClips.Add(text, clip);
			}
		}

		private static string Key(string name)
		{
			if (!string.IsNullOrEmpty(name))
			{
				return name.ToLowerInvariant().Replace("\\", "/").Replace(" ", "_")
					.Replace("-", "_");
			}
			return string.Empty;
		}
	}
	internal sealed class ArenaBullet : MonoBehaviour
	{
		private static Material _playerTracerMaterial;

		private static Material _enemyTracerMaterial;

		private Vector3 _direction;

		private Vector3 _targetPosition;

		private float _life;

		private float _speed;

		private int _damage;

		private bool _visualOnly;

		public static void FireTracer(Vector3 origin, Vector3 direction, Vector3 endPoint)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			ArenaBullet arenaBullet = CreateBullet(origin, direction, 0.1f, 0.28f, _playerTracerMaterial ?? (_playerTracerMaterial = CreateMaterial(Color.white)));
			arenaBullet._direction = ((Vector3)(ref direction)).normalized;
			arenaBullet._targetPosition = endPoint;
			arenaBullet._life = 1.4f;
			arenaBullet._speed = 48f;
			arenaBullet._visualOnly = true;
		}

		public static void FireDamaging(Vector3 origin, Vector3 direction, int damage)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			ArenaBullet arenaBullet = CreateBullet(origin, direction, 0.14f, 0.22f, _enemyTracerMaterial ?? (_enemyTracerMaterial = CreateMaterial(new Color(1f, 0.3f, 0.5f))));
			arenaBullet._direction = ((Vector3)(ref direction)).normalized;
			arenaBullet._life = 4f;
			arenaBullet._speed = 24f;
			arenaBullet._damage = damage;
			arenaBullet._visualOnly = false;
		}

		private void Update()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			if (_life <= 0f)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			if (_visualOnly)
			{
				float num = Mathf.Max(0.015f, _speed * Time.deltaTime);
				((Component)this).transform.position = Vector3.MoveTowards(((Component)this).transform.position, _targetPosition, num);
				if (Vector3.Distance(((Component)this).transform.position, _targetPosition) <= 0.05f)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
				}
				else
				{
					_life -= Time.deltaTime;
				}
				return;
			}
			float num2 = _speed * Time.deltaTime;
			int num3 = LayerMask.op_Implicit(SemiFunc.LayerMaskGetVisionObstruct()) | LayerMask.GetMask(new string[1] { "Player" });
			RaycastHit val = default(RaycastHit);
			if (Physics.SphereCast(((Component)this).transform.position, 0.08f, _direction, ref val, num2, num3, (QueryTriggerInteraction)1))
			{
				PlayerAvatar componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<PlayerAvatar>();
				if ((Object)(object)componentInParent != (Object)null && (Object)(object)componentInParent.playerHealth != (Object)null && !ArenaAccess.GetIsDisabled(componentInParent) && !ArenaAccess.GetDeadSet(componentInParent))
				{
					componentInParent.playerHealth.HurtOther(_damage, ((RaycastHit)(ref val)).point, false, -1, false);
				}
				((Component)this).transform.position = ((RaycastHit)(ref val)).point;
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
			else
			{
				Transform transform = ((Component)this).transform;
				transform.position += _direction * num2;
				_life -= Time.deltaTime;
			}
		}

		private static ArenaBullet CreateBullet(Vector3 origin, Vector3 direction, float radius, float trailTime, Material material)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)1);
			((Object)obj).name = "Empress Arena Bullet";
			obj.layer = 2;
			obj.transform.position = origin;
			obj.transform.rotation = Quaternion.LookRotation(((Vector3)(ref direction)).normalized, Vector3.up) * Quaternion.Euler(90f, 0f, 0f);
			obj.transform.localScale = new Vector3(radius, radius * 3.5f, radius);
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				component.enabled = false;
			}
			Renderer component2 = obj.GetComponent<Renderer>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.sharedMaterial = material;
			}
			TrailRenderer obj2 = obj.AddComponent<TrailRenderer>();
			obj2.time = trailTime;
			obj2.startWidth = radius * 1.1f;
			obj2.endWidth = 0f;
			((Renderer)obj2).sharedMaterial = material;
			return obj.AddComponent<ArenaBullet>();
		}

		private static Material CreateMaterial(Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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)
			Material val = new Material(Shader.Find("Standard"));
			val.color = color;
			if (val.HasProperty("_EmissionColor"))
			{
				val.EnableKeyword("_EMISSION");
				val.SetColor("_EmissionColor", color * 3.5f);
			}
			return val;
		}
	}
	internal enum EnemyKind : byte
	{
		Standard,
		Teleporter,
		Boss
	}
	internal sealed class ArenaEnemy : MonoBehaviour
	{
		private static Material _bodyMaterial;

		private static Material _accentMaterial;

		private static Material _faceMaterial;

		private static Material _deadMaterial;

		private int _health;

		private bool _dying;

		private float _deathTimer;

		private float _fireTimer;

		private float _pathRefreshTimer;

		private float _strafeTimer;

		private float _strafeSign;

		private float _stuckTimer;

		private float _reseatCooldown;

		private Vector3 _deathStartScale;

		private Vector3 _spawnPoint;

		private Vector3 _patrolTarget;

		private Vector3 _lastPosition;

		private Vector3 _remoteTargetPosition;

		private Quaternion _remoteTargetRotation;

		private bool _hasRemoteTarget;

		private bool _remoteAiming;

		private bool _remoteMoving;

		private bool _hasPatrolTarget;

		private bool _visualFromPrefab;

		private bool _wasAiming;

		private bool _remote;

		private EnemyKind _kind;

		private float _teleportTimer;

		private NavMeshAgent _agent;

		private NavMeshPath _path;

		private Renderer[] _renderers;

		private CapsuleCollider _hitCollider;

		private Transform _muzzle;

		private Animator _animator;

		public int Id { get; private set; }

		public bool Dead { get; private set; }

		public bool Remote => _remote;

		public EnemyKind Kind => _kind;

		public bool LastAiming { get; private set; }

		public bool LastMoving { get; private set; }

		public Vector3 AimPoint => ((Component)this).transform.position + Vector3.up * ((_kind == EnemyKind.Boss) ? 4.35f : 1.45f);

		public static ArenaEnemy Create(int id, EnemyKind kind, Vector3 position, Quaternion rotation, int health, Transform holder)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006c: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			if (!TryFindNearestNavMeshPoint(position, out var hit))
			{
				return null;
			}
			GameObject enemyPrefab = ArenaAssets.GetEnemyPrefab(id);
			GameObject val = new GameObject("Empress Arena Enemy " + id + " [" + kind.ToString() + "]");
			val.transform.SetParent(holder, false);
			val.transform.position = ((NavMeshHit)(ref hit)).position;
			val.transform.rotation = rotation;
			if (kind == EnemyKind.Boss)
			{
				val.transform.localScale = Vector3.one * 3f;
			}
			if ((Object)(object)enemyPrefab != (Object)null)
			{
				AttachPrefabVisual(enemyPrefab, val.transform);
			}
			ArenaEnemy arenaEnemy = val.AddComponent<ArenaEnemy>();
			arenaEnemy.Id = id;
			arenaEnemy._kind = kind;
			arenaEnemy._health = Mathf.Max(1, health);
			arenaEnemy._spawnPoint = ((NavMeshHit)(ref hit)).position;
			arenaEnemy._lastPosition = ((NavMeshHit)(ref hit)).position;
			arenaEnemy._visualFromPrefab = (Object)(object)enemyPrefab != (Object)null;
			arenaEnemy._teleportTimer = ((kind == EnemyKind.Teleporter) ? Random.Range(3.5f, 6f) : 0f);
			if ((Object)(object)enemyPrefab != (Object)null)
			{
				arenaEnemy.PreparePrefabVisual();
			}
			else
			{
				arenaEnemy.BuildProceduralVisual();
			}
			arenaEnemy.ApplyKindVisual();
			if (!arenaEnemy.ConfigureAgent(((NavMeshHit)(ref hit)).position))
			{
				Object.Destroy((Object)(object)val);
				return null;
			}
			arenaEnemy._fireTimer = Random.Range(0.6f, 1.8f);
			ArenaAssets.Play("enemy_spawn", ((NavMeshHit)(ref hit)).position, 0.7f);
			return arenaEnemy;
		}

		public static ArenaEnemy CreateRemote(int id, EnemyKind kind, Vector3 position, Quaternion rotation, Transform holder)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			GameObject enemyPrefab = ArenaAssets.GetEnemyPrefab(id);
			GameObject val = new GameObject("Empress Arena Enemy " + id + " [" + kind.ToString() + "] (Remote)");
			val.transform.SetParent(holder, false);
			val.transform.position = position;
			val.transform.rotation = rotation;
			if (kind == EnemyKind.Boss)
			{
				val.transform.localScale = Vector3.one * 3f;
			}
			if ((Object)(object)enemyPrefab != (Object)null)
			{
				AttachPrefabVisual(enemyPrefab, val.transform);
			}
			ArenaEnemy arenaEnemy = val.AddComponent<ArenaEnemy>();
			arenaEnemy.Id = id;
			arenaEnemy._kind = kind;
			arenaEnemy._remote = true;
			arenaEnemy._health = 1;
			arenaEnemy._spawnPoint = position;
			arenaEnemy._lastPosition = position;
			arenaEnemy._remoteTargetPosition = position;
			arenaEnemy._remoteTargetRotation = rotation;
			arenaEnemy._hasRemoteTarget = true;
			arenaEnemy._visualFromPrefab = (Object)(object)enemyPrefab != (Object)null;
			if ((Object)(object)enemyPrefab != (Object)null)
			{
				arenaEnemy.PreparePrefabVisual();
			}
			else
			{
				arenaEnemy.BuildProceduralVisual();
			}
			arenaEnemy.ApplyKindVisual();
			ArenaAssets.Play("enemy_spawn", position, 0.6f);
			return arenaEnemy;
		}

		private void ApplyKindVisual()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (_kind == EnemyKind.Teleporter)
			{
				ApplyTint(new Color(0.25f, 0.55f, 1f));
			}
		}

		private void ApplyTint(Color tint)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			if (_renderers == null)
			{
				return;
			}
			for (int i = 0; i < _renderers.Length; i++)
			{
				Renderer val = _renderers[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Material[] materials = val.materials;
				foreach (Material val2 in materials)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						val2.color = tint;
						if (val2.HasProperty("_EmissionColor"))
						{
							val2.EnableKeyword("_EMISSION");
							val2.SetColor("_EmissionColor", tint * 2.5f);
						}
					}
				}
				val.materials = materials;
			}
		}

		public void ApplyRemoteTransform(Vector3 position, Quaternion rotation, bool aiming, bool moving)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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)
			if (!Dead && !_dying)
			{
				if (Vector3.Distance(((Component)this).transform.position, position) > 4f)
				{
					((Component)this).transform.position = position;
					((Component)this).transform.rotation = rotation;
				}
				_remoteTargetPosition = position;
				_remoteTargetRotation = rotation;
				_remoteAiming = aiming;
				_remoteMoving = moving;
				_hasRemoteTarget = true;
			}
		}

		public void ApplyRemoteDeath(Vector3 direction)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!Dead)
			{
				Die(direction);
			}
		}

		private static void AttachPrefabVisual(GameObject prefab, Transform root)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			bool activeSelf = prefab.activeSelf;
			prefab.SetActive(false);
			GameObject obj = Object.Instantiate<GameObject>(prefab, root, false);
			prefab.SetActive(activeSelf);
			((Object)obj).name = ((Object)prefab).name;
			obj.transform.localPosition = Vector3.zero;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = Vector3.one;
			DisableImportedAgents(obj);
			obj.SetActive(true);
			LiftVisualToGround(obj);
		}

		private static void DisableImportedAgents(GameObject root)
		{
			MonoBehaviour[] componentsInChildren = root.GetComponentsInChildren<MonoBehaviour>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					((Behaviour)componentsInChildren[i]).enabled = false;
				}
			}
			NavMeshAgent[] componentsInChildren2 = root.GetComponentsInChildren<NavMeshAgent>(true);
			for (int j = 0; j < componentsInChildren2.Length; j++)
			{
				if ((Object)(object)componentsInChildren2[j] != (Object)null)
				{
					((Behaviour)componentsInChildren2[j]).enabled = false;
				}
			}
			NavMeshObstacle[] componentsInChildren3 = root.GetComponentsInChildren<NavMeshObstacle>(true);
			for (int k = 0; k < componentsInChildren3.Length; k++)
			{
				if ((Object)(object)componentsInChildren3[k] != (Object)null)
				{
					((Behaviour)componentsInChildren3[k]).enabled = false;
				}
			}
		}

		private static void LiftVisualToGround(GameObject visual)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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)
			Renderer[] componentsInChildren = visual.GetComponentsInChildren<Renderer>(true);
			if (componentsInChildren.Length == 0)
			{
				return;
			}
			Bounds bounds = componentsInChildren[0].bounds;
			for (int i = 1; i < componentsInChildren.Length; i++)
			{
				if ((Object)(object)componentsInChildren[i] != (Object)null)
				{
					((Bounds)(ref bounds)).Encapsulate(componentsInChildren[i].bounds);
				}
			}
			float num = (((Object)(object)visual.transform.parent != (Object)null) ? (visual.transform.parent.position.y + 0.02f) : 0.02f) - ((Bounds)(ref bounds)).min.y;
			if (Mathf.Abs(num) > 0.001f)
			{
				Transform transform = visual.transform;
				transform.position += Vector3.up * num;
			}
		}

		private void Update()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (_dying)
			{
				TickDeathAnimation();
			}
			else if (_remote && _hasRemoteTarget)
			{
				((Component)this).transform.position = Vector3.Lerp(((Component)this).transform.position, _remoteTargetPosition, Time.deltaTime * 12f);
				((Component)this).transform.rotation = Quaternion.RotateTowards(((Component)this).transform.rotation, _remoteTargetRotation, 540f * Time.deltaTime);
				Animate(_remoteAiming, _remoteMoving);
			}
		}

		private void TickDeathAnimation()
		{
			//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_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			_deathTimer += Time.unscaledDeltaTime;
			float num = Mathf.Clamp01(_deathTimer / 0.55f);
			float num2 = num * num * (3f - 2f * num);
			((Component)this).transform.localScale = Vector3.Lerp(_deathStartScale, Vector3.zero, num2);
			if (_renderers != null)
			{
				for (int i = 0; i < _renderers.Length; i++)
				{
					Renderer val = _renderers[i];
					if (!((Object)(object)val == (Object)null))
					{
						Material material = val.material;
						if ((Object)(object)material != (Object)null && material.HasProperty("_Color"))
						{
							material.color = Color.Lerp(material.color, Color.black, num2);
						}
					}
				}
			}
			if (num >= 1f)
			{
				((Component)this).gameObject.SetActive(false);
			}
		}

		public void TickCombat(float range)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (Dead || _dying || _remote || !EnsureAgentOnNavMesh())
			{
				return;
			}
			PlayerAvatar val = FindClosestTarget(range * 2f);
			Vector3 velocity;
			if ((Object)(object)val == (Object)null)
			{
				Patrol();
				int moving;
				if ((Object)(object)_agent != (Object)null)
				{
					velocity = _agent.velocity;
					moving = ((((Vector3)(ref velocity)).sqrMagnitude > 0.05f) ? 1 : 0);
				}
				else
				{
					moving = 0;
				}
				Animate(aiming: false, (byte)moving != 0);
				return;
			}
			Vector3 val2 = (((Component)val).transform.position - ((Component)this).transform.position).WithY(0f);
			float magnitude = ((Vector3)(ref val2)).magnitude;
			float num = ((_kind == EnemyKind.Boss) ? 3.4f : 1.6f);
			if (magnitude < num)
			{
				TouchPlayer(val);
				return;
			}
			MoveToward(((Component)val).transform.position);
			UpdateTeleport(val);
			FaceMovementDirection();
			int num2;
			if ((Object)(object)_agent != (Object)null)
			{
				velocity = _agent.velocity;
				num2 = ((((Vector3)(ref velocity)).sqrMagnitude > 0.05f) ? 1 : 0);
			}
			else
			{
				num2 = 0;
			}
			bool moving2 = (byte)num2 != 0;
			Animate(aiming: false, moving2);
		}

		private void UpdateTeleport(PlayerAvatar target)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			if (_kind != EnemyKind.Teleporter || (Object)(object)target == (Object)null || (Object)(object)_agent == (Object)null || !((Behaviour)_agent).isActiveAndEnabled || !_agent.isOnNavMesh)
			{
				return;
			}
			_teleportTimer -= Time.deltaTime;
			if (!(_teleportTimer > 0f))
			{
				_teleportTimer = Random.Range(4.5f, 8f);
				Vector2 insideUnitCircle = Random.insideUnitCircle;
				Vector2 val = ((Vector2)(ref insideUnitCircle)).normalized * Random.Range(5.5f, 10f);
				NavMeshHit val2 = default(NavMeshHit);
				if (NavMesh.SamplePosition(((Component)target).transform.position + new Vector3(val.x, 0f, val.y), ref val2, 4f, -1))
				{
					_agent.Warp(((NavMeshHit)(ref val2)).position);
					ArenaAssets.Play("crystal_hit", ((NavMeshHit)(ref val2)).position, 0.55f);
				}
			}
		}

		public void Hurt(int damage, Vector3 direction)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (Dead || _remote)
			{
				return;
			}
			_health -= Mathf.Max(1, damage);
			if (_health > 0)
			{
				ArenaAssets.Play("crystal_hit", ((Component)this).transform.position, 0.8f);
				return;
			}
			Die(direction);
			ArenaRuntime instance = ArenaRuntime.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.BroadcastEnemyDeath(this, direction);
			}
		}

		private void Die(Vector3 direction)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			Dead = true;
			_dying = true;
			_deathTimer = 0f;
			_deathStartScale = ((Component)this).transform.localScale;
			if ((Object)(object)_agent != (Object)null)
			{
				if (((Behaviour)_agent).isActiveAndEnabled && _agent.isOnNavMesh)
				{
					_agent.isStopped = true;
					_agent.ResetPath();
				}
				((Behaviour)_agent).enabled = false;
			}
			if ((Object)(object)_hitCollider != (Object)null)
			{
				((Collider)_hitCollider).enabled = false;
			}
			TriggerAnimator("death");
			ArenaAssets.Play("crystal_death", ((Component)this).transform.position);
			ArenaAssets.Play("crystal_crush", ((Component)this).transform.position, 0.7f);
			Vector3 val = direction.WithY(0f);
			if (((Vector3)(ref val)).sqrMagnitude > 0.001f)
			{
				Transform transform = ((Component)this).transform;
				transform.position += ((Vector3)(ref val)).normalized * 0.35f;
			}
			if (_renderers == null)
			{
				return;
			}
			for (int i = 0; i < _renderers.Length; i++)
			{
				if ((Object)(object)_renderers[i] != (Object)null)
				{
					_renderers[i].sharedMaterial = _deadMaterial;
				}
			}
		}

		private bool EnsureAgentOnNavMesh()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_agent != (Object)null && ((Behaviour)_agent).isActiveAndEnabled && _agent.isOnNavMesh)
			{
				return true;
			}
			_reseatCooldown -= Time.deltaTime;
			if (_reseatCooldown > 0f)
			{
				return false;
			}
			_reseatCooldown = 0.5f;
			return ConfigureAgent(((Component)this).transform.position);
		}

		private void MoveToward(Vector3 destination)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Invalid comparison between Unknown and I4
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_agent == (Object)null || !((Behaviour)_agent).isActiveAndEnabled || !_agent.isOnNavMesh)
			{
				return;
			}
			if (_path == null)
			{
				_path = new NavMeshPath();
			}
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(destination, ref val, 2.5f, -1))
			{
				return;
			}
			Vector3 position = ((NavMeshHit)(ref val)).position;
			_agent.speed = 2.85f;
			_agent.acceleration = 24f;
			_agent.angularSpeed = 720f;
			_agent.isStopped = false;
			_pathRefreshTimer -= Time.deltaTime;
			if (_pathRefreshTimer <= 0f || !_agent.hasPath || Vector3.Distance(_agent.destination, position) > 1f)
			{
				if (_agent.CalculatePath(position, _path) && (int)_path.status != 2)
				{
					_agent.SetPath(_path);
				}
				_pathRefreshTimer = 0.18f;
			}
			if (Vector3.Distance(((Component)this).transform.position, _lastPosition) < 0.01f * _agent.speed * Time.deltaTime)
			{
				_stuckTimer += Time.deltaTime;
			}
			else
			{
				_stuckTimer = 0f;
			}
			if (_stuckTimer > 1.5f)
			{
				_stuckTimer = 0f;
				NavMeshHit val2 = default(NavMeshHit);
				if (NavMesh.SamplePosition(((Component)this).transform.position, ref val2, 4f, -1))
				{
					_agent.Warp(((NavMeshHit)(ref val2)).position);
				}
			}
			_lastPosition = ((Component)this).transform.position;
		}

		private void StrafeAround(PlayerAvatar target)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null || (Object)(object)_agent == (Object)null || !((Behaviour)_agent).isActiveAndEnabled || !_agent.isOnNavMesh)
			{
				return;
			}
			_strafeTimer -= Time.deltaTime;
			if (_strafeTimer <= 0f)
			{
				_strafeTimer = Random.Range(1.4f, 2.6f);
				_strafeSign = ((Random.value < 0.5f) ? (-1f) : 1f);
			}
			Vector3 val = (((Component)target).transform.position - ((Component)this).transform.position).WithY(0f);
			if (((Vector3)(ref val)).sqrMagnitude < 0.001f)
			{
				return;
			}
			Vector3 val2 = Vector3.Cross(Vector3.up, ((Vector3)(ref val)).normalized);
			NavMeshHit val3 = default(NavMeshHit);
			if (NavMesh.SamplePosition(((Component)this).transform.position + val2 * _strafeSign * 2.5f, ref val3, 1.5f, -1))
			{
				_agent.isStopped = false;
				_agent.speed = 1.85f;
				if (_pathRefreshTimer <= 0f || Vector3.Distance(_agent.destination, ((NavMeshHit)(ref val3)).position) > 0.5f)
				{
					_agent.SetDestination(((NavMeshHit)(ref val3)).position);
					_pathRefreshTimer = 0.2f;
				}
			}
		}

		private void Patrol()
		{
			//IL_007b: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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)
			if (!((Object)(object)_agent == (Object)null) && ((Behaviour)_agent).isActiveAndEnabled && _agent.isOnNavMesh)
			{
				_agent.speed = 1.4f;
				_agent.angularSpeed = 360f;
				_agent.isStopped = false;
				NavMeshHit val = default(NavMeshHit);
				if ((!_hasPatrolTarget || Vector3.Distance(((Component)this).transform.position, _patrolTarget) < 1.2f) && NavMesh.SamplePosition(_spawnPoint + new Vector3(Random.Range(-4.5f, 4.5f), 0f, Random.Range(-4.5f, 4.5f)), ref val, 2f, -1))
				{
					_patrolTarget = ((NavMeshHit)(ref val)).position;
					_hasPatrolTarget = true;
					_agent.SetDestination(_patrolTarget);
				}
				FaceMovementDirection();
			}
		}

		private void TouchPlayer(PlayerAvatar target)
		{
			//IL_0056: 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)
			if (!((Object)(object)target == (Object)null) && !((Object)(object)target.playerHealth == (Object)null) && !ArenaAccess.GetIsDisabled(target) && !ArenaAccess.GetDeadSet(target))
			{
				int num = ((EmpressSuperHotArenaPlugin.Settings != null) ? Mathf.Max(1, EmpressSuperHotArenaPlugin.Settings.EnemyTouchDamage.Value) : 10);
				target.playerHealth.HurtOther(num, ((Component)target).transform.position, false, -1, false);
				Hurt(999, ((Component)this).transform.forward);
			}
		}

		private void FaceMovementDirection()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_agent == (Object)null) && ((Behaviour)_agent).isActiveAndEnabled && _agent.isOnNavMesh)
			{
				Vector3 val = _agent.desiredVelocity.WithY(0f);
				if (((Vector3)(ref val)).sqrMagnitude < 0.01f && _agent.hasPath)
				{
					val = (_agent.steeringTarget - ((Component)this).transform.position).WithY(0f);
				}
				if (!(((Vector3)(ref val)).sqrMagnitude < 0.01f))
				{
					Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
					((Component)this).transform.rotation = Quaternion.RotateTowards(((Component)this).transform.rotation, val2, 360f * Time.deltaTime);
				}
			}
		}

		private PlayerAvatar FindClosestTarget(float range)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			foreach (PlayerAvatar item in SemiFunc.PlayerGetList())
			{
				if (!((Object)(object)item == (Object)null) && !ArenaAccess.GetIsDisabled(item) && !ArenaAccess.GetDeadSet(item))
				{
					list.Add(item);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			PlayerAvatar val = list[Mathf.Abs(Id) % list.Count];
			if (Vector3.Distance(((Component)this).transform.position, ((Component)val).transform.position) <= range)
			{
				return val;
			}
			PlayerAvatar result = null;
			float num = range;
			for (int i = 0; i < list.Count; i++)
			{
				float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)list[i]).transform.position);
				if (num2 < num)
				{
					result = list[i];
					num = num2;
				}
			}
			return result;
		}

		private bool ConfigureAgent(Vector3 anchor)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01cd: 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)
			if (!TryFindNearestNavMeshPoint(anchor, out var hit))
			{
				return false;
			}
			_agent = ((Component)this).GetComponent<NavMeshAgent>();
			if ((Object)(object)_agent == (Object)null)
			{
				_agent = ((Component)this).gameObject.AddComponent<NavMeshAgent>();
			}
			float num = ((_kind == EnemyKind.Boss) ? 3f : 1f);
			float speed = ((_kind == EnemyKind.Boss) ? 1.6f : 2.4f);
			float num2 = ((_kind == EnemyKind.Boss) ? 3.4f : 1.6f);
			_agent.speed = speed;
			_agent.acceleration = 24f;
			_agent.angularSpeed = 480f;
			_agent.stoppingDistance = Mathf.Max(0.4f, num2 - 0.6f);
			_agent.radius = 0.45f * num;
			_agent.height = 2.05f * num;
			_agent.baseOffset = 0f;
			_agent.updatePosition = true;
			_agent.updateRotation = false;
			_agent.updateUpAxis = false;
			_agent.autoBraking = true;
			_agent.autoRepath = true;
			_agent.autoTraverseOffMeshLink = true;
			_agent.obstacleAvoidanceType = (ObstacleAvoidanceType)4;
			_agent.avoidancePriority = 50 + Id % 10;
			((Component)this).transform.position = ((NavMeshHit)(ref hit)).position;
			if (!((Behaviour)_agent).enabled)
			{
				((Behaviour)_agent).enabled = true;
			}
			if (!_agent.Warp(((NavMeshHit)(ref hit)).position))
			{
				return false;
			}
			if (!_agent.isOnNavMesh)
			{
				return false;
			}
			_path = new NavMeshPath();
			_pathRefreshTimer = 0f;
			_lastPosition = ((Component)this).transform.position;
			return true;
		}

		private void PreparePrefabVisual()
		{
			int layer = LayerMask.NameToLayer("Enemy");
			SetLayerRecursive(((Component)this).gameObject, layer);
			Rigidbody val = ((Component)this).GetComponent<Rigidbody>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)this).gameObject.AddComponent<Rigidbody>();
			}
			val.isKinematic = true;
			val.useGravity = false;
			EnsureHitCollider();
			_animator = ((Component)this).GetComponentInChildren<Animator>(true);
			if ((Object)(object)_animator != (Object)null)
			{
				((Behaviour)_animator).enabled = true;
				_animator.speed = 1f;
				_animator.applyRootMotion = false;
				_animator.cullingMode = (AnimatorCullingMode)0;
				_animator.updateMode = (AnimatorUpdateMode)0;
				_animator.Rebind();
				_animator.Update(0f);
			}
			_muzzle = FindChildByName(((Component)this).transform, "Muzzle");
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < _renderers.Length; i++)
			{
				if ((Object)(object)_renderers[i] != (Object)null)
				{
					_renderers[i].enabled = true;
				}
			}
		}

		private void BuildProceduralVisual()
		{
			//IL_0050: 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_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: 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_0257: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			EnsureMaterials();
			int layer = LayerMask.NameToLayer("Enemy");
			SetLayerRecursive(((Component)this).gameObject, layer);
			Rigidbody obj = ((Component)this).gameObject.AddComponent<Rigidbody>();
			obj.isKinematic = true;
			obj.useGravity = false;
			EnsureHitCollider();
			AddPart("Body", (PrimitiveType)1, new Vector3(0f, 1f, 0f), new Vector3(0.6f, 0.95f, 0.6f), _bodyMaterial, layer);
			AddPart("Head", (PrimitiveType)0, new Vector3(0f, 1.7f, 0f), new Vector3(0.46f, 0.46f, 0.46f), _bodyMaterial, layer);
			AddPart("Visor", (PrimitiveType)3, new Vector3(0f, 1.72f, 0.22f), new Vector3(0.34f, 0.1f, 0.05f), _faceMaterial, layer);
			AddPart("Chest Light", (PrimitiveType)3, new Vector3(0f, 1.15f, 0.28f), new Vector3(0.22f, 0.22f, 0.04f), _accentMaterial, layer);
			AddPart("Left Arm", (PrimitiveType)1, new Vector3(-0.46f, 1.15f, 0.14f), new Vector3(0.2f, 0.6f, 0.2f), _bodyMaterial, layer).transform.localRotation = Quaternion.Euler(72f, 0f, 18f);
			AddPart("Right Arm", (PrimitiveType)1, new Vector3(0.46f, 1.15f, 0.14f), new Vector3(0.2f, 0.6f, 0.2f), _bodyMaterial, layer).transform.localRotation = Quaternion.Euler(72f, 0f, -18f);
			AddPart("Left Leg", (PrimitiveType)1, new Vector3(-0.2f, 0.32f, 0f), new Vector3(0.22f, 0.68f, 0.22f), _bodyMaterial, layer);
			AddPart("Right Leg", (PrimitiveType)1, new Vector3(0.2f, 0.32f, 0f), new Vector3(0.22f, 0.68f, 0.22f), _bodyMaterial, layer);
			GameObject val = new GameObject("Muzzle");
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = new Vector3(0.36f, 1.18f, 0.42f);
			val.transform.localRotation = Quaternion.identity;
			_muzzle = val.transform;
			_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
		}

		private void EnsureHitCollider()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			_hitCollider = ((Component)this).GetComponent<CapsuleCollider>();
			if ((Object)(object)_hitCollider == (Object)null)
			{
				_hitCollider = ((Component)this).gameObject.AddComponent<CapsuleCollider>();
			}
			_hitCollider.center = new Vector3(0f, 0.95f, 0f);
			_hitCollider.height = 1.95f;
			_hitCollider.radius = 0.42f;
			((Collider)_hitCollider).isTrigger = false;
			((Collider)_hitCollider).enabled = true;
		}

		private GameObject AddPart(string name, PrimitiveType type, Vector3 localPosition, Vector3 localScale, Material material, int layer)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive(type);
			((Object)val).name = name;
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = localPosition;
			val.transform.localScale = localScale;
			if (layer >= 0)
			{
				val.layer = layer;
			}
			Collider component = val.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			Renderer component2 = val.GetComponent<Renderer>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)material != (Object)null)
			{
				component2.sharedMaterial = material;
			}
			return val;
		}

		private void Animate(bool aiming, bool moving)
		{
			LastAiming = aiming;
			LastMoving = moving;
			if (!((Object)(object)_animator == (Object)null))
			{
				if (aiming && !_wasAiming)
				{
					TriggerAnimator("EnterAttack");
				}
				_wasAiming = aiming;
				SetAnimatorBool("InstantSwitchToAim", aiming);
				SetAnimatorFloat("Velocity", moving ? 1f : 0f);
				SetAnimatorFloat("Speed", moving ? 1.6f : 0f);
				SetAnimatorFloat("Direction", 0f);
				SetAnimatorFloat("Rotation", 0f);
				SetAnimatorFloat("AimMoveAngle", 0f);
				SetAnimatorFloat("ShootSpeedup", Mathf.Lerp(1f, 1.4f, Mathf.Clamp01(Time.timeScale)));
			}
		}

		private void SetAnimatorFloat(string name, float value)
		{
			if ((Object)(object)_animator != (Object)null && HasParameter(name, (AnimatorControllerParameterType)1))
			{
				_animator.SetFloat(name, value);
			}
		}

		private void SetAnimatorBool(string name, bool value)
		{
			if ((Object)(object)_animator != (Object)null && HasParameter(name, (AnimatorControllerParameterType)4))
			{
				_animator.SetBool(name, value);
			}
		}

		private void TriggerAnimator(string name)
		{
			if ((Object)(object)_animator != (Object)null && HasParameter(name, (AnimatorControllerParameterType)9))
			{
				_animator.SetTrigger(name);
			}
		}

		private bool HasParameter(string name, AnimatorControllerParameterType type)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_animator == (Object)null || (Object)(object)_animator.runtimeAnimatorController == (Object)null)
			{
				return false;
			}
			AnimatorControllerParameter[] parameters = _animator.parameters;
			foreach (AnimatorControllerParameter val in parameters)
			{
				if (val.name == name && val.type == type)
				{
					return true;
				}
			}
			return false;
		}

		private static Transform FindChildByName(Transform root, string name)
		{
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				if (((Object)componentsInChildren[i]).name == name)
				{
					return componentsInChildren[i];
				}
			}
			return null;
		}

		private static void SetLayerRecursive(GameObject root, int layer)
		{
			if (layer >= 0)
			{
				Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					((Component)componentsInChildren[i]).gameObject.layer = layer;
				}
			}
		}

		private static bool TryFindNearestNavMeshPoint(Vector3 position, out NavMeshHit hit)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			float[] array = new float[5] { 4f, 8f, 16f, 32f, 64f };
			for (int i = 0; i < array.Length; i++)
			{
				if (NavMesh.SamplePosition(position, ref hit, array[i], -1))
				{
					return true;
				}
			}
			hit = default(NavMeshHit);
			return false;
		}

		private static void EnsureMaterials()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Expected O, but got Unknown
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_bodyMaterial != (Object)null))
			{
				Shader obj = Shader.Find("Standard");
				_bodyMaterial = new Material(obj);
				_bodyMaterial.color = new Color(0.04f, 0.05f, 0.08f);
				if (_bodyMaterial.HasProperty("_Metallic"))
				{
					_bodyMaterial.SetFloat("_Metallic", 0.6f);
				}
				if (_bodyMaterial.HasProperty("_Glossiness"))
				{
					_bodyMaterial.SetFloat("_Glossiness", 0.65f);
				}
				if (_bodyMaterial.HasProperty("_EmissionColor"))
				{
					_bodyMaterial.EnableKeyword("_EMISSION");
					_bodyMaterial.SetColor("_EmissionColor", new Color(0.05f, 0.18f, 0.32f) * 0.8f);
				}
				_accentMaterial = new Material(obj);
				_accentMaterial.color = new Color(1f, 0.18f, 0.35f);
				if (_accentMaterial.HasProperty("_EmissionColor"))
				{
					_accentMaterial.EnableKeyword("_EMISSION");
					_accentMaterial.SetColor("_EmissionColor", new Color(1f, 0.3f, 0.5f) * 3.2f);
				}
				_faceMaterial = new Material(obj);
				_faceMaterial.color = new Color(0.12f, 0.85f, 1f);
				if (_faceMaterial.HasProperty("_EmissionColor"))
				{
					_faceMaterial.EnableKeyword("_EMISSION");
					_faceMaterial.SetColor("_EmissionColor", new Color(0.32f, 0.95f, 1f) * 3.6f);
				}
				_deadMaterial = new Material(obj);
				_deadMaterial.color = Color.black;
			}
		}
	}
	internal static class VectorExtensions
	{
		public static Vector3 WithY(this Vector3 value, float y)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			value.y = y;
			return value;
		}
	}
	internal static class ArenaLevelRegistry
	{
		private static readonly FieldRef<LevelContent, Level> LevelContentLevelRef = AccessTools.FieldRefAccess<LevelContent, Level>("_level");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentStartRoomsRef = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_startRooms");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesNormal1Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesNormal1");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesNormal2Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesNormal2");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesNormal3Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesNormal3");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesPassage1Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesPassage1");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesPassage2Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesPassage2");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesPassage3Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesPassage3");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesDeadEnd1Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesDeadEnd1");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesDeadEnd2Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesDeadEnd2");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesDeadEnd3Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesDeadEnd3");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesExtraction1Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesExtraction1");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesExtraction2Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesExtraction2");

		private static readonly FieldRef<LevelContent, List<GameObject>> LevelContentModulesExtraction3Ref = AccessTools.FieldRefAccess<LevelContent, List<GameObject>>("_modulesExtraction3");

		private static readonly FieldRef<LevelContent, GameObject> LevelContentConnectObjectRef = AccessTools.FieldRefAccess<LevelContent, GameObject>("_connectObject");

		private static readonly FieldRef<LevelContent, GameObject> LevelContentBlockObjectRef = AccessTools.FieldRefAccess<LevelContent, GameObject>("_blockObject");

		public static Level RegisterArenaLevel()
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			Level val = ScriptableObject.CreateInstance<Level>();
			((Object)val).name = "Level - Empress SuperHot Arena";
			val.NarrativeName = "Empress SuperHot Arena";
			LevelValuables val2 = ScriptableObject.CreateInstance<LevelValuables>();
			((Object)val2).name = "Valuables - Empress SuperHot Arena";
			val2.tiny = new List<PrefabRef>();
			val2.small = new List<PrefabRef>();
			val2.medium = new List<PrefabRef>();
			val2.big = new List<PrefabRef>();
			val2.wide = new List<PrefabRef>();
			val2.tall = new List<PrefabRef>();
			val2.veryTall = new List<PrefabRef>();
			SetLevelField(val, "ModuleAmount", 0);
			SetLevelField(val, "PassageMaxAmount", 0);
			SetLevelField(val, "HasEnemies", false);
			SetLevelField(val, "ValuablePresets", new List<LevelValuables> { val2 });
			SetLevelField(val, "AmbiencePresets", new List<LevelAmbience>());
			SetLevelField(val, "FogColor", (object)new Color(0.015f, 0.03f, 0.06f));
			SetLevelField(val, "FogStartDistance", 5f);
			SetLevelField(val, "FogEndDistance", 70f);
			SetLevelField(val, "AmbientColor", (object)new Color(0.05f, 0.18f, 0.27f));
			SetLevelField(val, "AmbientColorAdaptation", (object)new Color(0.02f, 0.06f, 0.11f));
			SetLevelField(val, "ColorTemperature", -8f);
			SetLevelField(val, "ColorFilter", (object)new Color(0.78f, 0.95f, 1f, 1f));
			SetLevelField(val, "BloomIntensity", 6.5f);
			SetLevelField(val, "BloomThreshold", 0.78f);
			SetLevelField(val, "VignetteColor", (object)new Color(0.01f, 0.03f, 0.06f, 1f));
			SetLevelField(val, "VignetteIntensity", 0.32f);
			SetLevelField(val, "VignetteSmoothness", 0.78f);
			SetLevelField(val, "DiscordIcon", "level");
			EnsureLevelFieldInstance(val, "LoadingGraphic01");
			EnsureLevelFieldInstance(val, "LoadingGraphic02");
			EnsureLevelFieldInstance(val, "LoadingGraphic03");
			EnsureLevelFieldInstance(val, "ConnectObject");
			EnsureLevelFieldInstance(val, "BlockObject");
			LevelContent val3 = ScriptableObject.CreateInstance<LevelContent>();
			((Object)val3).name = "Empress SuperHot Arena Content";
			LevelContentLevelRef.Invoke(val3) = val;
			LevelContentStartRoomsRef.Invoke(val3) = new List<GameObject>();
			LevelContentModulesNormal1Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesNormal2Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesNormal3Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesPassage1Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesPassage2Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesPassage3Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesDeadEnd1Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesDeadEnd2Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesDeadEnd3Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesExtraction1Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesExtraction2Ref.Invoke(val3) = new List<GameObject>();
			LevelContentModulesExtraction3Ref.Invoke(val3) = new List<GameObject>();
			LevelContentConnectObjectRef.Invoke(val3) = null;
			LevelContentBlockObjectRef.Invoke(val3) = null;
			Levels.RegisterLevel(val3);
			return val;
		}

		private static void SetLevelField(Level level, string fieldName, object value)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(Level), fieldName);
			if (!(fieldInfo == null) && value != null && fieldInfo.FieldType.IsInstanceOfType(value))
			{
				fieldInfo.SetValue(level, value);
			}
		}

		private static void EnsureLevelFieldInstance(Level level, string fieldName)
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(Level), fieldName);
			if (!(fieldInfo == null) && fieldInfo.FieldType.IsClass && !(fieldInfo.FieldType == typeof(string)) && fieldInfo.GetValue(level) == null)
			{
				object uninitializedObject = FormatterServices.GetUninitializedObject(fieldInfo.FieldType);
				fieldInfo.SetValue(level, uninitializedObject);
			}
		}
	}
	[HarmonyPatch(typeof(RunManager), "SetRunLevel")]
	internal static class ArenaPatchRunManagerSetRunLevel
	{
		private static void Postfix(RunManager __instance)
		{
			if (EmpressSuperHotArenaPlugin.Settings != null && EmpressSuperHotArenaPlugin.Settings.ForceArenaLevel.Value && !((Object)(object)EmpressSuperHotArenaPlugin.ArenaLevel == (Object)null))
			{
				__instance.levelCurrent = EmpressSuperHotArenaPlugin.ArenaLevel;
			}
		}
	}
	[HarmonyPatch(typeof(LevelGenerator), "Generate")]
	internal static class ArenaPatchLevelGeneratorGenerate
	{
		private static bool Prefix(LevelGenerator __instance, ref IEnumerator __result)
		{
			if (!EmpressSuperHotArenaPlugin.IsArenaLevel(Object.op_Implicit((Object)(object)RunManager.instance) ? RunManager.instance.levelCurrent : null))
			{
				return true;
			}
			__result = ArenaRuntime.EnsureHost().GenerateArenaLevel(__instance);
			return false;
		}
	}
	[HarmonyPatch(typeof(LevelPoint), "NavMeshCheck")]
	internal static class ArenaPatchLevelPointNavMeshCheck
	{
		private static bool Prefix(ref IEnumerator __result)
		{
			if (!EmpressSuperHotArenaPlugin.IsArenaLevel(Object.op_Implicit((Object)(object)RunManager.instance) ? RunManager.instance.levelCurrent : null))
			{
				return true;
			}
			__result = ArenaRuntime.EmptyCoroutine();
			return false;
		}
	}
	[HarmonyPatch(typeof(EnvironmentDirector), "Setup")]
	internal static class ArenaPatchEnvironmentDirectorSetup
	{
		private static bool Prefix(EnvironmentDirector __instance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)LevelGenerator.Instance))
			{
				return true;
			}
			Level level = LevelGenerator.Instance.Level;
			if (!Object.op_Implicit((Object)(object)level) || !EmpressSuperHotArenaPlugin.IsArenaLevel(level))
			{
				return true;
			}
			ArenaAccess.SetEnvironmentFog(__instance, level.FogColor, level.FogStartDistance, level.FogEndDistance);
			ArenaAccess.SetEnvironmentAmbient(__instance, level.AmbientColor, level.AmbientColorAdaptation);
			RenderSettings.fogColor = level.FogColor;
			RenderSettings.fogStartDistance = level.FogStartDistance;
			RenderSettings.fogEndDistance = level.FogEndDistance;
			RenderSettings.ambientLight = level.AmbientColor;
			Camera val = ArenaAccess.GetEnvironmentMainCamera(__instance);
			if (!Object.op_Implicit((Object)(object)val))
			{
				val = Camera.main;
				ArenaAccess.SetEnvironmentMainCamera(__instance, val);
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				val.backgroundColor = RenderSettings.fogColor;
				val.farClipPlane = RenderSettings.fogEndDistance + 4f;
			}
			ArenaAccess.SetEnvironmentDarkAdaptation(__instance, 0.1f);
			ArenaAccess.SetEnvironmentSetupDone(__instance, value: true);
			return false;
		}
	}
	[HarmonyPatch(typeof(LoadingUI), "LevelAnimationStart")]
	internal static class ArenaPatchLoadingUiLevelAnimationStart
	{
		private static void Postfix(LoadingUI __instance)
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (EmpressSuperHotArenaPlugin.IsArenaLevel(Object.op_Implicit((Object)(object)LevelGenerator.Instance) ? LevelGenerator.Instance.Level : null))
			{
				if ((Object)(object)__instance.levelNumberText != (Object)null)
				{
					((TMP_Text)__instance.levelNumberText).text = "LEVEL " + ((!((Object)(object)RunManager.instance != (Object)null)) ? 1 : (RunManager.instance.levelsCompleted + 1));
					((Graphic)__instance.levelNumberText).color = new Color(0.36f, 0.94f, 1f);
					((Component)__instance.levelNumberText).gameObject.SetActive(true);
					((TMP_Text)__instance.levelNumberText).transform.SetAsLastSibling();
				}
				if ((Object)(object)__instance.levelNameText != (Object)null)
				{
					((TMP_Text)__instance.levelNameText).text = "Empress SuperHot Arena";
					((Graphic)__instance.levelNameText).color = new Color(1f, 0.4f, 0.55f);
					((Component)__instance.levelNameText).gameObject.SetActive(true);
					((TMP_Text)__instance.levelNameText).transform.SetAsLastSibling();
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemGun), "Shoot")]
	internal static class ArenaPatchItemGunShoot
	{
		private static void Postfix(ItemGun __instance, bool __result)
		{
			if (__result)
			{
				ArenaRuntime instance = ArenaRuntime.Instance;
				if ((Object)(object)instance != (Object)null && instance.Active)
				{
					instance.HandlePlayerShot(__instance);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemManager), "TurnOffIconLights")]
	internal static class ArenaPatchItemManagerTurnOffIconLights
	{
		private static bool Prefix(ItemManager __instance, ref IEnumerator __result)
		{
			if (!EmpressSuperHotArenaPlugin.IsArenaLevel(Object.op_Implicit((Object)(object)RunManager.instance) ? RunManager.instance.levelCurrent : null))
			{
				return true;
			}
			__result = SafeTurnOffIconLights(__instance);
			return false;
		}

		private static IEnumerator SafeTurnOffIconLights(ItemManager itemManager)
		{
			if ((Object)(object)itemManager.itemIconLights == (Object)null)
			{
				yield break;
			}
			if (SemiFunc.RunIsShop() || SemiFunc.MenuLevel())
			{
				itemManager.itemIconLights.SetActive(false);
				yield break;
			}
			while ((Object)(object)LevelGenerator.Instance == (Object)null || !LevelGenerator.Instance.Generated)
			{
				yield return (object)new WaitForSeconds(0.2f);
			}
			while (itemManager.spawnedItems != null)
			{
				itemManager.spawnedItems.RemoveAll((ItemAttributes item) => (Object)(object)item == (Object)null);
				bool flag = false;
				for (int i = 0; i < itemManager.spawnedItems.Count; i++)
				{
					ItemAttributes val = itemManager.spawnedItems[i];
					if ((Object)(object)val != (Object)null && !ArenaAccess.GetItemHasIcon(val))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.2f);
			}
			itemManager.itemIconLights.SetActive(false);
		}
	}
	internal sealed class ArenaRuntime : MonoBehaviour
	{
		private const float ArenaWidth = 36f;

		private const float ArenaDepth = 36f;

		private const float ArenaHeight = 8f;

		private const float WallThickness = 0.8f;

		private const float FloorThickness = 0.6f;

		private readonly List<ArenaEnemy> _enemies = new List<ArenaEnemy>();

		private readonly Dictionary<int, ArenaEnemy> _enemyById = new Dictionary<int, ArenaEnemy>();

		private readonly List<Vector3> _enemySpawnAnchors = new List<Vector3>();

		private readonly List<Light> _arenaLights = new List<Light>();

		private readonly ArenaWeaponService _weaponService = new ArenaWeaponService();

		private int _spawnToken;

		private float _transformBroadcastTimer;

		private AudioSource _musicSource;

		private Transform _arenaRoot;

		private Transform _enemyHolder;

		private Vector3 _playerSpawnAnchor;

		private bool _active;

		private bool _cleared;

		private float _exitTimer;

		private int _sceneHandle = -1;

		private LevelGenerator _generator;

		private int _arenaLevelNumber;

		private readonly Dictionary<int, int> _gunAssignments = new Dictionary<int, int>();

		private PhysGrabObject _localGun;

		private float _grabRetryTimer;

		public static ArenaRuntime Instance { get; private set; }

		public bool Active => _active;

		public static ArenaRuntime EnsureHost()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance;
			}
			GameObject val = new GameObject("Empress SuperHot Arena Runtime");
			val.transform.parent = null;
			((Object)val).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)val);
			Instance = val.AddComponent<ArenaRuntime>();
			return Instance;
		}

		public static IEnumerator EmptyCoroutine()
		{
			yield break;
		}

		private void Awake()
		{
			Instance = this;
			EnsureMusicSource();
		}

		private void EnsureMusicSource()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			if (!((Object)(object)_musicSource != (Object)null))
			{
				GameObject val = new GameObject("Empress Arena Music");
				val.transform.SetParent(((Component)this).transform, false);
				_musicSource = val.AddComponent<AudioSource>();
				_musicSource.playOnAwake = false;
				_musicSource.loop = true;
				_musicSource.spatialBlend = 0f;
				_musicSource.volume = 0.3f;
				_musicSource.priority = 0;
			}
		}

		private void StartMusic()
		{
			EnsureMusicSource();
			if ((Object)(object)_musicSource == (Object)null)
			{
				return;
			}
			AudioClip val = ArenaAssets.GetMusicClip("UwU") ?? ArenaAssets.GetMusicClip("uwu");
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)_musicSource.clip != (Object)(object)val)
				{
					_musicSource.clip = val;
				}
				_musicSource.volume = 0.3f;
				if (!_musicSource.isPlaying)
				{
					_musicSource.Play();
				}
			}
		}

		private void StopMusic()
		{
			if ((Object)(object)_musicSource != (Object)null && _musicSource.isPlaying)
			{
				_musicSource.Stop();
			}
		}

		private void Update()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			HandleSceneTransition();
			if (!_active)
			{
				return;
			}
			if (!EmpressSuperHotArenaPlugin.IsArenaLevel(Object.op_Implicit((Object)(object)RunManager.instance) ? RunManager.instance.levelCurrent : null))
			{
				Deactivate();
				return;
			}
			if ((Object)(object)LevelGenerator.Instance != (Object)null && LevelGenerator.Instance.Generated && (Object)(object)GameDirector.instance != (Object)null && (int)GameDirector.instance.currentState == 2 && IsLoadingFinished() && ArenaAccess.GetAllPlayersReady(LevelGenerator.Instance))
			{
				UpdateEnemies();
				_weaponService.Update();
				MaybeBroadcastTransforms();
				TryGrabLocalGun();
			}
			CheckClear();
			AdvanceAfterClear();
		}

		private void LateUpdate()
		{
			if (_active && Time.timeScale != 1f)
			{
				Time.timeScale = 1f;
			}
		}

		private bool IsLoadingFinished()
		{
			LoadingUI instance = LoadingUI.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			if (((Component)instance).gameObject.activeInHierarchy)
			{
				return false;
			}
			return ArenaAccess.GetLevelAnimationCompleted(instance);
		}

		public void HandlePlayerShot(ItemGun gun)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			if (!_active || (Object)(object)gun == (Object)null)
			{
				return;
			}
			Transform obj = (((Object)(object)gun.gunMuzzle != (Object)null) ? gun.gunMuzzle : ((Component)gun).transform);
			Vector3 position = obj.position;
			Vector3 val = obj.forward;
			if (((Vector3)(ref val)).sqrMagnitude <= 0.001f)
			{
				val = Vector3.forward;
			}
			val = ((Vector3)(ref val)).normalized;
			float num = Mathf.Max(10f, gun.gunRange);
			int num2 = LayerMask.op_Implicit(SemiFunc.LayerMaskGetVisionObstruct());
			float num3 = num;
			RaycastHit val2 = default(RaycastHit);
			if (Physics.Raycast(position, val, ref val2, num, num2, (QueryTriggerInteraction)1))
			{
				num3 = ((RaycastHit)(ref val2)).distance;
			}
			int num4 = LayerMask.NameToLayer("Enemy");
			int num5 = ((num4 >= 0) ? (1 << num4) : 0);
			ArenaEnemy arenaEnemy = null;
			float num6 = num3;
			RaycastHit val3 = default(RaycastHit);
			if (num5 != 0 && Physics.Raycast(position, val, ref val3, num3, num5, (QueryTriggerInteraction)1))
			{
				ArenaEnemy componentInParent = ((Component)((RaycastHit)(ref val3)).collider).GetComponentInParent<ArenaEnemy>();
				if ((Object)(object)componentInParent != (Object)null && !componentInParent.Dead)
				{
					arenaEnemy = componentInParent;
					num6 = ((RaycastHit)(ref val3)).distance;
				}
			}
			Vector3 val4 = position + val * (((Object)(object)arenaEnemy != (Object)null) ? num6 : num3);
			if ((Object)(object)arenaEnemy != (Object)null)
			{
				if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					arenaEnemy.Hurt(999, val);
				}
				else
				{
					RequestEnemyHit(arenaEnemy.Id, val);
				}
			}
			Vector3 val5 = val4 - position;
			ArenaBullet.FireTracer(position, ((Vector3)(ref val5)).normalized, val4);
		}

		public IEnumerator GenerateArenaLevel(LevelGenerator generator)
		{
			_generator = generator;
			EmpressSuperHotArenaPlugin.EnsurePhotonEventHooked();
			yield return (object)new WaitForSeconds(0.2f);
			if (!SemiFunc.IsMultiplayer())
			{
				ArenaAccess.SetAllPlayersReady(generator, value: true);
			}
			while (!ArenaAccess.GetAllPlayersReady(generator))
			{
				generator.State = (LevelState)1;
				yield return (object)new WaitForSeconds(0.1f);
			}
			yield return (object)new WaitForSeconds(0.2f);
			generator.Level = RunManager.instance.levelCurrent;
			ArenaAccess.SetLevelPrevious(RunManager.instance, generator.Level);
			generator.Generated = false;
			ArenaAccess.SetEnemyReady(generator, value: true);
			ArenaAccess.SetModulesSpawned(generator, 0);
			ArenaAccess.SetPlayerSpawnedCount(generator, 0);
			generator.LevelPathPoints = new List<LevelPoint>();
			generator.LevelPathTruck = null;
			if (Object.op_Implicit((Object)(object)ValuableDirector.instance))
			{
				ArenaAccess.SetValuableSetupComplete(ValuableDirector.instance, value: true);
				ArenaAccess.SetValuableValuablesSpawned(ValuableDirector.instance, value: true);
			}
			if (Object.op_Implicit((Object)(object)RoundDirector.instance))
			{
				ArenaAccess.ResetRoundExtraction(RoundDirector.instance);
			}
			generator.State = (LevelState)3;
			BuildArena(generator);
			ArenaRuntime arenaRuntime = this;
			Scene activeScene = SceneManager.GetActiveScene();
			arenaRuntime._sceneHandle = ((Scene)(ref activeScene)).handle;
			yield return (object)new WaitForSeconds(0.2f);
			if (Object.op_Implicit((Object)(object)EnvironmentDirector.Instance))
			{
				EnvironmentDirector.Instance.Setup();
			}
			if (Object.op_Implicit((Object)(object)PostProcessing.Instance))
			{
				PostProcessing.Instance.Setup();
			}
			if (Object.op_Implicit((Object)(object)LevelMusic.instance))
			{
				LevelMusic.instance.Setup();
			}
			if (Object.op_Implicit((Object)(object)ConstantMusic.instance))
			{
				ConstantMusic.instance.Setup();
			}
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				NavMeshSurface component = ((Component)generator).GetComponent<NavMeshSurface>();
				if ((Object)(object)component != (Object)null)
				{
					component.collectObjects = (CollectObjects)0;
					component.useGeometry = (NavMeshCollectGeometry)1;
					component.layerMask = LayerMask.op_Implicit(-1);
					component.defaultArea = 0;
				}
				generator.NavMeshSetup();
				yield return null;
				while ((Object)(object)GameDirector.instance == (Object)null || GameDirector.instance.PlayerList.Count == 0)
				{
					generator.State = (LevelState)12;
					yield return (object)new WaitForSeconds(0.1f);
				}
				generator.PlayerSpawn();
				yield return null;
				while (ArenaAccess.GetPlayerSpawnedCount(generator) < GameDirector.instance.PlayerList.Count)
				{
					generator.State = (LevelState)13;
					yield return (object)new WaitForSeconds(0.1f);
				}
				if (SemiFunc.IsMultiplayer())
				{
					generator.PhotonView.RPC("GenerateDone", (RpcTarget)3, Array.Empty<object>());
				}
				else
				{
					ArenaAccess.GenerateDone(generator);
				}
			}
			else
			{
				while (!generator.Generated)
				{
					yield return (object)new WaitForSeconds(0.1f);
				}
			}
			yield return (object)new WaitForSeconds(0.4f);
			Activate();
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				SpawnEnemies();
			}
		}

		private void Activate()
		{
			_active = true;
			_cleared = false;
			_exitTimer = 0f;
			_weaponService.Activate();
			StartMusic();
		}

		private void Deactivate()
		{
			if (_active)
			{
				_active = false;
				_cleared = false;
				_exitTimer = 0f;
				_enemies.Clear();
				_weaponService.Reset();
				_gunAssignments.Clear();
				_localGun = null;
				StopMusic();
			}
		}

		private void HandleSceneTransition()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			int handle = ((Scene)(ref activeScene)).handle;
			if (handle != _sceneHandle)
			{
				_sceneHandle = handle;
				_enemies.Clear();
				_enemyById.Clear();
				_enemySpawnAnchors.Clear();
				_arenaLights.Clear();
				_arenaRoot = null;
				_enemyHolder = null;
				_generator = null;
				_active = false;
				_cleared = false;
				_exitTimer = 0f;
				_weaponService.Reset();
				_gunAssignments.Clear();
				_localGun = null;
				StopMusic();
			}
		}

		private void UpdateEnemies()
		{
			if (_cleared || !SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			float value = EmpressSuperHotArenaPlugin.Settings.EnemyRange.Value;
			for (int i = 0; i < _enemies.Count; i++)
			{
				ArenaEnemy arenaEnemy = _enemies[i];
				if ((Object)(object)arenaEnemy != (Object)null && !arenaEnemy.Dead)
				{
					arenaEnemy.TickCombat(value);
				}
			}
		}

		private void MaybeBroadcastTransforms()
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || !SemiFunc.IsMultiplayer())
			{
				return;
			}
			_transformBroadcastTimer -= Time.unscaledDeltaTime;
			if (_transformBroadcastTimer > 0f)
			{
				return;
			}
			_transformBroadcastTimer = 0.07f;
			int num = 0;
			for (int i = 0; i < _enemies.Count; i++)
			{
				ArenaEnemy arenaEnemy = _enemies[i];
				if ((Object)(object)arenaEnemy != (Object)null && !arenaEnemy.Dead)
				{
					num++;
				}
			}
			if (num == 0)
			{
				return;
			}
			int[] array = new int[num];
			float[] array2 = new float[num * 4];
			byte[] array3 = new byte[num];
			int num2 = 0;
			for (int j = 0; j < _enemies.Count; j++)
			{
				ArenaEnemy arenaEnemy2 = _enemies[j];
				if (!((Object)(object)arenaEnemy2 == (Object)null) && !arenaEnemy2.Dead)
				{
					array[num2] = arenaEnemy2.Id;
					Vector3 position = ((Component)arenaEnemy2).transform.position;
					array2[num2 * 4] = position.x;
					array2[num2 * 4 + 1] = position.y;
					array2[num2 * 4 + 2] = position.z;
					int num3 = num2 * 4 + 3;
					Quaternion rotation = ((Component)arenaEnemy2).transform.rotation;
					array2[num3] = ((Quaternion)(ref rotation)).eulerAngles.y;
					byte b = 0;
					if (arenaEnemy2.LastAiming)
					{
						b = (byte)(b | 1u);
					}
					if (arenaEnemy2.LastMoving)
					{
						b = (byte)(b | 2u);
					}
					array3[num2] = b;
					num2++;
				}
			}
			EmpressSuperHotArenaPlugin.RaiseArenaTransforms(_spawnToken, array, array2, array3);
		}

		public void BroadcastEnemyDeath(ArenaEnemy enemy, Vector3 direction)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)enemy == (Object)null) && SemiFunc.IsMasterClientOrSingleplayer() && SemiFunc.IsMultiplayer())
			{
				EmpressSuperHotArenaPlugin.RaiseArenaDeath(_spawnToken, enemy.Id, direction.x, direction.z);
			}
		}

		public void RequestEnemyHit(int enemyId, Vector3 direction)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() && SemiFunc.IsMultiplayer())
			{
				EmpressSuperHotArenaPlugin.RaiseHitRequest(_spawnToken, enemyId, direction.x, direction.z);
			}
		}

		internal void ReceiveArenaSpawn(int spawnToken, int[] ids, float[] positions, float[] rotations, byte[] kinds)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() || ids == null || positions == null || rotations == null || kinds == null)
			{
				return;
			}
			_spawnToken = spawnToken;
			ClearEnemies();
			EnsureEnemyHolder();
			if ((Object)(object)_enemyHolder == (Object)null)
			{
				return;
			}
			int num = ids.Length;
			Vector3 position = default(Vector3);
			for (int i = 0; i < num && i * 3 + 2 < positions.Length && i < rotations.Length && i < kinds.Length; i++)
			{
				int num2 = ids[i];
				((Vector3)(ref position))..ctor(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]);
				Quaternion rotation = Quaternion.Euler(0f, rotations[i], 0f);
				EnemyKind kind = (EnemyKind)kinds[i];
				ArenaEnemy arenaEnemy = ArenaEnemy.CreateRemote(num2, kind, position, rotation, _enemyHolder);
				if ((Object)(object)arenaEnemy != (Object)null)
				{
					_enemies.Add(arenaEnemy);
					_enemyById[num2] = arenaEnemy;
				}
			}
			_active = true;
		}

		internal void ReceiveArenaTransforms(int spawnToken, int[] ids, float[] data, byte[] flags)
		{
			//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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() || spawnToken != _spawnToken || ids == null || data == null || flags == null)
			{
				return;
			}
			Vector3 position = default(Vector3);
			for (int i = 0; i < ids.Length && i < flags.Length && i * 4 + 3 < data.Length; i++)
			{
				if (_enemyById.TryGetValue(ids[i], out var value) && !((Object)(object)value == (Object)null) && !value.Dead)
				{
					((Vector3)(ref position))..ctor(data[i * 4], data[i * 4 + 1], data[i * 4 + 2]);
					Quaternion rotation = Quaternion.Euler(0f, data[i * 4 + 3], 0f);
					byte b = flags[i];
					value.ApplyRemoteTransform(position, rotation, (b & 1) != 0, (b & 2) != 0);
				}
			}
		}

		internal void ReceiveArenaDeath(int spawnToken, int id, float dirX, float dirZ)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (spawnToken == _spawnToken && _enemyById.TryGetValue(id, out var value) && !((Object)(object)value == (Object)null) && !value.Dead && !SemiFunc.IsMasterClientOrSingleplayer())
			{
				value.ApplyRemoteDeath(new Vector3(dirX, 0f, dirZ));
			}
		}

		internal void ReceiveHitRequest(int spawnToken, int id, float dirX, float dirZ)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (SemiFunc.IsMasterClientOrSingleplayer() && spawnToken == _spawnToken && _enemyById.TryGetValue(id, out var value) && (Object)(object)value != (Object)null && !value.Dead)
			{
				Vector3 forward = default(Vector3);
				((Vector3)(ref forward))..ctor(dirX, 0f, dirZ);
				if (((Vector3)(ref forward)).sqrMagnitude < 0.001f)
				{
					forward = ((Component)value).transform.forward;
				}
				value.Hurt(999, forward);
				EmpressSuperHotArenaPlugin.Log.LogInfo((object)("Arena hit request resolved on enemy " + id + "."));
			}
		}

		public void AssignLocalGun(PhysGrabObject grab)
		{
			_localGun = grab;
			_grabRetryTimer = 0f;
		}

		internal void ReceiveGunAssigned(int avatarViewId, int gunViewId)
		{
			_gunAssignments[avatarViewId] = gunViewId;
		}

		private void TryGrabLocalGun()
		{
			_grabRetryTimer -= Time.unscaledDeltaTime;
			if (_grabRetryTimer > 0f)
			{
				return;
			}
			_grabRetryTimer = 0.3f;
			PhysGrabObject val = ResolveLocalGun();
			if (!((Object)(object)val == (Object)null))
			{
				PhysGrabber instance = PhysGrabber.instance;
				if (!((Object)(object)instance == (Object)null))
				{
					instance.OverrideGrab(val, 0.45f, false);
				}
			}
		}

		private PhysGrabObject ResolveLocalGun()
		{
			if ((Object)(object)_localGun != (Object)null)
			{
				return _localGun;
			}
			if (!SemiFunc.IsMultiplayer())
			{
				return null;
			}
			PlayerController instance = PlayerController.instance;
			PlayerAvatar val = (((Object)(object)instance != (Object)null) ? instance.playerAvatarScript : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val.photonView == (Object)null)
			{
				return null;
			}
			int viewID = val.photonView.ViewID;
			if (!_gunAssignments.TryGetValue(viewID, out var value))
			{
				return null;
			}
			PhotonView val2 = PhotonView.Find(value);
			if ((Object)(object)val2 == (Object)null)
			{
				return null;
			}
			PhysGrabObject val3 = ((Component)val2).GetComponent<PhysGrabObject>() ?? ((Component)val2).GetComponentInChildren<PhysGrabObject>(true);
			if ((Object)(object)val3 != (Object)null)
			{
				_localGun = val3;
			}
			return val3;
		}

		private void EnsureEnemyHolder()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!((Object)(object)_enemyHolder != (Object)null) && !((Object)(object)_arenaRoot == (Object)null))
			{
				GameObject val = new GameObject("Empress Arena Enemies");
				val.transform.SetParent(_arenaRoot, false);
				_enemyHolder = val.transform;
			}
		}

		private void ClearEnemies()
		{
			for (int i = 0; i < _enemies.Count; i++)
			{
				ArenaEnemy arenaEnemy = _enemies[i];
				if ((Object)(object)arenaEnemy != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)arenaEnemy).gameObject);
				}
			}
			_enemies.Clear();
			_enemyById.Clear();
		}

		private void CheckClear()
		{
			if (_cleared || _enemies.Count == 0)
			{
				return;
			}
			for (int i = 0; i < _enemies.Count; i++)
			{
				ArenaEnemy arenaEnemy = _enemies[i];
				if ((Object)(object)arenaEnemy != (Object)null && !arenaEnemy.Dead)
				{
					return;
				}
			}
			_cleared = true;
			_exitTimer = Mathf.Max(0.5f, EmpressSuperHotArenaPlugin.Settings.ExitDelaySeconds.Value);
			EmpressSuperHotArenaPlugin.Log.LogInfo((object)"Empress SuperHot Arena cleared. Transitioning shortly.");
		}

		private void AdvanceAfterClear()
		{
			if (!_cleared || _exitTimer > 900f)
			{
				return;
			}
			_exitTimer -= Time.unscaledDeltaTime;
			if (!(_exitTimer > 0f) && SemiFunc.IsMasterClientOrSingleplayer())
			{
				_exitTimer = 999f;
				Time.timeScale = 1f;
				if ((Object)(object)RunManager.instance != (Object)null)
				{
					RunManager.instance.ChangeLevel(true, false, (ChangeLevelType)0);
				}
			}
		}

		private void SpawnEnemies()
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			ArenaSettings settings = EmpressSuperHotArenaPlugin.Settings;
			int num = (_arenaLevelNumber = Mathf.Max(1, (!((Object)(object)RunManager.instance != (Object)null)) ? 1 : (RunManager.instance.levelsCompleted + 1)));
			int num2 = (settings.EnableTeleporters.Value ? Mathf.Clamp(num - 1, 0, 5) : 0);
			int num3 = ((settings.EnableBosses.Value && num >= 4) ? Mathf.Clamp((num - 1) / 3, 0, 3) : 0);
			int num4 = Mathf.Clamp(settings.EnemyBaseCount.Value + (num - 1), 1, 25);
			num4 = Mathf.Max(1, num4 - num3 * 2);
			int num5 = Mathf.Max(1, settings.EnemyHealth.Value);
			int num6 = Mathf.Max(0, (num - 1) / 2);
			int num7 = num5 + num6;
			int num8 = num5 + num6;
			int num9 = (num5 + num6) * 10;
			List<EnemyKind> list = new List<EnemyKind>(num4 + num2 + num3);
			for (int i = 0; i < num3; i++)
			{
				list.Add(EnemyKind.Boss);
			}
			for (int j = 0; j < num2; j++)
			{
				list.Add(EnemyKind.Teleporter);
			}
			for (int k = 0; k < num4; k++)
			{
				list.Add(EnemyKind.Standard);
			}
			ClearEnemies();
			EnsureEnemyHolder();
			_spawnToken = DateTime.UtcNow.Ticks.GetHashCode() ^ Random.Range(1, int.MaxValue);
			List<Vector3> list2 = new List<Vector3>(_enemySpawnAnchors);
			for (int num10 = list2.Count - 1; num10 > 0; num10--)
			{
				int num11 = Random.Range(0, num10 + 1);
				List<Vector3> list3 = list2;
				int index = num10;
				int index2 = num11;
				Vector3 value = list2[num11];
				Vector3 value2 = list2[num10];
				list3[index] = value;
				list2[index2] = value2;
			}
			List<int> list4 = new List<int>();
			List<Vector3> list5 = new List<Vector3>();
			List<float> list6 = new List<float>();
			List<byte> list7 = new List<byte>();
			int count = list.Count;
			int num12 = 0;
			int num13 = 0;
			while (num12 < count && num13 < list2.Count * 3)
			{
				Vector3 position = list2[num13 % list2.Count];
				Quaternion rotation = Quaternion.Euler(0f, Random.Range(0f, 360f), 0f);
				EnemyKind enemyKind = list[num12];
				ArenaEnemy arenaEnemy = ArenaEnemy.Create(num12, enemyKind, position, rotation, enemyKind switch
				{
					EnemyKind.Boss => num9, 
					EnemyKind.Teleporter => num8, 
					_ => num7, 
				}, _enemyHolder);
				if ((Object)(object)arenaEnemy != (Object)null)
				{
					_enemies.Add(arenaEnemy);
					_enemyById[arenaEnemy.Id] = arenaEnemy;
					list4.Add(arenaEnemy.Id);
					list5.Add(((Component)arenaEnemy).transform.position);
					Quaternion rotation2 = ((Component)arenaEnemy).transform.rotation;
					list6.Add(((Quaternion)(ref rotation2)).eulerAngles.y);
					list7.Add((byte)enemyKind);
					num12++;
				}
				num13++;
			}
			EmpressSuperHotArenaPlugin.Log.LogInfo((object)("Empress SuperHot Arena level " + num + " spawned " + num12 + " enemies (boss " + num3 + " / teleporter " + num2 + " / standard " + num4 + ")."));
			if (SemiFunc.IsMultiplayer() && num12 != 0)
			{
				int[] ids = list4.ToArray();
				float[] array = new float[num12 * 3];
				float[] rotations = list6.ToArray();
				byte[] kinds = list7.ToArray();
				for (int l = 0; l < num12; l++)
				{
					array[l * 3] = list5[l].x;
					array[l * 3 + 1] = list5[l].y;
					array[l * 3 + 2] = list5[l].z;
				}
				EmpressSuperHotArenaPlugin.ClearArenaPhotonCache();
				EmpressSuperHotArenaPlugin.RaiseArenaSpawn(_spawnToken, ids, array, rotations, kinds);
			}
		}

		private void BuildArena(LevelGenerator generator)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)generator.LevelParent != (Object)null)
			{
				for (int num = generator.LevelParent.transform.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)generator.LevelParent.transform.GetChild(num)).gameObject);
				}
			}
			_enemies.Clear();
			_enemySpawnAnchors.Clear();
			_arenaLights.Clear();
			GameObject val = new GameObject("Empress Arena Root");
			val.transform.SetParent(generator.LevelParent.transform, false);
			_arenaRoot = val.transform;
			GameObject val2 = new GameObject("Empress Arena Module");
			val2.transform.SetParent(val.transform, false);
			val2.AddComponent<PhotonView>().ObservedComponents = new List<Component>();
			ArenaAccess.ConfigureStartRoomModule(val2.AddComponent<Module>(), 0, 0);
			val2.AddComponent<StartRoom>();
			GameObject val3 = new GameObject("Empress Arena Room Volume");
			val3.transform.SetParent(val2.transform, false);
			RoomVolume roomVolume = val3.AddComponent<RoomVolume>();
			BoxCollider obj = val3.AddComponent<BoxCollider>();
			((Collider)obj).isTrigger = true;
			obj.size = new Vector3(40f, 12f, 40f);
			obj.center = new Vector3(0f, 4f, 0f);
			ArenaMaterials.EnsureCreated();
			BuildShell(val2.transform);
			BuildGridFloor(val2.transform);
			BuildCover(val2.transform);
			BuildEmpressSignage(val2.transform);
			BuildLights(val2.transform);
			BuildSpawnPoints(val2.transform, roomVolume, generator);
			BuildEnemyAnchors();
		}

		private void BuildShell(Transform parent)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			CreateBox(parent, "Floor", new Vector3(0f, -0.3f, 0f), new Vector3(36f, 0.6f, 36f), ArenaMaterials.FloorMaterial);
			CreateBox(parent, "Ceiling", new Vector3(0f, 8.3f, 0f), new Vector3(36f, 0.6f, 36f), ArenaMaterials.CeilingMaterial);
			CreateBox(parent, "Wall North", new Vector3(0f, 4f, 18.4f), new Vector3(37.6f, 8f, 0.8f), ArenaMaterials.WallMaterial);
			CreateBox(parent, "Wall South", new Vector3(0f, 4f, -18.4f), new Vector3(37.6f, 8f, 0.8f), ArenaMaterials.WallMaterial);
			CreateBox(parent, "Wall East", new Vector3(18.4f, 4f, 0f), new Vector3(0.8f, 8f, 36f), ArenaMaterials.WallMaterial);
			CreateBox(parent, "Wall West", new Vector3(-18.4f, 4f, 0f), new Vector3(0.8f, 8f, 36f), ArenaMaterials.WallMaterial);
			float num = 0.18f;
			float num2 = 0.04f;
			CreateDecoration(parent, "Trim North", new Vector3(0f, num2, 18f - num * 0.5f), new Vector3(36f, 0.02f, num), ArenaMaterials.TrimMaterial);
			CreateDecoration(parent, "Trim South", new Vector3(0f, num2, -18f + num * 0.5f), new Vector3(36f, 0.02f, num), ArenaMaterials.TrimMaterial);
			CreateDecoration(parent, "Trim East", new Vector3(18f - num * 0.5f, num2, 0f), new Vector3(num, 0.02f, 36f), ArenaMaterials.TrimMaterial);
			CreateDecoration(parent, "Trim West", new Vector3(-18f + num * 0.5f, num2, 0f), new Vector3(num, 0.02f, 36f), ArenaMaterials.TrimMaterial);
			float num3 = 7.95f;
			CreateDecoration(parent, "Trim Top North", new Vector3(0f, num3, 18f - num * 0.5f), new Vector3(36f, 0.05f, num), ArenaMaterials.TrimSecondaryMaterial);
			CreateDecoration(parent, "Trim Top South", new Vector3(0f, num3, -18f + num * 0.5f), new Vector3(36f, 0.05f, num), ArenaMaterials.TrimSecondaryMaterial);
			CreateDecoration(parent, "Trim Top East", new Vector3(18f - num * 0.5f, num3, 0f), new Vector3(num, 0.05f, 36f), ArenaMaterials.TrimSecondaryMaterial);
			CreateDecoration(parent, "Trim Top West", new Vector3(-18f + num * 0.5f, num3, 0f), new Vector3(num, 0.05f, 36f), ArenaMaterials.TrimSecondaryMaterial);
		}

		private void BuildGridFloor(Transform parent)
		{
			//IL_0027: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Floor(3f) * 6f;
			for (float num2 = 0f - num; num2 <= num + 0.001f; num2 += 6f)
			{
				CreateDecoration(parent, "Grid X", new Vector3(num2, 0.01f, 0f), new Vector3(0.08f, 0.02f, 35.4f), ArenaMaterials.GridMaterial);
			}
			num = Mathf.Floor(3f) * 6f;
			for (float num3 = 0f - num; num3 <= num + 0.001f; num3 += 6f)
			{
				CreateDecoration(parent, "Grid Z", new Vector3(0f, 0.01f, num3), new Vector3(35.4f, 0.02f, 0.08f), ArenaMaterials.GridMaterial);
			}
		}

		private void BuildCover(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[5]
			{
				new Vector3(-8.5f, 0f, -8.5f),
				new Vector3(8.5f, 0f, -8.5f),
				new Vector3(-8.5f, 0f, 8.5f),
				new Vector3(8.5f, 0f, 8.5f),
				new Vector3(0f, 0f, 0f)
			};
			foreach (Vector3 val in array)
			{
				CreateBox(parent, "Pillar", val + new Vector3(0f, 1.9f, 0f), new Vector3(1.6f, 3.8f, 1.6f), ArenaMaterials.PillarMaterial);
				CreateDecoration(parent, "Pillar Cap", val + new Vector3(0f, 3.85f, 0f), new Vector3(1.68f, 0.06f, 1.68f), ArenaMaterials.TrimMaterial);
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(0f, 0f, -6f),
				new Vector3(0f, 0f, 6f),
				new Vector3(-6f, 0f, 0f),
				new Vector3(6f, 0f, 0f)
			};
			Vector3[] array3 = (Vector3[])(object)new Vector3[4]
			{
				new Vector3(6.5f, 1.35f, 0.55f),
				new Vector3(6.5f, 1.35f, 0.55f),
				new Vector3(0.55f, 1.35f, 6.5f),
				new Vector3(0.55f, 1.35f, 6.5f)
			};
			for (int j = 0; j < array2.Length; j++)
			{
				Vector3 val2 = array3[j];
				Vector3 val3 = array2[j] + new Vector3(0f, val2.y * 0.5f, 0f);
				CreateBox(parent, "Cover Wall", val3, val2, ArenaMaterials.PillarMaterial);
				CreateDecoration(parent, "Cover Trim", new Vector3(val3.x, array2[j].y + val2.y + 0.04f, val3.z), new Vector3(val2.x * 0.92f, 0.04f, val2.z * 0.92f), ArenaMaterials.TrimMaterial);
			}
		}

		private void BuildEmpressSignage(Transform parent)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			float num = 17.150002f;
			float num2 = 6.4f;
			CreateDecoration(parent, "Empress Sign", new Vector3(0f, num2, num), new Vector3(7.2f, 1.4f, 0.05f), ArenaMaterials.SignageMaterial);
			CreateDecoration(parent, "Empress Sign Glow", new Vector3(0f, num2, num - 0.04f), new Vector3(6.98f, 1.32f, 0.03f), ArenaMaterials.SignageGlowMaterial);
		}

		private void BuildLights(Transform parent)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[5]
			{
				new Vector3(-12.599999f, 7.1f, -12.599999f),
				new Vector3(12.599999f, 7.1f, -12.599999f),
				new Vector3(-12.599999f, 7.1f, 12.599999f),
				new Vector3(12.599999f, 7.1f, 12.599999f),
				new Vector3(0f, 6.9f, 0f)
			};
			foreach (Vector3 localPosition in array)
			{
				GameObject val = new GameObject("Empress Arena Light");
				val.transform.SetParent(parent, false);
				val.transform.localPosition = localPosition;
				Light val2 = val.AddComponent<Light>();
				val2.type = (LightType)2;
				val2.color = new Color(0.32f, 0.78f, 1f);
				val2.intensity = 1.6f;
				val2.range = 22f;
				_arenaLights.Add(val2);
			}
			GameObject val3 = new GameObject("Empress Arena Accent Light");
			val3.transform.SetParent(parent, false);
			val3.transform.localPosition = new Vector3(0f, 6.6f, 16.6f);
			val3.transform.localRotation = Quaternion.LookRotation(new Vector3(0f, -0.3f, -1f), Vector3.up);
			Light val4 = val3.AddComponent<Light>();
			val4.type = (LightType)0;
			val4.color = new Color(1f, 0.4f, 0.65f);
			val4.intensity = 2.6f;
			val4.range = 28f;
			val4.spotAngle = 80f;
			_arenaLights.Add(val4);
		}

		private void BuildSpawnPoints(Transform parent, RoomVolume roomVolume, LevelGenerator generator)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[6]
			{
				new Vector3(-3f, 0.15f, -14f),
				new Vector3(0f, 0.15f, -14f),
				new Vector3(3f, 0.15f, -14f),
				new Vector3(-3f, 0.15f, -11f),
				new Vector3(0f, 0.15f, -11f),
				new Vector3(3f, 0.15f, -11f)
			};
			Vector3[] array2 = array;
			foreach (Vector3 localPosition in array2)
			{
				GameObject val = new GameObject("Empress Arena Spawn");
				val.transform.SetParent(parent, false);
				val.transform.localPosition = localPosition;
				val.transform.localRotation = Quaternion.LookRotation(Vector3.forward, Vector3.up);
				val.AddComponent<SpawnPoint>();
			}
			_playerSpawnAnchor = array[1];
			LevelPoint val2 = CreateLevelPoint(parent, roomVolume, generator, new Vector3(0f, 0.15f, -12.5f), truck: true);
			LevelPoint val3 = CreateLevelPoint(parent, roomVolume, generator, new Vector3(0f, 0.15f, 0f), truck: false);
			LevelPoint val4 = CreateLevelPoint(parent, roomVolume, generator, new Vector3(0f, 0.15f, 12.5f), truck: false);
			val2.ConnectedPoints = new List<LevelPoint> { val3 };
			val3.ConnectedPoints = new List<LevelPoint> { val2, val4 };
			val4.ConnectedPoints = new List<LevelPoint> { val3 };
		}

		private void BuildEnemyAnchors()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			_enemySpawnAnchors.AddRange((IEnumerable<Vector3>)(object)new Vector3[11]
			{
				new Vector3(-12f, 0.1f, -2f),
				new Vector3(12f, 0.1f, -2f),
				new Vector3(-12f, 0.1f, 8f),
				new Vector3(12f, 0.1f, 8f),
				new Vector3(-4f, 0.1f, 11f),
				new Vector3(4f, 0.1f, 11f),
				new Vector3(-9f, 0.1f, 14f),
				new Vector3(9f, 0.1f, 14f),
				new Vector3(0f, 0.1f, 14f),
				new Vector3(-3f, 0.1f, 4f),
				new Vector3(3f, 0.1f, 4f)
			});
		}

		private static LevelPoint CreateLevelPoint(Transform parent, RoomVolume roomVolume, LevelGenerator generator, Vector3 localPosition, bool truck)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Empress Arena Level Point")
			{
				layer = LayerMask.NameToLayer("Other")
			};
			val.transform.SetParent(parent, false);
			val.transform.localPosition = localPosition;
			SphereCollider obj = val.AddComponent<SphereCollider>();
			((Collider)obj).isTrigger = true;
			obj.radius = 0.35f;
			LevelPoint obj2 = val.AddComponent<LevelPoint>();
			obj2.ConnectedPoints = new List<LevelPoint>();
			obj2.Room = roomVolume;
			obj2.Truck = truck;
			obj2.ModuleConnect = false;
			ArenaAccess.MarkLevelPointInStartRoom(obj2, value: true);
			if (generator.LevelPathPoints == null)
			{
				generator.LevelPathPoints = new List<LevelPoint>();
			}
			return obj2;
		}

		private static GameObject CreateBox(Transform parent, string name, Vector3 position, Vector3 size, Material material, bool localOffset = false)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)obj).name = name;
			obj.transform.SetParent(parent, false);
			obj.transform.localPosition = position;
			obj.transform.localRotation = Quaternion.identity;
			obj.transform.localScale = size;
			MeshRenderer component = obj.GetComponent<MeshRenderer>();
			if ((Object)(object)component != (Object)null && (Object)(object)material != (Object)null)
			{
				((Renderer)component).sharedMaterial = material;
			}
			return obj;
		}

		private static GameObject CreateDecoration(Transform parent, string name, Vector3 position, Vector3 size, Material material)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = CreateBox(parent, name, position, size, material);
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			return obj;
		}
	}
	internal static class ArenaMaterials
	{
		public static Material FloorMaterial { get; private set; }

		public static Material CeilingMaterial { get; private set; }

		public static Material WallMaterial { get; private set; }

		public static Material TrimMaterial { get; private set; }

		public static Material TrimSecondaryMaterial { get; private set; }

		public static Material GridMaterial { get; private set; }

		public static Material PillarMaterial { get; private set; }

		public static Material SignageMaterial { get; private set; }

		public static Material SignageGlowMaterial { get; private set; }

		public static void EnsureCreated()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)FloorMaterial != (Object)null))
			{
				Shader shader = Shader.Find("Standard");
				FloorMaterial = CreateMaterial(shader, new Color(0.02f, 0.03f, 0.05f), Color.black, 0f, 0.85f, 0.32f);
				CeilingMaterial = CreateMaterial(shader, new Color(0.02f, 0.02f, 0.04f), Color.black, 0f, 0.4f, 0.15f);
				WallMaterial = CreateMaterial(shader, new Color(0.03f, 0.04f, 0.07f), new Color(0.04f, 0.18f, 0.32f), 1.1f, 0.6f, 0.2f);
				TrimMaterial = CreateMaterial(shader, new Color(0.05f, 0.62f, 0.95f), new Color(0.18f, 0.78f, 1f), 3.6f, 1f, 0.18f);
				TrimSecondaryMaterial = CreateMaterial(shader, new Color(0.92f, 0.18f, 0.42f), new Color(1f, 0.32f, 0.58f), 2.6f, 1f, 0.22f);
				GridMaterial = CreateMaterial(shader, new Color(0.05f, 0.5f, 0.78f), new Color(0.12f, 0.65f, 0.95f), 2.2f, 1f, 0.18f);
				PillarMaterial = CreateMaterial(shader, new Color(0.05f, 0.06f, 0.09f), new Color(0.05f, 0.18f, 0.32f), 0.6f, 0.7f, 0.22f);
				SignageMaterial = CreateMaterial(shader, new Color(0.04f, 0.04f, 0.06f), Color.black, 0f, 0.55f, 0.15f);
				SignageGlowMaterial = CreateMaterial(shader, new Color(1f, 0.32f, 0.62f), new Color(1f, 0.4f, 0.78f), 3.4f, 1f, 0.2f);
			}
		}

		private static Material CreateMaterial(Shader shader, Color baseColor, Color emissionColor, float emissionStrength, float smoothness, float metallic)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(shader);
			val.color = baseColor;
			if (val.HasProperty("_Glossiness"))
			{
				val.SetFloat("_Glossiness", Mathf.Clamp01(smoothness));
			}
			if (val.HasProperty("_Smoothness"))
			{
				val.SetFloat("_Smoothness", Mathf.Clamp01(smoothness));
			}
			if (val.HasProperty("_Metallic"))
			{
				val.SetFloat("_Metallic", Mathf.Clamp01(metallic));
			}
			if (emissionStrength > 0f && val.HasProperty("_EmissionColor"))
			{
				val.EnableKeyword("_EMISSION");
				val.SetColor("_EmissionColor", emissionColor * emissionStrength);
				val.globalIlluminationFlags = (MaterialGlobalIlluminationFlags)1;
			}
			return val;
		}
	}
	internal sealed class ArenaWeaponService
	{
		private sealed class Loadout
		{
			public PlayerAvatar Avatar;

			public string SteamId;

			public string InstanceName;

			public int Spot;

			public ItemGun Gun;

			public ItemAttributes Attributes;

			public PhysGrabObject GrabObject;
		}

		private readonly Dictionary<string, Loadout> _loadouts = new Dictionary<string, Loadout>(StringComparer.Ordinal);

		private float _retryTimer;

		private bool _active;

		public void Activate()
		{
			_active = true;
			_retryTimer = 0f;
		}

		public void Reset()
		{
			_active = false;
			_retryTimer = 0f;
			_loadouts.Clear();
		}

		public void Update()
		{
			if (!_active || !SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			_retryTimer -= Time.unscaledDeltaTime;
			if (_retryTimer > 0f)
			{
				MaintainExisting();
				return;
			}
			_retryTimer = 1.5f;
			StatsManager instance = StatsManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Item val = FindHandgunItem(instance);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			PrefabRef prefab = val.prefab;
			if (prefab == null)
			{
				return;
			}
			string resourcePath = prefab.ResourcePath;
			GameObject prefab2 = prefab.Prefab;
			if (string.IsNullOrEmpty(resourcePath) && (Object)(object)prefab2 == (Object)null)
			{
				return;
			}
			GameDirector instance2 = GameDirector.instance;
			if ((Object)(object)instance2 == (Object)null || instance2.PlayerList == null)
			{
				return;
			}
			foreach (PlayerAvatar player in instance2.PlayerList)
			{
				if ((Object)(object)player == (Object)null)
				{
					continue;
				}
				string steamId = ArenaAccess.GetSteamId(player);
				if (string.IsNullOrEmpty(steamId))
				{
					continue;
				}
				if (_loadouts.TryGetValue(steamId, out var value) && (Object)(object)value.Gun != (Object)null)
				{
					MaintainLoadout(value);
					continue;
				}
				if (value == null)
				{
					value = new Loadout
					{
						Avatar = player,
						SteamId = steamId
					};
					_loadouts[steamId] = value;
				}
				TrySpawnAndEquip(value, val, prefab, resourcePath, prefab2, instance);
			}
		}

		private void MaintainExisting()
		{
			foreach (Loadout value in _loadouts.Values)
			{
				if (!((Object)(object)value.Gun == (Object)null))
				{
					MaintainLoadout(value);
				}
			}
		}

		private void TrySpawnAndEquip(Loadout loadout, Item handgun, PrefabRef prefab, string resourcePath, GameObject prefabObject, StatsManager stats)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			PlayerAvatar avatar = loadout.Avatar;
			if ((Object)(object)avatar == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)avatar).transform;
			Vector3 forward = transform.forward;
			forward.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.001f)
			{
				forward = Vector3.forward;
			}
			Vector3 val = transform.position + ((Vector3)(ref forward)).normalized * 0.8f + Vector3.up * 0.8f;
			Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref forward)).normalized, Vector3.up);
			int num = FindFreeSpotForPlayer(stats, loadout.SteamId);
			if (num < 0)
			{
				return;
			}
			string text = PredictNextInstanceName(stats, ((Object)handgun).name);
			stats.SetBatteryLevel(text, 100);
			ReserveInventorySpot(stats, PunManager.instance, loadout.SteamId, text, num);
			GameObject val3 = null;
			if (SemiFunc.IsMultiplayer() && !string.IsNullOrEmpty(resourcePath))
			{
				val3 = PhotonNetwork.InstantiateRoomObject(resourcePath, val, val2, (byte)0, (object[])null);
			}
			else if ((Object)(object)prefabObject != (Object)null)
			{
				val3 = Object.Instantiate<GameObject>(prefabObject, val, val2);
			}
			if ((Object)(object)val3 == (Object)null)
			{
				return;
			}
			loadout.Gun = val3.GetComponent<ItemGun>() ?? val3.GetComponentInChildren<ItemGun>(true);
			if (!((Object)(object)loadout.Gun == (Object)null))
			{
				loadout.Attributes = val3.GetComponent<ItemAttributes>() ?? val3.GetComponentInChildren<ItemAttributes>(true);
				loadout.GrabObject = val3.GetComponent<PhysGrabObject>() ?? val3.GetComponentInChildren<PhysGrabObject>(true);
				loadout.InstanceName = text;
				loadout.Spot = num;
				PunManager instance = PunManager.instance;
				if ((Object)(object)instance != (Object)null && (Object)(object)loadout.Attributes != (Object)null)
				{
					instance.SetItemName(text, loadout.Attributes, PhotonViewId((Component)(object)loadout.Attributes));
				}
				ItemEquippable val4 = val3.GetComponent<ItemEquippable>() ?? val3.GetComponentInChildren<ItemEquippable>(true);
				if ((Object)(object)val4 != (Object)null)
				{
					val4.RequestEquip(num, PhotonViewId((Component)(object)avatar));
				}
				ConfigureGun(loadout.Gun);
				ChargeGun(loadout, stats);
				AnnounceGunAssignment(loadout, avatar);
			}
		}

		private void MaintainLoadout(Loadout loadout)
		{
			if ((Object)(object)loadout.Avatar == (Object)null || (Object)(object)loadout.Gun == (Object)null)
			{
				return;
			}
			ItemAttributes attributes = loadout.Attributes;
			if ((Object)(object)attributes != (Object)null)
			{
				string itemInstanceName = ArenaAccess.GetItemInstanceName(attributes);
				if (!string.IsNullOrEmpty(itemInstanceName))
				{
					loadout.InstanceName = itemInstanceName;
				}
			}
			ConfigureGun(loadout.Gun);
			ChargeGun(loadout, StatsManager.instance);
			AnnounceGunAssignment(loadout, loadout.Avatar);
		}

		private static void ConfigureGun(ItemGun gun)
		{
			if (!((Object)(object)gun == (Object)null))
			{
				gun.shootCooldown = 0.12f;
				gun.shootTime = 0.04f;
				gun.batteryDrain = 0f;
				gun.batteryDrainFullBar = false;
			}
		}

		private static void ChargeGun(Loadout loadout, StatsManager stats)
		{
			if (!((Object)(object)loadout.Gun == (Object)null))
			{
				if ((Object)(object)stats != (Object)null && !string.IsNullOrEmpty(loadout.InstanceName))
				{
					stats.SetBatteryLevel(loadout.InstanceName, 100);
				}
				ItemBattery val = ArenaAccess.GetGunBattery(loadout.Gun) ?? ((Component)loadout.Gun).GetComponent<ItemBattery>();
				if (!((Object)(object)val == (Object)null))
				{
					val.batteryLife = 100f;
					ArenaAccess.SetItemBatteryLifeInt(val, val.batteryBars);
				}
			}
		}

		private void AnnounceGunAssignment(Loadout loadout, PlayerAvatar avatar)
		{
			if ((Object)(object)loadout.GrabObject == (Object)null || (Object)(object)avatar == (Object)null)
			{
				return;
			}
			ArenaRuntime instance = ArenaRuntime.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if (ArenaAccess.GetIsLocal(avatar))
			{
				instance.AssignLocalGun(loadout.GrabObject);
			}
			if (SemiFunc.IsMultiplayer() && !((Object)(object)avatar.photonView == (Object)null) && !((Object)(object)loadout.GrabObject == (Object)null))
			{
				PhotonView component = ((Component)loadout.GrabObject).GetComponent<PhotonView>();
				if (!((Object)(object)component == (Object)null))
				{
					EmpressSuperHotArenaPlugin.RaiseGunAssigned(avatar.photonView.ViewID, component.ViewID);
				}
			}
		}

		private static int FindFreeSpotForPlayer(StatsManager stats, string steamId)
		{
			for (int i = 0; i < 3; i++)
			{
				Dictionary<string, int> dictionary = i switch
				{
					1 => stats.playerInventorySpot2Taken, 
					0 => stats.playerInventorySpot1Taken, 
					_ => stats.playerInventorySpot3Taken, 
				};
				if (dictionary == null)
				{
					return i;
				}
				if (!dictionary.TryGetValue(steamId, out var value) || value == 0)
				{
					return i;
				}
			}
			return -1;
		}

		private static string PredictNextInstanceName(StatsManager stats, string itemName)
		{
			int num = 1;
			Dictionary<string, int> item = stats.item;
			if (item == null)
			{
				return itemName + "/" + num;
			}
			foreach (string key in item.Keys)
			{
				if (!string.IsNullOrEmpty(key) && key.Contains("/"))
				{
					string[] array = key.Split('/');
					if (array.Length == 2 && !(array[0] != itemName) && int.TryParse(array[1], out var result) && result >= num)
					{
						num = result + 1;
					}
				}
			}
			return itemName + "/" + num;
		}

		private static void ReserveInventorySpot(StatsManager stats, PunManager pun, string steamId, string instanceName, int spot)
		{
			string text = spot switch
			{
				1 => "playerInventorySpot2", 
				0 => "playerInventorySpot1", 
				_ => "playerInventorySpot3", 
			};
			int hashCode = instanceName.GetHashCode();
			stats.DictionaryUpdateValue(text, steamId, hashCode);
			if ((Object)(object)pun != (Object)null)
			{
				pun.UpdateStat(text, steamId, hashCode);
			}
			((Dictionary<string, int>)(spot switch
			{
				1 => stats.playerInventorySpot2Taken, 
				0 => stats.playerInventorySpot1Taken, 
				_ => stats.playerInventorySpot3Taken, 
			}))?.Remove(steamId);
		}

		private static Item FindHandgunItem(StatsManager stats)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between Unknown and I4
			Dictionary<string, Item> itemDictionary = stats.itemDictionary;
			if (itemDictionary == null)
			{
				return null;
			}
			foreach (KeyValuePair<string, Item> item in itemDictionary)
			{
				Item value = item.Value;
				if (!((Object)(object)value == (Object)null) && !value.disabled && (int)value.itemType == 9)
				{
					string obj = item.Key ?? string.Empty;
					string text = value.itemName ?? string.Empty;
					string text2 = ((Object)value).name ?? string.Empty;
					if (obj.IndexOf("handgun", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("handgun", StringComparison.OrdinalIgnoreCase) >= 0 || text2.IndexOf("handgun", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return value;
					}
				}
			}
			foreach (KeyValuePair<string, Item> item2 in itemDictionary)
			{
				Item value2 = item2.Value;
				if ((Object)(object)value2 != (Object)null && !value2.disabled && (int)value2.itemType == 9)
				{
					return value2;
				}
			}
			return null;
		}

		private static int PhotonViewId(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return -1;
			}
			PhotonView component2 = component.GetComponent<PhotonView>();
			if (!((Object)(object)component2 != (Object)null))
			{
				return -1;
			}
			return component2.ViewID;
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("com.empress.repo.superhotarena", "Empress SuperHot Arena", "1.0.0")]
	public sealed class EmpressSuperHotArenaPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.empress.repo.superhotarena";

		public const string PluginName = "Empress SuperHot Arena";

		public const string PluginVersion = "1.0.0";

		public const string ArenaLevelName = "Level - Empress SuperHot Arena";

		public const string ArenaDisplayName = "Empress SuperHot Arena";

		internal const byte ArenaSpawnEventCode = 190;

		internal const byte ArenaTransformEventCode = 191;

		internal const byte ArenaDeathEventCode = 192;

		internal const byte ArenaHitRequestEventCode = 193;

		internal const byte ArenaGunAssignedEventCode = 194;

		private static bool _photonEventsHooked;

		private Harmony _harmony;

		internal static EmpressSuperHotArenaPlugin Instance { get; private set; }

		internal static ManualLogSource Log { get; private set; }

		internal static ArenaSettings Settings { get; private set; }

		internal static Level ArenaLevel { get; private set; }

		private void Awake()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Settings = new ArenaSettings(((BaseUnityPlugin)this).Config);
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			ArenaLevel = ArenaLevelRegistry.RegisterArenaLevel();
			string? directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			ArenaAssets.Initialize(directoryName, ((BaseUnityPlugin)this).Logger);
			ArenaAssets.InitializeMusic(directoryName, ((BaseUnityPlugin)this).Logger);
			_harmony = new Harmony("com.empress.repo.superhotarena");
			_harmony.PatchAll(typeof(EmpressSuperHotArenaPlugin).Assembly);
			ArenaRuntime.EnsureHost();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Empress SuperHot Arena v1.0.0 loaded. Level registered: Level - Empress SuperHot Arena");
		}

		internal static bool IsArenaLevel(Level level)
		{
			if ((Object)(object)level != (Object)null)
			{
				return ((Object)level).name == "Level - Empress SuperHot Arena";
			}
			return false;
		}

		private void OnDestroy()
		{
			RemovePhotonEventHook();
		}

		internal static void EnsurePhotonEventHooked()
		{
			if (!_photonEventsHooked)
			{
				LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
				if (networkingClient != null)
				{
					networkingClient.EventReceived -= OnPhotonEvent;
					networkingClient.EventReceived += OnPhotonEvent;
					_photonEventsHooked = true;
				}
			}
		}

		internal static void RemovePhotonEventHook()
		{
			if (_photonEventsHooked)
			{
				LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
				if (networkingClient != null)
				{
					networkingClient.EventReceived -= OnPhotonEvent;
				}
				_photonEventsHooked = false;
			}
		}

		private static void OnPhotonEvent(EventData ev)
		{
			ArenaRuntime instance = ArenaRuntime.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			switch (ev.Code)
			{
			case 190:
			{
				if (!(ev.CustomData is object[] array5) || array5.Length < 5)
				{
					break;
				}
				object obj = array5[0];
				if (obj is int)
				{
					int spawnToken4 = (int)obj;
					if (array5[1] is int[] ids2 && array5[2] is float[] positions && array5[3] is float[] rotations && array5[4] is byte[] kinds)
					{
						instance.ReceiveArenaSpawn(spawnToken4, ids2, positions, rotations, kinds);
					}
				}
				break;
			}
			case 191:
			{
				if (!(ev.CustomData is object[] array4) || array4.Length < 4)
				{
					break;
				}
				object obj = array4[0];
				if (obj is int)
				{
					int spawnToken3 = (int)obj;
					if (array4[1] is int[] ids && array4[2] is float[] data && array4[3] is byte[] flags)
					{
						instance.ReceiveArenaTransforms(spawnToken3, ids, data, flags);
					}
				}
				break;
			}
			case 192:
			{
				if (!(ev.CustomData is object[] array3) || array3.Length < 4)
				{
					break;
				}
				object obj = array3[0];
				if (!(obj is int))
				{
					break;
				}
				int spawnToken2 = (int)obj;
				obj = array3[1];
				if (!(obj is int))
				{
					break;
				}
				int id2 = (int)obj;
				obj = array3[2];
				if (obj is float)
				{
					float dirX2 = (float)obj;
					obj = array3[3];
					if (obj is float)
					{
						float dirZ2 = (float)obj;
						instance.ReceiveArenaDeath(spawnToken2, id2, dirX2, dirZ2);
					}
				}
				break;
			}
			case 193:
			{
				if (!(ev.CustomData is object[] array2) || array2.Length < 4)
				{
					break;
				}
				object obj = array2[0];
				if (!(obj is int))
				{
					break;
				}
				int spawnToken = (int)obj;
				obj = array2[1];
				if (!(obj is int))
				{
					break;
				}
				int id = (int)obj;
				obj = array2[2];
				if (obj is float)
				{
					float dirX = (float)obj;
					obj = array2[3];
					if (obj is float)
					{
						float dirZ = (float)obj;
						instance.ReceiveHitRequest(spawnToken, id, dirX, dirZ);
					}
				}
				break;
			}
			case 194:
			{
				if (!(ev.CustomData is object[] array) || array.Length < 2)
				{
					break;
				}
				object obj = array[0];
				if (obj is int)
				{
					int avatarViewId = (int)obj;
					obj = array[1];
					if (obj is int)
					{
						int gunViewId = (int)obj;
						instance.ReceiveGunAssigned(avatarViewId, gunViewId);
					}
				}
				break;
			}
			}
		}

		internal static void RaiseArenaSpawn(int token, int[] ids, float[] positions, float[] rotations, byte[] kinds)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			RaisePhotonEvent(190, new object[5] { token, ids, positions, rotations, kinds }, (ReceiverGroup)0, (EventCaching)4, SendOptions.SendReliable);
		}

		internal static void RaiseArenaTransforms(int token, int[] ids, float[] data, byte[] flags)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			RaisePhotonEvent(191, new object[4] { token, ids, data, flags }, (ReceiverGroup)0, (EventCaching)0, SendOptions.SendUnreliable);
		}

		internal static void RaiseArenaDeath(int token, int id, float dirX, float dirZ)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			RaisePhotonEvent(192, new object[4] { token, id, dirX, dirZ }, (ReceiverGroup)0, (EventCaching)4, SendOptions.SendReliable);
		}

		internal static void RaiseHitRequest(int token, int id, float dirX, float dirZ)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			RaisePhotonEvent(193, new object[4] { token, id, dirX, dirZ }, (ReceiverGroup)2, (EventCaching)0, SendOptions.SendReliable);
		}

		internal static void RaiseGunAssigned(int avatarViewId, int gunViewId)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			RaisePhotonEvent(194, new object[2] { avatarViewId, gunViewId }, (ReceiverGroup)1, (EventCaching)4, SendOptions.SendReliable);
		}

		internal static void ClearArenaPhotonCache()
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_001c: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.InRoom)
			{
				RaiseEventOptions val = new RaiseEventOptions
				{
					CachingOption = (EventCaching)6
				};
				PhotonNetwork.RaiseEvent((byte)190, (object)null, val, SendOptions.SendReliable);
				PhotonNetwork.RaiseEvent((byte)192, (object)null, val, SendOptions.SendReliable);
				PhotonNetwork.RaiseEvent((byte)194, (object)null, val, SendOptions.SendReliable);
			}
		}

		private static void RaisePhotonEvent(byte code, object[] payload, ReceiverGroup receivers, EventCaching caching, SendOptions sendOptions)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0021: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			EnsurePhotonEventHooked();
			if (PhotonNetwork.InRoom)
			{
				RaiseEventOptions val = new RaiseEventOptions
				{
					Receivers = receivers,
					CachingOption = caching
				};
				PhotonNetwork.RaiseEvent(code, (object)payload, val, sendOptions);
			}
		}
	}
	internal sealed class ArenaSettings
	{
		public readonly ConfigEntry<bool> ForceArenaLevel;

		public readonly ConfigEntry<int> EnemyBaseCount;

		public readonly ConfigEntry<int> EnemyHealth;

		public readonly ConfigEntry<int> EnemyTouchDamage;

		public readonly ConfigEntry<float> EnemyRange;

		public readonly ConfigEntry<float> ExitDelaySeconds;

		public readonly ConfigEntry<bool> EnableTeleporters;

		public readonly ConfigEntry<bool> EnableBosses;

		public ArenaSettings(ConfigFile config)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			ForceArenaLevel = config.Bind<bool>("Debug", "ForceArenaLevel", false, "Forces every real run level to load the Empress SuperHot Arena. Useful for testing.");
			EnemyBaseCount = config.Bind<int>("Arena", "EnemyBaseCount", 8, new ConfigDescription("Base standard enemy count on level 1. Higher levels add more standards plus teleporters and bosses.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 30), Array.Empty<object>()));
			EnemyHealth = config.Bind<int>("Combat", "EnemyHealth", 1, new ConfigDescription("Base player shots required to drop a standard enemy. Bosses get 10x and per-level scaling adds more.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			EnemyTouchDamage = config.Bind<int>("Combat", "EnemyTouchDamage", 10, new ConfigDescription("Damage the player takes when an enemy touches them. The enemy dissolves on contact.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			EnemyRange = config.Bind<float>("Combat", "EnemyRange", 22f, new ConfigDescription("Detection range for enemies to acquire a player target.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 80f), Array.Empty<object>()));
			ExitDelaySeconds = config.Bind<float>("Arena", "ExitDelaySeconds", 3f, new ConfigDescription("Seconds after the arena is cleared before the level transitions away.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 30f), Array.Empty<object>()));
			EnableTeleporters = config.Bind<bool>("Arena", "EnableTeleporters", true, "Spawn blue teleporter enemies that warp around the arena. Appears from level 2 onward.");
			EnableBosses = config.Bind<bool>("Arena", "EnableBosses", true, "Spawn boss enemies (3x size, 10x HP). Appears from level 4 onward.");
		}
	}
}