using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("MuckReplayable")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("MuckReplayable")]
[assembly: AssemblyTitle("MuckReplayable")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MuckReforged;

public sealed class AggroController : MonoBehaviour
{
	private enum AggroState
	{
		Idle,
		Chasing,
		Searching,
		Returning
	}

	private Mob _mob;

	private Vector3 _homePosition;

	private Vector3 _lastSeenPosition;

	private int _currentPlayerId = -1;

	private float _lastSeenAt = float.NegativeInfinity;

	private float _farSince = -1f;

	private float _returnStartedAt = float.NegativeInfinity;

	private float _nextBlockingBuildScanAt;

	private Transform _cachedBlockingBuild;

	private int _lineOfSightFrame = -1;

	private int _lineOfSightPlayerId = -1;

	private bool _lineOfSightResult;

	private AggroState _state;

	private bool IsBoss
	{
		get
		{
			if ((Object)(object)_mob != (Object)null && (Object)(object)_mob.mobType != (Object)null)
			{
				return _mob.mobType.boss;
			}
			return false;
		}
	}

	private bool IsRanged
	{
		get
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			if ((Object)(object)_mob != (Object)null && (Object)(object)_mob.mobType != (Object)null)
			{
				if (!_mob.mobType.ranged)
				{
					return (int)_mob.mobType.behaviour == 2;
				}
				return true;
			}
			return false;
		}
	}

	private void Awake()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: 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)
		_mob = ((Component)this).GetComponent<Mob>();
		_homePosition = ((Component)this).transform.position;
		_lastSeenPosition = _homePosition;
		_state = AggroState.Idle;
	}

	internal void MarkDamagedBy(int playerId)
	{
		//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)
		if (TryGetLivingPlayer(playerId, out var player))
		{
			_currentPlayerId = playerId;
			_lastSeenPosition = ((Component)player).transform.position;
			_lastSeenAt = Time.time;
			_farSince = -1f;
			_state = AggroState.Chasing;
			SetPlayerTarget(player);
		}
	}

	internal Vector3 GetNextDestination()
	{
		//IL_0021: 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_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)_mob == (Object)null || (Object)(object)_mob.mobType == (Object)null)
		{
			return Vector3.zero;
		}
		if ((_mob.IsAttacking() && _mob.stopOnAttack) || _mob.knocked || !_mob.ready)
		{
			return Vector3.zero;
		}
		return (Vector3)(_state switch
		{
			AggroState.Idle => TickIdle(), 
			AggroState.Chasing => TickChasing(), 
			AggroState.Searching => TickSearching(), 
			AggroState.Returning => TickReturning(), 
			_ => Vector3.zero, 
		});
	}

	internal float GetNextThinkDelay()
	{
		float num;
		switch (_state)
		{
		case AggroState.Chasing:
		case AggroState.Searching:
			num = 0.5f;
			break;
		case AggroState.Returning:
			num = 1f;
			break;
		default:
			num = 0.75f;
			break;
		}
		return num + (float)Mathf.Abs(((Object)this).GetInstanceID() % 23) * 0.011f;
	}

	private Vector3 TickIdle()
	{
		//IL_002b: 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)
		PlayerManager val = FindClosestVisiblePlayer(AcquireDistance());
		if ((Object)(object)val == (Object)null)
		{
			ClearTarget();
			return Vector3.zero;
		}
		BeginChasing(val);
		return DestinationFor(val);
	}

	private Vector3 TickChasing()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: 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_00dd: 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_00a5: 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)
		if (!TryGetLivingPlayer(_currentPlayerId, out var player))
		{
			BeginReturning();
			return _homePosition;
		}
		float num = Vector3.Distance(((Component)this).transform.position, ((Component)player).transform.position);
		float num2 = Vector3.Distance(_homePosition, ((Component)this).transform.position);
		if (num > DisengageDistance() || num2 > HomeLeashDistance())
		{
			if (_farSince < 0f)
			{
				_farSince = Time.time;
			}
			else if (Time.time - _farSince >= Plugin.Settings.FarTargetGraceSeconds.Value)
			{
				BeginReturning();
				return _homePosition;
			}
		}
		else
		{
			_farSince = -1f;
		}
		if (HasLineOfSight(player) || num <= Plugin.Settings.ProximityAcquireDistance.Value)
		{
			_lastSeenPosition = ((Component)player).transform.position;
			_lastSeenAt = Time.time;
			SetPlayerTarget(player);
			return DestinationFor(player);
		}
		_state = AggroState.Searching;
		ClearTarget();
		return _lastSeenPosition;
	}

	private Vector3 TickSearching()
	{
		//IL_0016: 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_0087: 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_0059: Unknown result type (might be due to invalid IL or missing references)
		if (TryGetLivingPlayer(_currentPlayerId, out var player))
		{
			float num = Vector3.Distance(((Component)this).transform.position, ((Component)player).transform.position);
			if (num <= AcquireDistance() && (num <= Plugin.Settings.ProximityAcquireDistance.Value || HasLineOfSight(player)))
			{
				BeginChasing(player);
				return DestinationFor(player);
			}
		}
		if (Time.time - _lastSeenAt <= LostSightSeconds())
		{
			ClearTarget();
			return _lastSeenPosition;
		}
		BeginReturning();
		return _homePosition;
	}

	private Vector3 TickReturning()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: 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_00db: Unknown result type (might be due to invalid IL or missing references)
		if (Vector3.Distance(((Component)this).transform.position, _homePosition) <= Plugin.Settings.ReturnArrivalDistance.Value)
		{
			_state = AggroState.Idle;
			_currentPlayerId = -1;
			_farSince = -1f;
			ClearTarget();
			if ((Object)(object)_mob.agent != (Object)null && _mob.agent.isOnNavMesh)
			{
				_mob.agent.ResetPath();
			}
			return Vector3.zero;
		}
		if (Time.time - _returnStartedAt >= Plugin.Settings.ReturnReacquireCooldown.Value)
		{
			PlayerManager val = FindClosestVisiblePlayer(AcquireDistance());
			if ((Object)(object)val != (Object)null && Vector3.Distance(_homePosition, ((Component)val).transform.position) <= HomeLeashDistance())
			{
				BeginChasing(val);
				return DestinationFor(val);
			}
		}
		ClearTarget();
		return _homePosition;
	}

	private void BeginChasing(PlayerManager player)
	{
		//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)
		_state = AggroState.Chasing;
		_currentPlayerId = player.id;
		_lastSeenPosition = ((Component)player).transform.position;
		_lastSeenAt = Time.time;
		_farSince = -1f;
		SetPlayerTarget(player);
	}

	private void BeginReturning()
	{
		_state = AggroState.Returning;
		_returnStartedAt = Time.time;
		_currentPlayerId = -1;
		_farSince = -1f;
		ClearTarget();
	}

	private Vector3 DestinationFor(PlayerManager player)
	{
		//IL_0048: 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_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		if (Plugin.Settings.AttackBlockingBuildings.Value && TryFindBlockingBuild(player, out var result))
		{
			_mob.target = result;
			_mob.targetPlayerId = -1;
			return result.position;
		}
		SetPlayerTarget(player);
		float num = Vector3.Distance(((Component)this).transform.position, ((Component)player).transform.position);
		if (num <= 12f || _mob.mobType.followPlayerAccuracy >= 0.999f)
		{
			return ((Component)player).transform.position;
		}
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(Random.Range(-1f, 1f), 0f, Random.Range(-1f, 1f));
		val *= num * (1f - _mob.mobType.followPlayerAccuracy);
		return ((Component)player).transform.position + val;
	}

	private bool TryFindBlockingBuild(PlayerManager player, out Transform result)
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0135: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		result = null;
		if (_mob.mobType.ignoreBuilds || HasLineOfSight(player) || (Object)(object)ResourceManager.Instance == (Object)null || ResourceManager.Instance.builds == null)
		{
			_cachedBlockingBuild = null;
			return false;
		}
		float value = Plugin.Settings.BuildingAttackDistance.Value;
		if ((Object)(object)_cachedBlockingBuild != (Object)null)
		{
			Vector3 val = _cachedBlockingBuild.position - ((Component)this).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude <= value * value)
			{
				result = _cachedBlockingBuild;
				return true;
			}
			_cachedBlockingBuild = null;
		}
		if (Time.time < _nextBlockingBuildScanAt)
		{
			return false;
		}
		_nextBlockingBuildScanAt = Time.time + 2.1f + (float)Mathf.Abs(((Object)this).GetInstanceID() % 29) * 0.037f;
		float num = value;
		Vector3 val2 = ((Component)player).transform.position - ((Component)this).transform.position;
		Vector3 normalized = ((Vector3)(ref val2)).normalized;
		foreach (KeyValuePair<int, GameObject> build in ResourceManager.Instance.builds)
		{
			GameObject value2 = build.Value;
			if (!((Object)(object)value2 == (Object)null))
			{
				Vector3 val3 = value2.transform.position - ((Component)this).transform.position;
				float magnitude = ((Vector3)(ref val3)).magnitude;
				if (!(magnitude >= num) && !(Vector3.Dot(normalized, ((Vector3)(ref val3)).normalized) < 0.35f))
				{
					num = magnitude;
					result = value2.transform;
				}
			}
		}
		_cachedBlockingBuild = result;
		return (Object)(object)result != (Object)null;
	}

	private PlayerManager FindClosestVisiblePlayer(float maxDistance)
	{
		//IL_0046: 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)
		if (GameManager.players == null)
		{
			return null;
		}
		PlayerManager result = null;
		float num = maxDistance;
		foreach (PlayerManager value in GameManager.players.Values)
		{
			if (!((Object)(object)value == (Object)null) && !value.dead && !value.disconnected)
			{
				float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)value).transform.position);
				if (!(num2 >= num) && (!(num2 > Plugin.Settings.ProximityAcquireDistance.Value) || HasLineOfSight(value)))
				{
					result = value;
					num = num2;
				}
			}
		}
		return result;
	}

	private bool HasLineOfSight(PlayerManager player)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_004c: 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_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		if (_lineOfSightFrame == Time.frameCount && _lineOfSightPlayerId == player.id)
		{
			return _lineOfSightResult;
		}
		Vector3 val = ((Component)this).transform.position + Vector3.up * 1.2f;
		Vector3 val2 = ((Component)player).transform.position + Vector3.up * 1.2f - val;
		float magnitude = ((Vector3)(ref val2)).magnitude;
		if (magnitude <= 0.01f)
		{
			return CacheLineOfSight(player.id, result: true);
		}
		int num = -5;
		if ((Object)(object)MobManager.Instance != (Object)null && ((LayerMask)(ref MobManager.Instance.whatIsRaycastable)).value != 0)
		{
			num = ((LayerMask)(ref MobManager.Instance.whatIsRaycastable)).value;
		}
		RaycastHit val3 = default(RaycastHit);
		if (!Physics.Raycast(val, ((Vector3)(ref val2)).normalized, ref val3, magnitude + 0.5f, num, (QueryTriggerInteraction)1))
		{
			return CacheLineOfSight(player.id, result: true);
		}
		PlayerManager componentInParent = ((Component)((RaycastHit)(ref val3)).transform).GetComponentInParent<PlayerManager>();
		return CacheLineOfSight(player.id, (Object)(object)componentInParent == (Object)(object)player);
	}

	private bool CacheLineOfSight(int playerId, bool result)
	{
		_lineOfSightFrame = Time.frameCount;
		_lineOfSightPlayerId = playerId;
		_lineOfSightResult = result;
		return result;
	}

	private bool TryGetLivingPlayer(int playerId, out PlayerManager player)
	{
		player = null;
		if (playerId < 0 || GameManager.players == null || !GameManager.players.TryGetValue(playerId, out player))
		{
			return false;
		}
		if ((Object)(object)player != (Object)null && !player.dead)
		{
			return !player.disconnected;
		}
		return false;
	}

	private void SetPlayerTarget(PlayerManager player)
	{
		_mob.target = ((Component)player).transform;
		_mob.targetPlayerId = player.id;
	}

	private void ClearTarget()
	{
		_mob.target = null;
		_mob.targetPlayerId = -1;
	}

	private float AcquireDistance()
	{
		if (IsBoss)
		{
			return Plugin.Settings.BossAcquireDistance.Value;
		}
		if (!IsRanged)
		{
			return Plugin.Settings.MeleeAcquireDistance.Value;
		}
		return Plugin.Settings.RangedAcquireDistance.Value;
	}

	private float DisengageDistance()
	{
		if (IsBoss)
		{
			return Plugin.Settings.BossDisengageDistance.Value;
		}
		if (!IsRanged)
		{
			return Plugin.Settings.MeleeDisengageDistance.Value;
		}
		return Plugin.Settings.RangedDisengageDistance.Value;
	}

	private float HomeLeashDistance()
	{
		if (IsBoss)
		{
			return Plugin.Settings.BossHomeLeash.Value;
		}
		if (!IsRanged)
		{
			return Plugin.Settings.MeleeHomeLeash.Value;
		}
		return Plugin.Settings.RangedHomeLeash.Value;
	}

	private float LostSightSeconds()
	{
		if (IsBoss)
		{
			return Plugin.Settings.BossLostSightSeconds.Value;
		}
		if (!IsRanged)
		{
			return Plugin.Settings.MeleeLostSightSeconds.Value;
		}
		return Plugin.Settings.RangedLostSightSeconds.Value;
	}
}
[HarmonyPatch(typeof(MobServerEnemy), "FindNextPosition")]
internal static class MobServerEnemyFindNextPositionPatch
{
	private static bool Prefix(MobServerEnemy __instance, ref Vector3 __result)
	{
		//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)
		if (!Plugin.Settings.EnableAggro.Value)
		{
			return true;
		}
		AggroController aggroController = ((Component)__instance).GetComponent<AggroController>();
		if ((Object)(object)aggroController == (Object)null)
		{
			aggroController = ((Component)__instance).gameObject.AddComponent<AggroController>();
		}
		((MonoBehaviour)__instance).Invoke("SyncFindNextPosition", aggroController.GetNextThinkDelay());
		__result = aggroController.GetNextDestination();
		return false;
	}
}
[HarmonyPatch(typeof(Hitable), "Damage")]
internal static class HitableDamageAggroPatch
{
	private static void Prefix(Hitable __instance, int newHp, int fromClient)
	{
		if (!Plugin.Settings.EnableAggro.Value || !LocalClient.serverOwner || newHp >= __instance.hp)
		{
			return;
		}
		HitableMob val = (HitableMob)(object)((__instance is HitableMob) ? __instance : null);
		if (!((Object)(object)val == (Object)null))
		{
			AggroController aggroController = ((Component)val).GetComponent<AggroController>();
			if ((Object)(object)aggroController == (Object)null)
			{
				aggroController = ((Component)val).gameObject.AddComponent<AggroController>();
			}
			aggroController.MarkDamagedBy(fromClient);
		}
	}
}
[HarmonyPatch(typeof(Mob), "SetTarget")]
internal static class MobSetTargetPatch
{
	private static bool Prefix(Mob __instance, int targetId)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		if ((Object)(object)__instance.agent != (Object)null && __instance.agent.isOnNavMesh && targetId >= 0 && GameManager.players != null && GameManager.players.TryGetValue(targetId, out var value) && (Object)(object)value != (Object)null)
		{
			__instance.targetPlayerId = targetId;
			__instance.target = ((Component)value).transform;
			return false;
		}
		__instance.targetPlayerId = -1;
		__instance.target = null;
		return false;
	}
}
internal static class ArtifactBalance
{
	private static readonly FieldInfo JuiceSpeed = AccessTools.Field(typeof(PowerupInventory), "juiceSpeed");

	internal static int Stacks(int[] powerups, string name)
	{
		if (powerups == null && (Object)(object)PowerupInventory.Instance != (Object)null)
		{
			powerups = (int[])AccessTools.Field(typeof(PowerupInventory), "powerups")?.GetValue(PowerupInventory.Instance);
		}
		if (powerups == null || ItemManager.Instance?.stringToPowerupId == null || !ItemManager.Instance.stringToPowerupId.TryGetValue(name, out var value) || value < 0 || value >= powerups.Length)
		{
			return 0;
		}
		return Mathf.Max(0, powerups[value]);
	}

	internal static float Curve(int stacks, float speed, float maximum)
	{
		return PowerupInventory.CumulativeDistribution(Mathf.Max(0, stacks), speed, maximum);
	}

	internal static float Defense(int stacks)
	{
		return Curve(stacks, 0.12f, 35f);
	}

	internal static float Dumbbell(int stacks)
	{
		return 1f + Curve(stacks, 0.07f, 1.5f);
	}

	internal static float Berserk(int stacks, float missingHp)
	{
		return 1f + Mathf.Clamp01(missingHp) * Curve(stacks, 0.22f, 1.4f);
	}

	internal static float Stamina(int stacks)
	{
		return 1f + Curve(stacks, 0.13f, 1.5f);
	}

	internal static float Healing(int stacks)
	{
		return Curve(stacks, 0.09f, 0.75f);
	}

	internal static float Resource(int stacks)
	{
		return 1f + Curve(stacks, 0.22f, 2.5f);
	}

	internal static float Loot(int stacks)
	{
		return 1f + Curve(stacks, 0.17f, 0.9f);
	}

	internal static float AttackSpeed(int stacks)
	{
		return 1f + Curve(stacks, 0.13f, 0.85f);
	}

	internal static float Hunger(int stacks)
	{
		return 1f - Curve(stacks, 0.16f, 0.65f);
	}

	internal static float Juice(int stacks)
	{
		return 1f + Curve(stacks, 0.3f, 0.6f);
	}

	internal static float Robin(int stacks)
	{
		return 1f + Curve(stacks, 0.12f, 1f);
	}

	internal static float Speed(int stacks)
	{
		return 1f + Curve(stacks, 0.12f, 0.65f);
	}

	internal static float Adrenaline(int stacks)
	{
		return 1f + Curve(stacks, 0.55f, 0.75f);
	}

	internal static float Crit(int stacks)
	{
		return 0.18f + Curve(stacks, 0.12f, 0.52f);
	}

	internal static float Jump(int stacks)
	{
		return 1f + Curve(stacks, 0.13f, 1.2f);
	}

	internal static float Wings(int stacks)
	{
		if (stacks > 0)
		{
			return 1f + Curve(stacks, 0.32f, 1.5f);
		}
		return 1f;
	}

	internal static float Lifesteal(int stacks)
	{
		return Curve(stacks, 0.11f, 0.35f);
	}

	internal static float KnockbackChance(int stacks)
	{
		return Curve(stacks, 0.2f, 0.65f);
	}

	internal static float SniperChance(int stacks)
	{
		if (stacks > 0)
		{
			return 0.05f + Curve(stacks, 0.13f, 0.23f);
		}
		return 0f;
	}

	internal static float SniperDamage(int stacks)
	{
		if (stacks > 0)
		{
			return 2.2f + Curve(stacks, 0.16f, 2.8f);
		}
		return 1f;
	}

	internal static float LightningChance(int stacks)
	{
		return Curve(stacks, 0.14f, 0.35f);
	}

	internal static float LightningDamage(int stacks)
	{
		return 2f + Curve(stacks, 0.14f, 0.75f);
	}

	internal static float Enforcer(int stacks, float speed)
	{
		if (stacks > 0)
		{
			return 1f + Curve(stacks, 0.3f, 1.2f) * Mathf.Clamp01(Mathf.Max(0f, speed) / 22f);
		}
		return 1f;
	}

	internal static int BonusHp(int stacks)
	{
		return Mathf.Max(0, stacks) * 8;
	}

	internal static int BonusShield(int stacks)
	{
		return Mathf.Max(0, stacks) * 8;
	}

	internal static float JuiceSpeedMultiplier(PowerupInventory instance)
	{
		if (!((Object)(object)instance != (Object)null) || !(JuiceSpeed != null))
		{
			return 1f;
		}
		return Mathf.Max(1f, (float)JuiceSpeed.GetValue(instance));
	}

	internal static float LowHpRatio()
	{
		PlayerStatus instance = PlayerStatus.Instance;
		if (!((Object)(object)instance == (Object)null) && instance.maxHp > 0)
		{
			return ((float)instance.maxHp - instance.hp) / (float)instance.maxHp;
		}
		return 0f;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetDefenseMultiplier")]
internal static class BalancedDefenseArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Defense(ArtifactBalance.Stacks(playerPowerups, "Danis Milk"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetStrengthMultiplier")]
internal static class BalancedStrengthArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = 1.3f * ArtifactBalance.Dumbbell(ArtifactBalance.Stacks(playerPowerups, "Dumbbell")) * ArtifactBalance.Berserk(ArtifactBalance.Stacks(playerPowerups, "Berserk"), ArtifactBalance.LowHpRatio());
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetAttackSpeedMultiplier")]
internal static class BalancedAttackSpeedArtifactPatch
{
	private static bool Prefix(PowerupInventory __instance, int[] playerPowerups, ref float __result)
	{
		float num = (((Object)(object)PlayerStatus.Instance != (Object)null && PlayerStatus.Instance.adrenalineBoost) ? ArtifactBalance.Adrenaline(ArtifactBalance.Stacks(playerPowerups, "Adrenaline")) : 1f);
		__result = 1.5f * ArtifactBalance.AttackSpeed(ArtifactBalance.Stacks(playerPowerups, "Orange Juice")) * num * ArtifactBalance.JuiceSpeedMultiplier(__instance);
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetStaminaMultiplier")]
internal static class BalancedStaminaArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		float num = (((Object)(object)PlayerStatus.Instance != (Object)null && PlayerStatus.Instance.adrenalineBoost) ? ArtifactBalance.Adrenaline(ArtifactBalance.Stacks(playerPowerups, "Adrenaline")) : 1f);
		__result = ArtifactBalance.Stamina(ArtifactBalance.Stacks(playerPowerups, "Peanut Butter")) * num;
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetHealingMultiplier")]
internal static class BalancedHealingArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Healing(ArtifactBalance.Stacks(playerPowerups, "Broccoli"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetResourceMultiplier")]
internal static class BalancedResourceArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		__result = ArtifactBalance.Resource(ArtifactBalance.Stacks(playerPowerups, "Checkered Shirt"));
		if (GameManager.gameSettings != null && (int)GameManager.gameSettings.gameMode == 1)
		{
			__result += 1.25f;
		}
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetLootMultiplier")]
internal static class BalancedLootArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Loot(ArtifactBalance.Stacks(playerPowerups, "Piggybank"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetSniperScopeMultiplier")]
internal static class BalancedSniperArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		int num = ArtifactBalance.Stacks(playerPowerups, "Sniper Scope");
		__result = ((num > 0 && Random.value < ArtifactBalance.SniperChance(num)) ? ArtifactBalance.SniperDamage(num) : 1f);
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetSniperScopeDamageMultiplier")]
internal static class BalancedSniperDamageArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.SniperDamage(ArtifactBalance.Stacks(playerPowerups, "Sniper Scope"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetLightningMultiplier")]
internal static class BalancedLightningArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		int num = ArtifactBalance.Stacks(playerPowerups, "Knuts Hammer");
		__result = ((num > 0 && Random.value < ArtifactBalance.LightningChance(num)) ? ArtifactBalance.LightningDamage(num) : (-1f));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetHpMultiplier")]
internal static class BalancedHpArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref int __result)
	{
		__result = ArtifactBalance.BonusHp(ArtifactBalance.Stacks(playerPowerups, "Red Pill"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetShield")]
internal static class BalancedShieldArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref int __result)
	{
		__result = ArtifactBalance.BonusShield(ArtifactBalance.Stacks(playerPowerups, "Blue Pill"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetHungerMultiplier")]
internal static class BalancedHungerArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Hunger(ArtifactBalance.Stacks(playerPowerups, "Spooo Bean"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetJuiceMultiplier")]
internal static class BalancedJuiceArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Juice(ArtifactBalance.Stacks(playerPowerups, "Juice"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetRobinMultiplier")]
internal static class BalancedRobinArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Robin(ArtifactBalance.Stacks(playerPowerups, "Robin Hood Hat"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetEnforcerMultiplier")]
internal static class BalancedEnforcerArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, float speed, ref float __result)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		float num;
		if (!(speed >= 0f))
		{
			PlayerMovement instance = PlayerMovement.Instance;
			if (instance == null)
			{
				num = 0f;
			}
			else
			{
				Vector3 velocity = instance.GetVelocity();
				num = ((Vector3)(ref velocity)).magnitude;
			}
		}
		else
		{
			num = speed;
		}
		float speed2 = num;
		__result = ArtifactBalance.Enforcer(ArtifactBalance.Stacks(playerPowerups, "Enforcer"), speed2);
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetSpeedMultiplier")]
internal static class BalancedSpeedArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		float num = (((Object)(object)PlayerStatus.Instance != (Object)null && PlayerStatus.Instance.adrenalineBoost) ? ArtifactBalance.Adrenaline(ArtifactBalance.Stacks(playerPowerups, "Adrenaline")) : 1f);
		float num2 = PlayerStatus.Instance?.currentSpeedArmorMultiplier ?? 1f;
		__result = ArtifactBalance.Speed(ArtifactBalance.Stacks(playerPowerups, "Sneaker")) * num * num2;
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetAdrenalineBoost")]
internal static class BalancedAdrenalineArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Adrenaline(ArtifactBalance.Stacks(playerPowerups, "Adrenaline"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetCritChance")]
internal static class BalancedCritArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Crit(ArtifactBalance.Stacks(playerPowerups, "Horseshoe"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetJumpMultiplier")]
internal static class BalancedJumpArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Jump(ArtifactBalance.Stacks(playerPowerups, "Jetpack"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetExtraJumps")]
internal static class BalancedFrogArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref int __result)
	{
		__result = Mathf.Min(3, ArtifactBalance.Stacks(playerPowerups, "Janniks Frog"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetFallWingsMultiplier")]
internal static class BalancedWingsArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Wings(ArtifactBalance.Stacks(playerPowerups, "Wings of Glory"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetKnockbackMultiplier")]
internal static class BalancedBulldozerArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ((Random.value < ArtifactBalance.KnockbackChance(ArtifactBalance.Stacks(playerPowerups, "Bulldozer"))) ? 1f : 0f);
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetLifestealMultiplier")]
internal static class BalancedLifestealArtifactPatch
{
	private static bool Prefix(int[] playerPowerups, ref float __result)
	{
		__result = ArtifactBalance.Lifesteal(ArtifactBalance.Stacks(playerPowerups, "Crimson Dagger"));
		return false;
	}
}
[HarmonyPatch(typeof(PowerupInventory), "GetMaxDraculaStacks")]
internal static class BalancedDraculaCapPatch
{
	private static bool Prefix(ref int __result)
	{
		__result = ArtifactBalance.Stacks(null, "Dracula") * 25;
		return false;
	}
}
internal sealed class ArtifactOffer
{
	internal int ChestId;

	internal int PlayerId;

	internal int[] Choices;

	internal float ExpiresAt;
}
internal static class ArtifactChoiceService
{
	private sealed class DeterministicRoll
	{
		private uint state;

		internal DeterministicRoll(int seed)
		{
			state = ((seed == 0) ? 2738958700u : ((uint)seed));
		}

		internal uint Next()
		{
			state ^= state << 13;
			state ^= state >> 17;
			state ^= state << 5;
			return state;
		}

		internal int Range(int max)
		{
			if (max > 1)
			{
				return (int)(Next() % (uint)max);
			}
			return 0;
		}

		internal float NextFloat()
		{
			return (float)(Next() & 0xFFFFFF) / 16777216f;
		}
	}

	internal const int ChoicePacketId = 240;

	private static readonly Dictionary<long, ArtifactOffer> ServerOffers = new Dictionary<long, ArtifactOffer>();

	private static readonly MethodInfo SendTcp = AccessTools.Method(typeof(ClientSend), "SendTCPData", (Type[])null, (Type[])null);

	private static readonly FieldInfo PowerupsField = AccessTools.Field(typeof(PowerupInventory), "powerups");

	internal static int[] GenerateChoices(LootContainerInteract chest)
	{
		if ((Object)(object)chest == (Object)null || (Object)(object)ItemManager.Instance == (Object)null)
		{
			return Array.Empty<int>();
		}
		int[] array = GenerateChoices(chest.GetId(), chest.white, chest.blue, chest.gold);
		if (chest.testPowerup && (Object)(object)chest.powerupToTest != (Object)null && array.Length == 3 && ItemManager.Instance.allPowerups.ContainsKey(chest.powerupToTest.id))
		{
			int id = chest.powerupToTest.id;
			int num = Array.IndexOf(array, id);
			if (num > 0)
			{
				array[num] = array[0];
			}
			array[0] = id;
		}
		return array;
	}

	internal static int[] GenerateChoices(int chestId, float white, float blue, float gold)
	{
		Dictionary<int, Powerup> all = ItemManager.Instance?.allPowerups;
		if (all == null)
		{
			return Array.Empty<int>();
		}
		List<int> list = (from pair in all
			where (Object)(object)pair.Value != (Object)null
			select pair.Key into value
			orderby value
			select value).ToList();
		if (list.Count < 3)
		{
			return Array.Empty<int>();
		}
		List<int> white2 = list.Where((int id) => (int)all[id].tier == 0).ToList();
		List<int> blue2 = list.Where((int id) => (int)all[id].tier == 1).ToList();
		List<int> orange = list.Where((int id) => (int)all[id].tier == 2).ToList();
		DeterministicRoll deterministicRoll = new DeterministicRoll(GameManager.GetSeed() * 486187739 + chestId * 16777619 + 219671);
		List<int> result = new List<int>(3);
		for (int num = 0; num < 3; num++)
		{
			int num2 = -1;
			for (int num3 = 0; num3 < 20; num3++)
			{
				if (num2 >= 0 && !result.Contains(num2))
				{
					break;
				}
				List<int> list2 = PickTier(deterministicRoll, white2, blue2, orange, white, blue, gold);
				if (list2.Count > 0)
				{
					num2 = list2[deterministicRoll.Range(list2.Count)];
				}
			}
			if (num2 < 0 || result.Contains(num2))
			{
				num2 = list.First((int value) => !result.Contains(value));
			}
			result.Add(num2);
		}
		return result.ToArray();
	}

	private static List<int> PickTier(DeterministicRoll random, List<int> white, List<int> blue, List<int> orange, float whiteWeight, float blueWeight, float orangeWeight)
	{
		whiteWeight = ((white.Count > 0) ? Mathf.Max(0f, whiteWeight) : 0f);
		blueWeight = ((blue.Count > 0) ? Mathf.Max(0f, blueWeight) : 0f);
		orangeWeight = ((orange.Count > 0) ? Mathf.Max(0f, orangeWeight) : 0f);
		float num = whiteWeight + blueWeight + orangeWeight;
		if (num <= 0f)
		{
			whiteWeight = ((white.Count > 0) ? 1f : 0f);
			blueWeight = ((blue.Count > 0) ? 1f : 0f);
			orangeWeight = ((orange.Count > 0) ? 1f : 0f);
			num = whiteWeight + blueWeight + orangeWeight;
		}
		float num2 = random.NextFloat() * num;
		if (num2 < whiteWeight)
		{
			return white;
		}
		if (num2 < whiteWeight + blueWeight)
		{
			return blue;
		}
		return orange;
	}

	internal static bool RegisterServerOffer(LootContainerInteract chest, int fromClient)
	{
		if ((Object)(object)chest == (Object)null || fromClient < 0)
		{
			return false;
		}
		int[] array = GenerateChoices(chest);
		if (array.Length != 3)
		{
			return false;
		}
		long[] array2 = (from pair in ServerOffers
			where pair.Value.PlayerId == fromClient
			select pair.Key).ToArray();
		foreach (long key in array2)
		{
			ServerOffers.Remove(key);
		}
		ArtifactOffer artifactOffer = new ArtifactOffer
		{
			ChestId = chest.GetId(),
			PlayerId = fromClient,
			Choices = array,
			ExpiresAt = Time.unscaledTime + 1800f
		};
		ServerOffers[OfferKey(fromClient, artifactOffer.ChestId)] = artifactOffer;
		Plugin.Log.LogInfo((object)string.Format("Artifact offer chest={0}, player={1}, choices={2}", artifactOffer.ChestId, fromClient, string.Join(",", array)));
		return true;
	}

	internal static void Reset()
	{
		ServerOffers.Clear();
	}

	internal static void ForgetPlayer(int playerId)
	{
		long[] array = (from pair in ServerOffers
			where pair.Value.PlayerId == playerId
			select pair.Key).ToArray();
		foreach (long key in array)
		{
			ServerOffers.Remove(key);
		}
	}

	internal static void SubmitChoice(int chestId, int powerupId)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Expected O, but got Unknown
		if ((Object)(object)LocalClient.instance == (Object)null)
		{
			return;
		}
		if (LocalClient.serverOwner)
		{
			HandleChoice(LocalClient.instance.myId, chestId, powerupId);
			return;
		}
		try
		{
			Packet val = new Packet(240);
			try
			{
				val.Write(chestId);
				val.Write(powerupId);
				SendTcp?.Invoke(null, new object[1] { val });
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Could not send artifact choice: " + ex));
		}
	}

	internal static void HandleChoicePacket(int fromClient, Packet packet)
	{
		try
		{
			HandleChoice(fromClient, packet.ReadInt(true), packet.ReadInt(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed artifact choice from {fromClient}: {ex.Message}");
		}
	}

	private static void HandleChoice(int fromClient, int chestId, int powerupId)
	{
		long key = OfferKey(fromClient, chestId);
		Client value2;
		Powerup value3;
		if (!ServerOffers.TryGetValue(key, out var value) || value.ExpiresAt < Time.unscaledTime || value.Choices == null || !value.Choices.Contains(powerupId))
		{
			Plugin.Log.LogWarning((object)$"Rejected unoffered artifact {powerupId} from player {fromClient}, chest {chestId}");
			ServerOffers.Remove(key);
		}
		else if (Server.clients == null || !Server.clients.TryGetValue(fromClient, out value2) || value2?.player == null || ItemManager.Instance?.allPowerups == null || !ItemManager.Instance.allPowerups.TryGetValue(powerupId, out value3))
		{
			ServerOffers.Remove(key);
		}
		else
		{
			ServerOffers.Remove(key);
			Grant(fromClient, value2.player, value3);
		}
	}

	private static void Grant(int fromClient, Player serverPlayer, Powerup powerup)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: 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_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: 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)
		PlayerManager value;
		Vector3 val = ((GameManager.players != null && GameManager.players.TryGetValue(fromClient, out value) && (Object)(object)value != (Object)null) ? (((Component)value).transform.position + Vector3.up * 1.2f) : Vector3.zero);
		int nextId = ItemManager.Instance.GetNextId();
		ItemManager.Instance.DropPowerupAtPosition(powerup.id, val, nextId);
		ServerSend.DropPowerupAtPosition(powerup.id, nextId, val);
		if (serverPlayer.powerups != null && powerup.id >= 0 && powerup.id < serverPlayer.powerups.Length)
		{
			serverPlayer.powerups[powerup.id]++;
		}
		if ((Object)(object)GameManager.instance != (Object)null)
		{
			GameManager.instance.powerupsPickedup = true;
		}
		if (serverPlayer.stats != null)
		{
			serverPlayer.stats.TryGetValue("Powerups", out var value2);
			serverPlayer.stats["Powerups"] = value2 + 1;
		}
		if ((Object)(object)LocalClient.instance != (Object)null && fromClient == LocalClient.instance.myId && (Object)(object)PowerupInventory.Instance != (Object)null)
		{
			PowerupInventory.Instance.AddPowerup(powerup.name, powerup.id, nextId);
		}
		ItemManager.Instance.PickupItem(nextId);
		ServerSend.PickupItem(fromClient, nextId);
		Plugin.Log.LogInfo((object)$"Granted chosen artifact {powerup.name} ({powerup.id}) to player {fromClient}");
	}

	internal static int CurrentStacks(int powerupId)
	{
		if ((Object)(object)PowerupInventory.Instance == (Object)null || PowerupsField == null)
		{
			return 0;
		}
		int[] array = (int[])PowerupsField.GetValue(PowerupInventory.Instance);
		if (array == null || powerupId < 0 || powerupId >= array.Length)
		{
			return 0;
		}
		return array[powerupId];
	}

	private static long OfferKey(int playerId, int chestId)
	{
		return ((long)playerId << 32) ^ (uint)chestId;
	}
}
internal sealed class ArtifactChoiceOverlay : MonoBehaviour
{
	private static ArtifactChoiceOverlay instance;

	private int chestId;

	private Powerup[] choices;

	private CursorLockMode previousLock;

	private bool previousCursor;

	private bool previousInputActive;

	private bool inputCaptured;

	private GUIStyle titleStyle;

	private GUIStyle nameStyle;

	private GUIStyle bodyStyle;

	private GUIStyle tierStyle;

	internal static void Show(LootContainerInteract chest)
	{
		//IL_0048: 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_0053: Expected O, but got Unknown
		if (!Plugin.Settings.EnableArtifactChoices.Value || (Object)(object)chest == (Object)null || (Object)(object)ItemManager.Instance == (Object)null)
		{
			return;
		}
		int[] array = ArtifactChoiceService.GenerateChoices(chest);
		if (array.Length != 3)
		{
			return;
		}
		if ((Object)(object)instance == (Object)null)
		{
			GameObject val = new GameObject("Muck Replayable Artifact Choice");
			Object.DontDestroyOnLoad((Object)val);
			instance = val.AddComponent<ArtifactChoiceOverlay>();
		}
		Dictionary<int, Powerup> allPowerups = ItemManager.Instance.allPowerups;
		if (allPowerups == null)
		{
			return;
		}
		List<Powerup> list = new List<Powerup>(3);
		int[] array2 = array;
		foreach (int key in array2)
		{
			if (!allPowerups.TryGetValue(key, out var value) || (Object)(object)value == (Object)null)
			{
				return;
			}
			list.Add(value);
		}
		instance.Open(chest.GetId(), list.ToArray());
	}

	private void Open(int id, Powerup[] offered)
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		if (offered != null && offered.Length == 3 && !offered.Any((Powerup powerup) => (Object)(object)powerup == (Object)null))
		{
			if (!inputCaptured)
			{
				previousLock = Cursor.lockState;
				previousCursor = Cursor.visible;
				previousInputActive = (Object)(object)PlayerInput.Instance != (Object)null && PlayerInput.Instance.active;
				inputCaptured = true;
			}
			chestId = id;
			choices = offered;
			if ((Object)(object)PlayerInput.Instance != (Object)null)
			{
				PlayerInput.Instance.active = false;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}
	}

	private void Update()
	{
		if (choices != null && (Object)(object)GameManager.instance == (Object)null)
		{
			Close();
		}
		else if (choices != null && (Object)(object)PlayerInput.Instance != (Object)null && PlayerInput.Instance.active)
		{
			PlayerInput.Instance.active = false;
		}
	}

	private void OnGUI()
	{
		//IL_0086: 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_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_017a: Unknown result type (might be due to invalid IL or missing references)
		if (choices != null && choices.Length == 3)
		{
			LocalizationService.ApplyGuiFont();
			ReforgedGuiTheme.Ensure();
			EnsureStyles();
			GUI.depth = -2000;
			ReforgedGuiTheme.DrawDim();
			float num = Mathf.Min((float)Screen.width * 0.9f, 1280f);
			float num2 = Mathf.Min((float)Screen.height * 0.78f, 690f);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((float)Screen.width - num) * 0.5f, ((float)Screen.height - num2) * 0.5f, num, num2);
			GUI.Box(val, GUIContent.none, ReforgedGuiTheme.Window);
			GUI.Label(new Rect(((Rect)(ref val)).x + 24f, ((Rect)(ref val)).y + 18f, ((Rect)(ref val)).width - 48f, 44f), Header(), titleStyle);
			GUI.Label(new Rect(((Rect)(ref val)).x + 24f, ((Rect)(ref val)).y + 59f, ((Rect)(ref val)).width - 48f, 26f), Subtitle(), bodyStyle);
			float num3 = 14f;
			float num4 = (((Rect)(ref val)).width - 40f - num3 * 2f) / 3f;
			Rect card = default(Rect);
			for (int i = 0; i < 3; i++)
			{
				((Rect)(ref card))..ctor(((Rect)(ref val)).x + 20f + (float)i * (num4 + num3), ((Rect)(ref val)).y + 92f, num4, ((Rect)(ref val)).height - 112f);
				DrawCard(card, choices[i]);
			}
		}
	}

	private void DrawCard(Rect card, Powerup powerup)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: 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_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0260: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		Color outlineColor = powerup.GetOutlineColor();
		ReforgedGuiTheme.DrawCard(card, (Color?)new Color(outlineColor.r * 0.35f + 0.65f, outlineColor.g * 0.35f + 0.65f, outlineColor.b * 0.35f + 0.65f, 1f));
		GUI.Label(new Rect(((Rect)(ref card)).x + 12f, ((Rect)(ref card)).y + 8f, ((Rect)(ref card)).width - 24f, 24f), TierName(powerup.tier), tierStyle);
		float num = Mathf.Clamp(((Rect)(ref card)).height * 0.21f, 76f, 116f);
		Rect rect = default(Rect);
		((Rect)(ref rect))..ctor(((Rect)(ref card)).x + (((Rect)(ref card)).width - num) * 0.5f, ((Rect)(ref card)).y + 36f, num, num);
		ReforgedGuiTheme.DrawCard(new Rect(((Rect)(ref rect)).x - 7f, ((Rect)(ref rect)).y - 7f, ((Rect)(ref rect)).width + 14f, ((Rect)(ref rect)).height + 14f));
		DrawSprite(powerup.sprite, rect);
		float num2 = ((Rect)(ref rect)).yMax + 7f;
		GUI.Label(new Rect(((Rect)(ref card)).x + 12f, num2, ((Rect)(ref card)).width - 24f, 48f), ArtifactEffectFormatter.DisplayName(powerup.name), nameStyle);
		int num3 = ArtifactChoiceService.CurrentStacks(powerup.id);
		float num4 = num2 + 49f;
		GUI.Label(new Rect(((Rect)(ref card)).x + 16f, num4, ((Rect)(ref card)).width - 32f, 46f), StackLine(num3), bodyStyle);
		float num5 = num4 + 44f;
		GUI.Label(new Rect(((Rect)(ref card)).x + 16f, num5, ((Rect)(ref card)).width - 32f, 76f), ArtifactEffectFormatter.Describe(powerup.name, num3), bodyStyle);
		float num6 = ((Rect)(ref card)).yMax - 54f;
		float num7 = num5 + 76f;
		GUI.Label(new Rect(((Rect)(ref card)).x + 16f, num7, ((Rect)(ref card)).width - 32f, Mathf.Max(20f, num6 - num7 - 6f)), ArtifactEffectFormatter.Description(powerup.name, powerup.description), bodyStyle);
		if (GUI.Button(new Rect(((Rect)(ref card)).x + 18f, num6, ((Rect)(ref card)).width - 36f, 40f), ChooseText(), ReforgedGuiTheme.PrimaryButton))
		{
			ArtifactChoiceService.SubmitChoice(chestId, powerup.id);
			Close();
		}
	}

	private void Close()
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		choices = null;
		if (inputCaptured)
		{
			if ((Object)(object)PlayerInput.Instance != (Object)null)
			{
				PlayerInput.Instance.active = previousInputActive;
			}
			Cursor.lockState = previousLock;
			Cursor.visible = previousCursor;
			inputCaptured = false;
		}
	}

	private void OnDestroy()
	{
		Close();
		if ((Object)(object)instance == (Object)(object)this)
		{
			instance = null;
		}
	}

	private void EnsureStyles()
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Expected O, but got Unknown
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Expected O, but got Unknown
		//IL_0081: 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_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Expected O, but got Unknown
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Expected O, but got Unknown
		if (titleStyle != null)
		{
			LocalizationService.ApplyGuiFont(titleStyle, nameStyle, bodyStyle, tierStyle);
			return;
		}
		ReforgedGuiTheme.Ensure();
		titleStyle = new GUIStyle(ReforgedGuiTheme.Title)
		{
			alignment = (TextAnchor)4,
			fontSize = 28
		};
		nameStyle = new GUIStyle(ReforgedGuiTheme.Heading)
		{
			alignment = (TextAnchor)4,
			fontSize = 22
		};
		bodyStyle = new GUIStyle(ReforgedGuiTheme.Label)
		{
			alignment = (TextAnchor)1,
			fontSize = 15
		};
		tierStyle = new GUIStyle(ReforgedGuiTheme.Muted)
		{
			alignment = (TextAnchor)4,
			fontSize = 14,
			fontStyle = (FontStyle)1
		};
		LocalizationService.ApplyGuiFont(titleStyle, nameStyle, bodyStyle, tierStyle);
	}

	private static void DrawSprite(Sprite sprite, Rect rect)
	{
		//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_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)sprite == (Object)null) && !((Object)(object)sprite.texture == (Object)null))
		{
			Rect textureRect = sprite.textureRect;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)sprite.texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)sprite.texture).height, ((Rect)(ref textureRect)).width / (float)((Texture)sprite.texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)sprite.texture).height);
			GUI.DrawTextureWithTexCoords(rect, (Texture)(object)sprite.texture, val, true);
		}
	}

	private static string Header()
	{
		return LocalizationService.T("artifact_header");
	}

	private static string Subtitle()
	{
		return LocalizationService.T("artifact_subtitle");
	}

	private static string StackLine(int stacks)
	{
		return string.Format(LocalizationService.T("artifact_stack"), stacks, stacks + 1);
	}

	private static string ChooseText()
	{
		return LocalizationService.T("artifact_choose");
	}

	private static string TierName(PowerTier tier)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Invalid comparison between Unknown and I4
		if ((int)tier != 0)
		{
			if ((int)tier != 1)
			{
				return LocalizationService.T("tier_legendary");
			}
			return LocalizationService.T("tier_rare");
		}
		return LocalizationService.T("tier_common");
	}
}
internal static class ArtifactEffectFormatter
{
	internal static string DisplayName(string name)
	{
		return name ?? string.Empty;
	}

	internal static string Description(string name, string original)
	{
		return original ?? string.Empty;
	}

	internal static string Describe(string name, int current)
	{
		int num = current + 1;
		return name switch
		{
			"Red Pill" => $"Max HP: {100 + ArtifactBalance.BonusHp(current)} → {100 + ArtifactBalance.BonusHp(num)}", 
			"Blue Pill" => $"Shield: {ArtifactBalance.BonusShield(current)} → {ArtifactBalance.BonusShield(num)}", 
			"Dumbbell" => Bonus("Base damage", ArtifactBalance.Dumbbell(current), ArtifactBalance.Dumbbell(num)), 
			"Peanut Butter" => Bonus("Stamina efficiency", ArtifactBalance.Stamina(current), ArtifactBalance.Stamina(num)), 
			"Broccoli" => Percent("Healing factor", ArtifactBalance.Healing(current), ArtifactBalance.Healing(num)), 
			"Dracula" => $"+1 max HP per kill · cap {current * 25} → {num * 25}", 
			"Janniks Frog" => $"Extra jumps: {Mathf.Min(3, current)} → {Mathf.Min(3, num)} (cap 3)", 
			"Berserk" => Bonus("Damage at 1 HP", ArtifactBalance.Berserk(current, 1f), ArtifactBalance.Berserk(num, 1f)), 
			"Crimson Dagger" => Percent("Lifesteal", ArtifactBalance.Lifesteal(current), ArtifactBalance.Lifesteal(num)), 
			"Horseshoe" => Percent("Critical chance", ArtifactBalance.Crit(current), ArtifactBalance.Crit(num)), 
			"Orange Juice" => Bonus("Attack speed", ArtifactBalance.AttackSpeed(current), ArtifactBalance.AttackSpeed(num)), 
			"Sneaker" => Bonus("Move speed", ArtifactBalance.Speed(current), ArtifactBalance.Speed(num)), 
			"Piggybank" => Bonus("Bonus loot", ArtifactBalance.Loot(current), ArtifactBalance.Loot(num)), 
			"Checkered Shirt" => Bonus("Resource yield", ArtifactBalance.Resource(current), ArtifactBalance.Resource(num)), 
			"Spooo Bean" => Percent("Hunger drain reduction", 1f - ArtifactBalance.Hunger(current), 1f - ArtifactBalance.Hunger(num)), 
			"Juice" => Bonus("Post-kill speed", ArtifactBalance.Juice(current), ArtifactBalance.Juice(num)), 
			"Robin Hood Hat" => Bonus("Ranged damage", ArtifactBalance.Robin(current), ArtifactBalance.Robin(num)), 
			"Jetpack" => Bonus("Jump height", ArtifactBalance.Jump(current), ArtifactBalance.Jump(num)), 
			"Wings of Glory" => Bonus("Falling attack damage", ArtifactBalance.Wings(current), ArtifactBalance.Wings(num)), 
			"Bulldozer" => Percent("Knockback chance", ArtifactBalance.KnockbackChance(current), ArtifactBalance.KnockbackChance(num)), 
			"Adrenaline" => Bonus("Low-HP speed", ArtifactBalance.Adrenaline(current), ArtifactBalance.Adrenaline(num)), 
			"Enforcer" => Bonus("Damage at full momentum", ArtifactBalance.Enforcer(current, 22f), ArtifactBalance.Enforcer(num, 22f)), 
			"Danis Milk" => Value("Defense", ArtifactBalance.Defense(current), ArtifactBalance.Defense(num)), 
			"Sniper Scope" => Percent("Snipe chance", ArtifactBalance.SniperChance(current), ArtifactBalance.SniperChance(num)) + "\n" + Value("Snipe damage", ArtifactBalance.SniperDamage(current), ArtifactBalance.SniperDamage(num), "x"), 
			"Knuts Hammer" => Percent("Lightning chance", ArtifactBalance.LightningChance(current), ArtifactBalance.LightningChance(num)) + "\n" + Value("Lightning damage", ArtifactBalance.LightningDamage(current), ArtifactBalance.LightningDamage(num), "x"), 
			_ => $"Effect stack {current} → {num}", 
		};
	}

	private static string Bonus(string label, float before, float after)
	{
		return $"{label}: +{Mathf.Max(0f, before - 1f) * 100f:0.#}% → +{Mathf.Max(0f, after - 1f) * 100f:0.#}%";
	}

	private static string Percent(string label, float before, float after)
	{
		return $"{label}: {before * 100f:0.#}% → {after * 100f:0.#}%";
	}

	private static string Value(string label, float before, float after, string suffix = "")
	{
		return $"{label}: {before:0.##}{suffix} → {after:0.##}{suffix}";
	}
}
[HarmonyPatch(typeof(LootContainerInteract), "ServerExecute")]
internal static class ThreeChoiceArtifactServerPatch
{
	private static bool Prefix(LootContainerInteract __instance, int fromClient)
	{
		if (!Plugin.Settings.EnableArtifactChoices.Value || !LocalClient.serverOwner)
		{
			return true;
		}
		return !ArtifactChoiceService.RegisterServerOffer(__instance, fromClient);
	}
}
[HarmonyPatch(typeof(LootContainerInteract), "LocalExecute")]
internal static class ThreeChoiceArtifactUiPatch
{
	private static void Postfix(LootContainerInteract __instance)
	{
		ArtifactChoiceOverlay.Show(__instance);
	}
}
[HarmonyPatch(typeof(Server), "InitializeServerPackets")]
internal static class ArtifactChoicePacketRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (Server.PacketHandlers != null)
		{
			Server.PacketHandlers[240] = new PacketHandler(ArtifactChoiceService.HandleChoicePacket);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class ResetArtifactOffersPatch
{
	private static void Prefix()
	{
		ArtifactChoiceService.Reset();
	}
}
[HarmonyPatch(typeof(ServerHandle), "DisconnectPlayer")]
internal static class RemoveDisconnectedArtifactOffersPatch
{
	private static void Prefix(int fromClient)
	{
		ArtifactChoiceService.ForgetPlayer(fromClient);
	}
}
internal static class BalanceCurves
{
	internal static float EnemyHealth(Difficulty difficulty, int day)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		day = Mathf.Max(0, day);
		if (day > 20)
		{
			return EnemyHealthBeforeSoftCap(difficulty, 20) * (1f + PostTwentyGrowth(difficulty) * (float)(day - 20));
		}
		return EnemyHealthBeforeSoftCap(difficulty, day);
	}

	internal static float EnemyDamage(Difficulty difficulty, int day)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		day = Mathf.Max(0, day);
		if (day > 20)
		{
			return EnemyDamageBeforeSoftCap(difficulty, 20) * (1f + PostTwentyGrowth(difficulty) * (float)(day - 20));
		}
		return EnemyDamageBeforeSoftCap(difficulty, day);
	}

	internal static float ChestPriceCap(Difficulty difficulty)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Invalid comparison between Unknown and I4
		if ((int)difficulty != 0)
		{
			if ((int)difficulty == 2)
			{
				return Plugin.Settings.GamerChestPriceCap.Value;
			}
			return Plugin.Settings.NormalChestPriceCap.Value;
		}
		return Plugin.Settings.EasyChestPriceCap.Value;
	}

	private static float EnemyHealthBeforeSoftCap(Difficulty difficulty, int day)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		float num = day;
		if ((int)difficulty != 0)
		{
			if ((int)difficulty == 2)
			{
				return 1.3f + 0.22f * num + 0.013f * num * num;
			}
			return 1.05f + 0.14f * num + 0.0048f * num * num;
		}
		return 0.9f + 0.1f * num + 0.0015f * num * num;
	}

	private static float EnemyDamageBeforeSoftCap(Difficulty difficulty, int day)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Invalid comparison between Unknown and I4
		float num = day;
		if ((int)difficulty != 0)
		{
			if ((int)difficulty == 2)
			{
				return 1.65f + 0.2f * num + 0.016f * num * num;
			}
			return 0.9f + 0.12f * num + 0.005f * num * num;
		}
		return 0.4f + 0.07f * num + 0.00075f * num * num;
	}

	private static float PostTwentyGrowth(Difficulty difficulty)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Invalid comparison between Unknown and I4
		if ((int)difficulty != 0)
		{
			if ((int)difficulty == 2)
			{
				return 0.035f;
			}
			return 0.025f;
		}
		return 0.015f;
	}
}
[HarmonyPatch(typeof(PlayerMovement), "Awake")]
internal static class PlayerMovementSpeedPatch
{
	private static readonly FieldInfo MoveSpeed = AccessTools.Field(typeof(PlayerMovement), "moveSpeed");

	private static readonly FieldInfo MaxWalkSpeed = AccessTools.Field(typeof(PlayerMovement), "maxWalkSpeed");

	private static readonly FieldInfo MaxRunSpeed = AccessTools.Field(typeof(PlayerMovement), "maxRunSpeed");

	private static readonly FieldInfo MaxSpeed = AccessTools.Field(typeof(PlayerMovement), "maxSpeed");

	private static readonly FieldInfo SwimSpeed = AccessTools.Field(typeof(PlayerMovement), "swimSpeed");

	private static void Postfix(PlayerMovement __instance)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			float multiplier = Mathf.Clamp(Plugin.Settings.PlayerMoveSpeedMultiplier.Value, 0.5f, 3f);
			Scale(__instance, MoveSpeed, multiplier);
			Scale(__instance, MaxWalkSpeed, multiplier);
			Scale(__instance, MaxRunSpeed, multiplier);
			Scale(__instance, MaxSpeed, multiplier);
			Scale(__instance, SwimSpeed, multiplier);
		}
	}

	private static void Scale(PlayerMovement instance, FieldInfo field, float multiplier)
	{
		if (field != null)
		{
			field.SetValue(instance, (float)field.GetValue(instance) * multiplier);
		}
	}
}
[HarmonyPatch(typeof(PlayerStatus), "Awake")]
internal static class StaminaEconomyPatch
{
	private static readonly FieldInfo DrainRate = AccessTools.Field(typeof(PlayerStatus), "staminaDrainRate");

	private static readonly FieldInfo JumpDrain = AccessTools.Field(typeof(PlayerStatus), "jumpDrain");

	private static readonly FieldInfo RegenRate = AccessTools.Field(typeof(PlayerStatus), "staminaRegenRate");

	private static readonly FieldInfo HungerDrainRate = AccessTools.Field(typeof(PlayerStatus), "hungerDrainRate");

	private static void Postfix(PlayerStatus __instance)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			float num = Mathf.Clamp(Plugin.Settings.StaminaDrainMultiplier.Value, 0f, 2f);
			if (DrainRate != null)
			{
				DrainRate.SetValue(__instance, (float)DrainRate.GetValue(__instance) * num);
			}
			if (JumpDrain != null)
			{
				JumpDrain.SetValue(__instance, (float)JumpDrain.GetValue(__instance) * Mathf.Clamp(Plugin.Settings.JumpStaminaMultiplier.Value, 0f, 2f));
			}
			if (RegenRate != null)
			{
				RegenRate.SetValue(__instance, (float)RegenRate.GetValue(__instance) * Mathf.Clamp(Plugin.Settings.StaminaRegenMultiplier.Value, 0.1f, 5f));
			}
			if (HungerDrainRate != null)
			{
				float num2 = Mathf.Clamp(Plugin.Settings.HungerDrainMultiplier.Value, 0f, 2f);
				HungerDrainRate.SetValue(__instance, (float)HungerDrainRate.GetValue(__instance) * num2);
			}
		}
	}
}
[HarmonyPatch(typeof(HitableResource), "Hit")]
internal static class ResourceDamagePatch
{
	private static bool Prefix(HitableResource __instance, ref int damage, int hitEffect, int hitWeaponType)
	{
		if (damage <= 0)
		{
			return true;
		}
		if (hitWeaponType != -1 && StructureUpgradeService.TryUseHammer(__instance))
		{
			return false;
		}
		switch (hitWeaponType)
		{
		case -1:
			if ((((Object)(object)__instance != (Object)null && ResourceManager.Instance?.builds != null && ResourceManager.Instance.builds.ContainsKey(((Hitable)__instance).GetId())) || ((Object)(object)__instance != (Object)null && ((Component)((Component)__instance).transform.root).CompareTag("Build"))) && hitEffect != 1)
			{
				damage = Mathf.Max(1, Mathf.RoundToInt((float)damage * Mathf.Clamp(Plugin.Settings.BuildDamageMultiplier.Value, 0.05f, 1f)));
			}
			return true;
		case 1:
			return true;
		default:
			damage = Mathf.Max(1, Mathf.RoundToInt((float)damage * Plugin.Settings.ResourceDamageMultiplier.Value));
			return true;
		}
	}
}
[HarmonyPatch(typeof(GameManager), "MobHpMultiplier")]
internal static class MobHealthCurvePatch
{
	private static void Postfix(GameManager __instance, ref float __result)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		if (Plugin.Settings.EnableDifficultyCurves.Value && GameManager.gameSettings != null)
		{
			__result = BalanceCurves.EnemyHealth(GameManager.gameSettings.difficulty, __instance.currentDay);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "MobDamageMultiplier")]
internal static class MobDamageCurvePatch
{
	private static void Postfix(GameManager __instance, ref float __result)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		if (Plugin.Settings.EnableDifficultyCurves.Value && GameManager.gameSettings != null)
		{
			__result = BalanceCurves.EnemyDamage(GameManager.gameSettings.difficulty, __instance.currentDay);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "ChestPriceMultiplier")]
internal static class ChestPriceCapPatch
{
	private static void Postfix(ref float __result)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		if (Plugin.Settings.EnableDifficultyCurves.Value && GameManager.gameSettings != null)
		{
			__result = Mathf.Min(__result, BalanceCurves.ChestPriceCap(GameManager.gameSettings.difficulty));
		}
	}
}
[HarmonyPatch(typeof(GameSettings), "DayLength")]
internal static class DayLengthPatch
{
	private static void Postfix(GameSettings __instance, ref int __result)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: 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_001e: Invalid comparison between Unknown and I4
		if (!Plugin.Settings.EnableDifficultyCurves.Value)
		{
			return;
		}
		Difficulty difficulty = __instance.difficulty;
		if ((int)difficulty != 0)
		{
			if ((int)difficulty == 2)
			{
				__result = Mathf.RoundToInt((float)Plugin.Settings.GamerDayLength.Value * 1.3f);
			}
			else
			{
				__result = Mathf.RoundToInt((float)Plugin.Settings.NormalDayLength.Value * 1.3f);
			}
		}
		else
		{
			__result = Mathf.RoundToInt((float)Plugin.Settings.EasyDayLength.Value * 1.3f);
		}
	}
}
[HarmonyPatch(typeof(ItemManager), "InitAllItems")]
internal static class ItemEconomyPatch
{
	private static readonly HashSet<int> PatchedItems = new HashSet<int>();

	private static readonly HashSet<int> PatchedFuels = new HashSet<int>();

	private static void Postfix(ItemManager __instance)
	{
		//IL_0045: 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_007b: Invalid comparison between Unknown and I4
		if (__instance.allScriptableItems == null)
		{
			return;
		}
		InventoryItem[] allScriptableItems = __instance.allScriptableItems;
		foreach (InventoryItem val in allScriptableItems)
		{
			if (!((Object)(object)val == (Object)null) && PatchedItems.Add(((Object)val).GetInstanceID()))
			{
				if (val.stackable && (int)val.type == 0)
				{
					val.max = Mathf.Max(val.max, Plugin.Settings.MaterialStackSize.Value);
				}
				if (val.stackable && (int)val.tag == 8)
				{
					val.max = Mathf.Max(val.max, Plugin.Settings.ArrowStackSize.Value);
				}
				if (val.processable && val.processTime > 0f)
				{
					val.processTime = Mathf.Max(0.1f, val.processTime * Plugin.Settings.SmeltTimeMultiplier.Value);
				}
				if ((Object)(object)val.fuel != (Object)null && PatchedFuels.Add(((Object)val.fuel).GetInstanceID()))
				{
					val.fuel.maxUses = Mathf.Max(1, Mathf.RoundToInt((float)val.fuel.maxUses * Plugin.Settings.FuelUseMultiplier.Value));
				}
			}
		}
		Plugin.Log.LogInfo((object)"Applied stack, smelting, and fuel economy changes.");
	}
}
internal static class BedRegistry
{
	private const string AssetName = "MuckReplayable_Bed";

	private static Mesh mesh;

	internal static InventoryItem Item { get; private set; }

	internal static void Install(ItemManager manager)
	{
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Expected O, but got Unknown
		//IL_0265: Unknown result type (might be due to invalid IL or missing references)
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_027f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0240: Unknown result type (might be due to invalid IL or missing references)
		if (manager?.allItems == null || manager.allScriptableItems == null)
		{
			return;
		}
		Item = ((IEnumerable<InventoryItem>)manager.allItems.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem value) => (Object)(object)value != (Object)null && ((Object)value).name == "MuckReplayable_Bed"));
		if ((Object)(object)Item != (Object)null)
		{
			return;
		}
		InventoryItem val = ((IEnumerable<InventoryItem>)manager.allItems.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Wood Floor"));
		InventoryItem val2 = ((IEnumerable<InventoryItem>)manager.allItems.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Wood"));
		InventoryItem val3 = ((IEnumerable<InventoryItem>)manager.allItems.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Workbench"));
		if ((Object)(object)val?.prefab == (Object)null || (Object)(object)val.material == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
		{
			Plugin.Log.LogWarning((object)"Bed registration skipped because a vanilla source asset was unavailable.");
			return;
		}
		mesh = (((Object)(object)mesh != (Object)null) ? mesh : CreateBedMesh());
		InventoryItem val4 = ScriptableObject.CreateInstance<InventoryItem>();
		((Object)val4).name = "MuckReplayable_Bed";
		val4.id = manager.allItems.Keys.Max() + 1;
		val4.name = "Bed";
		val4.description = "Sleep at night. When every living player is in a bed, night passes seven times faster.";
		val4.type = (ItemType)0;
		val4.tag = (ItemTag)0;
		val4.tier = 1;
		val4.stackable = true;
		val4.max = 20;
		val4.amount = 1;
		val4.craftable = true;
		val4.craftAmount = 1;
		val4.stationRequirement = val3;
		val4.requirements = (CraftRequirement[])(object)new CraftRequirement[1]
		{
			new CraftRequirement
			{
				item = val2,
				amount = 15
			}
		};
		val4.mesh = mesh;
		val4.material = Object.Instantiate<Material>(val.material);
		((Object)val4.material).name = "Muck Replayable Bed Material";
		if (val4.material.HasProperty("_Color"))
		{
			val4.material.color = new Color(0.63f, 0.25f, 0.18f);
		}
		val4.sprite = CreateIcon();
		val4.rotationOffset = new Vector3(12f, 35f, -8f);
		val4.positionOffset = new Vector3(-0.05f, -0.34f, 0.48f);
		val4.scale = 0.32f;
		val4.buildable = true;
		val4.grid = true;
		val4.buildRotation = val.buildRotation;
		val4.prefab = CreatePrefab(val.prefab, manager, val4.material);
		val4.attackTypes = Array.Empty<Weakness>();
		Object.DontDestroyOnLoad((Object)(object)val4);
		Object.DontDestroyOnLoad((Object)(object)val4.material);
		manager.allItems[val4.id] = val4;
		manager.allScriptableItems = manager.allScriptableItems.Concat((IEnumerable<InventoryItem>)(object)new InventoryItem[1] { val4 }).ToArray();
		Item = val4;
		Plugin.Log.LogInfo((object)$"Registered craftable Bed (item ID {val4.id}).");
	}

	internal static void InjectCrafting(CraftingUI crafting)
	{
		if ((Object)(object)Item == (Object)null || crafting?.tabs == null || ((object)OtherInput.Instance?.workbench != crafting && !crafting.tabs.Any((Tab tab) => (tab?.items ?? Array.Empty<InventoryItem>()).Any((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Wood Axe"))))
		{
			return;
		}
		for (int num = 0; num < crafting.tabs.Length; num++)
		{
			InventoryItem[] array = crafting.tabs[num]?.items ?? Array.Empty<InventoryItem>();
			if (array.Any((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Wood Floor") && array.Any((InventoryItem value) => (Object)(object)value != (Object)null && (value.name == "Wood Wall" || value.name == "Workbench")))
			{
				crafting.tabs[num].items = (from value in array.Concat((IEnumerable<InventoryItem>)(object)new InventoryItem[1] { Item })
					where (Object)(object)value != (Object)null
					group value by value.id into @group
					select @group.First()).ToArray();
				return;
			}
		}
		if (crafting.tabs.Length != 0)
		{
			int num2 = crafting.tabs.Length - 1;
			InventoryItem[] first = crafting.tabs[num2]?.items ?? Array.Empty<InventoryItem>();
			crafting.tabs[num2].items = (from value in first.Concat((IEnumerable<InventoryItem>)(object)new InventoryItem[1] { Item })
				where (Object)(object)value != (Object)null
				group value by value.id into @group
				select @group.First()).ToArray();
		}
	}

	internal static bool IsCraftingReady()
	{
		if ((Object)(object)Item != (Object)null)
		{
			return Resources.FindObjectsOfTypeAll<CraftingUI>().Any((CraftingUI crafting) => (crafting?.tabs ?? Array.Empty<Tab>()).Any(delegate(Tab tab)
			{
				InventoryItem[] source = tab?.items ?? Array.Empty<InventoryItem>();
				return source.Any((InventoryItem value) => (Object)(object)value != (Object)null && value.id == Item.id) && source.Any((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Wood Floor");
			}));
		}
		return false;
	}

	private static GameObject CreatePrefab(GameObject source, ItemManager manager, Material material)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: 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_0099: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Object.Instantiate<GameObject>(source);
		((Object)val).name = "Muck Replayable Bed Prefab";
		Renderer[] componentsInChildren = val.GetComponentsInChildren<Renderer>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			componentsInChildren[i].enabled = false;
		}
		GameObject val2 = new GameObject("Bed Visual");
		val2.transform.SetParent(val.transform, false);
		val2.AddComponent<MeshFilter>().sharedMesh = mesh;
		((Renderer)val2.AddComponent<MeshRenderer>()).sharedMaterial = material;
		GameObject val3 = new GameObject("Bed Interaction");
		val3.transform.SetParent(val.transform, false);
		val3.transform.localPosition = new Vector3(0f, 0.55f, 0f);
		BoxCollider obj = val3.AddComponent<BoxCollider>();
		((Collider)obj).isTrigger = true;
		obj.size = new Vector3(1.8f, 1.2f, 3.2f);
		InventoryItem? obj2 = ((IEnumerable<InventoryItem>)manager.allItems.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem value) => (Object)(object)value != (Object)null && value.name == "Chest"));
		object obj3;
		if (obj2 == null)
		{
			obj3 = null;
		}
		else
		{
			GameObject prefab = obj2.prefab;
			obj3 = ((prefab != null) ? prefab.GetComponentInChildren<ChestInteract>(true) : null);
		}
		ChestInteract val4 = (ChestInteract)obj3;
		val3.layer = (((Object)(object)val4 != (Object)null) ? ((Component)val4).gameObject.layer : val.layer);
		val3.AddComponent<BedInteract>();
		val.transform.position = Vector3.down * 10000f;
		val.SetActive(false);
		Object.DontDestroyOnLoad((Object)(object)val);
		return val;
	}

	private static Mesh CreateBedMesh()
	{
		//IL_001d: 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_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Expected O, but got Unknown
		//IL_0103: Expected O, but got Unknown
		List<Vector3> list = new List<Vector3>();
		List<int> list2 = new List<int>();
		AddBox(list, list2, new Vector3(0f, 0.35f, 0f), new Vector3(1.8f, 0.35f, 3.2f));
		AddBox(list, list2, new Vector3(0f, 0.72f, -1.32f), new Vector3(1.9f, 1.15f, 0.22f));
		AddBox(list, list2, new Vector3(-0.72f, 0.12f, 0f), new Vector3(0.18f, 0.65f, 3.1f));
		AddBox(list, list2, new Vector3(0.72f, 0.12f, 0f), new Vector3(0.18f, 0.65f, 3.1f));
		Mesh val = new Mesh
		{
			name = "Muck Replayable Bed Mesh",
			vertices = list.ToArray(),
			triangles = list2.ToArray()
		};
		val.RecalculateNormals();
		val.RecalculateBounds();
		Object.DontDestroyOnLoad((Object)val);
		return val;
	}

	private static void AddBox(List<Vector3> vertices, List<int> triangles, Vector3 center, Vector3 size)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: 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_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: 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_00bf: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: 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_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: 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_010b: 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_0117: 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_0122: 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_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_013c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0142: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		int start = vertices.Count;
		Vector3 val = size * 0.5f;
		vertices.AddRange((IEnumerable<Vector3>)(object)new Vector3[8]
		{
			center + new Vector3(0f - val.x, 0f - val.y, 0f - val.z),
			center + new Vector3(val.x, 0f - val.y, 0f - val.z),
			center + new Vector3(val.x, val.y, 0f - val.z),
			center + new Vector3(0f - val.x, val.y, 0f - val.z),
			center + new Vector3(0f - val.x, 0f - val.y, val.z),
			center + new Vector3(val.x, 0f - val.y, val.z),
			center + new Vector3(val.x, val.y, val.z),
			center + new Vector3(0f - val.x, val.y, val.z)
		});
		int[] source = new int[36]
		{
			0, 2, 1, 0, 3, 2, 4, 5, 6, 4,
			6, 7, 0, 1, 5, 0, 5, 4, 3, 7,
			6, 3, 6, 2, 1, 2, 6, 1, 6, 5,
			0, 4, 7, 0, 7, 3
		};
		triangles.AddRange(source.Select((int value) => start + value));
	}

	private static Sprite CreateIcon()
	{
		//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_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Expected O, but got Unknown
		//IL_001e: 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_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: 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_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)
		Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
		{
			name = "Bed Icon",
			filterMode = (FilterMode)0
		};
		Color[] array = Enumerable.Repeat<Color>(Color.clear, 4096).ToArray();
		for (int i = 16; i < 46; i++)
		{
			for (int j = 8; j < 56; j++)
			{
				array[i * 64 + j] = ((i > 38) ? new Color(0.34f, 0.18f, 0.09f) : new Color(0.75f, 0.24f, 0.18f));
			}
		}
		for (int k = 38; k < 50; k++)
		{
			for (int l = 8; l < 20; l++)
			{
				array[k * 64 + l] = new Color(0.92f, 0.83f, 0.65f);
			}
		}
		val.SetPixels(array);
		val.Apply(false, true);
		Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 64f);
		Object.DontDestroyOnLoad((Object)(object)val);
		Object.DontDestroyOnLoad((Object)(object)obj);
		return obj;
	}
}
internal sealed class BedInteract : MonoBehaviour, Interactable
{
	public void Interact()
	{
		HitableResource componentInChildren = ((Component)((Component)this).transform.root).GetComponentInChildren<HitableResource>();
		if ((Object)(object)componentInChildren != (Object)null)
		{
			SleepService.RequestLocal(((Hitable)componentInChildren).GetId());
		}
	}

	public void LocalExecute()
	{
	}

	public void AllExecute()
	{
	}

	public void ServerExecute(int fromClient = -1)
	{
	}

	public void RemoveObject()
	{
	}

	public string GetName()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		if (!SleepService.IsNight)
		{
			return "Bed\n<size=50%>(Can only sleep at night)";
		}
		return $"Sleep\n<size=50%>(Press \"{InputManager.interact}\")";
	}

	public bool IsStarted()
	{
		return false;
	}
}
internal static class SleepService
{
	internal const int RequestPacketId = 248;

	internal const int SyncPacketId = 249;

	private static readonly HashSet<int> Sleeping = new HashSet<int>();

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

	private static readonly MethodInfo ClientSendTcp = AccessTools.Method(typeof(ClientSend), "SendTCPData", new Type[1] { typeof(Packet) }, (Type[])null);

	private static readonly MethodInfo ServerSendAll = AccessTools.Method(typeof(ServerSend), "SendTCPDataToAll", new Type[1] { typeof(Packet) }, (Type[])null);

	internal static bool IsNight
	{
		get
		{
			if (DayCycle.time > 0.5f)
			{
				return DayCycle.time < 0.99f;
			}
			return false;
		}
	}

	internal static bool LocalSleeping
	{
		get
		{
			if ((Object)(object)LocalClient.instance != (Object)null)
			{
				return Sleeping.Contains(LocalClient.instance.myId);
			}
			return false;
		}
	}

	internal static bool FastNight
	{
		get
		{
			if (!IsNight || GameManager.players == null)
			{
				return false;
			}
			int[] array = (from player in GameManager.players.Values
				where (Object)(object)player != (Object)null && !player.dead && !player.disconnected
				select player.id).ToArray();
			if (array.Length != 0)
			{
				return array.All(Sleeping.Contains);
			}
			return false;
		}
	}

	internal static void Reset()
	{
		Sleeping.Clear();
		Beds.Clear();
	}

	internal static void RequestLocal(int bedId)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Expected O, but got Unknown
		if ((Object)(object)LocalClient.instance == (Object)null || (Object)(object)GameManager.instance == (Object)null)
		{
			return;
		}
		bool flag = !LocalSleeping;
		if (flag && !IsNight)
		{
			ReforgedRuntime.Instance?.Notify("Beds can only be used at night.", 3f);
			return;
		}
		if (LocalClient.serverOwner)
		{
			SetServer(LocalClient.instance.myId, bedId, flag);
			return;
		}
		Packet val = new Packet(248);
		try
		{
			val.Write(bedId);
			val.Write(flag);
			ClientSendTcp?.Invoke(null, new object[1] { val });
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	internal static void ReceiveRequest(int fromClient, Packet packet)
	{
		try
		{
			SetServer(fromClient, packet.ReadInt(true), packet.ReadBool(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected bed request: " + ex.Message));
		}
	}

	private static void SetServer(int playerId, int bedId, bool sleep)
	{
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
		if (sleep)
		{
			if (!IsNight || !GameManager.players.TryGetValue(playerId, out var value) || (Object)(object)value == (Object)null || value.dead || ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.TryGetValue(bedId, out var value2) || (Object)(object)value2.GetComponentInChildren<BedInteract>() == (Object)null || Beds.Any((KeyValuePair<int, int> pair) => pair.Key != playerId && pair.Value == bedId) || (Server.clients.TryGetValue(playerId, out var value3) && value3?.player != null && Vector3.Distance(value3.player.pos, value2.transform.position) > 8f))
			{
				return;
			}
			Sleeping.Add(playerId);
			Beds[playerId] = bedId;
		}
		else
		{
			Sleeping.Remove(playerId);
			Beds.Remove(playerId);
		}
		Broadcast(playerId, bedId, sleep);
	}

	private static void Broadcast(int playerId, int bedId, bool sleeping)
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Expected O, but got Unknown
		Packet val = new Packet(249);
		try
		{
			val.Write(playerId);
			val.Write(bedId);
			val.Write(sleeping);
			ServerSendAll?.Invoke(null, new object[1] { val });
			ApplyState(playerId, bedId, sleeping);
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	internal static void ReceiveSync(Packet packet)
	{
		try
		{
			ApplyState(packet.ReadInt(true), packet.ReadInt(true), packet.ReadBool(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected bed state: " + ex.Message));
		}
	}

	private static void ApplyState(int playerId, int bedId, bool sleeping)
	{
		//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_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: 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)
		if (sleeping)
		{
			Sleeping.Add(playerId);
			Beds[playerId] = bedId;
		}
		else
		{
			Sleeping.Remove(playerId);
			Beds.Remove(playerId);
		}
		if (sleeping && (Object)(object)LocalClient.instance != (Object)null && playerId == LocalClient.instance.myId && ResourceManager.Instance?.list != null && ResourceManager.Instance.list.TryGetValue(bedId, out var value) && (Object)(object)PlayerMovement.Instance != (Object)null)
		{
			((Component)PlayerMovement.Instance).transform.position = value.transform.position + Vector3.up * 1.05f;
			PlayerMovement.Instance.GetRb().velocity = Vector3.zero;
		}
	}

	internal static void WakeLocal()
	{
		if (LocalSleeping && Beds.TryGetValue(LocalClient.instance.myId, out var value))
		{
			RequestLocal(value);
		}
	}

	internal static void ValidateServerState()
	{
		if (!LocalClient.serverOwner)
		{
			return;
		}
		int[] array = Sleeping.ToArray();
		foreach (int num in array)
		{
			if (!IsNight || !GameManager.players.TryGetValue(num, out var value) || !((Object)(object)value != (Object)null) || value.dead || !Beds.TryGetValue(num, out var value2) || ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.ContainsKey(value2))
			{
				SetServer(num, Beds.TryGetValue(num, out var value3) ? value3 : (-1), sleep: false);
			}
		}
	}

	internal static void ApplyRemotePose()
	{
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		if (GameManager.players == null)
		{
			return;
		}
		foreach (PlayerManager value in GameManager.players.Values)
		{
			if (!((Object)(object)value?.onlinePlayer?.upperBody == (Object)null))
			{
				Vector3 localEulerAngles = value.onlinePlayer.upperBody.localEulerAngles;
				localEulerAngles.z = (Sleeping.Contains(value.id) ? 88f : 0f);
				value.onlinePlayer.upperBody.localEulerAngles = localEulerAngles;
			}
		}
	}
}
[DefaultExecutionOrder(11000)]
internal sealed class SleepController : MonoBehaviour
{
	private bool inputSuppressed;

	private float nextValidation;

	private void Update()
	{
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: 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_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		if (Time.unscaledTime >= nextValidation)
		{
			nextValidation = Time.unscaledTime + 0.25f;
			SleepService.ValidateServerState();
		}
		bool localSleeping = SleepService.LocalSleeping;
		if (localSleeping && !inputSuppressed && (Object)(object)PlayerInput.Instance != (Object)null)
		{
			inputSuppressed = true;
			PlayerInput.Instance.active = false;
			ReforgedRuntime.Instance?.Notify("Sleeping… everyone asleep makes night pass ×7. Press E or a movement key to wake.", 5f);
		}
		if (localSleeping && (Input.GetKeyDown(InputManager.interact) || Input.GetKeyDown(InputManager.forward) || Input.GetKeyDown(InputManager.backwards) || Input.GetKeyDown(InputManager.left) || Input.GetKeyDown(InputManager.right) || Input.GetKeyDown(InputManager.jump)))
		{
			SleepService.WakeLocal();
		}
		if (!localSleeping && inputSuppressed)
		{
			inputSuppressed = false;
			if ((Object)(object)PlayerInput.Instance != (Object)null)
			{
				PlayerInput.Instance.active = true;
			}
		}
		SleepService.ApplyRemotePose();
	}

	private void LateUpdate()
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		if (SleepService.LocalSleeping && !((Object)(object)MoveCamera.Instance == (Object)null))
		{
			((Component)MoveCamera.Instance).transform.position = ((Component)PlayerMovement.Instance).transform.position + Vector3.up * 0.65f;
			Transform transform = ((Component)MoveCamera.Instance).transform;
			transform.rotation *= Quaternion.Euler(0f, 0f, 78f);
		}
	}
}
[HarmonyPatch(typeof(Server), "InitializeServerPackets")]
internal static class BedServerPacketPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (Server.PacketHandlers != null)
		{
			Server.PacketHandlers[248] = new PacketHandler(SleepService.ReceiveRequest);
		}
	}
}
[HarmonyPatch(typeof(LocalClient), "InitializeClientData")]
internal static class BedClientPacketPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (LocalClient.packetHandlers != null)
		{
			LocalClient.packetHandlers[249] = new PacketHandler(SleepService.ReceiveSync);
		}
	}
}
[HarmonyPatch(typeof(BuildManager), "BuildItem")]
internal static class ActivateBedBuildPatch
{
	private static void Postfix(int itemID, GameObject __result)
	{
		if ((Object)(object)BedRegistry.Item != (Object)null && itemID == BedRegistry.Item.id && (Object)(object)__result != (Object)null)
		{
			__result.SetActive(true);
		}
	}
}
[HarmonyPatch(typeof(DayCycle), "Update")]
internal static class SleepingNightSpeedPatch
{
	private static void Prefix(DayCycle __instance, out float __state)
	{
		__state = __instance.timeSpeed;
		if (SleepService.FastNight)
		{
			__instance.timeSpeed *= 7f;
		}
	}

	private static void Postfix(DayCycle __instance, float __state)
	{
		__instance.timeSpeed = __state;
	}
}
[HarmonyPatch(typeof(PlayerStatus), "HandleDamage")]
internal static class DamageWakesSleepingPlayerPatch
{
	private static void Postfix()
	{
		SleepService.WakeLocal();
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class SleepResetPatch
{
	private static void Prefix()
	{
		SleepService.Reset();
	}
}
[HarmonyPatch(typeof(UseInventory), "Use")]
internal static class AttackStaminaPatch
{
	private static readonly FieldInfo CurrentItem = AccessTools.Field(typeof(UseInventory), "currentItem");

	private static readonly FieldInfo JumpDrain = AccessTools.Field(typeof(PlayerStatus), "jumpDrain");

	private static void Prefix(UseInventory __instance)
	{
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Invalid comparison between Unknown and I4
		if (ShieldNetwork.LocalBlocking || (Object)(object)__instance == (Object)null || (Object)(object)PlayerStatus.Instance == (Object)null || CurrentItem == null || JumpDrain == null)
		{
			return;
		}
		object? value = CurrentItem.GetValue(__instance);
		InventoryItem val = (InventoryItem)((value is InventoryItem) ? value : null);
		if ((Object)(object)val == (Object)null || (int)val.tag == 2 || (Object)(object)OtherInput.Instance == (Object)null || OtherInput.Instance.IsAnyMenuOpen())
		{
			return;
		}
		Animator animator = __instance.animator;
		if (!((Object)(object)animator == (Object)null) && animator.GetCurrentAnimatorClipInfo(0).Length != 0)
		{
			string name = ((Object)((AnimatorClipInfo)(ref animator.GetCurrentAnimatorClipInfo(0)[0])).clip).name;
			if (!name.Contains("Attack") && !name.Contains("Equip") && !name.Contains("Eat") && !name.Contains("Charge") && !name.Contains("Shoot"))
			{
				float num = Mathf.Max(0f, (float)JumpDrain.GetValue(PlayerStatus.Instance));
				float num2 = (((Object)(object)PowerupInventory.Instance != (Object)null) ? Mathf.Max(0.1f, PowerupInventory.Instance.GetStaminaMultiplier((int[])null)) : 1f);
				PlayerStatus.Instance.stamina = Mathf.Max(0f, PlayerStatus.Instance.stamina - num / num2);
				StaminaRegenerationGate.MarkSpent();
			}
		}
	}
}
[HarmonyPatch(typeof(DayCycle), "Awake")]
internal static class NightLengthPatch
{
	private static void Postfix(DayCycle __instance)
	{
		if ((Object)(object)__instance != (Object)null)
		{
			__instance.nightDuration *= 0.61538464f;
		}
	}
}
[HarmonyPatch(typeof(Mob), "SetSpeed")]
internal static class FinalBossSpeedPatch
{
	private static void Prefix(Mob __instance, ref float multiplier)
	{
		if (__instance is BobMob)
		{
			multiplier *= 1.2f;
		}
	}
}
[HarmonyPatch(typeof(MobServerDragon), "FindNodes")]
internal static class FinalBossTravelPatch
{
	private static void Postfix(ref List<Vector3> ___nodes)
	{
		//IL_001c: 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_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_0035: 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_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0059: 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_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		if (___nodes != null && !((Object)(object)Boat.Instance == (Object)null))
		{
			Vector3 val = Boat.Instance.rbTransform.position + Vector3.up * 90f;
			for (int i = 0; i < ___nodes.Count; i++)
			{
				Vector3 val2 = ___nodes[i] - val;
				___nodes[i] = val + new Vector3(val2.x * 1.85f, val2.y * 1.2f, val2.z * 1.85f);
			}
		}
	}
}
[HarmonyPatch(typeof(LaserTest), "DamageEffect")]
internal static class GuardianLaserDamagePatch
{
	private static bool Prefix(LaserTest __instance)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance?.damageFx == (Object)null || (Object)(object)__instance.hitParticles == (Object)null)
		{
			return false;
		}
		HitboxDamage[] componentsInChildren = Object.Instantiate<GameObject>(__instance.damageFx, __instance.hitParticles.position, __instance.hitParticles.rotation).GetComponentsInChildren<HitboxDamage>(true);
		foreach (HitboxDamage val in componentsInChildren)
		{
			val.baseDamage = Mathf.Max(1, Mathf.RoundToInt((float)val.baseDamage * 0.5f));
		}
		return false;
	}
}
[HarmonyPatch(typeof(GuardianSpikes), "Awake")]
internal static class GuardianSpikeWarningPatch
{
	private static void Postfix(ref EnemyAttackIndicator ___indicator)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)___indicator != (Object)null)
		{
			Transform transform = ((Component)___indicator).transform;
			transform.localScale *= 0.5f;
		}
	}
}
[HarmonyPatch(typeof(GuardianSpikes), "SpawnAttack")]
internal static class GuardianSpikeRangePatch
{
	private static bool Prefix(GuardianSpikes __instance)
	{
		//IL_0043: 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_0064: 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)
		if ((Object)(object)__instance?.spikeAttack == (Object)null)
		{
			return false;
		}
		EnemyAttackIndicator value = Traverse.Create((object)__instance).Field("indicator").GetValue<EnemyAttackIndicator>();
		if ((Object)(object)value == (Object)null)
		{
			return false;
		}
		GameObject obj = Object.Instantiate<GameObject>(__instance.spikeAttack, ((Component)value).transform.position, __instance.spikeAttack.transform.rotation);
		Transform transform = obj.transform;
		transform.localScale *= 0.5f;
		HitboxDamage componentInChildren = obj.GetComponentInChildren<HitboxDamage>();
		if ((Object)(object)componentInChildren != (Object)null && (Object)(object)__instance.projectile != (Object)null)
		{
			componentInChildren.baseDamage = __instance.projectile.damage;
		}
		Object.Destroy((Object)(object)((Component)__instance).gameObject);
		return false;
	}
}
internal static class DetailedMapService
{
	private sealed class LandmarkCandidate
	{
		internal string Key;

		internal string Label;

		internal string MarkerName;

		internal Transform Transform;

		internal Texture2D Texture;

		internal Color Color;

		internal float Scale;

		internal float DiscoveryRadius;
	}

	private static readonly List<MapMarker> Landmarks = new List<MapMarker>();

	private static readonly Dictionary<string, LandmarkCandidate> Candidates = new Dictionary<string, LandmarkCandidate>();

	private static readonly HashSet<string> Discovered = new HashSet<string>(StringComparer.Ordinal);

	private static Map landmarkMap;

	private static Texture2D detailedTexture;

	private static Texture2D caveMarkerTexture;

	private static Texture2D shipMarkerTexture;

	private static Texture2D villageMarkerTexture;

	private static Texture2D traderMarkerTexture;

	private static float nextDiscoveryScan;

	private static float nextVillageScan;

	private static int knownVillageCount = -1;

	private static int stableVillageScans;

	internal static void ApplyDetailedTexture(Map map)
	{
		//IL_007b: 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_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Expected O, but got Unknown
		//IL_00c6: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_0225: Unknown result type (might be due to invalid IL or missing references)
		//IL_022a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0231: Unknown result type (might be due to invalid IL or missing references)
		//IL_0233: Unknown result type (might be due to invalid IL or missing references)
		//IL_0254: Unknown result type (might be due to invalid IL or missing references)
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0280: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02da: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)map == (Object)null || MapGenerator.Instance?.heightMap == null || (Object)(object)MapGenerator.Instance.textureData == (Object)null)
		{
			return;
		}
		try
		{
			int num = Mathf.Clamp(Plugin.Settings.DetailedMapResolution.Value, 512, 2048);
			float[,] heightMap = MapGenerator.Instance.heightMap;
			int length = heightMap.GetLength(0);
			int length2 = heightMap.GetLength(1);
			if (length < 2 || length2 < 2)
			{
				return;
			}
			Texture2D val = new Texture2D(num, num, (TextureFormat)4, true)
			{
				name = "Muck Replayable Detailed Map",
				filterMode = (FilterMode)2,
				wrapMode = (TextureWrapMode)1,
				anisoLevel = 4
			};
			Color[] array = (Color[])(object)new Color[num * num];
			float[] array2 = new float[array.Length];
			Vector3 val2 = new Vector3(-0.55f, 0.78f, 0.3f);
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / (float)(num - 1);
				float v = 1f - num2;
				for (int j = 0; j < num; j++)
				{
					float u = (float)j / (float)(num - 1);
					array2[i * num + j] = Sample(heightMap, length, length2, u, v);
				}
			}
			int num3 = Mathf.Max(1, Mathf.RoundToInt(((float)num - 1f) / ((float)length - 1f)));
			int num4 = Mathf.Max(1, Mathf.RoundToInt(((float)num - 1f) / ((float)length2 - 1f)));
			for (int k = 0; k < num; k++)
			{
				int num5 = Mathf.Max(0, k - num4);
				int num6 = Mathf.Min(num - 1, k + num4);
				for (int l = 0; l < num; l++)
				{
					int num7 = k * num + l;
					float num8 = array2[num7];
					Color val3 = TextureGenerator.GetColor(num8, MapGenerator.Instance.textureData);
					int num9 = Mathf.Max(0, l - num3);
					int num10 = Mathf.Min(num - 1, l + num3);
					float num11 = array2[k * num + num9];
					float num12 = array2[k * num + num10];
					float num13 = array2[num5 * num + l];
					float num14 = array2[num6 * num + l];
					val2 = new Vector3((num11 - num12) * 18f, 2f, (num13 - num14) * 18f);
					Vector3 normalized2 = ((Vector3)(ref val2)).normalized;
					float num15 = Mathf.Clamp(0.82f + Vector3.Dot(normalized2, normalized) * 0.24f, 0.68f, 1.14f);
					val3.r = Mathf.Clamp01(val3.r * num15);
					val3.g = Mathf.Clamp01(val3.g * num15);
					val3.b = Mathf.Clamp01(val3.b * num15);
					float num16 = Mathf.Abs(num12 - num11) + Mathf.Abs(num14 - num13);
					float num17 = Mathf.Abs(Mathf.Repeat(num8 * 28f, 1f) - 0.5f);
					if (num16 > 0.002f && num17 < 0.025f)
					{
						val3 = Color.Lerp(val3, Color.black, 0.12f);
					}
					array[num7] = val3;
				}
			}
			val.SetPixels(array);
			val.Apply(true, false);
			if ((Object)(object)map.mapTextureMaterial != (Object)null)
			{
				map.mapTextureMaterial.mainTexture = (Texture)(object)val;
			}
			if ((Object)(object)map.mapRender != (Object)null)
			{
				map.mapRender.texture = (Texture)(object)val;
				if ((Object)(object)map.mapTextureMaterial != (Object)null)
				{
					((Graphic)map.mapRender).material = map.mapTextureMaterial;
				}
			}
			if ((Object)(object)detailedTexture != (Object)null)
			{
				Object.Destroy((Object)(object)detailedTexture);
			}
			detailedTexture = val;
			Plugin.Log.LogInfo((object)$"Generated detailed {num}x{num} map from {length}x{length2} terrain data.");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Detailed map generation failed; keeping vanilla map: " + ex.Message));
		}
	}

	internal static void RefreshLandmarks()
	{
		//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_0232: Unknown result type (might be due to invalid IL or missing references)
		//IL_0237: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_048f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0494: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.ShowMapLandmarks.Value || (Object)(object)Map.Instance == (Object)null || (Object)(object)Map.Instance.mapMarkerPrefab == (Object)null)
		{
			return;
		}
		Map instance = Map.Instance;
		if ((Object)(object)landmarkMap != (Object)(object)instance)
		{
			Landmarks.Clear();
			landmarkMap = instance;
		}
		else
		{
			foreach (MapMarker landmark in Landmarks)
			{
				if (landmark != null && (Object)(object)landmark.marker != (Object)null && instance.mapMarkers.Contains(landmark))
				{
					instance.RemoveMarker(landmark);
				}
			}
			Landmarks.Clear();
		}
		EnsureMarkerTextures();
		Candidates.Clear();
		List<Transform> list = (from value in (from value in CaveNetwork.Entrances.Concat(from cave in Object.FindObjectsOfType<Cave>()
					where (Object)(object)cave != (Object)null
					select ((Component)cave).transform)
				where (Object)(object)value != (Object)null
				select value).Distinct()
			orderby value.position.x, value.position.z
			select value).ToList();
		for (int num = 0; num < list.Count; num++)
		{
			string text = PositionKey("cave", list[num].position);
			if (Discovered.Contains("cave:" + num))
			{
				Discovered.Add(text);
			}
			AddCandidate(new LandmarkCandidate
			{
				Key = text,
				Label = "Cave",
				MarkerName = "Muck Replayable Cave Marker",
				Transform = list[num],
				Texture = caveMarkerTexture,
				Color = new Color(0.45f, 0.88f, 1f, 1f),
				Scale = 0.72f,
				DiscoveryRadius = 72f
			});
		}
		List<Transform> list2 = FindVillages();
		RegisterVillageCandidates(list2);
		knownVillageCount = list2.Count;
		stableVillageScans = 0;
		List<Transform> list3 = (from @group in (from value in Object.FindObjectsOfType<TraderInteract>()
				where (Object)(object)value != (Object)null
				select ((Component)value).transform into value
				where (Object)(object)value != (Object)null
				select value).GroupBy((Func<Transform, Vector2Int>)((Transform value) => new Vector2Int(Mathf.RoundToInt(value.position.x / 5f), Mathf.RoundToInt(value.position.z / 5f))))
			select @group.First() into value
			orderby value.position.x, value.position.z
			select value).ToList();
		for (int num2 = 0; num2 < list3.Count; num2++)
		{
			AddCandidate(new LandmarkCandidate
			{
				Key = "trader:" + num2,
				Label = "Trader",
				MarkerName = "Muck Replayable Trader Marker",
				Transform = list3[num2],
				Texture = traderMarkerTexture,
				Color = new Color(0.38f, 1f, 0.62f, 1f),
				Scale = 0.66f,
				DiscoveryRadius = 82f
			});
		}
		if ((Object)(object)Boat.Instance != (Object)null)
		{
			AddCandidate(new LandmarkCandidate
			{
				Key = "ship",
				Label = "Ship",
				MarkerName = "Muck Replayable Ship Marker",
				Transform = ((Component)Boat.Instance).transform,
				Texture = shipMarkerTexture,
				Color = new Color(1f, 0.78f, 0.22f, 1f),
				Scale = 0.82f,
				DiscoveryRadius = 145f
			});
		}
		foreach (string item in Discovered)
		{
			AddMarkerFor(item);
		}
	}

	internal static void TickDiscovery()
	{
		//IL_00d6: 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_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.ShowMapLandmarks.Value || Time.unscaledTime < nextDiscoveryScan || (Object)(object)PlayerMovement.Instance == (Object)null || (Object)(object)Map.Instance == (Object)null)
		{
			return;
		}
		nextDiscoveryScan = Time.unscaledTime + 0.5f;
		if (Candidates.Count == 0 || (Object)(object)landmarkMap != (Object)(object)Map.Instance)
		{
			RefreshLandmarks();
		}
		if (Time.unscaledTime >= nextVillageScan)
		{
			nextVillageScan = Time.unscaledTime + 10f;
			List<Transform> list = FindVillages();
			if (list.Count != knownVillageCount)
			{
				knownVillageCount = list.Count;
				stableVillageScans = 0;
				RegisterVillageCandidates(list);
			}
			else if (++stableVillageScans >= 3)
			{
				nextVillageScan = float.PositiveInfinity;
			}
		}
		Vector3 position = ((Component)PlayerMovement.Instance).transform.position;
		foreach (LandmarkCandidate value in Candidates.Values)
		{
			if ((Object)(object)value.Transform == (Object)null || Discovered.Contains(value.Key))
			{
				continue;
			}
			Vector3 val = value.Transform.position - position;
			val.y = 0f;
			if (!(((Vector3)(ref val)).sqrMagnitude > value.DiscoveryRadius * value.DiscoveryRadius))
			{
				Discovered.Add(value.Key);
				AddMarkerFor(value.Key);
				string text = value.Label + " discovered — it is now marked on the map.";
				StatusMessage instance = StatusMessage.Instance;
				if ((Object)(object)instance != (Object)null && (Object)(object)instance.status != (Object)null && (Object)(object)instance.statusText != (Object)null && (Object)(object)instance.status.transform.parent != (Object)null)
				{
					instance.DisplayMessage(text);
				}
				Plugin.Log.LogInfo((object)$"Landmark discovered: {value.Key} at {value.Transform.position}");
			}
		}
	}

	internal static IEnumerable<string> GetDiscoveredKeys()
	{
		return Discovered.ToArray();
	}

	internal static void ImportDiscoveredKeys(IEnumerable<string> keys)
	{
		Discovered.Clear();
		if (keys != null)
		{
			foreach (string item in keys.Where((string value) => !string.IsNullOrWhiteSpace(value)))
			{
				Discovered.Add(item.Trim());
			}
		}
		RefreshLandmarks();
	}

	internal static void ResetLandmarks()
	{
		Landmarks.Clear();
		Candidates.Clear();
		Discovered.Clear();
		landmarkMap = null;
		nextDiscoveryScan = 0f;
		nextVillageScan = 0f;
		knownVillageCount = -1;
		stableVillageScans = 0;
		if ((Object)(object)detailedTexture != (Object)null)
		{
			Object.Destroy((Object)(object)detailedTexture);
			detailedTexture = null;
		}
	}

	private static float Sample(float[,] heightMap, int width, int height, float u, float v)
	{
		float num = Mathf.Clamp01(u) * (float)(width - 1);
		float num2 = Mathf.Clamp01(v) * (float)(height - 1);
		int num3 = Mathf.FloorToInt(num);
		int num4 = Mathf.FloorToInt(num2);
		int num5 = Mathf.Min(num3 + 1, width - 1);
		int num6 = Mathf.Min(num4 + 1, height - 1);
		float num7 = num - (float)num3;
		float num8 = num2 - (float)num4;
		return Mathf.Lerp(Mathf.Lerp(heightMap[num3, num4], heightMap[num5, num4], num7), Mathf.Lerp(heightMap[num3, num6], heightMap[num5, num6], num7), num8);
	}

	private static void EnsureMarkerTextures()
	{
		if ((Object)(object)caveMarkerTexture == (Object)null)
		{
			caveMarkerTexture = CreateMarkerTexture("Muck Replayable Cave Icon", (float x, float y) => Mathf.Abs(x) + Mathf.Abs(y) <= 0.78f);
		}
		if ((Object)(object)shipMarkerTexture == (Object)null)
		{
			shipMarkerTexture = CreateMarkerTexture("Muck Replayable Ship Icon", (float x, float y) => y >= -0.65f && y <= 0.72f && Mathf.Abs(x) <= 0.75f - y * 0.45f);
		}
		if ((Object)(object)villageMarkerTexture == (Object)null)
		{
			villageMarkerTexture = CreateMarkerTexture("Muck Replayable Village Icon", (float x, float y) => (y >= -0.65f && y <= 0.15f && Mathf.Abs(x) <= 0.62f) || (y > 0.05f && y <= 0.72f && Mathf.Abs(x) + y * 0.82f <= 0.78f));
		}
		if ((Object)(object)traderMarkerTexture == (Object)null)
		{
			traderMarkerTexture = CreateMarkerTexture("Muck Replayable Trader Icon", (float x, float y) => x * x + (y - 0.38f) * (y - 0.38f) <= 0.18f || (y >= -0.72f && y <= 0.12f && Mathf.Abs(x) <= 0.48f * (1f + y)));
		}
	}

	private static void AddCandidate(LandmarkCandidate candidate)
	{
		if (!((Object)(object)candidate?.Transform == (Object)null) && !string.IsNullOrEmpty(candidate.Key))
		{
			Candidates[candidate.Key] = candidate;
		}
	}

	private static List<Transform> FindVillages()
	{
		return (from value in (from value in Object.FindObjectsOfType<GenerateCamp>()
				where (Object)(object)value != (Object)null
				select ((Component)value).transform into value
				where (Object)(object)value != (Object)null
				select value).Distinct()
			orderby value.position.x, value.position.z
			select value).ToList();
	}

	private static void RegisterVillageCandidates(IReadOnlyList<Transform> villages)
	{
		//IL_0017: 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)
		if (villages == null)
		{
			return;
		}
		for (int i = 0; i < villages.Count; i++)
		{
			string text = PositionKey("village", villages[i].position);
			if (Discovered.Contains("village:" + i))
			{
				Discovered.Add(text);
			}
			AddCandidate(new LandmarkCandidate
			{
				Key = text,
				Label = "Village",
				MarkerName = "Muck Replayable Village Marker",
				Transform = villages[i],
				Texture = villageMarkerTexture,
				Color = new Color(1f, 0.62f, 0.24f, 1f),
				Scale = 0.76f,
				DiscoveryRadius = 105f
			});
			if (Discovered.Contains(text))
			{
				AddMarkerFor(text);
			}
		}
	}

	private static string PositionKey(string kind, Vector3 position)
	{
		//IL_0006: 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)
		return $"{kind}:{Mathf.RoundToInt(position.x)}:{Mathf.RoundToInt(position.z)}";
	}

	private static void AddMarkerFor(string key)
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)Map.Instance == (Object)null) && Candidates.TryGetValue(key, out var candidate) && !((Object)(object)candidate.Transform == (Object)null) && !Landmarks.Any((MapMarker value) => (Object)(object)value?.marker != (Object)null && ((Object)value.marker).name == candidate.MarkerName + " " + key))
		{
			MapMarker val = Map.Instance.AddMarker(candidate.Transform, (MarkerType)3, (Texture)(object)candidate.Texture, candidate.Color, candidate.Label, candidate.Scale);
			((Object)val.marker).name = candidate.MarkerName + " " + key;
			Landmarks.Add(val);
		}
	}

	private static Texture2D CreateMarkerTexture(string name, Func<float, float, bool> filled)
	{
		//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_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Expected O, but got Unknown
		//IL_007a: 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_007f: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(32, 32, (TextureFormat)4, false)
		{
			name = name,
			filterMode = (FilterMode)1,
			wrapMode = (TextureWrapMode)1
		};
		Color[] array = (Color[])(object)new Color[1024];
		for (int i = 0; i < 32; i++)
		{
			for (int j = 0; j < 32; j++)
			{
				float arg = (float)j / 31f * 2f - 1f;
				float arg2 = (float)i / 31f * 2f - 1f;
				array[i * 32 + j] = (filled(arg, arg2) ? Color.white : Color.clear);
			}
		}
		val.SetPixels(array);
		val.Apply(false, true);
		Object.DontDestroyOnLoad((Object)(object)val);
		return val;
	}
}
[HarmonyPatch(typeof(Map), "GenerateMap")]
internal static class DetailedMapGenerationPatch
{
	private static void Postfix(Map __instance)
	{
		DetailedMapService.ApplyDetailedTexture(__instance);
		DetailedMapService.RefreshLandmarks();
	}
}
internal static class LocalizationService
{
	private static readonly Dictionary<string, string> Text = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
	{
		["title"] = "Muck Replayable",
		["lobbies"] = "Lobbies",
		["saves"] = "Saves",
		["refresh"] = "Refresh",
		["quick_join"] = "Quick Join",
		["public_host"] = "Host Public",
		["friends_host"] = "Host Friends",
		["private_host"] = "Host Invite-only",
		["join"] = "Join",
		["players"] = "players",
		["slot"] = "Slot",
		["save_now"] = "Save now",
		["continue"] = "Continue as host",
		["empty"] = "Empty",
		["close"] = "Close [F6]",
		["saved"] = "Run saved",
		["host_only"] = "Only the host can save the world",
		["no_lobbies"] = "No compatible public lobbies",
		["lobby_disabled"] = "Lobby browser is disabled in the config.",
		["save_help"] = "F5: save active slot    F9: continue active slot    Autosave: {0}s",
		["day"] = "Day",
		["seed"] = "seed",
		["lobby_refresh_failed"] = "Lobby refresh failed: ",
		["lobby_created"] = "Lobby created.",
		["lobby_create_failed"] = "Could not create lobby: ",
		["creative_not_ready"] = "Creative flight is not ready yet.",
		["creative_flight_enabled"] = "Creative flight enabled • WASD / Space / Ctrl • Shift to boost",
		["creative_flight_disabled"] = "Creative flight disabled",
		["creative_catalog_title"] = "Muck Replayable Creative Catalog",
		["creative_hud_on"] = "Creative • F7 catalog • F8 flight\nF4 sort backpack • FLIGHT ON",
		["creative_hud_off"] = "Creative • F7 catalog • F8 flight\nF4 sort backpack • Flight off",
		["spectating"] = "Spectating: {0}",
		["spectator_free_camera"] = "Free camera",
		["spectator_free_controls"] = "WASD / Space / Ctrl move • Shift boost • F follow player",
		["spectator_follow_controls"] = "LMB/RMB cycle • Wheel zoom • F free camera",
		["catalog_items"] = "Items",
		["catalog_artifacts"] = "Artifacts",
		["catalog_close"] = "Close [F7]",
		["catalog_search"] = "Search",
		["catalog_spawn_hint"] = "Clicking an entry spawns a networked stack in front of your character.",
		["sort_held"] = "Put down the held item before sorting.",
		["sort_done"] = "Backpack sorted and partial stacks combined.",
		["save_slot_invalid"] = "Save slot {0} is empty or unreadable.",
		["save_world_loading"] = "The world is still loading; save again when play begins.",
		["save_failed"] = "Save failed: {0}",
		["load_timeout"] = "Load failed: the world did not finish initializing.",
		["loaded_day_seed"] = "Loaded day {0} • seed {1}",
		["load_partial_failed"] = "Load partially failed: {0}",
		["save_slots_full"] = "All 24 world slots are occupied. Open Worlds and save over a world you no longer need.",
		["leave_run_before_load"] = "Leave the current run before loading another save. Hot-loading would mix two world seeds.",
		["steam_not_ready"] = "Steam manager is not ready.",
		["saved_lobby_failed"] = "Could not create a lobby for the saved run.",
		["saved_scene_not_ready"] = "The lobby scene is not ready; the saved run was not started.",
		["saved_prepare_failed"] = "The saved run could not prepare its lobby.",
		["saved_lobby_closed"] = "The lobby closed before the saved run could start.",
		["lobby_vanilla"] = "This is a vanilla lobby. Disable Muck Replayable before joining it.",
		["lobby_rules_mismatch"] = "Lobby rules do not match your Reforged config. Use the same world/gameplay settings as the host.",
		["lobby_protocol_mismatch"] = "Incompatible Muck Replayable protocol: host {0}, local {1}",
		["artifact_header"] = "Choose one artifact",
		["artifact_subtitle"] = "You receive only the chosen artifact. Compare current stacks and the next effect.",
		["artifact_stack"] = "Current {0}  →  After pick {1}",
		["artifact_choose"] = "Choose this artifact",
		["tier_common"] = "COMMON",
		["tier_rare"] = "RARE",
		["tier_legendary"] = "LEGENDARY"
	};

	internal static string T(string key)
	{
		string text;
		if (!Text.TryGetValue(key ?? string.Empty, out var value))
		{
			text = key;
			if (text == null)
			{
				return string.Empty;
			}
		}
		else
		{
			text = value;
		}
		return text;
	}

	internal static void ApplyGuiFont()
	{
	}

	internal static void ApplyGuiFont(params GUIStyle[] styles)
	{
	}
}
internal static class LateJoinService
{
	internal enum LobbyAccess
	{
		Closed,
		Public,
		Private
	}

	internal const int BootstrapPacketId = 242;

	internal const int PlayerAddedPacketId = 243;

	private static readonly HashSet<int> PendingPlayers = new HashSet<int>();

	private static readonly MethodInfo SendTcp = AccessTools.Method(typeof(ServerSend), "SendTCPData", new Type[2]
	{
		typeof(int),
		typeof(Packet)
	}, (Type[])null);

	internal static LobbyAccess Access { get; private set; }

	internal static bool IsPublic => Access == LobbyAccess.Public;

	internal static bool IsPrivate => Access == LobbyAccess.Private;

	internal static void Reset()
	{
		PendingPlayers.Clear();
		Access = LobbyAccess.Closed;
	}

	internal static void OpenPublicGame(Lobby lobby)
	{
		//IL_0002: 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)
		if (((Lobby)(ref lobby)).Id.Value != 0L && LocalClient.serverOwner)
		{
			((Lobby)(ref lobby)).SetPublic();
			((Lobby)(ref lobby)).SetJoinable(true);
			LobbyMetadata.Apply(lobby);
			((Lobby)(ref lobby)).SetData("MRInProgress", "1");
			GameManager instance = GameManager.instance;
			((Lobby)(ref lobby)).SetData("MRDay", ((instance != null) ? instance.currentDay : 0).ToString());
			if (GameManager.gameSettings != null)
			{
				GameManager.gameSettings.multiplayer = (Multiplayer)1;
			}
			Time.timeScale = 1f;
			Access = LobbyAccess.Public;
			ReforgedRuntime.Instance?.Notify("This run is now public. Players can join it from Public Servers.", 6f);
			Plugin.Log.LogInfo((object)"Opened the active run to public late joining.");
		}
	}

	internal static void ClosePublicGame(Lobby lobby)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		if (((Lobby)(ref lobby)).Id.Value != 0L && LocalClient.serverOwner)
		{
			((Lobby)(ref lobby)).SetJoinable(false);
			((Lobby)(ref lobby)).SetFriendsOnly();
			((Lobby)(ref lobby)).SetData("MRInProgress", "0");
			Access = LobbyAccess.Closed;
			ReforgedRuntime.Instance?.Notify("Public joining is closed. Current players stay connected.", 5f);
			Plugin.Log.LogInfo((object)"Closed public late joining for the active run.");
		}
	}

	internal static void OpenPrivateGame(Lobby lobby)
	{
		//IL_0002: 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)
		if (((Lobby)(ref lobby)).Id.Value != 0L && LocalClient.serverOwner)
		{
			((Lobby)(ref lobby)).SetPrivate();
			((Lobby)(ref lobby)).SetJoinable(true);
			LobbyMetadata.Apply(lobby);
			((Lobby)(ref lobby)).SetData("MRInProgress", "1");
			GameManager instance = GameManager.instance;
			((Lobby)(ref lobby)).SetData("MRDay", ((instance != null) ? instance.currentDay : 0).ToString());
			if (GameManager.gameSettings != null)
			{
				GameManager.gameSettings.multiplayer = (Multiplayer)1;
			}
			Time.timeScale = 1f;
			Access = LobbyAccess.Private;
			ReforgedRuntime.Instance?.Notify("This run is now private. Invite players through Steam.", 6f);
			Plugin.Log.LogInfo((object)"Opened the active run for private invited late joining.");
		}
	}

	internal static bool HandleMemberJoined(Lobby lobby, Friend friend)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Invalid comparison between Unknown and I4
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: 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_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_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		if (!LocalClient.serverOwner || (Object)(object)GameManager.instance == (Object)null || (int)GameManager.state != 1 || ((Lobby)(ref lobby)).GetData("MRInProgress") != "1" || (Object)(object)SteamManager.Instance == (Object)null)
		{
			return false;
		}
		if (friend.Id.Value == SteamManager.Instance.PlayerSteamId.Value)
		{
			return true;
		}
		try
		{
			SteamManager.Instance.LobbyPartner = friend;
			SteamManager.Instance.lobbyOwnerSteamId = ((Lobby)(ref lobby)).Owner.Id;
			AccessTools.Method(typeof(SteamManager), "AcceptP2P", (Type[])null, (Type[])null)?.Invoke(SteamManager.Instance, new object[1] { friend.Id });
			if (!SteamLobby.steamIdToClientId.ContainsKey(friend.Id.Value))
			{
				SteamLobby.Instance.AddPlayerToLobby(friend);
			}
			if (!SteamLobby.steamIdToClientId.TryGetValue(friend.Id.Value, out var value))
			{
				return true;
			}
			PendingPlayers.Add(value);
			GameSettings gameSettings = GameManager.gameSettings;
			gameSettings.multiplayer = (Multiplayer)1;
			ServerSend.StartGame(value, gameSettings);
			Plugin.Log.LogInfo((object)$"Prepared in-progress join for {((Friend)(ref friend)).Name} as player {value}.");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Could not prepare late join: " + ex));
		}
		return true;
	}

	internal static bool FinishLateJoin(int playerId)
	{
		//IL_006e: 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_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_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_0053: 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_009b: 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_00a3: 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_0141: Unknown result type (might be due to invalid IL or missing references)
		if (!PendingPlayers.Contains(playerId) || Server.clients == null || !Server.clients.TryGetValue(playerId, out var value) || value?.player == null)
		{
			return false;
		}
		try
		{
			value.player.ready = true;
			ServerSend.PlayerFinishedLoading(playerId);
			Vector3 val = (((Object)(object)PlayerMovement.Instance != (Object)null) ? (((Component)PlayerMovement.Instance).transform.position + ((Component)PlayerMovement.Instance).transform.right * 3f + Vector3.up) : (Vector3.up * 3f));
			value.player.pos = val;
			if (GameManager.players != null && !GameManager.players.ContainsKey(playerId))
			{
				GameManager.instance.SpawnPlayer(playerId, value.player.username, value.player.color, val, 0f);
			}
			foreach (Client value2 in Server.clients.Values)
			{
				if (value2?.player != null && value2.player.id != playerId && value2.player.id != LocalClient.instance.myId)
				{
					SendPlayerAdded(value2.player.id, value.player, val);
				}
			}
			SendBootstrap(playerId);
			SendMobSnapshot(playerId);
			StructureUpgradeService.SendSnapshot(playerId);
			ServerSend.SendChatMessage(-1, "Server", value.player.username + " joined the running world.");
			Plugin.Log.LogInfo((object)$"Completed in-progress join bootstrap for player {playerId}.");
		}
		catch (Exception arg)
		{
			Plugin.Log.LogError((object)$"Late join bootstrap failed for player {playerId}: {arg}");
		}
		finally
		{
			PendingPlayers.Remove(playerId);
		}
		return true;
	}

	private static void SendBootstrap(int toClient)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Expected O, but got Unknown
		//IL_00be: 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_0116: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
		if (SendTcp == null || Server.clients == null)
		{
			return;
		}
		Packet val = new Packet(242);
		try
		{
			List<Player> list = (from val3 in Server.clients.Values
				where val3?.player != null
				select val3.player).ToList();
			val.Write(list.Count);
			foreach (Player item in list)
			{
				PlayerManager value;
				Vector3 val2 = ((GameManager.players != null && GameManager.players.TryGetValue(item.id, out value) && (Object)(object)value != (Object)null) ? ((Component)value).transform.position : item.pos);
				val.Write(item.id);
				val.Write(item.username ?? "Player");
				val.Write(new Vector3(item.color.r, item.color.g, item.color.b));
				val.Write(val2);
				val.Write(item.yOrientation);
			}
			GameManager instance = GameManager.instance;
			val.Write((instance != null) ? instance.currentDay : 0);
			val.Write(DayCycle.time);
			val.Write(RunSaveService.CaptureWorldSnapshotBase64());
			SendTcp.Invoke(null, new object[2] { toClient, val });
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	private static void SendPlayerAdded(int toClient, Player player, Vector3 position)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected O, but got Unknown
		//IL_005f: 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)
		if (SendTcp == null || player == null)
		{
			return;
		}
		Packet val = new Packet(243);
		try
		{
			val.Write(player.id);
			val.Write(player.username ?? "Player");
			val.Write(new Vector3(player.color.r, player.color.g, player.color.b));
			val.Write(position);
			val.Write(player.yOrientation);
			SendTcp.Invoke(null, new object[2] { toClient, val });
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	private static void SendMobSnapshot(int toClient)
	{
		//IL_00af: 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_00bf: Expected O, but got Unknown
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		if (SendTcp == null || MobManager.Instance?.mobs == null || MobSpawner.Instance?.allMobs == null)
		{
			return;
		}
		int num = 0;
		foreach (Mob item in MobManager.Instance.mobs.Values.Where((Mob value) => (Object)(object)value != (Object)null))
		{
			int num2 = Array.IndexOf(MobSpawner.Instance.allMobs, item.mobType);
			if (num2 >= 0)
			{
				Guardian component = ((Component)item).GetComponent<Guardian>();
				int num3 = ((!((Object)(object)component != (Object)null)) ? (-1) : ((int)component.type));
				Packet val = new Packet(30);
				try
				{
					val.Write(((Component)item).transform.position);
					val.Write(num2);
					val.Write(item.id);
					val.Write(item.multiplier);
					val.Write(item.bossMultiplier);
					val.Write(num3);
					SendTcp.Invoke(null, new object[2] { toClient, val });
					num++;
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}
		Plugin.Log.LogInfo((object)$"Sent {num} active mobs to late-joining player {toClient}.");
	}

	internal static void ReceiveBootstrap(Packet packet)
	{
		try
		{
			int num = Mathf.Clamp(packet.ReadInt(true), 1, SteamLobby.lobbySize);
			for (int i = 0; i < num; i++)
			{
				SpawnPacketPlayer(packet);
			}
			int num2 = Mathf.Max(0, packet.ReadInt(true));
			float num3 = packet.ReadFloat(true);
			string encoded = packet.ReadString(true);
			if ((Object)(object)NetworkController.Instance != (Object)null)
			{
				NetworkController.Instance.nPlayers = num;
			}
			GameManager.instance.StartGame();
			GameManager.instance.UpdateDay(num2);
			DayCycle.time = Mathf.Repeat(num3, 1f);
			ReforgedRuntime.Instance?.StartManagedCoroutine(RunSaveService.ApplyWorldSnapshotBase64(encoded));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Rejected late-join bootstrap: " + ex));
		}
	}

	internal static void ReceivePlayerAdded(Packet packet)
	{
		try
		{
			SpawnPacketPlayer(packet);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected late-join player packet: " + ex.Message));
		}
	}

	private static void SpawnPacketPlayer(Packet packet)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: 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_005c: Unknown result type (might be due to invalid IL or missing references)
		int num = packet.ReadInt(true);
		string text = packet.ReadString(true);
		Vector3 val = packet.ReadVector3(true);
		Vector3 val2 = packet.ReadVector3(true);
		float num2 = packet.ReadFloat(true);
		if (num >= 0 && num < SteamLobby.lobbySize && PacketSanitizer.ValidVector(val2))
		{
			GameManager.instance.SpawnPlayer(num, text, new Color(val.x, val.y, val.z), val2, num2);
		}
	}
}
[HarmonyPatch(typeof(SteamManager), "OnLobbyMemberJoinedCallback")]
internal static class RunningLobbyMemberJoinedPatch
{
	private static bool Prefix(Lobby lobby, Friend friend)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		return !LateJoinService.HandleMemberJoined(lobby, friend);
	}
}
[HarmonyPatch(typeof(ServerHandle), "PlayerFinishedLoading")]
internal static class RunningLobbyFinishedLoadingPatch
{
	private static bool Prefix(int fromClient)
	{
		return !LateJoinService.FinishLateJoin(fromClient);
	}
}
[HarmonyPatch(typeof(LocalClient), "InitializeClientData")]
internal static class LateJoinPacketRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Expected O, but got Unknown
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Expected O, but got Unknown
		if (LocalClient.packetHandlers != null)
		{
			LocalClient.packetHandlers[242] = new PacketHandler(LateJoinService.ReceiveBootstrap);
			LocalClient.packetHandlers[243] = new PacketHandler(LateJoinService.ReceivePlayerAdded);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class ResetLateJoinPatch
{
	private static void Prefix()
	{
		LateJoinService.Reset();
	}
}
internal static class LobbyMetadata
{
	internal static string RulesSignature => string.Join(";", "art=" + Flag(Plugin.Settings.EnableArtifactChoices.Value), "mobs=3:" + Flag(Plugin.Settings.EnableNewMonsterTypes.Value), "shields=3", "beds=1", "creative=" + Flag(Plugin.Settings.EnableCreativeOverhaul.Value), "island=" + Flag(Plugin.Settings.EnableExpandedIsland.Value) + ":" + Plugin.Settings.IslandChunkSize.Value, "caves=" + Flag(Plugin.Settings.EnableCaveNetwork.Value) + ":" + Flag(Plugin.Settings.MoveOresIntoCaves.Value) + ":" + Plugin.Settings.CaveOreNodesPerTunnel.Value + ":" + Plugin.Settings.SurfaceOreNodeCount.Value, "curves=" + Flag(Plugin.Settings.EnableDifficultyCurves.Value), $"days={Plugin.Settings.EasyDayLength.Value},{Plugin.Settings.NormalDayLength.Value},{Plugin.Settings.GamerDayLength.Value}", "resource=" + Plugin.Settings.ResourceDamageMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture), "move=" + Plugin.Settings.PlayerMoveSpeedMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture), "stamina=" + Plugin.Settings.StaminaDrainMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture), "jump=" + Plugin.Settings.JumpStaminaMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture), "hunger=" + Plugin.Settings.HungerDrainMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture), "buildDamage=" + Plugin.Settings.BuildDamageMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture), $"economy={Plugin.Settings.MaterialStackSize.Value},{Plugin.Settings.ArrowStackSize.Value}," + Plugin.Settings.SmeltTimeMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture) + "," + Plugin.Settings.FuelUseMultiplier.Value.ToString("0.###", CultureInfo.InvariantCulture));

	internal static void Apply(Lobby lobby)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		if (((Lobby)(ref lobby)).Id.Value != 0L)
		{
			((Lobby)(ref lobby)).SetData("MRProtocol", "15");
			((Lobby)(ref lobby)).SetData("MRVersion", "0.9.4");
			((Lobby)(ref lobby)).SetData("MRRules", RulesSignature);
			SteamManager instance = SteamManager.Instance;
			((Lobby)(ref lobby)).SetData("MRName", (((instance != null) ? instance.PlayerName : null) ?? "Muck") + " • Replayable");
			((Lobby)(ref lobby)).SetData("MRFeatures", "aggro,worlds,natural-caves,traders,armored-mobs,artifact-choice,late-join,upgrades,tiered-shields,beds,third-person,continue-after-victory");
			((Lobby)(ref lobby)).SetData("MRSave", (RunSaveService.Pending == null) ? "new" : "continue");
			if ((Object)(object)GameManager.instance == (Object)null)
			{
				((Lobby)(ref lobby)).SetData("MRInProgress", "0");
			}
			((Lobby)(ref lobby)).SetData("Version", Application.version + "-MR15");
		}
	}

	private static string Flag(bool value)
	{
		if (!value)
		{
			return "0";
		}
		return "1";
	}
}
[HarmonyPatch(typeof(SteamManager), "OnLobbyCreatedCallback")]
internal static class LobbyCreatedMetadataPatch
{
	private static void Postfix(Result result, Lobby lobby)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Invalid comparison between Unknown and I4
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		if ((int)result == 1)
		{
			LobbyMetadata.Apply(lobby);
		}
	}
}
[HarmonyPatch(typeof(SteamManager), "OnLobbyEnteredCallback")]
internal static class LobbyCompatibilityPatch
{
	private static bool Prefix(Lobby lobby)
	{
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: 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_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0170: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ff: 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_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		string data = ((Lobby)(ref lobby)).GetData("MRProtocol");
		if (string.IsNullOrEmpty(data))
		{
			Reject(lobby, LocalizationService.T("lobby_vanilla"));
			return false;
		}
		if (data == "15")
		{
			string data2 = ((Lobby)(ref lobby)).GetData("MRRules");
			if (string.IsNullOrEmpty(data2) || data2 != LobbyMetadata.RulesSignature)
			{
				Reject(lobby, LocalizationService.T("lobby_rules_mismatch"));
				return false;
			}
			if (((Lobby)(ref lobby)).MemberCount < 1)
			{
				((Lobby)(ref lobby)).Leave();
				return false;
			}
			if (((Lobby)(ref lobby)).GetData("MRInProgress") == "1")
			{
				LocalClient.serverOwner = false;
				AccessTools.Field(typeof(SteamManager), "originalLobbyOwnerId")?.SetValue(SteamManager.Instance, ((Lobby)(ref lobby)).Owner.Id);
				AccessTools.Method(typeof(SteamManager), "AcceptP2P", (Type[])null, (Type[])null)?.Invoke(SteamManager.Instance, new object[1] { ((Lobby)(ref lobby)).Owner.Id });
				((Lobby)(ref lobby)).SendChatString("incoming player info");
				ReforgedRuntime.Instance?.Notify("Joining running world...", 8f);
				return false;
			}
			LobbyVisuals.Instance.OpenLobby(lobby);
			LocalClient.serverOwner = false;
			AccessTools.Field(typeof(SteamManager), "originalLobbyOwnerId")?.SetValue(SteamManager.Instance, ((Lobby)(ref lobby)).Owner.Id);
			if (((Lobby)(ref lobby)).MemberCount != 1)
			{
				AccessTools.Method(typeof(SteamManager), "AcceptP2P", (Type[])null, (Type[])null)?.Invoke(SteamManager.Instance, new object[1] { ((Lobby)(ref lobby)).Owner.Id });
				((Lobby)(ref lobby)).SendChatString("incoming player info");
			}
			return false;
		}
		Reject(lobby, string.Format(LocalizationService.T("lobby_protocol_mismatch"), data, "15"));
		return false;
	}

	private static void Reject(Lobby lobby, string message)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		ReforgedRuntime.Instance?.Notify(message, 8f);
		((Lobby)(ref lobby)).Leave();
		ReforgedRuntime.Instance?.StartManagedCoroutine(DeferredLeave(((Lobby)(ref lobby)).Id.Value));
	}

	private static IEnumerator DeferredLeave(ulong rejectedLobbyId)
	{
		yield return null;
		if ((Object)(object)SteamManager.Instance != (Object)null && ((Lobby)(ref SteamManager.Instance.currentLobby)).Id.Value == rejectedLobbyId)
		{
			SteamManager.Instance.leaveLobby();
		}
	}
}
[HarmonyPatch(typeof(SteamLobby), "MakeSettings")]
internal static class SavedGameSettingsPatch
{
	private static void Postfix(ref GameSettings __result)
	{
		RunSaveData pending = RunSaveService.Pending;
		if (pending != null)
		{
			__result.Seed = pending.Seed;
			__result.difficulty = (Difficulty)pending.Difficulty;
			__result.gameMode = (GameMode)pending.GameMode;
			__result.friendlyFire = (FriendlyFire)pending.FriendlyFire;
			return;
		}
		LobbySettings instance = LobbySettings.Instance;
		object value;
		if (instance == null)
		{
			value = null;
		}
		else
		{
			TMP_InputField seed = instance.seed;
			value = ((seed != null) ? seed.text : null);
		}
		if (string.IsNullOrWhiteSpace((string?)value))
		{
			__result.Seed = NewWorldSeedService.Next();
		}
	}
}
internal static class NewWorldSeedService
{
	private static int counter = Environment.TickCount;

	internal static int Next()
	{
		byte[] value = Guid.NewGuid().ToByteArray();
		int num = BitConverter.ToInt32(value, 0) ^ BitConverter.ToInt32(value, 4) ^ BitConverter.ToInt32(value, 8) ^ BitConverter.ToInt32(value, 12) ^ Interlocked.Increment(ref counter) ^ (int)DateTime.UtcNow.Ticks;
		if (num == 0)
		{
			num = 1;
		}
		Plugin.Log.LogInfo((object)$"Generated unique blank-seed world seed {num}.");
		return num;
	}
}
[HarmonyPatch(typeof(SteamLobby), "StartGame")]
internal static class LobbyStartMetadataPatch
{
	private static void Prefix()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)SteamManager.Instance != (Object)null)
		{
			LobbyMetadata.Apply(SteamManager.Instance.currentLobby);
		}
	}
}
internal static class ReforgedModes
{
	internal static bool Creative
	{
		get
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if (Plugin.Settings != null && Plugin.Settings.EnableCreativeOverhaul.Value && GameManager.gameSettings != null && (int)GameManager.gameSettings.gameMode == 2)
			{
				return (int)GameManager.state == 1;
			}
			return false;
		}
	}
}
internal static class CreativeSpawnService
{
	internal const int SpawnRequestPacketId = 242;

	private static readonly MethodInfo SendTcp = AccessTools.Method(typeof(ClientSend), "SendTCPData", (Type[])null, (Type[])null);

	private static readonly Dictionary<int, float> LastRequest = new Dictionary<int, float>();

	internal static void Reset()
	{
		LastRequest.Clear();
	}

	internal static void Request(bool powerup, int id)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Expected O, but got Unknown
		if (!ReforgedModes.Creative || (Object)(object)LocalClient.instance == (Object)null)
		{
			return;
		}
		if (LocalClient.serverOwner)
		{
			Spawn(LocalClient.instance.myId, powerup, id);
			return;
		}
		try
		{
			Packet val = new Packet(242);
			try
			{
				val.Write(powerup);
				val.Write(id);
				SendTcp?.Invoke(null, new object[1] { val });
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Could not request Creative item: " + ex.Message));
		}
	}

	internal static void Receive(int fromClient, Packet packet)
	{
		try
		{
			Spawn(fromClient, packet.ReadBool(true), packet.ReadInt(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed Creative request from {fromClient}: {ex.Message}");
		}
	}

	private static void Spawn(int fromClient, bool powerup, int id)
	{
		//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_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_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//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_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		if (!ReforgedModes.Creative || !InteractionGuard.TryPlayer(fromClient, out var player) || (Object)(object)ItemManager.Instance == (Object)null)
		{
			return;
		}
		float unscaledTime = Time.unscaledTime;
		if (LastRequest.TryGetValue(fromClient, out var value) && unscaledTime - value < 0.08f)
		{
			return;
		}
		LastRequest[fromClient] = unscaledTime;
		Vector3 val = ((Component)player).transform.position + Vector3.up * 1.4f + ((Component)player).transform.forward * 1.8f;
		if (!PacketSanitizer.ValidVector(val))
		{
			return;
		}
		int nextId = ItemManager.Instance.GetNextId();
		InventoryItem value2;
		if (powerup)
		{
			if (ItemManager.Instance.allPowerups != null && ItemManager.Instance.allPowerups.ContainsKey(id))
			{
				ItemManager.Instance.DropPowerupAtPosition(id, val, nextId);
				ServerSend.DropPowerupAtPosition(id, nextId, val);
			}
		}
		else if (ItemManager.Instance.allItems != null && ItemManager.Instance.allItems.TryGetValue(id, out value2) && !((Object)(object)value2 == (Object)null))
		{
			int num = ((!value2.stackable) ? 1 : Mathf.Max(1, value2.max));
			ItemManager.Instance.DropItemAtPosition(id, num, val, nextId);
			ServerSend.DropItemAtPosition(id, num, nextId, val);
		}
	}
}
internal sealed class EnhancedModeController : MonoBehaviour
{
	private Rect catalogWindow = new Rect(55f, 45f, 720f, 650f);

	private Vector2 catalogScroll;

	private string search = string.Empty;

	private bool catalogVisible;

	private bool powerupTab;

	private CursorLockMode previousLock;

	private bool previousCursor;

	private bool previousInputActive;

	private Rigidbody flightBody;

	private bool oldGravity;

	private float oldDrag;

	internal static EnhancedModeController Instance { get; private set; }

	internal static bool Flying { get; private set; }

	private void Awake()
	{
		Instance = this;
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
	}

	private void OnDestroy()
	{
		SetCatalog(value: false);
		SetFlight(value: false);
		if ((Object)(object)Instance == (Object)(object)this)
		{
			Instance = null;
		}
	}

	private void Update()
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Invalid comparison between Unknown and I4
		bool num = (Object)(object)GameManager.instance != (Object)null && (int)GameManager.state == 1;
		if (catalogVisible)
		{
			SetCatalog(value: false);
		}
		if (Flying)
		{
			SetFlight(value: false);
		}
		if (num && Input.GetKeyDown((KeyCode)285))
		{
			InventorySorter.SortBackpack();
		}
	}

	private static void KeepCreativeVitalsFull()
	{
		PlayerStatus instance = PlayerStatus.Instance;
		if (!((Object)(object)instance == (Object)null) && !instance.IsPlayerDead())
		{
			instance.hp = instance.maxHp;
			instance.shield = instance.maxShield;
			instance.stamina = instance.maxStamina;
			instance.hunger = instance.maxHunger;
		}
	}

	private void SetCatalog(bool value)
	{
		//IL_0026: 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_009e: Unknown result type (might be due to invalid IL or missing references)
		if (catalogVisible == value)
		{
			return;
		}
		if (value && Flying)
		{
			SetFlight(value: false);
		}
		catalogVisible = value;
		if (value)
		{
			previousLock = Cursor.lockState;
			previousCursor = Cursor.visible;
			previousInputActive = (Object)(object)PlayerInput.Instance != (Object)null && PlayerInput.Instance.active;
			if ((Object)(object)PlayerInput.Instance != (Object)null)
			{
				PlayerInput.Instance.active = false;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}
		else
		{
			if ((Object)(object)PlayerInput.Instance != (Object)null)
			{
				PlayerInput.Instance.active = previousInputActive;
			}
			Cursor.lockState = previousLock;
			Cursor.visible = previousCursor;
		}
	}

	private void SetFlight(bool value)
	{
		//IL_0139: 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)
		if (Flying == value)
		{
			return;
		}
		if (value && ((Object)(object)PlayerMovement.Instance == (Object)null || (Object)(object)PlayerMovement.Instance.playerCam == (Object)null || (Object)(object)PlayerMovement.Instance.GetRb() == (Object)null))
		{
			ReforgedRuntime.Instance?.Notify(LocalizationService.T("creative_not_ready"));
			return;
		}
		Flying = value;
		if (value)
		{
			flightBody = (((Object)(object)PlayerMovement.Instance != (Object)null) ? PlayerMovement.Instance.GetRb() : null);
			if ((Object)(object)flightBody != (Object)null)
			{
				oldGravity = flightBody.useGravity;
				oldDrag = flightBody.drag;
				flightBody.useGravity = false;
				flightBody.drag = 0f;
				flightBody.velocity = Vector3.zero;
			}
			ReforgedRuntime.Instance?.Notify(LocalizationService.T("creative_flight_enabled"), 5f);
		}
		else
		{
			if ((Object)(object)flightBody != (Object)null)
			{
				flightBody.useGravity = oldGravity;
				flightBody.drag = oldDrag;
				flightBody.velocity = Vector3.zero;
			}
			flightBody = null;
			if ((Object)(object)GameManager.instance != (Object)null)
			{
				ReforgedRuntime.Instance?.Notify(LocalizationService.T("creative_flight_disabled"));
			}
		}
	}

	private void UpdateFlight()
	{
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: 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_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: 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_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0091: 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_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//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_00dd: 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_00e3: 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_011f: 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)
		if ((Object)(object)flightBody == (Object)null || (Object)(object)PlayerMovement.Instance == (Object)null || (Object)(object)PlayerMovement.Instance.playerCam == (Object)null)
		{
			SetFlight(value: false);
			return;
		}
		Transform playerCam = PlayerMovement.Instance.playerCam;
		Vector3 val = Vector3.zero;
		if (Input.GetKey(InputManager.forward))
		{
			val += playerCam.forward;
		}
		if (Input.GetKey(InputManager.backwards))
		{
			val -= playerCam.forward;
		}
		if (Input.GetKey(InputManager.right))
		{
			val += playerCam.right;
		}
		if (Input.GetKey(InputManager.left))
		{
			val -= playerCam.right;
		}
		if (Input.GetKey(InputManager.jump))
		{
			val += Vector3.up;
		}
		if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)99))
		{
			val -= Vector3.up;
		}
		float num = (Input.GetKey(InputManager.sprint) ? 45f : 16f);
		flightBody.velocity = ((((Vector3)(ref val)).sqrMagnitude > 0.001f) ? (((Vector3)(ref val)).normalized * num) : Vector3.zero);
	}

	private void OnGUI()
	{
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		LocalizationService.ApplyGuiFont();
		ReforgedGuiTheme.Ensure();
		if (Plugin.Settings.EnableEnhancedSpectator.Value && SpectatorFix.Active)
		{
			bool num = SpectatorFix.TargetName == "Free camera";
			string arg = (num ? LocalizationService.T("spectator_free_camera") : SpectatorFix.TargetName);
			string text = LocalizationService.T(num ? "spectator_free_controls" : "spectator_follow_controls");
			GUI.Box(new Rect(((float)Screen.width - 500f) * 0.5f, 12f, 500f, 54f), string.Format(LocalizationService.T("spectating"), arg) + "\n" + text, ReforgedGuiTheme.Hud);
		}
	}

	private void DrawCatalog(int id)
	{
		//IL_0020: 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_019b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: 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_01f7: Unknown result type (might be due to invalid IL or missing references)
		GUI.Label(new Rect(22f, 12f, ((Rect)(ref catalogWindow)).width - 90f, 36f), LocalizationService.T("creative_catalog_title"), ReforgedGuiTheme.Title);
		if (GUI.Button(new Rect(((Rect)(ref catalogWindow)).width - 58f, 12f, 36f, 36f), "×", ReforgedGuiTheme.CloseButton))
		{
			SetCatalog(value: false);
			return;
		}
		GUILayout.Space(52f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button(LocalizationService.T("catalog_items"), (!powerupTab) ? ReforgedGuiTheme.ActiveTab : ReforgedGuiTheme.Tab, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			powerupTab = false;
		}
		if (GUILayout.Button(LocalizationService.T("catalog_artifacts"), powerupTab ? ReforgedGuiTheme.ActiveTab : ReforgedGuiTheme.Tab, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			powerupTab = true;
		}
		GUILayout.EndHorizontal();
		GUILayout.Space(6f);
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUILayout.Label(LocalizationService.T("catalog_search"), ReforgedGuiTheme.Label, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(76f) });
		search = GUILayout.TextField(search ?? string.Empty, ReforgedGuiTheme.Input, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) });
		GUILayout.EndHorizontal();
		GUILayout.Label(LocalizationService.T("catalog_spawn_hint"), ReforgedGuiTheme.Muted, Array.Empty<GUILayoutOption>());
		catalogScroll = GUILayout.BeginScrollView(catalogScroll, ReforgedGuiTheme.Card);
		if ((Object)(object)ItemManager.Instance != (Object)null)
		{
			if (powerupTab)
			{
				DrawPowerups();
			}
			else
			{
				DrawItems();
			}
		}
		GUILayout.EndScrollView();
		GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref catalogWindow)).width - 70f, 58f));
	}

	private void DrawItems()
	{
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		IOrderedEnumerable<InventoryItem> orderedEnumerable = from item in ItemManager.Instance.allItems.Values
			where (Object)(object)item != (Object)null && Matches(item.name)
			orderby item.type, item.tier, item.name
			select item;
		int num = 0;
		foreach (InventoryItem item in orderedEnumerable)
		{
			if (num == 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			}
			string arg = (item.stackable ? $" ×{Mathf.Max(1, item.max)}" : string.Empty);
			if (GUILayout.Button($"{item.name}{arg}  •  {item.type}", ReforgedGuiTheme.CardButton, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(214f),
				GUILayout.Height(52f)
			}))
			{
				CreativeSpawnService.Request(powerup: false, item.id);
			}
			num++;
			if (num == 3)
			{
				GUILayout.EndHorizontal();
				num = 0;
			}
		}
		if (num != 0)
		{
			GUILayout.EndHorizontal();
		}
	}

	private void DrawPowerups()
	{
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		IOrderedEnumerable<Powerup> orderedEnumerable = from powerup in ItemManager.Instance.allPowerups.Values
			where (Object)(object)powerup != (Object)null && Matches(powerup.name)
			orderby powerup.tier, powerup.name
			select powerup;
		int num = 0;
		foreach (Powerup item in orderedEnumerable)
		{
			if (num == 0)
			{
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			}
			if (GUILayout.Button(ArtifactEffectFormatter.DisplayName(item.name) + "  •  " + TierDisplay(item.tier), ReforgedGuiTheme.CardButton, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(214f),
				GUILayout.Height(52f)
			}))
			{
				CreativeSpawnService.Request(powerup: true, item.id);
			}
			num++;
			if (num == 3)
			{
				GUILayout.EndHorizontal();
				num = 0;
			}
		}
		if (num != 0)
		{
			GUILayout.EndHorizontal();
		}
	}

	private bool Matches(string value)
	{
		if (!string.IsNullOrWhiteSpace(search))
		{
			return (value ?? string.Empty).IndexOf(search, StringComparison.OrdinalIgnoreCase) >= 0;
		}
		return true;
	}

	private static string TierDisplay(PowerTier tier)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Invalid comparison between Unknown and I4
		if ((int)tier != 0)
		{
			if ((int)tier != 1)
			{
				return LocalizationService.T("tier_legendary");
			}
			return LocalizationService.T("tier_rare");
		}
		return LocalizationService.T("tier_common");
	}
}
internal static class SpectatorFix
{
	private static float orbitDistance = 8f;

	private static bool rotationReady;

	internal static string TargetName { get; private set; } = "Free camera";

	internal static bool Active
	{
		get
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			if ((Object)(object)MoveCamera.Instance != (Object)null && (Object)(object)PlayerStatus.Instance != (Object)null && PlayerStatus.Instance.IsPlayerDead())
			{
				if ((int)MoveCamera.Instance.state != 2)
				{
					return (int)MoveCamera.Instance.state == 3;
				}
				return true;
			}
			return false;
		}
	}

	internal static bool RotationReady
	{
		get
		{
			return rotationReady;
		}
		set
		{
			rotationReady = value;
		}
	}

	internal static float OrbitDistance
	{
		get
		{
			return orbitDistance;
		}
		set
		{
			orbitDistance = Mathf.Clamp(value, 3f, 18f);
		}
	}

	internal static void Reset()
	{
		orbitDistance = 8f;
		rotationReady = false;
		TargetName = "Free camera";
	}

	internal static bool Valid(PlayerManager player)
	{
		if ((Object)(object)player != (Object)null && !player.dead && !player.disconnected && (Object)(object)((Component)player).gameObject != (Object)null)
		{
			return ((Component)player).gameObject.activeInHierarchy;
		}
		return false;
	}

	internal static PlayerManager Select(int currentId, int direction)
	{
		if (GameManager.players == null)
		{
			return null;
		}
		List<PlayerManager> list = (from player in GameManager.players.Values.Where(Valid)
			orderby player.id
			select player).ToList();
		if (list.Count == 0)
		{
			return null;
		}
		int num = list.FindIndex((PlayerManager player) => player.id == currentId);
		if (num < 0)
		{
			if (direction >= 0)
			{
				return list[0];
			}
			return list[list.Count - 1];
		}
		num = (num + direction + list.Count) % list.Count;
		return list[num];
	}

	internal static void SetTargetName(PlayerManager target)
	{
		TargetName = target?.username ?? "Free camera";
	}
}
internal static class InventorySorter
{
	internal static void SortBackpack()
	{
		InventoryUI instance = InventoryUI.Instance;
		if ((Object)(object)instance == (Object)null || (Object)(object)instance.inventoryParent == (Object)null || instance.HoldingItem())
		{
			ReforgedRuntime.Instance?.Notify(LocalizationService.T("sort_held"));
			return;
		}
		InventoryCell[] array = (from cell in ((Component)instance.inventoryParent).GetComponentsInChildren<InventoryCell>(true)
			where (Object)(object)cell != (Object)null && (int)cell.cellType == 0
			select cell).ToArray();
		List<InventoryItem> list = (from cell in array
			where (Object)(object)cell.currentItem != (Object)null
			select cell.currentItem).ToList();
		if (list.Count == 0)
		{
			return;
		}
		var list2 = (from item in list
			group item by item.id into @group
			select new
			{
				Prototype = @group.First(),
				Instances = @group.ToList(),
				Total = @group.Sum((InventoryItem item) => Mathf.Max(1, item.amount))
			} into @group
			orderby @group.Prototype.type, @group.Prototype.tier descending, @group.Prototype.name
			select @group).ToList();
		InventoryCell[] array2 = array;
		for (int num = 0; num < array2.Length; num++)
		{
			array2[num].currentItem = null;
		}
		int num2 = 0;
		foreach (var item in list2)
		{
			int num3 = item.Total;
			int num4 = ((!item.Prototype.stackable) ? 1 : Mathf.Max(1, item.Prototype.max));
			int num5 = 0;
			while (num3 > 0 && num2 < array.Length)
			{
				InventoryItem val = item.Instances[num5++];
				int num6 = Mathf.Min(num4, num3);
				val.Copy(item.Prototype, num6);
				array[num2++].currentItem = val;
				num3 -= num6;
			}
		}
		array2 = array;
		for (int num = 0; num < array2.Length; num++)
		{
			array2[num].UpdateCell();
		}
		Hotbar instance2 = Hotbar.Instance;
		if (instance2 != null)
		{
			instance2.UpdateHotbar();
		}
		ReforgedRuntime.Instance?.Notify(LocalizationService.T("sort_done"));
	}
}
[HarmonyPatch(typeof(Server), "InitializeServerPackets")]
internal static class CreativePacketRegistrationPatch
{
	private static void Postfix()
	{
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class ResetModeFixesPatch
{
	private static void Prefix()
	{
		SpectatorFix.Reset();
	}
}
[HarmonyPatch(typeof(PlayerStatus), "HandleDamage")]
internal static class CreativeInvulnerabilityPatch
{
	private static bool Prefix()
	{
		return true;
	}
}
[HarmonyPatch(typeof(ServerHandle), "PlayerHit")]
internal static class CreativeServerInvulnerabilityPatch
{
	private static bool Prefix()
	{
		return true;
	}
}
[HarmonyPatch(typeof(Hotbar), "UseItem")]
internal static class CreativeInfiniteHeldItemsPatch
{
	private static bool Prefix()
	{
		return true;
	}
}
[HarmonyPatch(typeof(InventoryUI), "GetMoney")]
internal static class CreativeMoneyPatch
{
	private static void Postfix(ref int __result)
	{
	}
}
[HarmonyPatch(typeof(InventoryUI), "UseMoney")]
internal static class CreativeFreePurchasesPatch
{
	private static bool Prefix()
	{
		return true;
	}
}
[HarmonyPatch(typeof(InventoryUI), "IsCraftable")]
internal static class CreativeCraftablePatch
{
	private static void Postfix(ref bool __result)
	{
		if (ReforgedModes.Creative)
		{
			__result = true;
		}
	}
}
[HarmonyPatch(typeof(InventoryUI), "HasItem")]
internal static class CreativeHasItemPatch
{
	private static void Postfix(ref bool __result)
	{
		if (ReforgedModes.Creative)
		{
			__result = true;
		}
	}
}
[HarmonyPatch(typeof(InventoryUI), "RemoveItem")]
internal static class CreativeResourceConsumptionPatch
{
	private static bool Prefix()
	{
		return !ReforgedModes.Creative;
	}
}
[HarmonyPatch(typeof(InventoryUI), "CanRepair")]
internal static class CreativeCanRepairPatch
{
	private static void Postfix(ref bool __result)
	{
		if (ReforgedModes.Creative)
		{
			__result = true;
		}
	}
}
[HarmonyPatch(typeof(InventoryUI), "Repair")]
internal static class CreativeFreeRepairPatch
{
	private static bool Prefix(ref bool __result)
	{
		if (!ReforgedModes.Creative)
		{
			return true;
		}
		__result = true;
		return false;
	}
}
[HarmonyPatch(typeof(InventoryUI), "CraftItem")]
internal static class CreativeCraftPatch
{
	private sealed class CraftState
	{
		internal CraftRequirement[] Requirements;
	}

	private static void Prefix(InventoryItem item, out CraftState __state)
	{
		__state = null;
		if (ReforgedModes.Creative && !((Object)(object)item == (Object)null))
		{
			__state = new CraftState
			{
				Requirements = item.requirements
			};
			item.requirements = Array.Empty<CraftRequirement>();
		}
	}

	private static void Postfix(InventoryItem item, CraftState __state)
	{
		if (__state != null && (Object)(object)item != (Object)null)
		{
			item.requirements = __state.Requirements;
		}
	}

	private static Exception Finalizer(InventoryItem item, CraftState __state, Exception __exception)
	{
		if (__state != null && (Object)(object)item != (Object)null)
		{
			item.requirements = __state.Requirements;
		}
		return __exception;
	}
}
[HarmonyPatch(typeof(PlayerMovement), "Movement")]
internal static class CreativeFlightMovementPatch
{
	private static bool Prefix()
	{
		return true;
	}
}
[HarmonyPatch(typeof(UiEvents), "IsSoftUnlocked")]
internal static class CreativeRecipeUnlockPatch
{
	private static bool Prefix(int id, ref bool __result)
	{
		if (!ReforgedModes.Creative && !ShieldRegistry.TryGet(id, out var _))
		{
			InventoryItem item = BedRegistry.Item;
			if (item == null || item.id != id)
			{
				return true;
			}
		}
		__result = true;
		return false;
	}
}
[HarmonyPatch(typeof(InventoryUI), "FillCellList")]
internal static class HotbarFirstPickupPatch
{
	private static void Postfix(InventoryUI __instance, ref List<InventoryCell> ___cells)
	{
		if (Plugin.Settings.HotbarFirstPickup.Value)
		{
			IEnumerable<InventoryCell> enumerable;
			if (!((Object)(object)__instance.hotkeysTransform != (Object)null))
			{
				enumerable = Enumerable.Empty<InventoryCell>();
			}
			else
			{
				IEnumerable<InventoryCell> componentsInChildren = ((Component)__instance.hotkeysTransform).GetComponentsInChildren<InventoryCell>(true);
				enumerable = componentsInChildren;
			}
			IEnumerable<InventoryCell> first = enumerable;
			IEnumerable<InventoryCell> enumerable2;
			if (!((Object)(object)__instance.inventoryParent != (Object)null))
			{
				enumerable2 = Enumerable.Empty<InventoryCell>();
			}
			else
			{
				IEnumerable<InventoryCell> componentsInChildren = ((Component)__instance.inventoryParent).GetComponentsInChildren<InventoryCell>(true);
				enumerable2 = componentsInChildren;
			}
			IEnumerable<InventoryCell> second = enumerable2;
			___cells = (from cell in first.Concat(second)
				where (Object)(object)cell != (Object)null
				select cell).Distinct().ToList();
		}
	}
}
[HarmonyPatch(typeof(InventoryUI), "CooldownPickup")]
internal static class BoundedPickupCooldownPatch
{
	private static bool Prefix(InventoryUI __instance)
	{
		__instance.pickupCooldown = true;
		((MonoBehaviour)__instance).CancelInvoke("ResetCooldown");
		((MonoBehaviour)__instance).Invoke("ResetCooldown", Mathf.Clamp((float)(NetStatus.GetPing() * 2) / 1000f, 0.05f, 0.35f));
		return false;
	}
}
[HarmonyPatch(typeof(InventoryCell), "ShiftClick")]
internal static class SafeChestShiftClickPatch
{
	private static bool Prefix(InventoryCell __instance, ref bool __result)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Invalid comparison between Unknown and I4
		if ((int)__instance.cellType != 2)
		{
			return true;
		}
		InventoryItem currentItem = __instance.currentItem;
		if ((Object)(object)currentItem == (Object)null || (Object)(object)InventoryUI.Instance == (Object)null || (Object)(object)OtherInput.Instance?.currentChest == (Object)null || !InventoryUI.Instance.CanPickup(currentItem))
		{
			__result = false;
			return false;
		}
		int amount = currentItem.amount;
		int num = InventoryUI.Instance.AddItemToInventory(currentItem);
		if (num >= amount)
		{
			__result = false;
			return false;
		}
		if (num > 0)
		{
			currentItem.amount = num;
			__instance.UpdateCell();
		}
		else
		{
			__instance.RemoveItem();
		}
		int num2 = (((Object)(object)__instance.currentItem != (Object)null) ? __instance.currentItem.id : (-1));
		int num3 = (((Object)(object)__instance.currentItem != (Object)null) ? __instance.currentItem.amount : 0);
		ClientSend.ChestUpdate(OtherInput.Instance.currentChest.id, __instance.cellId, num2, num3);
		__result = true;
		return false;
	}
}
[HarmonyPatch(typeof(GameManager), "RespawnPlayer")]
internal static class SafeRespawnPatch
{
	private static bool Prefix(GameManager __instance, int id, Vector3 zero)
	{
		//IL_0021: 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_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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: 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_008b: 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_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		if (GameManager.players == null || !GameManager.players.TryGetValue(id, out var value) || (Object)(object)value == (Object)null)
		{
			return false;
		}
		Vector3 val = ((PacketSanitizer.ValidVector(zero) && zero != Vector3.zero) ? zero : ((Component)value).transform.position);
		int graveId = value.graveId;
		if (graveId >= 0 && ResourceManager.Instance?.list != null && ResourceManager.Instance.list.TryGetValue(graveId, out var value2) && (Object)(object)value2 != (Object)null)
		{
			val = value2.transform.position;
			value.RemoveGrave();
		}
		else
		{
			value.graveId = -1;
		}
		if (!PacketSanitizer.ValidVector(val) || val.y < -100f)
		{
			val = Vector3.zero;
		}
		value.dead = false;
		if (Server.clients != null && Server.clients.TryGetValue(id, out var value3) && value3?.player != null)
		{
			value3.player.dead = false;
		}
		if ((Object)(object)LocalClient.instance != (Object)null && LocalClient.instance.myId == id && (Object)(object)PlayerMovement.Instance != (Object)null)
		{
			((Component)PlayerMovement.Instance).transform.position = val + Vector3.up * 3f;
			((Component)PlayerMovement.Instance).gameObject.SetActive(true);
			PlayerStatus instance = PlayerStatus.Instance;
			if (instance != null)
			{
				instance.Respawn();
			}
		}
		else
		{
			((Component)value).gameObject.SetActive(true);
		}
		return false;
	}
}
[HarmonyPatch(typeof(MoveCamera), "SpectateCamera")]
internal static class EnhancedSpectateCameraPatch
{
	private static bool Prefix(MoveCamera __instance, ref Transform ___target, ref Transform ___playerTarget, ref int ___spectatingId, ref Vector3 ___desiredSpectateRotation, ref float ___desiredX, ref float ___yRotation)
	{
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: 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_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0223: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: 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_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_024f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0254: Unknown result type (might be due to invalid IL or missing references)
		//IL_025e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_026b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0275: Unknown result type (might be due to invalid IL or missing references)
		//IL_0277: Unknown result type (might be due to invalid IL or missing references)
		//IL_0278: Unknown result type (might be due to invalid IL or missing references)
		//IL_027a: Unknown result type (might be due to invalid IL or missing references)
		//IL_027f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_028e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0293: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_0297: Unknown result type (might be due to invalid IL or missing references)
		//IL_0298: Unknown result type (might be due to invalid IL or missing references)
		//IL_029d: Unknown result type (might be due to invalid IL or missing references)
		//IL_029f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: 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_0315: Unknown result type (might be due to invalid IL or missing references)
		//IL_031a: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02da: Unknown result type (might be due to invalid IL or missing references)
		//IL_02df: Unknown result type (might be due to invalid IL or missing references)
		//IL_0336: Unknown result type (might be due to invalid IL or missing references)
		//IL_033b: Unknown result type (might be due to invalid IL or missing references)
		//IL_033d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0342: Unknown result type (might be due to invalid IL or missing references)
		//IL_0352: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.EnableEnhancedSpectator.Value)
		{
			return true;
		}
		if (Input.GetKeyDown((KeyCode)102))
		{
			__instance.state = (CameraState)3;
			Vector3 eulerAngles = ((Component)__instance).transform.eulerAngles;
			___desiredX = eulerAngles.y;
			___yRotation = ((eulerAngles.x > 180f) ? (eulerAngles.x - 360f) : eulerAngles.x);
			___target = null;
			___playerTarget = null;
			SpectatorFix.SetTargetName(null);
			return false;
		}
		PlayerManager value;
		PlayerManager val = ((GameManager.players != null && GameManager.players.TryGetValue(___spectatingId, out value) && SpectatorFix.Valid(value)) ? value : SpectatorFix.Select(___spectatingId, 1));
		if (Input.GetKeyDown(InputManager.rightClick))
		{
			val = SpectatorFix.Select(val?.id ?? ___spectatingId, 1);
		}
		else if (Input.GetKeyDown(InputManager.leftClick))
		{
			val = SpectatorFix.Select(val?.id ?? ___spectatingId, -1);
		}
		if ((Object)(object)val == (Object)null)
		{
			__instance.state = (CameraState)3;
			Vector3 eulerAngles2 = ((Component)__instance).transform.eulerAngles;
			___desiredX = eulerAngles2.y;
			___yRotation = ((eulerAngles2.x > 180f) ? (eulerAngles2.x - 360f) : eulerAngles2.x);
			SpectatorFix.SetTargetName(null);
			return false;
		}
		___spectatingId = val.id;
		___target = ((Component)val).transform;
		___playerTarget = ((Component)val).transform;
		((Component)__instance).transform.parent = null;
		SpectatorFix.SetTargetName(val);
		if (!SpectatorFix.RotationReady)
		{
			Vector3 eulerAngles3 = ((Component)__instance).transform.eulerAngles;
			___desiredSpectateRotation = new Vector3((eulerAngles3.x > 180f) ? (eulerAngles3.x - 360f) : eulerAngles3.x, eulerAngles3.y, 0f);
			SpectatorFix.RotationReady = true;
		}
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y"));
		___desiredSpectateRotation += new Vector3(0f - val2.y, val2.x, 0f) * 1.5f;
		___desiredSpectateRotation.x = Mathf.Clamp(___desiredSpectateRotation.x, -80f, 80f);
		SpectatorFix.OrbitDistance -= Input.mouseScrollDelta.y;
		Vector3 val3 = (((Object)(object)val.spectateOrbit != (Object)null) ? val.spectateOrbit : ((Component)val).transform).position + Vector3.up * 1.2f;
		Quaternion val4 = Quaternion.Euler(___desiredSpectateRotation);
		Vector3 val5 = val3 - val4 * Vector3.forward * SpectatorFix.OrbitDistance;
		Vector3 val6 = val5 - val3;
		RaycastHit val7 = default(RaycastHit);
		if (Physics.Raycast(val3, ((Vector3)(ref val6)).normalized, ref val7, ((Vector3)(ref val6)).magnitude, LayerMask.op_Implicit(__instance.whatIsGround)))
		{
			val5 = ((RaycastHit)(ref val7)).point + ((RaycastHit)(ref val7)).normal * 0.35f;
		}
		((Component)__instance).transform.position = Vector3.Lerp(((Component)__instance).transform.position, val5, Time.deltaTime * 12f);
		Vector3 val8 = val3 - ((Component)__instance).transform.position;
		if (((Vector3)(ref val8)).sqrMagnitude > 0.001f)
		{
			((Component)__instance).transform.rotation = Quaternion.Lerp(((Component)__instance).transform.rotation, Quaternion.LookRotation(val8, Vector3.up), Time.deltaTime * 14f);
		}
		return false;
	}
}
[HarmonyPatch(typeof(MoveCamera), "FreeCam")]
internal static class EnhancedFreeCameraPatch
{
	private static bool Prefix(MoveCamera __instance, ref Transform ___target, ref Transform ___playerTarget, ref float ___desiredX, ref float ___yRotation, ref Vector3 ___cameraRot)
	{
		//IL_00ca: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: 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_00fd: 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_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: 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_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: 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_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0139: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_015e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: Unknown result type (might be due to invalid IL or missing references)
		//IL_0176: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_019c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.EnableEnhancedSpectator.Value)
		{
			return true;
		}
		SpectatorFix.SetTargetName(null);
		if (Input.GetKeyDown((KeyCode)102) && (Object)(object)SpectatorFix.Select(-1, 1) != (Object)null)
		{
			___target = null;
			___playerTarget = null;
			SpectatorFix.RotationReady = false;
			__instance.state = (CameraState)2;
			return false;
		}
		float num = (((Object)(object)__instance.playerInput != (Object)null) ? (__instance.playerInput.sensitivity * 0.02f * PlayerInput.sensMultiplier) : 1f);
		float num2 = Input.GetAxis("Mouse X") * num;
		float num3 = Input.GetAxis("Mouse Y") * num;
		if (CurrentSettings.invertedHor)
		{
			num2 = 0f - num2;
		}
		if (CurrentSettings.invertedVer)
		{
			num3 = 0f - num3;
		}
		___desiredX += num2;
		___yRotation = Mathf.Clamp(___yRotation - num3, -90f, 90f);
		___cameraRot = new Vector3(___yRotation, ___desiredX, 0f);
		((Component)__instance).transform.rotation = Quaternion.Euler(___cameraRot);
		Vector3 val = Vector3.zero;
		if (Input.GetKey(InputManager.forward))
		{
			val += ((Component)__instance).transform.forward;
		}
		if (Input.GetKey(InputManager.backwards))
		{
			val -= ((Component)__instance).transform.forward;
		}
		if (Input.GetKey(InputManager.right))
		{
			val += ((Component)__instance).transform.right;
		}
		if (Input.GetKey(InputManager.left))
		{
			val -= ((Component)__instance).transform.right;
		}
		if (Input.GetKey(InputManager.jump))
		{
			val += Vector3.up;
		}
		if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)99))
		{
			val -= Vector3.up;
		}
		float num4 = (Input.GetKey(InputManager.sprint) ? 60f : 15f);
		if (((Vector3)(ref val)).sqrMagnitude > 0.001f)
		{
			Transform transform = ((Component)__instance).transform;
			transform.position += ((Vector3)(ref val)).normalized * num4 * Time.unscaledDeltaTime;
		}
		return false;
	}
}
internal static class NativeMenuIntegration
{
	private const string PublicServersButtonName = "Muck Replayable Public Servers";

	private const string PrivateServersButtonName = "Muck Replayable Private Servers";

	private const string WorldsButtonName = "Muck Replayable Worlds";

	private const string PausePublicButtonName = "Muck Replayable Open Public";

	private const string PausePrivateButtonName = "Muck Replayable Open Private";

	private static Button pausePublicButton;

	private static Button pausePrivateButton;

	private static TMP_Text pausePublicLabel;

	private static TMP_Text pausePrivateLabel;

	private static MenuUI appliedMainMenu;

	private static GameObject appliedPauseRoot;

	internal static void ResetSceneState()
	{
		appliedMainMenu = null;
		appliedPauseRoot = null;
		pausePublicButton = null;
		pausePrivateButton = null;
		pausePublicLabel = null;
		pausePrivateLabel = null;
	}

	internal static void Apply()
	{
		ApplyMainMenu();
		ApplyPauseMenu();
	}

	internal static void RefreshPauseButton()
	{
		if (!((Object)(object)pausePublicButton == (Object)null) && !((Object)(object)pausePrivateButton == (Object)null) && !((Object)(object)pausePublicLabel == (Object)null) && !((Object)(object)pausePrivateLabel == (Object)null))
		{
			bool flag = LocalClient.serverOwner && (Object)(object)GameManager.instance != (Object)null;
			((Component)pausePublicButton).gameObject.SetActive(flag);
			((Component)pausePrivateButton).gameObject.SetActive(flag);
			if (flag)
			{
				pausePublicLabel.text = (LateJoinService.IsPublic ? "Close Public" : "Open Public");
				pausePrivateLabel.text = (LateJoinService.IsPrivate ? "Close Private" : "Open Private");
				ConfigureOneLine(pausePublicLabel);
				ConfigureOneLine(pausePrivateLabel);
			}
		}
	}

	private static void ApplyMainMenu()
	{
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0184: Unknown result type (might be due to invalid IL or missing references)
		MenuUI val = Object.FindObjectOfType<MenuUI>();
		if ((Object)(object)val?.mainUi == (Object)null || (Object)(object)ReforgedRuntime.Instance == (Object)null || (Object)(object)appliedMainMenu == (Object)(object)val)
		{
			return;
		}
		Transform[] componentsInChildren = val.mainUi.GetComponentsInChildren<Transform>(true);
		Transform val2 = ((IEnumerable<Transform>)componentsInChildren).FirstOrDefault((Func<Transform, bool>)((Transform value) => ((Object)value).name == "Buttons"));
		Transform? obj = ((IEnumerable<Transform>)componentsInChildren).FirstOrDefault((Func<Transform, bool>)((Transform value) => ((Object)value).name == "MultiplayerButton"));
		Button val3 = ((obj != null) ? ((Component)obj).GetComponent<Button>() : null);
		if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
		{
			return;
		}
		Transform val4 = ((IEnumerable<Transform>)componentsInChildren).FirstOrDefault((Func<Transform, bool>)((Transform value) => ((Object)value).name == "JoinBtn"));
		if ((Object)(object)val4 != (Object)null)
		{
			((Component)val4).gameObject.SetActive(false);
		}
		Button val5 = CreateMainButton(val2, val3, "Muck Replayable Public Servers", "Public Servers", new Vector2(165f, -122f), delegate
		{
			ReforgedRuntime.Instance.OpenPanel(0);
		});
		Button val6 = CreateMainButton(val2, val3, "Muck Replayable Private Servers", "Private / Friends", new Vector2(165f, -208f), delegate
		{
			ReforgedRuntime.Instance.OpenPanel(1);
		});
		Button obj2 = CreateMainButton(val2, val3, "Muck Replayable Worlds", "Worlds", new Vector2(165f, -294f), delegate
		{
			ReforgedRuntime.Instance.OpenPanel(2);
		});
		MoveButton(componentsInChildren, "Settings", -380f);
		MoveButton(componentsInChildren, "Achievements", -466f);
		MoveButton(componentsInChildren, "About", -552f);
		MoveButton(componentsInChildren, "Quit", -638f);
		((Component)val5).transform.SetAsLastSibling();
		((Component)val6).transform.SetAsLastSibling();
		((Component)obj2).transform.SetAsLastSibling();
		string[] array = new string[4] { "Settings", "Achievements", "About", "Quit" };
		foreach (string name in array)
		{
			Transform val7 = ((IEnumerable<Transform>)componentsInChildren).FirstOrDefault((Func<Transform, bool>)((Transform value) => ((Object)value).name == name));
			if ((Object)(object)val7 != (Object)null)
			{
				val7.SetAsLastSibling();
			}
		}
		appliedMainMenu = val;
	}

	private static Button CreateMainButton(Transform parent, Button template, string objectName, string label, Vector2 anchoredPosition, Action action)
	{
		//IL_005c: 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_0090: Expected O, but got Unknown
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Expected O, but got Unknown
		Transform val = parent.Find(objectName);
		Button val2 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<Button>() : null);
		if ((Object)(object)val2 == (Object)null)
		{
			val2 = Object.Instantiate<Button>(template, parent);
			((Object)((Component)val2).gameObject).name = objectName;
		}
		Transform transform = ((Component)val2).transform;
		RectTransform val3 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		if ((Object)(object)val3 != (Object)null)
		{
			val3.anchoredPosition = anchoredPosition;
		}
		TMP_Text componentInChildren = ((Component)val2).GetComponentInChildren<TMP_Text>(true);
		if ((Object)(object)componentInChildren != (Object)null)
		{
			componentInChildren.text = label;
			EnsureVisibleLabel(componentInChildren);
		}
		val2.onClick = new ButtonClickedEvent();
		((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
		{
			action();
		});
		((Component)val2).gameObject.SetActive(true);
		return val2;
	}

	private static void MoveButton(Transform[] all, string name, float y)
	{
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		Transform? obj = ((IEnumerable<Transform>)all).FirstOrDefault((Func<Transform, bool>)((Transform value) => ((Object)value).name == name));
		RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
		if (!((Object)(object)val == (Object)null))
		{
			Vector2 anchoredPosition = val.anchoredPosition;
			anchoredPosition.y = y;
			val.anchoredPosition = anchoredPosition;
		}
	}

	private static void ApplyPauseMenu()
	{
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Expected O, but got Unknown
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Expected O, but got Unknown
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_0272: Expected O, but got Unknown
		//IL_0283: Unknown result type (might be due to invalid IL or missing references)
		//IL_028d: Expected O, but got Unknown
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		OtherInput instance = OtherInput.Instance;
		if ((Object)(object)instance?.pauseUi == (Object)null)
		{
			return;
		}
		Transform transform = instance.pauseUi.transform;
		if ((Object)(object)appliedPauseRoot == (Object)(object)((Component)transform).gameObject && (Object)(object)pausePublicButton != (Object)null && (Object)(object)pausePrivateButton != (Object)null)
		{
			RefreshPauseButton();
			return;
		}
		Button val = ((IEnumerable<Button>)((Component)transform).GetComponentsInChildren<Button>(true)).FirstOrDefault((Func<Button, bool>)((Button value) => ((Object)value).name == "ResumeBtn"));
		Button val2 = ((IEnumerable<Button>)((Component)transform).GetComponentsInChildren<Button>(true)).FirstOrDefault((Func<Button, bool>)((Button value) => ((Object)value).name == "LeaveBtn"));
		if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
		{
			Transform val3 = transform.Find("Muck Replayable Open Public");
			pausePublicButton = (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponent<Button>() : null);
			if ((Object)(object)pausePublicButton == (Object)null)
			{
				pausePublicButton = Object.Instantiate<Button>(val, transform);
				((Object)((Component)pausePublicButton).gameObject).name = "Muck Replayable Open Public";
			}
			Transform val4 = transform.Find("Muck Replayable Open Private");
			pausePrivateButton = (((Object)(object)val4 != (Object)null) ? ((Component)val4).GetComponent<Button>() : null);
			if ((Object)(object)pausePrivateButton == (Object)null)
			{
				pausePrivateButton = Object.Instantiate<Button>(val, transform);
				((Object)((Component)pausePrivateButton).gameObject).name = "Muck Replayable Open Private";
			}
			Button? obj = ((IEnumerable<Button>)((Component)transform).GetComponentsInChildren<Button>(true)).FirstOrDefault((Func<Button, bool>)((Button value) => ((Object)value).name.IndexOf("Settings", StringComparison.OrdinalIgnoreCase) >= 0));
			SetPausePosition(val, -390f);
			SetPausePosition(obj, -462f);
			SetPausePosition(pausePublicButton, -534f);
			SetPausePosition(pausePrivateButton, -606f);
			SetPausePosition(val2, -678f);
			Transform transform2 = ((Component)pausePublicButton).transform;
			RectTransform val5 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			if ((Object)(object)val5 != (Object)null)
			{
				val5.anchoredPosition = new Vector2(960f, -534f);
			}
			pausePublicLabel = ((Component)pausePublicButton).GetComponentInChildren<TMP_Text>(true);
			pausePrivateLabel = ((Component)pausePrivateButton).GetComponentInChildren<TMP_Text>(true);
			EnsureVisibleLabel(pausePublicLabel);
			EnsureVisibleLabel(pausePrivateLabel);
			pausePublicButton.onClick = new ButtonClickedEvent();
			((UnityEvent)pausePublicButton.onClick).AddListener(new UnityAction(TogglePublicGame));
			pausePrivateButton.onClick = new ButtonClickedEvent();
			((UnityEvent)pausePrivateButton.onClick).AddListener(new UnityAction(TogglePrivateGame));
			((Component)val).transform.SetAsLastSibling();
			if (obj != null)
			{
				((Component)obj).transform.SetAsLastSibling();
			}
			((Component)pausePublicButton).transform.SetAsLastSibling();
			((Component)pausePrivateButton).transform.SetAsLastSibling();
			((Component)val2).transform.SetAsLastSibling();
			appliedPauseRoot = ((Component)transform).gameObject;
			RefreshPauseButton();
		}
	}

	private static void SetPausePosition(Button button, float y)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		RectTransform val = (RectTransform)(((Object)(object)button != (Object)null) ? /*isinst with value type is only supported in some contexts*/: null);
		if ((Object)(object)val != (Object)null)
		{
			val.anchoredPosition = new Vector2(960f, y);
		}
	}

	private static void ConfigureOneLine(TMP_Text text)
	{
		if (!((Object)(object)text == (Object)null))
		{
			text.enableWordWrapping = false;
			text.overflowMode = (TextOverflowModes)0;
		}
	}

	private static void EnsureVisibleLabel(TMP_Text text)
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)text == (Object)null))
		{
			((Component)text).gameObject.SetActive(true);
			((Behaviour)text).enabled = true;
			Color color = ((Graphic)text).color;
			color.a = 1f;
			if (((Color)(ref color)).maxColorComponent < 0.35f)
			{
				((Color)(ref color))..ctor(1f, 0.66f, 0.38f, 1f);
			}
			((Graphic)text).color = color;
			text.fontSize = ((text.text != null && text.text.Length > 15) ? 30f : ((text.text != null && text.text.Length > 11) ? 34f : Mathf.Clamp(text.fontSize, 24f, 40f)));
			ConfigureOneLine(text);
			((Graphic)text).canvasRenderer.cull = false;
			((Graphic)text).SetLayoutDirty();
			((Graphic)text).SetVerticesDirty();
			text.ForceMeshUpdate(true, true);
		}
	}

	private static void TogglePublicGame()
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		if (!LocalClient.serverOwner || (Object)(object)SteamManager.Instance == (Object)null || (Object)(object)GameManager.instance == (Object)null)
		{
			return;
		}
		Lobby currentLobby = SteamManager.Instance.currentLobby;
		if (((Lobby)(ref currentLobby)).Id.Value == 0L)
		{
			ReforgedRuntime.Instance?.Notify("No Steam lobby is available for this run.", 6f);
			return;
		}
		if (LateJoinService.IsPublic)
		{
			LateJoinService.ClosePublicGame(currentLobby);
		}
		else
		{
			LateJoinService.OpenPublicGame(currentLobby);
		}
		RefreshPauseButton();
	}

	private static void TogglePrivateGame()
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		if (!LocalClient.serverOwner || (Object)(object)SteamManager.Instance == (Object)null || (Object)(object)GameManager.instance == (Object)null)
		{
			return;
		}
		Lobby currentLobby = SteamManager.Instance.currentLobby;
		if (((Lobby)(ref currentLobby)).Id.Value != 0L)
		{
			if (LateJoinService.IsPrivate)
			{
				LateJoinService.ClosePublicGame(currentLobby);
			}
			else
			{
				LateJoinService.OpenPrivateGame(currentLobby);
			}
			RefreshPauseButton();
		}
	}
}
internal static class InteractionGuard
{
	private static readonly Dictionary<int, int> ChestUsers = new Dictionary<int, int>();

	internal static bool TryPlayer(int clientId, out PlayerManager player)
	{
		player = null;
		if (Server.clients != null && Server.clients.TryGetValue(clientId, out var value) && value?.player != null && GameManager.players != null && GameManager.players.TryGetValue(clientId, out player) && (Object)(object)player != (Object)null)
		{
			return !player.dead;
		}
		return false;
	}

	internal static bool InRange(PlayerManager player, Vector3 position, float distance)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player != (Object)null && PacketSanitizer.ValidVector(position))
		{
			return Vector3.Distance(((Component)player).transform.position, position) <= distance;
		}
		return false;
	}

	internal static Packet SingleInt(int value)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Expected O, but got Unknown
		Packet val = new Packet();
		val.Write(value);
		val.ToArray();
		return val;
	}

	internal static void Reset()
	{
		ChestUsers.Clear();
	}

	internal static bool CanUseChest(int chestId, int playerId)
	{
		if (ChestUsers.TryGetValue(chestId, out var value))
		{
			return value == playerId;
		}
		return false;
	}

	internal static bool TryOpenChest(int chestId, int playerId)
	{
		if (ChestUsers.TryGetValue(chestId, out var value))
		{
			if (Server.clients != null && Server.clients.TryGetValue(value, out var value2) && value2?.player != null)
			{
				return value == playerId;
			}
			ChestUsers.Remove(chestId);
			if (ChestManager.Instance?.chests != null && ChestManager.Instance.chests.ContainsKey(chestId))
			{
				ChestManager.Instance.UseChest(chestId, false);
			}
		}
		ChestUsers[chestId] = playerId;
		return true;
	}

	internal static void CloseChest(int chestId, int playerId)
	{
		if (ChestUsers.TryGetValue(chestId, out var value) && value == playerId)
		{
			ChestUsers.Remove(chestId);
		}
	}

	internal static void ReleasePlayer(int playerId)
	{
		int[] array = (from pair in ChestUsers
			where pair.Value == playerId
			select pair.Key).ToArray();
		foreach (int num2 in array)
		{
			ChestUsers.Remove(num2);
			if (ChestManager.Instance?.chests != null && ChestManager.Instance.chests.ContainsKey(num2))
			{
				ChestManager.Instance.UseChest(num2, false);
				ServerSend.OpenChest(playerId, num2, false);
			}
		}
	}
}
[HarmonyPatch(typeof(ServerHandle), "ItemDroppedAtPosition")]
internal static class FixDroppedItemIdPatch
{
	private static bool Prefix(int fromClient, Packet packet)
	{
		//IL_0037: 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_0085: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || ItemManager.Instance?.allItems == null)
			{
				return false;
			}
			int num = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			Vector3 val = packet.ReadVector3(true);
			if (!ItemManager.Instance.allItems.TryGetValue(num, out var value) || (Object)(object)value == (Object)null)
			{
				return false;
			}
			num2 = Mathf.Clamp(num2, 1, Mathf.Max(1, (!value.stackable) ? 1 : value.max));
			if (!InteractionGuard.InRange(player, val, 15f))
			{
				val = ((Component)player).transform.position + Vector3.up;
			}
			int nextId = ItemManager.Instance.GetNextId();
			ItemManager.Instance.DropItemAtPosition(num, num2, val, nextId);
			ServerSend.DropItemAtPosition(num, num2, nextId, val);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed positioned item drop from {fromClient}: {ex.Message}");
		}
		return false;
	}
}
[HarmonyPatch(typeof(ServerHandle), "ItemDropped")]
internal static class ValidateDroppedItemPatch
{
	private static bool Prefix(int fromClient, Packet packet)
	{
		try
		{
			if (!InteractionGuard.TryPlayer(fromClient, out var _) || ItemManager.Instance?.allItems == null)
			{
				return false;
			}
			int num = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			if (!ItemManager.Instance.allItems.TryGetValue(num, out var value) || (Object)(object)value == (Object)null)
			{
				return false;
			}
			num2 = Mathf.Clamp(num2, 1, Mathf.Max(1, (!value.stackable) ? 1 : value.max));
			int nextId = ItemManager.Instance.GetNextId();
			ItemManager.Instance.DropItem(fromClient, num, num2, nextId);
			ServerSend.DropItem(fromClient, num, num2, nextId);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed item drop from {fromClient}: {ex.Message}");
		}
		return false;
	}
}
[HarmonyPatch(typeof(ServerHandle), "ItemPickedUp")]
internal static class FixItemPickupPatch
{
	private static bool Prefix(int fromClient, Packet packet)
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			int num = packet.ReadInt(true);
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || ItemManager.Instance?.list == null || !ItemManager.Instance.list.TryGetValue(num, out var value) || (Object)(object)value == (Object)null || !InteractionGuard.InRange(player, value.transform.position, 15f))
			{
				return false;
			}
			Item component = value.GetComponent<Item>();
			if ((Object)(object)component == (Object)null || ((Object)(object)component.item == (Object)null && (Object)(object)component.powerup == (Object)null))
			{
				return false;
			}
			Player player2 = Server.clients[fromClient].player;
			if ((Object)(object)component.powerup != (Object)null)
			{
				int id = component.powerup.id;
				if (id < 0 || id >= player2.powerups.Length)
				{
					return false;
				}
				player2.powerups[id]++;
				if ((Object)(object)GameManager.instance != (Object)null)
				{
					GameManager.instance.powerupsPickedup = true;
				}
				if (player2.stats != null)
				{
					player2.stats.TryGetValue("Powerups", out var value2);
					player2.stats["Powerups"] = value2 + 1;
				}
			}
			if ((Object)(object)LocalClient.instance != (Object)null && fromClient == LocalClient.instance.myId)
			{
				if ((Object)(object)component.item != (Object)null)
				{
					InventoryUI.Instance.AddItemToInventory(component.item);
				}
				else
				{
					PowerupInventory.Instance.AddPowerup(component.powerup.name, component.powerup.id, num);
				}
			}
			ItemManager.Instance.PickupItem(num);
			ServerSend.PickupItem(fromClient, num);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed pickup from {fromClient}: {ex.Message}");
		}
		return false;
	}
}
[HarmonyPatch(typeof(ClientHandle), "PickupItem")]
internal static class SafeClientPickupPatch
{
	private static bool Prefix(Packet packet)
	{
		int num;
		int num2;
		try
		{
			num = packet.ReadInt(true);
			num2 = packet.ReadInt(true);
		}
		catch
		{
			return false;
		}
		if (ItemManager.Instance?.list == null || !ItemManager.Instance.list.TryGetValue(num2, out var value) || (Object)(object)value == (Object)null)
		{
			return false;
		}
		Item component = value.GetComponent<Item>();
		if ((Object)(object)component == (Object)null)
		{
			return false;
		}
		if ((Object)(object)component.powerup != (Object)null && (Object)(object)GameManager.instance != (Object)null)
		{
			GameManager.instance.powerupsPickedup = true;
		}
		if ((Object)(object)LocalClient.instance != (Object)null && LocalClient.instance.myId == num && !LocalClient.serverOwner)
		{
			if ((Object)(object)component.item != (Object)null)
			{
				InventoryUI.Instance.AddItemToInventory(component.item);
			}
			else if ((Object)(object)component.powerup != (Object)null)
			{
				PowerupInventory.Instance.AddPowerup(component.powerup.name, component.powerup.id, num2);
			}
		}
		if (!LocalClient.serverOwner && ItemManager.Instance.list.ContainsKey(num2))
		{
			ItemManager.Instance.PickupItem(num2);
		}
		return false;
	}
}
[HarmonyPatch(typeof(ServerHandle), "ItemInteract")]
internal static class ValidatePickupInteractionPatch
{
	private static bool Prefix(int fromClient, ref Packet packet)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			int num = packet.ReadInt(true);
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.TryGetValue(num, out var value) || (Object)(object)value == (Object)null || !InteractionGuard.InRange(player, value.transform.position, 15f) || value.GetComponentInChildren<Interactable>() == null)
			{
				return false;
			}
			packet = InteractionGuard.SingleInt(num);
			return true;
		}
		catch
		{
			return false;
		}
	}
}
[HarmonyPatch(typeof(ServerHandle), "Interact")]
internal static class ValidateGeneralInteractionPatch
{
	private static bool Prefix(int fromClient, ref Packet packet)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			int num = packet.ReadInt(true);
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.TryGetValue(num, out var value) || (Object)(object)value == (Object)null || !InteractionGuard.InRange(player, value.transform.position, 20f) || value.GetComponentInChildren<Interactable>() == null)
			{
				return false;
			}
			packet = InteractionGuard.SingleInt(num);
			return true;
		}
		catch
		{
			return false;
		}
	}
}
[HarmonyPatch(typeof(ClientHandle), "PickupInteract")]
internal static class FixMultiplayerDoorInteractionPatch
{
	private static bool Prefix(Packet packet)
	{
		int num;
		int num2;
		try
		{
			num = packet.ReadInt(true);
			num2 = packet.ReadInt(true);
		}
		catch
		{
			return false;
		}
		if (ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.TryGetValue(num2, out var value) || (Object)(object)value == (Object)null)
		{
			return false;
		}
		Interactable componentInChildren = value.GetComponentInChildren<Interactable>();
		if (componentInChildren == null)
		{
			return false;
		}
		componentInChildren.AllExecute();
		if ((Object)(object)LocalClient.instance != (Object)null && LocalClient.instance.myId == num && !LocalClient.serverOwner)
		{
			componentInChildren.LocalExecute();
		}
		if (!LocalClient.serverOwner && !(componentInChildren is DoorInteractable) && ResourceManager.Instance.list.ContainsKey(num2))
		{
			ResourceManager.Instance.RemoveInteractItem(num2);
		}
		return false;
	}
}
[HarmonyPatch(typeof(ServerHandle), "RequestChest")]
internal static class GuardChestOpenPatch
{
	private static bool Prefix(int fromClient, Packet packet)
	{
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			int num = packet.ReadInt(true);
			bool flag = packet.ReadBool(true);
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || ChestManager.Instance?.chests == null || !ChestManager.Instance.chests.TryGetValue(num, out var value) || (Object)(object)value == (Object)null)
			{
				return false;
			}
			if (!flag)
			{
				if (InteractionGuard.CanUseChest(num, fromClient))
				{
					InteractionGuard.CloseChest(num, fromClient);
					ChestManager.Instance.UseChest(num, false);
					ServerSend.OpenChest(fromClient, num, false);
				}
				return false;
			}
			if (!InteractionGuard.InRange(player, ((Component)value).transform.position, 15f))
			{
				return false;
			}
			if (flag)
			{
				if (ChestManager.Instance.IsChestOpen(num) && !InteractionGuard.CanUseChest(num, fromClient))
				{
					return false;
				}
				if (!InteractionGuard.TryOpenChest(num, fromClient))
				{
					return false;
				}
				ChestManager.Instance.UseChest(num, true);
				ServerSend.OpenChest(fromClient, num, true);
				ChestInteract component = ((Component)value).GetComponent<ChestInteract>();
				if (component != null)
				{
					component.ServerExecute(fromClient);
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed chest request from {fromClient}: {ex.Message}");
		}
		return false;
	}
}
[HarmonyPatch(typeof(ServerHandle), "UpdateChest")]
internal static class GuardChestUpdatePatch
{
	private static bool Prefix(int fromClient, Packet packet)
	{
		try
		{
			int num = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			int num3 = packet.ReadInt(true);
			int num4 = packet.ReadInt(true);
			if (!InteractionGuard.CanUseChest(num, fromClient) || ChestManager.Instance?.chests == null || !ChestManager.Instance.chests.TryGetValue(num, out var value) || value?.cells == null || num2 < 0 || num2 >= value.cells.Length)
			{
				return false;
			}
			if (num3 == -1)
			{
				num4 = 0;
			}
			else
			{
				if (ItemManager.Instance?.allItems == null || !ItemManager.Instance.allItems.TryGetValue(num3, out var value2) || (Object)(object)value2 == (Object)null)
				{
					return false;
				}
				num4 = Mathf.Clamp(num4, 1, Mathf.Max(1, (!value2.stackable) ? 1 : value2.max));
			}
			ChestManager.Instance.UpdateChest(num, num2, num3, num4);
			ServerSend.UpdateChest(fromClient, num, num2, num3, num4);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed chest update from {fromClient}: {ex.Message}");
		}
		return false;
	}
}
[HarmonyPatch(typeof(ServerHandle), "DisconnectPlayer")]
internal static class ReleaseDisconnectedChestPatch
{
	private static void Prefix(int fromClient)
	{
		InteractionGuard.ReleasePlayer(fromClient);
	}
}
[HarmonyPatch(typeof(ServerHandle), "KickPlayer")]
internal static class ReleaseKickedChestPatch
{
	private static void Prefix(int client)
	{
		InteractionGuard.ReleasePlayer(client);
	}
}
[HarmonyPatch(typeof(ServerHandle), "ReceiveArmor")]
internal static class ValidateArmorPatch
{
	private static bool Prefix(int fromClient, Packet packet)
	{
		try
		{
			if (Server.clients == null || !Server.clients.TryGetValue(fromClient, out var value) || value?.player == null)
			{
				return false;
			}
			int num = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			if (num < 0 || num >= 4)
			{
				return false;
			}
			if (num2 >= 0 && (ItemManager.Instance?.allItems == null || !ItemManager.Instance.allItems.TryGetValue(num2, out var value2) || (Object)(object)value2 == (Object)null || !value2.IsArmour()))
			{
				return false;
			}
			value.player.UpdateArmor(num, num2);
			ServerSend.SendArmor(fromClient, num, num2);
		}
		catch
		{
		}
		return false;
	}
}
[HarmonyPatch(typeof(ClientHandle), "PlayerHitObject")]
internal static class SafeClientResourceHitPatch
{
	private static bool Prefix(Packet packet)
	{
		//IL_0022: 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_0030: 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_0083: Invalid comparison between Unknown and I4
		//IL_00a7: 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_0088: Invalid comparison between Unknown and I4
		try
		{
			int num = packet.ReadInt(true);
			int key = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			int num3 = packet.ReadInt(true);
			Vector3 val = packet.ReadVector3(true);
			WeaponHitType val2 = (WeaponHitType)packet.ReadInt(true);
			if (ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.TryGetValue(key, out var value) || (Object)(object)value == (Object)null)
			{
				return false;
			}
			Hitable component = value.GetComponent<Hitable>();
			if ((Object)(object)component == (Object)null)
			{
				return false;
			}
			if ((int)val2 != 2 && (int)val2 != -1 && (Object)(object)GameManager.instance != (Object)null)
			{
				GameManager.instance.onlyRock = false;
			}
			component.Damage(num2, num, num3, val);
		}
		catch
		{
		}
		return false;
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class ResetInteractionGuardsPatch
{
	private static void Prefix()
	{
		InteractionGuard.Reset();
	}
}
[HarmonyPatch(typeof(LootContainerInteract), "OpenContainer")]
internal static class RemoveOpenedLootContainerPatch
{
	private static void Postfix(LootContainerInteract __instance)
	{
		ResourceManager.Instance?.list?.Remove(__instance.GetId());
	}
}
[HarmonyPatch(typeof(ResourceManager), "RemoveItem")]
internal static class SafeResourceRemovalPatch
{
	[HarmonyPriority(800)]
	private static bool Prefix(ResourceManager __instance, int id)
	{
		if (__instance?.list != null)
		{
			return __instance.list.ContainsKey(id);
		}
		return false;
	}
}
[HarmonyPatch(typeof(ItemManager), "PickupItem")]
internal static class SafeItemRemovalPatch
{
	private static bool Prefix(ItemManager __instance, int objectID, ref bool __result)
	{
		if (__instance?.list != null && __instance.list.ContainsKey(objectID))
		{
			return true;
		}
		__result = false;
		return false;
	}
}
[HarmonyPatch(typeof(ClientSend), "PlayerDisconnect")]
internal static class SafeHostDisconnectPacketPatch
{
	private static bool Prefix()
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)LocalClient.instance == (Object)null || (Object)(object)SteamManager.Instance == (Object)null)
		{
			return false;
		}
		if (!LocalClient.serverOwner)
		{
			return true;
		}
		if (SteamLobby.steamIdToClientId != null)
		{
			return SteamLobby.steamIdToClientId.ContainsKey(SteamManager.Instance.PlayerSteamId.Value);
		}
		return false;
	}
}
internal enum ReforgedMobKind
{
	GoblinRider,
	CaveStalker,
	BombGoblin,
	StormShaman,
	CrystalGolem,
	EmberWyvern,
	AncientWarden
}
internal sealed class ReforgedMobDefinition
{
	internal ReforgedMobKind Kind;

	internal string Name;

	internal Func<MobType[], MobType> FindBase;

	internal int DayStart;

	internal int DayPeak;

	internal float MaxWeight;

	internal float StatMultiplier;

	internal float SpeedMultiplier;

	internal float RangedCooldownMultiplier = 1f;

	internal bool Animal;

	internal bool Boss;
}
internal static class NewMonsterRegistry
{
	private static readonly Dictionary<int, ReforgedMobDefinition> ById = new Dictionary<int, ReforgedMobDefinition>();

	private static readonly Dictionary<ReforgedMobKind, MobType> ByKind = new Dictionary<ReforgedMobKind, MobType>();

	private static MobSpawner installedSpawner;

	private static readonly ReforgedMobDefinition[] Definitions = new ReforgedMobDefinition[7]
	{
		Enemy(ReforgedMobKind.GoblinRider, "Goblin Raptor Rider", FindDino, 2, 6, 0.22f, 1.35f, 1.18f),
		Enemy(ReforgedMobKind.CaveStalker, "Cave Stalker", FindWolf, 2, 5, 0.2f, 1.18f, 1.24f),
		Enemy(ReforgedMobKind.BombGoblin, "Powder Goblin", FindGoblin, 4, 8, 0.14f, 1.48f, 0.92f),
		Enemy(ReforgedMobKind.StormShaman, "Storm Shaman", FindRangedGoblin, 5, 9, 0.14f, 1.36f, 0.94f, 0.66f),
		Enemy(ReforgedMobKind.CrystalGolem, "Crystal Golem", FindGolem, 6, 11, 0.12f, 1.72f, 0.8f),
		Enemy(ReforgedMobKind.EmberWyvern, "Ember Wyvern", FindWyvern, 7, 12, 0.1f, 1.42f, 1.12f, 0.82f),
		Boss(ReforgedMobKind.AncientWarden, "Ancient Warden", FindGuardian, 1.38f, 1.06f)
	};

	internal static bool TryGet(int id, out ReforgedMobDefinition definition)
	{
		return ById.TryGetValue(id, out definition);
	}

	internal static MobType Get(ReforgedMobKind kind)
	{
		ByKind.TryGetValue(kind, out var value);
		return value;
	}

	internal static void Install(MobSpawner spawner)
	{
		if ((Object)(object)spawner == (Object)null || spawner.allMobs == null || ((Object)(object)installedSpawner == (Object)(object)spawner && ById.Count > 0))
		{
			return;
		}
		installedSpawner = spawner;
		ById.Clear();
		ByKind.Clear();
		List<MobType> list = spawner.allMobs.Where((MobType type) => !IsReforgedClone(type)).ToList();
		MobType[] arg = list.Where((MobType type) => (Object)(object)type != (Object)null).ToArray();
		ReforgedMobDefinition[] definitions = Definitions;
		foreach (ReforgedMobDefinition reforgedMobDefinition in definitions)
		{
			MobType val = reforgedMobDefinition.FindBase(arg);
			if ((Object)(object)val == (Object)null || (Object)(object)val.mobPrefab == (Object)null)
			{
				Plugin.Log.LogWarning((object)("Skipped " + reforgedMobDefinition.Name + ": compatible vanilla model was not found."));
				continue;
			}
			MobType val2 = Object.Instantiate<MobType>(val);
			val2.name = reforgedMobDefinition.Name;
			((Object)val2).name = "MuckReforged_" + reforgedMobDefinition.Kind;
			val2.boss = reforgedMobDefinition.Boss;
			val2.speed = Mathf.Max(0.1f, val.speed * reforgedMobDefinition.SpeedMultiplier);
			val2.rangedCooldown = Mathf.Max(0.2f, val.rangedCooldown * reforgedMobDefinition.RangedCooldownMultiplier);
			val2.id = list.Count;
			list.Add(val2);
			ById.Add(val2.id, reforgedMobDefinition);
			ByKind.Add(reforgedMobDefinition.Kind, val2);
		}
		spawner.allMobs = list.ToArray();
		Plugin.Log.LogInfo((object)$"Registered {ById.Count} real Reforged mob types (total mob types: {spawner.allMobs.Length}).");
	}

	private static bool IsReforgedClone(MobType type)
	{
		if ((Object)(object)type == (Object)null)
		{
			return false;
		}
		return (((Object)type).name ?? string.Empty).StartsWith("MuckReforged_", StringComparison.Ordinal);
	}

	internal static void Install(GameLoop loop)
	{
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: 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_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Expected O, but got Unknown
		if (!Plugin.Settings.EnableNewMonsterTypes.Value || (Object)(object)loop == (Object)null || ById.Count == 0)
		{
			return;
		}
		List<MobSpawn> list = new List<MobSpawn>(loop.mobs ?? Array.Empty<MobSpawn>());
		foreach (ReforgedMobDefinition item in Definitions.Where((ReforgedMobDefinition value) => !value.Animal && !value.Boss))
		{
			MobType mob = Get(item.Kind);
			if (!((Object)(object)mob == (Object)null) && !list.Any((MobSpawn value) => (Object)(object)value?.mob == (Object)(object)mob))
			{
				list.Add(new MobSpawn
				{
					mob = mob,
					dayStart = item.DayStart,
					dayPeak = item.DayPeak,
					maxWeight = item.MaxWeight,
					currentWeight = 0f
				});
			}
		}
		loop.mobs = list.ToArray();
		MobType val = Get(ReforgedMobKind.AncientWarden);
		if ((Object)(object)val != (Object)null && !(loop.bosses ?? Array.Empty<MobType>()).Contains(val))
		{
			loop.bosses = (loop.bosses ?? Array.Empty<MobType>()).Concat((IEnumerable<MobType>)(object)new MobType[1] { val }).ToArray();
		}
		AccessTools.Method(typeof(GameLoop), "ResetBossRotations", (Type[])null, (Type[])null)?.Invoke(loop, null);
		Plugin.Log.LogInfo((object)$"Night roster expanded to {loop.mobs.Length}; boss rotation has {loop.bosses.Length} types.");
	}

	internal static void ApplySpawnedType(Mob mob, int requestedType)
	{
		if (!((Object)(object)mob == (Object)null) && MobSpawner.Instance?.allMobs != null && requestedType >= 0 && requestedType < MobSpawner.Instance.allMobs.Length)
		{
			if (!TryGet(requestedType, out var definition))
			{
				ContentVariants.Apply(mob);
			}
			else if (!((Object)(object)((Component)mob).GetComponent<ReforgedMobVisual>() != (Object)null))
			{
				mob.mobType = MobSpawner.Instance.allMobs[requestedType];
				mob.multiplier *= definition.StatMultiplier;
				((Component)mob).gameObject.AddComponent<ReforgedMobVisual>().Initialize(definition);
			}
		}
	}

	internal static void ReplaceAnimalZone(MobZone zone)
	{
	}

	internal static float Weight(MobSpawn spawn, int day)
	{
		if ((Object)(object)spawn?.mob == (Object)null || day < spawn.dayStart)
		{
			return 0f;
		}
		int num = Mathf.Max(1, spawn.dayPeak - spawn.dayStart + 1);
		float num2 = Mathf.Clamp01(((float)(day - spawn.dayStart) + 1f) / (float)num);
		float num3 = ((spawn.maxWeight > 0f) ? spawn.maxWeight : 1f);
		return num2 * num3;
	}

	private static uint StableHash(int seed, int id, string value)
	{
		uint num = 2166136261u;
		num = (num ^ (uint)seed) * 16777619;
		num = (num ^ (uint)id) * 16777619;
		foreach (char c in value)
		{
			num = (num ^ c) * 16777619;
		}
		return num;
	}

	private static bool Contains(string value, string part)
	{
		return value.IndexOf(part, StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static MobType Find(MobType[] all, Func<MobType, bool> predicate)
	{
		return ((IEnumerable<MobType>)all).FirstOrDefault((Func<MobType, bool>)((MobType type) => (Object)(object)type != (Object)null && predicate(type)));
	}

	private static MobType FindDino(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && (Contains(type.name, "lildave") || Contains(type.name, "lil dave"))) ?? Find(all, (MobType type) => !type.boss && (Contains(type.name, "dino") || Contains(type.name, "raptor") || Contains(type.name, "dave")));
	}

	private static MobType FindWolf(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && Contains(type.name, "wolf"));
	}

	private static MobType FindGoblin(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && Contains(type.name, "goblin"));
	}

	private static MobType FindRangedGoblin(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && Contains(type.name, "goblin") && (type.ranged || (int)type.behaviour == 2)) ?? FindGoblin(all);
	}

	private static MobType FindGolem(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && (Contains(type.name, "golem") || Contains(type.name, "rock") || Contains(type.name, "titan"))) ?? Find(all, (MobType type) => !type.boss && Contains(type.name, "chunk"));
	}

	private static MobType FindWyvern(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && (Contains(type.name, "wyvern") || Contains(type.name, "dragon")));
	}

	private static MobType FindCow(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && (int)type.behaviour == 0 && Contains(type.name, "cow"));
	}

	private static MobType FindBull(MobType[] all)
	{
		return Find(all, (MobType type) => !type.boss && (int)type.behaviour == 0 && Contains(type.name, "bull")) ?? FindCow(all);
	}

	private static MobType FindGuardian(MobType[] all)
	{
		return Find(all, (MobType type) => type.boss && Contains(type.name, "guardian")) ?? Find(all, (MobType type) => type.boss && (Contains(type.name, "gronk") || Contains(type.name, "chief"))) ?? Find(all, (MobType type) => type.boss);
	}

	private static ReforgedMobDefinition Enemy(ReforgedMobKind kind, string name, Func<MobType[], MobType> findBase, int dayStart, int dayPeak, float maxWeight, float stats, float speed, float cooldown = 1f)
	{
		return new ReforgedMobDefinition
		{
			Kind = kind,
			Name = name,
			FindBase = findBase,
			DayStart = dayStart,
			DayPeak = dayPeak,
			MaxWeight = maxWeight,
			StatMultiplier = stats,
			SpeedMultiplier = speed,
			RangedCooldownMultiplier = cooldown
		};
	}

	private static ReforgedMobDefinition Animal(ReforgedMobKind kind, string name, Func<MobType[], MobType> findBase, float stats, float speed)
	{
		return new ReforgedMobDefinition
		{
			Kind = kind,
			Name = name,
			FindBase = findBase,
			StatMultiplier = stats,
			SpeedMultiplier = speed,
			Animal = true
		};
	}

	private static ReforgedMobDefinition Boss(ReforgedMobKind kind, string name, Func<MobType[], MobType> findBase, float stats, float speed)
	{
		return new ReforgedMobDefinition
		{
			Kind = kind,
			Name = name,
			FindBase = findBase,
			StatMultiplier = stats,
			SpeedMultiplier = speed,
			Boss = true
		};
	}
}
internal sealed class ReforgedMobVisual : MonoBehaviour
{
	private ReforgedMobDefinition definition;

	internal void Initialize(ReforgedMobDefinition value)
	{
		definition = value;
	}

	private IEnumerator Start()
	{
		yield return null;
		Mob component = ((Component)this).GetComponent<Mob>();
		if (!((Object)(object)component == (Object)null) && definition != null)
		{
			if ((Object)(object)component.agent != (Object)null)
			{
				component.SetSpeed(1f);
			}
			switch (definition.Kind)
			{
			case ReforgedMobKind.GoblinRider:
				((Component)this).transform.localScale = Vector3.Scale(((Component)this).transform.localScale, new Vector3(1.12f, 1.05f, 1.16f));
				Tint(((Component)this).gameObject, new Color(0.78f, 0.48f, 0.22f), 0.44f);
				AttachRider();
				break;
			case ReforgedMobKind.CaveStalker:
				((Component)this).transform.localScale = Vector3.Scale(((Component)this).transform.localScale, new Vector3(0.86f, 0.8f, 1.16f));
				Tint(((Component)this).gameObject, new Color(0.16f, 0.22f, 0.3f), 0.68f);
				AddEyes(new Color(0.2f, 0.8f, 1f));
				break;
			case ReforgedMobKind.BombGoblin:
			{
				Transform transform3 = ((Component)this).transform;
				transform3.localScale *= 1.08f;
				Tint(((Component)this).gameObject, new Color(0.28f, 0.24f, 0.2f), 0.58f);
				AddBomb();
				break;
			}
			case ReforgedMobKind.StormShaman:
				((Component)this).transform.localScale = Vector3.Scale(((Component)this).transform.localScale, new Vector3(0.94f, 1.14f, 0.94f));
				Tint(((Component)this).gameObject, new Color(0.28f, 0.56f, 1f), 0.6f);
				AddStaff(new Color(0.15f, 0.62f, 1f));
				break;
			case ReforgedMobKind.CrystalGolem:
			{
				Transform transform2 = ((Component)this).transform;
				transform2.localScale *= 1.18f;
				Tint(((Component)this).gameObject, new Color(0.28f, 0.92f, 1f), 0.58f);
				AddCrystals();
				break;
			}
			case ReforgedMobKind.EmberWyvern:
				((Component)this).transform.localScale = Vector3.Scale(((Component)this).transform.localScale, new Vector3(1.12f, 0.96f, 1.12f));
				Tint(((Component)this).gameObject, new Color(1f, 0.25f, 0.08f), 0.56f);
				break;
			case ReforgedMobKind.AncientWarden:
			{
				Transform transform = ((Component)this).transform;
				transform.localScale *= 1.16f;
				Tint(((Component)this).gameObject, new Color(0.52f, 0.2f, 0.86f), 0.52f);
				AddCrown();
				break;
			}
			}
		}
	}

	private void AttachRider()
	{
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
		ReforgedMobDefinition reforgedMobDefinition;
		MobType val = MobSpawner.Instance?.allMobs?.FirstOrDefault((Func<MobType, bool>)((MobType type) => (Object)(object)type != (Object)null && !type.boss && (type.name ?? string.Empty).IndexOf("goblin", StringComparison.OrdinalIgnoreCase) >= 0 && !NewMonsterRegistry.TryGet(type.id, out reforgedMobDefinition)));
		if (!((Object)(object)val?.mobPrefab == (Object)null))
		{
			GameObject val2 = VisualCloneFactory.Instantiate(val.mobPrefab, ((Component)this).transform, "Goblin Rider Passenger");
			if (!((Object)(object)val2 == (Object)null))
			{
				val2.transform.localPosition = new Vector3(0f, 1.22f, -0.08f);
				val2.transform.localRotation = Quaternion.identity;
				val2.transform.localScale = Vector3.one * 0.6f;
				Tint(val2, new Color(0.84f, 0.62f, 0.3f), 0.46f);
			}
		}
	}

	private void AddBomb()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = Primitive("Powder Bomb", (PrimitiveType)0, ((Component)this).transform, new Vector3(0.34f, 0.82f, -0.34f), Vector3.one * 0.48f, new Color(0.06f, 0.06f, 0.07f));
		Primitive("Fuse", (PrimitiveType)2, val.transform, new Vector3(0f, 0.55f, 0f), new Vector3(0.08f, 0.32f, 0.08f), new Color(0.72f, 0.42f, 0.14f));
	}

	private void AddStaff(Color color)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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_0081: 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)
		GameObject val = Primitive("Storm Staff", (PrimitiveType)2, ((Component)this).transform, new Vector3(0.52f, 0.92f, 0f), new Vector3(0.09f, 0.92f, 0.09f), new Color(0.22f, 0.12f, 0.07f));
		Primitive("Storm Orb", (PrimitiveType)0, val.transform, new Vector3(0f, 1.08f, 0f), Vector3.one * 0.32f, color);
	}

	private void AddCrystals()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		Primitive("Crystal Left", (PrimitiveType)3, ((Component)this).transform, new Vector3(-0.45f, 1.05f, -0.15f), new Vector3(0.22f, 0.7f, 0.22f), new Color(0.18f, 0.9f, 1f), (Vector3?)new Vector3(0f, 0f, 18f));
		Primitive("Crystal Right", (PrimitiveType)3, ((Component)this).transform, new Vector3(0.44f, 0.92f, -0.18f), new Vector3(0.18f, 0.56f, 0.18f), new Color(0.36f, 0.72f, 1f), (Vector3?)new Vector3(0f, 0f, -20f));
	}

	private void AddEyes(Color color)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: 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)
		Primitive("Eye Left", (PrimitiveType)0, ((Component)this).transform, new Vector3(-0.17f, 0.52f, 0.48f), Vector3.one * 0.09f, color);
		Primitive("Eye Right", (PrimitiveType)0, ((Component)this).transform, new Vector3(0.17f, 0.52f, 0.48f), Vector3.one * 0.09f, color);
	}

	private void AddStagFeatures()
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: 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_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: 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_0276: Unknown result type (might be due to invalid IL or missing references)
		//IL_028a: Unknown result type (might be due to invalid IL or missing references)
		//IL_029e: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		Color color = default(Color);
		((Color)(ref color))..ctor(0.72f, 0.58f, 0.38f);
		Primitive("Stag Muzzle", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.56f, 0.63f), new Vector3(0.25f, 0.18f, 0.34f), new Color(0.24f, 0.13f, 0.08f));
		Primitive("Stag Ear Left", (PrimitiveType)3, ((Component)this).transform, new Vector3(-0.3f, 0.92f, 0.28f), new Vector3(0.13f, 0.12f, 0.28f), new Color(0.46f, 0.27f, 0.14f), (Vector3?)new Vector3(12f, -18f, -18f));
		Primitive("Stag Ear Right", (PrimitiveType)3, ((Component)this).transform, new Vector3(0.3f, 0.92f, 0.28f), new Vector3(0.13f, 0.12f, 0.28f), new Color(0.46f, 0.27f, 0.14f), (Vector3?)new Vector3(12f, 18f, 18f));
		for (int i = -1; i <= 1; i += 2)
		{
			Primitive("Stag Antler Beam " + i, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)i * 0.23f, 1.16f, 0.31f), new Vector3(0.055f, 0.46f, 0.055f), color, (Vector3?)new Vector3(-12f, 0f, (float)i * 22f));
			for (int j = 0; j < 3; j++)
			{
				Primitive("Stag Antler Tine " + i + " " + j, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)i * (0.31f + (float)j * 0.07f), 1.23f + (float)j * 0.14f, 0.3f), new Vector3(0.035f, 0.18f + (float)j * 0.025f, 0.035f), color, (Vector3?)new Vector3(-18f, 0f, (float)i * (42f - (float)j * 5f)));
			}
		}
		Primitive("Stag Tail", (PrimitiveType)3, ((Component)this).transform, new Vector3(0f, 0.55f, -0.7f), new Vector3(0.17f, 0.27f, 0.2f), new Color(0.78f, 0.68f, 0.52f), (Vector3?)new Vector3(-24f, 0f, 0f));
	}

	private void AddBoarFeatures()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00d3: 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_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: 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_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0220: Unknown result type (might be due to invalid IL or missing references)
		//IL_024b: Unknown result type (might be due to invalid IL or missing references)
		//IL_025f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		//IL_0287: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		Primitive("Boar Snout", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.35f, 0.7f), new Vector3(0.38f, 0.25f, 0.38f), new Color(0.26f, 0.14f, 0.12f));
		Primitive("Boar Nostril Left", (PrimitiveType)0, ((Component)this).transform, new Vector3(-0.12f, 0.36f, 0.99f), Vector3.one * 0.045f, new Color(0.03f, 0.02f, 0.02f));
		Primitive("Boar Nostril Right", (PrimitiveType)0, ((Component)this).transform, new Vector3(0.12f, 0.36f, 0.99f), Vector3.one * 0.045f, new Color(0.03f, 0.02f, 0.02f));
		Primitive("Boar Ear Left", (PrimitiveType)3, ((Component)this).transform, new Vector3(-0.31f, 0.68f, 0.35f), new Vector3(0.16f, 0.22f, 0.12f), new Color(0.3f, 0.16f, 0.12f), (Vector3?)new Vector3(0f, -14f, -24f));
		Primitive("Boar Ear Right", (PrimitiveType)3, ((Component)this).transform, new Vector3(0.31f, 0.68f, 0.35f), new Vector3(0.16f, 0.22f, 0.12f), new Color(0.3f, 0.16f, 0.12f), (Vector3?)new Vector3(0f, 14f, 24f));
		Primitive("Tusk Left", (PrimitiveType)2, ((Component)this).transform, new Vector3(-0.22f, 0.28f, 0.62f), new Vector3(0.055f, 0.23f, 0.055f), new Color(0.92f, 0.86f, 0.68f), (Vector3?)new Vector3(72f, 0f, 0f));
		Primitive("Tusk Right", (PrimitiveType)2, ((Component)this).transform, new Vector3(0.22f, 0.28f, 0.62f), new Vector3(0.055f, 0.23f, 0.055f), new Color(0.92f, 0.86f, 0.68f), (Vector3?)new Vector3(72f, 0f, 0f));
		for (int i = 0; i < 5; i++)
		{
			Primitive("Boar Mane " + i, (PrimitiveType)3, ((Component)this).transform, new Vector3(0f, 0.78f, 0.34f - (float)i * 0.23f), new Vector3(0.09f, 0.2f + (float)(i % 2) * 0.05f, 0.16f), new Color(0.12f, 0.07f, 0.05f), (Vector3?)new Vector3(0f, 0f, (i % 2 == 0) ? 8f : (-8f)));
		}
	}

	private void AddAntelopeFeatures()
	{
		//IL_0047: 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_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: 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_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_015a: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: Unknown result type (might be due to invalid IL or missing references)
		//IL_016f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0216: Unknown result type (might be due to invalid IL or missing references)
		//IL_022a: Unknown result type (might be due to invalid IL or missing references)
		//IL_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0278: Unknown result type (might be due to invalid IL or missing references)
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
		Color color = default(Color);
		((Color)(ref color))..ctor(0.72f, 0.44f, 0.18f);
		Color color2 = default(Color);
		((Color)(ref color2))..ctor(0.16f, 0.09f, 0.05f);
		Primitive("Antelope Muzzle", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.62f, 0.68f), new Vector3(0.21f, 0.15f, 0.36f), new Color(0.34f, 0.2f, 0.1f));
		Primitive("Antelope Face Stripe", (PrimitiveType)3, ((Component)this).transform, new Vector3(0f, 0.78f, 0.54f), new Vector3(0.075f, 0.34f, 0.055f), color2, (Vector3?)new Vector3(18f, 0f, 0f));
		Primitive("Antelope Ear Left", (PrimitiveType)3, ((Component)this).transform, new Vector3(-0.31f, 0.96f, 0.25f), new Vector3(0.12f, 0.1f, 0.32f), color, (Vector3?)new Vector3(8f, -20f, -18f));
		Primitive("Antelope Ear Right", (PrimitiveType)3, ((Component)this).transform, new Vector3(0.31f, 0.96f, 0.25f), new Vector3(0.12f, 0.1f, 0.32f), color, (Vector3?)new Vector3(8f, 20f, 18f));
		for (int i = -1; i <= 1; i += 2)
		{
			Primitive("Antelope Horn Lower " + i, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)i * 0.18f, 1.2f, 0.28f), new Vector3(0.045f, 0.42f, 0.045f), color2, (Vector3?)new Vector3(-9f, 0f, (float)i * 7f));
			Primitive("Antelope Horn Upper " + i, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)i * 0.22f, 1.57f, 0.2f), new Vector3(0.035f, 0.28f, 0.035f), color2, (Vector3?)new Vector3(-17f, 0f, (float)i * 9f));
		}
		Primitive("Antelope Belly", (PrimitiveType)3, ((Component)this).transform, new Vector3(0f, 0.3f, -0.02f), new Vector3(0.58f, 0.12f, 0.74f), new Color(0.88f, 0.78f, 0.57f));
		Primitive("Antelope Tail", (PrimitiveType)3, ((Component)this).transform, new Vector3(0f, 0.58f, -0.72f), new Vector3(0.12f, 0.22f, 0.18f), color2, (Vector3?)new Vector3(-20f, 0f, 0f));
	}

	private void AddRamFeatures()
	{
		//IL_0047: 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_006f: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_020d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0221: Unknown result type (might be due to invalid IL or missing references)
		//IL_025a: Unknown result type (might be due to invalid IL or missing references)
		//IL_026e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		Color color = default(Color);
		((Color)(ref color))..ctor(0.82f, 0.78f, 0.68f);
		Color color2 = default(Color);
		((Color)(ref color2))..ctor(0.56f, 0.43f, 0.28f);
		Primitive("Ram Muzzle", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.54f, 0.66f), new Vector3(0.27f, 0.2f, 0.34f), new Color(0.3f, 0.24f, 0.19f));
		for (int i = -2; i <= 2; i++)
		{
			Primitive("Ram Wool Collar " + i, (PrimitiveType)0, ((Component)this).transform, new Vector3((float)i * 0.17f, 0.69f + (float)Mathf.Abs(i) * 0.025f, 0.18f), new Vector3(0.24f, 0.28f, 0.25f), color);
		}
		for (int j = -1; j <= 1; j += 2)
		{
			Primitive("Ram Horn Crown " + j, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)j * 0.29f, 0.91f, 0.23f), new Vector3(0.07f, 0.26f, 0.07f), color2, (Vector3?)new Vector3(18f, 0f, (float)j * 68f));
			Primitive("Ram Horn Curve " + j, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)j * 0.42f, 0.78f, 0.32f), new Vector3(0.065f, 0.24f, 0.065f), color2, (Vector3?)new Vector3(62f, 0f, (float)j * 38f));
			Primitive("Ram Horn Tip " + j, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)j * 0.38f, 0.62f, 0.48f), new Vector3(0.045f, 0.18f, 0.045f), color2, (Vector3?)new Vector3(82f, 0f, (float)j * -20f));
		}
		Primitive("Ram Tail", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.58f, -0.68f), new Vector3(0.19f, 0.22f, 0.2f), color);
	}

	private void AddYakFeatures()
	{
		//IL_0047: 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_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_019a: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0257: Unknown result type (might be due to invalid IL or missing references)
		//IL_026b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_028a: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_0317: 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_0330: Unknown result type (might be due to invalid IL or missing references)
		Color color = default(Color);
		((Color)(ref color))..ctor(0.2f, 0.13f, 0.085f);
		Color color2 = default(Color);
		((Color)(ref color2))..ctor(0.76f, 0.65f, 0.45f);
		Primitive("Yak Broad Muzzle", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.5f, 0.68f), new Vector3(0.36f, 0.23f, 0.38f), new Color(0.24f, 0.16f, 0.11f));
		Primitive("Yak Forelock", (PrimitiveType)3, ((Component)this).transform, new Vector3(0f, 0.92f, 0.46f), new Vector3(0.32f, 0.34f, 0.13f), color, (Vector3?)new Vector3(20f, 0f, 0f));
		for (int i = -1; i <= 1; i += 2)
		{
			Primitive("Yak Horn Inner " + i, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)i * 0.38f, 0.91f, 0.24f), new Vector3(0.075f, 0.34f, 0.075f), color2, (Vector3?)new Vector3(2f, 0f, (float)i * 72f));
			Primitive("Yak Horn Outer " + i, (PrimitiveType)2, ((Component)this).transform, new Vector3((float)i * 0.67f, 1.02f, 0.24f), new Vector3(0.052f, 0.28f, 0.052f), color2, (Vector3?)new Vector3(-14f, 0f, (float)i * 48f));
		}
		for (int j = -2; j <= 2; j++)
		{
			Primitive("Yak Shag Left " + j, (PrimitiveType)3, ((Component)this).transform, new Vector3(-0.48f, 0.22f, (float)j * 0.23f), new Vector3(0.1f, 0.5f, 0.24f), color, (Vector3?)new Vector3(0f, 0f, 4f + (float)j * 2f));
			Primitive("Yak Shag Right " + j, (PrimitiveType)3, ((Component)this).transform, new Vector3(0.48f, 0.22f, (float)j * 0.23f), new Vector3(0.1f, 0.5f, 0.24f), color, (Vector3?)new Vector3(0f, 0f, -4f - (float)j * 2f));
		}
		Primitive("Yak Tail", (PrimitiveType)2, ((Component)this).transform, new Vector3(0f, 0.42f, -0.78f), new Vector3(0.09f, 0.36f, 0.09f), color, (Vector3?)new Vector3(68f, 0f, 0f));
		Primitive("Yak Tail Tuft", (PrimitiveType)0, ((Component)this).transform, new Vector3(0f, 0.31f, -1.02f), new Vector3(0.17f, 0.2f, 0.17f), color);
	}

	private void HideCowFeatures()
	{
		Renderer[] componentsInChildren = ((Component)this).GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val in componentsInChildren)
		{
			string text = ((Object)val).name ?? string.Empty;
			if (text.IndexOf("udder", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("milk", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("horn", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				val.enabled = false;
			}
		}
	}

	private void AddCrown()
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: 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_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		Color color = default(Color);
		((Color)(ref color))..ctor(1f, 0.68f, 0.12f);
		Primitive("Crown", (PrimitiveType)2, ((Component)this).transform, new Vector3(0f, 2.35f, 0f), new Vector3(0.55f, 0.16f, 0.55f), color);
		for (int i = -1; i <= 1; i++)
		{
			Primitive("Crown Spike", (PrimitiveType)3, ((Component)this).transform, new Vector3((float)i * 0.36f, 2.62f, 0f), new Vector3(0.14f, 0.52f, 0.14f), color, (Vector3?)new Vector3(0f, 0f, (float)i * -12f));
		}
	}

	private static GameObject Primitive(string name, PrimitiveType primitiveType, Transform parent, Vector3 position, Vector3 scale, Color color, Vector3? rotation = null)
	{
		//IL_0000: 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)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: 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_0099: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
		GameObject obj = GameObject.CreatePrimitive(primitiveType);
		((Object)obj).name = name;
		obj.transform.SetParent(parent, false);
		obj.transform.localPosition = position;
		obj.transform.localRotation = Quaternion.Euler((Vector3)(((??)rotation) ?? Vector3.zero));
		obj.transform.localScale = scale;
		Collider component = obj.GetComponent<Collider>();
		if ((Object)(object)component != (Object)null)
		{
			component.enabled = false;
		}
		Renderer component2 = obj.GetComponent<Renderer>();
		if ((Object)(object)component2 != (Object)null)
		{
			Material material = component2.material;
			if (material.HasProperty("_Color"))
			{
				material.color = color;
			}
			if (material.HasProperty("_EmissionColor"))
			{
				material.SetColor("_EmissionColor", color * 0.18f);
			}
		}
		return obj;
	}

	private static void Tint(GameObject root, Color color, float amount)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: 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_0083: Unknown result type (might be due to invalid IL or missing references)
		Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Material[] materials = componentsInChildren[i].materials;
			foreach (Material val in materials)
			{
				if (!((Object)(object)val == (Object)null) && val.HasProperty("_Color"))
				{
					val.color = Color.Lerp(val.color, val.color * color, amount);
					if (val.HasProperty("_EmissionColor") && ((Color)(ref color)).maxColorComponent > 0.85f)
					{
						val.SetColor("_EmissionColor", color * 0.22f);
					}
				}
			}
		}
	}
}
internal static class VisualCloneFactory
{
	internal static GameObject Instantiate(GameObject prefab, Transform parent, string name)
	{
		if ((Object)(object)prefab == (Object)null)
		{
			return null;
		}
		bool activeSelf = prefab.activeSelf;
		GameObject val = null;
		try
		{
			if (activeSelf)
			{
				prefab.SetActive(false);
			}
			val = Object.Instantiate<GameObject>(prefab, parent);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Could not create cosmetic visual '" + name + "': " + ex.Message));
			if ((Object)(object)val != (Object)null)
			{
				Object.Destroy((Object)(object)val);
			}
			val = null;
		}
		finally
		{
			if (activeSelf)
			{
				prefab.SetActive(true);
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			return null;
		}
		((Object)val).name = name;
		MonoBehaviour[] componentsInChildren = val.GetComponentsInChildren<MonoBehaviour>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)componentsInChildren[i]);
		}
		NavMeshAgent[] componentsInChildren2 = val.GetComponentsInChildren<NavMeshAgent>(true);
		for (int i = 0; i < componentsInChildren2.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)componentsInChildren2[i]);
		}
		Collider[] componentsInChildren3 = val.GetComponentsInChildren<Collider>(true);
		for (int i = 0; i < componentsInChildren3.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)componentsInChildren3[i]);
		}
		Rigidbody[] componentsInChildren4 = val.GetComponentsInChildren<Rigidbody>(true);
		for (int i = 0; i < componentsInChildren4.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)componentsInChildren4[i]);
		}
		AudioSource[] componentsInChildren5 = val.GetComponentsInChildren<AudioSource>(true);
		for (int i = 0; i < componentsInChildren5.Length; i++)
		{
			Object.DestroyImmediate((Object)(object)componentsInChildren5[i]);
		}
		val.SetActive(true);
		return val;
	}
}
[HarmonyPatch(typeof(MobSpawner), "Awake")]
internal static class ReforgedMobRegistrationPatch
{
	private static void Postfix(MobSpawner __instance)
	{
		NewMonsterRegistry.Install(__instance);
		GameLoop val = GameLoop.Instance ?? Object.FindObjectOfType<GameLoop>();
		if ((Object)(object)val != (Object)null)
		{
			NewMonsterRegistry.Install(val);
		}
	}
}
[HarmonyPatch(typeof(GameLoop), "Awake")]
internal static class ReforgedNightRosterPatch
{
	private static void Postfix(GameLoop __instance)
	{
		NewMonsterRegistry.Install(__instance);
	}
}
[HarmonyPatch(typeof(MobZoneGenerator), "ProcessZone")]
internal static class ReforgedAnimalZonePatch
{
	private static void Postfix(SpawnZone __result)
	{
		MobZone val = (MobZone)(object)((__result is MobZone) ? __result : null);
		if (val != null)
		{
			NewMonsterRegistry.ReplaceAnimalZone(val);
		}
	}
}
[HarmonyPatch(typeof(MobZone), "LocalSpawnEntity")]
internal static class ReforgedAnimalSpawnPatch
{
	private static void Postfix(int mobType, GameObject __result)
	{
		NewMonsterRegistry.ApplySpawnedType((__result != null) ? __result.GetComponent<Mob>() : null, mobType);
	}
}
[HarmonyPatch(typeof(GameLoop), "CalculateSpawnWeights")]
internal static class CorrectSpawnWeightPatch
{
	private static bool Prefix(GameLoop __instance, int day, ref float __result)
	{
		float num = 0f;
		MobSpawn[] array = __instance.mobs ?? Array.Empty<MobSpawn>();
		foreach (MobSpawn val in array)
		{
			val.currentWeight = NewMonsterRegistry.Weight(val, day);
			num += val.currentWeight;
		}
		__result = num;
		return false;
	}
}
[HarmonyPatch(typeof(GameLoop), "SelectMobToSpawn")]
internal static class CorrectSpawnSelectionPatch
{
	private static bool Prefix(GameLoop __instance, bool shrine, ref MobType __result)
	{
		MobSpawn[] array = __instance.mobs ?? Array.Empty<MobSpawn>();
		if (array.Length == 0)
		{
			return true;
		}
		int day = __instance.currentDay + (shrine ? 2 : 0);
		float num = array.Sum((MobSpawn entry) => NewMonsterRegistry.Weight(entry, day));
		if (num <= 0f)
		{
			__result = ((IEnumerable<MobSpawn>)array).FirstOrDefault((Func<MobSpawn, bool>)((MobSpawn entry) => (Object)(object)entry?.mob != (Object)null))?.mob;
			return (Object)(object)__result == (Object)null;
		}
		float num2 = Random.Range(0f, num);
		float num3 = 0f;
		MobSpawn[] array2 = array;
		foreach (MobSpawn val in array2)
		{
			num3 += NewMonsterRegistry.Weight(val, day);
			if (num2 <= num3 && (Object)(object)val?.mob != (Object)null)
			{
				__result = val.mob;
				return false;
			}
		}
		__result = array.Last((MobSpawn entry) => (Object)(object)entry?.mob != (Object)null).mob;
		return false;
	}
}
[BepInPlugin("kr.codex.muckreplayable", "Muck Replayable", "0.9.4")]
public sealed class Plugin : BaseUnityPlugin
{
	public const string PluginGuid = "kr.codex.muckreplayable";

	public const string PluginName = "Muck Replayable";

	public const string PluginVersion = "0.9.4";

	public const string ProtocolVersion = "15";

	internal static ManualLogSource Log;

	internal static ReforgedConfig Settings;

	private Harmony _harmony;

	private void Awake()
	{
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		Settings = new ReforgedConfig(((BaseUnityPlugin)this).Config);
		if (Settings.EnableExpandedIsland.Value)
		{
			int value = Settings.IslandChunkSize.Value;
			int num = Mathf.Clamp(value, 241, 321);
			if ((num & 1) == 0)
			{
				num = ((num < 321) ? (num + 1) : (num - 1));
			}
			MapGenerator.mapChunkSize = num;
			if (value != num)
			{
				Settings.IslandChunkSize.Value = num;
				((BaseUnityPlugin)this).Logger.LogWarning((object)$"IslandChunkSize {value} was normalized to the supported odd size {num}.");
			}
		}
		_harmony = new Harmony("kr.codex.muckreplayable");
		_harmony.PatchAll(typeof(Plugin).Assembly);
		((Component)this).gameObject.AddComponent<ReforgedRuntime>();
		((Component)this).gameObject.AddComponent<EnhancedModeController>();
		((Component)this).gameObject.AddComponent<ShieldController>();
		((Component)this).gameObject.AddComponent<ThirdPersonController>();
		((Component)this).gameObject.AddComponent<SleepController>();
		((Component)this).gameObject.AddComponent<VictoryContinuationController>();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Muck Replayable 0.9.4 loaded");
		((BaseUnityPlugin)this).Logger.LogInfo((object)($"Aggro={Settings.EnableAggro.Value}, ResourceDamage=x{Settings.ResourceDamageMultiplier.Value:0.##}, " + $"MoveSpeed=x{Settings.PlayerMoveSpeedMultiplier.Value:0.##}, " + $"StaminaDrain=x{Settings.StaminaDrainMultiplier.Value:0.##}, " + $"DifficultyCurves={Settings.EnableDifficultyCurves.Value}, ThreeChoiceArtifacts={Settings.EnableArtifactChoices.Value}, " + $"NewMonsterTypes={Settings.EnableNewMonsterTypes.Value}"));
	}

	private void OnDestroy()
	{
		Harmony harmony = _harmony;
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
	}
}
internal sealed class ReforgedConfig
{
	internal readonly ConfigEntry<bool> EnableAggro;

	internal readonly ConfigEntry<float> MeleeAcquireDistance;

	internal readonly ConfigEntry<float> RangedAcquireDistance;

	internal readonly ConfigEntry<float> BossAcquireDistance;

	internal readonly ConfigEntry<float> ProximityAcquireDistance;

	internal readonly ConfigEntry<float> MeleeDisengageDistance;

	internal readonly ConfigEntry<float> RangedDisengageDistance;

	internal readonly ConfigEntry<float> BossDisengageDistance;

	internal readonly ConfigEntry<float> MeleeHomeLeash;

	internal readonly ConfigEntry<float> RangedHomeLeash;

	internal readonly ConfigEntry<float> BossHomeLeash;

	internal readonly ConfigEntry<float> MeleeLostSightSeconds;

	internal readonly ConfigEntry<float> RangedLostSightSeconds;

	internal readonly ConfigEntry<float> BossLostSightSeconds;

	internal readonly ConfigEntry<float> FarTargetGraceSeconds;

	internal readonly ConfigEntry<float> ReturnReacquireCooldown;

	internal readonly ConfigEntry<float> ReturnArrivalDistance;

	internal readonly ConfigEntry<bool> AttackBlockingBuildings;

	internal readonly ConfigEntry<float> BuildingAttackDistance;

	internal readonly ConfigEntry<float> ResourceDamageMultiplier;

	internal readonly ConfigEntry<float> PlayerMoveSpeedMultiplier;

	internal readonly ConfigEntry<float> StaminaDrainMultiplier;

	internal readonly ConfigEntry<float> JumpStaminaMultiplier;

	internal readonly ConfigEntry<float> StaminaRegenMultiplier;

	internal readonly ConfigEntry<float> HungerDrainMultiplier;

	internal readonly ConfigEntry<bool> EnableDifficultyCurves;

	internal readonly ConfigEntry<int> EasyDayLength;

	internal readonly ConfigEntry<int> NormalDayLength;

	internal readonly ConfigEntry<int> GamerDayLength;

	internal readonly ConfigEntry<float> EasyChestPriceCap;

	internal readonly ConfigEntry<float> NormalChestPriceCap;

	internal readonly ConfigEntry<float> GamerChestPriceCap;

	internal readonly ConfigEntry<int> MaterialStackSize;

	internal readonly ConfigEntry<int> ArrowStackSize;

	internal readonly ConfigEntry<float> SmeltTimeMultiplier;

	internal readonly ConfigEntry<float> FuelUseMultiplier;

	internal readonly ConfigEntry<bool> EnableLobbyBrowser;

	internal readonly ConfigEntry<bool> EnableRunSaves;

	internal readonly ConfigEntry<int> ActiveSaveSlot;

	internal readonly ConfigEntry<int> AutosaveSeconds;

	internal readonly ConfigEntry<bool> EnableTextureOverrides;

	internal readonly ConfigEntry<bool> EnableContentVariants;

	internal readonly ConfigEntry<bool> EnableCaveNetwork;

	internal readonly ConfigEntry<bool> MoveOresIntoCaves;

	internal readonly ConfigEntry<int> CaveOreNodesPerTunnel;

	internal readonly ConfigEntry<int> SurfaceOreNodeCount;

	internal readonly ConfigEntry<bool> EnableExpandedIsland;

	internal readonly ConfigEntry<int> IslandChunkSize;

	internal readonly ConfigEntry<bool> EnableServerValidation;

	internal readonly ConfigEntry<int> MaxClientMobDamage;

	internal readonly ConfigEntry<int> MaxClientResourceDamage;

	internal readonly ConfigEntry<bool> EnableArtifactChoices;

	internal readonly ConfigEntry<bool> EnableNewMonsterTypes;

	internal readonly ConfigEntry<bool> EnableEnhancedSpectator;

	internal readonly ConfigEntry<bool> EnableCreativeOverhaul;

	internal readonly ConfigEntry<float> BuildDamageMultiplier;

	internal readonly ConfigEntry<bool> HotbarFirstPickup;

	internal readonly ConfigEntry<int> DetailedMapResolution;

	internal readonly ConfigEntry<bool> ShowMapLandmarks;

	internal ReforgedConfig(ConfigFile config)
	{
		EnableAggro = config.Bind<bool>("Aggro", "Enabled", true, "Enable finite aggro, search, disengage, and return-to-home behavior.");
		MeleeAcquireDistance = config.Bind<float>("Aggro", "MeleeAcquireDistance", 28f, "Line-of-sight acquisition distance for normal melee enemies.");
		RangedAcquireDistance = config.Bind<float>("Aggro", "RangedAcquireDistance", 35f, "Line-of-sight acquisition distance for ranged enemies.");
		BossAcquireDistance = config.Bind<float>("Aggro", "BossAcquireDistance", 60f, "Line-of-sight acquisition distance for bosses.");
		ProximityAcquireDistance = config.Bind<float>("Aggro", "ProximityAcquireDistance", 8f, "Enemies detect players this close even without a clear raycast.");
		MeleeDisengageDistance = config.Bind<float>("Aggro", "MeleeDisengageDistance", 55f, "Distance at which melee enemies begin their disengage timer.");
		RangedDisengageDistance = config.Bind<float>("Aggro", "RangedDisengageDistance", 65f, "Distance at which ranged enemies begin their disengage timer.");
		BossDisengageDistance = config.Bind<float>("Aggro", "BossDisengageDistance", 120f, "Distance at which bosses begin their disengage timer.");
		MeleeHomeLeash = config.Bind<float>("Aggro", "MeleeHomeLeash", 80f, "Maximum distance a melee enemy can move from its spawn point.");
		RangedHomeLeash = config.Bind<float>("Aggro", "RangedHomeLeash", 90f, "Maximum distance a ranged enemy can move from its spawn point.");
		BossHomeLeash = config.Bind<float>("Aggro", "BossHomeLeash", 150f, "Maximum distance a boss can move from its spawn point.");
		MeleeLostSightSeconds = config.Bind<float>("Aggro", "MeleeLostSightSeconds", 5f, "How long melee enemies search the last seen position.");
		RangedLostSightSeconds = config.Bind<float>("Aggro", "RangedLostSightSeconds", 6f, "How long ranged enemies search the last seen position.");
		BossLostSightSeconds = config.Bind<float>("Aggro", "BossLostSightSeconds", 10f, "How long bosses search the last seen position.");
		FarTargetGraceSeconds = config.Bind<float>("Aggro", "FarTargetGraceSeconds", 4f, "How long a target may remain outside disengage/leash range.");
		ReturnReacquireCooldown = config.Bind<float>("Aggro", "ReturnReacquireCooldown", 1.5f, "Minimum return time before an enemy may acquire a nearby player again.");
		ReturnArrivalDistance = config.Bind<float>("Aggro", "ReturnArrivalDistance", 3f, "Distance from spawn that completes a return.");
		AttackBlockingBuildings = config.Bind<bool>("Aggro", "AttackBlockingBuildings", true, "Allow enemies to attack nearby buildings only while a player is actively engaged.");
		BuildingAttackDistance = config.Bind<float>("Aggro", "BuildingAttackDistance", 9f, "Maximum distance used to select a blocking building.");
		ResourceDamageMultiplier = config.Bind<float>("Resources", "DamageMultiplier", 2.5f, "Multiplier applied only to positive melee/rock damage against harvestable resources.");
		PlayerMoveSpeedMultiplier = config.Bind<float>("Balance", "PlayerMoveSpeedMultiplier", 1.5f, "Multiplier for the player's walk speed, sprint speed, acceleration, and underwater propulsion.");
		StaminaDrainMultiplier = config.Bind<float>("Balance", "StaminaDrainMultiplier", 0.6f, "Multiplier for sprinting, swimming, and jumping stamina costs.");
		JumpStaminaMultiplier = config.Bind<float>("Balance", "JumpStaminaMultiplier", 0.75f, "Jump and attack stamina cost relative to vanilla; 0.75 spends 75% of the original cost.");
		StaminaRegenMultiplier = config.Bind<float>("Balance", "StaminaRegenMultiplier", 2f, "Recharge speed; 2.0 halves the wait to refill stamina.");
		if (Mathf.Approximately(PlayerMoveSpeedMultiplier.Value, 1.2f))
		{
			PlayerMoveSpeedMultiplier.Value = 1.5f;
		}
		if (Mathf.Approximately(JumpStaminaMultiplier.Value, 0.3f))
		{
			JumpStaminaMultiplier.Value = 0.75f;
		}
		HungerDrainMultiplier = config.Bind<float>("Balance", "HungerDrainMultiplier", 0.6f, "Multiplier applied only to passive hunger depletion. Food healing, stamina, and hunger restoration values are unchanged.");
		MaterialStackSize = config.Bind<int>("Resources", "MaterialStackSize", 250, "Minimum stack size for stackable material items.");
		ArrowStackSize = config.Bind<int>("Resources", "ArrowStackSize", 999, "Minimum stack size for arrows.");
		SmeltTimeMultiplier = config.Bind<float>("Resources", "SmeltTimeMultiplier", 0.55f, "Multiplier applied to processable item smelting time.");
		FuelUseMultiplier = config.Bind<float>("Resources", "FuelUseMultiplier", 1.5f, "Multiplier applied to fuel maximum uses.");
		EnableDifficultyCurves = config.Bind<bool>("Difficulty", "Enabled", true, "Replace vanilla runaway enemy HP and damage scaling.");
		EasyDayLength = config.Bind<int>("Difficulty", "EasyDayLength", 70, "Day duration used on Easy.");
		NormalDayLength = config.Bind<int>("Difficulty", "NormalDayLength", 64, "Day duration used on Normal.");
		GamerDayLength = config.Bind<int>("Difficulty", "GamerDayLength", 54, "Day duration used on Gamer.");
		EasyChestPriceCap = config.Bind<float>("Difficulty", "EasyChestPriceCap", 2f, "Maximum chest price multiplier on Easy.");
		NormalChestPriceCap = config.Bind<float>("Difficulty", "NormalChestPriceCap", 2.75f, "Maximum chest price multiplier on Normal.");
		GamerChestPriceCap = config.Bind<float>("Difficulty", "GamerChestPriceCap", 3.5f, "Maximum chest price multiplier on Gamer.");
		EnableLobbyBrowser = config.Bind<bool>("Platform", "LobbyBrowser", true, "Add a no-code public server browser to Muck's main menu.");
		EnableRunSaves = config.Bind<bool>("Platform", "RunSaves", true, "Enable a 24-world continue list with atomic saves and autosaves.");
		ActiveSaveSlot = config.Bind<int>("Platform", "ActiveSaveSlot", 1, "Internal autosave world slot (1-24).");
		AutosaveSeconds = config.Bind<int>("Platform", "AutosaveSeconds", 300, "Host autosave interval in seconds.");
		EnableTextureOverrides = config.Bind<bool>("Visuals", "AITextureOverrides", true, "Load versioned enhanced PNG textures without modifying Unity archives.");
		EnableContentVariants = config.Bind<bool>("World", "ContentVariants", true, "Enable deterministic low-modeling enemy and animal variants.");
		EnableCaveNetwork = config.Bind<bool>("World", "ConnectedCaves", true, "Create eight physically connected cave mouths as a deep, irregular branch network. No teleport portals are used.");
		MoveOresIntoCaves = config.Bind<bool>("World", "CaveOnlyOres", true, "Redistribute most mineral nodes across validated cave floors, walls, and ceilings while retaining a small surface supply.");
		CaveOreNodesPerTunnel = config.Bind<int>("World", "CaveOreNodesPerTunnel", 120, "Underground mineral budget per two cave entrances. With eight entrances the default target is 480 cave nodes.");
		SurfaceOreNodeCount = config.Bind<int>("World", "SurfaceOreNodeCount", 48, "Approximate minimum number of original mineral nodes retained on the surface after cave redistribution.");
		if (CaveOreNodesPerTunnel.Value == 72 || CaveOreNodesPerTunnel.Value == 96)
		{
			CaveOreNodesPerTunnel.Value = 120;
		}
		EnableExpandedIsland = config.Bind<bool>("World", "ExpandedIsland", true, "Generate a larger island and scale dependent spawn radii.");
		IslandChunkSize = config.Bind<int>("World", "IslandChunkSize", 281, "Odd terrain sample size; 281 is about 36% more land area than vanilla.");
		EnableServerValidation = config.Bind<bool>("Security", "ServerValidation", true, "Clamp malformed or impossible public-lobby combat/build packets on the host.");
		MaxClientMobDamage = config.Bind<int>("Security", "MaxClientMobDamage", 1200, "Hard upper bound for one client-reported mob hit before defenses.");
		MaxClientResourceDamage = config.Bind<int>("Security", "MaxClientResourceDamage", 2500, "Hard upper bound for one client-reported resource hit.");
		EnableArtifactChoices = config.Bind<bool>("Gameplay", "ThreeChoiceArtifacts", true, "Replace random chest drops with a host-validated choice of three artifacts.");
		EnableNewMonsterTypes = config.Bind<bool>("World", "NewMonsterTypes", true, "Add networked enemy and boss types built from existing models and attacks; neutral animals remain vanilla cows and bulls.");
		EnableEnhancedSpectator = config.Bind<bool>("Gameplay", "EnhancedSpectator", true, "Fix target cycling and dead targets, add zoom, and provide a controllable free camera.");
		EnableCreativeOverhaul = config.Bind<bool>("Gameplay", "CreativeOverhaul", true, "Creative unlocks every recipe and removes crafting/building resource costs, without extra cheats or developer UI.");
		BuildDamageMultiplier = config.Bind<float>("Balance", "EnemyBuildDamageMultiplier", 0.4f, "Enemy damage dealt to player-built structures; structural support collapse remains unchanged.");
		HotbarFirstPickup = config.Bind<bool>("QualityOfLife", "HotbarFirstPickup", true, "Fill available hotbar slots before backpack slots when collecting items.");
		DetailedMapResolution = config.Bind<int>("Visuals", "DetailedMapResolution", 1024, "Map texture resolution (512-2048). Higher values sharpen terrain and coastlines.");
		ShowMapLandmarks = config.Bind<bool>("Visuals", "ShowMapLandmarks", true, "Reveal caves, villages, and the ship on the map only after the player discovers them.");
	}
}
internal static class ReforgedGuiTheme
{
	private static bool ready;

	private static bool usedInventoryTexture;

	private static Texture2D dimTexture;

	private static Texture2D windowTexture;

	private static Texture2D cardTexture;

	private static Texture2D cardHoverTexture;

	private static Texture2D buttonTexture;

	private static Texture2D buttonHoverTexture;

	private static Texture2D buttonActiveTexture;

	private static Texture2D accentTexture;

	private static Texture2D inputTexture;

	private static Texture2D transparentTexture;

	private static Font nativeFont;

	internal static readonly Color Accent = new Color(1f, 0.647f, 0.412f, 1f);

	internal static readonly Color Text = new Color(0.96f, 0.91f, 0.84f, 1f);

	internal static readonly Color MutedText = new Color(0.79f, 0.66f, 0.53f, 1f);

	internal static readonly Color Cyan = Accent;

	internal static GUIStyle Window { get; private set; }

	internal static GUIStyle Card { get; private set; }

	internal static GUIStyle Title { get; private set; }

	internal static GUIStyle Heading { get; private set; }

	internal static GUIStyle Label { get; private set; }

	internal static GUIStyle Muted { get; private set; }

	internal static GUIStyle Centered { get; private set; }

	internal static GUIStyle Button { get; private set; }

	internal static GUIStyle PrimaryButton { get; private set; }

	internal static GUIStyle CardButton { get; private set; }

	internal static GUIStyle WorldButton { get; private set; }

	internal static GUIStyle Tab { get; private set; }

	internal static GUIStyle ActiveTab { get; private set; }

	internal static GUIStyle Input { get; private set; }

	internal static GUIStyle Hud { get; private set; }

	internal static GUIStyle CloseButton { get; private set; }

	internal static void Ensure()
	{
		//IL_0064: 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_00bc: 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_0118: Unknown result type (might be due to invalid IL or missing references)
		//IL_0146: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		//IL_0234: Unknown result type (might be due to invalid IL or missing references)
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Expected O, but got Unknown
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_024c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0256: Expected O, but got Unknown
		//IL_025b: Expected O, but got Unknown
		//IL_026a: Unknown result type (might be due to invalid IL or missing references)
		//IL_026f: Unknown result type (might be due to invalid IL or missing references)
		//IL_027f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0288: Unknown result type (might be due to invalid IL or missing references)
		//IL_0292: Expected O, but got Unknown
		//IL_0292: Unknown result type (might be due to invalid IL or missing references)
		//IL_029b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a5: Expected O, but got Unknown
		//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b4: Expected O, but got Unknown
		//IL_02b9: Expected O, but got Unknown
		//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_030e: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_034a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0368: Unknown result type (might be due to invalid IL or missing references)
		//IL_037c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0381: Unknown result type (might be due to invalid IL or missing references)
		//IL_0388: Unknown result type (might be due to invalid IL or missing references)
		//IL_0390: Unknown result type (might be due to invalid IL or missing references)
		//IL_0399: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a3: Expected O, but got Unknown
		//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_03b6: Expected O, but got Unknown
		//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e3: 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_0411: Unknown result type (might be due to invalid IL or missing references)
		//IL_0417: Unknown result type (might be due to invalid IL or missing references)
		//IL_0421: Unknown result type (might be due to invalid IL or missing references)
		//IL_0431: Unknown result type (might be due to invalid IL or missing references)
		//IL_0437: Unknown result type (might be due to invalid IL or missing references)
		//IL_0441: Unknown result type (might be due to invalid IL or missing references)
		//IL_0451: 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_0461: Unknown result type (might be due to invalid IL or missing references)
		//IL_046a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0474: Expected O, but got Unknown
		//IL_0474: Unknown result type (might be due to invalid IL or missing references)
		//IL_047b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0485: Expected O, but got Unknown
		//IL_0485: Unknown result type (might be due to invalid IL or missing references)
		//IL_048d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0499: Expected O, but got Unknown
		//IL_04a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04af: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04be: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e3: Expected O, but got Unknown
		//IL_04f7: Unknown result type (might be due to invalid IL or missing references)
		if (ready)
		{
			if (usedInventoryTexture || (Object)(object)FindTexture("InventorySlot") == (Object)null)
			{
				return;
			}
			ready = false;
		}
		ready = true;
		Texture2D val = FindTexture("Ground026_2K_AmbientOcclusion");
		Texture2D val2 = FindTexture("InventorySlot");
		Texture2D val3 = FindTexture("InventorySlotOverlay");
		usedInventoryTexture = (Object)(object)val2 != (Object)null;
		Texture2D val4 = val ?? Solid("Muck Native Stone Fallback", Color.white);
		Texture2D source = val2 ?? val3 ?? val4;
		dimTexture = Solid("Muck Native Dim", new Color(0f, 0f, 0f, 0.58f));
		buttonTexture = Tinted((Texture)(object)val4, "Muck Native Button", new Color(0.538f, 0.408f, 0.241f, 1f), 128);
		buttonHoverTexture = Tinted((Texture)(object)val4, "Muck Native Button Hover", new Color(0.21f, 0.12f, 0.07f, 1f), 128);
		buttonActiveTexture = Tinted((Texture)(object)val4, "Muck Native Button Active", new Color(0.11f, 0.06f, 0.035f, 1f), 128);
		windowTexture = Tinted((Texture)(object)val4, "Muck Native Window", new Color(0.205f, 0.125f, 0.075f, 0.985f), 192);
		cardTexture = Tinted((Texture)(object)source, "Muck Native Inventory Panel", new Color(0.63f, 0.405f, 0.3f, 0.985f), 128);
		cardHoverTexture = Tinted((Texture)(object)source, "Muck Native Inventory Panel Hover", new Color(0.82f, 0.53f, 0.34f, 1f), 128);
		inputTexture = Tinted((Texture)(object)source, "Muck Native Input", new Color(0.38f, 0.235f, 0.17f, 1f), 128);
		accentTexture = Solid("Muck Native Orange", Accent);
		transparentTexture = Solid("Muck Native Transparent", Color.clear);
		nativeFont = FindNativeFont();
		GUIStyle val5 = new GUIStyle(GUI.skin.box);
		val5.normal.background = windowTexture;
		val5.border = new RectOffset(8, 8, 8, 8);
		val5.padding = new RectOffset(24, 24, 20, 22);
		Window = WithFont(val5);
		GUIStyle val6 = new GUIStyle(GUI.skin.box);
		val6.normal.background = cardTexture;
		val6.border = new RectOffset(9, 9, 9, 9);
		val6.padding = new RectOffset(14, 14, 12, 12);
		val6.margin = new RectOffset(3, 3, 4, 4);
		Card = WithFont(val6);
		Title = TextStyle(34, (FontStyle)1, (TextAnchor)3, Accent);
		Heading = TextStyle(20, (FontStyle)1, (TextAnchor)3, Accent);
		Label = TextStyle(16, (FontStyle)1, (TextAnchor)3, Text);
		Muted = TextStyle(14, (FontStyle)1, (TextAnchor)3, MutedText);
		Centered = TextStyle(16, (FontStyle)1, (TextAnchor)4, Text);
		Button = ButtonStyle(buttonTexture, buttonHoverTexture, buttonActiveTexture, Accent);
		PrimaryButton = ButtonStyle(buttonTexture, buttonHoverTexture, buttonActiveTexture, Color.white);
		CardButton = ButtonStyle(cardTexture, cardHoverTexture, buttonActiveTexture, Text);
		WorldButton = new GUIStyle(CardButton)
		{
			alignment = (TextAnchor)3,
			fontSize = 18,
			padding = new RectOffset(24, 18, 10, 10),
			wordWrap = false,
			richText = true
		};
		Tab = ButtonStyle(buttonTexture, buttonHoverTexture, buttonActiveTexture, MutedText);
		ActiveTab = ButtonStyle(buttonHoverTexture, buttonActiveTexture, buttonActiveTexture, Accent);
		GUIStyle val7 = new GUIStyle(GUI.skin.textField);
		val7.normal.background = inputTexture;
		val7.normal.textColor = Text;
		val7.focused.background = cardHoverTexture;
		val7.focused.textColor = Color.white;
		val7.hover.background = inputTexture;
		val7.hover.textColor = Color.white;
		val7.border = new RectOffset(9, 9, 9, 9);
		val7.padding = new RectOffset(12, 12, 7, 7);
		val7.fontSize = 16;
		val7.fontStyle = (FontStyle)1;
		Input = WithFont(val7);
		GUIStyle val8 = new GUIStyle(Card)
		{
			alignment = (TextAnchor)4,
			fontSize = 15,
			fontStyle = (FontStyle)1
		};
		val8.normal.background = cardTexture;
		val8.normal.textColor = Text;
		Hud = WithFont(val8);
		CloseButton = ButtonStyle(transparentTexture, buttonHoverTexture, buttonActiveTexture, Accent);
		CloseButton.fontSize = 28;
		ManualLogSource log = Plugin.Log;
		if (log != null)
		{
			object arg = (Object)(object)val != (Object)null;
			object arg2 = (Object)(object)val2 != (Object)null;
			Font obj = nativeFont;
			log.LogInfo((object)string.Format("Native Muck UI skin ready (menuTexture={0}, inventoryTexture={1}, font={2}).", arg, arg2, ((obj != null) ? ((Object)obj).name : null) ?? "skin default"));
		}
	}

	internal static void DrawDim()
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		Ensure();
		GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)dimTexture);
	}

	internal static void DrawAccent(Rect rect, Color? color = null)
	{
		//IL_0005: 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_0015: Unknown result type (might be due to invalid IL or missing references)
		Ensure();
		Color color2 = GUI.color;
		if (color.HasValue)
		{
			GUI.color = color.Value;
		}
		GUI.DrawTexture(rect, (Texture)(object)accentTexture);
		GUI.color = color2;
	}

	internal static void DrawCard(Rect rect, Color? tint = null)
	{
		//IL_0005: 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_0015: Unknown result type (might be due to invalid IL or missing references)
		Ensure();
		Color color = GUI.color;
		if (tint.HasValue)
		{
			GUI.color = tint.Value;
		}
		GUI.Box(rect, GUIContent.none, Card);
		GUI.color = color;
	}

	private static GUIStyle TextStyle(int size, FontStyle style, TextAnchor anchor, Color color)
	{
		//IL_000a: 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_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		GUIStyle val = new GUIStyle(GUI.skin.label)
		{
			fontSize = size,
			fontStyle = style,
			alignment = anchor,
			wordWrap = true
		};
		val.normal.textColor = color;
		return WithFont(val);
	}

	private static GUIStyle ButtonStyle(Texture2D normal, Texture2D hover, Texture2D active, Color text)
	{
		//IL_000a: 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)
		//IL_0021: 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_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: 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_0055: 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_006b: 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_007b: 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_008d: 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_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: 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_00c1: 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_00d7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Expected O, but got Unknown
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_011d: Expected O, but got Unknown
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Expected O, but got Unknown
		//IL_0131: Expected O, but got Unknown
		GUIStyle val = new GUIStyle(GUI.skin.button);
		val.normal.background = normal;
		val.normal.textColor = text;
		val.hover.background = hover;
		val.hover.textColor = Color.white;
		val.active.background = active;
		val.active.textColor = Color.white;
		val.focused.background = hover;
		val.focused.textColor = Color.white;
		val.onNormal.background = normal;
		val.onNormal.textColor = text;
		val.onHover.background = hover;
		val.onHover.textColor = Color.white;
		val.onActive.background = active;
		val.onActive.textColor = Color.white;
		val.onFocused.background = hover;
		val.onFocused.textColor = Color.white;
		val.border = new RectOffset(6, 6, 6, 6);
		val.alignment = (TextAnchor)4;
		val.fontSize = 17;
		val.fontStyle = (FontStyle)1;
		val.padding = new RectOffset(12, 12, 8, 8);
		val.margin = new RectOffset(3, 3, 3, 3);
		return WithFont(val);
	}

	private static GUIStyle WithFont(GUIStyle style)
	{
		if ((Object)(object)nativeFont != (Object)null)
		{
			style.font = nativeFont;
		}
		return style;
	}

	private static Font FindNativeFont()
	{
		Font val = ((IEnumerable<Font>)Resources.FindObjectsOfTypeAll<Font>()).FirstOrDefault((Func<Font, bool>)((Font value) => (Object)(object)value != (Object)null && ((Object)value).name.IndexOf("Roboto", StringComparison.OrdinalIgnoreCase) >= 0));
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		try
		{
			return Font.CreateDynamicFontFromOSFont(Font.GetOSInstalledFontNames().FirstOrDefault((string value) => value.IndexOf("Roboto", StringComparison.OrdinalIgnoreCase) >= 0) ?? "Arial", 24);
		}
		catch
		{
			GUISkin skin = GUI.skin;
			return (skin != null) ? skin.font : null;
		}
	}

	private static Texture2D FindTexture(string name)
	{
		return ((IEnumerable<Texture2D>)Resources.FindObjectsOfTypeAll<Texture2D>()).FirstOrDefault((Func<Texture2D, bool>)((Texture2D value) => (Object)(object)value != (Object)null && string.Equals(((Object)value).name, name, StringComparison.OrdinalIgnoreCase)));
	}

	private static Texture2D Tinted(Texture source, string name, Color tint, int size)
	{
		//IL_0022: 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_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Expected O, but got Unknown
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: 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_009b: 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_00c2: 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_00e9: 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_0111: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: Unknown result type (might be due to invalid IL or missing references)
		RenderTexture active = RenderTexture.active;
		RenderTexture temporary = RenderTexture.GetTemporary(size, size, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)0);
		try
		{
			Graphics.Blit(source, temporary);
			RenderTexture.active = temporary;
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false)
			{
				name = name,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)0
			};
			val.ReadPixels(new Rect(0f, 0f, (float)size, (float)size), 0, 0, false);
			Color32[] pixels = val.GetPixels32();
			for (int i = 0; i < pixels.Length; i++)
			{
				Color32 val2 = pixels[i];
				val2.r = (byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)val2.r * tint.r), 0, 255);
				val2.g = (byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)val2.g * tint.g), 0, 255);
				val2.b = (byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)val2.b * tint.b), 0, 255);
				val2.a = (byte)Mathf.Clamp(Mathf.RoundToInt((float)(int)val2.a * tint.a), 0, 255);
				pixels[i] = val2;
			}
			val.SetPixels32(pixels);
			val.Apply(false, true);
			Object.DontDestroyOnLoad((Object)(object)val);
			return val;
		}
		finally
		{
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
		}
	}

	private static Texture2D Solid(string name, Color color)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0028: 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_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false)
		{
			name = name,
			filterMode = (FilterMode)0,
			wrapMode = (TextureWrapMode)1
		};
		val.SetPixels((Color[])(object)new Color[4] { color, color, color, color });
		val.Apply(false, true);
		Object.DontDestroyOnLoad((Object)(object)val);
		return val;
	}
}
internal sealed class ReforgedRuntime : MonoBehaviour
{
	private bool visible;

	private int tab;

	private Rect window = new Rect(60f, 50f, 820f, 690f);

	private Vector2 lobbyScroll;

	private Vector2 saveScroll;

	private Lobby[] lobbies = Array.Empty<Lobby>();

	private bool refreshing;

	private bool creatingLobby;

	private string status = string.Empty;

	private float statusUntil;

	private float nextAutosave;

	private CursorLockMode previousLock;

	private bool previousCursor;

	private bool previousInputActive;

	private float nextNativeUiRefresh;

	private int selectedWorldSlot = -1;

	private int deleteConfirmSlot = -1;

	private float deleteConfirmUntil;

	private string savedWorldVisibility = "friends";

	private bool quitSaveRequested;

	internal static ReforgedRuntime Instance { get; private set; }

	private void Awake()
	{
		Instance = this;
		Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		TextureOverrideService.Initialize();
		RunSaveService.Initialize();
		SceneManager.sceneLoaded += OnSceneLoaded;
		nextAutosave = Time.unscaledTime + (float)Mathf.Max(30, Plugin.Settings.AutosaveSeconds.Value);
		((MonoBehaviour)this).StartCoroutine(ApplySceneServices());
	}

	private void OnDestroy()
	{
		if (visible)
		{
			CloseWindow();
		}
		SceneManager.sceneLoaded -= OnSceneLoaded;
		if ((Object)(object)Instance == (Object)(object)this)
		{
			Instance = null;
		}
	}

	private void OnApplicationQuit()
	{
		if (!quitSaveRequested)
		{
			quitSaveRequested = true;
			RunSaveService.SaveBeforeExit("application quit");
		}
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		NativeMenuIntegration.ResetSceneState();
		nextNativeUiRefresh = 0f;
		((MonoBehaviour)this).StartCoroutine(ApplySceneServices());
	}

	private IEnumerator ApplySceneServices()
	{
		yield return null;
		UiStabilityService.CleanupLegacyTextOverlays();
		TextureOverrideService.ApplyAll();
		NativeMenuIntegration.Apply();
	}

	private void Update()
	{
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Invalid comparison between Unknown and I4
		if (visible && Input.GetKeyDown((KeyCode)27))
		{
			CloseWindow();
			return;
		}
		if (Input.GetKeyDown((KeyCode)287))
		{
			Toggle();
		}
		if (Input.GetKeyDown((KeyCode)286))
		{
			SaveActiveSlot();
		}
		if (Input.GetKeyDown((KeyCode)290))
		{
			ContinueSlot(Mathf.Clamp(Plugin.Settings.ActiveSaveSlot.Value, 1, 24));
		}
		DetailedMapService.TickDiscovery();
		if (Time.unscaledTime >= nextNativeUiRefresh)
		{
			nextNativeUiRefresh = Time.unscaledTime + 5f;
			NativeMenuIntegration.Apply();
			NativeMenuIntegration.RefreshPauseButton();
		}
		if (Plugin.Settings.EnableRunSaves.Value && Time.unscaledTime >= nextAutosave)
		{
			nextAutosave = Time.unscaledTime + (float)Mathf.Max(30, Plugin.Settings.AutosaveSeconds.Value);
			if ((Object)(object)GameManager.instance != (Object)null && LocalClient.serverOwner && (int)GameManager.state == 1)
			{
				RunSaveService.SaveSlot(Mathf.Clamp(Plugin.Settings.ActiveSaveSlot.Value, 1, 24), automatic: true);
			}
		}
	}

	internal void Notify(string message, float seconds = 4f)
	{
		status = message ?? string.Empty;
		statusUntil = Time.unscaledTime + seconds;
		Plugin.Log.LogInfo((object)message);
	}

	internal void StartManagedCoroutine(IEnumerator routine)
	{
		if (routine != null)
		{
			((MonoBehaviour)this).StartCoroutine(routine);
		}
	}

	private void Toggle()
	{
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		if (!visible)
		{
			visible = true;
			float num = Mathf.Min(840f, (float)Screen.width - 32f);
			float num2 = Mathf.Min(720f, (float)Screen.height - 32f);
			window = new Rect(((float)Screen.width - num) * 0.5f, ((float)Screen.height - num2) * 0.5f, num, num2);
			previousLock = Cursor.lockState;
			previousCursor = Cursor.visible;
			previousInputActive = (Object)(object)PlayerInput.Instance != (Object)null && PlayerInput.Instance.active;
			if ((Object)(object)PlayerInput.Instance != (Object)null)
			{
				PlayerInput.Instance.active = false;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}
		else
		{
			CloseWindow();
		}
	}

	internal void OpenPanel(int selectedTab)
	{
		tab = Mathf.Clamp(selectedTab, 0, 2);
		if (!visible)
		{
			Toggle();
		}
		if (tab <= 1)
		{
			RefreshLobbies();
		}
	}

	private void CloseWindow()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		visible = false;
		if ((Object)(object)PlayerInput.Instance != (Object)null)
		{
			PlayerInput.Instance.active = previousInputActive;
		}
		Cursor.lockState = previousLock;
		Cursor.visible = previousCursor;
	}

	private void OnGUI()
	{
		//IL_00f8: 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_0118: Expected O, but got Unknown
		//IL_0113: 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)
		if (visible)
		{
			ReforgedGuiTheme.Ensure();
			ReforgedGuiTheme.DrawDim();
			float num = Mathf.Min(840f, (float)Screen.width - 32f);
			float num2 = Mathf.Min(720f, (float)Screen.height - 32f);
			((Rect)(ref window)).width = Mathf.Max(600f, num);
			((Rect)(ref window)).height = Mathf.Max(520f, num2);
			((Rect)(ref window)).x = Mathf.Clamp(((Rect)(ref window)).x, 16f, Mathf.Max(16f, (float)Screen.width - ((Rect)(ref window)).width - 16f));
			((Rect)(ref window)).y = Mathf.Clamp(((Rect)(ref window)).y, 16f, Mathf.Max(16f, (float)Screen.height - ((Rect)(ref window)).height - 16f));
			window = GUI.Window(925110, window, new WindowFunction(DrawWindow), GUIContent.none, ReforgedGuiTheme.Window);
		}
	}

	private void DrawWindow(int id)
	{
		//IL_0045: 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_020a: Unknown result type (might be due to invalid IL or missing references)
		string text = ((tab == 0) ? "Public Servers" : ((tab == 1) ? "Private / Friends Servers" : "Select World"));
		GUI.Label(new Rect(24f, 14f, ((Rect)(ref window)).width - 100f, 40f), text, ReforgedGuiTheme.Title);
		if (GUI.Button(new Rect(((Rect)(ref window)).width - 62f, 16f, 38f, 38f), "×", ReforgedGuiTheme.CloseButton))
		{
			Toggle();
			return;
		}
		GUILayout.Space(58f);
		if (tab <= 1)
		{
			DrawLobbies();
		}
		else
		{
			DrawSaves();
		}
		GUILayout.FlexibleSpace();
		if (Time.unscaledTime < statusUntil)
		{
			GUILayout.Label(status, ReforgedGuiTheme.Hud, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) });
		}
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		if (GUILayout.Button("Public Servers", (tab == 0) ? ReforgedGuiTheme.ActiveTab : ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			tab = 0;
			RefreshLobbies();
		}
		if (GUILayout.Button("Private / Friends", (tab == 1) ? ReforgedGuiTheme.ActiveTab : ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			tab = 1;
			RefreshLobbies();
		}
		if (GUILayout.Button("Worlds", (tab == 2) ? ReforgedGuiTheme.ActiveTab : ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			tab = 2;
		}
		if (GUILayout.Button("Back", ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[2]
		{
			GUILayout.Width(120f),
			GUILayout.Height(38f)
		}))
		{
			CloseWindow();
		}
		GUILayout.EndHorizontal();
		GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref window)).width - 72f, 80f));
	}

	private void DrawLobbies()
	{
		//IL_0117: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.EnableLobbyBrowser.Value)
		{
			GUILayout.Label(LocalizationService.T("lobby_disabled"), ReforgedGuiTheme.Centered, Array.Empty<GUILayoutOption>());
			return;
		}
		bool flag = tab == 1;
		GUILayout.Label(flag ? "Join a friend's private or friends-only server" : "Join without a lobby code", ReforgedGuiTheme.Heading, Array.Empty<GUILayoutOption>());
		GUILayout.Label(flag ? "Friends currently playing a compatible Muck Replayable lobby are shown here. Steam invitations also join directly." : "Only compatible public Muck Replayable games are shown.", ReforgedGuiTheme.Muted, Array.Empty<GUILayoutOption>());
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUI.enabled = !refreshing && (Object)(object)SteamManager.Instance != (Object)null && SteamManager.Instance.ConnectedToSteam();
		if (GUILayout.Button(LocalizationService.T("refresh"), ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			RefreshLobbies();
		}
		if (GUILayout.Button(LocalizationService.T("quick_join"), ReforgedGuiTheme.PrimaryButton, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(38f) }))
		{
			QuickJoin();
		}
		GUI.enabled = true;
		GUILayout.EndHorizontal();
		GUILayout.Space(10f);
		lobbyScroll = GUILayout.BeginScrollView(lobbyScroll, ReforgedGuiTheme.Card, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(Mathf.Max(250f, ((Rect)(ref window)).height - 245f)) });
		if (!refreshing && (lobbies == null || lobbies.Length == 0))
		{
			GUILayout.Space(70f);
			GUILayout.Label(flag ? "No compatible private/friends lobbies found" : LocalizationService.T("no_lobbies"), ReforgedGuiTheme.Centered, Array.Empty<GUILayoutOption>());
		}
		else if (lobbies != null)
		{
			Lobby[] array = lobbies;
			for (int i = 0; i < array.Length; i++)
			{
				Lobby lobby = array[i];
				GUILayout.BeginVertical(ReforgedGuiTheme.Card, Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				string text = ((Lobby)(ref lobby)).GetData("MRName");
				if (string.IsNullOrWhiteSpace(text))
				{
					Friend owner = ((Lobby)(ref lobby)).Owner;
					text = ((Friend)(ref owner)).Name;
				}
				bool flag2 = ((Lobby)(ref lobby)).GetData("MRInProgress") == "1";
				GUILayout.Label(text, ReforgedGuiTheme.Heading, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.ExpandWidth(true),
					GUILayout.Height(30f)
				});
				if (GUILayout.Button(LocalizationService.T("join"), ReforgedGuiTheme.PrimaryButton, (GUILayoutOption[])(object)new GUILayoutOption[2]
				{
					GUILayout.Width(108f),
					GUILayout.Height(38f)
				}))
				{
					JoinLobby(lobby);
				}
				GUILayout.EndHorizontal();
				string text2 = (flag2 ? ("Running world • Day " + ((Lobby)(ref lobby)).GetData("MRDay")) : "Waiting in lobby");
				GUILayout.Label(string.Format("{0}     {1}/{2} players     v{3}", text2, ((Lobby)(ref lobby)).MemberCount, ((Lobby)(ref lobby)).MaxMembers, ((Lobby)(ref lobby)).GetData("MRVersion")), ReforgedGuiTheme.Muted, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(24f) });
				GUILayout.EndVertical();
			}
		}
		GUILayout.EndScrollView();
	}

	private void DrawSaves()
	{
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0123: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		GUILayout.Label("Your Worlds", ReforgedGuiTheme.Heading, Array.Empty<GUILayoutOption>());
		GUILayout.Label($"Worlds autosave every {Mathf.Max(30, Plugin.Settings.AutosaveSeconds.Value)} seconds. Most recently played worlds appear first.", ReforgedGuiTheme.Muted, Array.Empty<GUILayoutOption>());
		GUILayout.Space(10f);
		float num = ((Rect)(ref window)).height - ((selectedWorldSlot > 0) ? 470f : 315f);
		saveScroll = GUILayout.BeginScrollView(saveScroll, ReforgedGuiTheme.Card, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(Mathf.Max(190f, num)) });
		List<RunSaveSummary> worldSummaries = RunSaveService.GetWorldSummaries();
		if (selectedWorldSlot > 0 && !worldSummaries.Any((RunSaveSummary value) => value.Slot == selectedWorldSlot))
		{
			selectedWorldSlot = -1;
		}
		if (worldSummaries.Count == 0)
		{
			GUILayout.Space(90f);
			GUILayout.Label("No saved worlds yet", ReforgedGuiTheme.Centered, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Create a world with Host Lobby. It will appear here after the first autosave.", ReforgedGuiTheme.Centered, Array.Empty<GUILayoutOption>());
		}
		foreach (RunSaveSummary item in worldSummaries)
		{
			string text = ((object)(GameMode)item.GameMode/*cast due to .constrained prefix*/).ToString();
			string text2 = ((object)(Difficulty)item.Difficulty/*cast due to .constrained prefix*/).ToString();
			int num2 = Mathf.Max(0, Mathf.RoundToInt(item.TotalTime / 60f));
			string text3 = $"{item.WorldName}  •  Day {item.Day}  •  {text2} {text}  •  {num2 / 60}h {num2 % 60:00}m  •  {item.Timestamp}  •  Seed {item.Seed}";
			GUI.enabled = (Object)(object)GameManager.instance == (Object)null;
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(text3, ReforgedGuiTheme.WorldButton, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(56f) }))
			{
				selectedWorldSlot = item.Slot;
				deleteConfirmSlot = -1;
			}
			if (GUILayout.Button((deleteConfirmSlot == item.Slot && Time.unscaledTime < deleteConfirmUntil) ? "Confirm" : "Delete", ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(112f),
				GUILayout.Height(56f)
			}))
			{
				HandleWorldDelete(item.Slot);
			}
			GUILayout.EndHorizontal();
			GUI.enabled = true;
		}
		GUILayout.EndScrollView();
		RunSaveSummary runSaveSummary = worldSummaries.FirstOrDefault((RunSaveSummary value) => value.Slot == selectedWorldSlot);
		if (runSaveSummary.Exists)
		{
			GUILayout.Label($"Selected: {runSaveSummary.WorldName}  •  Day {runSaveSummary.Day}  •  Seed {runSaveSummary.Seed}", ReforgedGuiTheme.Heading, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Lobby access", ReforgedGuiTheme.Muted, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(105f),
				GUILayout.Height(34f)
			});
			string[] array = new string[3] { "public", "friends", "private" };
			foreach (string text4 in array)
			{
				if (GUILayout.Button((text4 == "public") ? "Public" : ((text4 == "friends") ? "Friends" : "Private"), (savedWorldVisibility == text4) ? ReforgedGuiTheme.ActiveTab : ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
				{
					savedWorldVisibility = text4;
				}
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = (Object)(object)GameManager.instance == (Object)null;
			if (GUILayout.Button("Host Selected World", ReforgedGuiTheme.PrimaryButton, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(42f) }))
			{
				int slot = runSaveSummary.Slot;
				Plugin.Settings.ActiveSaveSlot.Value = slot;
				CloseWindow();
				ContinueSlot(slot, savedWorldVisibility);
			}
			if (GUILayout.Button((deleteConfirmSlot == runSaveSummary.Slot && Time.unscaledTime < deleteConfirmUntil) ? "Confirm Delete" : "Delete World", ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(170f),
				GUILayout.Height(42f)
			}))
			{
				HandleWorldDelete(runSaveSummary.Slot);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
		}
		GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
		GUI.enabled = (Object)(object)GameManager.instance == (Object)null;
		if (GUILayout.Button("Create New World", ReforgedGuiTheme.PrimaryButton, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(42f) }))
		{
			CloseWindow();
			MenuUI obj = Object.FindObjectOfType<MenuUI>();
			if (obj != null)
			{
				obj.StartLobby();
			}
		}
		GUI.enabled = (Object)(object)GameManager.instance != (Object)null && LocalClient.serverOwner;
		if (GUILayout.Button("Save Current World", ReforgedGuiTheme.Button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(42f) }))
		{
			SaveActiveSlot();
		}
		GUI.enabled = true;
		GUILayout.EndHorizontal();
	}

	private void HandleWorldDelete(int slot)
	{
		selectedWorldSlot = slot;
		if (deleteConfirmSlot == slot && Time.unscaledTime < deleteConfirmUntil)
		{
			if (RunSaveService.ArchiveSlot(slot))
			{
				Notify("World deleted. A recoverable copy was moved to Saves/Trash.", 6f);
				selectedWorldSlot = -1;
			}
			else
			{
				Notify("The world could not be deleted.", 6f);
			}
			deleteConfirmSlot = -1;
		}
		else
		{
			deleteConfirmSlot = slot;
			deleteConfirmUntil = Time.unscaledTime + 5f;
		}
	}

	private async void RefreshLobbies()
	{
		if (refreshing)
		{
			return;
		}
		refreshing = true;
		try
		{
			if (tab == 1)
			{
				List<Lobby> friendLobbies = new List<Lobby>();
				foreach (Friend friend2 in SteamFriends.GetFriends())
				{
					Friend friend = friend2;
					if (!((Friend)(ref friend)).IsPlayingThisGame)
					{
						continue;
					}
					await ((Friend)(ref friend)).RequestInfoAsync();
					FriendGameInfo? gameInfo = ((Friend)(ref friend)).GameInfo;
					Lobby? obj;
					if (!gameInfo.HasValue)
					{
						obj = null;
					}
					else
					{
						FriendGameInfo valueOrDefault = gameInfo.GetValueOrDefault();
						obj = ((FriendGameInfo)(ref valueOrDefault)).Lobby;
					}
					Lobby? val = obj;
					if (val.HasValue)
					{
						Lobby value = val.Value;
						((Lobby)(ref value)).Refresh();
						if (((Lobby)(ref value)).GetData("MRProtocol") == "15" && ((Lobby)(ref value)).GetData("MRRules") == LobbyMetadata.RulesSignature)
						{
							friendLobbies.Add(value);
						}
					}
				}
				lobbies = (from lobby in friendLobbies
					group lobby by ((Lobby)(ref lobby)).Id.Value into @group
					select @group.First()).ToArray();
				Array.Sort(lobbies, (Lobby a, Lobby b) => ((Lobby)(ref b)).MemberCount.CompareTo(((Lobby)(ref a)).MemberCount));
			}
			else
			{
				LobbyQuery val2 = SteamMatchmaking.LobbyList;
				val2 = ((LobbyQuery)(ref val2)).WithKeyValue("MRProtocol", "15");
				val2 = ((LobbyQuery)(ref val2)).WithSlotsAvailable(1);
				val2 = ((LobbyQuery)(ref val2)).WithMaxResults(50);
				val2 = ((LobbyQuery)(ref val2)).FilterDistanceWorldwide();
				lobbies = Array.FindAll((await ((LobbyQuery)(ref val2)).RequestAsync()) ?? Array.Empty<Lobby>(), (Lobby lobby) => ((Lobby)(ref lobby)).GetData("MRRules") == LobbyMetadata.RulesSignature);
				Array.Sort(lobbies, (Lobby a, Lobby b) => ((Lobby)(ref b)).MemberCount.CompareTo(((Lobby)(ref a)).MemberCount));
			}
		}
		catch (Exception ex)
		{
			Notify(LocalizationService.T("lobby_refresh_failed") + ex.Message);
			lobbies = Array.Empty<Lobby>();
		}
		finally
		{
			refreshing = false;
		}
	}

	private void QuickJoin()
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		if (lobbies != null && lobbies.Length != 0)
		{
			JoinLobby(lobbies[0]);
		}
		else
		{
			RefreshLobbies();
		}
	}

	private void JoinLobby(Lobby lobby)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		SteamManager instance = SteamManager.Instance;
		if ((Object)(object)instance == (Object)null || !instance.ConnectedToSteam())
		{
			Notify(LocalizationService.T("lobby_refresh_failed"));
			return;
		}
		instance.JoinLobby(lobby);
		Toggle();
	}

	private async void CreateLobby(string visibility)
	{
		if (creatingLobby || (Object)(object)SteamManager.Instance == (Object)null)
		{
			return;
		}
		creatingLobby = true;
		try
		{
			if (!((!(visibility == "friends")) ? (await SteamManager.Instance.CreateLobby(0)) : (await SteamManager.Instance.CreateFriendLobby())))
			{
				Notify(LocalizationService.T("lobby_create_failed"));
				return;
			}
			Lobby currentLobby = SteamManager.Instance.currentLobby;
			if (visibility == "private")
			{
				((Lobby)(ref currentLobby)).SetPrivate();
			}
			else if (visibility == "friends")
			{
				((Lobby)(ref currentLobby)).SetFriendsOnly();
			}
			else
			{
				((Lobby)(ref currentLobby)).SetPublic();
			}
			LobbyMetadata.Apply(currentLobby);
			Notify(LocalizationService.T("lobby_created"));
		}
		catch (Exception ex)
		{
			Notify(LocalizationService.T("lobby_create_failed") + ex.Message);
			Plugin.Log.LogWarning((object)("Lobby creation failed: " + ex));
		}
		finally
		{
			creatingLobby = false;
		}
	}

	private void SaveActiveSlot()
	{
		if (Plugin.Settings.EnableRunSaves.Value)
		{
			RunSaveService.SaveSlot(Mathf.Clamp(Plugin.Settings.ActiveSaveSlot.Value, 1, 24), automatic: false);
		}
	}

	private void ContinueSlot(int slot, string visibility = "friends")
	{
		if (Plugin.Settings.EnableRunSaves.Value)
		{
			((MonoBehaviour)this).StartCoroutine(ContinueRoutine(slot, visibility));
		}
	}

	private IEnumerator ContinueRoutine(int slot, string visibility)
	{
		if ((Object)(object)GameManager.instance != (Object)null)
		{
			Notify(LocalizationService.T("leave_run_before_load"), 7f);
		}
		else
		{
			if (!RunSaveService.QueueSlot(slot))
			{
				yield break;
			}
			if ((Object)(object)SteamManager.Instance == (Object)null)
			{
				Notify(LocalizationService.T("steam_not_ready"));
				RunSaveService.CancelPendingLoad();
				yield break;
			}
			Task<bool> task;
			try
			{
				task = SteamManager.Instance.CreateLobby(0);
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Saved-run lobby creation failed before starting: " + ex));
				Notify(LocalizationService.T("saved_lobby_failed"));
				RunSaveService.CancelPendingLoad();
				yield break;
			}
			if (task == null)
			{
				Notify(LocalizationService.T("saved_lobby_failed"));
				RunSaveService.CancelPendingLoad();
				yield break;
			}
			while (!task.IsCompleted)
			{
				yield return null;
			}
			if (task.IsCanceled || task.IsFaulted || !task.Result)
			{
				Notify(LocalizationService.T("saved_lobby_failed"));
				RunSaveService.CancelPendingLoad();
				yield break;
			}
			if ((Object)(object)SteamManager.Instance == (Object)null || (Object)(object)SteamLobby.Instance == (Object)null)
			{
				Notify(LocalizationService.T("saved_scene_not_ready"));
				RunSaveService.CancelPendingLoad();
				SteamManager instance = SteamManager.Instance;
				if (instance != null)
				{
					instance.leaveLobby();
				}
				yield break;
			}
			try
			{
				Lobby currentLobby = SteamManager.Instance.currentLobby;
				if (visibility == "private")
				{
					((Lobby)(ref currentLobby)).SetPrivate();
				}
				else if (visibility == "public")
				{
					((Lobby)(ref currentLobby)).SetPublic();
				}
				else
				{
					((Lobby)(ref currentLobby)).SetFriendsOnly();
				}
				((Lobby)(ref currentLobby)).SetJoinable(true);
				LobbyMetadata.Apply(currentLobby);
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("Saved-run lobby metadata failed: " + ex2));
				Notify(LocalizationService.T("saved_prepare_failed"));
				RunSaveService.CancelPendingLoad();
				SteamManager instance2 = SteamManager.Instance;
				if (instance2 != null)
				{
					instance2.leaveLobby();
				}
				yield break;
			}
			yield return (object)new WaitForSecondsRealtime(0.75f);
			if ((Object)(object)SteamManager.Instance != (Object)null && (Object)(object)SteamLobby.Instance != (Object)null && (Object)(object)LobbyVisuals.Instance != (Object)null)
			{
				ApplyPendingLobbyControls();
				LobbyVisuals.Instance.OpenLobby(SteamManager.Instance.currentLobby);
				string text = ((visibility == "public") ? "public" : ((visibility == "private") ? "private/invite-only" : "friends-only"));
				Notify("Saved world is ready as " + text + ". Press Start Game when everyone is in the lobby.", 8f);
			}
			else
			{
				Notify(LocalizationService.T("saved_lobby_closed"));
				RunSaveService.CancelPendingLoad();
			}
		}
	}

	private static void ApplyPendingLobbyControls()
	{
		RunSaveData pending = RunSaveService.Pending;
		LobbySettings instance = LobbySettings.Instance;
		if (pending != null && !((Object)(object)instance == (Object)null))
		{
			if ((Object)(object)instance.seed != (Object)null)
			{
				instance.seed.text = pending.Seed.ToString(CultureInfo.InvariantCulture);
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(UiSettings), "UpdateSetting", (Type[])null, (Type[])null);
			methodInfo?.Invoke(instance.difficultySetting, new object[1] { pending.Difficulty });
			methodInfo?.Invoke(instance.gamemodeSetting, new object[1] { pending.GameMode });
			methodInfo?.Invoke(instance.friendlyFireSetting, new object[1] { pending.FriendlyFire });
		}
	}
}
[Serializable]
public sealed class RunSaveData
{
	public int FormatVersion = 4;

	public string ModVersion = "0.9.4";

	public string WorldName;

	public string TimestampUtc;

	public ulong SteamId;

	public int Seed;

	public int Day;

	public float DayTime;

	public float TotalTime;

	public int Difficulty;

	public int GameMode;

	public int FriendlyFire;

	public int ResourceGlobalId;

	public int ItemGlobalId;

	public PlayerRunSave Player = new PlayerRunSave();

	public List<int> RemovedResourceIds = new List<int>();

	public List<BuildRunSave> Builds = new List<BuildRunSave>();

	public List<WorldItemRunSave> WorldItems = new List<WorldItemRunSave>();

	public List<string> DiscoveredLandmarks = new List<string>();
}
[Serializable]
public sealed class PlayerRunSave
{
	public Vec3 Position = new Vec3();

	public float Hp;

	public float Shield;

	public float Stamina;

	public float Hunger;

	public int DraculaStacks;

	public List<ItemStackSave> Inventory = new List<ItemStackSave>();

	public List<int> Powerups = new List<int>();

	public List<int> Armor = new List<int>();
}
[Serializable]
public sealed class ItemStackSave
{
	public int Cell;

	public int ItemId;

	public int Amount;
}
[Serializable]
public sealed class BuildRunSave
{
	public int ObjectId;

	public int ItemId;

	public int OwnerId;

	public Vec3 Position = new Vec3();

	public int YRotation;

	public int UpgradeTier;

	public int Hp;

	public int MaxHp;

	public List<ItemStackSave> Chest = new List<ItemStackSave>();
}
[Serializable]
public sealed class WorldItemRunSave
{
	public int ObjectId;

	public int ItemId;

	public bool IsPowerup;

	public int PowerupId = -1;

	public int Amount;

	public Vec3 Position = new Vec3();
}
[Serializable]
public sealed class Vec3
{
	public float X;

	public float Y;

	public float Z;

	public Vec3()
	{
	}

	public Vec3(Vector3 value)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		X = value.x;
		Y = value.y;
		Z = value.z;
	}

	public Vector3 ToVector3()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		return new Vector3(X, Y, Z);
	}
}
internal struct RunSaveSummary
{
	internal int Slot;

	internal bool Exists;

	internal string WorldName;

	internal int Day;

	internal int Seed;

	internal int Difficulty;

	internal int GameMode;

	internal float TotalTime;

	internal long TimestampTicks;

	internal string Timestamp;
}
internal static class RunSaveService
{
	private sealed class CachedSummary
	{
		internal string Fingerprint;

		internal RunSaveSummary Summary;
	}

	private sealed class FieldInfoCache
	{
		internal readonly FieldInfo Powerups = AccessTools.Field(typeof(PowerupInventory), "powerups");

		internal readonly FieldInfo PowerupUiDictionary = AccessTools.Field(typeof(PowerupUI), "powerups");

		internal readonly FieldInfo TotalTime = AccessTools.Field(typeof(DayCycle), "<totalTime>k__BackingField");
	}

	internal const int MaxWorldSlots = 24;

	private static readonly XmlSerializer Serializer = new XmlSerializer(typeof(RunSaveData));

	private static readonly HashSet<int> RemovedResources = new HashSet<int>();

	private static readonly Dictionary<int, CachedSummary> SummaryCache = new Dictionary<int, CachedSummary>();

	private static readonly FieldInfoCache Fields = new FieldInfoCache();

	private static string saveDirectory;

	private static bool restoring;

	private static int sessionSlot;

	private static int pendingSlot;

	private static string sessionWorldName;

	private static bool warnedNoAutosaveSlot;

	private static float lastExitSaveTime = -10f;

	internal static RunSaveData Pending { get; private set; }

	internal static void Initialize()
	{
		saveDirectory = Path.Combine(Paths.ConfigPath, "MuckReforged", "Saves");
		Directory.CreateDirectory(saveDirectory);
		sessionSlot = 0;
		pendingSlot = 0;
		sessionWorldName = null;
		SummaryCache.Clear();
	}

	internal static RunSaveSummary GetSummary(int slot)
	{
		string text = SaveFingerprint(slot);
		if (SummaryCache.TryGetValue(slot, out var value) && value.Fingerprint == text)
		{
			return value.Summary;
		}
		RunSaveData runSaveData = ReadSlot(slot, logErrors: false);
		if (runSaveData == null)
		{
			RunSaveSummary runSaveSummary = new RunSaveSummary
			{
				Slot = slot
			};
			SummaryCache[slot] = new CachedSummary
			{
				Fingerprint = text,
				Summary = runSaveSummary
			};
			return runSaveSummary;
		}
		string timestamp = runSaveData.TimestampUtc;
		if (DateTime.TryParse(runSaveData.TimestampUtc, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result))
		{
			timestamp = result.ToLocalTime().ToString("yyyy-MM-dd HH:mm", CultureInfo.CurrentCulture);
		}
		long timestampTicks = 0L;
		if (DateTime.TryParse(runSaveData.TimestampUtc, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result2))
		{
			timestampTicks = result2.ToUniversalTime().Ticks;
		}
		RunSaveSummary runSaveSummary2 = new RunSaveSummary
		{
			Slot = slot,
			Exists = true,
			WorldName = (string.IsNullOrWhiteSpace(runSaveData.WorldName) ? $"World {slot}" : runSaveData.WorldName.Trim()),
			Day = runSaveData.Day,
			Seed = runSaveData.Seed,
			Difficulty = runSaveData.Difficulty,
			GameMode = runSaveData.GameMode,
			TotalTime = runSaveData.TotalTime,
			TimestampTicks = timestampTicks,
			Timestamp = timestamp
		};
		SummaryCache[slot] = new CachedSummary
		{
			Fingerprint = text,
			Summary = runSaveSummary2
		};
		return runSaveSummary2;
	}

	internal static List<RunSaveSummary> GetWorldSummaries()
	{
		List<RunSaveSummary> list = new List<RunSaveSummary>();
		for (int i = 1; i <= 24; i++)
		{
			RunSaveSummary summary = GetSummary(i);
			if (summary.Exists)
			{
				list.Add(summary);
			}
		}
		return (from value in list
			orderby value.TimestampTicks descending, value.Slot
			select value).ToList();
	}

	internal static bool ArchiveSlot(int slot)
	{
		if ((Object)(object)GameManager.instance != (Object)null || slot < 1 || slot > 24)
		{
			return false;
		}
		if (!GetSummary(slot).Exists)
		{
			return false;
		}
		try
		{
			string text = SlotPath(slot);
			string text2 = Path.Combine(Path.Combine(saveDirectory, "Trash"), $"slot{slot}-{DateTime.UtcNow:yyyyMMdd-HHmmssfff}");
			Directory.CreateDirectory(text2);
			string[] array = new string[3]
			{
				string.Empty,
				".bak",
				".tmp"
			};
			foreach (string text3 in array)
			{
				string text4 = text + text3;
				if (File.Exists(text4))
				{
					File.Move(text4, Path.Combine(text2, Path.GetFileName(text4)));
				}
			}
			SummaryCache.Remove(slot);
			if (pendingSlot == slot || sessionSlot == slot)
			{
				CancelPendingLoad();
			}
			if (Plugin.Settings.ActiveSaveSlot.Value == slot)
			{
				Plugin.Settings.ActiveSaveSlot.Value = 1;
			}
			Plugin.Log.LogInfo((object)$"Moved world slot {slot} to recoverable trash: {text2}");
			return true;
		}
		catch (Exception arg)
		{
			Plugin.Log.LogError((object)$"Could not delete world slot {slot}: {arg}");
			return false;
		}
	}

	private static string SaveFingerprint(int slot)
	{
		string text = SlotPath(slot);
		return string.Concat(str2: FileFingerprint(text + ".bak"), str0: FileFingerprint(text), str1: "|");
	}

	private static string FileFingerprint(string path)
	{
		if (!File.Exists(path))
		{
			return "-";
		}
		FileInfo fileInfo = new FileInfo(path);
		return fileInfo.Length.ToString(CultureInfo.InvariantCulture) + ":" + fileInfo.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture);
	}

	internal static bool QueueSlot(int slot)
	{
		slot = Mathf.Clamp(slot, 1, 24);
		Pending = ReadSlot(slot, logErrors: true);
		if (Pending == null)
		{
			ReforgedRuntime.Instance?.Notify(string.Format(LocalizationService.T("save_slot_invalid"), slot));
			return false;
		}
		pendingSlot = slot;
		sessionSlot = slot;
		sessionWorldName = (string.IsNullOrWhiteSpace(Pending.WorldName) ? $"World {slot}" : Pending.WorldName.Trim());
		warnedNoAutosaveSlot = false;
		RemovedResources.Clear();
		foreach (int removedResourceId in Pending.RemovedResourceIds)
		{
			RemovedResources.Add(removedResourceId);
		}
		return true;
	}

	internal static void CancelPendingLoad()
	{
		Pending = null;
		pendingSlot = 0;
		sessionSlot = 0;
		RemovedResources.Clear();
	}

	internal static void SaveSlot(int slot, bool automatic)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Invalid comparison between Unknown and I4
		if (restoring || (Object)(object)GameManager.instance == (Object)null || GameManager.gameSettings == null)
		{
			return;
		}
		if (!LocalClient.serverOwner)
		{
			if (!automatic)
			{
				ReforgedRuntime.Instance?.Notify(LocalizationService.T("host_only"));
			}
			return;
		}
		if ((int)GameManager.state != 1 || (Object)(object)PlayerMovement.Instance == (Object)null || (Object)(object)InventoryUI.Instance == (Object)null || (Object)(object)PowerupInventory.Instance == (Object)null)
		{
			if (!automatic)
			{
				ReforgedRuntime.Instance?.Notify(LocalizationService.T("save_world_loading"));
			}
			return;
		}
		slot = (automatic ? ResolveAutosaveSlot(slot) : Mathf.Clamp(slot, 1, 24));
		if (slot == 0)
		{
			return;
		}
		if (!automatic)
		{
			sessionSlot = slot;
			if (string.IsNullOrWhiteSpace(sessionWorldName))
			{
				RunSaveSummary summary = GetSummary(slot);
				sessionWorldName = (summary.Exists ? summary.WorldName : $"World {slot}");
			}
			warnedNoAutosaveSlot = false;
		}
		try
		{
			RunSaveData runSaveData = Capture();
			string text = SlotPath(slot);
			string text2 = text + ".tmp";
			string text3 = text + ".bak";
			Directory.CreateDirectory(saveDirectory);
			using (FileStream stream = new FileStream(text2, FileMode.Create, FileAccess.Write, FileShare.None))
			{
				using GZipStream gZipStream = new GZipStream(stream, CompressionLevel.Fastest);
				Serializer.Serialize((Stream)gZipStream, (object)runSaveData);
			}
			if (File.Exists(text))
			{
				try
				{
					File.Replace(text2, text, text3, ignoreMetadataErrors: true);
				}
				catch
				{
					File.Copy(text, text3, overwrite: true);
					File.Delete(text);
					File.Move(text2, text);
				}
			}
			else
			{
				File.Move(text2, text);
			}
			Plugin.Settings.ActiveSaveSlot.Value = slot;
			SummaryCache.Remove(slot);
			if (!automatic)
			{
				ReforgedRuntime.Instance?.Notify(LocalizationService.T("saved"));
			}
			Plugin.Log.LogInfo((object)$"Saved run slot {slot}: day {runSaveData.Day}, builds {runSaveData.Builds.Count}, removed resources {runSaveData.RemovedResourceIds.Count}");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Run save failed: " + ex));
			if (!automatic)
			{
				ReforgedRuntime.Instance?.Notify(string.Format(LocalizationService.T("save_failed"), ex.Message));
			}
		}
	}

	internal static void SaveBeforeExit(string reason)
	{
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Invalid comparison between Unknown and I4
		if (Plugin.Settings.EnableRunSaves.Value && !(Time.realtimeSinceStartup - lastExitSaveTime < 0.5f) && !((Object)(object)GameManager.instance == (Object)null) && LocalClient.serverOwner && (int)GameManager.state == 1)
		{
			lastExitSaveTime = Time.realtimeSinceStartup;
			Plugin.Log.LogInfo((object)("Saving active host world before " + reason + "."));
			SaveSlot(Mathf.Clamp(Plugin.Settings.ActiveSaveSlot.Value, 1, 24), automatic: true);
		}
	}

	private static RunSaveData Capture()
	{
		//IL_006b: 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_00e1: Expected I4, but got Unknown
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Expected I4, but got Unknown
		//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Expected I4, but got Unknown
		GameSettings gameSettings = GameManager.gameSettings;
		RunSaveData obj = new RunSaveData
		{
			WorldName = (string.IsNullOrWhiteSpace(sessionWorldName) ? $"World {Mathf.Clamp(sessionSlot, 1, 24)}" : sessionWorldName),
			TimestampUtc = DateTime.UtcNow.ToString("O", CultureInfo.InvariantCulture)
		};
		SteamManager instance = SteamManager.Instance;
		obj.SteamId = ((instance != null) ? instance.PlayerSteamId.Value : 0);
		obj.Seed = gameSettings.Seed;
		obj.Day = GameManager.instance.currentDay;
		obj.DayTime = DayCycle.time;
		obj.TotalTime = ((Fields.TotalTime != null) ? ((float)Fields.TotalTime.GetValue(null)) : DayCycle.totalTime);
		obj.Difficulty = (int)gameSettings.difficulty;
		obj.GameMode = (int)gameSettings.gameMode;
		obj.FriendlyFire = (int)gameSettings.friendlyFire;
		obj.ResourceGlobalId = ResourceManager.globalId;
		obj.ItemGlobalId = ItemManager.currentId;
		obj.RemovedResourceIds = RemovedResources.OrderBy((int value) => value).ToList();
		obj.DiscoveredLandmarks = (from value in DetailedMapService.GetDiscoveredKeys()
			orderby value
			select value).ToList();
		CapturePlayer(obj.Player);
		CaptureBuilds(obj.Builds);
		CaptureWorldItems(obj.WorldItems);
		return obj;
	}

	private static void CapturePlayer(PlayerRunSave player)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)PlayerMovement.Instance != (Object)null)
		{
			player.Position = new Vec3(((Component)PlayerMovement.Instance).transform.position);
		}
		if ((Object)(object)PlayerStatus.Instance != (Object)null)
		{
			player.Hp = PlayerStatus.Instance.hp;
			player.Shield = PlayerStatus.Instance.shield;
			player.Stamina = PlayerStatus.Instance.stamina;
			player.Hunger = PlayerStatus.Instance.hunger;
			player.DraculaStacks = PlayerStatus.Instance.draculaStacks;
			if (PlayerStatus.Instance.armor != null)
			{
				player.Armor.AddRange(PlayerStatus.Instance.armor.Select((InventoryItem item) => (!((Object)(object)item == (Object)null)) ? item.id : (-1)));
			}
		}
		if (InventoryUI.Instance?.allCells != null)
		{
			for (int num = 0; num < InventoryUI.Instance.allCells.Length; num++)
			{
				InventoryItem val = InventoryUI.Instance.allCells[num]?.currentItem;
				if ((Object)(object)val != (Object)null)
				{
					player.Inventory.Add(new ItemStackSave
					{
						Cell = num,
						ItemId = val.id,
						Amount = val.amount
					});
				}
			}
		}
		if ((Object)(object)PowerupInventory.Instance != (Object)null && Fields.Powerups != null)
		{
			int[] array = (int[])Fields.Powerups.GetValue(PowerupInventory.Instance);
			if (array != null)
			{
				player.Powerups.AddRange(array);
			}
		}
	}

	private static void CaptureBuilds(List<BuildRunSave> output)
	{
		//IL_0177: 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)
		if (ResourceManager.Instance?.builds == null || ItemManager.Instance?.allItems == null)
		{
			return;
		}
		Dictionary<string, int> itemIdsByPrefab = ItemManager.Instance.allItems.Where((KeyValuePair<int, InventoryItem> pair) => (Object)(object)pair.Value != (Object)null && pair.Value.buildable && (Object)(object)pair.Value.prefab != (Object)null).GroupBy<KeyValuePair<int, InventoryItem>, string>((KeyValuePair<int, InventoryItem> pair) => ((Object)pair.Value.prefab).name, StringComparer.Ordinal).ToDictionary<IGrouping<string, KeyValuePair<int, InventoryItem>>, string, int>((IGrouping<string, KeyValuePair<int, InventoryItem>> group) => group.Key, (IGrouping<string, KeyValuePair<int, InventoryItem>> group) => group.First().Key, StringComparer.Ordinal);
		foreach (KeyValuePair<int, GameObject> item in ResourceManager.Instance.builds.OrderBy((KeyValuePair<int, GameObject> pair) => pair.Key))
		{
			GameObject value = item.Value;
			if ((Object)(object)value == (Object)null)
			{
				continue;
			}
			int num = FindBuildItemId(value, itemIdsByPrefab);
			if (num < 0)
			{
				continue;
			}
			BuildInfo component = value.GetComponent<BuildInfo>();
			HitableResource componentInChildren = value.GetComponentInChildren<HitableResource>();
			BuildRunSave buildRunSave = new BuildRunSave
			{
				ObjectId = item.Key,
				ItemId = num,
				OwnerId = (((Object)(object)component != (Object)null) ? component.ownerId : (-1)),
				Position = new Vec3(value.transform.position),
				YRotation = Mathf.RoundToInt(value.transform.eulerAngles.y),
				UpgradeTier = StructureUpgradeService.GetTier(item.Key),
				Hp = (((Object)(object)componentInChildren != (Object)null) ? ((Hitable)componentInChildren).hp : 0),
				MaxHp = (((Object)(object)componentInChildren != (Object)null) ? ((Hitable)componentInChildren).maxHp : 0)
			};
			Chest componentInChildren2 = value.GetComponentInChildren<Chest>();
			if (componentInChildren2?.cells != null)
			{
				for (int num2 = 0; num2 < componentInChildren2.cells.Length; num2++)
				{
					InventoryItem val = componentInChildren2.cells[num2];
					if ((Object)(object)val != (Object)null)
					{
						buildRunSave.Chest.Add(new ItemStackSave
						{
							Cell = num2,
							ItemId = val.id,
							Amount = val.amount
						});
					}
				}
			}
			output.Add(buildRunSave);
		}
	}

	private static int FindBuildItemId(GameObject build, Dictionary<string, int> itemIdsByPrefab)
	{
		string key = ((Object)build).name.Replace("(Clone)", string.Empty).Trim();
		if (!itemIdsByPrefab.TryGetValue(key, out var value))
		{
			return -1;
		}
		return value;
	}

	private static void CaptureWorldItems(List<WorldItemRunSave> output)
	{
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		if (ItemManager.Instance?.list == null)
		{
			return;
		}
		foreach (KeyValuePair<int, GameObject> item in ItemManager.Instance.list.OrderBy((KeyValuePair<int, GameObject> pair) => pair.Key))
		{
			Item val = (((Object)(object)item.Value != (Object)null) ? item.Value.GetComponent<Item>() : null);
			if ((Object)(object)((val != null) ? val.item : null) != (Object)null)
			{
				output.Add(new WorldItemRunSave
				{
					ObjectId = item.Key,
					ItemId = val.item.id,
					Amount = val.item.amount,
					Position = new Vec3(item.Value.transform.position)
				});
			}
			else if ((Object)(object)((val != null) ? val.powerup : null) != (Object)null)
			{
				output.Add(new WorldItemRunSave
				{
					ObjectId = item.Key,
					IsPowerup = true,
					PowerupId = val.powerup.id,
					Amount = 1,
					Position = new Vec3(item.Value.transform.position)
				});
			}
		}
	}

	internal static string CaptureWorldSnapshotBase64()
	{
		try
		{
			if ((Object)(object)GameManager.instance == (Object)null || GameManager.gameSettings == null || !RestoreManagersReady())
			{
				return string.Empty;
			}
			RunSaveData runSaveData = Capture();
			runSaveData.Player = new PlayerRunSave();
			using MemoryStream memoryStream = new MemoryStream();
			using (GZipStream gZipStream = new GZipStream(memoryStream, CompressionLevel.Fastest, leaveOpen: true))
			{
				Serializer.Serialize((Stream)gZipStream, (object)runSaveData);
			}
			return Convert.ToBase64String(memoryStream.ToArray());
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Could not capture late-join world snapshot: " + ex));
			return string.Empty;
		}
	}

	internal static IEnumerator ApplyWorldSnapshotBase64(string encoded)
	{
		if (string.IsNullOrWhiteSpace(encoded))
		{
			yield break;
		}
		RunSaveData snapshot;
		try
		{
			using MemoryStream stream = new MemoryStream(Convert.FromBase64String(encoded), writable: false);
			using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
			snapshot = Normalize((RunSaveData)Serializer.Deserialize((Stream)gZipStream));
			if (snapshot == null || snapshot.FormatVersion > 4)
			{
				throw new InvalidDataException("Unsupported world snapshot.");
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("Could not decode late-join world snapshot: " + ex));
			yield break;
		}
		float deadline = Time.realtimeSinceStartup + 45f;
		while (!RestoreManagersReady() && Time.realtimeSinceStartup < deadline)
		{
			yield return null;
		}
		if (!RestoreManagersReady())
		{
			Plugin.Log.LogError((object)"Late-join world snapshot timed out waiting for managers.");
			yield break;
		}
		try
		{
			ClearCurrentBuildsAndItems();
			RemoveDestroyedResources(snapshot.RemovedResourceIds);
			RestoreBuilds(snapshot.Builds);
		}
		catch (Exception ex2)
		{
			Plugin.Log.LogError((object)("Could not prepare late-join world snapshot: " + ex2));
			yield break;
		}
		yield return null;
		try
		{
			RestoreChests(snapshot.Builds);
			RestoreWorldItems(snapshot.WorldItems);
			RestoreClock(snapshot);
			DetailedMapService.ImportDiscoveredKeys(snapshot.DiscoveredLandmarks);
			ResourceManager.globalId = Math.Max(ResourceManager.globalId, snapshot.ResourceGlobalId);
			ItemManager.currentId = Math.Max(ItemManager.currentId, snapshot.ItemGlobalId);
			Plugin.Log.LogInfo((object)$"Applied late-join world snapshot: day {snapshot.Day}, builds {snapshot.Builds.Count}, items {snapshot.WorldItems.Count}.");
		}
		catch (Exception ex3)
		{
			Plugin.Log.LogError((object)("Could not apply late-join world snapshot: " + ex3));
		}
	}

	internal static void OnWorldReady()
	{
		if (Pending != null)
		{
			ReforgedRuntime.Instance?.StartManagedCoroutine(RestoreIntoCurrentWorld());
		}
	}

	internal static IEnumerator RestoreIntoCurrentWorld()
	{
		RunSaveData save = Pending;
		if (save == null)
		{
			yield break;
		}
		restoring = true;
		float deadline = Time.realtimeSinceStartup + 60f;
		while (!RestoreManagersReady() && Time.realtimeSinceStartup < deadline)
		{
			yield return null;
		}
		if (!RestoreManagersReady())
		{
			Plugin.Log.LogError((object)"Save restore timed out while waiting for world managers.");
			ReforgedRuntime.Instance?.Notify(LocalizationService.T("load_timeout"));
			Pending = null;
			restoring = false;
			yield break;
		}
		List<int> removedExisting = save.RemovedResourceIds.Where((int id) => ResourceManager.Instance.list.ContainsKey(id) && !ResourceManager.Instance.builds.ContainsKey(id)).Distinct().ToList();
		try
		{
			ClearCurrentBuildsAndItems();
			RemoveDestroyedResources(removedExisting);
			RestoreBuilds(save.Builds);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("World restore stage failed: " + ex));
		}
		yield return null;
		try
		{
			RestoreChests(save.Builds);
			RestoreWorldItems(save.WorldItems);
			RestorePlayer(save.Player);
			RestoreClock(save);
			DetailedMapService.ImportDiscoveredKeys(save.DiscoveredLandmarks);
			ResourceManager.globalId = Math.Max(ResourceManager.globalId, save.ResourceGlobalId);
			ItemManager.currentId = Math.Max(ItemManager.currentId, save.ItemGlobalId);
			SynchronizeRestoredWorld(save, removedExisting);
			ReforgedRuntime.Instance?.Notify(string.Format(LocalizationService.T("loaded_day_seed"), save.Day, save.Seed));
			Plugin.Log.LogInfo((object)$"Restored run: day {save.Day}, builds {save.Builds.Count}, items {save.WorldItems.Count}");
		}
		catch (Exception ex2)
		{
			Plugin.Log.LogError((object)("Player restore stage failed: " + ex2));
			ReforgedRuntime.Instance?.Notify(string.Format(LocalizationService.T("load_partial_failed"), ex2.Message));
		}
		finally
		{
			Pending = null;
			pendingSlot = 0;
			restoring = false;
		}
	}

	private static bool RestoreManagersReady()
	{
		if ((Object)(object)ResourceManager.Instance != (Object)null && (Object)(object)ItemManager.Instance != (Object)null && (Object)(object)BuildManager.Instance != (Object)null && (Object)(object)PlayerMovement.Instance != (Object)null && (Object)(object)InventoryUI.Instance != (Object)null)
		{
			return (Object)(object)PowerupInventory.Instance != (Object)null;
		}
		return false;
	}

	private static void ClearCurrentBuildsAndItems()
	{
		if (ResourceManager.Instance?.builds != null)
		{
			int[] array = ResourceManager.Instance.builds.Keys.ToArray();
			foreach (int key in array)
			{
				if (ResourceManager.Instance.list.TryGetValue(key, out var value))
				{
					Object.Destroy((Object)(object)value);
				}
				ResourceManager.Instance.list.Remove(key);
				ResourceManager.Instance.builds.Remove(key);
				if (ChestManager.Instance?.chests != null)
				{
					ChestManager.Instance.chests.Remove(key);
				}
			}
		}
		if (ItemManager.Instance?.list == null)
		{
			return;
		}
		foreach (GameObject value2 in ItemManager.Instance.list.Values)
		{
			if ((Object)(object)value2 != (Object)null)
			{
				Object.Destroy((Object)(object)value2);
			}
		}
		ItemManager.Instance.list.Clear();
	}

	private static void RemoveDestroyedResources(IEnumerable<int> ids)
	{
		if (ResourceManager.Instance?.list == null)
		{
			return;
		}
		foreach (int id in ids)
		{
			if (ResourceManager.Instance.list.TryGetValue(id, out var value))
			{
				ResourceManager.Instance.list.Remove(id);
				Object.Destroy((Object)(object)value);
			}
		}
	}

	private static void RestoreBuilds(IEnumerable<BuildRunSave> builds)
	{
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		foreach (BuildRunSave build in builds)
		{
			if (build != null && ItemManager.Instance.allItems.ContainsKey(build.ItemId) && !ResourceManager.Instance.list.ContainsKey(build.ObjectId))
			{
				BuildManager.Instance.BuildItem(ResolveBuildOwner(build.OwnerId), build.ItemId, build.ObjectId, build.Position.ToVector3(), build.YRotation);
				StructureUpgradeService.ApplySaved(build.ObjectId, build.UpgradeTier, build.Hp, build.MaxHp);
			}
		}
	}

	private static void RestoreChests(IEnumerable<BuildRunSave> builds)
	{
		if (ChestManager.Instance?.chests == null)
		{
			return;
		}
		foreach (BuildRunSave build in builds)
		{
			if (build == null || build.Chest.Count == 0 || !ChestManager.Instance.chests.TryGetValue(build.ObjectId, out var value))
			{
				continue;
			}
			if (value.cells == null || value.cells.Length == 0)
			{
				value.cells = (InventoryItem[])(object)new InventoryItem[value.chestSize];
			}
			foreach (ItemStackSave item in build.Chest)
			{
				if (item.Cell >= 0 && item.Cell < value.cells.Length && ItemManager.Instance.allItems.TryGetValue(item.ItemId, out var value2))
				{
					InventoryItem val = ScriptableObject.CreateInstance<InventoryItem>();
					val.Copy(value2, SafeAmount(value2, item.Amount));
					value.cells[item.Cell] = val;
				}
			}
		}
	}

	private static void RestoreWorldItems(IEnumerable<WorldItemRunSave> items)
	{
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		foreach (WorldItemRunSave item in items)
		{
			if (item == null || ItemManager.Instance.list.ContainsKey(item.ObjectId))
			{
				continue;
			}
			InventoryItem value;
			if (item.IsPowerup)
			{
				if (ItemManager.Instance.allPowerups.ContainsKey(item.PowerupId))
				{
					ItemManager.Instance.DropPowerupAtPosition(item.PowerupId, item.Position.ToVector3(), item.ObjectId);
				}
			}
			else if (ItemManager.Instance.allItems.TryGetValue(item.ItemId, out value))
			{
				int num = SafeAmount(value, item.Amount);
				ItemManager.Instance.DropItemAtPosition(item.ItemId, num, item.Position.ToVector3(), item.ObjectId);
			}
		}
	}

	private static int ResolveBuildOwner(int savedOwner)
	{
		if (Server.clients != null && Server.clients.TryGetValue(savedOwner, out var value) && value?.player != null)
		{
			return savedOwner;
		}
		if (!((Object)(object)LocalClient.instance != (Object)null))
		{
			return savedOwner;
		}
		return LocalClient.instance.myId;
	}

	private static void SynchronizeRestoredWorld(RunSaveData save, IEnumerable<int> removedExisting)
	{
		//IL_006b: 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_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
		if (!LocalClient.serverOwner || (Object)(object)LocalClient.instance == (Object)null || Server.clients == null)
		{
			return;
		}
		int hostId = LocalClient.instance.myId;
		int num = Server.clients.Values.Count((Client client) => client?.player != null && client.player.id != hostId);
		if (num == 0)
		{
			return;
		}
		foreach (int item in removedExisting)
		{
			ServerSend.PlayerHitObject(hostId, item, 0, 0, Vector3.zero, -1);
		}
		foreach (BuildRunSave build in save.Builds)
		{
			if (build == null || !ItemManager.Instance.allItems.ContainsKey(build.ItemId))
			{
				continue;
			}
			ServerSend.SendBuild(ResolveBuildOwner(build.OwnerId), build.ItemId, build.ObjectId, build.Position.ToVector3(), build.YRotation);
			foreach (ItemStackSave item2 in build.Chest)
			{
				if (item2 != null && item2.Cell >= 0 && ItemManager.Instance.allItems.TryGetValue(item2.ItemId, out var value))
				{
					ServerSend.UpdateChest(hostId, build.ObjectId, item2.Cell, item2.ItemId, SafeAmount(value, item2.Amount));
				}
			}
		}
		foreach (WorldItemRunSave worldItem in save.WorldItems)
		{
			if (worldItem == null)
			{
				continue;
			}
			InventoryItem value2;
			if (worldItem.IsPowerup)
			{
				if (ItemManager.Instance.allPowerups.ContainsKey(worldItem.PowerupId))
				{
					ServerSend.DropPowerupAtPosition(worldItem.PowerupId, worldItem.ObjectId, worldItem.Position.ToVector3());
				}
			}
			else if (ItemManager.Instance.allItems.TryGetValue(worldItem.ItemId, out value2))
			{
				ServerSend.DropItemAtPosition(worldItem.ItemId, SafeAmount(value2, worldItem.Amount), worldItem.ObjectId, worldItem.Position.ToVector3());
			}
		}
		foreach (Client value3 in Server.clients.Values)
		{
			if (value3?.player != null && value3.player.id != hostId)
			{
				StructureUpgradeService.SendSnapshot(value3.player.id);
			}
		}
		Plugin.Log.LogInfo((object)$"Synchronized restored world to {num} remote player(s).");
	}

	private static void RestorePlayer(PlayerRunSave player)
	{
		//IL_0011: 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_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		Rigidbody rb = PlayerMovement.Instance.GetRb();
		Vector3 position = player.Position.ToVector3();
		((Component)PlayerMovement.Instance).transform.position = position;
		if ((Object)(object)rb != (Object)null)
		{
			rb.position = position;
			rb.velocity = Vector3.zero;
		}
		InventoryCell[] allCells = InventoryUI.Instance.allCells;
		if (allCells != null)
		{
			InventoryCell[] array = allCells;
			foreach (InventoryCell val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.currentItem = null;
					val.UpdateCell();
				}
			}
			foreach (ItemStackSave item in player.Inventory)
			{
				if (item.Cell >= 0 && item.Cell < allCells.Length && !((Object)(object)allCells[item.Cell] == (Object)null) && ItemManager.Instance.allItems.TryGetValue(item.ItemId, out var value))
				{
					InventoryItem val2 = ScriptableObject.CreateInstance<InventoryItem>();
					val2.Copy(value, SafeAmount(value, item.Amount));
					allCells[item.Cell].currentItem = val2;
					allCells[item.Cell].UpdateCell();
				}
			}
			Hotbar instance = Hotbar.Instance;
			if (instance != null)
			{
				instance.UpdateHotbar();
			}
		}
		int num = ItemManager.Instance?.allPowerups?.Count ?? player.Powerups.Count;
		int[] array2 = new int[Mathf.Max(0, num)];
		for (int j = 0; j < array2.Length && j < player.Powerups.Count; j++)
		{
			array2[j] = Mathf.Clamp(player.Powerups[j], 0, 999);
		}
		Fields.Powerups?.SetValue(PowerupInventory.Instance, array2);
		RebuildPowerupUi(array2);
		int num2 = (((Object)(object)LocalClient.instance != (Object)null) ? LocalClient.instance.myId : (-1));
		if (num2 >= 0 && Server.clients != null && Server.clients.TryGetValue(num2, out var value2) && value2?.player != null)
		{
			value2.player.powerups = (int[])array2.Clone();
		}
		PlayerStatus instance2 = PlayerStatus.Instance;
		instance2.draculaStacks = player.DraculaStacks;
		instance2.UpdateStats();
		instance2.hp = Mathf.Clamp(player.Hp, 1f, (float)instance2.maxHp);
		instance2.shield = Mathf.Clamp(player.Shield, 0f, (float)instance2.maxShield);
		instance2.stamina = Mathf.Clamp(player.Stamina, 0f, instance2.maxStamina);
		instance2.hunger = Mathf.Clamp(player.Hunger, 0f, instance2.maxHunger);
		for (int k = 0; k < 4; k++)
		{
			int num3 = ((k < player.Armor.Count) ? player.Armor[k] : (-1));
			if (num3 >= 0 && (ItemManager.Instance?.allItems == null || !ItemManager.Instance.allItems.TryGetValue(num3, out var value3) || !value3.IsArmour()))
			{
				num3 = -1;
			}
			instance2.UpdateArmor(k, num3);
			if (num2 >= 0 && Server.clients != null && Server.clients.TryGetValue(num2, out var value4) && value4?.player != null)
			{
				value4.player.UpdateArmor(k, num3);
			}
		}
	}

	private static void RebuildPowerupUi(int[] powerups)
	{
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)PowerupUI.Instance == (Object)null)
		{
			return;
		}
		foreach (Transform item in ((Component)PowerupUI.Instance).transform)
		{
			Object.Destroy((Object)(object)((Component)item).gameObject);
		}
		Fields.PowerupUiDictionary?.SetValue(PowerupUI.Instance, new Dictionary<int, GameObject>());
		if (powerups == null)
		{
			return;
		}
		for (int i = 0; i < powerups.Length; i++)
		{
			for (int j = 0; j < powerups[i]; j++)
			{
				PowerupUI.Instance.AddPowerup(i);
			}
		}
	}

	private static void RestoreClock(RunSaveData save)
	{
		DayCycle.time = Mathf.Repeat(save.DayTime, 1f);
		Fields.TotalTime?.SetValue(null, save.TotalTime);
		if ((Object)(object)GameLoop.Instance != (Object)null && LocalClient.serverOwner)
		{
			AccessTools.Method(typeof(GameLoop), "NewDay", (Type[])null, (Type[])null)?.Invoke(GameLoop.Instance, new object[1] { Mathf.Max(0, save.Day) });
		}
		else
		{
			GameManager.instance.UpdateDay(Mathf.Max(0, save.Day));
			if ((Object)(object)GameLoop.Instance != (Object)null)
			{
				GameLoop.Instance.currentDay = Mathf.Max(0, save.Day);
			}
		}
		WorldSyncPackets.BroadcastRestoredClock(save.DayTime, save.TotalTime);
	}

	private static RunSaveData ReadSlot(int slot, bool logErrors)
	{
		string text = SlotPath(slot);
		string path = text + ".bak";
		if (!File.Exists(text))
		{
			if (!File.Exists(path))
			{
				return null;
			}
			try
			{
				RunSaveData data = DeserializeSave(path);
				if (logErrors)
				{
					Plugin.Log.LogWarning((object)$"Loaded slot {slot} from backup because its primary file is missing.");
				}
				return Normalize(data);
			}
			catch (Exception arg)
			{
				if (logErrors)
				{
					Plugin.Log.LogError((object)$"Could not load backup for slot {slot}: {arg}");
				}
				return null;
			}
		}
		try
		{
			return Normalize(DeserializeSave(text));
		}
		catch (Exception arg2)
		{
			if (logErrors)
			{
				Plugin.Log.LogError((object)$"Could not load slot {slot}: {arg2}");
			}
			if (!File.Exists(path))
			{
				return null;
			}
			try
			{
				RunSaveData data2 = DeserializeSave(path);
				if (logErrors)
				{
					Plugin.Log.LogWarning((object)$"Recovered slot {slot} from its backup file.");
				}
				return Normalize(data2);
			}
			catch
			{
				return null;
			}
		}
	}

	private static RunSaveData DeserializeSave(string path)
	{
		using FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
		using GZipStream gZipStream = new GZipStream(stream, CompressionMode.Decompress);
		RunSaveData runSaveData = (RunSaveData)Serializer.Deserialize((Stream)gZipStream);
		if (runSaveData == null || runSaveData.FormatVersion > 4)
		{
			throw new InvalidDataException("Unsupported save format.");
		}
		return runSaveData;
	}

	private static RunSaveData Normalize(RunSaveData data)
	{
		data.WorldName = data.WorldName?.Trim();
		data.Player = data.Player ?? new PlayerRunSave();
		data.Player.Position = data.Player.Position ?? new Vec3();
		data.Player.Inventory = data.Player.Inventory ?? new List<ItemStackSave>();
		data.Player.Powerups = data.Player.Powerups ?? new List<int>();
		data.Player.Armor = data.Player.Armor ?? new List<int>();
		data.Player.Inventory = data.Player.Inventory.Where((ItemStackSave item) => item != null).ToList();
		data.RemovedResourceIds = (data.RemovedResourceIds ?? new List<int>()).Where((int id) => id >= 0).Distinct().ToList();
		data.Builds = (data.Builds ?? new List<BuildRunSave>()).Where((BuildRunSave build) => build != null).ToList();
		data.WorldItems = (data.WorldItems ?? new List<WorldItemRunSave>()).Where((WorldItemRunSave item) => item != null).ToList();
		data.DiscoveredLandmarks = (data.DiscoveredLandmarks ?? new List<string>()).Where((string value) => !string.IsNullOrWhiteSpace(value)).Distinct().ToList();
		foreach (BuildRunSave build in data.Builds)
		{
			build.Position = build.Position ?? new Vec3();
			build.Chest = (build.Chest ?? new List<ItemStackSave>()).Where((ItemStackSave item) => item != null).ToList();
		}
		foreach (WorldItemRunSave worldItem in data.WorldItems)
		{
			worldItem.Position = worldItem.Position ?? new Vec3();
		}
		return data;
	}

	private static int SafeAmount(InventoryItem source, int amount)
	{
		int num = ((!((Object)(object)source != (Object)null) || !source.stackable) ? 1 : Mathf.Max(1, source.max));
		return Mathf.Clamp(amount, 1, num);
	}

	private static int ResolveAutosaveSlot(int requested)
	{
		if (sessionSlot >= 1 && sessionSlot <= 24)
		{
			return sessionSlot;
		}
		int preferred = Mathf.Clamp(requested, 1, 24);
		int[] array = (from slot in Enumerable.Range(1, 24)
			orderby (slot != preferred) ? 1 : 0, slot
			select slot).ToArray();
		foreach (int num2 in array)
		{
			string text = SlotPath(num2);
			if (!File.Exists(text) && !File.Exists(text + ".bak"))
			{
				sessionSlot = num2;
				sessionWorldName = $"World {num2}";
				Plugin.Settings.ActiveSaveSlot.Value = num2;
				Plugin.Log.LogInfo((object)$"Bound this new run to empty autosave slot {num2}.");
				return num2;
			}
		}
		if (!warnedNoAutosaveSlot)
		{
			warnedNoAutosaveSlot = true;
			ReforgedRuntime.Instance?.Notify(LocalizationService.T("save_slots_full"), 7f);
			Plugin.Log.LogWarning((object)"Autosave skipped because every slot is occupied and this new run is not bound to a slot.");
		}
		return 0;
	}

	private static string SlotPath(int slot)
	{
		return Path.Combine(saveDirectory, $"slot{Mathf.Clamp(slot, 1, 24)}.mucksave");
	}

	internal static void TrackRemovedResource(int id)
	{
		if (!restoring)
		{
			RemovedResources.Add(id);
		}
	}

	internal static void ResetForNewWorld()
	{
		if (Pending == null)
		{
			RemovedResources.Clear();
			sessionSlot = 0;
			pendingSlot = 0;
			sessionWorldName = null;
			warnedNoAutosaveSlot = false;
		}
		else if (pendingSlot >= 1 && pendingSlot <= 24)
		{
			sessionSlot = pendingSlot;
			sessionWorldName = (string.IsNullOrWhiteSpace(Pending.WorldName) ? $"World {pendingSlot}" : Pending.WorldName.Trim());
		}
	}
}
[HarmonyPatch(typeof(ResourceManager), "RemoveItem")]
internal static class RemovedResourceTrackingPatch
{
	private static void Prefix(ResourceManager __instance, int id)
	{
		if (__instance?.list != null && __instance.builds != null && __instance.list.ContainsKey(id) && !__instance.builds.ContainsKey(id))
		{
			RunSaveService.TrackRemovedResource(id);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "LeaveGame")]
internal static class SaveBeforeLeavingWorldPatch
{
	private static void Prefix()
	{
		RunSaveService.SaveBeforeExit("leaving the world");
	}
}
[HarmonyPatch(typeof(GameLoop), "NewDay")]
internal static class NewDayAutosavePatch
{
	private static void Postfix()
	{
		if (Plugin.Settings.EnableRunSaves.Value && LocalClient.serverOwner && (Object)(object)GameManager.instance != (Object)null && GameManager.instance.currentDay > 0)
		{
			RunSaveService.SaveSlot(Mathf.Clamp(Plugin.Settings.ActiveSaveSlot.Value, 1, 24), automatic: true);
		}
	}
}
internal static class PacketSanitizer
{
	internal static bool ValidFloat(float value)
	{
		if (!float.IsNaN(value))
		{
			return !float.IsInfinity(value);
		}
		return false;
	}

	internal static bool ValidVector(Vector3 value)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		if (ValidFloat(value.x) && ValidFloat(value.y) && ValidFloat(value.z) && Mathf.Abs(value.x) < 10000f && Mathf.Abs(value.y) < 10000f)
		{
			return Mathf.Abs(value.z) < 10000f;
		}
		return false;
	}

	internal static Packet RebuildMobHit(int mobId, int damage, float sharpness, int effect, Vector3 position, int weaponType)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: 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_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Expected O, but got Unknown
		Packet val = new Packet();
		val.Write(mobId);
		val.Write(damage);
		val.Write(sharpness);
		val.Write(effect);
		val.Write(position);
		val.Write(weaponType);
		val.ToArray();
		return val;
	}

	internal static Packet RebuildResourceHit(int damage, int objectId, int effect, Vector3 position, int weaponType)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		Packet val = new Packet();
		val.Write(damage);
		val.Write(objectId);
		val.Write(effect);
		val.Write(position);
		val.Write(weaponType);
		val.ToArray();
		return val;
	}

	internal static Packet RebuildBuild(int itemId, Vector3 position, int rotation)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		Packet val = new Packet();
		val.Write(itemId);
		val.Write(position);
		val.Write(rotation);
		val.ToArray();
		return val;
	}
}
[HarmonyPatch(typeof(ServerHandle), "PlayerDamageMob")]
internal static class ValidateMobDamagePacketPatch
{
	private static bool Prefix(int fromClient, ref Packet packet)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: 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_0127: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.EnableServerValidation.Value)
		{
			return true;
		}
		try
		{
			int num = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			float num3 = packet.ReadFloat(true);
			int num4 = packet.ReadInt(true);
			Vector3 val = packet.ReadVector3(true);
			int num5 = packet.ReadInt(true);
			num2 = Mathf.Clamp(num2, 0, Mathf.Max(1, Plugin.Settings.MaxClientMobDamage.Value));
			if (!PacketSanitizer.ValidFloat(num3))
			{
				num3 = 0f;
			}
			num3 = Mathf.Clamp(num3, -10f, 100f);
			num4 = Mathf.Clamp(num4, 0, 16);
			num5 = Mathf.Clamp(num5, -1, 2);
			if (!PacketSanitizer.ValidVector(val))
			{
				val = Vector3.zero;
			}
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || MobManager.Instance?.mobs == null || !MobManager.Instance.mobs.TryGetValue(num, out var value) || (Object)(object)value == (Object)null || (Object)(object)((Component)value).GetComponent<HitableMob>() == (Object)null)
			{
				return false;
			}
			if (Vector3.Distance(((Component)player).transform.position, ((Component)value).transform.position) > 140f)
			{
				num2 = 0;
			}
			packet = PacketSanitizer.RebuildMobHit(num, num2, num3, num4, val, num5);
			return true;
		}
		catch
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed mob damage packet from client {fromClient}");
			return false;
		}
	}
}
[HarmonyPatch(typeof(ServerHandle), "PlayerHitObject")]
internal static class ValidateResourceDamagePacketPatch
{
	private static bool Prefix(int fromClient, ref Packet packet)
	{
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0074: 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_0081: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.EnableServerValidation.Value)
		{
			return true;
		}
		try
		{
			int num = packet.ReadInt(true);
			int num2 = packet.ReadInt(true);
			int num3 = packet.ReadInt(true);
			Vector3 val = packet.ReadVector3(true);
			int num4 = packet.ReadInt(true);
			num = Mathf.Clamp(num, 0, Mathf.Max(1, Plugin.Settings.MaxClientResourceDamage.Value));
			num3 = Mathf.Clamp(num3, 0, 16);
			num4 = Mathf.Clamp(num4, -1, 2);
			if (!PacketSanitizer.ValidVector(val))
			{
				val = Vector3.zero;
			}
			if (!InteractionGuard.TryPlayer(fromClient, out var player) || ResourceManager.Instance?.list == null || !ResourceManager.Instance.list.TryGetValue(num2, out var value) || (Object)(object)value == (Object)null || (Object)(object)value.GetComponent<Hitable>() == (Object)null)
			{
				return false;
			}
			if (Vector3.Distance(((Component)player).transform.position, value.transform.position) > 25f)
			{
				num = 0;
			}
			packet = PacketSanitizer.RebuildResourceHit(num, num2, num3, val, num4);
			return true;
		}
		catch
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed resource packet from client {fromClient}");
			return false;
		}
	}
}
[HarmonyPatch(typeof(ServerHandle), "RequestBuild")]
internal static class ValidateBuildPacketPatch
{
	private static bool Prefix(int fromClient, ref Packet packet)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: 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)
		if (!Plugin.Settings.EnableServerValidation.Value)
		{
			return true;
		}
		try
		{
			int num = packet.ReadInt(true);
			Vector3 val = packet.ReadVector3(true);
			int num2 = packet.ReadInt(true);
			if (!PacketSanitizer.ValidVector(val) || ItemManager.Instance?.allItems == null || !ItemManager.Instance.allItems.TryGetValue(num, out var value) || (Object)(object)value == (Object)null || !value.buildable)
			{
				return false;
			}
			if (GameManager.players.TryGetValue(fromClient, out var value2) && (Object)(object)value2 != (Object)null && Vector3.Distance(((Component)value2).transform.position, val) > 20f)
			{
				return false;
			}
			num2 = (num2 % 360 + 360) % 360;
			packet = PacketSanitizer.RebuildBuild(num, val, num2);
			return true;
		}
		catch
		{
			Plugin.Log.LogWarning((object)$"Rejected malformed build packet from client {fromClient}");
			return false;
		}
	}
}
internal sealed class ReplayableShield
{
	internal string Name;

	internal string MaterialName;

	internal string HandleName;

	internal string VisualSource;

	internal string Station;

	internal int Tier;

	internal int MaterialAmount;

	internal int HandleAmount;

	internal int BashDamage;

	internal float PassiveReduction;

	internal Color Color;

	internal InventoryItem Item;
}
internal static class ShieldRegistry
{
	private const string AssetPrefix = "MuckReplayable_Shield_";

	private static readonly Dictionary<int, ReplayableShield> ById = new Dictionary<int, ReplayableShield>();

	private static ItemManager installedManager;

	private static Mesh sharedMesh;

	private static readonly ReplayableShield[] Definitions = new ReplayableShield[7]
	{
		Shield("Wood Shield", "Wood", "Wood", "Wood Axe", "Workbench", 1, 10, 0, 9, 0.05f, new Color(0.48f, 0.27f, 0.12f)),
		Shield("Gold Shield", "Gold bar", "Wood", "Gold Sword", "Anvil", 2, 8, 3, 12, 0.07f, new Color(1f, 0.66f, 0.1f)),
		Shield("Steel Shield", "Iron bar", "Birch Wood", "Steel Sword", "Anvil", 2, 10, 3, 15, 0.09f, new Color(0.58f, 0.63f, 0.68f)),
		Shield("Mithril Shield", "Mithril bar", "Fir Wood", "Mithril Sword", "Anvil", 3, 10, 3, 18, 0.11f, new Color(0.24f, 0.72f, 0.92f)),
		Shield("Adamantite Shield", "Adamantite bar", "Oak Wood", "Adamantite Sword", "Anvil", 4, 10, 3, 23, 0.13f, new Color(0.34f, 0.88f, 0.48f)),
		Shield("Obamium Shield", "Obamium bar", "Dark Oak Wood", "Obamium Sword", "Anvil", 5, 12, 4, 28, 0.15f, new Color(0.67f, 0.28f, 0.87f)),
		Shield("Chunkium Shield", "Chunkium bar", "Dark Oak Wood", "Chunkium Helmet", "Anvil", 5, 12, 4, 32, 0.17f, new Color(0.92f, 0.39f, 0.14f))
	};

	internal static IEnumerable<ReplayableShield> All => Definitions.Where((ReplayableShield value) => (Object)(object)value.Item != (Object)null);

	internal static void Install(ItemManager manager)
	{
		//IL_0250: Unknown result type (might be due to invalid IL or missing references)
		//IL_0258: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c1: Expected O, but got Unknown
		//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ee: Expected O, but got Unknown
		//IL_0384: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_035e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0365: Unknown result type (might be due to invalid IL or missing references)
		//IL_036f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0445: Unknown result type (might be due to invalid IL or missing references)
		if (manager?.allScriptableItems == null || manager.allItems == null || ((Object)(object)installedManager == (Object)(object)manager && ById.Count == Definitions.Length))
		{
			return;
		}
		installedManager = manager;
		ById.Clear();
		List<InventoryItem> list = manager.allScriptableItems.Where((InventoryItem item) => (Object)(object)item != (Object)null && !(((Object)item).name ?? string.Empty).StartsWith("MuckReplayable_Shield_", StringComparison.Ordinal)).ToList();
		int[] array = (from pair in manager.allItems
			where (Object)(object)pair.Value != (Object)null && (((Object)pair.Value).name ?? string.Empty).StartsWith("MuckReplayable_Shield_", StringComparison.Ordinal)
			select pair.Key).ToArray();
		foreach (int key in array)
		{
			manager.allItems.Remove(key);
		}
		sharedMesh = (((Object)(object)sharedMesh != (Object)null) ? sharedMesh : CreateShieldMesh());
		int count = list.Count;
		ReplayableShield[] definitions = Definitions;
		foreach (ReplayableShield replayableShield in definitions)
		{
			InventoryItem val = Find(manager, replayableShield.MaterialName);
			InventoryItem val2 = Find(manager, replayableShield.HandleName);
			InventoryItem val3 = Find(manager, replayableShield.VisualSource) ?? val;
			InventoryItem val4 = Find(manager, replayableShield.Station);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3?.material == (Object)null || (Object)(object)val4 == (Object)null)
			{
				Plugin.Log.LogWarning((object)("Skipped " + replayableShield.Name + ": recipe or visual source was unavailable."));
				continue;
			}
			InventoryItem val5 = ScriptableObject.CreateInstance<InventoryItem>();
			((Object)val5).name = "MuckReplayable_Shield_" + replayableShield.Name.Replace(" ", string.Empty);
			val5.id = count++;
			val5.name = replayableShield.Name;
			val5.description = $"Equip in the shield slot to passively block {replayableShield.PassiveReduction * 100f:0}% damage. " + $"Hold RMB for {replayableShield.PassiveReduction * 300f:0}% block strength. LMB bashes when held in the main hand.";
			val5.type = (ItemType)4;
			val5.tag = (ItemTag)3;
			val5.tier = replayableShield.Tier;
			val5.stackable = false;
			val5.max = 1;
			val5.amount = 1;
			val5.craftable = true;
			val5.craftAmount = 1;
			val5.stationRequirement = val4;
			List<CraftRequirement> list2 = new List<CraftRequirement>
			{
				new CraftRequirement
				{
					item = val,
					amount = replayableShield.MaterialAmount
				}
			};
			if (replayableShield.HandleAmount > 0)
			{
				list2.Add(new CraftRequirement
				{
					item = val2,
					amount = replayableShield.HandleAmount
				});
			}
			val5.requirements = list2.ToArray();
			val5.mesh = sharedMesh;
			val5.material = Object.Instantiate<Material>(val3.material);
			((Object)val5.material).name = "MuckReplayable_Shield_" + replayableShield.Name + " Material";
			if (val5.material.HasProperty("_Color"))
			{
				val5.material.color = Color.Lerp(val5.material.color, replayableShield.Color, 0.72f);
			}
			val5.sprite = CreateShieldSprite(replayableShield.Name, replayableShield.Color);
			val5.rotationOffset = new Vector3(8f, 92f, -8f);
			val5.positionOffset = new Vector3(-0.12f, -0.32f, 0.38f);
			val5.scale = 0.78f;
			val5.attackDamage = replayableShield.BashDamage;
			val5.attackSpeed = 0.82f;
			val5.attackRange = 0.2f;
			val5.resourceDamage = 1;
			val5.sharpness = 0f;
			val5.swingFx = false;
			val5.attackTypes = (Weakness[])(object)new Weakness[1] { (Weakness)1 };
			val5.rarity = (ItemRarity)((replayableShield.Tier >= 4) ? 2 : ((replayableShield.Tier >= 3) ? 1 : 0));
			Object.DontDestroyOnLoad((Object)(object)val5);
			Object.DontDestroyOnLoad((Object)(object)val5.material);
			list.Add(val5);
			manager.allItems[val5.id] = val5;
			replayableShield.Item = val5;
			ById[val5.id] = replayableShield;
		}
		manager.allScriptableItems = list.ToArray();
		BedRegistry.Install(manager);
		CraftingUI[] array2 = Resources.FindObjectsOfTypeAll<CraftingUI>();
		for (int num = 0; num < array2.Length; num++)
		{
			InjectCrafting(array2[num]);
		}
		Plugin.Log.LogInfo((object)string.Format("Registered {0} craftable shields (item IDs {1}).", ById.Count, string.Join(",", ById.Keys.OrderBy((int id) => id))));
	}

	internal static bool TryGet(InventoryItem item, out ReplayableShield shield)
	{
		return TryGet(((Object)(object)item != (Object)null) ? item.id : (-1), out shield);
	}

	internal static bool TryGet(int itemId, out ReplayableShield shield)
	{
		return ById.TryGetValue(itemId, out shield);
	}

	internal static bool TryGetEquipped(out InventoryItem item, out ReplayableShield shield, out bool leftHand)
	{
		item = InventoryUI.Instance?.leftHand?.currentItem;
		leftHand = TryGet(item, out shield);
		if (leftHand)
		{
			return true;
		}
		item = Hotbar.Instance?.currentItem;
		return TryGet(item, out shield);
	}

	internal static void InjectCrafting(CraftingUI crafting)
	{
		if (crafting?.tabs == null || ById.Count == 0)
		{
			return;
		}
		bool workbench = (object)OtherInput.Instance?.workbench == crafting || (crafting.tabs.Any((Tab tab) => (tab?.items ?? Array.Empty<InventoryItem>()).Any((InventoryItem item) => (Object)(object)item != (Object)null && item.name == "Wood Axe")) && crafting.tabs.Any((Tab tab) => (tab?.items ?? Array.Empty<InventoryItem>()).Any((InventoryItem item) => (Object)(object)item != (Object)null && item.name == "Wood Floor")));
		bool flag = (object)OtherInput.Instance?.anvil == crafting || crafting.tabs.Any((Tab tab) => (tab?.items ?? Array.Empty<InventoryItem>()).Any((InventoryItem item) => (Object)(object)item != (Object)null && item.name == "Gold Sword"));
		if (!workbench && !flag)
		{
			return;
		}
		InventoryItem[] second = (from value in All
			where (!workbench) ? (value.Name != "Wood Shield") : (value.Name == "Wood Shield")
			select value.Item).ToArray();
		int num = -1;
		for (int num2 = 0; num2 < crafting.tabs.Length; num2++)
		{
			InventoryItem[] source = crafting.tabs[num2]?.items ?? Array.Empty<InventoryItem>();
			if (workbench && source.Any((InventoryItem item) => (Object)(object)item != (Object)null && (item.name == "Wood Axe" || item.name.EndsWith("Pickaxe", StringComparison.OrdinalIgnoreCase))))
			{
				num = num2;
				break;
			}
			if (flag && source.Any((InventoryItem item) => (Object)(object)item != (Object)null && (int)item.type == 3))
			{
				num = num2;
				break;
			}
		}
		if (num < 0 && crafting.tabs.Length != 0)
		{
			num = 0;
		}
		if (num >= 0)
		{
			crafting.tabs[num].items = (from item in (crafting.tabs[num].items ?? Array.Empty<InventoryItem>()).Concat(second)
				where (Object)(object)item != (Object)null
				group item by item.id into @group
				select @group.First()).ToArray();
		}
	}

	internal static bool EnsureCraftingInjected()
	{
		bool flag = false;
		bool flag2 = false;
		foreach (CraftingUI item in from value in Resources.FindObjectsOfTypeAll<CraftingUI>()
			where (Object)(object)value != (Object)null
			select value)
		{
			InjectCrafting(item);
			BedRegistry.InjectCrafting(item);
			Tab[] array = item.tabs ?? Array.Empty<Tab>();
			for (int num = 0; num < array.Length; num++)
			{
				InventoryItem[] source = (array[num]?.items ?? Array.Empty<InventoryItem>()).Where((InventoryItem item) => (Object)(object)item != (Object)null).ToArray();
				flag |= source.Any((InventoryItem item) => item.name == "Wood Shield") && source.Any((InventoryItem item) => item.name == "Wood Axe" || item.name.EndsWith("Pickaxe", StringComparison.OrdinalIgnoreCase));
				flag2 |= source.Any((InventoryItem item) => item.name == "Gold Shield") && source.Any((InventoryItem item) => (int)item.type == 3);
			}
		}
		if (flag && flag2)
		{
			return BedRegistry.IsCraftingReady();
		}
		return false;
	}

	internal static void InjectStructureChestLoot(SpawnChestsInLocations spawner)
	{
		//IL_0193: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c5: Expected O, but got Unknown
		if (spawner?.lootTables == null)
		{
			return;
		}
		ReplayableShield item = All.FirstOrDefault((ReplayableShield value) => value.Name == "Wood Shield");
		ReplayableShield item2 = All.FirstOrDefault((ReplayableShield value) => value.Name == "Steel Shield");
		ReplayableShield item3 = All.FirstOrDefault((ReplayableShield value) => value.Name == "Gold Shield");
		(ReplayableShield, float)[] array = new(ReplayableShield, float)[3]
		{
			(item, 0.09f),
			(item2, 0.045f),
			(item3, 0.03f)
		};
		WeightedTables[] lootTables = spawner.lootTables;
		for (int num = 0; num < lootTables.Length; num++)
		{
			LootDrop val = lootTables[num]?.table;
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			List<LootItems> list = (val.loot ?? Array.Empty<LootItems>()).Where((LootItems value) => value != null).ToList();
			(ReplayableShield, float)[] array2 = array;
			for (int num2 = 0; num2 < array2.Length; num2++)
			{
				(ReplayableShield, float) tuple = array2[num2];
				InventoryItem item4 = tuple.Item1?.Item;
				if (!((Object)(object)item4 == (Object)null) && !list.Any((LootItems value) => (Object)(object)value.item != (Object)null && value.item.id == item4.id))
				{
					list.Add(new LootItems
					{
						item = item4,
						amountMin = 1,
						amountMax = 1,
						dropChance = tuple.Item2
					});
				}
			}
			val.loot = list.ToArray();
		}
	}

	private static InventoryItem Find(ItemManager manager, string name)
	{
		return ((IEnumerable<InventoryItem>)manager.allItems.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem item) => (Object)(object)item != (Object)null && string.Equals(item.name, name, StringComparison.OrdinalIgnoreCase)));
	}

	private static ReplayableShield Shield(string name, string material, string handle, string source, string station, int tier, int materialAmount, int handleAmount, int bash, float reduction, Color color)
	{
		//IL_0052: 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)
		return new ReplayableShield
		{
			Name = name,
			MaterialName = material,
			HandleName = handle,
			VisualSource = source,
			Station = station,
			Tier = tier,
			MaterialAmount = materialAmount,
			HandleAmount = handleAmount,
			BashDamage = bash,
			PassiveReduction = reduction,
			Color = color
		};
	}

	private static Mesh CreateShieldMesh()
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_0125: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_016b: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0243: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0255: Unknown result type (might be due to invalid IL or missing references)
		//IL_025c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_026e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_027a: Expected O, but got Unknown
		//IL_027b: Expected O, but got Unknown
		Vector2[] array = (Vector2[])(object)new Vector2[8]
		{
			new Vector2(-0.72f, 0.42f),
			new Vector2(-0.48f, 0.82f),
			new Vector2(0f, 0.94f),
			new Vector2(0.48f, 0.82f),
			new Vector2(0.72f, 0.42f),
			new Vector2(0.58f, -0.38f),
			new Vector2(0f, -0.94f),
			new Vector2(-0.58f, -0.38f)
		};
		Vector3[] array2 = (Vector3[])(object)new Vector3[array.Length * 2];
		Vector2[] array3 = (Vector2[])(object)new Vector2[array2.Length];
		Vector2 val = default(Vector2);
		for (int i = 0; i < array.Length; i++)
		{
			array2[i] = new Vector3(array[i].x, array[i].y, -0.14f);
			array2[i + array.Length] = new Vector3(array[i].x, array[i].y, 0.14f);
			((Vector2)(ref val))..ctor(array[i].x * 0.5f + 0.5f, array[i].y * 0.5f + 0.5f);
			array3[i] = val;
			array3[i + array.Length] = val;
		}
		List<int> list = new List<int>();
		for (int j = 1; j < array.Length - 1; j++)
		{
			list.Add(0);
			list.Add(j + 1);
			list.Add(j);
			list.Add(array.Length);
			list.Add(array.Length + j);
			list.Add(array.Length + j + 1);
		}
		for (int k = 0; k < array.Length; k++)
		{
			int num = (k + 1) % array.Length;
			list.Add(k);
			list.Add(num);
			list.Add(array.Length + num);
			list.Add(k);
			list.Add(array.Length + num);
			list.Add(array.Length + k);
		}
		Mesh val2 = new Mesh
		{
			name = "Muck Replayable Shield Mesh",
			vertices = array2,
			uv = array3,
			triangles = list.ToArray()
		};
		val2.RecalculateNormals();
		val2.RecalculateBounds();
		Object.DontDestroyOnLoad((Object)val2);
		return val2;
	}

	private static Sprite CreateShieldSprite(string name, Color color)
	{
		//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_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Expected O, but got Unknown
		//IL_003b: 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_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: 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_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_0130: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
		{
			name = "MuckReplayable_Shield_" + name + " Icon",
			filterMode = (FilterMode)1,
			wrapMode = (TextureWrapMode)1
		};
		Color[] array = (Color[])(object)new Color[4096];
		Color val2 = Color.Lerp(color, Color.black, 0.62f);
		for (int i = 0; i < 64; i++)
		{
			for (int j = 0; j < 64; j++)
			{
				float num = (float)j / 63f * 2f - 1f;
				float num2 = (float)i / 63f * 2f - 1f;
				float num3 = ((num2 > 0.35f) ? (0.68f - (num2 - 0.35f) * 0.25f) : (0.68f * Mathf.Clamp01((num2 + 0.92f) / 0.7f)));
				bool flag = num2 >= -0.92f && num2 <= 0.85f && Mathf.Abs(num) <= num3;
				bool flag2 = flag && (Mathf.Abs(num) >= num3 - 0.09f || num2 >= 0.75f || num2 <= -0.8f);
				array[i * 64 + j] = (flag ? (flag2 ? val2 : Color.Lerp(color, Color.white, 0.12f + (num2 + 1f) * 0.08f)) : Color.clear);
			}
		}
		val.SetPixels(array);
		val.Apply(false, true);
		Sprite obj = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 64f);
		((Object)obj).name = name + " Icon";
		Object.DontDestroyOnLoad((Object)(object)val);
		Object.DontDestroyOnLoad((Object)(object)obj);
		return obj;
	}
}
internal static class ShieldNetwork
{
	internal sealed class ShieldState
	{
		internal int ItemId;

		internal bool Blocking;

		internal float UpdatedAt;
	}

	internal const int BlockStatePacketId = 246;

	internal const int VisualStatePacketId = 247;

	private static readonly Dictionary<int, ShieldState> States = new Dictionary<int, ShieldState>();

	private static readonly Dictionary<int, ShieldState> RemoteStates = new Dictionary<int, ShieldState>();

	private static readonly Dictionary<int, GameObject> RemoteVisuals = new Dictionary<int, GameObject>();

	private static readonly MethodInfo SendTcp = AccessTools.Method(typeof(ClientSend), "SendTCPData", new Type[1] { typeof(Packet) }, (Type[])null);

	private static readonly MethodInfo SendToAllExcept = AccessTools.Method(typeof(ServerSend), "SendTCPDataToAll", new Type[2]
	{
		typeof(int),
		typeof(Packet)
	}, (Type[])null);

	internal static bool LocalBlocking { get; private set; }

	internal static void Reset()
	{
		States.Clear();
		RemoteStates.Clear();
		LocalBlocking = false;
		foreach (GameObject value in RemoteVisuals.Values)
		{
			if ((Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)value);
			}
		}
		RemoteVisuals.Clear();
	}

	internal static void SetLocal(bool blocking, int itemId)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Expected O, but got Unknown
		LocalBlocking = blocking;
		if ((Object)(object)LocalClient.instance == (Object)null)
		{
			return;
		}
		if (LocalClient.serverOwner)
		{
			SetServer(LocalClient.instance.myId, blocking, itemId, broadcast: true);
			return;
		}
		Packet val = new Packet(246);
		try
		{
			val.Write(blocking);
			val.Write(itemId);
			SendTcp?.Invoke(null, new object[1] { val });
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	internal static void Receive(int fromClient, Packet packet)
	{
		try
		{
			SetServer(fromClient, packet.ReadBool(true), packet.ReadInt(true), broadcast: true);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected shield state: " + ex.Message));
		}
	}

	private static void SetServer(int playerId, bool blocking, int itemId, bool broadcast)
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Expected O, but got Unknown
		if (!ShieldRegistry.TryGet(itemId, out var _))
		{
			States.Remove(playerId);
		}
		else
		{
			States[playerId] = new ShieldState
			{
				ItemId = itemId,
				Blocking = blocking,
				UpdatedAt = Time.unscaledTime
			};
		}
		if (!broadcast || SendToAllExcept == null || (Object)(object)LocalClient.instance == (Object)null)
		{
			return;
		}
		Packet val = new Packet(247);
		try
		{
			val.Write(playerId);
			val.Write(itemId);
			val.Write(blocking);
			SendToAllExcept.Invoke(null, new object[2] { playerId, val });
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	internal static void ReceiveVisual(Packet packet)
	{
		try
		{
			int num = packet.ReadInt(true);
			int itemId = packet.ReadInt(true);
			bool blocking = packet.ReadBool(true);
			if (!((Object)(object)LocalClient.instance != (Object)null) || num != LocalClient.instance.myId)
			{
				if (!ShieldRegistry.TryGet(itemId, out var _))
				{
					RemoteStates.Remove(num);
					return;
				}
				RemoteStates[num] = new ShieldState
				{
					ItemId = itemId,
					Blocking = blocking,
					UpdatedAt = Time.unscaledTime
				};
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected remote shield visual: " + ex.Message));
		}
	}

	internal static float Reduction(int playerId)
	{
		if (!States.TryGetValue(playerId, out var value) || Time.unscaledTime - value.UpdatedAt > 1.1f || !ShieldRegistry.TryGet(value.ItemId, out var shield))
		{
			return 0f;
		}
		return Mathf.Clamp01(shield.PassiveReduction * (value.Blocking ? 3f : 1f));
	}

	internal static int ReduceDamage(int playerId, int damage)
	{
		float num = Reduction(playerId);
		if (!(num <= 0f))
		{
			return Mathf.Max(1, Mathf.RoundToInt((float)damage * (1f - num)));
		}
		return damage;
	}

	internal static void UpdateRemoteVisuals()
	{
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0175: 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_0195: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Unknown result type (might be due to invalid IL or missing references)
		//IL_0219: Unknown result type (might be due to invalid IL or missing references)
		//IL_021d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_023a: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: 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_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		if (RemoteStates.Count == 0)
		{
			return;
		}
		int[] array = RemoteStates.Keys.ToArray();
		foreach (int num in array)
		{
			ShieldState shieldState = RemoteStates[num];
			if (Time.unscaledTime - shieldState.UpdatedAt > 1.2f || !GameManager.players.TryGetValue(num, out var value) || (Object)(object)value?.onlinePlayer == (Object)null || !ShieldRegistry.TryGet(shieldState.ItemId, out var shield))
			{
				RemoteStates.Remove(num);
				if (RemoteVisuals.TryGetValue(num, out var value2) && (Object)(object)value2 != (Object)null)
				{
					value2.SetActive(false);
				}
				continue;
			}
			GameObject remoteVisual = GetRemoteVisual(num, value.onlinePlayer);
			if (!((Object)(object)remoteVisual == (Object)null))
			{
				bool num2 = !remoteVisual.activeSelf;
				remoteVisual.SetActive(true);
				remoteVisual.GetComponent<MeshFilter>().sharedMesh = shield.Item.mesh;
				((Renderer)remoteVisual.GetComponent<MeshRenderer>()).sharedMaterial = shield.Item.material;
				float num3 = 1f - Mathf.Exp((0f - Time.deltaTime) * 18f);
				Vector3 val = (shieldState.Blocking ? new Vector3(-0.14f, 0.12f, 0.3f) : new Vector3(-0.31f, -0.18f, 0.13f));
				Quaternion val2 = Quaternion.Euler(shieldState.Blocking ? new Vector3(-6f, 88f, 2f) : new Vector3(8f, 52f, -24f));
				Vector3 val3 = Vector3.one * (shieldState.Blocking ? 0.49f : 0.46f);
				if (num2)
				{
					remoteVisual.transform.localPosition = val;
					remoteVisual.transform.localRotation = val2;
					remoteVisual.transform.localScale = val3;
				}
				else
				{
					remoteVisual.transform.localPosition = Vector3.Lerp(remoteVisual.transform.localPosition, val, num3);
					remoteVisual.transform.localRotation = Quaternion.Slerp(remoteVisual.transform.localRotation, val2, num3);
					remoteVisual.transform.localScale = Vector3.Lerp(remoteVisual.transform.localScale, val3, num3);
				}
			}
		}
	}

	private static GameObject GetRemoteVisual(int id, OnlinePlayer player)
	{
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Expected O, but got Unknown
		if (RemoteVisuals.TryGetValue(id, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		Transform val = (((Object)(object)player.upperBody != (Object)null) ? player.upperBody : ((Component)player).transform);
		Transform val2 = ((IEnumerable<Transform>)((Component)player).GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform val4) => ((Object)val4).name.IndexOf("left", StringComparison.OrdinalIgnoreCase) >= 0 && ((Object)val4).name.IndexOf("hand", StringComparison.OrdinalIgnoreCase) >= 0));
		if ((Object)(object)val2 != (Object)null)
		{
			val = val2;
		}
		GameObject val3 = new GameObject("Muck Replayable Remote Shield " + id);
		val3.transform.SetParent(val, false);
		val3.AddComponent<MeshFilter>();
		val3.AddComponent<MeshRenderer>();
		val3.SetActive(false);
		RemoteVisuals[id] = val3;
		return val3;
	}
}
internal sealed class ShieldController : MonoBehaviour
{
	private bool blocking;

	private int heldId = -1;

	private float nextHeartbeat;

	private float nextCraftingScan;

	private bool craftingReady;

	private GameObject leftHandVisual;

	private MeshFilter leftHandFilter;

	private MeshRenderer leftHandRenderer;

	private bool leftPoseInitialized;

	private void Awake()
	{
		SceneManager.sceneLoaded += OnSceneLoaded;
	}

	private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
	{
		craftingReady = false;
		nextCraftingScan = 0f;
	}

	private void Update()
	{
		//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
		if (!craftingReady && Time.unscaledTime >= nextCraftingScan)
		{
			craftingReady = ShieldRegistry.EnsureCraftingInjected();
			nextCraftingScan = Time.unscaledTime + 1f;
		}
		InventoryItem item;
		ReplayableShield shield;
		bool leftHand;
		bool flag = ShieldRegistry.TryGetEquipped(out item, out shield, out leftHand);
		int num = (flag ? item.id : (-1));
		if (num != heldId)
		{
			heldId = num;
			blocking = false;
			ShieldNetwork.SetLocal(blocking: false, heldId);
			nextHeartbeat = Time.unscaledTime + 0.35f;
			PlayerStatus instance = PlayerStatus.Instance;
			if (instance != null)
			{
				instance.UpdateStats();
			}
			leftPoseInitialized = false;
		}
		bool flag2 = flag && (Object)(object)PlayerStatus.Instance != (Object)null && PlayerStatus.Instance.stamina > 0.1f && (Object)(object)OtherInput.Instance != (Object)null && !OtherInput.Instance.IsAnyMenuOpen() && Input.GetKey(InputManager.rightClick);
		if (flag2)
		{
			PlayerStatus.Instance.stamina = Mathf.Max(0f, PlayerStatus.Instance.stamina - Time.deltaTime * 5f);
			StaminaRegenerationGate.MarkSpent();
		}
		if (flag2 && PlayerStatus.Instance.stamina <= 0f)
		{
			flag2 = false;
		}
		if (flag2 != blocking)
		{
			blocking = flag2;
			ShieldNetwork.SetLocal(blocking, heldId);
			nextHeartbeat = Time.unscaledTime + 0.35f;
		}
		else if (flag && Time.unscaledTime >= nextHeartbeat)
		{
			ShieldNetwork.SetLocal(blocking, heldId);
			nextHeartbeat = Time.unscaledTime + 0.35f;
		}
		UpdatePose(item, flag, leftHand);
		ShieldNetwork.UpdateRemoteVisuals();
	}

	private void UpdatePose(InventoryItem shieldItem, bool isShield, bool leftHand)
	{
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_005e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0084: 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_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_0222: Unknown result type (might be due to invalid IL or missing references)
		//IL_0227: Unknown result type (might be due to invalid IL or missing references)
		//IL_0284: Unknown result type (might be due to invalid IL or missing references)
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_028b: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02db: Unknown result type (might be due to invalid IL or missing references)
		//IL_023c: Unknown result type (might be due to invalid IL or missing references)
		//IL_024d: Unknown result type (might be due to invalid IL or missing references)
		//IL_025f: Unknown result type (might be due to invalid IL or missing references)
		Transform val = UseInventory.Instance?.renderTransform;
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		float num = 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) * 15f);
		if (isShield && !leftHand)
		{
			Quaternion val2 = Quaternion.Euler((Vector3)(blocking ? new Vector3(2f, 180f, 2f) : shieldItem.rotationOffset));
			Vector3 val3 = (Vector3)(blocking ? new Vector3(0.03f, -0.12f, 0.74f) : shieldItem.positionOffset);
			val.localRotation = Quaternion.Slerp(val.localRotation, val2, num);
			val.localPosition = Vector3.Lerp(val.localPosition, val3, num);
		}
		Transform parent = (((Object)(object)MoveCamera.Instance?.gunCamera != (Object)null) ? ((Component)MoveCamera.Instance.gunCamera).transform : val.parent);
		if (!isShield && (Object)(object)leftHandVisual == (Object)null)
		{
			return;
		}
		EnsureLeftHandVisual(parent);
		if ((Object)(object)leftHandVisual == (Object)null)
		{
			return;
		}
		if (!(isShield && leftHand))
		{
			if (leftHandVisual.activeSelf)
			{
				leftHandVisual.SetActive(false);
			}
			leftPoseInitialized = false;
			return;
		}
		if (!leftHandVisual.activeSelf)
		{
			leftHandVisual.SetActive(true);
		}
		if ((Object)(object)leftHandFilter.sharedMesh != (Object)(object)shieldItem.mesh)
		{
			leftHandFilter.sharedMesh = shieldItem.mesh;
		}
		if ((Object)(object)((Renderer)leftHandRenderer).sharedMaterial != (Object)(object)shieldItem.material)
		{
			((Renderer)leftHandRenderer).sharedMaterial = shieldItem.material;
		}
		Vector3 val4 = (blocking ? new Vector3(-0.32f, -0.12f, 0.8f) : new Vector3(-0.55f, -0.43f, 0.86f));
		Quaternion val5 = Quaternion.Euler(blocking ? new Vector3(-3f, 2f, 1f) : new Vector3(10f, 30f, -20f));
		Vector3 val6 = Vector3.one * (blocking ? 0.36f : 0.3f);
		if (!leftPoseInitialized)
		{
			leftHandVisual.transform.localPosition = val4;
			leftHandVisual.transform.localRotation = val5;
			leftHandVisual.transform.localScale = val6;
			leftPoseInitialized = true;
		}
		else
		{
			leftHandVisual.transform.localPosition = Vector3.Lerp(leftHandVisual.transform.localPosition, val4, num);
			leftHandVisual.transform.localRotation = Quaternion.Slerp(leftHandVisual.transform.localRotation, val5, num);
			leftHandVisual.transform.localScale = Vector3.Lerp(leftHandVisual.transform.localScale, val6, num);
		}
	}

	private void EnsureLeftHandVisual(Transform parent)
	{
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Expected O, but got Unknown
		if (!((Object)(object)parent == (Object)null) && (!((Object)(object)leftHandVisual != (Object)null) || !((Object)(object)leftHandVisual.transform.parent == (Object)(object)parent)))
		{
			if ((Object)(object)leftHandVisual != (Object)null)
			{
				Object.Destroy((Object)(object)leftHandVisual);
			}
			leftHandVisual = new GameObject("Muck Replayable Equipped Shield");
			leftHandVisual.transform.SetParent(parent, false);
			leftHandVisual.layer = (((Object)(object)UseInventory.Instance?.meshRenderer != (Object)null) ? ((Component)UseInventory.Instance.meshRenderer).gameObject.layer : ((Component)parent).gameObject.layer);
			leftHandFilter = leftHandVisual.AddComponent<MeshFilter>();
			leftHandRenderer = leftHandVisual.AddComponent<MeshRenderer>();
			leftHandVisual.SetActive(false);
			leftPoseInitialized = false;
		}
	}

	private void OnDisable()
	{
		ShieldNetwork.SetLocal(blocking: false, -1);
		blocking = false;
	}

	private void OnDestroy()
	{
		SceneManager.sceneLoaded -= OnSceneLoaded;
		if ((Object)(object)leftHandVisual != (Object)null)
		{
			Object.Destroy((Object)(object)leftHandVisual);
		}
	}
}
[HarmonyPatch(typeof(ItemManager), "InitAllItems")]
[HarmonyPriority(0)]
internal static class ShieldItemRegistrationPatch
{
	private static void Postfix(ItemManager __instance)
	{
		ShieldRegistry.Install(__instance);
	}
}
[HarmonyPatch(typeof(CraftingUI), "Awake")]
internal static class ShieldCraftingTabPatch
{
	private static void Postfix(CraftingUI __instance)
	{
		ShieldRegistry.InjectCrafting(__instance);
	}
}
[HarmonyPatch(typeof(CraftingUI), "Start")]
internal static class ShieldCraftingStartPatch
{
	private static void Postfix(CraftingUI __instance)
	{
		ShieldRegistry.InjectCrafting(__instance);
		BedRegistry.InjectCrafting(__instance);
	}
}
[HarmonyPatch(typeof(CraftingUI), "UpdateCraftables")]
internal static class ReplayableRecipeRefreshPatch
{
	private static void Prefix(CraftingUI __instance)
	{
		ShieldRegistry.InjectCrafting(__instance);
		BedRegistry.InjectCrafting(__instance);
	}
}
[HarmonyPatch(typeof(SpawnChestsInLocations), "SetChests")]
internal static class ShieldStructureChestLootPatch
{
	private static void Prefix(SpawnChestsInLocations __instance)
	{
		ShieldRegistry.InjectStructureChestLoot(__instance);
	}
}
[HarmonyPatch(typeof(Server), "InitializeServerPackets")]
internal static class ShieldPacketRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (Server.PacketHandlers != null)
		{
			Server.PacketHandlers[246] = new PacketHandler(ShieldNetwork.Receive);
		}
	}
}
[HarmonyPatch(typeof(LocalClient), "InitializeClientData")]
internal static class ShieldVisualPacketRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (LocalClient.packetHandlers != null)
		{
			LocalClient.packetHandlers[247] = new PacketHandler(ShieldNetwork.ReceiveVisual);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class ShieldResetPatch
{
	private static void Prefix()
	{
		ShieldNetwork.Reset();
	}
}
[HarmonyPatch(typeof(Player), "Damage")]
internal static class ServerShieldDamagePatch
{
	private static void Prefix(Player __instance, ref int damageDone)
	{
		damageDone = ShieldNetwork.ReduceDamage(__instance.id, damageDone);
	}
}
[HarmonyPatch(typeof(ServerSend), "HitPlayer")]
internal static class ShieldDamageSyncPatch
{
	private static void Prefix(ref int damage, int hurtPlayerId)
	{
		damage = ShieldNetwork.ReduceDamage(hurtPlayerId, damage);
	}
}
[HarmonyPatch(typeof(PlayerStatus), "HandleDamage")]
internal static class ShieldStaminaOnHitPatch
{
	private static void Prefix(int damageTaken)
	{
		if (ShieldNetwork.LocalBlocking && !((Object)(object)PlayerStatus.Instance == (Object)null))
		{
			PlayerStatus.Instance.stamina = Mathf.Max(0f, PlayerStatus.Instance.stamina - Mathf.Max(2f, (float)damageTaken * 0.18f));
			StaminaRegenerationGate.MarkSpent();
		}
	}
}
internal static class StaminaRegenerationGate
{
	private const float RegenDelay = 0.2f;

	private static float blockedUntil;

	internal static bool IsBlocked => Time.time < blockedUntil;

	internal static void MarkSpent()
	{
		blockedUntil = Mathf.Max(blockedUntil, Time.time + 0.2f);
	}

	internal static void Reset()
	{
		blockedUntil = 0f;
	}
}
[HarmonyPatch(typeof(PlayerStatus), "Stamina")]
internal static class DelayedStaminaRegenerationPatch
{
	private static void Prefix(PlayerStatus __instance, out float __state)
	{
		__state = ((__instance != null) ? __instance.stamina : 0f);
	}

	private static void Postfix(PlayerStatus __instance, float __state)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			if (__instance.stamina < __state - 0.001f)
			{
				StaminaRegenerationGate.MarkSpent();
			}
			else if (__instance.stamina > __state && StaminaRegenerationGate.IsBlocked)
			{
				__instance.stamina = __state;
			}
		}
	}
}
[HarmonyPatch(typeof(PlayerStatus), "Jump")]
internal static class JumpStaminaDelayPatch
{
	private static void Postfix()
	{
		StaminaRegenerationGate.MarkSpent();
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class StaminaDelayResetPatch
{
	private static void Prefix()
	{
		StaminaRegenerationGate.Reset();
	}
}
internal static class StructureUpgradeService
{
	private sealed class State
	{
		internal int Tier;

		internal int BaseMaxHp;
	}

	internal const int RequestPacketId = 244;

	internal const int SyncPacketId = 245;

	private static readonly Dictionary<int, State> States = new Dictionary<int, State>();

	private static readonly MethodInfo ClientSendTcp = AccessTools.Method(typeof(ClientSend), "SendTCPData", (Type[])null, (Type[])null);

	private static readonly MethodInfo ServerSendTcp = AccessTools.Method(typeof(ServerSend), "SendTCPData", new Type[2]
	{
		typeof(int),
		typeof(Packet)
	}, (Type[])null);

	private static readonly MethodInfo SendToAllExcept = AccessTools.Method(typeof(ServerSend), "SendTCPDataToAll", new Type[2]
	{
		typeof(int),
		typeof(Packet)
	}, (Type[])null);

	internal static void Reset()
	{
		States.Clear();
	}

	internal static bool TryUseHammer(HitableResource resource)
	{
		if ((Object)(object)resource == (Object)null || (Object)(object)Hotbar.Instance?.currentItem == (Object)null || ResourceManager.Instance?.builds == null || !ResourceManager.Instance.builds.ContainsKey(((Hitable)resource).GetId()))
		{
			return false;
		}
		if ((Hotbar.Instance.currentItem.name ?? string.Empty).IndexOf("Hammer", StringComparison.OrdinalIgnoreCase) < 0)
		{
			return false;
		}
		int tier = GetTier(((Hitable)resource).GetId());
		bool flag = ((Hitable)resource).hp < ((Hitable)resource).maxHp;
		if (!flag && tier >= 3)
		{
			ReforgedRuntime.Instance?.Notify("This structure is already fully upgraded.", 3f);
			return true;
		}
		if (!ReforgedModes.Creative && !ConsumeCost(flag, tier + 1))
		{
			return true;
		}
		Submit(((Hitable)resource).GetId());
		return true;
	}

	private static bool ConsumeCost(bool repair, int nextTier)
	{
		string itemName = (repair ? "Wood" : (nextTier switch
		{
			2 => "Rock", 
			1 => "Wood", 
			_ => "Iron Bar", 
		}));
		int num = (repair ? 3 : (nextTier switch
		{
			2 => 18, 
			1 => 15, 
			_ => 8, 
		}));
		InventoryItem val = ((IEnumerable<InventoryItem>)ItemManager.Instance?.allItems?.Values).FirstOrDefault((Func<InventoryItem, bool>)((InventoryItem item) => (Object)(object)item != (Object)null && string.Equals(item.name, itemName, StringComparison.OrdinalIgnoreCase)));
		if ((Object)(object)val == (Object)null || (Object)(object)InventoryUI.Instance == (Object)null)
		{
			return false;
		}
		InventoryItem val2 = ScriptableObject.CreateInstance<InventoryItem>();
		val2.Copy(val, num);
		if (!InventoryUI.Instance.HasItem(val2))
		{
			ReforgedRuntime.Instance?.Notify($"Need {num} {itemName}.", 3f);
			Object.Destroy((Object)(object)val2);
			return false;
		}
		InventoryUI.Instance.RemoveItem(val2);
		Object.Destroy((Object)(object)val2);
		return true;
	}

	private static void Submit(int objectId)
	{
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Expected O, but got Unknown
		if ((Object)(object)LocalClient.instance == (Object)null)
		{
			return;
		}
		if (LocalClient.serverOwner)
		{
			HandleRequest(LocalClient.instance.myId, objectId);
			return;
		}
		Packet val = new Packet(244);
		try
		{
			val.Write(objectId);
			ClientSendTcp?.Invoke(null, new object[1] { val });
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	internal static void ReceiveRequest(int fromClient, Packet packet)
	{
		try
		{
			HandleRequest(fromClient, packet.ReadInt(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected structure upgrade request: " + ex.Message));
		}
	}

	private static void HandleRequest(int fromClient, int objectId)
	{
		//IL_0058: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		if (!LocalClient.serverOwner || !InteractionGuard.TryPlayer(fromClient, out var player) || ResourceManager.Instance?.builds == null || !ResourceManager.Instance.builds.TryGetValue(objectId, out var value) || (Object)(object)value == (Object)null)
		{
			return;
		}
		HitableResource componentInChildren = value.GetComponentInChildren<HitableResource>();
		if ((Object)(object)componentInChildren == (Object)null || Vector3.Distance(((Component)player).transform.position, ((Component)componentInChildren).transform.position) > 12f)
		{
			return;
		}
		State orCreate = GetOrCreate(componentInChildren);
		string message;
		if (((Hitable)componentInChildren).hp < ((Hitable)componentInChildren).maxHp)
		{
			((Hitable)componentInChildren).hp = ((Hitable)componentInChildren).maxHp;
			message = "Structure repaired.";
		}
		else
		{
			if (orCreate.Tier >= 3)
			{
				return;
			}
			orCreate.Tier++;
			float num = ((orCreate.Tier == 1) ? 1.5f : ((orCreate.Tier == 2) ? 2.2f : 3.2f));
			((Hitable)componentInChildren).maxHp = Mathf.Max(((Hitable)componentInChildren).maxHp, Mathf.RoundToInt((float)orCreate.BaseMaxHp * num));
			((Hitable)componentInChildren).hp = ((Hitable)componentInChildren).maxHp;
			message = $"Structure upgraded to tier {orCreate.Tier}.";
		}
		ApplyVisual(componentInChildren, orCreate.Tier);
		Broadcast(objectId, orCreate.Tier, ((Hitable)componentInChildren).hp, ((Hitable)componentInChildren).maxHp, fromClient);
		ReforgedRuntime.Instance?.Notify(message, 3f);
	}

	private static State GetOrCreate(HitableResource resource)
	{
		int id = ((Hitable)resource).GetId();
		if (!States.TryGetValue(id, out var value))
		{
			value = new State
			{
				Tier = 0,
				BaseMaxHp = Mathf.Max(1, ((Hitable)resource).maxHp)
			};
			States[id] = value;
		}
		return value;
	}

	private static void Broadcast(int id, int tier, int hp, int maxHp, int requester)
	{
		if (SendToAllExcept == null || (Object)(object)LocalClient.instance == (Object)null)
		{
			return;
		}
		Packet val = CreateSyncPacket(id, tier, hp, maxHp);
		try
		{
			SendToAllExcept.Invoke(null, new object[2]
			{
				LocalClient.instance.myId,
				val
			});
		}
		finally
		{
			((IDisposable)val)?.Dispose();
		}
	}

	private static Packet CreateSyncPacket(int id, int tier, int hp, int maxHp)
	{
		//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_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Expected O, but got Unknown
		Packet val = new Packet(245);
		val.Write(id);
		val.Write(tier);
		val.Write(hp);
		val.Write(maxHp);
		return val;
	}

	internal static void ReceiveSync(Packet packet)
	{
		try
		{
			Apply(packet.ReadInt(true), packet.ReadInt(true), packet.ReadInt(true), packet.ReadInt(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected structure sync: " + ex.Message));
		}
	}

	private static void Apply(int id, int tier, int hp, int maxHp)
	{
		if (tier >= 0 && tier <= 3 && hp >= 0 && maxHp >= 1 && hp <= maxHp && ResourceManager.Instance?.builds != null && ResourceManager.Instance.builds.TryGetValue(id, out var value) && !((Object)(object)value == (Object)null))
		{
			HitableResource componentInChildren = value.GetComponentInChildren<HitableResource>();
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				States[id] = new State
				{
					Tier = tier,
					BaseMaxHp = ((tier == 0) ? maxHp : Mathf.Max(1, Mathf.RoundToInt((float)maxHp / tier switch
					{
						2 => 2.2f, 
						1 => 1.5f, 
						_ => 3.2f, 
					})))
				};
				((Hitable)componentInChildren).maxHp = maxHp;
				((Hitable)componentInChildren).hp = hp;
				ApplyVisual(componentInChildren, tier);
			}
		}
	}

	internal static void ApplySaved(int id, int tier, int hp, int maxHp)
	{
		if (ResourceManager.Instance?.builds == null || !ResourceManager.Instance.builds.TryGetValue(id, out var value) || (Object)(object)value == (Object)null)
		{
			return;
		}
		HitableResource componentInChildren = value.GetComponentInChildren<HitableResource>();
		if (!((Object)(object)componentInChildren == (Object)null))
		{
			if (maxHp <= 0)
			{
				maxHp = ((Hitable)componentInChildren).maxHp;
			}
			if (hp <= 0)
			{
				hp = maxHp;
			}
			Apply(id, Mathf.Clamp(tier, 0, 3), Mathf.Clamp(hp, 1, maxHp), maxHp);
		}
	}

	internal static void SendSnapshot(int toClient)
	{
		if (!LocalClient.serverOwner || ServerSendTcp == null || ResourceManager.Instance?.builds == null)
		{
			return;
		}
		foreach (KeyValuePair<int, State> state in States)
		{
			if (!ResourceManager.Instance.builds.TryGetValue(state.Key, out var value) || (Object)(object)value == (Object)null)
			{
				continue;
			}
			HitableResource componentInChildren = value.GetComponentInChildren<HitableResource>();
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				Packet val = CreateSyncPacket(state.Key, state.Value.Tier, ((Hitable)componentInChildren).hp, ((Hitable)componentInChildren).maxHp);
				try
				{
					ServerSendTcp.Invoke(null, new object[2] { toClient, val });
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
		}
	}

	internal static int GetTier(int id)
	{
		if (!States.TryGetValue(id, out var value))
		{
			return 0;
		}
		return value.Tier;
	}

	private static void ApplyVisual(HitableResource resource, int tier)
	{
		//IL_0048: 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_0032: 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_0094: Unknown result type (might be due to invalid IL or missing references)
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		if (tier <= 0)
		{
			return;
		}
		Color val = (Color)(tier switch
		{
			2 => new Color(0.85f, 0.64f, 0.28f), 
			1 => new Color(0.75f, 0.76f, 0.8f), 
			_ => new Color(0.35f, 0.86f, 0.8f), 
		});
		Renderer[] componentsInChildren = ((Component)((Component)resource).transform.root).GetComponentsInChildren<Renderer>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Material[] materials = componentsInChildren[i].materials;
			foreach (Material val2 in materials)
			{
				if ((Object)(object)val2 != (Object)null && val2.HasProperty("_Color"))
				{
					val2.color = Color.Lerp(val2.color, val, 0.28f);
				}
			}
		}
	}

	internal static float StationTimeMultiplier(Component station)
	{
		HitableResource val = (((Object)(object)station != (Object)null) ? ((Component)station.transform.root).GetComponentInChildren<HitableResource>() : null);
		return (((Object)(object)val != (Object)null) ? GetTier(((Hitable)val).GetId()) : 0) switch
		{
			3 => 0.42f, 
			2 => 0.62f, 
			1 => 0.82f, 
			_ => 1f, 
		};
	}
}
[HarmonyPatch(typeof(Server), "InitializeServerPackets")]
internal static class StructureUpgradeServerRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (Server.PacketHandlers != null)
		{
			Server.PacketHandlers[244] = new PacketHandler(StructureUpgradeService.ReceiveRequest);
		}
	}
}
[HarmonyPatch(typeof(LocalClient), "InitializeClientData")]
internal static class StructureUpgradeClientRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (LocalClient.packetHandlers != null)
		{
			LocalClient.packetHandlers[245] = new PacketHandler(StructureUpgradeService.ReceiveSync);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class StructureUpgradeResetPatch
{
	private static void Prefix()
	{
		StructureUpgradeService.Reset();
	}
}
[HarmonyPatch(typeof(FurnaceSync), "StartProcessing")]
internal static class UpgradedFurnaceSpeedPatch
{
	private static void Postfix(FurnaceSync __instance, ref float ___timeToProcess)
	{
		___timeToProcess = Mathf.Max(0.1f, ___timeToProcess * StructureUpgradeService.StationTimeMultiplier((Component)(object)__instance));
	}
}
[HarmonyPatch(typeof(CauldronSync), "UpdateCraftables")]
internal static class UpgradedCauldronSpeedPatch
{
	private static void Postfix(CauldronSync __instance, ref bool ___processing, ref float ___currentProcessTime, ref float ___timeToProcess)
	{
		if (___processing && ___currentProcessTime <= 0.001f)
		{
			___timeToProcess = Mathf.Max(0.1f, ___timeToProcess * StructureUpgradeService.StationTimeMultiplier((Component)(object)__instance));
		}
	}
}
internal static class TextureOverrideService
{
	private static readonly Dictionary<string, Texture2D> Overrides = new Dictionary<string, Texture2D>(StringComparer.OrdinalIgnoreCase);

	private static bool initialized;

	internal static void Initialize()
	{
		//IL_00cd: 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_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f5: Expected O, but got Unknown
		if (initialized || !Plugin.Settings.EnableTextureOverrides.Value)
		{
			return;
		}
		initialized = true;
		string text = Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location) ?? Paths.PluginPath, "MuckReplayableAssets", "Textures");
		if (!Directory.Exists(text))
		{
			text = Path.Combine(Paths.PluginPath, "MuckReplayableAssets", "Textures");
		}
		if (!Directory.Exists(text))
		{
			text = Path.Combine(Paths.PluginPath, "MuckReforgedAssets", "Textures");
		}
		if (!Directory.Exists(text))
		{
			Plugin.Log.LogWarning((object)("Texture override directory not found: " + text));
			return;
		}
		string[] files = Directory.GetFiles(text, "*.png", SearchOption.TopDirectoryOnly);
		foreach (string text2 in files)
		{
			try
			{
				byte[] array = File.ReadAllBytes(text2);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, true)
				{
					name = Path.GetFileNameWithoutExtension(text2),
					filterMode = (FilterMode)2,
					wrapMode = (TextureWrapMode)0,
					anisoLevel = 8
				};
				if (!ImageConversion.LoadImage(val, array, false))
				{
					Object.Destroy((Object)(object)val);
					continue;
				}
				Object.DontDestroyOnLoad((Object)(object)val);
				Overrides[((Object)val).name] = val;
				Plugin.Log.LogInfo((object)$"Loaded enhanced texture {((Object)val).name} ({((Texture)val).width}x{((Texture)val).height})");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Could not load texture " + text2 + ": " + ex.Message));
			}
		}
		ApplyAll();
	}

	internal static void ApplyAll()
	{
		if (Overrides.Count == 0)
		{
			return;
		}
		int num = 0;
		try
		{
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			for (int i = 0; i < array.Length; i++)
			{
				if (TryReplace(array[i]))
				{
					num++;
				}
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogDebug((object)("Texture application scan skipped: " + ex.Message));
		}
		if (num > 0)
		{
			Plugin.Log.LogInfo((object)$"Applied {num} enhanced texture material bindings");
		}
	}

	private static bool TryReplace(Material material)
	{
		if ((Object)(object)material == (Object)null || !material.HasProperty("_MainTex"))
		{
			return false;
		}
		Texture texture = material.GetTexture("_MainTex");
		if ((Object)(object)texture == (Object)null || !Overrides.TryGetValue(((Object)texture).name, out var value) || (Object)(object)texture == (Object)(object)value)
		{
			return false;
		}
		material.SetTexture("_MainTex", (Texture)(object)value);
		return true;
	}
}
[DefaultExecutionOrder(10000)]
internal sealed class ThirdPersonController : MonoBehaviour
{
	private bool enabledView;

	private float distance = 4.5f;

	private bool previousGunCamera;

	private void Update()
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKeyDown((KeyCode)118) && (Object)(object)MoveCamera.Instance != (Object)null && (Object)(object)PlayerStatus.Instance != (Object)null && !PlayerStatus.Instance.IsPlayerDead() && ((Object)(object)OtherInput.Instance == (Object)null || !OtherInput.Instance.IsAnyMenuOpen()))
		{
			SetEnabled(!enabledView);
			ReforgedRuntime.Instance?.Notify(enabledView ? "Third-person camera enabled (V)" : "First-person camera enabled (V)", 2f);
		}
		if (enabledView)
		{
			if ((Object)(object)MoveCamera.Instance == (Object)null || (int)MoveCamera.Instance.state != 0 || (Object)(object)PlayerStatus.Instance == (Object)null || PlayerStatus.Instance.IsPlayerDead())
			{
				SetEnabled(value: false);
			}
			else if ((Object)(object)OtherInput.Instance == (Object)null || !OtherInput.Instance.IsAnyMenuOpen())
			{
				distance = Mathf.Clamp(distance - Input.mouseScrollDelta.y * 0.5f, 2.5f, 8f);
			}
		}
	}

	private void LateUpdate()
	{
		//IL_0034: 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_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: 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_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009a: Unknown result type (might be due to invalid IL or missing references)
		//IL_009f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: 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_00c6: 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_00f6: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		if (enabledView && !((Object)(object)MoveCamera.Instance == (Object)null) && !((Object)(object)PlayerMovement.Instance == (Object)null) && !((Object)(object)PlayerInput.Instance == (Object)null) && (int)MoveCamera.Instance.state == 0)
		{
			Transform transform = ((Component)MoveCamera.Instance).transform;
			Vector3 val = ((Component)PlayerMovement.Instance).transform.position + Vector3.up * 1.45f;
			Quaternion val2 = Quaternion.Euler(PlayerInput.Instance.cameraRot);
			Vector3 val3 = val2 * new Vector3(0.58f, 0.15f, 0f);
			Vector3 val4 = -(val2 * Vector3.forward);
			float num = distance;
			RaycastHit val5 = default(RaycastHit);
			if (Physics.SphereCast(val + val3, 0.22f, val4, ref val5, distance, LayerMask.op_Implicit(MoveCamera.Instance.whatIsGround), (QueryTriggerInteraction)1))
			{
				num = Mathf.Max(0.55f, ((RaycastHit)(ref val5)).distance - 0.18f);
			}
			Vector3 val6 = val + val3 + val4 * num;
			transform.position = Vector3.Lerp(transform.position, val6, 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) * 18f));
			transform.rotation = val2;
		}
	}

	private void SetEnabled(bool value)
	{
		if (enabledView == value)
		{
			return;
		}
		enabledView = value;
		Camera val = MoveCamera.Instance?.gunCamera;
		if (value)
		{
			previousGunCamera = (Object)(object)val != (Object)null && ((Behaviour)val).enabled;
			if ((Object)(object)val != (Object)null)
			{
				((Behaviour)val).enabled = false;
			}
		}
		else if ((Object)(object)val != (Object)null)
		{
			((Behaviour)val).enabled = previousGunCamera;
		}
	}

	private void OnDisable()
	{
		SetEnabled(value: false);
	}
}
[HarmonyPatch(typeof(Item), "UpdateMesh")]
internal static class GroundWheatVisibilityPatch
{
	private static void Postfix(Item __instance)
	{
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: 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_0068: 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_0087: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)((__instance != null) ? __instance.item : null) == (Object)null || !string.Equals(__instance.item.name, "Wheat", StringComparison.OrdinalIgnoreCase))
		{
			return;
		}
		Transform transform = ((Component)__instance).transform;
		Vector3 localScale = transform.localScale;
		localScale.x = Mathf.Max(localScale.x, 1.6f);
		localScale.z = Mathf.Max(localScale.z, 1.6f);
		transform.localScale = localScale;
		Rigidbody component = ((Component)__instance).GetComponent<Rigidbody>();
		if ((Object)(object)component != (Object)null)
		{
			component.constraints = (RigidbodyConstraints)(component.constraints | 0x50);
		}
		MeshRenderer component2 = ((Component)__instance).GetComponent<MeshRenderer>();
		if ((Object)(object)component2 != (Object)null)
		{
			((Renderer)component2).enabled = true;
			Material material = ((Renderer)component2).material;
			if ((Object)(object)material != (Object)null && material.HasProperty("_OutlineWidth"))
			{
				material.SetFloat("_OutlineWidth", 0.1f);
			}
		}
	}
}
internal static class UiStabilityService
{
	internal static void CleanupLegacyTextOverlays()
	{
		try
		{
			Text[] array = (from value in Resources.FindObjectsOfTypeAll<Text>()
				where (Object)(object)value != (Object)null && ((Object)((Component)value).gameObject).name == "Muck Reforged Unicode Text"
				select value).ToArray();
			Text[] array2 = array;
			for (int num = 0; num < array2.Length; num++)
			{
				GameObject gameObject = ((Component)array2[num]).gameObject;
				Transform parent = gameObject.transform.parent;
				TMP_Text val = ((parent != null) ? ((Component)parent).GetComponent<TMP_Text>() : null);
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = true;
				}
				Object.Destroy((Object)(object)gameObject);
			}
			if (array.Length != 0)
			{
				Plugin.Log.LogInfo((object)$"Removed {array.Length} obsolete localization text overlays.");
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogDebug((object)("Legacy UI cleanup skipped: " + ex.Message));
		}
	}

	internal static void ConfigureTooltip(ItemInfo itemInfo)
	{
		if (!((Object)(object)itemInfo?.text == (Object)null))
		{
			((Behaviour)itemInfo.text).enabled = true;
			((TMP_Text)itemInfo.text).richText = true;
		}
	}

	internal static void RefreshInventory()
	{
		InventoryUI instance = InventoryUI.Instance;
		if (!((Object)(object)instance == (Object)null))
		{
			instance.UpdateAllCells();
			Hotbar instance2 = Hotbar.Instance;
			if (instance2 != null)
			{
				instance2.UpdateHotbar();
			}
		}
	}
}
[HarmonyPatch(typeof(ItemInfo), "Awake")]
internal static class TooltipInitializationPatch
{
	private static void Postfix(ItemInfo __instance)
	{
		UiStabilityService.ConfigureTooltip(__instance);
	}
}
[HarmonyPatch(typeof(ItemInfo), "SetText")]
internal static class TooltipLayoutPatch
{
	private static void Prefix(ItemInfo __instance)
	{
		UiStabilityService.ConfigureTooltip(__instance);
	}

	private static void Postfix(ItemInfo __instance)
	{
		if (!((Object)(object)__instance?.text == (Object)null))
		{
			((TMP_Text)__instance.text).ForceMeshUpdate(false, false);
			__instance.FitToText();
		}
	}
}
[HarmonyPatch(typeof(OtherInput), "ToggleInventory")]
internal static class InventoryVisibilityRefreshPatch
{
	private static void Postfix()
	{
		if ((Object)(object)InventoryUI.Instance != (Object)null && ((Component)InventoryUI.Instance).gameObject.activeInHierarchy)
		{
			UiStabilityService.RefreshInventory();
		}
	}
}
[HarmonyPatch(typeof(InventoryUI), "AddItemToInventory")]
internal static class PickupVisibilityRefreshPatch
{
	private static void Postfix()
	{
		Hotbar instance = Hotbar.Instance;
		if (instance != null)
		{
			instance.UpdateHotbar();
		}
	}
}
internal static class VictoryContinuation
{
	internal const int ContinuePacketId = 250;

	private static readonly MethodInfo SendAllExcept = AccessTools.Method(typeof(ServerSend), "SendTCPDataToAll", new Type[2]
	{
		typeof(int),
		typeof(Packet)
	}, (Type[])null);

	private static readonly FieldInfo BoatSinking = AccessTools.Field(typeof(Boat), "sinking");

	private static bool handled;

	internal static float OriginalWaterY { get; set; }

	internal static void Reset()
	{
		handled = false;
		OriginalWaterY = 0f;
	}

	internal static bool HandleDragonDestroyed(Dragon dragon)
	{
		//IL_0029: 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_0042: Invalid comparison between Unknown and I4
		//IL_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Expected O, but got Unknown
		if (handled || (Object)(object)dragon == (Object)null || (Object)(object)GameManager.instance == (Object)null || GameManager.gameSettings == null || (int)GameManager.gameSettings.gameMode != 0 || !GameManager.instance.boatLeft || (int)GameManager.state != 1)
		{
			return false;
		}
		handled = true;
		if ((Object)(object)dragon.roar != (Object)null)
		{
			Object.Instantiate<GameObject>(dragon.roar, ((Component)dragon).transform.position, Quaternion.identity);
		}
		if (LocalClient.serverOwner)
		{
			Packet val = new Packet(250);
			try
			{
				val.Write(OriginalWaterY);
				SendAllExcept?.Invoke(null, new object[2]
				{
					LocalClient.instance.myId,
					val
				});
				Apply(OriginalWaterY);
				ServerSend.SendChatMessage(-1, "", "<color=orange>Victory! The island remains available for continued play.");
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		return true;
	}

	internal static void Receive(Packet packet)
	{
		try
		{
			Apply(packet.ReadFloat(true));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected continue-after-victory packet: " + ex.Message));
		}
	}

	private static void Apply(float waterY)
	{
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: 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_00ca: 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_011a: 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_012b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0131: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_014e: Unknown result type (might be due to invalid IL or missing references)
		//IL_015f: 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_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: 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_018c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		handled = true;
		if ((Object)(object)GameManager.instance == (Object)null)
		{
			return;
		}
		((MonoBehaviour)GameManager.instance).CancelInvoke("ShowEndScreen");
		GameManager.instance.boatLeft = false;
		GameManager.state = (GameState)1;
		if ((Object)(object)GameManager.instance.gameoverUi != (Object)null)
		{
			GameManager.instance.gameoverUi.SetActive(false);
		}
		if ((Object)(object)Boat.Instance != (Object)null)
		{
			BoatSinking?.SetValue(Boat.Instance, false);
		}
		if ((Object)(object)World.Instance?.water != (Object)null)
		{
			World.Instance.water.position = new Vector3(World.Instance.water.position.x, waterY, World.Instance.water.position.z);
		}
		if ((Object)(object)PlayerMovement.Instance != (Object)null)
		{
			int num = LocalClient.instance?.myId ?? 0;
			Vector2 val = new Vector2(Mathf.Cos((float)num * 2.1f), Mathf.Sin((float)num * 2.1f)) * 4f;
			Vector3 val2 = new Vector3(val.x, 2000f, val.y);
			Vector3 position = default(Vector3);
			((Vector3)(ref position))..ctor(val.x, 30f, val.y);
			RaycastHit val3 = default(RaycastHit);
			if (Physics.Raycast(val2, Vector3.down, ref val3, 4000f, LayerMask.op_Implicit(GameManager.instance.whatIsGround), (QueryTriggerInteraction)1))
			{
				position = ((RaycastHit)(ref val3)).point + Vector3.up * 3f;
			}
			((Component)PlayerMovement.Instance).transform.position = position;
			Rigidbody rb = PlayerMovement.Instance.GetRb();
			if ((Object)(object)rb != (Object)null)
			{
				rb.position = position;
				rb.velocity = Vector3.zero;
			}
		}
		if ((Object)(object)PlayerInput.Instance != (Object)null)
		{
			PlayerInput.Instance.active = true;
		}
		Cursor.visible = false;
		Cursor.lockState = (CursorLockMode)1;
		AchievementManager instance = AchievementManager.Instance;
		if (instance != null)
		{
			instance.CheckGameOverAchievements(-3);
		}
		MusicController instance2 = MusicController.Instance;
		if (instance2 != null)
		{
			instance2.PlaySong((SongType)(DayCycle.time > 0.5f), true);
		}
		ReforgedRuntime.Instance?.Notify("Victory! You returned to the island and can keep playing.", 7f);
		if (LocalClient.serverOwner)
		{
			RunSaveService.SaveSlot(Mathf.Clamp(Plugin.Settings.ActiveSaveSlot.Value, 1, 24), automatic: false);
		}
	}
}
internal sealed class VictoryContinuationController : MonoBehaviour
{
	private void Update()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)World.Instance?.water != (Object)null && (Object)(object)GameManager.instance != (Object)null && !GameManager.instance.boatLeft)
		{
			VictoryContinuation.OriginalWaterY = World.Instance.water.position.y;
		}
	}
}
[HarmonyPatch(typeof(Dragon), "OnDestroy")]
internal static class ContinueAfterDragonPatch
{
	private static bool Prefix(Dragon __instance)
	{
		return !VictoryContinuation.HandleDragonDestroyed(__instance);
	}
}
[HarmonyPatch(typeof(LocalClient), "InitializeClientData")]
internal static class VictoryContinuePacketPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (LocalClient.packetHandlers != null)
		{
			LocalClient.packetHandlers[250] = new PacketHandler(VictoryContinuation.Receive);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class VictoryContinueResetPatch
{
	private static void Prefix()
	{
		VictoryContinuation.Reset();
	}
}
[HarmonyPatch(typeof(TextureGenerator), "ColorTextureFromHeightMap")]
internal static class ExpandedMapTexturePatch
{
	private static bool Prefix(float[,] heightMap, TextureData textureData, ref Texture2D __result)
	{
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		if (heightMap == null || textureData?.layers == null || textureData.layers.Length == 0)
		{
			return true;
		}
		int length = heightMap.GetLength(0);
		int length2 = heightMap.GetLength(1);
		Color[] array = (Color[])(object)new Color[length * length2];
		for (int i = 0; i < length2; i++)
		{
			int num = length2 - 1 - i;
			for (int j = 0; j < length; j++)
			{
				array[i * length + j] = TextureGenerator.GetColor(heightMap[j, num], textureData);
			}
		}
		__result = TextureGenerator.textureFromColorMap(array, length, length2);
		return false;
	}
}
internal enum VariantKind
{
	None,
	GoblinShaman,
	GoblinRider,
	AlphaWolf,
	CrystalGolem,
	ForestDeer,
	WildBoar,
	EclipseBoss
}
internal static class ContentVariants
{
	internal static void Apply(Mob mob)
	{
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_028b: Unknown result type (might be due to invalid IL or missing references)
		if (!Plugin.Settings.EnableContentVariants.Value || (Object)(object)mob == (Object)null || (Object)(object)mob.mobType == (Object)null || (Object)(object)((Component)mob).GetComponent<VariantVisual>() != (Object)null || (Object)(object)((Component)mob).GetComponent<ReforgedMobVisual>() != (Object)null)
		{
			return;
		}
		int num = (((Object)(object)GameManager.instance != (Object)null) ? GameManager.instance.currentDay : 0);
		string text = (mob.mobType.name ?? ((Object)mob).name).ToLowerInvariant();
		uint num2 = StableHash(mob.id, text);
		if (!mob.mobType.boss && (int)mob.mobType.behaviour != 0 && num >= 1 && num2 % 100 < (uint)Mathf.Min(32, 14 + num * 2))
		{
			int num3 = ((num >= 8 && (num2 & 3) == 0) ? 3 : ((num < 4 || (num2 & 1) != 0) ? 1 : 2));
			mob.multiplier = Mathf.Max(mob.multiplier, 1f + (float)num3 * 0.08f);
			((Component)mob).gameObject.AddComponent<ArmoredMobVisual>().Initialize(num3);
		}
		VariantKind variantKind = Select(text, num2, num, mob.mobType.boss);
		if (variantKind != VariantKind.None)
		{
			float num4 = 1f;
			float speed = 1f;
			Color white = Color.white;
			switch (variantKind)
			{
			case VariantKind.GoblinShaman:
				num4 = 1.25f;
				speed = 0.92f;
				((Color)(ref white))..ctor(0.55f, 0.8f, 1f);
				break;
			case VariantKind.GoblinRider:
				num4 = 1.35f;
				speed = 1.2f;
				((Color)(ref white))..ctor(0.75f, 0.55f, 0.35f);
				break;
			case VariantKind.AlphaWolf:
				num4 = 1.4f;
				speed = 1.14f;
				((Color)(ref white))..ctor(1f, 0.38f, 0.3f);
				break;
			case VariantKind.CrystalGolem:
				num4 = 1.55f;
				speed = 0.88f;
				((Color)(ref white))..ctor(0.35f, 0.9f, 1f);
				break;
			case VariantKind.ForestDeer:
				speed = 1.28f;
				((Color)(ref white))..ctor(0.58f, 0.36f, 0.2f);
				break;
			case VariantKind.WildBoar:
				num4 = 1.2f;
				speed = 1.08f;
				((Color)(ref white))..ctor(0.42f, 0.28f, 0.2f);
				break;
			case VariantKind.EclipseBoss:
				num4 = 1.3f;
				speed = 1.08f;
				((Color)(ref white))..ctor(0.62f, 0.3f, 0.95f);
				break;
			}
			mob.multiplier = Mathf.Max(mob.multiplier, num4);
			((Component)mob).gameObject.AddComponent<VariantVisual>().Initialize(variantKind, white, speed);
		}
	}

	private static VariantKind Select(string name, uint hash, int day, bool boss)
	{
		if (boss && day >= 8 && hash % 3 == 0)
		{
			return VariantKind.EclipseBoss;
		}
		if (name.Contains("dino") && day >= 2 && hash % 9 == 0)
		{
			return VariantKind.GoblinRider;
		}
		if (name.Contains("goblin") && day >= 3 && hash % 8 == 0)
		{
			return VariantKind.GoblinShaman;
		}
		if (name.Contains("wolf") && day >= 2 && hash % 7 == 0)
		{
			return VariantKind.AlphaWolf;
		}
		if ((name.Contains("golem") || name.Contains("chunk")) && day >= 4 && hash % 8 == 0)
		{
			return VariantKind.CrystalGolem;
		}
		if (name.Contains("cow") && hash % 13 == 0)
		{
			return VariantKind.ForestDeer;
		}
		if (name.Contains("bull") && hash % 11 == 0)
		{
			return VariantKind.WildBoar;
		}
		return VariantKind.None;
	}

	private static uint StableHash(int id, string value)
	{
		uint num = 2166136261u;
		num = (num ^ (uint)id) * 16777619;
		foreach (char c in value)
		{
			num = (num ^ c) * 16777619;
		}
		return num;
	}
}
internal sealed class ArmoredMobVisual : MonoBehaviour
{
	private int tier;

	internal void Initialize(int value)
	{
		tier = Mathf.Clamp(value, 1, 3);
	}

	private IEnumerator Start()
	{
		yield return null;
		Renderer[] array = (from value in ((Component)this).GetComponentsInChildren<Renderer>(true)
			where (Object)(object)value != (Object)null && !((Object)value).name.StartsWith("Replayable Armor", StringComparison.Ordinal)
			select value).ToArray();
		if (array.Length != 0)
		{
			Bounds bounds = array[0].bounds;
			for (int num = 1; num < array.Length; num++)
			{
				((Bounds)(ref bounds)).Encapsulate(array[num].bounds);
			}
			float num2 = Mathf.Clamp(((Bounds)(ref bounds)).size.x, 0.65f, 3.2f);
			float num3 = Mathf.Clamp(((Bounds)(ref bounds)).size.z, 0.5f, 2.8f);
			Color color = ((tier == 1) ? new Color(0.42f, 0.43f, 0.46f) : ((tier == 2) ? new Color(0.78f, 0.63f, 0.22f) : new Color(0.25f, 0.78f, 0.72f)));
			CreatePlate("Replayable Armor Helmet", ((Bounds)(ref bounds)).center + Vector3.up * ((Bounds)(ref bounds)).extents.y * 0.72f, new Vector3(num2 * 0.72f, Mathf.Max(0.14f, ((Bounds)(ref bounds)).size.y * 0.11f), num3 * 0.78f), color);
			CreatePlate("Replayable Armor Chest", ((Bounds)(ref bounds)).center + Vector3.up * ((Bounds)(ref bounds)).extents.y * 0.06f, new Vector3(num2 * 0.92f, Mathf.Max(0.18f, ((Bounds)(ref bounds)).size.y * 0.22f), Mathf.Max(0.12f, num3 * 0.3f)), color);
			CreatePlate("Replayable Armor Shoulder L", ((Bounds)(ref bounds)).center + Vector3.left * num2 * 0.52f + Vector3.up * ((Bounds)(ref bounds)).extents.y * 0.22f, Vector3.one * Mathf.Max(0.16f, num2 * 0.23f), color);
			CreatePlate("Replayable Armor Shoulder R", ((Bounds)(ref bounds)).center + Vector3.right * num2 * 0.52f + Vector3.up * ((Bounds)(ref bounds)).extents.y * 0.22f, Vector3.one * Mathf.Max(0.16f, num2 * 0.23f), color);
		}
	}

	private void CreatePlate(string objectName, Vector3 worldPosition, Vector3 worldScale, Color color)
	{
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
		GameObject obj = GameObject.CreatePrimitive((PrimitiveType)3);
		((Object)obj).name = objectName + " T" + tier;
		Collider component = obj.GetComponent<Collider>();
		if ((Object)(object)component != (Object)null)
		{
			Object.Destroy((Object)(object)component);
		}
		obj.transform.SetParent(((Component)this).transform, true);
		obj.transform.position = worldPosition;
		Vector3 lossyScale = ((Component)this).transform.lossyScale;
		obj.transform.localScale = new Vector3(worldScale.x / Mathf.Max(0.01f, lossyScale.x), worldScale.y / Mathf.Max(0.01f, lossyScale.y), worldScale.z / Mathf.Max(0.01f, lossyScale.z));
		obj.GetComponent<Renderer>().material.color = color;
	}
}
internal sealed class VariantVisual : MonoBehaviour
{
	private VariantKind kind;

	private Color tint;

	private float speedMultiplier;

	internal void Initialize(VariantKind value, Color color, float speed)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		kind = value;
		tint = color;
		speedMultiplier = speed;
	}

	private IEnumerator Start()
	{
		yield return null;
		Mob component = ((Component)this).GetComponent<Mob>();
		if (!((Object)(object)component == (Object)null))
		{
			if ((Object)(object)component.agent != (Object)null)
			{
				component.SetSpeed(speedMultiplier);
			}
			TintRenderers(((Component)this).gameObject, tint);
			if (kind == VariantKind.GoblinRider)
			{
				AttachGoblinRider();
			}
			if (kind == VariantKind.ForestDeer)
			{
				((Component)this).transform.localScale = Vector3.Scale(((Component)this).transform.localScale, new Vector3(0.88f, 1.15f, 0.9f));
			}
			if (kind == VariantKind.WildBoar)
			{
				((Component)this).transform.localScale = Vector3.Scale(((Component)this).transform.localScale, new Vector3(0.9f, 0.72f, 1.05f));
			}
		}
	}

	private void AttachGoblinRider()
	{
		//IL_008e: 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_00bd: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
		if (MobSpawner.Instance?.allMobs == null)
		{
			return;
		}
		MobType val = ((IEnumerable<MobType>)MobSpawner.Instance.allMobs).FirstOrDefault((Func<MobType, bool>)((MobType type) => (Object)(object)type != (Object)null && !type.boss && (type.name ?? string.Empty).IndexOf("goblin", StringComparison.OrdinalIgnoreCase) >= 0));
		if (!((Object)(object)val?.mobPrefab == (Object)null))
		{
			GameObject val2 = VisualCloneFactory.Instantiate(val.mobPrefab, ((Component)this).transform, "Reforged Goblin Rider Visual");
			if (!((Object)(object)val2 == (Object)null))
			{
				val2.transform.localPosition = new Vector3(0f, 1.25f, -0.05f);
				val2.transform.localRotation = Quaternion.Euler(0f, 0f, 0f);
				val2.transform.localScale = Vector3.one * 0.62f;
				TintRenderers(val2, new Color(0.85f, 0.65f, 0.38f));
			}
		}
	}

	private static void TintRenderers(GameObject root, Color color)
	{
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
		for (int i = 0; i < componentsInChildren.Length; i++)
		{
			Material[] materials = componentsInChildren[i].materials;
			foreach (Material val in materials)
			{
				if (!((Object)(object)val == (Object)null) && val.HasProperty("_Color"))
				{
					val.color = Color.Lerp(val.color, val.color * color, 0.48f);
					if (val.HasProperty("_EmissionColor") && ((Color)(ref color)).maxColorComponent > 0.9f)
					{
						val.SetColor("_EmissionColor", color * 0.35f);
					}
				}
			}
		}
	}
}
internal static class CaveNetwork
{
	private sealed class CaveVolume
	{
		internal Vector3 Center;

		internal Quaternion Rotation;

		internal Quaternion InverseRotation;

		internal Vector3 HalfExtents;

		internal bool Contains(Vector3 point)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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_0048: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = InverseRotation * (point - Center);
			if (Mathf.Abs(val.x) <= HalfExtents.x && Mathf.Abs(val.y) <= HalfExtents.y)
			{
				return Mathf.Abs(val.z) <= HalfExtents.z;
			}
			return false;
		}
	}

	private sealed class CaveOpening
	{
		internal Vector3 AxisOrigin;

		internal Vector3 Direction;

		internal float Width;

		internal float Height;
	}

	private sealed class OreNode
	{
		internal int Id;

		internal GameObject Object;

		internal string Kind;

		internal OreTier Tier;
	}

	private enum CaveSurfaceKind
	{
		Floor,
		Wall,
		Ceiling
	}

	private sealed class OreSlotCandidate
	{
		internal Vector3 Origin;

		internal Vector3 Direction;

		internal CaveSurfaceKind Kind;
	}

	private sealed class CaveOreSurfaceSlot
	{
		internal Vector3 Position;

		internal Vector3 Normal;

		internal CaveSurfaceKind Kind;
	}

	private sealed class GuardedOre
	{
		internal int Id;

		internal GameObject Object;

		internal Vector3 Position;
	}

	private enum OreTier
	{
		Stone,
		Coal,
		Iron,
		Gold,
		Mithril,
		Adamantite,
		Obamium,
		Ruby,
		Unknown
	}

	private struct WaterRendererState
	{
		internal bool Enabled;

		internal bool ForceRenderingOff;
	}

	private sealed class CaveOreGuardController : MonoBehaviour
	{
		private readonly List<GuardedOre> pending = new List<GuardedOre>();

		private int cursor;

		private float nextCheck;

		internal void Initialize(IEnumerable<GuardedOre> values)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_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_0083: Unknown result type (might be due to invalid IL or missing references)
			pending.Clear();
			foreach (GuardedOre value in values)
			{
				float num = Noise01(value.Id, 951, GameManager.GetSeed()) * (float)Math.PI * 2f;
				Vector3 candidate = value.Position + new Vector3(Mathf.Cos(num), 0f, Mathf.Sin(num)) * 2.8f;
				if (TryFindCaveFloor(((Component)this).transform, candidate, out var grounded) || TryFindCaveFloor(((Component)this).transform, value.Position, out grounded))
				{
					pending.Add(new GuardedOre
					{
						Id = value.Id,
						Object = value.Object,
						Position = grounded.Position + Vector3.up * 0.18f
					});
				}
			}
			Plugin.Log.LogInfo((object)$"Prepared {pending.Count} cave mineral guards (90% none / 10% one per placed mineral).");
			((Behaviour)this).enabled = pending.Count > 0;
		}

		private void Update()
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (!LocalClient.serverOwner || Time.unscaledTime < nextCheck || pending.Count == 0)
			{
				return;
			}
			nextCheck = Time.unscaledTime + 0.25f;
			if (MobSpawner.Instance?.allMobs == null || (Object)(object)MobManager.Instance == (Object)null || GameManager.players == null)
			{
				return;
			}
			int num = Mathf.Min(8, pending.Count);
			while (num-- > 0 && pending.Count > 0)
			{
				cursor %= pending.Count;
				GuardedOre guard = pending[cursor];
				if ((Object)(object)guard.Object == (Object)null)
				{
					pending.RemoveAt(cursor);
				}
				else if (!GameManager.players.Values.Any(delegate(PlayerManager player)
				{
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					//IL_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0034: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)player != (Object)null && !player.dead && !player.disconnected)
					{
						Vector3 val = ((Component)player).transform.position - guard.Position;
						return ((Vector3)(ref val)).sqrMagnitude <= 42.25f;
					}
					return false;
				}))
				{
					cursor++;
				}
				else if (TrySpawnGuard(guard.Position))
				{
					pending.RemoveAt(cursor);
				}
				else
				{
					cursor++;
				}
			}
			if (pending.Count == 0)
			{
				((Behaviour)this).enabled = false;
			}
		}

		private static bool TrySpawnGuard(Vector3 position)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			MobType val = NewMonsterRegistry.Get(ReforgedMobKind.CaveStalker) ?? ((IEnumerable<MobType>)MobSpawner.Instance.allMobs).FirstOrDefault((Func<MobType, bool>)((MobType value) => (Object)(object)value != (Object)null && !value.boss && (int)value.behaviour != 0 && ((value.name ?? string.Empty).IndexOf("wolf", StringComparison.OrdinalIgnoreCase) >= 0 || (value.name ?? string.Empty).IndexOf("goblin", StringComparison.OrdinalIgnoreCase) >= 0)));
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			int num = Array.IndexOf(MobSpawner.Instance.allMobs, val);
			if (num < 0)
			{
				num = val.id;
			}
			if (num < 0 || num >= MobSpawner.Instance.allMobs.Length)
			{
				return false;
			}
			try
			{
				MobSpawner.Instance.ServerSpawnNewMob(MobManager.Instance.GetNextId(), num, position, 1f, 1f, (BossType)0, -1);
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Cave mineral guard spawn failed safely: " + ex.Message));
				return false;
			}
		}
	}

	private static bool built;

	private static readonly List<Transform> SurfaceEntrances = new List<Transform>();

	private static readonly List<CaveVolume> Volumes = new List<CaveVolume>();

	private static readonly Dictionary<Vector2Int, List<CaveVolume>> VolumeCells = new Dictionary<Vector2Int, List<CaveVolume>>();

	private const float VolumeCellSize = 64f;

	private static readonly Dictionary<Renderer, WaterRendererState> WaterRendererStates = new Dictionary<Renderer, WaterRendererState>();

	private static bool waterHidden;

	private static int cachedInsideFrame = -1;

	private static bool cachedInside;

	internal static bool IsLocalInside
	{
		get
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (cachedInsideFrame == Time.frameCount)
			{
				return cachedInside;
			}
			cachedInsideFrame = Time.frameCount;
			cachedInside = (Object)(object)PlayerMovement.Instance != (Object)null && IsInside(((Component)PlayerMovement.Instance).transform.position);
			return cachedInside;
		}
	}

	internal static IEnumerable<Transform> Entrances => SurfaceEntrances.Where((Transform value) => (Object)(object)value != (Object)null);

	internal static void Reset()
	{
		built = false;
		SurfaceEntrances.Clear();
		Volumes.Clear();
		VolumeCells.Clear();
		cachedInsideFrame = -1;
		cachedInside = false;
		RestoreWaterRenderers();
		DetailedMapService.ResetLandmarks();
	}

	internal static bool IsInside(Vector3 point)
	{
		//IL_000b: 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_0037: 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)
		if (!built)
		{
			return false;
		}
		Vector2Int key = default(Vector2Int);
		((Vector2Int)(ref key))..ctor(Mathf.FloorToInt(point.x / 64f), Mathf.FloorToInt(point.z / 64f));
		if (!VolumeCells.TryGetValue(key, out var value))
		{
			return false;
		}
		for (int i = 0; i < value.Count; i++)
		{
			if (value[i].Contains(point))
			{
				return true;
			}
		}
		return false;
	}

	internal static void UpdateWaterVisibility()
	{
		if (IsLocalInside && !waterHidden)
		{
			World instance = World.Instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				Transform water = instance.water;
				obj = ((water != null) ? ((Component)water).GetComponentsInChildren<Renderer>(true) : null);
			}
			if (obj == null)
			{
				obj = Array.Empty<Renderer>();
			}
			Renderer[] array = (Renderer[])obj;
			foreach (Renderer val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					if (!WaterRendererStates.ContainsKey(val))
					{
						WaterRendererStates[val] = new WaterRendererState
						{
							Enabled = val.enabled,
							ForceRenderingOff = val.forceRenderingOff
						};
					}
					val.enabled = false;
					val.forceRenderingOff = true;
				}
			}
			waterHidden = true;
		}
		else if (waterHidden)
		{
			RestoreWaterRenderers();
		}
	}

	private static void RestoreWaterRenderers()
	{
		foreach (KeyValuePair<Renderer, WaterRendererState> waterRendererState in WaterRendererStates)
		{
			if ((Object)(object)waterRendererState.Key != (Object)null)
			{
				waterRendererState.Key.enabled = waterRendererState.Value.Enabled;
				waterRendererState.Key.forceRenderingOff = waterRendererState.Value.ForceRenderingOff;
			}
		}
		WaterRendererStates.Clear();
		waterHidden = false;
	}

	internal static void Build()
	{
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Expected O, but got Unknown
		//IL_011d: Unknown result type (might be due to invalid IL or missing references)
		if (built || !Plugin.Settings.EnableCaveNetwork.Value)
		{
			return;
		}
		Cave[] source = Object.FindObjectsOfType<Cave>();
		built = true;
		List<Cave> source2 = (from cave in source
			orderby ((Component)cave).transform.position.x, ((Component)cave).transform.position.z
			select cave).ToList();
		Material val = source2.Select(delegate(Cave cave)
		{
			Renderer componentInChildren = ((Component)cave).GetComponentInChildren<Renderer>();
			return (componentInChildren == null) ? null : componentInChildren.sharedMaterial;
		}).FirstOrDefault((Func<Material, bool>)((Material value) => (Object)(object)value != (Object)null));
		if ((Object)(object)val == (Object)null)
		{
			MapDisplay obj = Object.FindObjectOfType<MapDisplay>();
			object obj2;
			if (obj == null)
			{
				obj2 = null;
			}
			else
			{
				MeshFilter meshFilter = obj.meshFilter;
				if (meshFilter == null)
				{
					obj2 = null;
				}
				else
				{
					Renderer component = ((Component)meshFilter).GetComponent<Renderer>();
					obj2 = ((component != null) ? component.sharedMaterial : null);
				}
			}
			val = (Material)obj2;
		}
		GameObject val2 = new GameObject("Muck Replayable Natural Cave Network");
		if ((Object)(object)World.Instance?.water != (Object)null)
		{
			_ = World.Instance.water.position;
		}
		List<Transform> list = new List<Transform>(8);
		AddDistantEntrances(val2.transform, list, val, 8, source2.Select((Cave cave) => ((Component)cave).transform.position));
		if (list.Count == 0)
		{
			built = false;
			Object.Destroy((Object)(object)val2);
			Plugin.Log.LogWarning((object)"Connected cave generation skipped: no terrain-safe entrance could be placed.");
			return;
		}
		SurfaceEntrances.AddRange(list);
		CarveTerrainEntrances(list);
		ClearEntranceObstacles(list);
		int num = Mathf.Clamp(Plugin.Settings.CaveOreNodesPerTunnel.Value, 24, 120) * Mathf.Max(1, list.Count / 2);
		List<OreSlotCandidate> list2 = new List<OreSlotCandidate>(num * 3);
		BuildSharedNetwork(val2.transform, list, val, list2);
		RebuildVolumeIndex();
		if (Plugin.Settings.MoveOresIntoCaves.Value)
		{
			List<GuardedOre> list3 = MoveOreNodes(val2.transform, list2, num);
			if (list3.Count > 0 && LocalClient.serverOwner)
			{
				val2.AddComponent<CaveOreGuardController>().Initialize(list3);
			}
		}
		DetailedMapService.RefreshLandmarks();
		Plugin.Log.LogInfo((object)($"Built natural cave network: {list.Count} distant entrances, " + $"a connected backbone and shared cavern, {list2.Count} mineral probes for a {num}-node target"));
	}

	private static List<Vector3> SelectEntrancePositions(List<Vector3> candidates, int maximum)
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0065: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		List<Vector3> list = new List<Vector3>();
		foreach (Vector3 candidate in candidates.OrderBy((Vector3 value) => Mathf.Atan2(value.z, value.x)))
		{
			if (list.All((Vector3 existing) => HorizontalDistance(existing, candidate) >= 180f))
			{
				list.Add(candidate);
			}
		}
		List<Vector3> list2 = list;
		if (list2.Count <= maximum)
		{
			return list2;
		}
		List<Vector3> selected = new List<Vector3> { list2[0] };
		list2.RemoveAt(0);
		while (selected.Count < maximum && list2.Count > 0)
		{
			Vector3 item = list2.OrderByDescending((Vector3 b) => selected.Min((Vector3 existing) => HorizontalDistance(existing, b))).First();
			selected.Add(item);
			list2.Remove(item);
		}
		return selected.OrderBy((Vector3 value) => Mathf.Atan2(value.z, value.x)).ToList();
	}

	private static void AddDistantEntrances(Transform root, List<Transform> entrances, Material material, int targetCount, IEnumerable<Vector3> exclusions = null)
	{
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_0158: Unknown result type (might be due to invalid IL or missing references)
		//IL_0178: Unknown result type (might be due to invalid IL or missing references)
		//IL_017d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0203: Unknown result type (might be due to invalid IL or missing references)
		//IL_0236: Unknown result type (might be due to invalid IL or missing references)
		//IL_023d: Expected O, but got Unknown
		//IL_0253: Unknown result type (might be due to invalid IL or missing references)
		//IL_027a: Unknown result type (might be due to invalid IL or missing references)
		List<Vector3> list = entrances.Select((Transform value) => value.position).ToList();
		List<Vector3> source = (exclusions ?? Enumerable.Empty<Vector3>()).ToList();
		float num = 1100f * (float)MapGenerator.mapChunkSize / 241f;
		float num2 = (float)Mathf.Abs(GameManager.GetSeed() % 360) * ((float)Math.PI / 180f);
		float num3 = (((Object)(object)World.Instance?.water != (Object)null) ? World.Instance.water.position.y : 0f);
		int num4 = LayerMask.NameToLayer("Ground");
		int mask = ((num4 >= 0) ? (1 << num4) : (-5));
		MeshCollider val = Object.FindObjectOfType<MapDisplay>()?.meshCollider;
		if ((Object)(object)val == (Object)null)
		{
			Plugin.Log.LogWarning((object)"Connected cave entrances skipped: the terrain collider was unavailable.");
			return;
		}
		for (int num5 = 0; num5 < 192; num5++)
		{
			if (entrances.Count >= targetCount)
			{
				break;
			}
			float num6 = num2 + (float)num5 * 137.50777f * ((float)Math.PI / 180f);
			float num7 = 0.42f + (float)(num5 % 3) * 0.11f;
			if (!TryRaycastTerrain(new Vector3(Mathf.Cos(num6) * num * num7, 1200f, Mathf.Sin(num6) * num * num7), val, mask, out var terrainHit))
			{
				continue;
			}
			Vector3 point = ((RaycastHit)(ref terrainHit)).point;
			if (!(point.y <= num3 + 18f) && !(Vector3.Dot(((RaycastHit)(ref terrainHit)).normal, Vector3.up) < 0.72f) && !list.Any((Vector3 existing) => HorizontalDistance(existing, point) < 230f) && !source.Any((Vector3 existing) => HorizontalDistance(existing, point) < 85f))
			{
				Vector3 val2 = new Vector3(0f - point.x, 0f, 0f - point.z);
				Vector3 inward = ((Vector3)(ref val2)).normalized;
				if (((Vector3)(ref inward)).sqrMagnitude < 0.1f)
				{
					inward = Vector3.forward;
				}
				if (HasSafeEntranceProfile(point, inward, val, mask, num3))
				{
					GameObject val3 = new GameObject("Reforged Distant Cave Entrance " + (entrances.Count + 1));
					val3.transform.SetParent(root);
					val3.transform.position = point;
					BuildSurfaceArch(val3.transform, material);
					entrances.Add(val3.transform);
					list.Add(point);
				}
			}
		}
		if (entrances.Count < targetCount)
		{
			Plugin.Log.LogWarning((object)$"Only {entrances.Count}/{targetCount} safely separated cave entrances fit this island seed.");
		}
	}

	private static bool TryRaycastTerrain(Vector3 origin, MeshCollider terrainCollider, int mask, out RaycastHit terrainHit)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: 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_0066: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		terrainHit = default(RaycastHit);
		RaycastHit[] array = Physics.RaycastAll(origin, Vector3.down, 2400f, mask, (QueryTriggerInteraction)1);
		if (array == null || array.Length == 0)
		{
			return false;
		}
		Array.Sort(array, (RaycastHit left, RaycastHit right) => ((RaycastHit)(ref left)).distance.CompareTo(((RaycastHit)(ref right)).distance));
		RaycastHit[] array2 = array;
		for (int num = 0; num < array2.Length; num++)
		{
			RaycastHit val = array2[num];
			if (!((Object)(object)((RaycastHit)(ref val)).collider != (Object)(object)terrainCollider))
			{
				terrainHit = val;
				return true;
			}
		}
		return false;
	}

	private static bool HasSafeEntranceProfile(Vector3 point, Vector3 inward, MeshCollider terrainCollider, int mask, float waterY)
	{
		//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_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: 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)
		float[] array = new float[4] { 8f, 16f, 26f, 38f };
		foreach (float num in array)
		{
			if (!TryRaycastTerrain(point + inward * num + Vector3.up * 1200f, terrainCollider, mask, out var terrainHit))
			{
				return false;
			}
			if (((RaycastHit)(ref terrainHit)).point.y <= waterY + 10f || Vector3.Dot(((RaycastHit)(ref terrainHit)).normal, Vector3.up) < 0.52f)
			{
				return false;
			}
			if (!(num < 26f))
			{
				float num2 = point.y + 4.3f - Mathf.Max(0f, num - 1.5f) * 0.5095255f + 4.455033f;
				if (((RaycastHit)(ref terrainHit)).point.y < num2 + 0.9f)
				{
					return false;
				}
			}
		}
		return true;
	}

	private static void BuildSurfaceArch(Transform anchor, Material material)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: 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_0028: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0076: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: 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_0037: 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_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)
		//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0108: Unknown result type (might be due to invalid IL or missing references)
		//IL_011b: 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_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0133: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: 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_019e: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a3: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: 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_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_0207: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0224: Unknown result type (might be due to invalid IL or missing references)
		//IL_0229: Unknown result type (might be due to invalid IL or missing references)
		//IL_023d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0247: Unknown result type (might be due to invalid IL or missing references)
		//IL_0273: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ad: 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_02b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0303: Unknown result type (might be due to invalid IL or missing references)
		//IL_0304: Unknown result type (might be due to invalid IL or missing references)
		//IL_0314: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		//IL_031e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0322: Unknown result type (might be due to invalid IL or missing references)
		//IL_032c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0331: Unknown result type (might be due to invalid IL or missing references)
		//IL_0336: Unknown result type (might be due to invalid IL or missing references)
		//IL_0340: Unknown result type (might be due to invalid IL or missing references)
		//IL_0345: Unknown result type (might be due to invalid IL or missing references)
		//IL_034a: Unknown result type (might be due to invalid IL or missing references)
		//IL_035e: Unknown result type (might be due to invalid IL or missing references)
		//IL_036f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0374: Unknown result type (might be due to invalid IL or missing references)
		//IL_0390: Unknown result type (might be due to invalid IL or missing references)
		//IL_0395: Unknown result type (might be due to invalid IL or missing references)
		Vector3 position = anchor.position;
		Vector3 val = new Vector3(0f - position.x, 0f, 0f - position.z);
		Vector3 val2 = ((Vector3)(ref val)).normalized;
		if (((Vector3)(ref val2)).sqrMagnitude < 0.1f)
		{
			val2 = Vector3.forward;
		}
		Quaternion val3 = Quaternion.LookRotation(val2, Vector3.up);
		Vector3 val4 = val3 * Vector3.right;
		CreateOrientedBlock(anchor, "Entrance Walkable Apron", position + val2 * 4.2f + Vector3.down * 0.42f, new Vector3(8.4f, 0.55f, 11.5f), val3, material);
		int seed = StableHash(((Object)anchor).name) ^ GameManager.GetSeed();
		Vector3 scale = default(Vector3);
		for (int i = 0; i <= 10; i++)
		{
			float num = (float)i / 10f * (float)Math.PI;
			float num2 = Mathf.Cos(num);
			float num3 = Mathf.Sin(num);
			float num4 = Noise01(i, 4, seed) - 0.5f;
			Vector3 position2 = position + val4 * num2 * (6.1f + num4 * 0.7f) + Vector3.up * (0.9f + num3 * 6.3f) + val2 * (num4 * 0.9f);
			((Vector3)(ref scale))..ctor(3f + Noise01(i, 5, seed) * 1.4f, 3.1f + Noise01(i, 6, seed) * 1.5f, 3.5f + Noise01(i, 7, seed) * 1.8f);
			Quaternion rotation = val3 * Quaternion.Euler((float)i * 17f, (float)i * 31f, num2 * 18f);
			CreateLowPolyRock(anchor, "Entrance Rock " + i, position2, scale, rotation, material, collider: false);
		}
		Vector3 scale2 = default(Vector3);
		for (int j = -1; j <= 1; j += 2)
		{
			for (int k = 0; k < 3; k++)
			{
				float num5 = 2.8f + (float)k * 3.8f;
				Vector3 position3 = position + val2 * num5 + val4 * (float)j * (5.35f - (float)k * 0.22f) + Vector3.up * (0.35f - (float)k * 0.18f);
				((Vector3)(ref scale2))..ctor(3.4f + (float)k * 0.35f, 3f + (float)k * 0.25f, 4.8f);
				Quaternion rotation2 = val3 * Quaternion.Euler((float)j * (8f + (float)k * 3f), (float)j * (12f + (float)k * 9f), (float)j * (10f - (float)k * 2f));
				CreateLowPolyRock(anchor, $"Entrance Shoulder {j} {k}", position3, scale2, rotation2, material, collider: false);
			}
		}
		for (int l = -1; l <= 1; l += 2)
		{
			Vector3 position4 = position + val2 * (3.8f + (float)l * 0.35f) + val4 * (float)l * 4.35f + Vector3.up * 0.05f;
			CreateLowPolyRock(anchor, $"Entrance Ground Blend {l}", position4, new Vector3(2.6f, 1.65f, 6.4f), val3 * Quaternion.Euler((float)l * 7f, (float)l * 14f, (float)l * 5f), material, collider: false);
		}
	}

	private static void BuildSharedNetwork(Transform root, List<Transform> entrances, Material material, List<OreSlotCandidate> oreSlots)
	{
		//IL_0052: 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_0059: 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_006e: 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_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_00c5: 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_00ce: 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_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_00ec: 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_0153: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0163: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_024e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0257: Unknown result type (might be due to invalid IL or missing references)
		//IL_025e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0263: Unknown result type (might be due to invalid IL or missing references)
		//IL_026d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0272: Unknown result type (might be due to invalid IL or missing references)
		//IL_0277: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		//IL_0282: Unknown result type (might be due to invalid IL or missing references)
		//IL_0289: Unknown result type (might be due to invalid IL or missing references)
		//IL_028e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_029a: Unknown result type (might be due to invalid IL or missing references)
		//IL_029f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02af: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0303: Unknown result type (might be due to invalid IL or missing references)
		//IL_0305: Unknown result type (might be due to invalid IL or missing references)
		//IL_030c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0311: Unknown result type (might be due to invalid IL or missing references)
		//IL_031b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0320: 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_0360: Unknown result type (might be due to invalid IL or missing references)
		//IL_0362: Unknown result type (might be due to invalid IL or missing references)
		//IL_036c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0371: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04da: Unknown result type (might be due to invalid IL or missing references)
		//IL_04df: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_051d: Unknown result type (might be due to invalid IL or missing references)
		//IL_051f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0523: Unknown result type (might be due to invalid IL or missing references)
		//IL_0528: Unknown result type (might be due to invalid IL or missing references)
		//IL_052d: Unknown result type (might be due to invalid IL or missing references)
		//IL_052f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0533: Unknown result type (might be due to invalid IL or missing references)
		//IL_0538: Unknown result type (might be due to invalid IL or missing references)
		//IL_0573: Unknown result type (might be due to invalid IL or missing references)
		//IL_0578: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_05db: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_05eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0604: Unknown result type (might be due to invalid IL or missing references)
		//IL_0651: Unknown result type (might be due to invalid IL or missing references)
		//IL_0656: Unknown result type (might be due to invalid IL or missing references)
		//IL_065a: Unknown result type (might be due to invalid IL or missing references)
		//IL_065f: Unknown result type (might be due to invalid IL or missing references)
		//IL_066c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0671: Unknown result type (might be due to invalid IL or missing references)
		//IL_0675: Unknown result type (might be due to invalid IL or missing references)
		//IL_067a: Unknown result type (might be due to invalid IL or missing references)
		//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_06e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0716: Unknown result type (might be due to invalid IL or missing references)
		//IL_0723: Unknown result type (might be due to invalid IL or missing references)
		//IL_0735: Unknown result type (might be due to invalid IL or missing references)
		//IL_073f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0747: Unknown result type (might be due to invalid IL or missing references)
		//IL_0754: Unknown result type (might be due to invalid IL or missing references)
		//IL_0767: Unknown result type (might be due to invalid IL or missing references)
		//IL_0774: Unknown result type (might be due to invalid IL or missing references)
		//IL_077f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0951: Unknown result type (might be due to invalid IL or missing references)
		//IL_0969: Unknown result type (might be due to invalid IL or missing references)
		//IL_097f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0984: Unknown result type (might be due to invalid IL or missing references)
		//IL_0989: Unknown result type (might be due to invalid IL or missing references)
		//IL_09b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_09de: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a28: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a2d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a37: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a3c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a50: Unknown result type (might be due to invalid IL or missing references)
		//IL_07bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_07ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_07db: Unknown result type (might be due to invalid IL or missing references)
		//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_08e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0876: Unknown result type (might be due to invalid IL or missing references)
		//IL_087c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0889: Unknown result type (might be due to invalid IL or missing references)
		//IL_088e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0810: Unknown result type (might be due to invalid IL or missing references)
		//IL_081f: Unknown result type (might be due to invalid IL or missing references)
		//IL_082c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0831: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a07: Unknown result type (might be due to invalid IL or missing references)
		int num = GameManager.GetSeed() ^ 0x51A7C3;
		List<Vector3> endpoints = new List<Vector3>(entrances.Count);
		List<Vector3> list = new List<Vector3>(entrances.Count);
		List<Vector3> list2 = new List<Vector3>(entrances.Count);
		Vector3 val;
		for (int i = 0; i < entrances.Count; i++)
		{
			Vector3 position = entrances[i].position;
			val = new Vector3(0f - position.x, 0f, 0f - position.z);
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			if (((Vector3)(ref normalized)).sqrMagnitude < 0.1f)
			{
				float num2 = (float)i * (float)Math.PI * 2f / (float)Mathf.Max(1, entrances.Count);
				((Vector3)(ref normalized))..ctor(Mathf.Cos(num2), 0f, Mathf.Sin(num2));
			}
			Vector3 val2 = position + normalized * 1.5f + Vector3.up * 4.3f;
			float num3 = -94f + (Noise01(i, 71, num) - 0.5f) * 18f;
			float num4 = num3 - 3f;
			float num5 = Mathf.Clamp(Mathf.Abs(val2.y - num4) / Mathf.Tan(0.47123888f) + 24f + 17f, 245f, 500f);
			float num6 = num5;
			Vector3 originalEndpoint = new Vector3(position.x, num3, position.z) + normalized * (1.5f + num5);
			float num7 = ((endpoints.Count == 0) ? float.PositiveInfinity : endpoints.Min((Vector3 existing) => HorizontalDistance(existing, originalEndpoint)));
			if (num7 < 80f)
			{
				for (int num8 = -3; num8 <= 3; num8++)
				{
					float num9 = Mathf.Clamp(num5 + (float)num8 * 35f, 220f, 520f);
					Vector3 candidate = new Vector3(position.x, num3, position.z) + normalized * (1.5f + num9);
					float num10 = endpoints.Min((Vector3 existing) => HorizontalDistance(existing, candidate));
					if (!(num10 <= num7))
					{
						num7 = num10;
						num6 = num9;
					}
				}
			}
			Vector3 val3 = new Vector3(position.x, num3, position.z) + normalized * (1.5f + num6);
			Vector3 val4 = new Vector3(val3.x, num4, val3.z) - normalized * 17f;
			endpoints.Add(val3);
			list.Add(val2);
			list2.Add(val4);
			CreateAccessCorridor(root, "Surface Access Route " + (i + 1), val2, val4, 12f, 10f, material, oreSlots);
			CreateCaveLight(root, "Access Light " + (i + 1), Vector3.Lerp(val2, val4, 0.56f) + Vector3.up * 2.5f, new Color(0.92f, 0.55f, 0.27f), 52f, 0.75f);
			CreateCaveLight(root, "Junction Light " + (i + 1), val3 + Vector3.up * 2.5f, new Color(0.78f, 0.46f, 0.24f), 46f, 0.72f);
		}
		List<int[]> list3 = new List<int[]>();
		HashSet<int> visited = new HashSet<int>();
		int current = (int)((uint)num % (uint)Mathf.Max(1, endpoints.Count));
		visited.Add(current);
		while (visited.Count < endpoints.Count)
		{
			int num11 = (from index in Enumerable.Range(0, endpoints.Count)
				where !visited.Contains(index)
				select index).OrderBy(delegate(int index)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				Vector3 val7 = endpoints[index] - endpoints[current];
				return ((Vector3)(ref val7)).sqrMagnitude;
			}).First();
			list3.Add(new int[2] { current, num11 });
			visited.Add(num11);
			current = num11;
		}
		for (int num12 = 0; num12 < list3.Count; num12++)
		{
			Vector3 val5 = endpoints[list3[num12][0]];
			Vector3 val6 = endpoints[list3[num12][1]];
			val = val6 - val5;
			Vector3 normalized2 = ((Vector3)(ref val)).normalized;
			float num13 = Mathf.Min(17f, Vector3.Distance(val5, val6) * 0.28f);
			CreateCorridor(root, "Natural Backbone " + (num12 + 1), val5 + normalized2 * num13, val6 - normalized2 * num13, EdgeWidth(num12, num), 14.5f, material, oreSlots);
		}
		Vector3 cavern = SelectSharedCavernPosition(endpoints, -99f, num);
		List<int> list4 = Enumerable.Range(0, endpoints.Count).OrderBy(delegate(int index)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val7 = endpoints[index] - cavern;
			return ((Vector3)(ref val7)).sqrMagnitude;
		}).Take(Mathf.Min(3, endpoints.Count))
			.ToList();
		foreach (int item in list4)
		{
			val = endpoints[item] - cavern;
			Vector3 normalized3 = ((Vector3)(ref val)).normalized;
			float num14 = Vector3.Distance(cavern, endpoints[item]);
			float num15 = Mathf.Min(33f, num14 * 0.36f);
			float num16 = Mathf.Min(17f, num14 * 0.22f);
			CreateCorridor(root, "Cavern Branch " + (item + 1), cavern + normalized3 * num15, endpoints[item] - normalized3 * num16, 15f, 15f, material, oreSlots);
		}
		CreateCavernMesh(root, "Deep Shared Cavern", cavern, 35f, 18f, list4.Select((int index) => Opening(cavern, endpoints[index] - cavern, 15f, 15f)).ToList(), material);
		AddCavernOreProbes(oreSlots, cavern, 35f, 18f, num ^ 0x421D, 18);
		for (int num17 = 0; num17 < endpoints.Count; num17++)
		{
			List<CaveOpening> list5 = new List<CaveOpening> { Opening(new Vector3(endpoints[num17].x, list2[num17].y, endpoints[num17].z), new Vector3(list[num17].x - list2[num17].x, 0f, list[num17].z - list2[num17].z), 12f, 10f) };
			for (int num18 = 0; num18 < list3.Count; num18++)
			{
				int[] array = list3[num18];
				if (array[0] == num17)
				{
					list5.Add(Opening(endpoints[num17], endpoints[array[1]] - endpoints[num17], EdgeWidth(num18, num), 14.5f));
				}
				else if (array[1] == num17)
				{
					list5.Add(Opening(endpoints[num17], endpoints[array[0]] - endpoints[num17], EdgeWidth(num18, num), 14.5f));
				}
			}
			if (list4.Contains(num17))
			{
				list5.Add(Opening(endpoints[num17], cavern - endpoints[num17], 15f, 15f));
			}
			CreateCavernMesh(root, "Irregular Junction " + (num17 + 1), endpoints[num17], 19f, 16f, list5, material);
			AddCavernOreProbes(oreSlots, endpoints[num17], 19f, 16f, num ^ ((num17 + 1) * 7919), 6);
		}
		for (int num19 = 0; num19 < 8; num19++)
		{
			float num20 = (float)num19 * (float)Math.PI * 2f / 8f + Noise01(num19, 99, num) * 0.35f;
			Vector3 position2 = cavern + new Vector3(Mathf.Cos(num20), 0f, Mathf.Sin(num20)) * (18f + (float)(num19 % 3) * 3f);
			position2.y -= 3.5f;
			CreateLowPolyRock(root, "Natural Cavern Pillar " + (num19 + 1), position2, new Vector3(3.2f + (float)(num19 % 2), 8f + (float)(num19 % 3) * 1.6f, 3.5f + (float)((num19 + 1) % 2)), Quaternion.Euler((float)num19 * 13f, (float)num19 * 41f, (num19 % 2 == 0) ? (-5f) : 5f), material);
		}
		CreateCaveLight(root, "Deep Cavern Light", cavern + Vector3.up * 3.5f, new Color(0.94f, 0.48f, 0.21f), 88f, 1.05f);
	}

	private static void AddCavernOreProbes(List<OreSlotCandidate> slots, Vector3 center, float radius, float height, int seed, int count)
	{
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: 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_0081: 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_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_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_00dd: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		float num = Noise01(0, 318, seed) * (float)Math.PI * 2f;
		Vector3 val = default(Vector3);
		for (int i = 0; i < count; i++)
		{
			float num2 = num + (float)i * 2.3999631f;
			((Vector3)(ref val))..ctor(Mathf.Cos(num2), 0f, Mathf.Sin(num2));
			float num3 = (Noise01(i, 319, seed) - 0.5f) * height * 0.42f;
			AddOreProbe(slots, center + val * (radius * 0.62f) + Vector3.up * num3, val, CaveSurfaceKind.Wall);
			if ((i & 1) == 0)
			{
				AddOreProbe(slots, center + val * (radius * 0.52f) - Vector3.up * (height * 0.2f), Vector3.down, CaveSurfaceKind.Floor);
			}
			else
			{
				AddOreProbe(slots, center + val * (radius * 0.38f) + Vector3.up * (height * 0.2f), Vector3.up, CaveSurfaceKind.Ceiling);
			}
		}
	}

	private static Vector3 SelectSharedCavernPosition(List<Vector3> endpoints, float y, int seed)
	{
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0140: 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_0124: Unknown result type (might be due to invalid IL or missing references)
		Vector3 average = endpoints.Aggregate(Vector3.zero, (Vector3 sum, Vector3 point) => sum + point) / (float)Mathf.Max(1, endpoints.Count);
		average.y = y;
		Vector3 result = average;
		float num = ((endpoints.Count == 0) ? float.PositiveInfinity : endpoints.Min((Vector3 point) => HorizontalDistance(point, average)));
		float num2 = Noise01(11, 91, seed) * (float)Math.PI * 2f;
		for (int num3 = 0; num3 < 18; num3++)
		{
			float num4 = num2 + (float)num3 * 2.3999631f;
			float num5 = 105f + (float)(num3 % 4) * 28f;
			Vector3 candidate = average + new Vector3(Mathf.Cos(num4), 0f, Mathf.Sin(num4)) * num5;
			float num6 = ((endpoints.Count == 0) ? float.PositiveInfinity : endpoints.Min((Vector3 point) => HorizontalDistance(point, candidate)));
			if (num6 > num)
			{
				result = candidate;
				num = num6;
			}
			if (num6 >= 88f)
			{
				break;
			}
		}
		return result;
	}

	private static float EdgeWidth(int edgeIndex, int networkSeed)
	{
		return 13.5f + Noise01(edgeIndex, 80, networkSeed) * 2f;
	}

	private static CaveOpening Opening(Vector3 origin, Vector3 direction, float width, float height)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		return new CaveOpening
		{
			AxisOrigin = origin,
			Direction = ((((Vector3)(ref direction)).sqrMagnitude > 0.001f) ? ((Vector3)(ref direction)).normalized : Vector3.forward),
			Width = width,
			Height = height
		};
	}

	private static void CreateAccessCorridor(Transform root, string name, Vector3 start, Vector3 end, float width, float height, Material material, List<OreSlotCandidate> oreSlots)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: Unknown result type (might be due to invalid IL or missing references)
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_0106: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: 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_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_011c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0126: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(end.x - start.x, 0f, end.z - start.z);
		float magnitude = ((Vector3)(ref val)).magnitude;
		if (magnitude < 4f)
		{
			CreateCorridor(root, name, start, end, width, height, material, oreSlots);
			return;
		}
		Vector3 val2 = val / magnitude;
		float num = Mathf.Min(48f, magnitude * 0.28f);
		float num2 = (start.y - end.y) / Mathf.Max(1f, magnitude - num * 0.5f);
		int num3 = Mathf.Max(3, Mathf.CeilToInt(magnitude / 7f) + 1);
		Vector3[] array = (Vector3[])(object)new Vector3[num3];
		for (int i = 0; i < num3; i++)
		{
			float num4 = magnitude * (float)i / ((float)num3 - 1f);
			float num5;
			if (num4 <= magnitude - num)
			{
				num5 = start.y - num2 * num4;
			}
			else
			{
				float num6 = (num4 - (magnitude - num)) / num;
				num5 = start.y - num2 * (magnitude - num) - num2 * num * (num6 - num6 * num6 * 0.5f);
			}
			array[i] = new Vector3(start.x, num5, start.z) + val2 * num4;
		}
		array[0] = start;
		array[^1] = end;
		CreateCurvedTunnelMesh(root, name, array, width, height, material, oreSlots);
	}

	private static void CreateCurvedTunnelMesh(Transform root, string name, Vector3[] centers, float width, float height, Material material, List<OreSlotCandidate> oreSlots)
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00af: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: 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_0091: 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_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d0: 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_0195: 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_01a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0301: Unknown result type (might be due to invalid IL or missing references)
		//IL_0306: Unknown result type (might be due to invalid IL or missing references)
		//IL_030b: Unknown result type (might be due to invalid IL or missing references)
		//IL_030f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0314: Unknown result type (might be due to invalid IL or missing references)
		//IL_0319: Unknown result type (might be due to invalid IL or missing references)
		//IL_031e: Unknown result type (might be due to invalid IL or missing references)
		//IL_031f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0324: Unknown result type (might be due to invalid IL or missing references)
		//IL_0329: 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_0330: Unknown result type (might be due to invalid IL or missing references)
		//IL_0335: Unknown result type (might be due to invalid IL or missing references)
		//IL_0408: Unknown result type (might be due to invalid IL or missing references)
		//IL_040d: Unknown result type (might be due to invalid IL or missing references)
		//IL_042a: Unknown result type (might be due to invalid IL or missing references)
		//IL_042f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0434: Unknown result type (might be due to invalid IL or missing references)
		//IL_043e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0443: Unknown result type (might be due to invalid IL or missing references)
		//IL_0448: Unknown result type (might be due to invalid IL or missing references)
		//IL_0356: Unknown result type (might be due to invalid IL or missing references)
		//IL_035b: Unknown result type (might be due to invalid IL or missing references)
		//IL_035f: Unknown result type (might be due to invalid IL or missing references)
		//IL_036b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0370: Unknown result type (might be due to invalid IL or missing references)
		//IL_0375: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Unknown result type (might be due to invalid IL or missing references)
		//IL_038a: Unknown result type (might be due to invalid IL or missing references)
		//IL_038f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0391: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_03da: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
		if (centers == null || centers.Length < 2)
		{
			return;
		}
		int num = centers.Length;
		int seed = StableHash(name);
		Vector3[] array = (Vector3[])(object)new Vector3[num * 16];
		Vector2[] array2 = (Vector2[])(object)new Vector2[array.Length];
		int[] array3 = new int[(num - 1) * 16 * 6];
		float num2 = 0f;
		for (int i = 0; i < num; i++)
		{
			if (i > 0)
			{
				num2 += Vector3.Distance(centers[i - 1], centers[i]);
			}
			Vector3 val = ((i == 0) ? (centers[1] - centers[0]) : ((i == num - 1) ? (centers[num - 1] - centers[num - 2]) : (centers[i + 1] - centers[i - 1])));
			Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
			Vector3 val3 = val2 * Vector3.right;
			Vector3 val4 = val2 * Vector3.up;
			float num3 = Mathf.Sin((float)i / ((float)num - 1f) * (float)Math.PI);
			for (int j = 0; j < 16; j++)
			{
				float num4 = (float)j * (float)Math.PI * 2f / 16f;
				float num5 = 0.82f + Noise01(i, j, seed) * 0.32f;
				float num6 = Mathf.Lerp(1f, num5, num3);
				float num7 = Mathf.Cos(num4) * width * 0.5f * num6;
				float num8 = Mathf.Sin(num4) * height * 0.5f * num6;
				if (j >= 10 && j <= 14)
				{
					num8 = (0f - height) * 0.5f;
				}
				int num9 = i * 16 + j;
				array[num9] = centers[i] + val3 * num7 + val4 * num8;
				array2[num9] = new Vector2((float)j / 16f * 7f, num2 / 8f);
			}
		}
		int num10 = 0;
		for (int k = 0; k < num - 1; k++)
		{
			for (int l = 0; l < 16; l++)
			{
				int num11 = (l + 1) % 16;
				int num12 = k * 16 + l;
				int num13 = k * 16 + num11;
				int num14 = (k + 1) * 16 + l;
				int num15 = (k + 1) * 16 + num11;
				array3[num10++] = num12;
				array3[num10++] = num15;
				array3[num10++] = num13;
				array3[num10++] = num12;
				array3[num10++] = num14;
				array3[num10++] = num15;
			}
		}
		CreateCaveMeshObject(root, name + " Terrain Tunnel", array, array2, array3, material);
		for (int m = 0; m < num - 1; m++)
		{
			AddCorridorVolume(centers[m], centers[m + 1], width, height);
		}
		for (int n = 2; n < num - 2; n++)
		{
			Vector3 val5 = centers[n + 1] - centers[n - 1];
			Quaternion val6 = Quaternion.LookRotation(((Vector3)(ref val5)).normalized, Vector3.up);
			Vector3 val7 = val6 * Vector3.right;
			Vector3 val8 = val6 * Vector3.up;
			if ((n & 1) == 0)
			{
				float num16 = (((n & 2) == 0) ? (-1f) : 1f);
				AddOreProbe(oreSlots, centers[n] + val7 * num16 * (width * 0.31f) - val8 * (height * 0.5f - 1.1f), -val8, CaveSurfaceKind.Floor);
			}
			if (n % 3 == 0)
			{
				float num17 = (((n & 1) == 0) ? (-1f) : 1f);
				AddOreProbe(oreSlots, centers[n] + val7 * num17 * (width * 0.18f) - val8 * (height * 0.04f), val7 * num17, CaveSurfaceKind.Wall);
			}
			if (n % 5 == 0)
			{
				AddOreProbe(oreSlots, centers[n] + val7 * ((Noise01(n, 312, seed) - 0.5f) * width * 0.22f) + val8 * (height * 0.16f), val8, CaveSurfaceKind.Ceiling);
			}
		}
	}

	private static void AddCorridorVolume(Vector3 start, Vector3 end, float width, float height)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: 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_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//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_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = end - start;
		float magnitude = ((Vector3)(ref val)).magnitude;
		if (!(magnitude < 0.01f))
		{
			Volumes.Add(new CaveVolume
			{
				Center = (start + end) * 0.5f,
				Rotation = Quaternion.LookRotation(val / magnitude, Vector3.up),
				HalfExtents = new Vector3(width * 0.68f, height * 0.72f, (magnitude + 3f) * 0.5f)
			});
			CaveVolume caveVolume = Volumes[Volumes.Count - 1];
			caveVolume.InverseRotation = Quaternion.Inverse(caveVolume.Rotation);
		}
	}

	private static void RebuildVolumeIndex()
	{
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0054: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: 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_00cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0169: Unknown result type (might be due to invalid IL or missing references)
		//IL_0181: Unknown result type (might be due to invalid IL or missing references)
		VolumeCells.Clear();
		Vector2Int key = default(Vector2Int);
		foreach (CaveVolume volume in Volumes)
		{
			Vector3 val = volume.Rotation * Vector3.right;
			Vector3 val2 = volume.Rotation * Vector3.up;
			Vector3 val3 = volume.Rotation * Vector3.forward;
			float num = Mathf.Abs(val.x) * volume.HalfExtents.x + Mathf.Abs(val2.x) * volume.HalfExtents.y + Mathf.Abs(val3.x) * volume.HalfExtents.z;
			float num2 = Mathf.Abs(val.z) * volume.HalfExtents.x + Mathf.Abs(val2.z) * volume.HalfExtents.y + Mathf.Abs(val3.z) * volume.HalfExtents.z;
			int num3 = Mathf.FloorToInt((volume.Center.x - num) / 64f);
			int num4 = Mathf.FloorToInt((volume.Center.x + num) / 64f);
			int num5 = Mathf.FloorToInt((volume.Center.z - num2) / 64f);
			int num6 = Mathf.FloorToInt((volume.Center.z + num2) / 64f);
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num5; j <= num6; j++)
				{
					((Vector2Int)(ref key))..ctor(i, j);
					if (!VolumeCells.TryGetValue(key, out var value))
					{
						value = new List<CaveVolume>(4);
						VolumeCells.Add(key, value);
					}
					value.Add(volume);
				}
			}
		}
		cachedInsideFrame = -1;
		Plugin.Log.LogInfo((object)$"Indexed {Volumes.Count} cave volumes into {VolumeCells.Count} spatial cells.");
	}

	private static void CreateCorridor(Transform root, string name, Vector3 start, Vector3 end, float width, float height, Material material, List<OreSlotCandidate> oreSlots, bool addOreSlots = true)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: 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_0022: 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_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: 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_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: 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_00ca: 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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: 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_0112: Unknown result type (might be due to invalid IL or missing references)
		//IL_0115: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: 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_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_013b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0185: 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_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)
		Vector3 val = end - start;
		float magnitude = ((Vector3)(ref val)).magnitude;
		if (magnitude < 4f)
		{
			return;
		}
		Vector3 val2 = val / magnitude;
		Quaternion val3 = Quaternion.LookRotation(val2, Vector3.up);
		Vector3 val4 = val3 * Vector3.right;
		Vector3 val5 = val3 * Vector3.up;
		AddCorridorVolume(start - val2 * 4.5f, end + val2 * 4.5f, width, height);
		CreateTunnelMesh(root, name, start, end, width, height, material);
		if (!addOreSlots)
		{
			return;
		}
		int num = 0;
		float num2 = 10f;
		while (num2 <= magnitude - 10f)
		{
			float num3 = (((Mathf.RoundToInt(num2 / 7.5f) & 1) == 0) ? (-1f) : 1f);
			Vector3 val6 = start + val2 * num2;
			AddOreProbe(oreSlots, val6 + val4 * num3 * (width * 0.31f) - val5 * (height * 0.5f - 1.1f), -val5, CaveSurfaceKind.Floor);
			if ((num & 1) == 0)
			{
				AddOreProbe(oreSlots, val6 + val4 * num3 * (width * 0.18f) - val5 * (height * 0.04f), val4 * num3, CaveSurfaceKind.Wall);
			}
			if (num % 3 == 1)
			{
				AddOreProbe(oreSlots, val6 + val4 * ((Noise01(num, 313, StableHash(name)) - 0.5f) * width * 0.22f) + val5 * (height * 0.16f), val5, CaveSurfaceKind.Ceiling);
			}
			num2 += 7.5f;
			num++;
		}
	}

	private static void AddOreProbe(List<OreSlotCandidate> slots, Vector3 origin, Vector3 direction, CaveSurfaceKind kind)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: 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)
		if (!(((Vector3)(ref direction)).sqrMagnitude < 0.01f))
		{
			slots.Add(new OreSlotCandidate
			{
				Origin = origin,
				Direction = ((Vector3)(ref direction)).normalized,
				Kind = kind
			});
		}
	}

	private static void CreateTunnelMesh(Transform root, string name, Vector3 start, Vector3 end, float width, float height, Material material, bool addDecorations = true, bool addCollider = true)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: 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_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_00aa: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_0107: Unknown result type (might be due to invalid IL or missing references)
		//IL_010c: Unknown result type (might be due to invalid IL or missing references)
		//IL_010e: 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_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0136: Unknown result type (might be due to invalid IL or missing references)
		//IL_0140: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0200: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_0235: Unknown result type (might be due to invalid IL or missing references)
		//IL_0362: Unknown result type (might be due to invalid IL or missing references)
		//IL_0363: Unknown result type (might be due to invalid IL or missing references)
		//IL_0366: Unknown result type (might be due to invalid IL or missing references)
		//IL_036b: Unknown result type (might be due to invalid IL or missing references)
		//IL_036f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0376: Unknown result type (might be due to invalid IL or missing references)
		//IL_0380: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Unknown result type (might be due to invalid IL or missing references)
		//IL_038a: Unknown result type (might be due to invalid IL or missing references)
		//IL_039a: Unknown result type (might be due to invalid IL or missing references)
		//IL_039f: Unknown result type (might be due to invalid IL or missing references)
		//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e5: 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_0406: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = end - start;
		float magnitude = ((Vector3)(ref val)).magnitude;
		int num = Mathf.Max(2, Mathf.CeilToInt(magnitude / 7f) + 1);
		Quaternion val2 = Quaternion.LookRotation(((Vector3)(ref val)).normalized, Vector3.up);
		Vector3 val3 = val2 * Vector3.right;
		Vector3 val4 = val2 * Vector3.up;
		int num2 = StableHash(name);
		Vector3[] array = (Vector3[])(object)new Vector3[num * 16];
		Vector2[] array2 = (Vector2[])(object)new Vector2[array.Length];
		int[] array3 = new int[(num - 1) * 16 * 6];
		for (int i = 0; i < num; i++)
		{
			float num3 = (float)i / (float)(num - 1);
			Vector3 val5 = Vector3.Lerp(start, end, num3);
			float num4 = Mathf.Sin(num3 * (float)Math.PI);
			val5 += val3 * (Mathf.Sin(num3 * (float)Math.PI * 3f + (float)num2 * 0.013f) * width * 0.16f + Mathf.Sin(num3 * (float)Math.PI * 7f + (float)num2 * 0.004f) * width * 0.045f) * num4;
			val5 += val4 * Mathf.Sin(num3 * (float)Math.PI * 4f + (float)num2 * 0.007f) * height * 0.075f * num4;
			for (int j = 0; j < 16; j++)
			{
				float num5 = (float)j * (float)Math.PI * 2f / 16f;
				float num6 = 0.82f + Noise01(i, j, num2) * 0.32f;
				float num7 = Mathf.Lerp(1f, num6, Mathf.Sin(num3 * (float)Math.PI));
				float num8 = Mathf.Cos(num5) * width * 0.5f * num7;
				float num9 = Mathf.Sin(num5) * height * 0.5f * num7;
				if (j >= 10 && j <= 14)
				{
					num9 = (0f - height) * 0.5f;
				}
				int num10 = i * 16 + j;
				array[num10] = val5 + val3 * num8 + val4 * num9;
				array2[num10] = new Vector2((float)j / 16f * 7f, num3 * magnitude / 8f);
			}
		}
		int num11 = 0;
		for (int k = 0; k < num - 1; k++)
		{
			for (int l = 0; l < 16; l++)
			{
				int num12 = (l + 1) % 16;
				int num13 = k * 16 + l;
				int num14 = k * 16 + num12;
				int num15 = (k + 1) * 16 + l;
				int num16 = (k + 1) * 16 + num12;
				array3[num11++] = num13;
				array3[num11++] = num16;
				array3[num11++] = num14;
				array3[num11++] = num13;
				array3[num11++] = num15;
				array3[num11++] = num16;
			}
		}
		CreateCaveMeshObject(root, name + " Terrain Tunnel", array, array2, array3, material, addCollider);
		if (addDecorations)
		{
			int num17 = Mathf.Clamp(Mathf.FloorToInt(magnitude / 55f), 1, 6);
			for (int m = 1; m <= num17; m++)
			{
				float num18 = (float)m / (float)(num17 + 1);
				float num19 = (((m & 1) == 0) ? (-1f) : 1f);
				Vector3 position = Vector3.Lerp(start, end, num18) + val3 * num19 * width * 0.37f - val4 * (height * 0.5f - 1.4f);
				float num20 = 1.7f + Noise01(m, 17, num2) * 1.6f;
				CreateLowPolyRock(root, name + " Wall Rock " + m, position, new Vector3(num20 * 1.3f, num20, num20), val2 * Quaternion.Euler((float)m * 19f, (float)m * 41f, (float)m * 13f), material, collider: false);
			}
		}
	}

	private static void CreateCavernMesh(Transform root, string name, Vector3 center, float radius, float height, List<CaveOpening> exits, Material material)
	{
		//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_0123: 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_013a: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_016d: Unknown result type (might be due to invalid IL or missing references)
		//IL_016e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Unknown result type (might be due to invalid IL or missing references)
		//IL_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_017c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: 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_01ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_0205: Unknown result type (might be due to invalid IL or missing references)
		//IL_0209: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_021a: Unknown result type (might be due to invalid IL or missing references)
		//IL_021f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0242: Unknown result type (might be due to invalid IL or missing references)
		//IL_0266: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_0279: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_0317: Unknown result type (might be due to invalid IL or missing references)
		//IL_031c: 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_03c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
		//IL_050b: Unknown result type (might be due to invalid IL or missing references)
		//IL_050c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0512: Unknown result type (might be due to invalid IL or missing references)
		//IL_0517: Unknown result type (might be due to invalid IL or missing references)
		//IL_051d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0522: Unknown result type (might be due to invalid IL or missing references)
		//IL_0548: Unknown result type (might be due to invalid IL or missing references)
		//IL_054d: 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_05b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
		int seed = StableHash(name);
		CaveOpening[] array = (exits ?? new List<CaveOpening>()).Where((CaveOpening value) => value != null && ((Vector3)(ref value.Direction)).sqrMagnitude > 0.1f && value.Width > 0f && value.Height > 0f).ToArray();
		float num = Mathf.Max(4f, radius - 5f);
		List<Vector3> list = new List<Vector3>(258);
		List<Vector2> list2 = new List<Vector2>(258);
		Vector3 val = default(Vector3);
		for (int num2 = 0; num2 < 64; num2++)
		{
			float num3 = (float)num2 * (float)Math.PI * 2f / 64f;
			((Vector3)(ref val))..ctor(Mathf.Cos(num3), 0f, Mathf.Sin(num3));
			float num4 = radius * (0.92f + Noise01(0, num2, seed) * 0.15f);
			float num5 = num * (0.97f + Noise01(2, num2, seed) * 0.06f);
			float num6 = height * (0.46f + Noise01(1, num2, seed) * 0.07f);
			float num7 = height * (0.465f + Noise01(3, num2, seed) * 0.035f);
			list.Add(center + val * num5 + Vector3.down * (height * 0.5f));
			list2.Add(new Vector2((float)num2 / 64f * 9f, num / 8f));
			list.Add(center + val * num5 + Vector3.up * num7);
			list2.Add(new Vector2((float)num2 / 64f * 9f, height / 7f));
			list.Add(center + val * num4 + Vector3.down * (height * 0.5f));
			list2.Add(new Vector2((float)num2 / 64f * 9f, 0f));
			list.Add(center + val * num4 + Vector3.up * num6);
			list2.Add(new Vector2((float)num2 / 64f * 9f, height / 7f));
		}
		int count = list.Count;
		list.Add(center + Vector3.down * (height * 0.5f));
		list2.Add(new Vector2(0.5f, 0.5f));
		int count2 = list.Count;
		Vector3 val2 = default(Vector3);
		((Vector3)(ref val2))..ctor((Noise01(7, 201, seed) - 0.5f) * radius * 0.14f, 0f, (Noise01(8, 202, seed) - 0.5f) * radius * 0.14f);
		list.Add(center + val2 + Vector3.up * (height * (0.68f + Noise01(9, 203, seed) * 0.08f)));
		list2.Add(new Vector2(0.5f, 0.5f));
		List<int> list3 = new List<int>(1536);
		for (int num8 = 0; num8 < 64; num8++)
		{
			int num9 = (num8 + 1) % 64;
			int num10 = num8 * 4;
			int item = num10 + 1;
			int num11 = num10 + 2;
			int num12 = num10 + 3;
			int num13 = num9 * 4;
			int item2 = num13 + 1;
			int num14 = num13 + 2;
			int num15 = num13 + 3;
			float num16 = ((float)num8 + 0.5f) * (float)Math.PI * 2f / 64f;
			Vector3 radial = new Vector3(Mathf.Cos(num16), 0f, Mathf.Sin(num16));
			bool num17 = array.Any((CaveOpening exit) => IsOpeningSector(radial, exit, radius));
			list3.Add(count);
			list3.Add(num13);
			list3.Add(num10);
			list3.Add(count2);
			list3.Add(item);
			list3.Add(item2);
			if (num17)
			{
				CaveOpening[] openings = array.Where((CaveOpening exit) => IsOpeningSector(radial, exit, radius)).ToArray();
				AddOpeningWallBands(list, list2, list3, num11, num12, num14, num15, openings);
				continue;
			}
			list3.Add(num10);
			list3.Add(num14);
			list3.Add(num11);
			list3.Add(num10);
			list3.Add(num13);
			list3.Add(num14);
			list3.Add(item);
			list3.Add(num12);
			list3.Add(num15);
			list3.Add(item);
			list3.Add(num15);
			list3.Add(item2);
			list3.Add(num11);
			list3.Add(num15);
			list3.Add(num12);
			list3.Add(num11);
			list3.Add(num14);
			list3.Add(num15);
		}
		Volumes.Add(new CaveVolume
		{
			Center = center,
			Rotation = Quaternion.identity,
			InverseRotation = Quaternion.identity,
			HalfExtents = new Vector3(radius + 1.5f, height * 0.82f, radius + 1.5f)
		});
		CreateCaveMeshObject(root, name + " Terrain Chamber", list.ToArray(), list2.ToArray(), list3.ToArray(), material);
		CaveOpening[] array2 = array;
		foreach (CaveOpening caveOpening in array2)
		{
			Vector3 val3 = new Vector3(caveOpening.Direction.x, 0f, caveOpening.Direction.z);
			Vector3 normalized = ((Vector3)(ref val3)).normalized;
			CreateOpeningSeamLiner(root, name, center, num, radius, caveOpening, material);
			CreateNaturalOpeningBlend(root, name, center, radius, height, caveOpening.Width, normalized, material);
			CreateCaveOpeningCollar(root, name, center, radius, height, caveOpening.Width, normalized, material);
		}
	}

	private static void AddOpeningWallBands(List<Vector3> vertices, List<Vector2> uvs, List<int> triangles, int leftBottom, int leftTop, int rightBottom, int rightTop, CaveOpening[] openings)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_0052: 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_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: 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_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0073: 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_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: 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_00c8: 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_00d8: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0101: Unknown result type (might be due to invalid IL or missing references)
		//IL_0113: 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)
		Vector3 val = vertices[leftBottom];
		Vector3 val2 = vertices[leftTop];
		Vector3 val3 = vertices[rightBottom];
		Vector3 val4 = vertices[rightTop];
		for (int i = 0; i < 8; i++)
		{
			float num = (float)i / 8f;
			float num2 = ((float)i + 1f) / 8f;
			Vector3 val5 = Vector3.Lerp(val, val2, num);
			Vector3 val6 = Vector3.Lerp(val3, val4, num);
			Vector3 val7 = Vector3.Lerp(val, val2, num2);
			Vector3 val8 = Vector3.Lerp(val3, val4, num2);
			float middleY = (val5.y + val6.y + val7.y + val8.y) * 0.25f;
			if (!openings.Any((CaveOpening opening) => middleY >= opening.AxisOrigin.y - opening.Height * 0.54f && middleY <= opening.AxisOrigin.y + opening.Height * 0.54f))
			{
				int count = vertices.Count;
				vertices.Add(val5);
				vertices.Add(val6);
				vertices.Add(val7);
				vertices.Add(val8);
				uvs.Add(new Vector2(num, 0f));
				uvs.Add(new Vector2(num, 1f));
				uvs.Add(new Vector2(num2, 0f));
				uvs.Add(new Vector2(num2, 1f));
				triangles.Add(count);
				triangles.Add(count + 3);
				triangles.Add(count + 2);
				triangles.Add(count);
				triangles.Add(count + 1);
				triangles.Add(count + 3);
			}
		}
	}

	private static void CreateOpeningSeamLiner(Transform root, string chamberName, Vector3 center, float innerRadius, float radius, CaveOpening opening, Material material)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Unknown result type (might be due to invalid IL or missing references)
		//IL_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f4: 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_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)
		Vector3 normalized = ((Vector3)(ref opening.Direction)).normalized;
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(normalized.x, 0f, normalized.z);
		float magnitude = ((Vector3)(ref val)).magnitude;
		if (!(magnitude < 0.1f))
		{
			float num = Mathf.Max(0f, innerRadius - 2.5f) / magnitude;
			float num2 = (radius + 4f) / magnitude;
			Vector3 val2 = opening.AxisOrigin;
			Vector3 val3 = val2 - center;
			if (((Vector3)(ref val3)).sqrMagnitude > radius * radius * 0.45f)
			{
				val2 = center;
			}
			CreateTunnelMesh(root, chamberName + " Opening Seam Liner " + StableHash(((object)Unsafe.As<Vector3, Vector3>(ref opening.Direction)/*cast due to .constrained prefix*/).ToString()), val2 + normalized * num, val2 + normalized * num2, opening.Width * 1.14f + 1f, opening.Height + 1f, material, addDecorations: false, addCollider: false);
			CreateOpeningFloorBridge(root, chamberName, val2, normalized, opening.Width, opening.Height, num, num2);
		}
	}

	private unsafe static void CreateOpeningFloorBridge(Transform root, string chamberName, Vector3 axisOrigin, Vector3 direction, float width, float height, float startDistance, float endDistance)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		//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_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0081: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: 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)
		Quaternion val = Quaternion.LookRotation(direction, Vector3.up);
		Vector3 val2 = val * Vector3.up;
		GameObject val3 = new GameObject(chamberName + " Opening Floor Bridge " + StableHash(((object)(*(Vector3*)(&direction))/*cast due to .constrained prefix*/).ToString()));
		val3.transform.SetParent(root);
		val3.transform.position = axisOrigin + direction * ((startDistance + endDistance) * 0.5f) - val2 * (height * 0.5f + 0.12f);
		val3.transform.rotation = val;
		int num = LayerMask.NameToLayer("Ground");
		if (num >= 0)
		{
			val3.layer = num;
		}
		val3.AddComponent<BoxCollider>().size = new Vector3(width * 0.74f, 0.36f, endDistance - startDistance + 1.5f);
	}

	private static bool IsOpeningSector(Vector3 radial, CaveOpening opening, float apertureRadius)
	{
		//IL_0068: 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)
		Vector3 val = default(Vector3);
		((Vector3)(ref val))..ctor(opening.Direction.x, 0f, opening.Direction.z);
		if (((Vector3)(ref val)).sqrMagnitude < 0.01f)
		{
			return false;
		}
		((Vector3)(ref val)).Normalize();
		float num = Mathf.Asin(Mathf.Clamp((opening.Width * 0.56f + 0.4f) / apertureRadius, 0.08f, 0.94f)) * 57.29578f;
		return Vector3.Angle(radial, val) <= num;
	}

	private unsafe static void CreateNaturalOpeningBlend(Transform root, string chamberName, Vector3 center, float radius, float height, float exitWidth, Vector3 direction, Material material)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: 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_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: 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_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00de: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0177: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_017b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = Vector3.Cross(Vector3.up, direction);
		Vector3 normalized = ((Vector3)(ref val)).normalized;
		Quaternion val2 = Quaternion.LookRotation(direction, Vector3.up);
		val = direction;
		int seed = StableHash(chamberName + ((object)(*(Vector3*)(&val))/*cast due to .constrained prefix*/).ToString());
		Vector3 scale = default(Vector3);
		for (int i = 0; i < 4; i++)
		{
			float num = ((i < 2) ? (-1f) : 1f);
			float num2 = num * (exitWidth * (0.48f + Noise01(i, 131, seed) * 0.18f));
			float num3 = ((i % 2 == 0) ? ((0f - height) * 0.27f) : (height * (0.25f + Noise01(i, 132, seed) * 0.12f)));
			Vector3 position = center + direction * (radius - 1.2f + Noise01(i, 133, seed) * 2.5f) + normalized * num2 + Vector3.up * num3;
			((Vector3)(ref scale))..ctor(2.2f + Noise01(i, 134, seed) * 2.5f, 2.5f + Noise01(i, 135, seed) * 3.4f, 3f + Noise01(i, 136, seed) * 2.7f);
			CreateLowPolyRock(root, chamberName + " Natural Opening Blend " + i + " " + seed, position, scale, val2 * Quaternion.Euler((Noise01(i, 137, seed) - 0.5f) * 26f, (Noise01(i, 138, seed) - 0.5f) * 34f, num * (7f + Noise01(i, 139, seed) * 15f)), material, collider: false);
		}
	}

	private unsafe static void CreateCaveOpeningCollar(Transform root, string chamberName, Vector3 center, float radius, float height, float exitWidth, Vector3 direction, Material material)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//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_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: 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_0058: 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_0063: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: 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_00dc: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_018b: Unknown result type (might be due to invalid IL or missing references)
		//IL_018c: 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_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_01a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01be: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		Vector3 val = Vector3.Cross(Vector3.up, direction);
		Vector3 normalized = ((Vector3)(ref val)).normalized;
		Quaternion val2 = Quaternion.LookRotation(direction, Vector3.up);
		Vector3 val3 = center + direction * (radius * 0.96f);
		float num = exitWidth * 0.56f;
		float num2 = height * 0.62f;
		for (int i = -1; i <= 1; i += 2)
		{
			Vector3 position = val3 + normalized * (float)i * num + Vector3.down * (height * 0.17f);
			CreateLowPolyRock(root, chamberName + " Opening Side " + i + " " + StableHash(((object)(*(Vector3*)(&direction))/*cast due to .constrained prefix*/).ToString()), position, new Vector3(3.2f, num2, 4.6f), val2 * Quaternion.Euler((float)i * 4f, (float)i * 8f, (float)i * 3f), material, collider: false);
		}
		for (int j = -1; j <= 1; j++)
		{
			float num3 = (float)j * exitWidth * 0.34f;
			float num4 = height * ((j == 0) ? 0.43f : 0.35f);
			CreateLowPolyRock(root, chamberName + " Opening Crown " + j + " " + StableHash(((object)(*(Vector3*)(&direction))/*cast due to .constrained prefix*/).ToString()), val3 + normalized * num3 + Vector3.up * num4, new Vector3(4.4f, 3.4f, 4.5f), val2 * Quaternion.Euler((float)j * 5f, (float)j * 9f, (float)j * 8f), material, collider: false);
		}
	}

	private static void CreateCaveMeshObject(Transform root, string name, Vector3[] vertices, Vector2[] uvs, int[] triangles, Material material, bool addCollider = true)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0017: Expected O, but got Unknown
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Expected O, but got Unknown
		Mesh val = new Mesh
		{
			name = name + " Mesh"
		};
		val.vertices = vertices;
		val.uv = uvs;
		val.triangles = triangles;
		val.RecalculateNormals();
		val.RecalculateBounds();
		GameObject val2 = new GameObject(name);
		val2.transform.SetParent(root);
		int num = LayerMask.NameToLayer("Ground");
		if (num >= 0)
		{
			val2.layer = num;
		}
		val2.AddComponent<MeshFilter>().sharedMesh = val;
		MeshRenderer val3 = val2.AddComponent<MeshRenderer>();
		if ((Object)(object)material != (Object)null)
		{
			((Renderer)val3).sharedMaterial = material;
		}
		if (addCollider)
		{
			val2.AddComponent<MeshCollider>().sharedMesh = val;
		}
	}

	private static void CreateLowPolyRock(Transform root, string name, Vector3 position, Vector3 scale, Quaternion rotation, Material material, bool collider = true)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bd: 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_00e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ee: 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_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0208: Unknown result type (might be due to invalid IL or missing references)
		//IL_0210: Unknown result type (might be due to invalid IL or missing references)
		//IL_0218: Unknown result type (might be due to invalid IL or missing references)
		//IL_0227: Unknown result type (might be due to invalid IL or missing references)
		//IL_0230: Unknown result type (might be due to invalid IL or missing references)
		//IL_0239: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0259: Unknown result type (might be due to invalid IL or missing references)
		//IL_0265: Unknown result type (might be due to invalid IL or missing references)
		//IL_026b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_0280: Unknown result type (might be due to invalid IL or missing references)
		//IL_0285: Unknown result type (might be due to invalid IL or missing references)
		//IL_028d: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bd: Expected O, but got Unknown
		//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fc: Expected O, but got Unknown
		//IL_0310: Unknown result type (might be due to invalid IL or missing references)
		//IL_031d: Unknown result type (might be due to invalid IL or missing references)
		int seed = StableHash(name);
		Vector3[] array = (Vector3[])(object)new Vector3[8];
		Vector3[] array2 = (Vector3[])(object)new Vector3[8];
		Vector3[] array3 = (Vector3[])(object)new Vector3[8];
		for (int i = 0; i < 8; i++)
		{
			float num = (float)i * (float)Math.PI * 2f / 8f;
			float num2 = Mathf.Cos(num);
			float num3 = Mathf.Sin(num);
			float num4 = 0.31f + Noise01(i, 1, seed) * 0.06f;
			float num5 = 0.46f + Noise01(i, 2, seed) * 0.07f;
			float num6 = 0.31f + Noise01(i, 3, seed) * 0.08f;
			array[i] = new Vector3(num2 * num4, -0.43f + Noise01(i, 4, seed) * 0.035f, num3 * num4);
			array2[i] = new Vector3(num2 * num5, -0.03f + Noise01(i, 5, seed) * 0.06f, num3 * num5);
			array3[i] = new Vector3(num2 * num6, 0.34f + Noise01(i, 6, seed) * 0.055f, num3 * num6);
		}
		Vector3 arg = default(Vector3);
		((Vector3)(ref arg))..ctor((Noise01(0, 7, seed) - 0.5f) * 0.12f, 0.51f, (Noise01(1, 7, seed) - 0.5f) * 0.12f);
		Vector3 arg2 = default(Vector3);
		((Vector3)(ref arg2))..ctor((Noise01(2, 7, seed) - 0.5f) * 0.08f, -0.5f, (Noise01(3, 7, seed) - 0.5f) * 0.08f);
		List<Vector3> vertices = new List<Vector3>(144);
		List<Vector2> uvs = new List<Vector2>(144);
		List<int> triangles = new List<int>(144);
		Action<Vector3, Vector3, Vector3> action = delegate(Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0014: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_005a: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			int count = vertices.Count;
			Vector3[] array4 = (Vector3[])(object)new Vector3[3] { a, b, c };
			foreach (Vector3 val4 in array4)
			{
				vertices.Add(Vector3.Scale(val4, scale));
				uvs.Add(new Vector2(Mathf.Atan2(val4.z, val4.x) / ((float)Math.PI * 2f) + 0.5f, val4.y + 0.5f));
			}
			triangles.Add(count);
			triangles.Add(count + 1);
			triangles.Add(count + 2);
		};
		for (int num7 = 0; num7 < 8; num7++)
		{
			int num8 = (num7 + 1) % 8;
			action(array[num7], array2[num7], array2[num8]);
			action(array[num7], array2[num8], array[num8]);
			action(array2[num7], array3[num7], array3[num8]);
			action(array2[num7], array3[num8], array2[num8]);
			action(arg, array3[num8], array3[num7]);
			action(arg2, array[num7], array[num8]);
		}
		Mesh val = new Mesh
		{
			name = name + " Low Poly Rock Mesh"
		};
		val.SetVertices(vertices);
		val.SetUVs(0, uvs);
		val.SetTriangles(triangles, 0);
		val.RecalculateNormals();
		val.RecalculateBounds();
		GameObject val2 = new GameObject(name);
		val2.transform.SetParent(root);
		val2.transform.position = position;
		val2.transform.rotation = rotation;
		int num9 = LayerMask.NameToLayer("Ground");
		if (num9 >= 0)
		{
			val2.layer = num9;
		}
		val2.AddComponent<MeshFilter>().sharedMesh = val;
		MeshRenderer val3 = val2.AddComponent<MeshRenderer>();
		if ((Object)(object)material != (Object)null)
		{
			((Renderer)val3).sharedMaterial = material;
		}
		if (collider)
		{
			val2.AddComponent<MeshCollider>().sharedMesh = val;
		}
	}

	private static int StableHash(string value)
	{
		int num = 23;
		string text = value ?? string.Empty;
		foreach (char c in text)
		{
			num = num * 31 + c;
		}
		return num;
	}

	private static float Noise01(int a, int b, int seed)
	{
		int num = seed ^ (a * 374761393) ^ (b * 668265263);
		return (float)(((num ^ (num >> 13)) * 1274126177) & 0x7FFFFFFF) / 2.1474836E+09f;
	}

	private static void CarveTerrainEntrances(List<Transform> entrances)
	{
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0124: Unknown result type (might be due to invalid IL or missing references)
		//IL_012f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_013f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0144: Unknown result type (might be due to invalid IL or missing references)
		//IL_0148: Unknown result type (might be due to invalid IL or missing references)
		//IL_014f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_016c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0174: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_01bb: 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_01c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		MapDisplay val = Object.FindObjectOfType<MapDisplay>();
		MeshFilter filter = val?.meshFilter;
		MeshCollider val2 = val?.meshCollider;
		MeshFilter obj = filter;
		Mesh val3 = ((obj != null) ? obj.sharedMesh : null);
		if ((Object)(object)val3 == (Object)null || (Object)(object)val2 == (Object)null || entrances.Count == 0)
		{
			Plugin.Log.LogWarning((object)"Terrain entrance carving skipped: world mesh was unavailable.");
			return;
		}
		Vector3[] vertices = val3.vertices;
		int[] triangles = val3.triangles;
		List<Vector2[]> source = entrances.Select(delegate(Transform value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0028: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0037: 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)
			Vector3 position = value.position;
			Vector3 val8 = new Vector3(0f - position.x, 0f, 0f - position.z);
			Vector3 val9 = ((Vector3)(ref val8)).normalized;
			if (((Vector3)(ref val9)).sqrMagnitude < 0.1f)
			{
				val9 = Vector3.forward;
			}
			Vector3 val10 = ((Component)filter).transform.InverseTransformPoint(position + val9 * 0.35f);
			Vector3 val11 = ((Component)filter).transform.InverseTransformPoint(position + val9 * 27.5f);
			return (Vector2[])(object)new Vector2[2]
			{
				new Vector2(val10.x, val10.z),
				new Vector2(val11.x, val11.z)
			};
		}).ToList();
		float worldScale = Mathf.Max(0.01f, Mathf.Max(Mathf.Abs(((Component)filter).transform.lossyScale.x), Mathf.Abs(((Component)filter).transform.lossyScale.z)));
		float num = 5.25f / worldScale;
		float radiusSquared = num * num;
		List<int> list = new List<int>(triangles.Length);
		int num2 = 0;
		for (int num3 = 0; num3 + 2 < triangles.Length; num3 += 3)
		{
			Vector3 val4 = vertices[triangles[num3]];
			Vector3 val5 = vertices[triangles[num3 + 1]];
			Vector3 val6 = vertices[triangles[num3 + 2]];
			Vector2 center = new Vector2((val4.x + val5.x + val6.x) / 3f, (val4.z + val5.z + val6.z) / 3f);
			bool flag = source.Any((Vector2[] cut) => DistanceToSegmentSquared(center, cut[0], cut[1]) <= radiusSquared);
			if (!flag)
			{
				Vector2 av = new Vector2(val4.x, val4.z);
				Vector2 bv = new Vector2(val5.x, val5.z);
				Vector2 cv = new Vector2(val6.x, val6.z);
				float mouthRadiusSquared = radiusSquared * 0.58f;
				flag = source.Any(delegate(Vector2[] cut)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0009: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: 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_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_001e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0023: Unknown result type (might be due to invalid IL or missing references)
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					//IL_003f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0045: Unknown result type (might be due to invalid IL or missing references)
					//IL_004b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0051: Unknown result type (might be due to invalid IL or missing references)
					Vector2 val8 = cut[1] - cut[0];
					Vector2 normalized = ((Vector2)(ref val8)).normalized;
					return DistanceToTriangleSquared(cut[0] + normalized * (2.6f / worldScale), av, bv, cv) <= mouthRadiusSquared;
				});
			}
			if (flag)
			{
				num2++;
				continue;
			}
			list.Add(triangles[num3]);
			list.Add(triangles[num3 + 1]);
			list.Add(triangles[num3 + 2]);
		}
		Mesh val7 = Object.Instantiate<Mesh>(val3);
		((Object)val7).name = "Muck Replayable Physically Carved Terrain";
		val7.triangles = list.ToArray();
		val7.RecalculateNormals();
		val7.RecalculateBounds();
		filter.sharedMesh = val7;
		val2.sharedMesh = null;
		val2.sharedMesh = val7;
		Plugin.Log.LogInfo((object)$"Carved {entrances.Count} physical cave mouths from terrain ({num2} triangles removed).");
	}

	private static float DistanceToSegmentSquared(Vector2 point, Vector2 start, Vector2 end)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: 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_002f: 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_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		Vector2 val = end - start;
		float sqrMagnitude = ((Vector2)(ref val)).sqrMagnitude;
		Vector2 val2;
		if (sqrMagnitude < 0.0001f)
		{
			val2 = point - start;
			return ((Vector2)(ref val2)).sqrMagnitude;
		}
		float num = Mathf.Clamp01(Vector2.Dot(point - start, val) / sqrMagnitude);
		val2 = point - (start + val * num);
		return ((Vector2)(ref val2)).sqrMagnitude;
	}

	private static float DistanceToTriangleSquared(Vector2 point, Vector2 a, Vector2 b, Vector2 c)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		//IL_001b: 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_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_002f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0030: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_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_008d: 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_008f: Unknown result type (might be due to invalid IL or missing references)
		float num = Cross(b - a, point - a);
		float num2 = Cross(c - b, point - b);
		float num3 = Cross(a - c, point - c);
		bool flag = num < 0f || num2 < 0f || num3 < 0f;
		bool flag2 = num > 0f || num2 > 0f || num3 > 0f;
		if (!(flag && flag2))
		{
			return 0f;
		}
		return Mathf.Min(DistanceToSegmentSquared(point, a, b), Mathf.Min(DistanceToSegmentSquared(point, b, c), DistanceToSegmentSquared(point, c, a)));
	}

	private static float Cross(Vector2 a, Vector2 b)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		return a.x * b.y - a.y * b.x;
	}

	private static void ClearEntranceObstacles(List<Transform> entrances)
	{
		if (ResourceManager.Instance?.list == null)
		{
			return;
		}
		KeyValuePair<int, GameObject>[] array = ResourceManager.Instance.list.ToArray();
		for (int i = 0; i < array.Length; i++)
		{
			KeyValuePair<int, GameObject> keyValuePair = array[i];
			GameObject value = keyValuePair.Value;
			if (!((Object)(object)value == (Object)null) && !entrances.All((Transform entrance) => HorizontalDistance(entrance.position, value.transform.position) > 18f) && (ResourceManager.Instance.builds == null || !ResourceManager.Instance.builds.ContainsKey(keyValuePair.Key)) && GetOreTier(value.GetComponentInChildren<HitableResource>()) == OreTier.Unknown)
			{
				ResourceManager.Instance.list.Remove(keyValuePair.Key);
				Object.Destroy((Object)(object)value);
			}
		}
	}

	private static List<CaveOreSurfaceSlot> SelectSurfaceSlots(List<CaveOreSurfaceSlot> candidates, int desired)
	{
		if (candidates.Count <= desired)
		{
			return candidates;
		}
		Dictionary<CaveSurfaceKind, Queue<CaveOreSurfaceSlot>> dictionary = (from candidate in candidates
			group candidate by candidate.Kind).ToDictionary((IGrouping<CaveSurfaceKind, CaveOreSurfaceSlot> group) => group.Key, (IGrouping<CaveSurfaceKind, CaveOreSurfaceSlot> group) => new Queue<CaveOreSurfaceSlot>(group));
		Dictionary<CaveSurfaceKind, int> counts = dictionary.Keys.ToDictionary((CaveSurfaceKind kind) => kind, (CaveSurfaceKind kind) => 0);
		List<CaveOreSurfaceSlot> list = new List<CaveOreSurfaceSlot>(desired);
		while (list.Count < desired)
		{
			CaveSurfaceKind key = (from entry in dictionary
				where entry.Value.Count > 0
				orderby ((float)counts[entry.Key] + 1f) / CaveSurfaceWeight(entry.Key), entry.Key
				select entry.Key).FirstOrDefault();
			if (!dictionary.TryGetValue(key, out var value) || value.Count == 0)
			{
				break;
			}
			list.Add(value.Dequeue());
			counts[key]++;
		}
		return list;
	}

	private static float CaveSurfaceWeight(CaveSurfaceKind kind)
	{
		return kind switch
		{
			CaveSurfaceKind.Floor => 5f, 
			CaveSurfaceKind.Wall => 3f, 
			CaveSurfaceKind.Ceiling => 2f, 
			_ => 0.01f, 
		};
	}

	private static float HorizontalDistance(Vector3 a, Vector3 b)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		float num = a.x - b.x;
		float num2 = a.z - b.z;
		return Mathf.Sqrt(num * num + num2 * num2);
	}

	private static void CreateBlock(Transform parent, string name, Vector3 position, Vector3 scale, Material material, bool collider = true)
	{
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		CreateOrientedBlock(parent, name, position, scale, Quaternion.identity, material, collider);
	}

	private static void CreateOrientedBlock(Transform parent, string name, Vector3 position, Vector3 scale, Quaternion rotation, Material material, bool collider = true)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0039: 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)
		GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
		((Object)val).name = name;
		val.transform.SetParent(parent);
		val.transform.position = position;
		val.transform.rotation = rotation;
		val.transform.localScale = scale;
		int num = LayerMask.NameToLayer("Ground");
		if (num >= 0)
		{
			val.layer = num;
		}
		Renderer component = val.GetComponent<Renderer>();
		if ((Object)(object)material != (Object)null)
		{
			component.sharedMaterial = material;
		}
		ApplyCaveTiling(component, scale);
		if (!collider)
		{
			val.GetComponent<Collider>().enabled = false;
		}
	}

	private static void ApplyCaveTiling(Renderer renderer, Vector3 scale)
	{
		//IL_002a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0062: Expected O, but got Unknown
		//IL_007b: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)renderer == (Object)null) && !((Object)(object)renderer.sharedMaterial == (Object)null) && renderer.sharedMaterial.HasProperty("_MainTex"))
		{
			float num = Mathf.Clamp(Mathf.Max(scale.x, Mathf.Max(scale.y, scale.z)) / 12f, 1f, 48f);
			MaterialPropertyBlock val = new MaterialPropertyBlock();
			renderer.GetPropertyBlock(val);
			val.SetVector("_MainTex_ST", new Vector4(num, num, 0f, 0f));
			renderer.SetPropertyBlock(val);
		}
	}

	private static void CreateCaveLight(Transform parent, string name, Vector3 position, Color color, float range, float intensity)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_002b: Unknown result type (might be due to invalid IL or missing references)
		GameObject val = new GameObject(name);
		val.transform.SetParent(parent);
		val.transform.position = position;
		Light obj = val.AddComponent<Light>();
		obj.type = (LightType)2;
		obj.color = color;
		obj.range = range;
		obj.intensity = intensity;
		obj.shadows = (LightShadows)0;
		obj.renderMode = (LightRenderMode)2;
	}

	private static List<GuardedOre> MoveOreNodes(Transform caveRoot, List<OreSlotCandidate> slots, int desiredSlots)
	{
		//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_0251: Unknown result type (might be due to invalid IL or missing references)
		//IL_0256: Unknown result type (might be due to invalid IL or missing references)
		//IL_025b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0262: Unknown result type (might be due to invalid IL or missing references)
		//IL_0267: Unknown result type (might be due to invalid IL or missing references)
		//IL_026c: Unknown result type (might be due to invalid IL or missing references)
		//IL_027a: Unknown result type (might be due to invalid IL or missing references)
		//IL_028f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0296: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
		List<GuardedOre> list = new List<GuardedOre>();
		if (slots.Count == 0 || ResourceManager.Instance?.list == null)
		{
			return list;
		}
		Dictionary<int, OreNode> dictionary = new Dictionary<int, OreNode>();
		HitableResource[] array = Resources.FindObjectsOfTypeAll<HitableResource>();
		foreach (HitableResource val in array)
		{
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			Scene scene = ((Component)val).gameObject.scene;
			if (!((Scene)(ref scene)).IsValid())
			{
				continue;
			}
			OreTier oreTier = GetOreTier(val);
			if (oreTier != OreTier.Unknown)
			{
				int id = ((Hitable)val).GetId();
				if (id >= 0 && !dictionary.ContainsKey(id) && ResourceManager.Instance.list.TryGetValue(id, out var value) && !((Object)(object)value == (Object)null))
				{
					dictionary.Add(id, new OreNode
					{
						Id = id,
						Object = value,
						Kind = (val.dropItem?.name ?? string.Empty),
						Tier = oreTier
					});
				}
			}
		}
		List<OreNode> list2 = dictionary.Values.OrderBy((OreNode node) => node.Id).ToList();
		if (list2.Count == 0)
		{
			return list;
		}
		Physics.SyncTransforms();
		CaveOreSurfaceSlot grounded;
		List<CaveOreSurfaceSlot> list3 = (from slot in slots
			select (!TryFindCaveSurface(caveRoot, slot, out grounded)) ? null : grounded into slot
			where slot != null
			select slot).ToList();
		List<CaveOreSurfaceSlot> list4 = SelectSurfaceSlots(list3, Mathf.Min(desiredSlots, list3.Count));
		int num = Mathf.Clamp(Plugin.Settings.SurfaceOreNodeCount.Value, 0, Mathf.Max(0, list2.Count - 1));
		int count = Mathf.Min(Mathf.Max(0, list2.Count - num), list4.Count);
		List<OreNode> list5 = SelectTieredOres(list2, count);
		int seed = GameManager.GetSeed();
		int num2 = 0;
		for (int num3 = 0; num3 < list5.Count; num3++)
		{
			OreNode oreNode = list5[num3];
			GameObject val2 = oreNode.Object;
			if (!((Object)(object)val2 == (Object)null))
			{
				CaveOreSurfaceSlot caveOreSurfaceSlot = list4[num3];
				float num4 = PositiveModulo(oreNode.Id * 47 + seed, 360);
				val2.transform.rotation = Quaternion.AngleAxis(num4, caveOreSurfaceSlot.Normal) * Quaternion.FromToRotation(Vector3.up, caveOreSurfaceSlot.Normal);
				float num5 = VisibleSurfaceOffset(val2, caveOreSurfaceSlot.Normal);
				val2.transform.position = caveOreSurfaceSlot.Position + caveOreSurfaceSlot.Normal * (num5 + 0.06f);
				num2++;
				if (Noise01(oreNode.Id, 941, seed) < 0.1f)
				{
					list.Add(new GuardedOre
					{
						Id = oreNode.Id,
						Object = val2,
						Position = caveOreSurfaceSlot.Position
					});
				}
			}
		}
		int num6 = list2.Count - num2;
		string arg = string.Join(", ", from node in list5
			group node by node.Tier into @group
			orderby @group.Key
			select $"{@group.Key}={@group.Count()}");
		string text = string.Join(", ", from slot in list4
			group slot by slot.Kind into @group
			orderby @group.Key
			select $"{@group.Key}={@group.Count()}");
		Plugin.Log.LogInfo((object)($"Placed {num2}/{list5.Count} minerals on {list4.Count}/{list3.Count}/{slots.Count} selected/validated/probed cave surfaces " + "(" + text + "); " + $"({arg}); retained {num6} surface minerals and destroyed none; armed {list.Count} lazy guards."));
		return list;
	}

	private static List<OreNode> SelectTieredOres(List<OreNode> ores, int count)
	{
		Dictionary<OreTier, Queue<OreNode>> dictionary = (from node in ores
			group node by node.Tier).ToDictionary((IGrouping<OreTier, OreNode> group) => group.Key, (IGrouping<OreTier, OreNode> group) => new Queue<OreNode>(group.OrderBy((OreNode node) => node.Id)));
		Dictionary<OreTier, int> selectedPerTier = dictionary.Keys.ToDictionary((OreTier tier) => tier, (OreTier tier) => 0);
		List<OreNode> list = new List<OreNode>(count);
		while (list.Count < count)
		{
			OreTier key = (from entry in dictionary
				where entry.Value.Count > 0
				orderby ((float)selectedPerTier[entry.Key] + 1f) / OreWeight(entry.Key), entry.Key
				select entry.Key).FirstOrDefault();
			if (!dictionary.TryGetValue(key, out var value) || value.Count == 0)
			{
				break;
			}
			list.Add(value.Dequeue());
			selectedPerTier[key]++;
		}
		return list;
	}

	private static float OreWeight(OreTier tier)
	{
		return tier switch
		{
			OreTier.Stone => 26f, 
			OreTier.Coal => 24f, 
			OreTier.Iron => 22f, 
			OreTier.Gold => 13f, 
			OreTier.Mithril => 8f, 
			OreTier.Adamantite => 4f, 
			OreTier.Obamium => 2f, 
			OreTier.Ruby => 1f, 
			_ => 0.01f, 
		};
	}

	private static OreTier GetOreTier(HitableResource resource)
	{
		string text = resource?.dropItem?.name ?? string.Empty;
		if (text.Equals("Rock", StringComparison.OrdinalIgnoreCase) || text.IndexOf("Stone", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Stone;
		}
		if (text.IndexOf("Coal", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Coal;
		}
		if (text.IndexOf("Iron", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Iron;
		}
		if (text.IndexOf("Gold", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Gold;
		}
		if (text.IndexOf("Mithril", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Mithril;
		}
		if (text.IndexOf("Adamantite", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Adamanite", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Adamantite;
		}
		if (text.IndexOf("Obamium", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Obamium;
		}
		if (text.IndexOf("Ruby", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return OreTier.Ruby;
		}
		return OreTier.Unknown;
	}

	private static bool TryFindCaveSurface(Transform caveRoot, OreSlotCandidate candidate, out CaveOreSurfaceSlot grounded)
	{
		//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_0065: 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_0096: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0103: Unknown result type (might be due to invalid IL or missing references)
		//IL_0147: Unknown result type (might be due to invalid IL or missing references)
		//IL_014c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Unknown result type (might be due to invalid IL or missing references)
		//IL_0159: Unknown result type (might be due to invalid IL or missing references)
		grounded = null;
		int num = LayerMask.NameToLayer("Ground");
		int num2 = ((num >= 0) ? (1 << num) : (-5));
		RaycastHit val = default(RaycastHit);
		foreach (RaycastHit item in from value in Physics.RaycastAll(candidate.Origin, candidate.Direction, 14f, num2, (QueryTriggerInteraction)1)
			orderby ((RaycastHit)(ref value)).distance
			select value)
		{
			RaycastHit current = item;
			if (!((Object)(object)((RaycastHit)(ref current)).collider == (Object)null) && ((Component)((RaycastHit)(ref current)).collider).transform.IsChildOf(caveRoot) && !(Vector3.Dot(((RaycastHit)(ref current)).normal, -candidate.Direction) < 0.42f) && IsInside(((RaycastHit)(ref current)).point + ((RaycastHit)(ref current)).normal * 1.1f) && (candidate.Kind != CaveSurfaceKind.Floor || !Physics.Raycast(((RaycastHit)(ref current)).point + ((RaycastHit)(ref current)).normal * 0.18f, ((RaycastHit)(ref current)).normal, ref val, 2.8f, num2, (QueryTriggerInteraction)1) || !((Object)(object)((RaycastHit)(ref val)).collider != (Object)null) || !((Component)((RaycastHit)(ref val)).collider).transform.IsChildOf(caveRoot)))
			{
				grounded = new CaveOreSurfaceSlot
				{
					Position = ((RaycastHit)(ref current)).point,
					Normal = ((RaycastHit)(ref current)).normal,
					Kind = candidate.Kind
				};
				return true;
			}
		}
		return false;
	}

	private static bool TryFindCaveFloor(Transform caveRoot, Vector3 candidate, out CaveOreSurfaceSlot grounded)
	{
		//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_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0032: 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_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b6: 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_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_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: 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)
		grounded = null;
		int num = LayerMask.NameToLayer("Ground");
		int num2 = ((num >= 0) ? (1 << num) : (-5));
		foreach (RaycastHit item in from value in Physics.RaycastAll(candidate + Vector3.up * 3.5f, Vector3.down, 32f, num2, (QueryTriggerInteraction)1)
			orderby ((RaycastHit)(ref value)).distance
			select value)
		{
			RaycastHit current = item;
			if (!((Object)(object)((RaycastHit)(ref current)).collider == (Object)null) && ((Component)((RaycastHit)(ref current)).collider).transform.IsChildOf(caveRoot) && !(Vector3.Dot(((RaycastHit)(ref current)).normal, Vector3.up) < 0.48f) && IsInside(((RaycastHit)(ref current)).point + Vector3.up * 1.1f))
			{
				grounded = new CaveOreSurfaceSlot
				{
					Position = ((RaycastHit)(ref current)).point,
					Normal = ((RaycastHit)(ref current)).normal,
					Kind = CaveSurfaceKind.Floor
				};
				return true;
			}
		}
		return false;
	}

	private static float VisibleSurfaceOffset(GameObject root, Vector3 normal)
	{
		//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)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: 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_0062: 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_0075: 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_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Unknown result type (might be due to invalid IL or missing references)
		Renderer[] componentsInChildren = root.GetComponentsInChildren<Renderer>(true);
		if (componentsInChildren.Length == 0)
		{
			return 0.08f;
		}
		Bounds bounds = componentsInChildren[0].bounds;
		for (int i = 1; i < componentsInChildren.Length; i++)
		{
			((Bounds)(ref bounds)).Encapsulate(componentsInChildren[i].bounds);
		}
		Vector3 extents = ((Bounds)(ref bounds)).extents;
		float num = Mathf.Abs(normal.x) * extents.x + Mathf.Abs(normal.y) * extents.y + Mathf.Abs(normal.z) * extents.z;
		float num2 = Vector3.Dot(((Bounds)(ref bounds)).center - root.transform.position, normal);
		return Mathf.Clamp(num - num2, 0.04f, 3.2f);
	}

	private static int PositiveModulo(int value, int modulo)
	{
		int num = value % modulo;
		if (num >= 0)
		{
			return num;
		}
		return num + modulo;
	}
}
[HarmonyPatch(typeof(MobSpawner), "SpawnMob")]
internal static class ContentVariantSpawnPatch
{
	private static void Postfix(int mobType, int mobId)
	{
		if (MobManager.Instance?.mobs != null && MobManager.Instance.mobs.TryGetValue(mobId, out var value))
		{
			NewMonsterRegistry.ApplySpawnedType(value, mobType);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "Awake")]
internal static class ExpandedWorldSetupPatch
{
	private static void Postfix(GameManager __instance)
	{
		CaveNetwork.Reset();
		RunSaveService.ResetForNewWorld();
		if (Plugin.Settings.EnableExpandedIsland.Value)
		{
			float num = 1100f;
			float num2 = (float)MapGenerator.mapChunkSize / 241f;
			AccessTools.Field(typeof(GameManager), "mapRadius")?.SetValue(__instance, num * num2);
		}
	}
}
[HarmonyPatch(typeof(GameManager), "GenerateWorldRoutine")]
internal static class WorldGenerationCompletionPatch
{
	private static void Postfix(ref IEnumerator __result)
	{
		__result = Wrap(__result);
	}

	private static IEnumerator Wrap(IEnumerator original)
	{
		while (original.MoveNext())
		{
			yield return original.Current;
		}
		CaveNetwork.Build();
		TextureOverrideService.ApplyAll();
		RunSaveService.OnWorldReady();
	}
}
[HarmonyPatch(typeof(PlayerMovement), "IsUnderWater")]
internal static class CaveBreathingPatch
{
	private static void Postfix(ref bool __result)
	{
		if (CaveNetwork.IsLocalInside)
		{
			__result = false;
		}
	}
}
[HarmonyPatch(typeof(WorldUtility), "WorldHeightToBiome")]
internal static class CaveBiomePatch
{
	private static bool Prefix(float height, ref TerrainType __result)
	{
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		if (!CaveNetwork.IsLocalInside)
		{
			return true;
		}
		float num = (((Object)(object)World.Instance?.water != (Object)null) ? World.Instance.water.position.y : 0f);
		if (height > num - 12f)
		{
			return true;
		}
		__result = (TerrainType)2;
		return false;
	}
}
[HarmonyPatch(typeof(PlayerMovement), "Update")]
internal static class CaveWaterVisibilityPatch
{
	private static void Postfix()
	{
		CaveNetwork.UpdateWaterVisibility();
	}
}
[HarmonyPatch(typeof(DayCycle), "Update")]
[HarmonyPriority(0)]
internal static class CaveSurfaceFogPatch
{
	private static void Postfix(DayCycle __instance)
	{
		//IL_005f: 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_006b: Unknown result type (might be due to invalid IL or missing references)
		if (CaveNetwork.IsLocalInside && !((Object)(object)__instance == (Object)null))
		{
			float num = ((__instance.waterGraph != null) ? __instance.waterGraph.Evaluate(Mathf.Repeat(DayCycle.time + 0.75f, 1f)) : ((DayCycle.time > 0.5f) ? 1f : 0f));
			RenderSettings.fogDensity = 0.0035f;
			RenderSettings.fogColor = Color.Lerp(__instance.dayFog, __instance.nightFog, num);
		}
	}
}
[HarmonyPatch(typeof(PlayerStatus), "SlowUpdate")]
internal static class CaveUnderwaterAudioPatch
{
	private static void Prefix(ref float __state)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		__state = float.NaN;
		Transform val = World.Instance?.water;
		if (CaveNetwork.IsLocalInside && !((Object)(object)val == (Object)null))
		{
			__state = val.position.y;
			Vector3 position = val.position;
			position.y = -10000f;
			val.position = position;
		}
	}

	private static void Postfix(float __state)
	{
		Restore(__state);
	}

	private static Exception Finalizer(Exception __exception, float __state)
	{
		Restore(__state);
		return __exception;
	}

	private static void Restore(float originalY)
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0034: Unknown result type (might be due to invalid IL or missing references)
		Transform val = World.Instance?.water;
		if (!((Object)(object)val == (Object)null) && !float.IsNaN(originalY))
		{
			Vector3 position = val.position;
			position.y = originalY;
			val.position = position;
		}
	}
}
internal static class WorldSyncPackets
{
	internal const int RestoreClockPacketId = 241;

	private static readonly MethodInfo SendToAllExcept = AccessTools.Method(typeof(ServerSend), "SendTCPDataToAll", new Type[2]
	{
		typeof(int),
		typeof(Packet)
	}, (Type[])null);

	private static readonly FieldInfo TotalTime = AccessTools.Field(typeof(DayCycle), "<totalTime>k__BackingField");

	internal static void BroadcastRestoredClock(float dayTime, float totalTime)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_002e: Expected O, but got Unknown
		if (!LocalClient.serverOwner || (Object)(object)LocalClient.instance == (Object)null || SendToAllExcept == null)
		{
			return;
		}
		try
		{
			Packet val = new Packet(241);
			try
			{
				val.Write(Mathf.Repeat(dayTime, 1f));
				val.Write(Mathf.Max(0f, totalTime));
				SendToAllExcept.Invoke(null, new object[2]
				{
					LocalClient.instance.myId,
					val
				});
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Could not synchronize restored clock: " + ex.Message));
		}
	}

	internal static void ReceiveRestoredClock(Packet packet)
	{
		try
		{
			float num = packet.ReadFloat(true);
			float num2 = packet.ReadFloat(true);
			if (PacketSanitizer.ValidFloat(num) && PacketSanitizer.ValidFloat(num2))
			{
				DayCycle.time = Mathf.Repeat(num, 1f);
				TotalTime?.SetValue(null, Mathf.Max(0f, num2));
				Plugin.Log.LogInfo((object)$"Applied restored world clock ({DayCycle.time:0.000}, total {Mathf.Max(0f, num2):0.000}).");
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("Rejected malformed restored-clock packet: " + ex.Message));
		}
	}
}
[HarmonyPatch(typeof(LocalClient), "InitializeClientData")]
internal static class RestoredClockPacketRegistrationPatch
{
	private static void Postfix()
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown
		if (LocalClient.packetHandlers != null)
		{
			LocalClient.packetHandlers[241] = new PacketHandler(WorldSyncPackets.ReceiveRestoredClock);
		}
	}
}