using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DigitalRuby.ThunderAndLightning;
using GameNetcodeStuff;
using HarmonyLib;
using LegaFusionCore;
using LegaFusionCore.Behaviours.Shaders;
using LegaFusionCore.Managers;
using LegaFusionCore.Managers.NetworkManagers;
using LegaFusionCore.ModsCompat;
using LegaFusionCore.Registries;
using LegaFusionCore.Utilities;
using LethalLib.Extras;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using StrangerThings.Behaviours.Enemies;
using StrangerThings.Behaviours.Items;
using StrangerThings.Behaviours.MapObjects;
using StrangerThings.Behaviours.Scripts;
using StrangerThings.Managers;
using StrangerThings.ModsCompat;
using StrangerThings.NetcodePatcher;
using StrangerThings.Patches;
using StrangerThings.Registries;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.InputSystem;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("StrangerThings")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("StrangerThings")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("55a48e0f-a2f5-4aaf-a2fa-909d3c45d5d2")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[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 StrangerThings
{
	internal class Constants
	{
		public const string GLOBAL = "_Global_";

		public const string MIRROR_SCRAPS = "Mirror Scraps";

		public const string UPSIDE_DOWN = "Upside Down";

		public const string BATS_HORDE = "Bats Horde";

		public const string DEMOGORGON = "Demogorgon";

		public const string DEMOGORGON_KIDNAPPER = "Demogorgon Kidnapper";

		public const string VECNA = "Vecna";

		public const string CRUSTAPIKAN = "Crustapikan";

		public const string CRUSTAPIKAN_LARVAE = "Crustapikan Larvae";

		public const string LIMADON = "Limadon";

		public const string MIRROR_FUSION = "Mirror Fusion : [E]";
	}
	[BepInPlugin("Lega.StrangerThings", "Stranger Things", "1.0.1")]
	public class StrangerThings : BaseUnityPlugin
	{
		internal const string modGUID = "Lega.StrangerThings";

		internal const string modName = "Stranger Things";

		internal const string modVersion = "1.0.1";

		private readonly Harmony harmony = new Harmony("Lega.StrangerThings");

		internal static readonly AssetBundle bundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "strangerthings"));

		internal static ManualLogSource mls;

		public static ConfigFile configFile;

		public static GameObject managerPrefab = NetworkPrefabs.CreateNetworkPrefab("StrangerThingsNetworkManager");

		public static Dictionary<EnemyType, int> upsideDownEnemies = new Dictionary<EnemyType, int>();

		public static GameObject upsideDownAtmosphere;

		public static GameObject upsideDownSpores;

		public static GameObject upsideDownTentacles;

		public static GameObject upsideDownPortal;

		public static GameObject upsideDownMirrorObject;

		public static GameObject antennaHazard;

		public static GameObject rockProjectileObj;

		public static GameObject rockExplosionAudio;

		public static GameObject tree1Obj;

		public static GameObject tree2Obj;

		public static GameObject tree3Obj;

		public static GameObject batsSkyObj;

		public static Item antennaItem;

		public static GameObject batsHordeObj;

		public static EnemyType limadonType;

		public static EnemyType crustopikanLarvaeType;

		public void Awake()
		{
			mls = Logger.CreateLogSource("StrangerThings");
			configFile = ((BaseUnityPlugin)this).Config;
			ConfigManager.Load();
			LoadManager();
			NetcodePatcher();
			LoadItems();
			LoadHazards();
			LoadEnemies();
			LoadPrefabs();
			LoadNetworkPrefabs();
			harmony.PatchAll(typeof(AudioMixerPatch));
			harmony.PatchAll(typeof(NetworkBehaviourPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			harmony.PatchAll(typeof(RoundManagerPatch));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(GrabbableObjectPatch));
			harmony.PatchAll(typeof(ShotgunItemPatch));
			harmony.PatchAll(typeof(FlashlightItemPatch));
			harmony.PatchAll(typeof(GiftBoxItemPatch));
			harmony.PatchAll(typeof(StormyWeatherPatch));
			harmony.PatchAll(typeof(LightningBoltScriptPatch));
			harmony.PatchAll(typeof(DoorLockPatch));
			harmony.PatchAll(typeof(EnemyAIPatch));
			harmony.PatchAll(typeof(FlowerSnakeEnemyPatch));
			harmony.PatchAll(typeof(HoarderBugAIPatch));
			harmony.PatchAll(typeof(JesterAIPatch));
			harmony.PatchAll(typeof(NutcrackerEnemyAIPatch));
			harmony.PatchAll(typeof(RadMechAIPatch));
			harmony.PatchAll(typeof(SandSpiderWebTrapPatch));
			harmony.PatchAll(typeof(DeadBodyInfoPatch));
			harmony.PatchAll(typeof(VehicleControllerPatch));
			LethalMinSoftCompat.Patch(harmony);
			MelaniesVoiceSoftCompat.Patch(harmony);
			OpenBodyCamsSoftCompat.Patch(harmony);
			SelfSortingStorageSoftCompat.Patch(harmony);
			SpectateEnemySoftCompat.Patch(harmony);
		}

		public static void LoadManager()
		{
			Utilities.FixMixerGroups(managerPrefab);
			managerPrefab.AddComponent<StrangerThingsNetworkManager>();
		}

		private static void NetcodePatcher()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}

		public void LoadItems()
		{
			antennaItem = LFCObjectsManager.RegisterObject(typeof(AntennaItem), bundle.LoadAsset<Item>("Assets/Antenna/AntennaItem.asset"));
			Items.RegisterShopItem(antennaItem, 10);
			LFCSpawnableItemRegistry.Add(typeof(BaseballBat), bundle.LoadAsset<Item>("Assets/Items/BaseballBat/BaseballBatItem.asset"), 0, 2, 10, 180, 270);
			LFCSpawnableItemRegistry.Add(typeof(Guitar), bundle.LoadAsset<Item>("Assets/Items/Guitar/GuitarItem.asset"), 0, 2, 150, 125, 225);
			LFCSpawnableItemRegistry.Add(typeof(UpsideDownObject), bundle.LoadAsset<Item>("Assets/Items/StarcourtSign/StarcourtSignItem.asset"), 0, 2, 50, 100, 150);
			LFCSpawnableItemRegistry.Add(typeof(UpsideDownObject), bundle.LoadAsset<Item>("Assets/Items/WalkieTalkie/WalkieTalkieItem.asset"), 0, 2, 60, 80, 120);
			LFCSpawnableItemRegistry.Add(typeof(UpsideDownObject), bundle.LoadAsset<Item>("Assets/Items/Camera/CameraItem.asset"), 0, 2, 70, 60, 90);
			LFCSpawnableItemRegistry.Add(typeof(UpsideDownObject), bundle.LoadAsset<Item>("Assets/Items/WafflesBox/WafflesBoxItem.asset"), 0, 2, 75, 50, 75);
			LFCSpawnableItemRegistry.Add(typeof(UpsideDownObject), bundle.LoadAsset<Item>("Assets/Items/FairyLights/FairyLightsItem.asset"), 0, 2, 75, 50, 75);
		}

		public void LoadHazards()
		{
			batsHordeObj = RegisterHazard(bundle.LoadAsset<GameObject>("Assets/UpsideDown/Bats/BatsHorde.prefab"), ConfigManager.minBatsHordeInside.Value, ConfigManager.maxBatsHordeInside.Value);
		}

		public GameObject RegisterHazard(GameObject gameObject, float minSpawn, float maxSpawn)
		{
			//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_001e: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			SpawnableMapObjectDef val = ScriptableObject.CreateInstance<SpawnableMapObjectDef>();
			val.spawnableMapObject = new SpawnableMapObject
			{
				prefabToSpawn = gameObject
			};
			AnimationCurve animationCurveInside = new AnimationCurve((Keyframe[])(object)new Keyframe[1]
			{
				new Keyframe(minSpawn, maxSpawn)
			});
			NetworkPrefabs.RegisterNetworkPrefab(val.spawnableMapObject.prefabToSpawn);
			Utilities.FixMixerGroups(val.spawnableMapObject.prefabToSpawn);
			MapObjects.RegisterMapObject(val, (LevelTypes)(-1), (Func<SelectableLevel, AnimationCurve>)((SelectableLevel _) => animationCurveInside));
			return val.spawnableMapObject.prefabToSpawn;
		}

		public void LoadEnemies()
		{
			(Dictionary<LevelTypes, int> spawnRateByLevelType, Dictionary<string, int> spawnRateByCustomLevelType) demogorgonsSpawns = ConfigManager.GetDemogorgonsSpawns();
			Dictionary<LevelTypes, int> item = demogorgonsSpawns.spawnRateByLevelType;
			Dictionary<string, int> item2 = demogorgonsSpawns.spawnRateByCustomLevelType;
			TerminalNode terminalNode = bundle.LoadAsset<TerminalNode>("Assets/Enemies/Demogorgon/DemogorgonTN.asset");
			TerminalKeyword terminalKeyword = bundle.LoadAsset<TerminalKeyword>("Assets/Enemies/Demogorgon/DemogorgonTK.asset");
			Item bodyItem = bundle.LoadAsset<Item>("Assets/Enemies/Demogorgon/DemogorgonHeadItem.asset");
			RegisterEnemy(bundle.LoadAsset<EnemyType>("Assets/Enemies/Demogorgon/DemogorgonKidnapperEnemy.asset"), item, item2, terminalNode, terminalKeyword, bodyItem, ConfigManager.demogorgonMinHeadValue.Value, ConfigManager.demogorgonMaxHeadValue.Value);
			RegisterEnemy(bundle.LoadAsset<EnemyType>("Assets/Enemies/Demogorgon/DemogorgonHunterEnemy.asset"), item, item2, terminalNode, terminalKeyword, bodyItem, ConfigManager.demogorgonMinHeadValue.Value, ConfigManager.demogorgonMaxHeadValue.Value);
			RegisterUpsideDownEnemy(bundle.LoadAsset<EnemyType>("Assets/Enemies/Crustapikan/CrustapikanEnemy.asset"), ConfigManager.crustapikanRarity.Value, bundle.LoadAsset<TerminalNode>("Assets/Enemies/Crustapikan/CrustapikanTN.asset"), bundle.LoadAsset<TerminalKeyword>("Assets/Enemies/Crustapikan/CrustapikanTK.asset"), bundle.LoadAsset<Item>("Assets/Enemies/Crustapikan/CrustapikanArmItem.asset"), ConfigManager.crustapikanMinArmValue.Value, ConfigManager.crustapikanMaxArmValue.Value);
			limadonType = RegisterUpsideDownEnemy(bundle.LoadAsset<EnemyType>("Assets/Enemies/Limadon/LimadonEnemy.asset"), ConfigManager.limadonRarity.Value, bundle.LoadAsset<TerminalNode>("Assets/Enemies/Limadon/LimadonTN.asset"), bundle.LoadAsset<TerminalKeyword>("Assets/Enemies/Limadon/LimadonTK.asset"), bundle.LoadAsset<Item>("Assets/Enemies/Limadon/LimadonCorpseItem.asset"), ConfigManager.limadonMinCorpseValue.Value, ConfigManager.limadonMaxCorpseValue.Value);
			crustopikanLarvaeType = RegisterUpsideDownEnemy(bundle.LoadAsset<EnemyType>("Assets/Enemies/CrustapikanLarvae/CrustapikanLarvaeEnemy.asset"), ConfigManager.crustapikanLarvaeRarity.Value, bundle.LoadAsset<TerminalNode>("Assets/Enemies/CrustapikanLarvae/CrustapikanLarvaeTN.asset"), bundle.LoadAsset<TerminalKeyword>("Assets/Enemies/CrustapikanLarvae/CrustapikanLarvaeTK.asset"), bundle.LoadAsset<Item>("Assets/Enemies/CrustapikanLarvae/CrustapikanLarvaeCorpseItem.asset"), ConfigManager.crustapikanLarvaeMinCorpseValue.Value, ConfigManager.crustapikanLarvaeMaxCorpseValue.Value);
		}

		public void RegisterEnemy(EnemyType enemyType, Dictionary<LevelTypes, int> spawnRateByLevelType, Dictionary<string, int> spawnRateByCustomLevelType, TerminalNode terminalNode, TerminalKeyword terminalKeyword, Item bodyItem, int bodyMinValue, int bodyMaxValue, bool bodyEnabled = true)
		{
			NetworkPrefabs.RegisterNetworkPrefab(enemyType.enemyPrefab);
			Enemies.RegisterEnemy(enemyType, spawnRateByLevelType, spawnRateByCustomLevelType, terminalNode, terminalKeyword);
			SellBodiesFixedSoftCompat.RegisterBody(enemyType.enemyName, bodyItem, bodyMinValue, bodyMaxValue, bodyEnabled);
		}

		public EnemyType RegisterUpsideDownEnemy(EnemyType enemyType, int rarity, TerminalNode terminalNode, TerminalKeyword terminalKeyword, Item bodyItem, int bodyMinValue, int bodyMaxValue, bool bodyEnabled = true)
		{
			NetworkPrefabs.RegisterNetworkPrefab(enemyType.enemyPrefab);
			Enemies.RegisterEnemy(enemyType, rarity, (LevelTypes)1, terminalNode, terminalKeyword);
			SellBodiesFixedSoftCompat.RegisterBody(enemyType.enemyName, bodyItem, bodyMinValue, bodyMaxValue, bodyEnabled);
			upsideDownEnemies.Add(enemyType, rarity);
			return enemyType;
		}

		public void LoadPrefabs()
		{
			upsideDownAtmosphere = bundle.LoadAsset<GameObject>("Assets/UpsideDown/UpsideDownAtmosphere.prefab");
			upsideDownSpores = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Spores/Spores.prefab");
			upsideDownTentacles = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Tentacles/Tentacles.prefab");
			tree1Obj = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Trees/Tree1.prefab");
			tree2Obj = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Trees/Tree2.prefab");
			tree3Obj = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Trees/Tree3.prefab");
			batsSkyObj = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Bats/BatsSky.prefab");
		}

		public void LoadNetworkPrefabs()
		{
			HashSet<GameObject> hashSet = new HashSet<GameObject>
			{
				upsideDownPortal = bundle.LoadAsset<GameObject>("Assets/UpsideDown/Portal/UpsideDownPortal.prefab"),
				upsideDownMirrorObject = bundle.LoadAsset<GameObject>("Assets/Items/UpsideDownMirrorObject.prefab"),
				antennaHazard = bundle.LoadAsset<GameObject>("Assets/Antenna/AntennaHazard.prefab"),
				rockProjectileObj = bundle.LoadAsset<GameObject>("Assets/Enemies/Crustapikan/RockProjectile.prefab"),
				rockExplosionAudio = bundle.LoadAsset<GameObject>("Assets/Enemies/Crustapikan/RockExplosionAudio.prefab")
			};
			foreach (GameObject item in hashSet)
			{
				NetworkPrefabs.RegisterNetworkPrefab(item);
				Utilities.FixMixerGroups(item);
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "StrangerThings";

		public const string PLUGIN_NAME = "StrangerThings";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace StrangerThings.Registries
{
	public class DimensionRegistry : MonoBehaviour
	{
		private static readonly HashSet<GameObject> upsideDownEntities = new HashSet<GameObject>();

		public static GameObject GetUpsideDownEntity(GameObject entity)
		{
			upsideDownEntities.RemoveWhere((GameObject e) => (Object)(object)e == (Object)null);
			return ((IEnumerable<GameObject>)upsideDownEntities).FirstOrDefault((Func<GameObject, bool>)((GameObject e) => (Object)(object)e == (Object)(object)entity));
		}

		public static bool CanSetInUpsideDown(GameObject entity, bool isInUpsideDown)
		{
			PlayerControllerB safeComponent = LFCUtilities.GetSafeComponent<PlayerControllerB>(entity);
			if ((Object)(object)safeComponent != (Object)null && !safeComponent.isPlayerDead && !isInUpsideDown)
			{
				UpsideDownPortal[] upsideDownPortals = MapObjectsManager.GetUpsideDownPortals();
				foreach (UpsideDownPortal upsideDownPortal in upsideDownPortals)
				{
					if (!((Object)(object)upsideDownPortal.corruptedPlayer == (Object)(object)safeComponent))
					{
						continue;
					}
					if (!StartOfRound.Instance.shipHasLanded)
					{
						upsideDownPortal.RestorePortalEveryoneRpc();
						continue;
					}
					if (LFCUtilities.ShouldBeLocalPlayer(safeComponent))
					{
						HUDManager.Instance.DisplayTip("Impossible action", "You have been corrupted. You must find another way out.", false, false, "LC_Tip1");
					}
					return false;
				}
			}
			if (!isInUpsideDown)
			{
				return upsideDownEntities.Remove(entity);
			}
			return upsideDownEntities.Add(entity);
		}

		public static void SetInUpsideDown(GameObject entity, bool isInUpsideDown)
		{
			if ((Object)(object)LFCUtilities.LocalPlayer == (Object)null || (Object)(object)entity == (Object)null || !CanSetInUpsideDown(entity, isInUpsideDown))
			{
				return;
			}
			PlayerControllerB safeComponent = LFCUtilities.GetSafeComponent<PlayerControllerB>(entity);
			if ((Object)(object)safeComponent != (Object)null)
			{
				if (LFCUtilities.ShouldBeLocalPlayer(safeComponent))
				{
					RefreshStatesForLocalClient();
					UpdateLightsVisibilityForLocalClient();
					UpdateShipFeaturesForLocalClient();
					UpdateFlickeringFlashlights(safeComponent);
					UpsideDownAtmosphereController.Instance.SetUpsideDownState(isInUpsideDown);
				}
				else
				{
					if (LFCUtilities.LocalPlayer.isPlayerDead && (Object)(object)LFCUtilities.LocalPlayer.spectatedPlayerScript == (Object)(object)safeComponent)
					{
						SetInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject, isInUpsideDown);
						return;
					}
					UpdateVisibilityState(((Component)safeComponent).gameObject);
					UpdateFlickeringFlashlights(safeComponent);
				}
				StartOfRound.Instance.UpdatePlayerVoiceEffects();
			}
			else
			{
				UpdateVisibilityState(entity);
			}
		}

		public static bool IsInUpsideDown(GameObject entity)
		{
			if ((Object)(object)entity != (Object)null)
			{
				return Object.op_Implicit((Object)(object)GetUpsideDownEntity(entity));
			}
			return false;
		}

		public static bool AreInSameDimension(GameObject a, GameObject b)
		{
			if (!((Object)(object)a == (Object)null) && !((Object)(object)b == (Object)null) && !IsBlacklisted(a) && !IsBlacklisted(b))
			{
				return IsInUpsideDown(a) == IsInUpsideDown(b);
			}
			return true;
		}

		public static void RefreshStatesForLocalClient()
		{
			//IL_00dd: 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)
			NetworkBehaviour[] array = Object.FindObjectsOfType<NetworkBehaviour>(true);
			foreach (NetworkBehaviour val in array)
			{
				if (val.IsSpawned && IsWhitelisted(((Component)val).gameObject))
				{
					UpdateVisibilityState(((Component)val).gameObject);
				}
			}
			foreach (GrabbableObject allA in LFCSpawnRegistry.GetAllAs<GrabbableObject>())
			{
				if (LFCUtilities.LocalPlayer.ItemSlots.Contains(allA))
				{
					BeltBagItem val2 = (BeltBagItem)(object)((allA is BeltBagItem) ? allA : null);
					if (val2 != null)
					{
						for (int num = val2.objectsInBag.Count - 1; num >= 0; num--)
						{
							GrabbableObject val3 = val2.objectsInBag[num];
							if ((Object)(object)val3 != (Object)null)
							{
								StrangerThingsNetworkManager.Instance.SetGObjectInUpsideDownEveryoneRpc(NetworkObjectReference.op_Implicit(((Component)val3).GetComponent<NetworkObject>()), IsInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject));
							}
						}
					}
					StrangerThingsNetworkManager.Instance.SetGObjectInUpsideDownEveryoneRpc(NetworkObjectReference.op_Implicit(((Component)allA).GetComponent<NetworkObject>()), IsInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject));
				}
				else
				{
					UpdateVisibilityState(((Component)allA).gameObject);
				}
			}
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val4 in allPlayerScripts)
			{
				if (LFCUtilities.ShouldNotBeLocalPlayer(val4))
				{
					UpdateVisibilityState(((Component)val4).gameObject);
				}
			}
			SandSpiderWebTrap[] array2 = Object.FindObjectsOfType<SandSpiderWebTrap>(true);
			foreach (SandSpiderWebTrap val5 in array2)
			{
				UpdateVisibilityState(((Component)val5).gameObject);
			}
			DeadBodyInfo[] array3 = Object.FindObjectsOfType<DeadBodyInfo>(true);
			foreach (DeadBodyInfo val6 in array3)
			{
				UpdateVisibilityState(((Component)val6).gameObject);
			}
		}

		public static void UpdateVisibilityState(GameObject entity)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, entity))
			{
				LFCVisibilityRegistry.Restore(entity, "Stranger ThingsDimension");
			}
			else
			{
				LFCVisibilityRegistry.Hide(entity, "Stranger ThingsDimension");
			}
		}

		private static void UpdateLightsVisibilityForLocalClient()
		{
			foreach (Animator allPoweredLightsAnimator in RoundManager.Instance.allPoweredLightsAnimators)
			{
				if (IsInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject))
				{
					LFCPoweredLightsRegistry.AddLock(allPoweredLightsAnimator, "Stranger Things");
				}
				else
				{
					LFCPoweredLightsRegistry.RemoveLock(allPoweredLightsAnimator, "Stranger Things");
				}
			}
		}

		private static void UpdateShipFeaturesForLocalClient()
		{
			if (IsInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject))
			{
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)0, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)1, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)2, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)3, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)4, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)5, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)6, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)7, "Stranger Things");
				LFCShipFeatureRegistry.AddLock((ShipFeatureType)8, "Stranger Things");
			}
			else
			{
				LFCShipFeatureRegistry.ClearLocks("Stranger Things");
			}
		}

		private static void UpdateFlickeringFlashlights(PlayerControllerB player)
		{
			if (IsInUpsideDown(((Component)player).gameObject))
			{
				return;
			}
			HashSet<Component> setExact = LFCSpawnRegistry.GetSetExact<FlashlightItem>();
			if (setExact == null)
			{
				return;
			}
			foreach (FlashlightItem item in setExact.Cast<FlashlightItem>())
			{
				LFCObjectStateRegistry.RemoveFlickeringFlashlight(item, "Stranger Things" + player.playerUsername);
			}
		}

		public static bool IsWhitelisted(GameObject gObject)
		{
			if ((Object)(object)gObject != (Object)null && !IsBlacklisted(gObject))
			{
				EnemyAI val = default(EnemyAI);
				VehicleController val2 = default(VehicleController);
				RockProjectile rockProjectile = default(RockProjectile);
				AntennaHazard antennaHazard = default(AntennaHazard);
				if (!gObject.TryGetComponent<EnemyAI>(ref val) && !gObject.TryGetComponent<VehicleController>(ref val2) && !gObject.TryGetComponent<RockProjectile>(ref rockProjectile) && !gObject.TryGetComponent<AntennaHazard>(ref antennaHazard))
				{
					return LFCUtilities.HasNameFromList(LFCUtilities.GetGameObjectName(gObject), ConfigManager.visibilityStateInclusions.Value);
				}
				return true;
			}
			return false;
		}

		public static bool IsBlacklisted(GameObject gObject)
		{
			if ((Object)(object)gObject != (Object)null)
			{
				return LFCUtilities.HasNameFromList(LFCUtilities.GetGameObjectName(gObject), ConfigManager.visibilityStateExclusions.Value);
			}
			return false;
		}
	}
}
namespace StrangerThings.Patches
{
	public class AudioMixerPatch
	{
		[HarmonyPatch(typeof(AudioMixer), "SetFloat")]
		[HarmonyBefore(new string[] { "me.swipez.melonloader.morecompany" })]
		[HarmonyPrefix]
		private static void UpdatePlayerVolume(string name, ref float value)
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || !name.StartsWith("PlayerVolume"))
			{
				return;
			}
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || !localPlayer.isPlayerControlled || localPlayer.isPlayerDead)
			{
				return;
			}
			int length = "PlayerVolume".Length;
			string s = name.Substring(length, name.Length - length);
			if (int.TryParse(s, out var result) && result >= 0 && result < StartOfRound.Instance.allPlayerScripts.Length)
			{
				float num = 1f;
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[result];
				if ((Object)(object)val != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)localPlayer).gameObject, ((Component)val).gameObject))
				{
					num = ((!DimensionRegistry.IsInUpsideDown(((Component)localPlayer).gameObject)) ? (((!localPlayer.speakingToWalkieTalkie || !val.holdingWalkieTalkie) && (!val.speakingToWalkieTalkie || !localPlayer.holdingWalkieTalkie)) ? 0f : (MapObjectsManager.IsNearAntennaHazard(val) ? 1f : 0f)) : (((!localPlayer.speakingToWalkieTalkie || !val.holdingWalkieTalkie) && (!val.speakingToWalkieTalkie || !localPlayer.holdingWalkieTalkie)) ? 0.1f : (MapObjectsManager.IsNearAntennaHazard(localPlayer) ? 1f : 0f)));
				}
				value *= num;
			}
		}
	}
	public class DeadBodyInfoPatch
	{
		[HarmonyPatch(typeof(DeadBodyInfo), "Awake")]
		[HarmonyPostfix]
		private static void AwakeDeadBodyInfo(DeadBodyInfo __instance)
		{
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)null)
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}
	}
	public class DoorLockPatch
	{
		[HarmonyPatch(typeof(DoorLock), "OnTriggerStay")]
		[HarmonyPostfix]
		private static void BreakDoor(DoorLock __instance, ref Collider other)
		{
			//IL_0069: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if (LFCUtilities.IsServer && !__instance.isDoorOpened && !((Object)(object)((Component)__instance).GetComponent<DoorProjectile>() != (Object)null) && !((Object)(object)other == (Object)null) && ((Component)other).CompareTag("Enemy"))
			{
				EnemyAICollisionDetect component = ((Component)other).GetComponent<EnemyAICollisionDetect>();
				if ((Object)(object)component != (Object)null && component.mainScript is DemogorgonAI demogorgonAI && demogorgonAI.isDashing)
				{
					Vector3 val = ((Component)((EnemyAI)demogorgonAI).targetPlayer).transform.position - ((Component)demogorgonAI).transform.position;
					Vector3 direction = ((Vector3)(ref val)).normalized * 5f;
					demogorgonAI.BreakDoorEveryoneRpc(NetworkObjectReference.op_Implicit(((Component)__instance).GetComponentInParent<NetworkObject>()), direction);
					((EnemyAI)demogorgonAI).agent.speed = 0f;
					((EnemyAI)demogorgonAI).agent.velocity = Vector3.zero;
				}
			}
		}
	}
	public class EnemyAIPatch
	{
		[HarmonyPatch(typeof(EnemyAI), "Start")]
		[HarmonyPostfix]
		private static void StartEnemy(ref EnemyAI __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (LFCUtilities.IsServer && !(__instance is UpsideDownEnemyAI))
			{
				SpawnUpsideDownEnemy(__instance.isOutside, ((Component)__instance).transform.position);
			}
		}

		private static void SpawnUpsideDownEnemy(bool isOutside, Vector3 position)
		{
			//IL_0015: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0032: Unknown result type (might be due to invalid IL or missing references)
			EnemyType randomEnemy = GetRandomEnemy(isOutside);
			if ((Object)(object)randomEnemy != (Object)null)
			{
				position = RoundManager.Instance.GetRandomNavMeshPositionInRadiusSpherical(position, 10f, default(NavMeshHit));
				GameObject val = Object.Instantiate<GameObject>(randomEnemy.enemyPrefab, position, Quaternion.identity);
				NetworkObject componentInChildren = val.GetComponentInChildren<NetworkObject>();
				componentInChildren.Spawn(true);
				randomEnemy.numberSpawned++;
				RoundManager.Instance.SpawnedEnemies.Add(val.GetComponent<EnemyAI>());
			}
		}

		public static EnemyType GetRandomEnemy(bool isOutside)
		{
			List<EnemyType> eligibleEnemies = GetEligibleEnemies(isOutside);
			if (eligibleEnemies.Count <= 0)
			{
				return null;
			}
			return eligibleEnemies[new Random().Next(eligibleEnemies.Count)];
		}

		public static List<EnemyType> GetEligibleEnemies(bool isOutside)
		{
			List<EnemyType> list = new List<EnemyType>();
			foreach (KeyValuePair<EnemyType, int> upsideDownEnemy in StrangerThings.upsideDownEnemies)
			{
				EnemyType key = upsideDownEnemy.Key;
				EnemyAI component = key.enemyPrefab.GetComponent<EnemyAI>();
				if ((Object)(object)component != (Object)null && component.isOutside == isOutside && key.numberSpawned < key.MaxCount)
				{
					for (int i = 0; i < upsideDownEnemy.Value; i++)
					{
						list.Add(key);
					}
				}
			}
			return list;
		}

		[HarmonyPatch(typeof(EnemyAI), "PlayerIsTargetable")]
		[HarmonyPrefix]
		private static bool PlayerIsTargetable(ref EnemyAI __instance, ref bool __result, PlayerControllerB playerScript)
		{
			if (!DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)playerScript).gameObject) && (!(__instance is DemogorgonKidnapperAI demogorgonKidnapperAI) || ((EnemyAI)demogorgonKidnapperAI).currentBehaviourStateIndex != 0))
			{
				__result = false;
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyAI), "NavigateTowardsTargetPlayer")]
		[HarmonyPrefix]
		private static bool NavigateTowardsPlayer(ref EnemyAI __instance)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)__instance.targetPlayer).gameObject))
			{
				UpsideDownPortal closestPortal = MapObjectsManager.GetClosestPortal(((Component)__instance).transform.position);
				if ((Object)(object)closestPortal != (Object)null)
				{
					__instance.destination = ((Component)closestPortal).transform.position;
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(EnemyAI), "TargetClosestPlayer")]
		[HarmonyPostfix]
		private static void PreventTargetClosestPlayer(EnemyAI __instance, ref bool __result)
		{
			if (__result && (Object)(object)__instance.targetPlayer != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)__instance.targetPlayer).gameObject))
			{
				__result = false;
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "CheckLineOfSightForClosestPlayer")]
		[HarmonyPostfix]
		private static void PreventCheckLineOfSightForClosestPlayer(EnemyAI __instance, ref PlayerControllerB __result)
		{
			if ((Object)(object)__result != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)__result).gameObject))
			{
				__result = null;
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "CheckLineOfSightForPlayer")]
		[HarmonyPostfix]
		private static void PreventCheckLineOfSightForPlayer(EnemyAI __instance, ref PlayerControllerB __result)
		{
			if ((Object)(object)__result != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)__result).gameObject))
			{
				__result = null;
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "GetClosestPlayer")]
		[HarmonyPostfix]
		private static void PreventGetClosestPlayer(EnemyAI __instance, ref PlayerControllerB __result)
		{
			if ((Object)(object)__result != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)__result).gameObject))
			{
				__result = null;
			}
		}
	}
	public class FlashlightItemPatch
	{
		[HarmonyPatch(typeof(FlashlightItem), "SwitchFlashlight")]
		[HarmonyPostfix]
		private static void SwitchFlashlight(FlashlightItem __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject))
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}

		[HarmonyPatch(typeof(FlashlightItem), "PocketFlashlightClientRpc")]
		[HarmonyPostfix]
		private static void PocketFlashlightForClients(FlashlightItem __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject))
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}
	}
	public class FlowerSnakeEnemyPatch
	{
		[HarmonyPatch(typeof(FlowerSnakeEnemy), "Update")]
		[HarmonyPostfix]
		private static void UpdateTulipSnake(FlowerSnakeEnemy __instance)
		{
			if ((Object)(object)__instance.clingingToPlayer != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)__instance.clingingToPlayer).gameObject))
			{
				__instance.StopClingingOnLocalClient(__instance.clingPosition == 4);
			}
		}
	}
	public class GiftBoxItemPatch
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(GiftBoxItem), "OpenGiftBoxServerRpc")]
		private static IEnumerable<CodeInstruction> OpenGiftBoxForServer(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(NetworkObject), "Spawn", new Type[1] { typeof(bool) }, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(NetworkBehaviour), "NetworkObject");
			MethodInfo methodInfo3 = AccessTools.Method(typeof(GiftBoxItemPatch), "SetInUpsideDown", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count; i++)
			{
				if (!CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					continue;
				}
				int num = -1;
				for (int num2 = i; num2 >= 1; num2--)
				{
					if (CodeInstructionExtensions.Calls(list[num2], methodInfo2) && CodeInstructionExtensions.IsLdloc(list[num2 - 1], (LocalBuilder)null))
					{
						num = num2 - 1;
						break;
					}
				}
				if (num != -1)
				{
					List<CodeInstruction> list2 = new List<CodeInstruction>(3)
					{
						list[num].Clone(),
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Call, (object)methodInfo3)
					};
					int index = i + 1;
					list.InsertRange(index, list2);
					i += list2.Count;
				}
			}
			return list;
		}

		private static void SetInUpsideDown(GrabbableObject grabbableObject, GiftBoxItem giftBox)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)grabbableObject != (Object)null && (Object)(object)giftBox != (Object)null && DimensionRegistry.IsInUpsideDown(((Component)giftBox).gameObject))
			{
				StrangerThingsNetworkManager.Instance.SetGObjectInUpsideDownEveryoneRpc(NetworkObjectReference.op_Implicit(((Component)grabbableObject).GetComponent<NetworkObject>()), isInUpsideDown: true);
			}
		}
	}
	public class GrabbableObjectPatch
	{
		[HarmonyPatch(typeof(GrabbableObject), "EnableItemMeshes")]
		[HarmonyPostfix]
		private static void EnableItemMeshes(GrabbableObject __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject))
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "PocketItem")]
		[HarmonyPostfix]
		private static void PocketItem(GrabbableObject __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject))
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "DiscardItem")]
		[HarmonyPostfix]
		private static void DiscardItem(GrabbableObject __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject))
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}
	}
	public class HoarderBugAIPatch
	{
		[HarmonyPatch(typeof(HoarderBugAI), "RefreshGrabbableObjectsInMapList")]
		[HarmonyPostfix]
		private static void RefreshGrabbableObjects()
		{
			HashSet<GameObject> gObjects = new HashSet<GameObject>(from g in LFCSpawnRegistry.GetAllAs<GrabbableObject>()
				where (Object)(object)g != (Object)null && DimensionRegistry.IsInUpsideDown(((Component)g).gameObject)
				select ((Component)g).gameObject);
			HoarderBugAI.grabbableObjectsInMap.RemoveAll((GameObject g) => (Object)(object)g == (Object)null || gObjects.Contains(g));
			HoarderBugAI.HoarderBugItems.RemoveAll((HoarderBugItem h) => h == null || (Object)(object)h.itemGrabbableObject == (Object)null || gObjects.Contains(((Component)h.itemGrabbableObject).gameObject));
		}
	}
	public static class JesterAIPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(JesterAI), "Update")]
		private static void CaptureTimer(ref float ___noPlayersToChaseTimer, ref float __state)
		{
			__state = ___noPlayersToChaseTimer;
		}

		[HarmonyPostfix]
		[HarmonyAfter(new string[] { "AudioKnight.StarlancerAIFix" })]
		[HarmonyPatch(typeof(JesterAI), "Update")]
		private static void UpdateJester(ref JesterAI __instance, ref bool ___targetingPlayer, ref float ___noPlayersToChaseTimer, float __state)
		{
			if (!LFCUtilities.IsServer || ((EnemyAI)__instance).currentBehaviourStateIndex != 2)
			{
				return;
			}
			if ((Object)(object)((EnemyAI)__instance).targetPlayer != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)((EnemyAI)__instance).targetPlayer).gameObject))
			{
				((EnemyAI)__instance).targetPlayer = null;
			}
			___targetingPlayer = false;
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerControlled && val.isInsideFactory != ((EnemyAI)__instance).isOutside && DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)val).gameObject))
				{
					___targetingPlayer = true;
					break;
				}
			}
			float num = __state;
			if (!___targetingPlayer)
			{
				num -= Time.deltaTime;
				if (num <= 0f)
				{
					((EnemyAI)__instance).SwitchToBehaviourState(0);
				}
			}
			else
			{
				num = 5f;
			}
			___noPlayersToChaseTimer = num;
		}
	}
	public class LightningBoltScriptPatch
	{
		[HarmonyPatch(typeof(LightningBoltScript), "CreateParameters")]
		[HarmonyPostfix]
		private static void UpsideDownStrike(ref LightningBoltParameters __result)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (DimensionRegistry.IsInUpsideDown((localPlayer != null) ? ((Component)localPlayer).gameObject : null))
			{
				Color32 val = default(Color32);
				((Color32)(ref val))..ctor((byte)230, (byte)25, (byte)25, byte.MaxValue);
				__result.Color = val;
				__result.MainTrunkTintColor = val;
				__result.Intensity = 1.6f;
				__result.GlowIntensity = 1.4f;
				__result.GlowWidthMultiplier = 1.2f;
				__result.Forkedness = 1.2f;
			}
		}
	}
	public class NetworkBehaviourPatch
	{
		[HarmonyPatch(typeof(NetworkBehaviour), "InternalOnNetworkSpawn")]
		[HarmonyPostfix]
		private static void SpawnNetworkBehaviour(NetworkBehaviour __instance)
		{
			VehicleController val = default(VehicleController);
			if (!((Component)__instance).gameObject.TryGetComponent<VehicleController>(ref val) && (DimensionRegistry.IsWhitelisted(((Component)__instance).gameObject) || __instance is GrabbableObject))
			{
				if (__instance is UpsideDownObject || __instance is UpsideDownEnemyAI)
				{
					DimensionRegistry.SetInUpsideDown(((Component)__instance).gameObject, isInUpsideDown: true);
				}
				else
				{
					DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
				}
			}
		}
	}
	public class NutcrackerEnemyAIPatch
	{
		[HarmonyPatch(typeof(NutcrackerEnemyAI), "CheckLineOfSightForLocalPlayer")]
		[HarmonyPostfix]
		private static void PreventCheckLineOfSightForLocalPlayer(NutcrackerEnemyAI __instance, ref bool __result)
		{
			if (__result && (Object)(object)LFCUtilities.LocalPlayer != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance).gameObject, ((Component)LFCUtilities.LocalPlayer).gameObject))
			{
				__result = false;
			}
		}

		[HarmonyPatch(typeof(NutcrackerEnemyAI), "TurnTorsoToTargetDegrees")]
		[HarmonyPostfix]
		private static void TurnTorsoAudio(NutcrackerEnemyAI __instance)
		{
			GameObject gameObject = ((Component)__instance).gameObject;
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (!DimensionRegistry.AreInSameDimension(gameObject, (localPlayer != null) ? ((Component)localPlayer).gameObject : null))
			{
				__instance.torsoTurnAudio.volume = 0f;
			}
		}
	}
	public class PlayerControllerBPatch
	{
		private static bool canFlick = false;

		private static float flickerTimer = 0f;

		private static readonly float flickerCooldown = 0.5f;

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		private static void StartPlayer(PlayerControllerB __instance)
		{
			if (LFCUtilities.ShouldBeLocalPlayer(__instance) && (Object)(object)UpsideDownAtmosphereController.Instance == (Object)null)
			{
				Object.Instantiate<GameObject>(StrangerThings.upsideDownAtmosphere, ((Component)__instance.gameplayCamera).transform);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPrefix]
		private static void PreUpdatePlayer(PlayerControllerB __instance, bool ___isCameraDisabled, bool ___isPlayerControlled, bool ___isHostPlayerObject, bool ___isTestingPlayer)
		{
			if (___isCameraDisabled && ((((NetworkBehaviour)__instance).IsOwner && ___isPlayerControlled && (!((NetworkBehaviour)__instance).IsServer || ___isHostPlayerObject)) || ___isTestingPlayer) && DimensionRegistry.IsInUpsideDown(((Component)__instance).gameObject))
			{
				DimensionRegistry.SetInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject, isInUpsideDown: false);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		private static void PostUpdatePlayer(PlayerControllerB __instance)
		{
			//IL_0097: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RoundManager.Instance == (Object)null)
			{
				return;
			}
			if (LFCUtilities.ShouldBeLocalPlayer(__instance))
			{
				LFCUtilities.UpdateTimer(ref flickerTimer, flickerCooldown, !canFlick, (Action)delegate
				{
					canFlick = true;
				});
			}
			else
			{
				if (!canFlick || !DimensionRegistry.IsInUpsideDown(((Component)__instance).gameObject))
				{
					return;
				}
				canFlick = false;
				Animator val = null;
				float num = float.MaxValue;
				Vector3 val2;
				foreach (Animator allPoweredLightsAnimator in RoundManager.Instance.allPoweredLightsAnimators)
				{
					val2 = ((Component)allPoweredLightsAnimator).transform.position - ((Component)__instance).transform.position;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (!LFCPoweredLightsRegistry.IsLocked(allPoweredLightsAnimator) && sqrMagnitude <= 50f && sqrMagnitude < num)
					{
						num = sqrMagnitude;
						val = allPoweredLightsAnimator;
					}
				}
				if (val != null)
				{
					val.SetTrigger("Flicker");
				}
				HashSet<Component> setExact = LFCSpawnRegistry.GetSetExact<FlashlightItem>();
				if (setExact == null)
				{
					return;
				}
				foreach (FlashlightItem item in setExact.Cast<FlashlightItem>())
				{
					if (!DimensionRegistry.IsInUpsideDown(((Component)item).gameObject))
					{
						val2 = ((Component)item).transform.position - ((Component)__instance).transform.position;
						if (((Vector3)(ref val2)).sqrMagnitude <= 25f)
						{
							LFCObjectStateRegistry.AddFlickeringFlashlight(item, "Stranger Things" + __instance.playerUsername);
							continue;
						}
					}
					LFCObjectStateRegistry.RemoveFlickeringFlashlight(item, "Stranger Things" + __instance.playerUsername);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetHoverTipAndCurrentInteractTrigger")]
		[HarmonyPrefix]
		private static bool SetHoverTipMirrorFusion(PlayerControllerB __instance)
		{
			if (DimensionRegistry.IsInUpsideDown(((Component)__instance).gameObject) && !string.IsNullOrEmpty(((TMP_Text)__instance.cursorTip).text))
			{
				return !((TMP_Text)__instance.cursorTip).text.Equals("Mirror Fusion : [E]");
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Interact_performed")]
		[HarmonyPrefix]
		private static bool MirrorFusionActivate(PlayerControllerB __instance, ref CallbackContext context)
		{
			if (!((CallbackContext)(ref context)).performed || !LFCUtilities.ShouldBeLocalPlayer(__instance) || !DimensionRegistry.IsInUpsideDown(((Component)__instance).gameObject) || __instance.isPlayerDead || !__instance.isPlayerControlled || __instance.isGrabbingObjectAnimation || __instance.inSpecialMenu || __instance.quickMenuManager.isMenuOpen)
			{
				return true;
			}
			GrabbableObject currentlyHeldObjectServer = __instance.currentlyHeldObjectServer;
			UpsideDownMirrorBehaviour upsideDownMirrorBehaviour = default(UpsideDownMirrorBehaviour);
			if ((Object)(object)currentlyHeldObjectServer != (Object)null && LFCUtilities.TryGetComponentInChildren<UpsideDownMirrorBehaviour>(((Component)currentlyHeldObjectServer).gameObject, ref upsideDownMirrorBehaviour) && upsideDownMirrorBehaviour.canFusion)
			{
				upsideDownMirrorBehaviour.CompleteFusionServerRpc();
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayerClientRpc")]
		[HarmonyPostfix]
		private static void KillPlayerForClients(PlayerControllerB __instance)
		{
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)(object)__instance && DimensionRegistry.IsInUpsideDown(((Component)__instance).gameObject))
			{
				DimensionRegistry.SetInUpsideDown(((Component)__instance).gameObject, isInUpsideDown: false);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SpectateNextPlayer")]
		[HarmonyPostfix]
		private static void SwitchSpectatedPlayer(PlayerControllerB __instance)
		{
			if ((Object)(object)__instance.spectatedPlayerScript != (Object)null && !DimensionRegistry.AreInSameDimension(((Component)__instance.spectatedPlayerScript).gameObject, ((Component)__instance).gameObject))
			{
				DimensionRegistry.SetInUpsideDown(((Component)__instance).gameObject, DimensionRegistry.IsInUpsideDown(((Component)__instance.spectatedPlayerScript).gameObject));
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ResetZAndXRotation")]
		[HarmonyPostfix]
		private static void ResetZAndXRotation(PlayerControllerB __instance)
		{
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)(object)__instance)
			{
				PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
				if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject))
				{
					DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
				}
			}
		}
	}
	public class RadMechAIPatch
	{
		[HarmonyPatch(typeof(RadMechAI), "ShootGun")]
		[HarmonyPrefix]
		private static bool ShootGun(RadMechAI __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			return DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject);
		}

		[HarmonyPatch(typeof(RadMechAI), "SetExplosion")]
		[HarmonyPrefix]
		private static bool SetExplosion(RadMechAI __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			return DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject);
		}

		[HarmonyPatch(typeof(RadMechAI), "Stomp")]
		[HarmonyPrefix]
		private static bool Stomp(RadMechAI __instance)
		{
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			return DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)__instance).gameObject);
		}

		[HarmonyPatch(typeof(RadMechAI), "CheckSightForThreat")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> CheckSightForThreatTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo fieldInfo = AccessTools.Field(typeof(RadMechAI), "focusedThreatTransform");
			MethodInfo methodInfo = AccessTools.Method(typeof(RadMechAIPatch), "AreInSameDimension", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count - 1; i++)
			{
				if (list[i].opcode == OpCodes.Stfld && list[i].operand is FieldInfo fieldInfo2 && fieldInfo2 == fieldInfo)
				{
					Label label = il.DefineLabel();
					list[i + 1].labels.Add(label);
					list.InsertRange(i + 1, new <>z__ReadOnlyArray<CodeInstruction>((CodeInstruction[])(object)new CodeInstruction[5]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Call, (object)methodInfo),
						new CodeInstruction(OpCodes.Brtrue_S, (object)label),
						new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
						new CodeInstruction(OpCodes.Ret, (object)null)
					}));
					break;
				}
			}
			return list;
		}

		private static bool AreInSameDimension(RadMechAI radMech)
		{
			Transform focusedThreatTransform = radMech.focusedThreatTransform;
			if (!DimensionRegistry.AreInSameDimension((focusedThreatTransform != null) ? ((Component)focusedThreatTransform).gameObject : null, ((Component)radMech).gameObject))
			{
				((EnemyAI)radMech).SwitchToBehaviourStateOnLocalClient(0);
				return false;
			}
			return true;
		}
	}
	public class RoundManagerPatch
	{
		[HarmonyPatch(typeof(RoundManager), "SpawnOutsideHazards")]
		[HarmonyPostfix]
		private static void SpawnUpsideDownEnvironment()
		{
			//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_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_0039: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			UpsideDownAtmosphereController instance = UpsideDownAtmosphereController.Instance;
			if (!((Object)(object)instance == (Object)null))
			{
				instance.batsSky = Object.Instantiate<GameObject>(StrangerThings.batsSkyObj, StartOfRound.Instance.shipLandingPosition.position + Vector3.up * 50f, Quaternion.identity);
				instance.batsSky.SetActive(false);
				if (LFCUtilities.IsServer)
				{
					LFCMapObjectsManager.SpawnOutsideMapObjectsForServer(ConfigManager.minBatsHordeOutside.Value, ConfigManager.maxBatsHordeOutside.Value, (Action<Vector3, Quaternion>)SpawnBatsHorde);
					StrangerThingsNetworkManager.Instance.SpawnUpsideDownTreesEveryoneRpc(StartOfRound.Instance.randomMapSeed);
				}
				if ((Object)(object)instance.spores == (Object)null)
				{
					GameObject upsideDownSpores = StrangerThings.upsideDownSpores;
					PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
					GameObject val = Object.Instantiate<GameObject>(upsideDownSpores, ((localPlayer != null) ? new Vector3?(((Component)localPlayer.gameplayCamera).transform.position) : null).Value + Vector3.forward * 2f, Quaternion.identity);
					instance.spores = val.GetComponent<ParticleSystem>();
					((Component)instance.spores).gameObject.SetActive(false);
				}
			}
		}

		public static void SpawnBatsHorde(Vector3 position, Quaternion rotation)
		{
			//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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = default(RaycastHit);
			if (Physics.Raycast(position, Vector3.down, ref val, 5f, StartOfRound.Instance.collidersAndRoomMaskAndDefault))
			{
				GameObject val2 = Object.Instantiate<GameObject>(StrangerThings.batsHordeObj, ((RaycastHit)(ref val)).point + Vector3.up * 2.25f, Quaternion.Euler(0f, ((Quaternion)(ref rotation)).eulerAngles.y, ((Quaternion)(ref rotation)).eulerAngles.z), RoundManager.Instance.mapPropsContainer.transform);
				val2.GetComponent<NetworkObject>().Spawn(true);
			}
		}

		[HarmonyPatch(typeof(RoundManager), "waitForScrapToSpawnToSync")]
		[HarmonyPostfix]
		private static IEnumerator SpawnMirrorObjects(IEnumerator result)
		{
			while (result.MoveNext())
			{
				yield return result.Current;
			}
			int num = Random.Range(ConfigManager.minMirrorScraps.Value, ConfigManager.maxMirrorScraps.Value + 1);
			int num2 = 0;
			foreach (GrabbableObject allA in LFCSpawnRegistry.GetAllAs<GrabbableObject>())
			{
				if (!string.IsNullOrEmpty(allA.itemProperties?.itemName) && (string.IsNullOrEmpty(ConfigManager.scrapExclusions.Value) || !ConfigManager.scrapExclusions.Value.Contains(allA.itemProperties.itemName)) && allA.isInFactory && !allA.isInShipRoom && allA.scrapValue > 0 && !DimensionRegistry.IsInUpsideDown(((Component)allA).gameObject))
				{
					GrabbableObject val = SpawnUpsideDownObject(allA.itemProperties);
					if ((Object)(object)val != (Object)null)
					{
						GameObject val2 = Object.Instantiate<GameObject>(StrangerThings.upsideDownMirrorObject, ((Component)val).transform.position, Quaternion.identity);
						NetworkObject component = val2.GetComponent<NetworkObject>();
						component.Spawn(false);
						StrangerThingsNetworkManager.Instance.AddToMirrorEveryoneRpc(NetworkObjectReference.op_Implicit(component), NetworkObjectReference.op_Implicit(((Component)val).GetComponent<NetworkObject>()), NetworkObjectReference.op_Implicit(((Component)allA).GetComponent<NetworkObject>()));
					}
					if (num <= num2++)
					{
						break;
					}
				}
			}
		}

		public static GrabbableObject SpawnUpsideDownObject(Item itemToSpawn, int value = 0)
		{
			//IL_0049: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_00ac: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			List<RandomScrapSpawn> list = Object.FindObjectsOfType<RandomScrapSpawn>().ToList();
			if (list.Any())
			{
				LFCUtilities.Shuffle<RandomScrapSpawn>((IList<RandomScrapSpawn>)list);
				int index = new Random().Next(0, list.Count);
				RandomScrapSpawn val = list[index];
				RoundManager instance = RoundManager.Instance;
				((Component)val).transform.position = instance.GetRandomNavMeshPositionInBoxPredictable(((Component)val).transform.position, val.itemSpawnRange, instance.navHit, instance.AnomalyRandom, -1, 1f) + Vector3.up * itemToSpawn.verticalOffset;
				Vector3 val2 = ((Component)val).transform.position + Vector3.up * 0.5f;
				GrabbableObject val3 = LFCObjectsManager.SpawnObjectForServer(itemToSpawn.spawnPrefab, val2);
				if (!(val3 is UpsideDownObject))
				{
					StrangerThingsNetworkManager.Instance.SetGObjectInUpsideDownEveryoneRpc(NetworkObjectReference.op_Implicit(((Component)val3).GetComponent<NetworkObject>()), isInUpsideDown: true);
				}
				LFCNetworkManager.Instance.SetScrapValueEveryoneRpc(NetworkObjectReference.op_Implicit(((Component)val3).GetComponent<NetworkObject>()), value);
				return val3;
			}
			return null;
		}

		[HarmonyPatch(typeof(RoundManager), "ResetEnemyTypesSpawnedCounts")]
		[HarmonyPostfix]
		private static void ResetEnemyTypesSpawnedCounts(RoundManager __instance)
		{
			foreach (KeyValuePair<EnemyType, int> upsideDownEnemy in StrangerThings.upsideDownEnemies)
			{
				EnemyType key = upsideDownEnemy.Key;
				key.numberSpawned = 0;
				foreach (EnemyAI spawnedEnemy in __instance.SpawnedEnemies)
				{
					if ((Object)(object)spawnedEnemy.enemyType == (Object)(object)key)
					{
						key.numberSpawned++;
					}
				}
			}
		}

		[HarmonyPatch(typeof(RoundManager), "PlayRandomClip")]
		[HarmonyPrefix]
		private static bool PlayRandomClip(AudioSource audioSource)
		{
			GameObject val = ((audioSource != null) ? ((Component)audioSource).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			GameObject val2 = ((localPlayer != null) ? ((Component)localPlayer).gameObject : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return true;
			}
			EnemyAI val3 = default(EnemyAI);
			if (LFCUtilities.TryGetComponentInParent<EnemyAI>(val, ref val3))
			{
				return DimensionRegistry.AreInSameDimension(((Component)val3).gameObject, val2);
			}
			GrabbableObject val4 = default(GrabbableObject);
			if (LFCUtilities.TryGetComponentInParent<GrabbableObject>(val, ref val4))
			{
				return DimensionRegistry.AreInSameDimension(((Component)val4).gameObject, val2);
			}
			return true;
		}
	}
	public class SandSpiderWebTrapPatch
	{
		[HarmonyPatch(typeof(SandSpiderWebTrap), "Awake")]
		[HarmonyPostfix]
		private static void AwakeSpiderWeb(SandSpiderWebTrap __instance)
		{
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)null)
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}
	}
	public class ShotgunItemPatch
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(ShotgunItem), "ShootGun")]
		private static IEnumerable<CodeInstruction> ShootGun(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Expected O, but got Unknown
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0366: Expected O, but got Unknown
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0378: Expected O, but got Unknown
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			MethodInfo methodInfo = AccessTools.Method(typeof(PlayerControllerB), "DamagePlayer", new Type[7]
			{
				typeof(int),
				typeof(bool),
				typeof(bool),
				typeof(CauseOfDeath),
				typeof(int),
				typeof(bool),
				typeof(Vector3)
			}, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(IHittable), "Hit", new Type[5]
			{
				typeof(int),
				typeof(Vector3),
				typeof(PlayerControllerB),
				typeof(bool),
				typeof(int)
			}, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(Component), "gameObject");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(DimensionRegistry), "AreInSameDimension", new Type[2]
			{
				typeof(GameObject),
				typeof(GameObject)
			}, (Type[])null);
			for (int i = 0; i < list.Count; i++)
			{
				if (methodInfo != null && CodeInstructionExtensions.Calls(list[i], methodInfo))
				{
					int num = FindPrevLdlocIndex(list, i, 1);
					if (num != -1)
					{
						Label label = il.DefineLabel();
						Label label2 = il.DefineLabel();
						list[num].labels.Add(label);
						if (i + 1 < list.Count)
						{
							list[i + 1].labels.Add(label2);
						}
						List<CodeInstruction> list2 = new List<CodeInstruction>(7)
						{
							new CodeInstruction(OpCodes.Ldarg_0, (object)null),
							new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
							new CodeInstruction(OpCodes.Ldloc_1, (object)null),
							new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
							new CodeInstruction(OpCodes.Call, (object)methodInfo4),
							new CodeInstruction(OpCodes.Brtrue_S, (object)label),
							new CodeInstruction(OpCodes.Br_S, (object)label2)
						};
						list.InsertRange(num, list2);
						i += list2.Count;
					}
				}
				else
				{
					if (!(methodInfo2 != null) || !CodeInstructionExtensions.Calls(list[i], methodInfo2))
					{
						continue;
					}
					int num2 = FindPrevLdlocIndex(list, i, 10);
					if (num2 == -1)
					{
						continue;
					}
					Label label4;
					if (i + 1 < list.Count && (list[i + 1].opcode == OpCodes.Brfalse || list[i + 1].opcode == OpCodes.Brfalse_S) && list[i + 1].operand is Label label3)
					{
						label4 = label3;
					}
					else
					{
						label4 = il.DefineLabel();
						if (i + 1 < list.Count)
						{
							list[i + 1].labels.Add(label4);
						}
					}
					List<CodeInstruction> list3 = new List<CodeInstruction>(6)
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
						new CodeInstruction(OpCodes.Ldloc_S, (object)(byte)12),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
						new CodeInstruction(OpCodes.Call, (object)methodInfo4),
						new CodeInstruction(OpCodes.Brfalse_S, (object)label4)
					};
					list.InsertRange(num2, list3);
					i += list3.Count;
				}
			}
			return list;
		}

		private static int FindPrevLdlocIndex(List<CodeInstruction> code, int fromIndex, int localIndex)
		{
			for (int num = fromIndex; num >= 0; num--)
			{
				if (TryGetLdlocIndex(code[num], out var index) && index == localIndex)
				{
					return num;
				}
			}
			return -1;
		}

		private static bool TryGetLdlocIndex(CodeInstruction ci, out int index)
		{
			index = -1;
			if (ci.opcode == OpCodes.Ldloc_0)
			{
				index = 0;
				return true;
			}
			if (ci.opcode == OpCodes.Ldloc_1)
			{
				index = 1;
				return true;
			}
			if (ci.opcode == OpCodes.Ldloc_2)
			{
				index = 2;
				return true;
			}
			if (ci.opcode == OpCodes.Ldloc_3)
			{
				index = 3;
				return true;
			}
			if (ci.opcode != OpCodes.Ldloc && ci.opcode != OpCodes.Ldloc_S)
			{
				return false;
			}
			if (ci.operand is LocalBuilder localBuilder)
			{
				index = localBuilder.LocalIndex;
				return true;
			}
			if (ci.operand is int num)
			{
				index = num;
				return true;
			}
			if (ci.operand is byte b)
			{
				index = b;
				return true;
			}
			return false;
		}
	}
	public class StartOfRoundPatch
	{
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		private static void StartRound(StartOfRound __instance)
		{
			if (NetworkManager.Singleton.IsHost && (Object)(object)StrangerThingsNetworkManager.Instance == (Object)null)
			{
				GameObject val = Object.Instantiate<GameObject>(StrangerThings.managerPrefab, ((Component)__instance).transform.parent);
				val.GetComponent<NetworkObject>().Spawn(false);
				StrangerThings.mls.LogInfo((object)"Spawning StrangerThingsNetworkManager");
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		[HarmonyPostfix]
		public static void EndRound(StartOfRound __instance)
		{
			PlayerControllerB[] allPlayerScripts = __instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (DimensionRegistry.IsInUpsideDown(((Component)val).gameObject))
				{
					DimensionRegistry.SetInUpsideDown(((Component)val).gameObject, isInUpsideDown: false);
				}
			}
			UpsideDownAtmosphereController instance = UpsideDownAtmosphereController.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				foreach (GameObject item in instance.deadTrees.ToList())
				{
					if ((Object)(object)item != (Object)null)
					{
						Object.Destroy((Object)(object)item);
					}
				}
				Object.Destroy((Object)(object)instance.batsSky);
				instance.aliveTrees.Clear();
				instance.deadTrees.Clear();
				instance.batsHordes.Clear();
				instance.batsSky = null;
			}
			MapObjectsManager.upsideDownPortals.Clear();
		}

		[HarmonyPatch(typeof(StartOfRound), "OnDisable")]
		[HarmonyPostfix]
		public static void OnDisable()
		{
			StrangerThingsNetworkManager.Instance = null;
		}
	}
	public class StormyWeatherPatch
	{
		[HarmonyTranspiler]
		[HarmonyPatch(typeof(StormyWeather), "Update")]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo fieldInfo = AccessTools.Field(typeof(GrabbableObject), "isInFactory");
			MethodInfo operand = AccessTools.Method(typeof(StormyWeatherPatch), "IsUntargetableObject", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand is FieldInfo fieldInfo2 && fieldInfo2 == fieldInfo)
				{
					list[i].opcode = OpCodes.Call;
					list[i].operand = operand;
				}
			}
			return list;
		}

		[HarmonyPatch(typeof(StormyWeather), "LightningStrike")]
		[HarmonyPrefix]
		private static bool ShouldRunLightningStrike(StormyWeather __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if ((int)StartOfRound.Instance.currentLevel.currentWeather != 2)
			{
				PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
				if (!DimensionRegistry.IsInUpsideDown((localPlayer != null) ? ((Component)localPlayer).gameObject : null))
				{
					__instance.staticElectricityParticle.Stop();
					((Component)__instance.staticElectricityParticle).GetComponent<AudioSource>().Stop();
					__instance.setStaticToObject = null;
					return false;
				}
			}
			return true;
		}

		private static bool IsUntargetableObject(GrabbableObject grabbableObject)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if (!((Object)(object)grabbableObject == (Object)null) && !grabbableObject.isInFactory)
			{
				if ((int)StartOfRound.Instance.currentLevel.currentWeather != 2)
				{
					return !DimensionRegistry.IsInUpsideDown(((Component)grabbableObject).gameObject);
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(StormyWeather), "SetStaticElectricityWarning")]
		[HarmonyPrefix]
		private static bool SetStaticElectricityWarning(NetworkObject warningObject)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			GameObject gameObject = ((Component)warningObject).gameObject;
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if (DimensionRegistry.AreInSameDimension(gameObject, (localPlayer != null) ? ((Component)localPlayer).gameObject : null))
			{
				if ((int)StartOfRound.Instance.currentLevel.currentWeather != 2)
				{
					PlayerControllerB localPlayer2 = LFCUtilities.LocalPlayer;
					return DimensionRegistry.IsInUpsideDown((localPlayer2 != null) ? ((Component)localPlayer2).gameObject : null);
				}
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(StormyWeather), "PlayThunderEffects")]
		[HarmonyPrefix]
		private static void FogFlash()
		{
			UpsideDownAtmosphereController.Instance?.TriggerLightning();
		}
	}
	public class VehicleControllerPatch
	{
		[HarmonyPatch(typeof(VehicleController), "Start")]
		[HarmonyPostfix]
		private static void StartVehicleController(VehicleController __instance)
		{
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)null)
			{
				DimensionRegistry.UpdateVisibilityState(((Component)__instance).gameObject);
			}
		}
	}
}
namespace StrangerThings.ModsCompat
{
	public static class LethalMinSoftCompat
	{
		public static void Patch(Harmony harmony)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			Type type = Type.GetType("LethalMin.PikminAI, NoteBoxz.LethalMin");
			if (type != null)
			{
				MethodInfo methodInfo = AccessTools.Method(type, "Start", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(LethalMinSoftCompat), "Start", (Type[])null, (Type[])null));
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void Start(object __instance)
		{
			EnemyAI val = (EnemyAI)((__instance is EnemyAI) ? __instance : null);
			if (val != null)
			{
				PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
				if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, ((Component)val).gameObject))
				{
					DimensionRegistry.UpdateVisibilityState(((Component)val).gameObject);
				}
			}
		}
	}
	public static class MelaniesVoiceSoftCompat
	{
		private static PropertyInfo piPlayerAudioGroup;

		private static PropertyInfo piPlayerScript;

		private static PropertyInfo piGroupVolume;

		public static void Patch(Harmony harmony)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			Type type = Type.GetType("com.github.zehsteam.MelaniesVoice.MonoBehaviours.VoiceController, com.github.zehsteam.MelaniesVoice");
			if (type != null)
			{
				MethodInfo methodInfo = AccessTools.Method(type, "UpdateVoiceVolume", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					piPlayerAudioGroup = AccessTools.Property(type, "PlayerAudioGroup");
					piPlayerScript = AccessTools.Property(type, "PlayerScript");
					HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(MelaniesVoiceSoftCompat), "UpdateVoiceVolume", (Type[])null, (Type[])null));
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void UpdateVoiceVolume(object __instance)
		{
			if (__instance == null)
			{
				return;
			}
			PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
			if ((Object)(object)localPlayer == (Object)null || !localPlayer.isPlayerControlled || localPlayer.isPlayerDead)
			{
				return;
			}
			object? obj = piPlayerScript?.GetValue(__instance, null);
			PlayerControllerB val = (PlayerControllerB)((obj is PlayerControllerB) ? obj : null);
			if (!LFCUtilities.ShouldNotBeLocalPlayer(val) || DimensionRegistry.AreInSameDimension(((Component)localPlayer).gameObject, ((Component)val).gameObject))
			{
				return;
			}
			object obj2 = piPlayerAudioGroup?.GetValue(__instance, null);
			if (obj2 == null)
			{
				return;
			}
			if (piGroupVolume == null)
			{
				piGroupVolume = AccessTools.Property(obj2.GetType(), "Volume");
			}
			float num = ((piGroupVolume != null) ? ((float)piGroupVolume.GetValue(obj2, null)) : 0f);
			if (num > 0f)
			{
				float num2 = ((!DimensionRegistry.IsInUpsideDown(((Component)localPlayer).gameObject)) ? (((!localPlayer.speakingToWalkieTalkie || !val.holdingWalkieTalkie) && (!val.speakingToWalkieTalkie || !localPlayer.holdingWalkieTalkie)) ? 0f : (MapObjectsManager.IsNearAntennaHazard(val) ? 1f : 0f)) : (((!localPlayer.speakingToWalkieTalkie || !val.holdingWalkieTalkie) && (!val.speakingToWalkieTalkie || !localPlayer.holdingWalkieTalkie)) ? 0.1f : (MapObjectsManager.IsNearAntennaHazard(localPlayer) ? 1f : 0f)));
				if (piGroupVolume != null && piGroupVolume.CanWrite)
				{
					piGroupVolume.SetValue(obj2, num * num2, null);
				}
			}
		}
	}
	public static class OpenBodyCamsSoftCompat
	{
		private static FieldInfo fiCurrentActualTarget;

		private static FieldInfo fiCurrentPlayer;

		private static FieldInfo fiEnableCamera;

		private static MethodInfo miGetForceTargetInvalid;

		private static Type statusEnumType;

		private static object statusDisabled;

		private static object statusTargetInvalid;

		public static void Patch(Harmony harmony)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			Type type = Type.GetType("OpenBodyCams.BodyCamComponent, OpenBodyCams");
			if (!(type != null))
			{
				return;
			}
			MethodInfo methodInfo = AccessTools.Method(type, "GetUpdatedCameraStatus", (Type[])null, (Type[])null);
			if (!(methodInfo != null))
			{
				return;
			}
			statusEnumType = methodInfo.ReturnType;
			if (statusEnumType != null && statusEnumType.IsEnum)
			{
				statusDisabled = Enum.Parse(statusEnumType, "Disabled", ignoreCase: false);
				statusTargetInvalid = Enum.Parse(statusEnumType, "TargetInvalid", ignoreCase: false);
				fiEnableCamera = AccessTools.Field(type, "EnableCamera");
				miGetForceTargetInvalid = AccessTools.PropertyGetter(type, "ForceTargetInvalid");
				fiCurrentActualTarget = AccessTools.Field(type, "currentActualTarget");
				fiCurrentPlayer = AccessTools.Field(type, "currentPlayer");
				if (fiEnableCamera == null || miGetForceTargetInvalid == null || fiCurrentActualTarget == null || fiCurrentPlayer == null)
				{
					StrangerThings.mls.LogError((object)"OpenBodyCams compat: members not found.");
					return;
				}
				HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(OpenBodyCamsSoftCompat), "GetUpdatedCameraStatus_Prefix", (Type[])null, (Type[])null));
				harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private static bool GetUpdatedCameraStatus_Prefix(object __instance, ref object __result)
		{
			if (!(bool)fiEnableCamera.GetValue(__instance) || fiCurrentActualTarget.GetValue(__instance) == null || (bool)miGetForceTargetInvalid.Invoke(__instance, null))
			{
				return true;
			}
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)null && DimensionRegistry.IsInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject))
			{
				__result = statusDisabled;
				return false;
			}
			PlayerControllerB val = (PlayerControllerB)((fiCurrentPlayer != null) ? /*isinst with value type is only supported in some contexts*/: null);
			if ((Object)(object)LFCUtilities.LocalPlayer != (Object)null && (Object)(object)val != (Object)null && val.isPlayerControlled && !DimensionRegistry.AreInSameDimension(((Component)LFCUtilities.LocalPlayer).gameObject, ((Component)val).gameObject))
			{
				__result = statusTargetInvalid;
				return false;
			}
			return true;
		}
	}
	public static class SelfSortingStorageSoftCompat
	{
		public static void Patch(Harmony harmony)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			Type type = Type.GetType("SelfSortingStorage.Utils.Effects, SelfSortingStorage") ?? AccessTools.TypeByName("SelfSortingStorage.Utils.Effects");
			if (type != null)
			{
				MethodInfo methodInfo = AccessTools.Method(type, "SpawnItem", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(SelfSortingStorageSoftCompat), "SpawnItem", (Type[])null, (Type[])null));
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void SpawnItem(object __result)
		{
			//IL_0045: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			if (__result == null)
			{
				return;
			}
			FieldInfo fieldInfo = AccessTools.GetDeclaredFields(__result.GetType()).FirstOrDefault((FieldInfo f) => f.FieldType == typeof(NetworkObjectReference));
			if (fieldInfo == null)
			{
				return;
			}
			NetworkObjectReference val = (NetworkObjectReference)fieldInfo.GetValue(__result);
			NetworkObject val2 = default(NetworkObject);
			if (((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null) && (Object)(object)val2 != (Object)null)
			{
				GrabbableObject component = ((Component)val2).GetComponent<GrabbableObject>();
				if (component is UpsideDownObject)
				{
					StrangerThingsNetworkManager.Instance?.SetGObjectInUpsideDownEveryoneRpc(NetworkObjectReference.op_Implicit(val2), isInUpsideDown: false);
				}
			}
		}
	}
	public static class SpectateEnemySoftCompat
	{
		private static FieldInfo fiSpectatedEnemyIndex;

		private static FieldInfo fiSpectatingEnemies;

		private static FieldInfo fiSpectatorList;

		public static void Patch(Harmony harmony)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			Type type = Type.GetType("SpectateEnemy.SpectateEnemies, SpectateEnemy");
			if (type != null)
			{
				MethodInfo methodInfo = AccessTools.Method(type, "GetNextValidSpectatable", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					HarmonyMethod val = new HarmonyMethod(AccessTools.Method(typeof(SpectateEnemySoftCompat), "GetNextValidSpectatable", (Type[])null, (Type[])null));
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
					fiSpectatedEnemyIndex = AccessTools.Field(type, "SpectatedEnemyIndex");
					fiSpectatingEnemies = AccessTools.Field(type, "SpectatingEnemies");
					fiSpectatorList = AccessTools.Field(type, "SpectatorList");
				}
			}
		}

		private static void GetNextValidSpectatable(object __instance)
		{
			if (fiSpectatedEnemyIndex != null && fiSpectatingEnemies != null && (bool)fiSpectatingEnemies.GetValue(__instance) && fiSpectatorList != null)
			{
				int index = (int)fiSpectatedEnemyIndex.GetValue(__instance);
				IEnumerable<object> source = (IEnumerable<object>)fiSpectatorList.GetValue(__instance);
				object obj = source.ElementAtOrDefault(index);
				object? obj2 = AccessTools.Field(obj.GetType(), "enemyInstance")?.GetValue(obj);
				EnemyAI val = (EnemyAI)((obj2 is EnemyAI) ? obj2 : null);
				PlayerControllerB localPlayer = LFCUtilities.LocalPlayer;
				if (!DimensionRegistry.AreInSameDimension((localPlayer != null) ? ((Component)localPlayer).gameObject : null, (val != null) ? ((Component)val).gameObject : null))
				{
					DimensionRegistry.SetInUpsideDown(((Component)LFCUtilities.LocalPlayer).gameObject, DimensionRegistry.IsInUpsideDown(((Component)val).gameObject));
				}
			}
		}
	}
}
namespace StrangerThings.Managers
{
	public class ConfigManager
	{
		public static ConfigEntry<bool> globalTips;

		public static ConfigEntry<int> minMirrorScraps;

		public static ConfigEntry<int> maxMirrorScraps;

		public static ConfigEntry<bool> colorBlindTips;

		public static ConfigEntry<string> scrapExclusions;

		public static ConfigEntry<string> demogorgonSpawnWeights;

		public static ConfigEntry<int> demogorgonRarity;

		public static ConfigEntry<int> demogorgonMinHeadValue;

		public static ConfigEntry<int> demogorgonMaxHeadValue;

		public static ConfigEntry<int> crustapikanRarity;

		public static ConfigEntry<int> crustapikanMinArmValue;

		public static ConfigEntry<int> crustapikanMaxArmValue;

		public static ConfigEntry<int> crustapikanLarvaeRarity;

		public static ConfigEntry<int> crustapikanLarvaeMinCorpseValue;

		public static ConfigEntry<int> crustapikanLarvaeMaxCorpseValue;

		public static ConfigEntry<int> limadonRarity;

		public static ConfigEntry<int> limadonMinCorpseValue;

		public static ConfigEntry<int> limadonMaxCorpseValue;

		public static ConfigEntry<int> portalLockDuration;

		public static ConfigEntry<float> upsideDownVolume;

		public static ConfigEntry<string> visibilityStateInclusions;

		public static ConfigEntry<string> visibilityStateExclusions;

		public static ConfigEntry<int> minBatsHordeOutside;

		public static ConfigEntry<int> maxBatsHordeOutside;

		public static ConfigEntry<int> minBatsHordeInside;

		public static ConfigEntry<int> maxBatsHordeInside;

		public static void Load()
		{
			globalTips = StrangerThings.configFile.Bind<bool>("_Global_", "Global tips", true, "Enable global tips to help learn the mod’s mechanics.");
			minMirrorScraps = StrangerThings.configFile.Bind<int>("Mirror Scraps", "Min Mirror Scraps", 6, "Min Mirror Scraps.");
			maxMirrorScraps = StrangerThings.configFile.Bind<int>("Mirror Scraps", "Max Mirror Scraps", 10, "Max Mirror Scraps.");
			colorBlindTips = StrangerThings.configFile.Bind<bool>("Mirror Scraps", "Colorblind tips", true, "Enable particle color change notifications for mirror Mirror Scraps.");
			scrapExclusions = StrangerThings.configFile.Bind<string>("Mirror Scraps", "Exclusion list", "Key,Bee hive,Apparatus,EnginePart1,V-type engine,Toy car", "List of scraps that will not spawn in the Upside Down.\nYou can add scraps by separating them with a comma.");
			demogorgonSpawnWeights = StrangerThings.configFile.Bind<string>("Demogorgon", "Spawn weights", "Vanilla:20,Modded:20", "Demogorgon spawn weights.");
			demogorgonRarity = StrangerThings.configFile.Bind<int>("Demogorgon", "Rarity", 20, "Demogorgon Kidnapper base rarity (Upside Down spawn).");
			demogorgonMinHeadValue = StrangerThings.configFile.Bind<int>("Demogorgon", "Min head value", 80, "Demogorgon min head value (SellBodiesFixed must be installed).");
			demogorgonMaxHeadValue = StrangerThings.configFile.Bind<int>("Demogorgon", "Max head value", 120, "Demogorgon max head value (SellBodiesFixed must be installed).");
			crustapikanRarity = StrangerThings.configFile.Bind<int>("Crustapikan", "Rarity", 20, "Crustapikan base rarity.");
			crustapikanMinArmValue = StrangerThings.configFile.Bind<int>("Crustapikan", "Min arm value", 250, "Crustapikan min arm value (SellBodiesFixed must be installed).");
			crustapikanMaxArmValue = StrangerThings.configFile.Bind<int>("Crustapikan", "Max arm value", 300, "Crustapikan max arm value (SellBodiesFixed must be installed).");
			crustapikanLarvaeRarity = StrangerThings.configFile.Bind<int>("Crustapikan Larvae", "Rarity", 20, "Crustapikan Larvae base rarity.");
			crustapikanLarvaeMinCorpseValue = StrangerThings.configFile.Bind<int>("Crustapikan Larvae", "Min corpse value", 20, "Crustapikan Larvae min corpse value (SellBodiesFixed must be installed).");
			crustapikanLarvaeMaxCorpseValue = StrangerThings.configFile.Bind<int>("Crustapikan Larvae", "Max corpse value", 40, "Crustapikan Larvae max corpse value (SellBodiesFixed must be installed).");
			limadonRarity = StrangerThings.configFile.Bind<int>("Limadon", "Rarity", 20, "Limadon base rarity.");
			limadonMinCorpseValue = StrangerThings.configFile.Bind<int>("Limadon", "Min corpse value", 70, "Limadon min corpse value (SellBodiesFixed must be installed).");
			limadonMaxCorpseValue = StrangerThings.configFile.Bind<int>("Limadon", "Max corpse value", 110, "Limadon max corpse value (SellBodiesFixed must be installed).");
			portalLockDuration = StrangerThings.configFile.Bind<int>("Upside Down", "Portal lock duration", 60, "Portal lock duration when entering or exiting.");
			upsideDownVolume = StrangerThings.configFile.Bind<float>("Upside Down", "Upside Down volume", 0.6f, "Volume of background music in the Upside Down.");
			visibilityStateInclusions = StrangerThings.configFile.Bind<string>("Upside Down", "Visibility state whitelist", "SP_Snowman,SP_SnowPile,LK_Lantern,SawBoxExplosive,ChainEscape,Sprout", "Additional list of Network Objects whose visibility (visible/invisible) will be updated when switching between dimensions.");
			visibilityStateExclusions = StrangerThings.configFile.Bind<string>("Upside Down", "Visibility state blacklist", "Locker,DressGirl", "Network Objects whose visibility (visible/invisible) will not be updated when switching between dimensions.");
			minBatsHordeOutside = StrangerThings.configFile.Bind<int>("Bats Horde", "Min outside", 3, "Min Bats Horde to spawn outside.");
			maxBatsHordeOutside = StrangerThings.configFile.Bind<int>("Bats Horde", "Max outside", 4, "Min Bats Horde to spawn outside.");
			minBatsHordeInside = StrangerThings.configFile.Bind<int>("Bats Horde", "Min inside", 4, "Min Bats Horde to spawn inside.");
			maxBatsHordeInside = StrangerThings.configFile.Bind<int>("Bats Horde", "Max inside", 5, "Min Bats Horde to spawn inside.");
		}

		public static (Dictionary<LevelTypes, int> spawnRateByLevelType, Dictionary<string, int> spawnRateByCustomLevelType) GetDemogorgonsSpawns()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<LevelTypes, int> dictionary = new Dictionary<LevelTypes, int>();
			Dictionary<string, int> dictionary2 = new Dictionary<string, int>();
			foreach (string item in from s in demogorgonSpawnWeights.Value.Split(',')
				select s.Trim())
			{
				string[] array = item.Split(':');
				if (array.Length != 2)
				{
					continue;
				}
				string text = array[0];
				if (int.TryParse(array[1], out var result))
				{
					if (Enum.TryParse<LevelTypes>(text, ignoreCase: true, out LevelTypes result2))
					{
						dictionary[result2] = result;
					}
					else
					{
						dictionary2[text] = result;
					}
				}
			}
			return (dictionary, dictionary2);
		}
	}
	public static class MapObjectsManager
	{
		public static HashSet<UpsideDownPortal> upsideDownPortals = new HashSet<UpsideDownPortal>();

		public static HashSet<AntennaHazard> antennaHazards = new HashSet<AntennaHazard>();

		public static void AddUpsideDownPortal(UpsideDownPortal upsideDownPortal)
		{
			upsideDownPortals.Add(upsideDownPortal);
		}

		public static UpsideDownPortal[] GetUpsideDownPortals()
		{
			upsideDownPortals.RemoveWhere((UpsideDownPortal p) => (Object)(object)p == (Object)null);
			return upsideDownPortals.Where((UpsideDownPortal p) => !p.isFake).ToArray();
		}

		public static void SpawnPortalsForServer()
		{
			if (GetUpsideDownPortals().Length < 8)
			{
				LFCMapObjectsManager.SpawnScatteredMapObjectsForServer(8, 2, 2, (Action<Vector3, bool>)delegate(Vector3 position, bool isOutside)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					SpawnUpsideDownPortalForServer(position, isOutside);
				});
			}
		}

		public static UpsideDownPortal SpawnUpsideDownPortalForServer(Vector3 position, bool isOutside, bool isFake = false)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001a: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(StrangerThings.upsideDownPortal, position + Vector3.down * 0.1f, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
			val.GetComponent<NetworkObject>().Spawn(true);
			UpsideDownPortal component = val.GetComponent<UpsideDownPortal>();
			component.InitializeEveryoneRpc(isOutside, isFake);
			return component;
		}

		public static UpsideDownPortal GetClosestPortal(Vector3 position)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			UpsideDownPortal result = null;
			float num = float.MaxValue;
			UpsideDownPortal[] array = GetUpsideDownPortals();
			foreach (UpsideDownPortal upsideDownPortal in array)
			{
				if ((Object)(object)upsideDownPortal != (Object)null)
				{
					float num2 = Vector3.SqrMagnitude(((Component)upsideDownPortal).transform.position - position);
					if (num2 < num)
					{
						num = num2;
						result = upsideDownPortal;
					}
				}
			}
			return result;
		}

		public static UpsideDownPortal GetFurthestPortal(Vector3 position)
		{
			//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_002e: Unknown result type (might be due to invalid IL or missing references)
			UpsideDownPortal result = null;
			float num = 0f;
			UpsideDownPortal[] array = GetUpsideDownPortals();
			foreach (UpsideDownPortal upsideDownPortal in array)
			{
				if ((Object)(object)upsideDownPortal != (Object)null)
				{
					float num2 = Vector3.SqrMagnitude(((Component)upsideDownPortal).transform.position - position);
					if (num2 > num)
					{
						num = num2;
						result = upsideDownPortal;
					}
				}
			}
			return result;
		}

		public static void AddAntennaHazards(AntennaHazard antennaHazard)
		{
			antennaHazards.Add(antennaHazard);
		}

		public static HashSet<AntennaHazard> GetAntennaHazards()
		{
			antennaHazards.RemoveWhere((AntennaHazard p) => (Object)(object)p == (Object)null);
			return antennaHazards;
		}

		public static bool IsNearAntennaHazard(PlayerControllerB player)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			foreach (AntennaHazard antennaHazard in GetAntennaHazards())
			{
				if ((Object)(object)antennaHazard != (Object)null && (Object)(object)antennaHazard.antennaItem != (Object)null)
				{
					float num = Vector3.SqrMagnitude(((Component)antennaHazard).transform.position - ((Component)player).transform.position);
					if (num < 5625f)
					{
						return true;
					}
				}
			}
			return false;
		}
	}
	public class StrangerThingsNetworkManager : NetworkBehaviour
	{
		public static StrangerThingsNetworkManager Instance;

		public void Awake()
		{
			Instance = this;
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void SpawnUpsideDownTreesEveryoneRpc(int seed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL