using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using DbsContentApi;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;
using Zorro.Core.Serizalization;
using pworld.Scripts.Extensions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ProgressionRebalance")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+44a1e7060eb750aa5464efff7424010fea241365")]
[assembly: AssemblyProduct("Progression Rebalance")]
[assembly: AssemblyTitle("ProgressionRebalance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ProgressionRebalance
{
	public class ItemSellDropBox : MonoBehaviourPunCallbacks
	{
		public const int PhotonViewId = 997;

		private const float RefundFraction = 0.3f;

		private const float DelayBeforeEvaluate = 0.3f;

		private const float MaxWaitAfterClosed = 1.5f;

		private const float ProcessingDuration = 3f;

		public ItemSellDropBoxItemDetector Detector;

		public ItemSellDropBoxLid Lid;

		public GameObject Particles;

		private PhotonView m_photonView;

		private ParticleSystem[] m_particleSystems = Array.Empty<ParticleSystem>();

		private bool m_checkingContents;

		private bool m_ejecting;

		private bool m_processing;

		private float m_elapsedSinceFullyClosed;

		private float m_processingElapsed;

		private int? m_pendingRefund;

		private float m_ignoreNewInteractionsUntilRealtime;

		private void Awake()
		{
			m_photonView = ((Component)this).GetComponent<PhotonView>();
			if ((Object)(object)m_photonView == (Object)null)
			{
				Logger.LogError("ItemSellDropBox: PhotonView not found on Awake.");
			}
			Transform val = ((Component)this).transform.Find("Particles/Left");
			Transform val2 = ((Component)this).transform.Find("Particles/Right");
			ParticleSystem val3 = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<ParticleSystem>() : null);
			ParticleSystem val4 = (((Object)(object)val2 != (Object)null) ? ((Component)val2).GetComponent<ParticleSystem>() : null);
			if ((Object)(object)val3 == (Object)null)
			{
				Logger.LogError("ItemSellDropBox: ParticleSystem not found on Particles/Left");
			}
			if ((Object)(object)val4 == (Object)null)
			{
				Logger.LogError("ItemSellDropBox: ParticleSystem not found on Particles/Right");
			}
			m_particleSystems = (ParticleSystem[])((!((Object)(object)val3 != (Object)null) || !((Object)(object)val4 != (Object)null)) ? ((!((Object)(object)val3 != (Object)null)) ? ((!((Object)(object)val4 != (Object)null)) ? ((Array)Array.Empty<ParticleSystem>()) : ((Array)new ParticleSystem[1] { val4 })) : new ParticleSystem[1] { val3 }) : new ParticleSystem[2] { val3, val4 });
		}

		private void FixedUpdate()
		{
			//IL_0093: 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_00b0: 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_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_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)
			if (!PhotonNetwork.IsMasterClient || !m_ejecting)
			{
				return;
			}
			if (!Lid.m_opened)
			{
				Lid.Open();
			}
			List<(Item, Pickup)> list = Detector.CheckForItems();
			if (list.Count == 0)
			{
				m_ejecting = false;
			}
			else
			{
				if (!Lid.IsHalfwayOpenForEject())
				{
					return;
				}
				Transform transform = ((Component)this).transform;
				foreach (var item2 in list)
				{
					Pickup item = item2.Item2;
					if (!((Object)(object)item == (Object)null) && !((Object)(object)item.Rigidbody == (Object)null))
					{
						Rigidbody rigidbody = item.Rigidbody;
						if (!(rigidbody.linearVelocity.y > 0.1f))
						{
							rigidbody.AddTorque(Vector3.right * 3f, (ForceMode)1);
							rigidbody.AddForce(Vector3.up * 25f + -transform.forward * 6f, (ForceMode)1);
						}
					}
				}
			}
		}

		private void Update()
		{
			if (PhotonNetwork.IsMasterClient)
			{
				UpdateLogic();
			}
		}

		private static bool TryGetSellRefund(Item item, out int refund)
		{
			refund = 0;
			if ((Object)(object)item == (Object)null || item.price <= 0)
			{
				return false;
			}
			refund = Mathf.RoundToInt((float)item.price * 0.3f);
			return refund > 0;
		}

		private void UpdateLogic()
		{
			if (m_processing)
			{
				m_processingElapsed += Time.deltaTime;
				if (m_processingElapsed >= 3f)
				{
					EndProcessing();
				}
				return;
			}
			List<(Item, Pickup)> list = Detector.CheckForItems();
			bool flag = list.Count > 0;
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (realtimeSinceStartup < m_ignoreNewInteractionsUntilRealtime)
			{
				if (!flag)
				{
					m_ignoreNewInteractionsUntilRealtime = 0f;
				}
				return;
			}
			if (!m_checkingContents && !m_ejecting)
			{
				if (!flag && !Lid.m_opened)
				{
					Lid.Open();
				}
				else if (flag && Lid.m_opened)
				{
					Lid.Close();
				}
			}
			if (!m_checkingContents && !m_ejecting && flag && !Lid.m_opened && Lid.IsFullyClosed())
			{
				m_checkingContents = true;
				m_elapsedSinceFullyClosed = 0f;
			}
			if (!m_checkingContents)
			{
				return;
			}
			list = Detector.CheckForItems();
			if (list.Count == 0)
			{
				m_checkingContents = false;
				m_elapsedSinceFullyClosed = 0f;
				if (!Lid.m_opened)
				{
					Lid.Open();
				}
				return;
			}
			m_elapsedSinceFullyClosed += Time.deltaTime;
			if (m_elapsedSinceFullyClosed < 0.3f)
			{
				return;
			}
			if (m_elapsedSinceFullyClosed <= 1.5f)
			{
				if (!TryConsumeSingleSellableItem(list))
				{
					BeginEject();
				}
			}
			else
			{
				BeginEject();
			}
		}

		private bool TryConsumeSingleSellableItem(List<(Item item, Pickup pickup)> items)
		{
			if (items.Count != 1 || (Object)(object)items[0].pickup == (Object)null)
			{
				return false;
			}
			Item item = items[0].item;
			Pickup item2 = items[0].pickup;
			if (!TryGetSellRefund(item, out var refund))
			{
				return false;
			}
			item2.m_photonView.RPC("RPC_Remove", (RpcTarget)2, Array.Empty<object>());
			m_checkingContents = false;
			m_elapsedSinceFullyClosed = 0f;
			BeginProcessing(refund);
			return true;
		}

		private void BeginProcessing(int refund)
		{
			if (PhotonNetwork.InRoom && (Object)(object)m_photonView != (Object)null)
			{
				m_photonView.RPC("RPC_BeginProcessing", (RpcTarget)0, new object[2] { refund, true });
			}
			else
			{
				StartProcessingState(refund, 0f);
				PlayProcessingVisuals(playSfx: true);
			}
		}

		private void StartProcessingState(int refund, float elapsed)
		{
			m_processing = true;
			m_processingElapsed = elapsed;
			m_pendingRefund = refund;
		}

		private void PlayProcessingVisuals(bool playSfx)
		{
			if ((Object)(object)Particles != (Object)null)
			{
				if (!Particles.activeSelf)
				{
					Particles.SetActive(true);
				}
				ParticleSystem[] particleSystems = m_particleSystems;
				foreach (ParticleSystem val in particleSystems)
				{
					val.Clear();
					val.Play();
				}
			}
			else
			{
				Logger.LogError("ItemSellDropBox: Particles reference is null");
			}
			if (!playSfx)
			{
				return;
			}
			Transform val2 = ((Component)this).transform.Find("SFX/Construction");
			if ((Object)(object)val2 != (Object)null)
			{
				SFX_PlayOneShot component = ((Component)val2).GetComponent<SFX_PlayOneShot>();
				if ((Object)(object)component != (Object)null)
				{
					component.Play();
				}
				else
				{
					Logger.LogError("ItemSellDropBox: SFX_PlayOneShot not found on SFX/Construction");
				}
			}
			else
			{
				Logger.LogError("ItemSellDropBox: child SFX/Construction not found");
			}
		}

		public void PlayHatchSfx(bool opened)
		{
			Transform val = ((Component)this).transform.Find(opened ? "SFX/HatchOpen" : "SFX/HatchClose");
			if ((Object)(object)val != (Object)null)
			{
				SFX_PlayOneShot component = ((Component)val).GetComponent<SFX_PlayOneShot>();
				if ((Object)(object)component != (Object)null)
				{
					component.Play();
				}
				else
				{
					Logger.LogError("ItemSellDropBox: SFX_PlayOneShot not found on " + ((Object)val).name);
				}
			}
			else
			{
				Logger.LogError("ItemSellDropBox: hatch SFX child not found for opened=" + opened);
			}
		}

		private void StopProcessingVisuals(ParticleSystemStopBehavior stopBehavior)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			ParticleSystem[] particleSystems = m_particleSystems;
			foreach (ParticleSystem val in particleSystems)
			{
				val.Stop(true, stopBehavior);
			}
		}

		private void EndProcessing()
		{
			m_processing = false;
			m_processingElapsed = 0f;
			int num = -1;
			if (m_pendingRefund.HasValue)
			{
				int value = m_pendingRefund.Value;
				RoomStatsHolder roomStats = SurfaceNetworkHandler.RoomStats;
				if (roomStats != null)
				{
					roomStats.AddMoney(value);
				}
				else
				{
					Logger.LogError("ItemSellDropBox: RoomStats is null; refund skipped.");
				}
				num = value;
				m_pendingRefund = null;
			}
			else
			{
				Logger.LogError("ItemSellDropBox: EndProcessing called but m_pendingRefund is null.");
			}
			if (PhotonNetwork.InRoom && (Object)(object)m_photonView != (Object)null)
			{
				m_photonView.RPC("RPC_EndProcessingVisuals", (RpcTarget)0, new object[1] { num });
			}
			else
			{
				StopProcessingVisuals((ParticleSystemStopBehavior)1);
				if (num > 0)
				{
					ShowRefundNotification(num);
				}
			}
			m_ignoreNewInteractionsUntilRealtime = Time.realtimeSinceStartup + 0.65f;
			Lid.Open();
		}

		private void BeginEject()
		{
			m_checkingContents = false;
			m_elapsedSinceFullyClosed = 0f;
			m_ejecting = true;
			if (!Lid.m_opened)
			{
				Lid.Open();
			}
		}

		public void SyncHatchState()
		{
			if (PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient && (Object)(object)m_photonView != (Object)null)
			{
				m_photonView.RPC("RPC_SyncLid", (RpcTarget)1, new object[1] { Lid.m_opened });
			}
		}

		[PunRPC]
		public void RPC_SyncLid(bool state)
		{
			Lid.SetOpenState(state, playSfx: true, syncIfMaster: false);
		}

		[PunRPC]
		private void RPC_BeginProcessing(int refund, bool playSfx)
		{
			StartProcessingState(refund, 0f);
			PlayProcessingVisuals(playSfx);
		}

		[PunRPC]
		private void RPC_EndProcessingVisuals(int refund)
		{
			m_processing = false;
			m_processingElapsed = 0f;
			m_pendingRefund = null;
			StopProcessingVisuals((ParticleSystemStopBehavior)1);
			if (refund > 0)
			{
				ShowRefundNotification(refund);
			}
		}

		private static void ShowRefundNotification(int refund)
		{
			UserInterface.ShowMoneyNotification("Item Sold", $"${refund}", (MoneyCellType)1);
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			((MonoBehaviourPunCallbacks)this).OnPlayerEnteredRoom(newPlayer);
			if (PhotonNetwork.IsMasterClient && !((Object)(object)m_photonView == (Object)null))
			{
				int num = m_pendingRefund ?? (-1);
				m_photonView.RPC("RPC_SyncState", newPlayer, new object[4] { Lid.m_opened, m_processing, num, m_processingElapsed });
			}
		}

		[PunRPC]
		private void RPC_SyncState(bool lidOpened, bool processing, int pendingRefund, float processingElapsed)
		{
			Lid.SetOpenState(lidOpened, playSfx: false, syncIfMaster: false);
			if (processing)
			{
				if (pendingRefund >= 0)
				{
					StartProcessingState(pendingRefund, processingElapsed);
				}
				PlayProcessingVisuals(playSfx: false);
			}
			else
			{
				m_processing = false;
				m_processingElapsed = 0f;
				m_pendingRefund = null;
				StopProcessingVisuals((ParticleSystemStopBehavior)0);
			}
		}
	}
	public static class ItemSellDropBoxContent
	{
		public static GameObject? SellDropboxPrefab { get; private set; }

		public static void Init(AssetBundle bundle)
		{
			SellDropboxPrefab = ContentLoader.LoadPrefabFromBundle(bundle, "SellItemDropbox.prefab");
			if ((Object)(object)SellDropboxPrefab == (Object)null)
			{
				Logger.LogError("ItemSellDropBox: SellItemDropbox.prefab missing from progressionrebalance bundle.");
			}
		}
	}
	public class ItemSellDropBoxItemDetector : MonoBehaviour
	{
		private Collider[] results = (Collider[])(object)new Collider[10];

		public List<(Item item, Pickup pickup)> CheckForItems()
		{
			//IL_0012: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			HashSet<Pickup> hashSet = new HashSet<Pickup>();
			List<(Item, Pickup)> list = new List<(Item, Pickup)>();
			int num = Physics.OverlapBoxNonAlloc(((Component)this).transform.position, ((Component)this).transform.lossyScale * 0.5f, results, ((Component)this).transform.rotation);
			for (int i = 0; i < num; i++)
			{
				Collider val = results[i];
				Pickup componentInParent = ((Component)val).GetComponentInParent<Pickup>();
				if (Object.op_Implicit((Object)(object)componentInParent) && (Object)(object)componentInParent.itemInstance != (Object)null && (Object)(object)componentInParent.itemInstance.item != (Object)null)
				{
					Item item = componentInParent.itemInstance.item;
					if (hashSet.Add(componentInParent))
					{
						list.Add((item, componentInParent));
					}
				}
			}
			return list;
		}

		private void OnDrawGizmos()
		{
			//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_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_0043: Unknown result type (might be due to invalid IL or missing references)
			Matrix4x4 matrix = Gizmos.matrix;
			Gizmos.matrix = ((Component)this).transform.localToWorldMatrix;
			Gizmos.color = new Color(0f, 1f, 0f, 0.5f);
			Gizmos.DrawCube(Vector3.zero, Vector3.one);
			Gizmos.matrix = matrix;
		}
	}
	public class ItemSellDropBoxLid : MonoBehaviour
	{
		public ItemSellDropBox Machine;

		public bool m_opened = true;

		public float Spring = 70f;

		public float Drag = 0.15f;

		public float m_openedRotation;

		public float m_closedRotation = 90f;

		private OneDPhysicsSpring m_spring;

		private void Awake()
		{
			//IL_0003: 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)
			OneDPhysicsSpring spring = default(OneDPhysicsSpring);
			((OneDPhysicsSpring)(ref spring)).Spring = Spring;
			((OneDPhysicsSpring)(ref spring)).Drag = Drag;
			m_spring = spring;
		}

		private void Update()
		{
			//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)
			((OneDPhysicsSpring)(ref m_spring)).Drag = Drag;
			((OneDPhysicsSpring)(ref m_spring)).Spring = Spring;
			((OneDPhysicsSpring)(ref m_spring)).Update();
			((Component)this).transform.localRotation = Quaternion.Euler(new Vector3(0f, 0f, ((OneDPhysicsSpring)(ref m_spring)).Current));
		}

		private void FixedUpdate()
		{
			//IL_002e: 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)
			((OneDPhysicsSpring)(ref m_spring)).Target = (m_opened ? m_openedRotation : m_closedRotation);
			((OneDPhysicsSpring)(ref m_spring)).FixedUpdate();
			m_spring = SpringClamp.BounceClamp<OneDPhysicsSpring>(m_spring, Mathf.Min(m_openedRotation, m_closedRotation) - 5f, Mathf.Max(m_openedRotation, m_closedRotation) + 5f, 0.6f);
		}

		public bool IsFullyClosed()
		{
			if (m_opened)
			{
				return false;
			}
			if (Mathf.Abs(((OneDPhysicsSpring)(ref m_spring)).Current - m_closedRotation) < 3f)
			{
				return Mathf.Abs(((OneDPhysicsSpring)(ref m_spring)).Velocity) < 0.25f;
			}
			return false;
		}

		public bool IsHalfwayOpenForEject()
		{
			if (!m_opened)
			{
				return false;
			}
			float num = (m_closedRotation + m_openedRotation) * 0.5f;
			return ((OneDPhysicsSpring)(ref m_spring)).Current <= num + 5f;
		}

		public void Close()
		{
			SetOpenState(opened: false, playSfx: true, syncIfMaster: true);
		}

		public void Open()
		{
			SetOpenState(opened: true, playSfx: true, syncIfMaster: true);
		}

		public void SetOpenState(bool opened, bool playSfx, bool syncIfMaster)
		{
			if (m_opened != opened)
			{
				m_opened = opened;
				if (syncIfMaster && PhotonNetwork.IsMasterClient)
				{
					Machine.SyncHatchState();
				}
				if (playSfx)
				{
					Machine.PlayHatchSfx(opened);
				}
			}
		}
	}
	public static class Logger
	{
		private const string Prefix = "[ProgressionRebalance]";

		public static void Log(string message)
		{
			Debug.Log((object)("[ProgressionRebalance] " + message));
		}

		public static void LogWarning(string message)
		{
			Debug.LogWarning((object)("[ProgressionRebalance] " + message));
		}

		public static void LogError(string message)
		{
			Debug.LogError((object)("[ProgressionRebalance] " + message));
		}
	}
	internal class BigNumberTweaks
	{
		public static void ApplyTweaks()
		{
			Logger.Log("Applying BigNumber tweaks...");
			AssetBundle bundle = ProgressionRebalance.Bundle;
			BigNumbers instance = SingletonAsset<BigNumbers>.Instance;
			BigNumbers obj = bundle.LoadAsset<BigNumbers>("AdjustedBigNumbers");
			FieldInfo[] fields = typeof(BigNumbers).GetFields();
			foreach (FieldInfo fieldInfo in fields)
			{
				fieldInfo.SetValue(instance, fieldInfo.GetValue(obj));
			}
			Logger.Log("BigNumber tweaks applied!");
		}
	}
	public static class CustomItems
	{
		private static AssetBundle? _bundle;

		public static void Setup(AssetBundle bundle)
		{
			_bundle = bundle;
			Items.DeferRegistration((Action)delegate
			{
				RegisterSnailEgg();
			});
		}

		private static void RegisterSnailEgg()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//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)
			GameObject val = ContentLoader.LoadPrefabFromBundle(_bundle, "SnailEgg.prefab");
			val.AddComponent<SnailEggArtifactBehaviour>();
			GameMaterials.ApplyMaterial(val, (GameMaterial)26, true);
			ArtifactConfig val2 = new ArtifactConfig();
			((ItemConfig)val2).displayName = "Snail Egg";
			((ItemConfig)val2).persistentId = "progressionrebalance.snail_egg";
			((ItemConfig)val2).icon = GetSprite("snail_egg_icon");
			((ItemConfig)val2).impactSoundTypes = (ImpactSoundType[])(object)new ImpactSoundType[1] { (ImpactSoundType)7 };
			((ItemConfig)val2).holdPos = new Vector3(0.3f, -0.3f, 0.4f);
			((ItemConfig)val2).budgetCost = 3;
			((ItemConfig)val2).rarity = 1f;
			val2.contentValue = 75f;
			val2.comments = new string[2] { "is that an egg?", "please don't hatch that thing" };
			Items.RegisterArtifact(val, val2);
		}

		public static Sprite GetSprite(string iconName)
		{
			return _bundle.LoadAsset<Sprite>(iconName);
		}
	}
	internal static class HospitalBillTweaks
	{
		public const int BaseCostPerDeadPlayer = 50;

		public const int CostIncreasePerQuota = 25;

		public static int GetPerDeadPlayerCost(RoomStatsHolder roomStats)
		{
			return 50 + 25 * roomStats.CurrentRun;
		}

		public static int GetTotalBill(int perDeadPlayer, int deadCount)
		{
			return perDeadPlayer * deadCount;
		}
	}
	internal class ItemTweaks
	{
		public static void ApplyTweaks()
		{
			Item itemByPrefabComponent = Items.GetItemByPrefabComponent<Defib>();
			if ((Object)(object)itemByPrefabComponent != (Object)null)
			{
				itemByPrefabComponent.price = 500;
			}
			Item itemByPrefabComponent2 = Items.GetItemByPrefabComponent<ItemHugger>();
			if ((Object)(object)itemByPrefabComponent2 != (Object)null)
			{
				itemByPrefabComponent2.price = 300;
			}
			Item itemByCondition = getItemByCondition((Item item) => (Object)(object)item.itemObject.GetComponent<Flashlight>() != (Object)null && item.price == 600);
			if ((Object)(object)itemByCondition != (Object)null)
			{
				itemByCondition.price = 300;
			}
			Item itemByCondition2 = getItemByCondition((Item item) => item.displayName == "Apple");
			if ((Object)(object)itemByCondition2 != (Object)null)
			{
				itemByCondition2.price = 3;
			}
		}

		public static Item? getItemByCondition(Func<Item, bool> condition)
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = Items.GetObjectsField(instance);
			List<Item> itemsFromField = Items.GetItemsFromField(objectsField, instance);
			foreach (Item item in itemsFromField)
			{
				if (condition(item))
				{
					return item;
				}
			}
			return null;
		}
	}
	public class SnailEggArtifactBehaviour : ItemInstanceBehaviour, IArtifactContent
	{
		private const string ZombiePrefabName = "Zombe";

		private const int ZombiesToSpawn = 2;

		private const float HoldDuration = 3f;

		private IntRangeEntry chargesEntry;

		private StashAbleEntry stashAbleEntry;

		private float timeInHand;

		public bool IsHeld => base.isHeld;

		public bool IsActive => chargesEntry.selectedValue <= 0;

		private void Update()
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if (!base.isHeldByMe || !base.isSimulatedByMe || !base.isHeld)
			{
				return;
			}
			timeInHand += Time.deltaTime;
			if (!(timeInHand <= 3f))
			{
				timeInHand = 0f;
				if (chargesEntry.selectedValue > 0)
				{
					chargesEntry.selectedValue = 0;
					((ItemDataEntry)chargesEntry).SetDirty();
					BinarySerializer val = new BinarySerializer();
					Vector3 val2 = Player.localPlayer.Center();
					val.WriteFloat(val2.x);
					val.WriteFloat(val2.y);
					val.WriteFloat(val2.z);
					base.itemInstance.CallRPC((ItemRPC)0, val);
				}
			}
		}

		public override void ConfigItem(ItemInstanceData data, PhotonView playerView)
		{
			//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_0041: Expected O, but got Unknown
			//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_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			if (data.TryGetEntry<StashAbleEntry>(ref stashAbleEntry))
			{
				Logger.Log($"stashAbleEntry entry found, isStashAble: {stashAbleEntry.isStashAble}");
			}
			else
			{
				stashAbleEntry = new StashAbleEntry
				{
					isStashAble = false
				};
				data.AddDataEntry((ItemDataEntry)(object)stashAbleEntry);
				Logger.Log("stashAbleEntry entry not found, adding new entry with false.");
			}
			if (data.TryGetEntry<IntRangeEntry>(ref chargesEntry))
			{
				Logger.Log($"chargesEntry entry found, charges: {chargesEntry.selectedValue}");
			}
			else
			{
				chargesEntry = new IntRangeEntry
				{
					selectedValue = 1,
					maxValue = 1
				};
				data.AddDataEntry((ItemDataEntry)(object)chargesEntry);
				Logger.Log("chargesEntry entry not found, adding new entry with 1.");
			}
			base.itemInstance.RegisterRPC((ItemRPC)0, (Action<BinaryDeserializer>)RPCA_SpawnSnails);
		}

		private void RPCA_SpawnSnails(BinaryDeserializer deserializer)
		{
			//IL_002c: 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_00a5: 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_00e8: 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_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_013b: Unknown result type (might be due to invalid IL or missing references)
			if (!PhotonNetwork.IsMasterClient)
			{
				return;
			}
			float num = deserializer.ReadFloat();
			float num2 = deserializer.ReadFloat();
			float num3 = deserializer.ReadFloat();
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(num, num2, num3);
			Logger.Log($"RPCA_SpawnSnails: Received target position {val}");
			List<PatrolPoint> pointsOutsideMinDistanceSortedOnClosest = Level.currentLevel.GetPointsOutsideMinDistanceSortedOnClosest(ExtCollections.PToList<PatrolGroup>((PatrolGroup)4), val, 40f, 10f, false);
			Logger.Log($"RPCA_SpawnSnails: Found {pointsOutsideMinDistanceSortedOnClosest.Count} potential spawn points.");
			int num4 = 0;
			Player val2 = default(Player);
			foreach (PatrolPoint item in pointsOutsideMinDistanceSortedOnClosest)
			{
				if (num4 >= 2)
				{
					break;
				}
				if (PlayerHandler.instance.CanAnAlivePlayerSeePoint(((Component)item).transform.position, ref val2, (Player)null))
				{
					continue;
				}
				Logger.Log(string.Format("RPCA_SpawnSnails: Spawning {0} at {1}", "Zombe", ((Component)item).transform.position));
				GameObject val3 = MonsterSpawner.SpawnMonster("Zombe", ((Component)item).transform.position);
				if ((Object)(object)val3 != (Object)null)
				{
					Bot componentInChildren = val3.GetComponentInChildren<Bot>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						Logger.Log($"RPCA_SpawnSnails: Bot component found. Setting busy=true and targetPos={val}");
						componentInChildren.busy = true;
						componentInChildren.navTargetPos_Set = val;
						((MonoBehaviour)componentInChildren).StartCoroutine(MoveToTarget(componentInChildren, val));
					}
					else
					{
						Logger.LogWarning("RPCA_SpawnSnails: Spawned Zombe but no Bot component found in children!");
					}
				}
				else
				{
					Logger.LogError("RPCA_SpawnSnails: Failed to spawn Zombe!");
				}
				num4++;
			}
		}

		private IEnumerator MoveToTarget(Bot bot, Vector3 target)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Logger.Log($"MoveToTarget: Started for bot {((Object)bot).name} towards {target}");
			while ((Object)(object)bot != (Object)null && bot.busy)
			{
				float num = Vector3.Distance(bot.Center(), target);
				if (num < 1.5f)
				{
					Logger.Log($"MoveToTarget: Bot {((Object)bot).name} reached target (distance: {num}). Exiting busy mode.");
					bot.busy = false;
					bot.StandStill();
					yield break;
				}
				bot.Look(bot.navDirection_Read, 3f);
				bot.Walk();
				yield return null;
			}
			if ((Object)(object)bot == (Object)null)
			{
				Logger.LogWarning("MoveToTarget: Bot became null during movement.");
			}
			else if (!bot.busy)
			{
				Logger.Log("MoveToTarget: Bot " + ((Object)bot).name + " busy flag was cleared externally.");
			}
		}
	}
	public class MyPluginInfo
	{
		public const string PLUGIN_GUID = "db.progressionrebalance";

		public const string PLUGIN_NAME = "Progression Rebalance";

		public const string PLUGIN_VERSION = "0.1.0";

		public const bool VANILLA_COMPATIBLE = false;
	}
	[ContentWarningPlugin("db.progressionrebalance", "0.1.0", false)]
	[BepInPlugin("db.progressionrebalance", "Progression Rebalance", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class ProgressionRebalance : BaseUnityPlugin
	{
		private bool _isPatched;

		public static bool DEBUG_MODE;

		private string assetBundleName = "progressionrebalance";

		public static AssetBundle? Bundle { get; private set; }

		private Harmony? Harmony { get; set; }

		public static ProgressionRebalance Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			InitializeMod();
			BigNumberTweaks.ApplyTweaks();
			ItemTweaks.ApplyTweaks();
			PatchAll();
			Logger.Log("Plugin db.progressionrebalance is loaded!");
		}

		private void InitializeMod()
		{
			Logger.Log("Loading asset bundle...");
			Bundle = ContentLoader.LoadAssetBundle(Assembly.GetExecutingAssembly(), assetBundleName);
			if ((Object)(object)Bundle != (Object)null)
			{
				CustomItems.Setup(Bundle);
				ItemSellDropBoxContent.Init(Bundle);
			}
			else
			{
				Logger.LogError("Failed to load asset bundle");
			}
		}

		private void PatchAll()
		{
			//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_0032: Expected O, but got Unknown
			//IL_0037: Expected O, but got Unknown
			if (_isPatched)
			{
				Logger.LogError("Already patched!");
				return;
			}
			Logger.Log("Patching...");
			if (Harmony == null)
			{
				Harmony val = new Harmony("db.progressionrebalance");
				Harmony val2 = val;
				Harmony = val;
			}
			try
			{
				Harmony.PatchAll();
				_isPatched = true;
				Logger.Log("Patched!");
			}
			catch (Exception arg)
			{
				Logger.LogError($"Failed to patch: {arg}");
			}
		}

		public void UnpatchAll()
		{
			if (!_isPatched)
			{
				Logger.LogError("Already unpatched!");
				return;
			}
			Logger.Log("Unpatching...");
			try
			{
				Harmony? harmony = Harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
				_isPatched = false;
				Logger.Log("Unpatched!");
			}
			catch (Exception arg)
			{
				Logger.LogError($"Failed to unpatch: {arg}");
			}
		}
	}
}
namespace ProgressionRebalance.Patches
{
	[HarmonyPatch(typeof(SurfaceNetworkHandler), "CheckForHospitalBill")]
	internal static class HospitalBillPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(SurfaceNetworkHandler __instance)
		{
			List<Player> list = PhotonNetwork.CurrentRoom.Players.Values.ToList();
			List<(int, int)> hospitalBill = new List<(int, int)>();
			ICollection<Player> value = Traverse.Create(typeof(SurfaceNetworkHandler)).Field<ICollection<Player>>("PlayersAliveFromUnderWorld").Value;
			if (value != null)
			{
				foreach (Player alivePlayer in value)
				{
					Player val = list.Find((Player p) => p.ActorNumber == alivePlayer.refs.view.OwnerActorNr);
					if (val != null)
					{
						list.Remove(val);
					}
				}
			}
			int count = list.Count;
			if (count == 0)
			{
				Logger.Log("Hospital bill: no dead players, skipping.");
				return false;
			}
			RoomStatsHolder roomStats = SurfaceNetworkHandler.RoomStats;
			int perDeadPlayerCost = HospitalBillTweaks.GetPerDeadPlayerCost(roomStats);
			int totalBill = HospitalBillTweaks.GetTotalBill(perDeadPlayerCost, count);
			string text = "Checking Hospital Bill, Dead Players Are: ";
			foreach (Player item in list)
			{
				text = text + item.NickName + " ID: " + item.ActorNumber + " \n";
				hospitalBill.Add((item.ActorNumber, perDeadPlayerCost));
			}
			MonoFunctions.instance.DelayCall((Action)delegate
			{
				Traverse.Create((object)__instance).Method("SendHospitalBill", new object[1] { hospitalBill }).GetValue();
			}, 3f);
			text = text + " Per-dead fee: $" + perDeadPlayerCost + " Total Bill is: $" + totalBill + " (quota run " + roomStats.CurrentRun + ")";
			Debug.Log((object)text);
			Logger.Log(text);
			return false;
		}
	}
	[HarmonyPatch(typeof(DivingBell), "Awake")]
	internal static class SpawnItemSellDropBoxPatch
	{
		[HarmonyPostfix]
		public static void Postfix(DivingBell __instance)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (!(((Scene)(ref activeScene)).name != "SurfaceScene"))
			{
				SetupItemSellDropbox();
			}
		}

		private static void SetupItemSellDropbox()
		{
			//IL_0041: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			GameObject sellDropboxPrefab = ItemSellDropBoxContent.SellDropboxPrefab;
			if ((Object)(object)sellDropboxPrefab == (Object)null)
			{
				Logger.LogError("ProgressionRebalance: SellItemDropbox prefab is null; sell hatch not spawned.");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(sellDropboxPrefab);
			((Object)val).name = "SellItemDropbox";
			val.transform.localPosition = new Vector3(0.34f, 0.772f, 8.66f);
			val.transform.localEulerAngles = new Vector3(0f, 24.91f, 0f);
			val.transform.localScale = new Vector3(0.6f, 0.6f, 0.6f);
			Transform obj = val.transform.Find("Dropbox");
			GameObject val2 = ((obj != null) ? ((Component)obj).gameObject : null);
			Transform obj2 = val.transform.Find("DropboxFrontText");
			GameObject val3 = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			Transform obj3 = val.transform.Find("Vents");
			GameObject val4 = ((obj3 != null) ? ((Component)obj3).gameObject : null);
			Transform obj4 = val.transform.Find("Wheels");
			GameObject val5 = ((obj4 != null) ? ((Component)obj4).gameObject : null);
			Transform obj5 = val.transform.Find("LidPivot");
			GameObject val6 = ((obj5 != null) ? ((Component)obj5).gameObject : null);
			object obj6;
			if (val6 == null)
			{
				obj6 = null;
			}
			else
			{
				Transform obj7 = val6.transform.Find("Lid");
				obj6 = ((obj7 != null) ? ((Component)obj7).gameObject : null);
			}
			GameObject val7 = (GameObject)obj6;
			Transform obj8 = val.transform.Find("UpgradeDetectionZone");
			GameObject val8 = ((obj8 != null) ? ((Component)obj8).gameObject : null);
			if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null || (Object)(object)val5 == (Object)null || (Object)(object)val6 == (Object)null || (Object)(object)val7 == (Object)null || (Object)(object)val8 == (Object)null)
			{
				Logger.LogError("ProgressionRebalance: SellItemDropbox prefab hierarchy is incomplete; sell hatch not wired.");
				Object.Destroy((Object)(object)val);
				return;
			}
			PhotonView val9 = val.AddComponent<PhotonView>();
			val9.ViewID = 997;
			ItemSellDropBox itemSellDropBox = val.AddComponent<ItemSellDropBox>();
			itemSellDropBox.Particles = ((Component)val.transform.Find("Particles")).gameObject;
			ItemSellDropBoxItemDetector detector = val8.AddComponent<ItemSellDropBoxItemDetector>();
			ItemSellDropBoxLid itemSellDropBoxLid = val6.AddComponent<ItemSellDropBoxLid>();
			itemSellDropBox.Detector = detector;
			itemSellDropBox.Lid = itemSellDropBoxLid;
			itemSellDropBoxLid.Machine = itemSellDropBox;
			ApplyDropboxMaterials(val2, val3, val4, val5, val7);
			ObjectHelper.FixShadersForCurrentScene(val);
			Logger.Log("ProgressionRebalance: Item sell hatch spawned on SurfaceScene.");
		}

		private static void ApplyDropboxMaterials(GameObject dropboxChild, GameObject dropboxFrontTextChild, GameObject dropboxVents, GameObject dropboxWheels, GameObject dropboxLid)
		{
			GameMaterials.ApplyMaterial(dropboxChild, (GameMaterial)301, true);
			GameMaterials.ApplyMaterial(dropboxFrontTextChild, (GameMaterial)301, true);
			MeshRenderer component = dropboxVents.GetComponent<MeshRenderer>();
			((Renderer)component).materials = (Material[])(object)new Material[2]
			{
				GameMaterials.GetMaterial((GameMaterial)302),
				GameMaterials.GetMaterial((GameMaterial)302)
			};
			GameMaterials.ApplyMaterial(dropboxWheels, (GameMaterial)34, true);
			MeshRenderer component2 = dropboxLid.GetComponent<MeshRenderer>();
			((Renderer)component2).materials = (Material[])(object)new Material[2]
			{
				GameMaterials.GetMaterial((GameMaterial)302),
				GameMaterials.GetMaterial((GameMaterial)304)
			};
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}