using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Beyond.Core;
using Beyond.Plugin.Integration;
using Beyond.Plugin.Runtime;
using Beyond.Plugin.World;
using HarmonyLib;
using Jotunn;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using PassiveTree;
using SoftReferenceableAssets;
using Splatform;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Brom8")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.32.1.0")]
[assembly: AssemblyInformationalVersion("0.32.1+7631678d0972989b79d54fd3945dbfa47aa166be")]
[assembly: AssemblyProduct("Beyond")]
[assembly: AssemblyTitle("Beyond")]
[assembly: AssemblyVersion("0.32.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Beyond.Plugin
{
	[BepInPlugin("brom8.beyond", "Beyond", "0.32.1")]
	[BepInDependency("com.jotunn.jotunn", "2.30.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class BeyondPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "brom8.beyond";

		public const string PluginName = "Beyond";

		public const string PluginVersion = "0.32.1";

		public const string PathOfValheimanGuid = "treextr.pathofvalheiman";

		private BeyondSettings _settings;

		private string _assetReport = "Asset probe pending world prefab registration.";

		private string _targetVersion = "unknown";

		private bool _loaded;

		private bool _voidRegistryPending;

		private Harmony? _patches;

		internal static BeyondPlugin? Instance { get; private set; }

		internal TrialRuntime? Runtime { get; private set; }

		internal void LoggerForWorld(string message)
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)message);
		}

		private void Awake()
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			TestSaveDirectory.Apply(((BaseUnityPlugin)this).Logger);
			_settings = new BeyondSettings(((BaseUnityPlugin)this).Config);
			Instance = this;
			Runtime = new TrialRuntime(_settings, ((BaseUnityPlugin)this).Logger);
			_patches = new Harmony("brom8.beyond");
			try
			{
				_patches.PatchAll(typeof(BeyondPlugin).Assembly);
			}
			catch (Exception ex)
			{
				_patches.UnpatchSelf();
				Runtime.Dispose();
				Runtime = null;
				((BaseUnityPlugin)this).Logger.LogError((object)("Beyond could not install its scoped game hooks and has stopped: " + ex));
				return;
			}
			if (Chainloader.PluginInfos.TryGetValue("treextr.pathofvalheiman", out var value))
			{
				_targetVersion = value.Metadata.Version.ToString();
			}
			PrefabManager.OnPrefabsRegistered += OnPrefabsRegistered;
			ItemManager.OnItemsRegistered += OnVoidItemsRegistered;
			PrefabManager.OnVanillaPrefabsAvailable += RegisterContent;
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new StatusCommand(Describe, delegate(string text)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)text);
			}));
			_loaded = true;
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Beyond 0.32.1 experimental Trial loaded; PathOfValheiman " + _targetVersion + ". Use the separate test profile and test saves."));
		}

		private void RegisterContent()
		{
			try
			{
				TrialEnemyDirector.RegisterPrefab();
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Beyond content registration failed: " + ex));
				Runtime?.BlockStarts("Beyond content is unavailable. Check the host log and restart after fixing dependencies.");
			}
			try
			{
				VoidCreatures.Register();
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Void creatures registered: Beyond_VoidEidolon, Beyond_Riftstalker, Beyond_HollowCantor, Beyond_VoidBlob (no rewards).");
			}
			catch (Exception ex2)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Void creature registration failed; do not use their spawn commands: " + ex2));
			}
		}

		private void Update()
		{
			Runtime?.Tick();
		}

		private void LateUpdate()
		{
			Runtime?.LateUpdate();
		}

		private void OnPrefabsRegistered()
		{
			_assetReport = VisualAssets.Probe();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Beyond asset probe:\n" + _assetReport));
			if (EnemyPrefabRegistry.CheckScene(out string message))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			}
			else
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)message);
			}
			_voidRegistryPending = true;
			if (!VoidBlob.CheckWeapon())
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Void spawn registry: waiting for ObjectDB animation-weapon registration.");
			}
			else
			{
				OnVoidItemsRegistered();
			}
		}

		private void OnVoidItemsRegistered()
		{
			if (_voidRegistryPending && !((Object)(object)ZNetScene.instance == (Object)null))
			{
				_voidRegistryPending = false;
				if (VoidCreatures.CheckScene(out string message))
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)message);
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogError((object)message);
				}
			}
		}

		private string Describe()
		{
			if (!_loaded)
			{
				return "Beyond foundation is not active.";
			}
			FloorRules val = _settings.SnapshotTrial();
			return "Beyond 0.32.1 | PathOfValheiman " + _targetVersion + "\n" + $"Floor 0 Trial: gate {val.EntryWindowSeconds}s, survival {val.SurvivalSeconds}s, shared coin pool {val.CoinPool}, participant cap {val.ParticipantLimit}.\n" + "Experimental Beyond: " + Runtime?.Status + "\n" + Runtime?.Client?.GroundStatus + "\n" + _assetReport;
		}

		private void OnDestroy()
		{
			_loaded = false;
			PrefabManager.OnPrefabsRegistered -= OnPrefabsRegistered;
			ItemManager.OnItemsRegistered -= OnVoidItemsRegistered;
			PrefabManager.OnVanillaPrefabsAvailable -= RegisterContent;
			Runtime?.Dispose();
			VoidModels.Dispose();
			Harmony? patches = _patches;
			if (patches != null)
			{
				patches.UnpatchSelf();
			}
			Instance = null;
		}
	}
	internal sealed class BeyondSettings
	{
		private readonly ConfigEntry<float>[] _floorHealth = new ConfigEntry<float>[21];

		private readonly ConfigEntry<float>[] _floorDamage = new ConfigEntry<float>[21];

		private readonly ConfigEntry<int>[] _offerPrices = new ConfigEntry<int>[ShopCatalogue.ExtendedOffers.Count];

		public ConfigEntry<int> EntryCoinsPerFloor { get; }

		public ConfigEntry<int> ClearCoinsPerFloor { get; }

		public ConfigEntry<bool> AllowNewRuns { get; }

		public ConfigEntry<int> ScalingStartFloor { get; }

		public ConfigEntry<float> HealthGrowth { get; }

		public ConfigEntry<KeyboardShortcut> MenuShortcut { get; }

		public ConfigEntry<float> DamageGrowth { get; }

		public ConfigEntry<float> NamedHealthBonusEffect { get; }

		public ConfigEntry<int> EntryWindowSeconds { get; }

		public ConfigEntry<int> SurvivalSeconds { get; }

		public ConfigEntry<int> CoinPool { get; }

		public ConfigEntry<int> ParticipantLimit { get; }

		public ConfigEntry<int> MaxInstances { get; }

		public ConfigEntry<int> EnemyLimit { get; }

		public ConfigEntry<int> IronPrice { get; }

		public ConfigEntry<int> TinPrice { get; }

		public ConfigEntry<int> CopperPrice { get; }

		public ConfigEntry<int> BronzePrice { get; }

		public ConfigEntry<int> SimpleRunePacketPrice { get; }

		public ConfigEntry<int> SurtlingCorePrice { get; }

		public ConfigEntry<int> CoreWoodPrice { get; }

		public ConfigEntry<int> FineWoodPrice { get; }

		public ConfigEntry<int> AncientBarkPrice { get; }

		public ConfigEntry<int> GuckPrice { get; }

		public ConfigEntry<int> SilverPrice { get; }

		public ConfigEntry<int> ObsidianPrice { get; }

		public ConfigEntry<int> CrystalPrice { get; }

		public SharedRealmSettings Realm { get; }

		public BeyondSettings(ConfigFile config)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected O, but got Unknown
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Expected O, but got Unknown
			//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f0: Expected O, but got Unknown
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Expected O, but got Unknown
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Expected O, but got Unknown
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Expected O, but got Unknown
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Expected O, but got Unknown
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Expected O, but got Unknown
			//IL_0508: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Expected O, but got Unknown
			//IL_053a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0544: Expected O, but got Unknown
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Expected O, but got Unknown
			//IL_059c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Expected O, but got Unknown
			//IL_0634: Unknown result type (might be due to invalid IL or missing references)
			//IL_063e: Expected O, but got Unknown
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Expected O, but got Unknown
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b5: Expected O, but got Unknown
			//IL_070d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0717: Expected O, but got Unknown
			//IL_0744: Unknown result type (might be due to invalid IL or missing references)
			//IL_074e: Expected O, but got Unknown
			//IL_077b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0785: Expected O, but got Unknown
			//IL_07b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07bc: Expected O, but got Unknown
			//IL_07e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f3: Expected O, but got Unknown
			//IL_0820: Unknown result type (might be due to invalid IL or missing references)
			//IL_082a: Expected O, but got Unknown
			//IL_0857: Unknown result type (might be due to invalid IL or missing references)
			//IL_0861: Expected O, but got Unknown
			//IL_088e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0898: Expected O, but got Unknown
			//IL_08c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cf: Expected O, but got Unknown
			//IL_08fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0906: Expected O, but got Unknown
			//IL_0933: Unknown result type (might be due to invalid IL or missing references)
			//IL_093d: Expected O, but got Unknown
			//IL_096a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0974: Expected O, but got Unknown
			//IL_0990: Unknown result type (might be due to invalid IL or missing references)
			//IL_099a: Expected O, but got Unknown
			Realm = new SharedRealmSettings(config);
			ConfigEntry<KeyboardShortcut> val = config.Bind<KeyboardShortcut>("UI", "MenuShortcut", new KeyboardShortcut((KeyCode)289, Array.Empty<KeyCode>()), "Retired shortcut location.");
			MenuShortcut = config.Bind<KeyboardShortcut>("00 - Interface", "MenuShortcut", val.Value, "Local Beyond menu shortcut. Default F8. Inventory can stay open; approach the stone to open a portal. Suppressed while typing, fighting in Beyond or using other blocking interfaces.");
			config.Remove(((ConfigEntryBase)val).Definition);
			ConfigurationManagerAttributes val2 = new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			};
			EntryCoinsPerFloor = config.Bind<int>("01 - Economy", "EntryCoinsPerFloor", 100, new ConfigDescription("Numbered floor entry = floor number times this amount. Bank first plus carried shortfall. Only opener pays; friends enter free.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50000), new object[1] { val2 }));
			ClearCoinsPerFloor = config.Bind<int>("01 - Economy", "ClearCoinsPerFloor", 300, new ConfigDescription("Numbered clear reward = floor number times this amount. Banked only for a surviving opener. Trial remains 200 by default.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 50000), new object[1] { val2 }));
			foreach (ShopOffer extendedOffer in ShopCatalogue.ExtendedOffers)
			{
				_offerPrices[extendedOffer.PriceIndex] = config.Bind<int>("Shop.Floor" + extendedOffer.Tab, extendedOffer.Request + "Price", extendedOffer.DefaultPrice, new ConfigDescription("Coin price for " + extendedOffer.Quantity + " " + extendedOffer.DisplayName + ". Captured at run start.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			}
			ScalingStartFloor = config.Bind<int>("Scaling", "StartFloor", 1, new ConfigDescription("First floor receiving one growth step. Floor1 at10% grows to1.10x; Floor2 to1.21x. Trial stays neutral by default.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000), new object[1] { val2 }));
			ConfigEntry<int> val3 = config.Bind<int>("Migration", "ScalingRevision", 0, "Internal default migration; leave unchanged.");
			if (val3.Value < 1)
			{
				if (ScalingStartFloor.Value == 10)
				{
					ScalingStartFloor.Value = 1;
				}
				val3.Value = 1;
			}
			NamedHealthBonusEffect = config.Bind<float>("Scaling", "NamedHealthBonusEffect", 2f, new ConfigDescription("Multiply only the added health-growth bonus for required named targets.2 means normal+21% becomes named+42%; authored base health/stars/rarity and per-floor overrides remain separate. Captured at run start.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 5f), new object[1] { val2 }));
			HealthGrowth = config.Bind<float>("Scaling", "HealthGrowthPerFloor", 0.1f, new ConfigDescription("Additional compounded health growth per floor from StartFloor. 0.10 means 10%; final factors clamp to 0.01..100.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1] { val2 }));
			DamageGrowth = config.Bind<float>("Scaling", "DamageGrowthPerFloor", 0f, new ConfigDescription("Separate compounded damage growth per floor from StartFloor. Default 0 keeps damage unchanged.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), new object[1] { val2 }));
			for (int i = 0; i <= 20; i++)
			{
				string text = ((i == 0) ? "Trial" : ("Floor" + i));
				_floorHealth[i] = config.Bind<float>(text, "HealthMultiplier", 1f, new ConfigDescription("Additional health multiplier for this floor; combines once with Scaling growth and PoV difficulty. Captured at run start.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), new object[1] { val2 }));
				_floorDamage[i] = config.Bind<float>(text, "DamageMultiplier", 1f, new ConfigDescription("Additional damage multiplier for this floor; default 1. Captured at run start.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), new object[1] { val2 }));
			}
			AllowNewRuns = config.Bind<bool>("General", "AllowNewRuns", true, new ConfigDescription("Enable new Beyond runs. Disable to stop new runs while retaining recovery/exits. Use test saves.", (AcceptableValueBase)null, new object[1] { val2 }));
			EntryWindowSeconds = config.Bind<int>("Trial", "EntryWindowSeconds", 10, new ConfigDescription("Entry reservation window for all floors (legacy Trial section). Accepted transfers have a bounded arrival wait before combat.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 120), new object[1] { val2 }));
			SurvivalSeconds = config.Bind<int>("Trial", "SurvivalSeconds", 100, new ConfigDescription("Host survival duration in seconds; captured when an attempt starts.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 3600), new object[1] { val2 }));
			CoinPool = config.Bind<int>("Trial", "CoinPool", 200, new ConfigDescription("Trial reward banked for the surviving portal opener. Design default: 200.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 1000000), new object[1] { val2 }));
			for (int j = 1; j <= 20; j++)
			{
				ConfigEntry<int> val4 = config.Bind<int>("Floor" + j, "CoinPool", 300 * j, "Retired by C11 economy.");
				config.Remove(((ConfigEntryBase)val4).Definition);
			}
			ParticipantLimit = config.Bind<int>("Dungeons", "ParticipantLimit", 8, new ConfigDescription("Bound on unique participants in one attempt. Initial test target is solo then two players.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 16), new object[1] { val2 }));
			MaxInstances = config.Bind<int>("Dungeons", "MaxConcurrentInstances", 4, new ConfigDescription("Maximum simultaneous Beyond instances, including shops and pending returns. Fixed support layouts are pooled; hard maximum 4.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 4), new object[1] { val2 }));
			ConfigEntry<int> val5 = config.Bind<int>("Trial", "MaxLivingEnemies", 50, new ConfigDescription("Retired Trial limit, migrated to the per-instance setting.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			EnemyLimit = config.Bind<int>("Dungeons", "MaxLivingEnemiesPerInstance", val5.Value, new ConfigDescription("Living-enemy limit for EACH independent Beyond instance, including boss/adds. No shared population cap. Four instances can total 200 enemies at 50 each. Spawn pacing stays bounded.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), new object[1] { val2 }));
			ConfigEntry<int> val6 = config.Bind<int>("Dungeons", "MaxLivingEnemiesTotal", 50, "Retired shared cap; no longer enforced.");
			config.Remove(((ConfigEntryBase)val5).Definition);
			config.Remove(((ConfigEntryBase)val6).Definition);
			config.Save();
			ConfigEntry<int> val7 = config.Bind<int>("Shop", "BeyondEntranceKeyPrice", 100, "Retired item.");
			config.Remove(((ConfigEntryBase)val7).Definition);
			IronPrice = config.Bind<int>("Shop", "TrialIronPrice", 100, new ConfigDescription("Standard coin price for a packet of 2 iron bars in floor tab 3. Legacy setting name retained.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			ConfigEntry<int> val8 = config.Bind<int>("Migration", "IronPriceRevision", 0, new ConfigDescription("Internal one-time iron-price migration marker.", (AcceptableValueBase)null, Array.Empty<object>()));
			if (val8.Value < 1)
			{
				if (IronPrice.Value == 10)
				{
					IronPrice.Value = 50;
				}
				val8.Value = 1;
			}
			ConfigEntry<int> val9 = config.Bind<int>("Migration", "IronPacketRevision", 0, new ConfigDescription("Internal one-time migration of the former iron default to packet pricing.", (AcceptableValueBase)null, Array.Empty<object>()));
			if (val9.Value < 1)
			{
				if (IronPrice.Value == 50)
				{
					IronPrice.Value = 100;
				}
				val9.Value = 1;
			}
			TinPrice = config.Bind<int>("Shop", "TinPrice", 10, new ConfigDescription("Standard coin price per Tin bar in the Trial tab.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			CopperPrice = config.Bind<int>("Shop", "CopperPrice", 10, new ConfigDescription("Standard coin price per Copper bar in the Trial tab.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			BronzePrice = config.Bind<int>("Shop", "BronzePrice", 30, new ConfigDescription("Standard coin price per Bronze bar in the Trial tab.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			SimpleRunePacketPrice = config.Bind<int>("Shop", "SimpleRunePacketPrice", 100, new ConfigDescription("Standard coin price per basic PoV rune packet in every Trial tab. Fixed packets use base ordinary-dust costs at 100 dust: Insight/Guise 10, Spark 7, Weaving 5, Change 4. Ignores blank runestones and passive discounts. Host-controlled; captured at run start.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			SurtlingCorePrice = config.Bind<int>("Shop", "SurtlingCorePrice", 100, new ConfigDescription("Standard coin price for a packet of 2 Surtling cores in floor tab 1.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			CoreWoodPrice = config.Bind<int>("Shop", "CoreWoodPrice", 100, new ConfigDescription("Standard coin price for a packet of 10 core wood in floor tab 2.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			FineWoodPrice = config.Bind<int>("Shop", "FineWoodPrice", 100, new ConfigDescription("Standard coin price for a packet of 10 fine wood in floor tab 2.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			AncientBarkPrice = config.Bind<int>("Shop", "AncientBarkPrice", 100, new ConfigDescription("Coin price per packet of 10 ancient bark in tab 4.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			GuckPrice = config.Bind<int>("Shop", "GuckPrice", 100, new ConfigDescription("Coin price per packet of 5 guck in tab 4.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			SilverPrice = config.Bind<int>("Shop", "SilverPrice", 100, new ConfigDescription("Coin price per packet of 2 silver bars in tab 5.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			ObsidianPrice = config.Bind<int>("Shop", "ObsidianPrice", 100, new ConfigDescription("Coin price per packet of 10 obsidian in tab 6.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			CrystalPrice = config.Bind<int>("Shop", "CrystalPrice", 100, new ConfigDescription("Coin price per packet of 5 crystal in tab 6.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 1000000), new object[1] { val2 }));
			ConfigEntry<int> val10 = config.Bind<int>("Migration", "ShopPacketRevision", 0, new ConfigDescription("Internal one-time migration of former default unit prices to packet prices.", (AcceptableValueBase)null, Array.Empty<object>()));
			if (val10.Value < 1)
			{
				if (SurtlingCorePrice.Value == 50)
				{
					SurtlingCorePrice.Value = 100;
				}
				if (CoreWoodPrice.Value == 10)
				{
					CoreWoodPrice.Value = 100;
				}
				if (FineWoodPrice.Value == 10)
				{
					FineWoodPrice.Value = 100;
				}
				val10.Value = 1;
			}
			config.Save();
		}

		public CreaturePower SnapshotScaling(int floor)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			return new CreaturePower(FloorScaling.Factor(floor, ScalingStartFloor.Value, HealthGrowth.Value, _floorHealth[floor].Value), FloorScaling.Factor(floor, ScalingStartFloor.Value, DamageGrowth.Value, _floorDamage[floor].Value), (float?)FloorScaling.NamedFactor(FloorScaling.Factor(floor, ScalingStartFloor.Value, HealthGrowth.Value, 1f), NamedHealthBonusEffect.Value, _floorHealth[floor].Value));
		}

		public ShopPrices SnapshotShop()
		{
			return new ShopPrices
			{
				tin = TinPrice.Value,
				copper = CopperPrice.Value,
				bronze = BronzePrice.Value,
				iron = IronPrice.Value,
				surtlingCore = SurtlingCorePrice.Value,
				coreWood = CoreWoodPrice.Value,
				fineWood = FineWoodPrice.Value,
				ancientBark = AncientBarkPrice.Value,
				guck = GuckPrice.Value,
				silver = SilverPrice.Value,
				obsidian = ObsidianPrice.Value,
				crystal = CrystalPrice.Value,
				simpleRunePacket = SimpleRunePacketPrice.Value,
				extended = Array.ConvertAll(_offerPrices, (ConfigEntry<int> entry) => entry.Value)
			};
		}

		public FloorRules SnapshotTrial()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			return new FloorRules(0, (double)SurvivalSeconds.Value, CoinPool.Value, ParticipantLimit.Value, (double)EntryWindowSeconds.Value, 45.0, 2.0, (FloorObjective)0);
		}

		public FloorRules SnapshotFloor(int floor)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			if (floor != 0)
			{
				return new FloorRules(floor, 100.0, ClearCoinsPerFloor.Value * floor, ParticipantLimit.Value, (double)EntryWindowSeconds.Value, 45.0, 2.0, (FloorObjective)1);
			}
			return SnapshotTrial();
		}
	}
	internal sealed class SharedRealmSettings
	{
		public ConfigEntry<bool> Enabled { get; }

		public ConfigEntry<bool> LandscapePreview { get; }

		public ConfigEntry<int> MinimumFloor { get; }

		public ConfigEntry<int> RespawnSeconds { get; }

		public ConfigEntry<int> EnemyLimit { get; }

		public ConfigEntry<float> Health { get; }

		public ConfigEntry<float> Damage { get; }

		public SharedRealmSettings(ConfigFile file)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Expected O, but got Unknown
			ConfigurationManagerAttributes val = new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			};
			Enabled = file.Bind<bool>("Shared realm", "Enabled", true, new ConfigDescription("Host: allow new free shared-realm visits; exits/recovery remain available when disabled.", (AcceptableValueBase)null, new object[1] { val }));
			LandscapePreview = file.Bind<bool>("Shared realm", "LandscapePreview", true, new ConfigDescription("Host: new shared visits use the separate768m six-setting biome showcase (no enemies). False selects the original1km realm. Destination is pinned per visit; reload world to change.", (AcceptableValueBase)null, new object[1] { val }));
			MinimumFloor = file.Bind<int>("Shared realm", "MinimumCompletedFloor", 14, new ConfigDescription("Personal highest completion required for shared-realm entry. Use0 for testing after Trial.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), new object[1] { val }));
			RespawnSeconds = file.Bind<int>("Shared realm", "RespawnSeconds", 600, new ConfigDescription("Earliest respawn after confirmed native death processing, measured in host-running seconds. Living actors are never replaced.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(60, 3600), new object[1] { val }));
			EnemyLimit = file.Bind<int>("Shared realm", "MaxLivingEnemies", 50, new ConfigDescription("Independent shared-realm ceiling including named targets/adds. Not shared with numbered instances; authored initial roster is eight named targets.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), new object[1] { val }));
			Health = file.Bind<float>("Shared realm", "HealthMultiplier", 1f, new ConfigDescription("Additional shared-realm health factor, independent of numbered-floor exponential scaling. Native stars/authored base health remain explicit.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 20f), new object[1] { val }));
			Damage = file.Bind<float>("Shared realm", "DamageMultiplier", 1f, new ConfigDescription("Additional shared-realm damage factor. Physical-world biome/corruption multipliers are excluded.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 10f), new object[1] { val }));
		}
	}
	internal sealed class StatusCommand : ConsoleCommand
	{
		private readonly Func<string> _describe;

		private readonly Action<string> _writeLog;

		public override string Name => "beyond_status";

		public override string Help => "Show Beyond foundation/version/config status and runtime asset availability; makes no world changes.";

		public StatusCommand(Func<string> describe, Action<string> writeLog)
		{
			_describe = describe;
			_writeLog = writeLog;
		}

		public override void Run(string[] args)
		{
			_writeLog(_describe());
		}

		public override void Run(string[] args, Terminal terminal)
		{
			terminal.AddString(_describe());
		}
	}
	internal static class VisualAssets
	{
		internal static readonly (string Role, string Prefab)[] Candidates = new(string, string)[11]
		{
			("entrance totem", "StatueEvil"),
			("portal", "portal_wood"),
			("arena floor", "stone_floor_2x2"),
			("ruin boundary", "stone_wall_4x2"),
			("blue accent light", "piece_groundtorch_blue"),
			("Trial enemy", "Troll"),
			("bear option", "Bjorn"),
			("goblin", "Goblin"),
			("trader", "Haldor"),
			("currency", "Coins"),
			("first shop resource", "Iron")
		};

		internal static string Probe()
		{
			List<string> list = new List<string>();
			(string, string)[] candidates = Candidates;
			for (int i = 0; i < candidates.Length; i++)
			{
				(string, string) tuple = candidates[i];
				bool flag = (Object)(object)PrefabManager.Instance.GetPrefab(tuple.Item2) != (Object)null;
				list.Add(tuple.Item1 + ": " + tuple.Item2 + " = " + (flag ? "available" : "missing"));
			}
			return string.Join("\n", list);
		}
	}
}
namespace Beyond.Plugin.World
{
	internal static class AdvancedFloorLayout
	{
		public static Vector3 Entry(int floor)
		{
			//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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			return (Vector3)(floor switch
			{
				4 => new Vector3(0f, 2f, -35f), 
				5 => new Vector3(0f, 2f, -36f), 
				6 => new Vector3(-20f, 2f, -77f), 
				_ => throw new ArgumentOutOfRangeException("floor"), 
			});
		}

		public static Vector3 Boss(int floor)
		{
			//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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			return (Vector3)(floor switch
			{
				4 => new Vector3(12f, 1.5f, 20f), 
				5 => new Vector3(0f, 1.5f, 28f), 
				6 => new Vector3(18f, 1.5f, 73f), 
				_ => throw new ArgumentOutOfRangeException("floor"), 
			});
		}

		public static Vector3 ShopGate(int floor)
		{
			//IL_0001: 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)
			return Boss(floor) + new Vector3(0f, -1.5f, -9f);
		}

		public static Vector3 Group(int floor, int group)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			return (Vector3)(floor switch
			{
				4 => Vector3.zero, 
				5 => group switch
				{
					0 => new Vector3(-22f, 0f, -12f), 
					1 => new Vector3(22f, 0f, 0f), 
					_ => new Vector3(0f, 0f, 24f), 
				}, 
				6 => group switch
				{
					0 => new Vector3(-18f, 0f, -48f), 
					1 => new Vector3(18f, 0f, -2f), 
					_ => new Vector3(-18f, 0f, 43f), 
				}, 
				_ => throw new ArgumentOutOfRangeException("floor"), 
			});
		}

		public static Vector3 Guard(int floor, int index, int groupSize)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			int num = index / groupSize;
			int num2 = index % groupSize;
			if (floor == 4)
			{
				float num3 = ((float)num2 * 137.5f + (float)(num * 41)) * (MathF.PI / 180f);
				float num4 = 15 + num2 % 3 * 2;
				return new Vector3(Mathf.Sin(num3) * num4, 1.5f, Mathf.Cos(num3) * num4);
			}
			return Group(floor, num) + new Vector3(((float)(num2 % 4) - 1.5f) * 2.7f, 1.5f, ((float)(num2 / 4) - 1.5f) * 3f);
		}

		public static Mesh RoundBoundary()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			CanyonLayout.Builder builder = new CanyonLayout.Builder();
			Vector3 val = default(Vector3);
			Vector3 val2 = default(Vector3);
			for (int i = 0; i < 64; i++)
			{
				float num = (float)i * MathF.PI / 32f;
				float num2 = (float)(i + 1) * MathF.PI / 32f;
				((Vector3)(ref val))..ctor(Mathf.Sin(num) * 46f, -2f, Mathf.Cos(num) * 46f);
				((Vector3)(ref val2))..ctor(Mathf.Sin(num2) * 46f, -2f, Mathf.Cos(num2) * 46f);
				builder.Quad(val, val + Vector3.up * 40f, val2 + Vector3.up * 40f, val2, doubleSided: true);
			}
			return builder.Build("Beyond compact floor invisible rim");
		}

		public static void Build(NativeScenery scenery, Transform parent, Vector3 origin, int floor)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			int count = 0;
			bool frost = floor >= 5;
			if (floor == 4 || floor == 5)
			{
				for (int i = 0; i < 28; i++)
				{
					float num = (float)i * MathF.PI * 2f / 28f;
					Rock(Mathf.Sin(num) * 44f, Mathf.Cos(num) * 44f, 15f, (floor == 4) ? 14 : 23, 17f, i * 73);
					if (floor == 4 && i % 2 == 0)
					{
						Place((i % 4 == 0) ? "SwampTree2" : "SwampTree1", Mathf.Sin(num) * 40f, Mathf.Cos(num) * 40f, 1f, 24 + i % 4, 1f, i * 39, uniform: true);
					}
					if (floor == 5 && i % 4 == 0)
					{
						Place("FirTree_small", Mathf.Sin(num) * 38f, Mathf.Cos(num) * 38f, 1f, 10 + i % 3, 1f, i * 37, uniform: true);
					}
				}
				if (floor == 4)
				{
					Vector2[] array = (Vector2[])(object)new Vector2[6]
					{
						new Vector2(-8f, -7f),
						new Vector2(8f, -6f),
						new Vector2(-5f, 8f),
						new Vector2(7f, 9f),
						new Vector2(-12f, 0f),
						new Vector2(2f, -12f)
					};
					for (int j = 0; j < array.Length; j++)
					{
						Rock(array[j].x, array[j].y, 3.4f, 0.9f, 4f, j * 67, 0.72f);
					}
					for (int k = 0; k < 3; k++)
					{
						float num2 = (float)k * MathF.PI * 2f / 3f;
						float num3 = Mathf.Cos(num2) * 30f;
						float num4 = Mathf.Sin(num2) * 30f;
						Rock(num3, num4, 10f, 6f, 10f, k * 81);
						Place("SwampTree2", num3, num4, 1f, 26f, 1f, k * 100, uniform: true);
						Place("SwampTree2_log", num3 + 2f, num4 + 3f, 9f, 1.8f, 3f, k * 110);
					}
				}
				else
				{
					Rock(0f, -2f, 18f, 21f, 25f, 17f);
					Rock(-4f, -7f, 12f, 10f, 14f, 93f);
					Rock(5f, 5f, 11f, 15f, 12f, 42f);
				}
				for (int l = 0; l < 22; l++)
				{
					float num5 = (float)l * 137.5f * (MathF.PI / 180f);
					float x = Mathf.Sin(num5) * 33f;
					float z = Mathf.Cos(num5) * 33f;
					Rock(x, z, 3 + l % 3, 0.8f, 4f, l * 47, 0.8f);
					if (floor == 4)
					{
						Place("Bush01", x, z, 2.5f, 1.2f, 2.5f, l * 81);
					}
					else if (l % 3 == 0)
					{
						Place("FirTree_small_dead", x, z, 1f, 5f, 1f, l * 89, uniform: true);
					}
				}
				return;
			}
			if (floor == 6)
			{
				for (int m = -1; m <= 1; m += 2)
				{
					for (int n = 0; n < 17; n++)
					{
						Rock(m * 43, -95 + n * 12, 18f, 24 + n % 3 * 3, 20f, n * 53);
					}
				}
				for (int num6 = -1; num6 <= 1; num6 += 2)
				{
					for (int num7 = 0; num7 < 7; num7++)
					{
						Rock(-42 + num7 * 14, num6 * 98, 22f, 28f, 18f, num7 * 71);
					}
				}
				for (int num8 = 0; num8 < 3; num8++)
				{
					int num9 = ((num8 % 2 == 0) ? 1 : (-1));
					float num10 = -44 + num8 * 44;
					Rock(num9 * 18, num10, 23f, 18f, 19f, 20 + num8 * 57);
					Rock(num9 * 30, num10 - 4f, 17f, 24f, 16f, num8 * 83);
					Place("Pickable_MountainCaveCrystal", num9 * 12, num10 - 9f, 2f, 3f, 2f, num8 * 109);
					Place("Pickable_MountainCaveCrystal", num9 * 28, num10 + 10f, 3f, 4f, 3f, num8 * 39);
				}
				for (int num11 = -1; num11 <= 1; num11 += 2)
				{
					for (int num12 = 0; num12 < 12; num12++)
					{
						Rock(num11 * 34, -85 + num12 * 15, 4f, 0.7f, 5f, num12 * 47, 0.8f);
						if (num12 % 3 == 0)
						{
							Place("Pickable_MountainCaveCrystal", num11 * 36, -85 + num12 * 15, 2f, 2.5f, 2f, num12 * 67);
						}
					}
				}
				scenery.Run(delegate
				{
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					//IL_000a: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: 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_003d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_0047: Unknown result type (might be due to invalid IL or missing references)
					//IL_006d: Unknown result type (might be due to invalid IL or missing references)
					GameObject val = new GameObject("Beyond warm sanctum court");
					val.transform.SetParent(parent, false);
					val.transform.position = origin + NumberedFloorLayout.AtGround(floor, new Vector3(18f, 5f, 73f));
					Light obj = val.AddComponent<Light>();
					obj.type = (LightType)2;
					obj.color = new Color(1f, 0.36f, 0.12f);
					obj.range = 26f;
					obj.intensity = 2.3f;
					obj.shadows = (LightShadows)0;
				});
				return;
			}
			throw new ArgumentOutOfRangeException("floor");
			void Place(string prefab, float num13, float num14, float w, float h, float d, float yaw = 0f, bool uniform = false, float embed = 0f)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				if (++count > 190)
				{
					throw new InvalidOperationException("Beyond advanced scenery budget exceeded.");
				}
				scenery.Place(parent, prefab, origin + NumberedFloorLayout.AtGround(floor, new Vector3(num13, -0.1f - h * embed, num14)), new Vector3(w, h, d), yaw, uniform, warm: false, frost);
			}
			void Rock(float x2, float z2, float w, float h, float d, float yaw = 0f, float embed = 0.5f)
			{
				Place("Rock_7", x2, z2, w, h, d, yaw, uniform: false, embed);
			}
		}
	}
	internal sealed class AuthoredVoidSkin
	{
		private readonly List<Object> Assets = new List<Object>();

		private readonly string _prefix;

		private readonly VoidKind _kind;

		private static readonly Dictionary<VoidKind, AuthoredVoidSkin> Skins = new Dictionary<VoidKind, AuthoredVoidSkin>();

		private Mesh[]? _meshes;

		private Material[]? _materials;

		private string[] _names = Array.Empty<string>();

		private AuthoredVoidSkin(VoidKind kind)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			_kind = kind;
			_prefix = (((int)kind == 0) ? "eidolon" : (((int)kind == 1) ? "riftstalker" : "hollowcantor"));
		}

		internal static void Build(VoidKind kind, Transform rig, IReadOnlyDictionary<string, Transform> bones, Material native)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (!Skins.TryGetValue(kind, out AuthoredVoidSkin value))
			{
				value = new AuthoredVoidSkin(kind);
				Skins.Add(kind, value);
			}
			value.Attach(rig, bones, native);
		}

		private void Attach(Transform rig, IReadOnlyDictionary<string, Transform> bones, Material native)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			if (_meshes == null)
			{
				Load(rig, bones, native);
			}
			Transform[] array = (Transform[])(object)new Transform[_names.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = bones[_names[i]];
			}
			for (int j = 0; j < 3; j++)
			{
				GameObject val = new GameObject("Stone" + j);
				val.transform.SetParent(rig, false);
				SkinnedMeshRenderer obj = val.AddComponent<SkinnedMeshRenderer>();
				obj.sharedMesh = _meshes[j];
				((Renderer)obj).sharedMaterial = _materials[j];
				obj.bones = array;
				obj.rootBone = bones["body"];
				obj.quality = (SkinQuality)4;
				obj.updateWhenOffscreen = false;
				((Renderer)obj).localBounds = (((int)_kind == 0) ? new Bounds(new Vector3(0f, 2.8f, 0f), new Vector3(11f, 10f, 10f)) : new Bounds(new Vector3(0f, 1.3f, 0f), new Vector3(7f, 7f, 8f)));
				((Renderer)obj).shadowCastingMode = (ShadowCastingMode)(j != 2);
				((Renderer)obj).receiveShadows = j != 2;
			}
		}

		private void Load(Transform rig, IReadOnlyDictionary<string, Transform> bones, Material native)
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0401: Unknown result type (might be due to invalid IL or missing references)
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0413: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0454: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_0486: Expected O, but got Unknown
			//IL_0639: Unknown result type (might be due to invalid IL or missing references)
			//IL_063e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_0668: Unknown result type (might be due to invalid IL or missing references)
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_0673: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Expected O, but got Unknown
			//IL_06a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0798: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ae: Unknown result type (might be due to invalid IL or missing references)
			using BinaryReader binaryReader = new BinaryReader(Resource(_prefix + ".mesh"));
			if (Encoding.ASCII.GetString(binaryReader.ReadBytes(8)) != "BEVM0001")
			{
				throw new InvalidDataException("Invalid Eidolon skin format.");
			}
			int num = binaryReader.ReadInt32();
			int num2 = binaryReader.ReadInt32();
			if (num < 3 || num > 100000 || num % 3 != 0 || num2 < 1 || num2 > 64)
			{
				throw new InvalidDataException("Invalid Eidolon skin counts.");
			}
			_names = new string[num2];
			Matrix4x4[] array = (Matrix4x4[])(object)new Matrix4x4[num2];
			HashSet<string> hashSet = new HashSet<string>();
			for (int i = 0; i < num2; i++)
			{
				int num3 = binaryReader.ReadInt32();
				if (num3 < 1 || num3 > 64)
				{
					throw new InvalidDataException("Invalid joint name.");
				}
				string text = Encoding.UTF8.GetString(binaryReader.ReadBytes(num3));
				if (!hashSet.Add(text) || !bones.TryGetValue(text, out Transform value))
				{
					throw new InvalidDataException("Missing/repeated Eidolon joint: " + text);
				}
				_names[i] = text;
				array[i] = value.worldToLocalMatrix * rig.localToWorldMatrix;
			}
			Vector3[] array2 = (Vector3[])(object)new Vector3[num];
			Vector3[] array3 = (Vector3[])(object)new Vector3[num];
			Vector2[] array4 = (Vector2[])(object)new Vector2[num];
			BoneWeight[] array5 = (BoneWeight[])(object)new BoneWeight[num];
			List<int>[] array6 = new List<int>[3]
			{
				new List<int>(),
				new List<int>(),
				new List<int>()
			};
			int num4 = -1;
			for (int j = 0; j < num; j++)
			{
				array2[j] = new Vector3(F(binaryReader), F(binaryReader), F(binaryReader));
				array3[j] = new Vector3(F(binaryReader), F(binaryReader), F(binaryReader));
				array4[j] = new Vector2(F(binaryReader), F(binaryReader));
				int[] array7 = new int[4]
				{
					binaryReader.ReadInt32(),
					binaryReader.ReadInt32(),
					binaryReader.ReadInt32(),
					binaryReader.ReadInt32()
				};
				float[] array8 = new float[4]
				{
					F(binaryReader),
					F(binaryReader),
					F(binaryReader),
					F(binaryReader)
				};
				float num5 = 0f;
				for (int k = 0; k < 4; k++)
				{
					if (array7[k] < 0 || array7[k] >= num2 || array8[k] < 0f || array8[k] > 1f)
					{
						throw new InvalidDataException("Invalid skin influence.");
					}
					num5 += array8[k];
				}
				if (Mathf.Abs(num5 - 1f) > 0.001f || ((Vector3)(ref array3[j])).sqrMagnitude < 0.1f)
				{
					throw new InvalidDataException("Invalid skin weight sum/normal.");
				}
				int num6 = j;
				BoneWeight val = default(BoneWeight);
				((BoneWeight)(ref val)).boneIndex0 = array7[0];
				((BoneWeight)(ref val)).boneIndex1 = array7[1];
				((BoneWeight)(ref val)).boneIndex2 = array7[2];
				((BoneWeight)(ref val)).boneIndex3 = array7[3];
				((BoneWeight)(ref val)).weight0 = array8[0];
				((BoneWeight)(ref val)).weight1 = array8[1];
				((BoneWeight)(ref val)).weight2 = array8[2];
				((BoneWeight)(ref val)).weight3 = array8[3];
				array5[num6] = val;
				int num7 = binaryReader.ReadInt32();
				if (num7 < 0 || num7 > 2 || (j % 3 != 0 && num7 != num4))
				{
					throw new InvalidDataException("Invalid material triangle.");
				}
				num4 = num7;
				array6[num7].Add(j);
			}
			if (binaryReader.BaseStream.Position != binaryReader.BaseStream.Length)
			{
				throw new InvalidDataException("Trailing Eidolon skin data.");
			}
			Mesh[] array9 = (Mesh[])(object)new Mesh[3];
			for (int l = 0; l < 3; l++)
			{
				if (array6[l].Count == 0)
				{
					throw new InvalidDataException("Empty Eidolon skin material.");
				}
				int count = array6[l].Count;
				Vector3[] array10 = (Vector3[])(object)new Vector3[count];
				Vector3[] array11 = (Vector3[])(object)new Vector3[count];
				Vector2[] array12 = (Vector2[])(object)new Vector2[count];
				BoneWeight[] array13 = (BoneWeight[])(object)new BoneWeight[count];
				int[] array14 = new int[count];
				for (int m = 0; m < count; m++)
				{
					int num8 = array6[l][m];
					array10[m] = array2[num8];
					array11[m] = array3[num8];
					array12[m] = array4[num8];
					array13[m] = array5[num8];
					array14[m] = m;
				}
				Mesh val2 = new Mesh
				{
					name = _prefix + " sculpted skin " + l,
					indexFormat = (IndexFormat)(count > 65535)
				};
				Assets.Add((Object)(object)val2);
				val2.vertices = array10;
				val2.normals = array11;
				val2.uv = array12;
				val2.boneWeights = array13;
				val2.bindposes = array;
				val2.SetTriangles(array14, 0);
				val2.RecalculateTangents();
				val2.RecalculateBounds();
				array9[l] = val2;
			}
			Texture2D val3 = Texture(_prefix + "_basecolor.png", linear: false);
			Texture2D val4 = Texture(_prefix + "_normal.png", linear: true);
			Texture2D val5 = Texture(_prefix + "_roughness.png", linear: true);
			Texture2D val6 = Texture(_prefix + "_occlusion.png", linear: true);
			Texture2D val7 = Texture(_prefix + "_emission.png", linear: false);
			Color32[] pixels = val4.GetPixels32();
			for (int n = 0; n < pixels.Length; n++)
			{
				pixels[n] = new Color32(byte.MaxValue, pixels[n].g, pixels[n].b, pixels[n].r);
			}
			val4.SetPixels32(pixels);
			val4.Apply(true, true);
			Color32[] pixels2 = val5.GetPixels32();
			for (int num9 = 0; num9 < pixels2.Length; num9++)
			{
				pixels2[num9] = new Color32((byte)0, (byte)0, (byte)0, (byte)(255 - pixels2[num9].r));
			}
			val5.SetPixels32(pixels2);
			val5.Apply(true, true);
			Material[] array15 = (Material[])(object)new Material[3];
			for (int num10 = 0; num10 < 3; num10++)
			{
				Material val8 = new Material(native)
				{
					name = "Beyond sculpted " + _prefix + " " + num10,
					mainTexture = (Texture)(object)val3,
					mainTextureScale = Vector2.one,
					mainTextureOffset = Vector2.zero
				};
				Assets.Add((Object)(object)val8);
				if (val8.HasProperty("_Color"))
				{
					val8.SetColor("_Color", Color.white);
				}
				if (val8.HasProperty("_Metallic"))
				{
					val8.SetFloat("_Metallic", 0f);
				}
				Map(val8, "_BumpMap", (Texture)(object)val4, "_NORMALMAP");
				Map(val8, "_MetallicGlossMap", (Texture)(object)val5, "_METALLICGLOSSMAP");
				Map(val8, "_OcclusionMap", (Texture)(object)val6);
				Map(val8, "_EmissionMap", (Texture)(object)val7, "_EMISSION");
				if (val8.HasProperty("_BumpScale"))
				{
					val8.SetFloat("_BumpScale", 0.7f);
				}
				if (val8.HasProperty("_OcclusionStrength"))
				{
					val8.SetFloat("_OcclusionStrength", 0.65f);
				}
				if (val8.HasProperty("_GlossMapScale"))
				{
					val8.SetFloat("_GlossMapScale", 1f);
				}
				if (val8.HasProperty("_EmissionColor"))
				{
					val8.SetColor("_EmissionColor", new Color(0.8f, 0.01f, 1f) * ((num10 == 2) ? 3f : 0.3f));
				}
				array15[num10] = val8;
			}
			val3.Apply(true, true);
			val6.Apply(true, true);
			val7.Apply(true, true);
			_meshes = array9;
			_materials = array15;
			Debug.Log((object)("Beyond " + _prefix + " weighted skin loaded: " + num / 3 + " triangles, " + num2 + " joints, 1024px base/normal/response/AO/emission. Native appearance/deformation still require testing."));
			Debug.Log((object)("Beyond " + _prefix + " native shader '" + ((Object)native.shader).name + "'; map properties normal=" + native.HasProperty("_BumpMap") + ", roughness=" + native.HasProperty("_MetallicGlossMap") + ", AO=" + native.HasProperty("_OcclusionMap") + ", emission=" + native.HasProperty("_EmissionMap") + "."));
		}

		private static float F(BinaryReader reader)
		{
			float num = reader.ReadSingle();
			if (float.IsNaN(num) || float.IsInfinity(num))
			{
				throw new InvalidDataException("Non-finite Eidolon skin data.");
			}
			return num;
		}

		private Stream Resource(string name)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return Assembly.GetExecutingAssembly().GetManifestResourceStream((((int)_kind == 0) ? "Beyond.Eidolon." : "Beyond.Adds.") + name) ?? throw new InvalidDataException("Missing authored Eidolon asset: " + name);
		}

		private Texture2D Texture(string name, bool linear)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_003f: Expected O, but got Unknown
			using Stream stream = Resource(name);
			using MemoryStream memoryStream = new MemoryStream();
			stream.CopyTo(memoryStream);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true, linear)
			{
				name = "Beyond " + name,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Assets.Add((Object)(object)val);
			if (!ImageConversion.LoadImage(val, memoryStream.ToArray(), false) || ((Texture)val).width != 1024 || ((Texture)val).height != 1024)
			{
				throw new InvalidDataException("Invalid authored Eidolon map: " + name);
			}
			return val;
		}

		private static void Map(Material material, string property, Texture texture, string keyword = "")
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (material.HasProperty(property))
			{
				material.SetTexture(property, texture);
				material.SetTextureScale(property, Vector2.one);
				material.SetTextureOffset(property, Vector2.zero);
				if (keyword.Length > 0)
				{
					material.EnableKeyword(keyword);
				}
			}
		}

		internal static void Dispose()
		{
			foreach (AuthoredVoidSkin value in Skins.Values)
			{
				foreach (Object asset in value.Assets)
				{
					if (asset != (Object)null)
					{
						Object.Destroy(asset);
					}
				}
			}
			Skins.Clear();
		}
	}
	internal sealed class BeyondAtmosphere : IDisposable
	{
		private const string ArenaName = "brom8.beyond.island";

		private const string CanyonName = "brom8.beyond.canyon";

		private const string ForestName = "brom8.beyond.forest";

		private const string SwampName = "brom8.beyond.swamp";

		private const string MountainName = "brom8.beyond.mountain";

		private const string SanctumName = "brom8.beyond.sanctum";

		private const string ShopName = "brom8.beyond.stars";

		private readonly TrialWorld _world;

		private readonly BeyondIslandMist _mist = new BeyondIslandMist();

		private readonly BeyondSnow _snow = new BeyondSnow();

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

		private EnvMan? _manager;

		private EnvSetup? _arena;

		private EnvSetup? _canyon;

		private EnvSetup? _forest;

		private EnvSetup? _swamp;

		private EnvSetup? _mountain;

		private EnvSetup? _sanctum;

		private EnvSetup? _shop;

		private Camera? _camera;

		private CameraClearFlags _clear;

		private Color _background;

		private float _far;

		private bool _active;

		private bool _inShop;

		private int _floor;

		private bool _fog;

		private FogMode _fogMode;

		private float _fogDensity;

		private Color _fogColor;

		private EnvSetup? FloorEnvironment
		{
			get
			{
				if (_later.TryGetValue(_floor, out EnvSetup value))
				{
					return value;
				}
				EnvSetup result;
				switch (_floor)
				{
				case 1:
					result = _canyon;
					break;
				case 2:
					result = _forest;
					break;
				case 3:
				case 4:
					result = _swamp;
					break;
				case 5:
					result = _mountain;
					break;
				case 6:
					result = _sanctum;
					break;
				default:
					result = _arena;
					break;
				}
				return result;
			}
		}

		public string? EnvironmentOverride
		{
			get
			{
				if (!_active)
				{
					return null;
				}
				if (!_inShop)
				{
					return FloorEnvironment?.m_name;
				}
				return "brom8.beyond.stars";
			}
		}

		public BeyondAtmosphere(TrialWorld world)
		{
			_world = world;
		}

		public void LateUpdate()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Unknown result type (might be due to invalid IL or missing references)
			//IL_048b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0659: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_060d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0553: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_0560: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			BeyondPlugin? instance = BeyondPlugin.Instance;
			bool flag = instance != null && instance.Runtime?.Realm?.Inside == true;
			if (!((Object)(object)localPlayer != (Object)null) || !(_world.IsBeyond(((Component)localPlayer).transform.position) || flag))
			{
				Restore();
			}
			else
			{
				if ((Object)(object)EnvMan.instance == (Object)null)
				{
					return;
				}
				if ((Object)(object)_manager != (Object)(object)EnvMan.instance)
				{
					_manager = EnvMan.instance;
					EnvSetup source = (from e in _manager.m_environments
						where e.m_name.IndexOf("mist", StringComparison.OrdinalIgnoreCase) >= 0
						orderby e.m_fogDensityDay descending
						select e).FirstOrDefault() ?? _manager.m_environments.First();
					_arena = Create(source, "brom8.beyond.island", shop: false);
					_shop = Create(source, "brom8.beyond.stars", shop: true);
					_canyon = CreateCanyon(source);
					_forest = CreateForest(source);
					_swamp = CreateSwamp(source);
					_manager.m_environments.Add(_arena);
					_manager.m_environments.Add(_shop);
					_manager.m_environments.Add(_canyon);
					_manager.m_environments.Add(_forest);
					_manager.m_environments.Add(_swamp);
					_mountain = CreateMountain(source, sanctum: false);
					_sanctum = CreateMountain(source, sanctum: true);
					_manager.m_environments.Add(_mountain);
					_manager.m_environments.Add(_sanctum);
					_later.Clear();
					for (int num = 7; num <= 20; num++)
					{
						EnvSetup val;
						if ((uint)(num - 13) <= 1u)
						{
							val = CreateMountain(source, sanctum: false);
						}
						else
						{
							EnvSetup val2;
							if (((uint)(num - 7) <= 1u || (uint)(num - 11) <= 1u) ? true : false)
							{
								val2 = CreateCanyon(source);
							}
							else
							{
								bool flag2 = ((num == 9 || num == 17) ? true : false);
								val2 = (flag2 ? CreateForest(source) : CreateMountain(source, sanctum: true));
							}
							val = val2;
						}
						EnvSetup val3 = val;
						val3.m_name = "brom8.beyond.floor" + num;
						if ((uint)(num - 13) <= 1u)
						{
							val3.m_snowBuildup = 1f;
							val3.m_fogDensityDay = (val3.m_fogDensityNight = 0.008f);
						}
						if (((uint)(num - 11) <= 1u || num == 18) ? true : false)
						{
							val3.m_ambColorDay = (val3.m_ambColorNight = new Color(0.43f, 0.22f, 0.16f));
						}
						_later.Add(num, val3);
						_manager.m_environments.Add(val3);
					}
				}
				if (!_active)
				{
					_fog = RenderSettings.fog;
					_fogMode = RenderSettings.fogMode;
					_fogDensity = RenderSettings.fogDensity;
					_fogColor = RenderSettings.fogColor;
				}
				_active = true;
				_inShop = !flag && _world.IsShop(((Component)localPlayer).transform.position);
				_floor = (flag ? BeyondPlugin.Instance.Runtime.Realm.EnvironmentFloor : _world.SelectedFloor);
				_mist.Update(!_inShop && _floor == 0, _world.Arena);
				BeyondSnow snow = _snow;
				bool flag3 = !_inShop;
				if (flag3)
				{
					int floor = _floor;
					bool flag4 = (uint)(floor - 13) <= 1u;
					flag3 = flag4;
				}
				snow.Update(flag3, ((Component)localPlayer).transform.position);
				EnvSetup val4 = (_inShop ? _shop : FloorEnvironment);
				Color val5 = val4.m_fogColorDay;
				if (flag && SharedRealmWorld.ContainsPreview(((Component)localPlayer).transform.position))
				{
					float num2 = ((Component)localPlayer).transform.position.z - SharedRealmWorld.PreviewOrigin.z;
					int num3 = LandscapePreviewLayout.Section(num2);
					if (num3 > 0)
					{
						int num4 = LandscapePreviewLayout.EnvironmentFloor((float)(num3 * 128 - 65));
						EnvSetup value;
						EnvSetup val = (EnvSetup)((!_later.TryGetValue(num4, out value)) ? (num4 switch
						{
							1 => _canyon, 
							2 => _forest, 
							3 => _swamp, 
							6 => _sanctum, 
							_ => _mountain, 
						}) : value);
						EnvSetup val6 = val;
						if (val6 != null)
						{
							val5 = Color.Lerp(val6.m_fogColorDay, val5, LandscapePreviewLayout.Transition(num2));
						}
					}
				}
				Camera main = Camera.main;
				if ((Object)(object)main != (Object)(object)_camera)
				{
					RestoreCamera();
					_camera = main;
					if ((Object)(object)_camera != (Object)null)
					{
						_clear = _camera.clearFlags;
						_background = _camera.backgroundColor;
						_far = _camera.farClipPlane;
					}
				}
				if ((Object)(object)_camera != (Object)null)
				{
					_camera.clearFlags = (CameraClearFlags)2;
					_camera.backgroundColor = (Color)((_inShop || _floor == 0) ? new Color(0.009f, 0.006f, 0.022f) : val5);
					_camera.farClipPlane = (flag ? 650 : (_inShop ? 90 : ((_floor == 0) ? 160 : 210)));
				}
				RenderSettings.fog = true;
				RenderSettings.fogMode = (FogMode)3;
				RenderSettings.fogColor = val5;
				RenderSettings.fogDensity = (flag ? 0.0025f : val4.m_fogDensityDay);
			}
		}

		private static EnvSetup CreateCanyon(EnvSetup source)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			EnvSetup obj = Create(source, "brom8.beyond.canyon", shop: false);
			obj.m_alwaysDark = false;
			obj.m_ambColorDay = (obj.m_ambColorNight = new Color(0.68f, 0.46f, 0.29f));
			obj.m_fogColorDay = (obj.m_fogColorMorning = (obj.m_fogColorEvening = (obj.m_fogColorNight = new Color(0.64f, 0.39f, 0.18f))));
			obj.m_fogColorSunDay = (obj.m_fogColorSunMorning = (obj.m_fogColorSunEvening = (obj.m_fogColorSunNight = obj.m_fogColorDay)));
			obj.m_fogDensityDay = (obj.m_fogDensityMorning = (obj.m_fogDensityEvening = (obj.m_fogDensityNight = 0.009f)));
			obj.m_sunColorDay = (obj.m_sunColorMorning = (obj.m_sunColorEvening = (obj.m_sunColorNight = new Color(1f, 0.75f, 0.42f))));
			obj.m_lightIntensityDay = (obj.m_lightIntensityNight = 0.75f);
			return obj;
		}

		private static EnvSetup CreateForest(EnvSetup source)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			EnvSetup obj = Create(source, "brom8.beyond.forest", shop: false);
			obj.m_alwaysDark = false;
			obj.m_ambColorDay = (obj.m_ambColorNight = new Color(0.34f, 0.42f, 0.32f));
			obj.m_fogColorDay = (obj.m_fogColorMorning = (obj.m_fogColorEvening = (obj.m_fogColorNight = new Color(0.08f, 0.14f, 0.12f))));
			obj.m_fogColorSunDay = (obj.m_fogColorSunMorning = (obj.m_fogColorSunEvening = (obj.m_fogColorSunNight = obj.m_fogColorDay)));
			obj.m_fogDensityDay = (obj.m_fogDensityMorning = (obj.m_fogDensityEvening = (obj.m_fogDensityNight = 0.012f)));
			obj.m_sunColorDay = (obj.m_sunColorMorning = (obj.m_sunColorEvening = (obj.m_sunColorNight = new Color(0.66f, 0.76f, 0.52f))));
			obj.m_lightIntensityDay = (obj.m_lightIntensityNight = 0.6f);
			return obj;
		}

		private static EnvSetup CreateSwamp(EnvSetup source)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: 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)
			EnvSetup obj = Create(source, "brom8.beyond.swamp", shop: false);
			obj.m_ambColorDay = (obj.m_ambColorNight = new Color(0.25f, 0.31f, 0.16f));
			obj.m_fogColorDay = (obj.m_fogColorMorning = (obj.m_fogColorEvening = (obj.m_fogColorNight = new Color(0.06f, 0.1f, 0.045f))));
			obj.m_fogColorSunDay = (obj.m_fogColorSunMorning = (obj.m_fogColorSunEvening = (obj.m_fogColorSunNight = obj.m_fogColorDay)));
			obj.m_fogDensityDay = (obj.m_fogDensityMorning = (obj.m_fogDensityEvening = (obj.m_fogDensityNight = 0.018f)));
			obj.m_sunColorDay = (obj.m_sunColorMorning = (obj.m_sunColorEvening = (obj.m_sunColorNight = new Color(0.45f, 0.5f, 0.22f))));
			obj.m_lightIntensityDay = (obj.m_lightIntensityNight = 0.38f);
			return obj;
		}

		private static EnvSetup CreateMountain(EnvSetup source, bool sanctum)
		{
			//IL_0047: 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_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			EnvSetup obj = Create(source, sanctum ? "brom8.beyond.sanctum" : "brom8.beyond.mountain", shop: false);
			obj.m_alwaysDark = sanctum;
			obj.m_ambColorDay = (obj.m_ambColorNight = (sanctum ? new Color(0.27f, 0.31f, 0.43f) : new Color(0.57f, 0.65f, 0.78f)));
			obj.m_fogColorDay = (obj.m_fogColorMorning = (obj.m_fogColorEvening = (obj.m_fogColorNight = (sanctum ? new Color(0.055f, 0.075f, 0.13f) : new Color(0.31f, 0.41f, 0.55f)))));
			obj.m_fogColorSunDay = (obj.m_fogColorSunMorning = (obj.m_fogColorSunEvening = (obj.m_fogColorSunNight = obj.m_fogColorDay)));
			obj.m_fogDensityDay = (obj.m_fogDensityMorning = (obj.m_fogDensityEvening = (obj.m_fogDensityNight = (sanctum ? 0.012f : 0.008f))));
			obj.m_sunColorDay = (obj.m_sunColorMorning = (obj.m_sunColorEvening = (obj.m_sunColorNight = new Color(0.68f, 0.78f, 1f))));
			obj.m_lightIntensityDay = (obj.m_lightIntensityNight = (sanctum ? 0.45f : 0.8f));
			return obj;
		}

		private static EnvSetup Create(EnvSetup source, string name, bool shop)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: 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)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			EnvSetup obj = source.Clone();
			obj.m_name = name;
			obj.m_default = false;
			obj.m_isWet = (obj.m_isCold = (obj.m_isColdAtNight = (obj.m_isFreezing = (obj.m_isFreezingAtNight = false))));
			obj.m_snowBuildup = 0f;
			obj.m_alwaysDark = true;
			obj.m_envObject = null;
			obj.m_psystems = Array.Empty<GameObject>();
			obj.m_ambientLoop = null;
			obj.m_ambientList = "";
			obj.m_rainCloudAlpha = 0f;
			obj.m_windMin = (obj.m_windMax = 0f);
			obj.m_ambColorDay = (obj.m_ambColorNight = (shop ? new Color(0.45f, 0.4f, 0.55f) : new Color(0.28f, 0.24f, 0.4f)));
			obj.m_fogColorDay = (obj.m_fogColorMorning = (obj.m_fogColorEvening = (obj.m_fogColorNight = new Color(0.025f, 0.018f, 0.055f))));
			obj.m_fogColorSunDay = (obj.m_fogColorSunMorning = (obj.m_fogColorSunEvening = (obj.m_fogColorSunNight = obj.m_fogColorDay)));
			float fogDensityNight = (shop ? 0.002f : Mathf.Max(0.018f, source.m_fogDensityDay * 0.5f));
			obj.m_fogDensityDay = (obj.m_fogDensityMorning = (obj.m_fogDensityEvening = (obj.m_fogDensityNight = fogDensityNight)));
			obj.m_sunColorDay = (obj.m_sunColorMorning = (obj.m_sunColorEvening = (obj.m_sunColorNight = new Color(0.3f, 0.25f, 0.45f))));
			obj.m_lightIntensityDay = (obj.m_lightIntensityNight = (shop ? 0.3f : 0.15f));
			return obj;
		}

		private void RestoreCamera()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_camera != (Object)null)
			{
				_camera.clearFlags = _clear;
				_camera.backgroundColor = _background;
				_camera.farClipPlane = _far;
			}
			_camera = null;
		}

		private void Restore()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (_active)
			{
				_mist.Update(active: false, Vector3.zero);
				_snow.Update(active: false, Vector3.zero);
				RestoreCamera();
				RenderSettings.fog = _fog;
				RenderSettings.fogMode = _fogMode;
				RenderSettings.fogDensity = _fogDensity;
				RenderSettings.fogColor = _fogColor;
				_active = false;
			}
		}

		public void Dispose()
		{
			Restore();
			_mist.Dispose();
			_snow.Dispose();
			if ((Object)(object)_manager != (Object)null)
			{
				foreach (EnvSetup value in _later.Values)
				{
					_manager.m_environments.Remove(value);
				}
			}
			_later.Clear();
			if ((Object)(object)_manager != (Object)null)
			{
				if (_arena != null)
				{
					_manager.m_environments.Remove(_arena);
				}
				if (_shop != null)
				{
					_manager.m_environments.Remove(_shop);
				}
				if (_canyon != null)
				{
					_manager.m_environments.Remove(_canyon);
				}
				if (_forest != null)
				{
					_manager.m_environments.Remove(_forest);
				}
				if (_swamp != null)
				{
					_manager.m_environments.Remove(_swamp);
				}
			}
			if ((Object)(object)_manager != (Object)null)
			{
				if (_mountain != null)
				{
					_manager.m_environments.Remove(_mountain);
				}
				if (_sanctum != null)
				{
					_manager.m_environments.Remove(_sanctum);
				}
			}
		}
	}
	[HarmonyPatch(typeof(EnvMan), "GetEnvironmentOverride")]
	internal static class BeyondEnvironmentPatch
	{
		private static void Postfix(ref string __result)
		{
			string text = BeyondPlugin.Instance?.Runtime?.Client?.Atmosphere.EnvironmentOverride;
			if (text != null)
			{
				__result = text;
			}
		}
	}
	internal sealed class BeyondIslandMist : IDisposable
	{
		private const int MaximumParticles = 512;

		private GameObject? _root;

		private ParticleSystem? _particles;

		private Vector3 _center;

		private bool _active;

		private bool _warned;

		private float _nextSearch;

		private float _accumulator;

		private float _perSecond = 25f;

		private MinMaxGradient _color;

		public void Update(bool active, Vector3 center)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			if (!active)
			{
				if (_active && (Object)(object)_particles != (Object)null)
				{
					_particles.Stop(true, (ParticleSystemStopBehavior)0);
					_root.SetActive(false);
				}
				_active = false;
				_accumulator = 0f;
				return;
			}
			if ((Object)(object)_particles == (Object)null)
			{
				if (Time.unscaledTime < _nextSearch)
				{
					return;
				}
				_nextSearch = Time.unscaledTime + 10f;
				ParticleMist val = FindSource();
				if ((Object)(object)val == (Object)null || !Create(val))
				{
					if (!_warned)
					{
						Debug.LogWarning((object)"[Beyond] Native ParticleMist visual is unavailable; arena uses environment haze only. Visible mist needs a supported native particle material.");
						_warned