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.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.Rendering;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: AssemblyCompany("UpgradableStats")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.4.0")]
[assembly: AssemblyInformationalVersion("1.1.4")]
[assembly: AssemblyProduct("Upgradable Stats")]
[assembly: AssemblyTitle("UpgradableStats")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 UpgradableStats
{
	internal static class HudFigure
	{
		internal static RectTransform Anchor()
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.selfRedCanvasGroup == (Object)null)
			{
				return null;
			}
			return ((Component)instance.selfRedCanvasGroup).GetComponent<RectTransform>();
		}

		internal static RectTransform NewSibling(string name, Vector2 sizeFactor, Vector2 offsetFactor, Vector2 extraOffset)
		{
			//IL_0025: 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_0063: 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_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_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_00a0: 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_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_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_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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)
			RectTransform val = Anchor();
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)component).SetParent(((Transform)val).parent, false);
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex() + 1);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(0.5f, 0.5f);
			component.anchorMax = val2;
			component.anchorMin = val2;
			component.pivot = new Vector2(0.5f, 0.5f);
			Rect rect = val.rect;
			float width = ((Rect)(ref rect)).width;
			rect = val.rect;
			float height = ((Rect)(ref rect)).height;
			component.sizeDelta = new Vector2(width * sizeFactor.x, height * sizeFactor.y);
			((Transform)component).localPosition = ((Transform)val).localPosition + new Vector3(width * offsetFactor.x + extraOffset.x, height * offsetFactor.y + extraOffset.y, 0f);
			((Transform)component).localRotation = Quaternion.identity;
			((Transform)component).localScale = Vector3.one;
			return component;
		}

		internal static Sprite SpriteFromRows(string[] rows, Color mainColor, Color darkColor, Color gemColor)
		{
			//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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected O, but got Unknown
			//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_00a6: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			int num = rows.Length;
			int num2 = rows.Max((string r) => r.Length);
			Color val = default(Color);
			((Color)(ref val))..ctor(0f, 0f, 0f, 0f);
			Texture2D val2 = new Texture2D(num2, num, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			for (int num3 = 0; num3 < num; num3++)
			{
				string text = rows[num - 1 - num3];
				for (int num4 = 0; num4 < num2; num4++)
				{
					val2.SetPixel(num4, num3, (Color)(((num4 < text.Length) ? text[num4] : '.') switch
					{
						'X' => gemColor, 
						'd' => darkColor, 
						'g' => mainColor, 
						_ => val, 
					}));
				}
			}
			val2.Apply();
			return Sprite.Create(val2, new Rect(0f, 0f, (float)num2, (float)num), new Vector2(0.5f, 0.5f), 100f);
		}
	}
	internal static class CrownIndicator
	{
		private static Image _crown;

		private static AudioClip _glassClip;

		private static bool _searchedClip;

		internal static void Tick()
		{
			bool flag = StatsEffects.HasSecondWind && !StatsEffects.SecondWindActive && (Object)(object)GameNetworkManager.Instance != (Object)null && (Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null && !GameNetworkManager.Instance.localPlayerController.isPlayerDead;
			if ((Object)(object)_crown == (Object)null)
			{
				if (!flag)
				{
					return;
				}
				Build();
				if ((Object)(object)_crown == (Object)null)
				{
					return;
				}
			}
			if (((Behaviour)_crown).enabled != flag)
			{
				((Behaviour)_crown).enabled = flag;
			}
		}

		private static void Build()
		{
			//IL_000f: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = HudFigure.NewSibling("SecondWindCrown[UpgradableStats]", new Vector2(0.42f, 0.16f), new Vector2(0f, 0.62f), new Vector2(0f, 4f));
			if (!((Object)(object)val == (Object)null))
			{
				_crown = ((Component)val).gameObject.AddComponent<Image>();
				_crown.sprite = BuildCrownSprite();
				_crown.preserveAspect = true;
				((Graphic)_crown).raycastTarget = false;
				((Behaviour)_crown).enabled = false;
				Plugin.Log.LogInfo((object)"Corona del segundo aliento creada (anclada a la figura).");
			}
		}

		private static Sprite BuildCrownSprite()
		{
			//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_0067: 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_0069: Unknown result type (might be due to invalid IL or missing references)
			Color white = Color.white;
			return HudFigure.SpriteFromRows(new string[11]
			{
				".g.....g.....g...", ".gg...g.g...gg...", ".g.g..g.g..g.g...", ".g..g.g.g.g..g...", ".g...gg.gg...g...", ".g...........g...", ".ggggggggggggg...", ".g.....g.....g...", ".g....g.g....g...", ".g.....g.....g...",
				".ggggggggggggg..."
			}, white, white, white);
		}

		internal static void PlayBreakSound()
		{
			AudioClip val = FindGlassClip();
			if (!((Object)(object)val == (Object)null) && !((Object)(object)HUDManager.Instance == (Object)null) && !((Object)(object)HUDManager.Instance.UIAudio == (Object)null))
			{
				HUDManager.Instance.UIAudio.PlayOneShot(val, 0.4f);
			}
		}

		private static AudioClip FindGlassClip()
		{
			if ((Object)(object)_glassClip != (Object)null || _searchedClip)
			{
				return _glassClip;
			}
			_searchedClip = true;
			string[] obj = new string[5] { "glassbreak", "glassshatter", "shatter", "glass", "windowbreak" };
			AudioClip[] source = Resources.FindObjectsOfTypeAll<AudioClip>();
			string[] array = obj;
			foreach (string key in array)
			{
				_glassClip = ((IEnumerable<AudioClip>)source).FirstOrDefault((Func<AudioClip, bool>)((AudioClip c) => (Object)(object)c != (Object)null && ((Object)c).name.ToLowerInvariant().Contains(key)));
				if ((Object)(object)_glassClip != (Object)null)
				{
					Plugin.Log.LogInfo((object)("Sonido de vidrio: usando el clip del juego \"" + ((Object)_glassClip).name + "\"."));
					return _glassClip;
				}
			}
			_glassClip = SynthesizeGlass();
			Plugin.Log.LogInfo((object)"Sonido de vidrio: no encontré clip del juego, usando uno sintetizado.");
			return _glassClip;
		}

		private static AudioClip SynthesizeGlass()
		{
			int num = 15435;
			float[] array = new float[num];
			Random random = new Random(1234);
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / (float)num;
				float num3 = Mathf.Pow(1f - num2, 2.6f);
				float num4 = (float)(random.NextDouble() * 2.0 - 1.0) * 0.55f;
				float num5 = Mathf.Sin(MathF.PI * 7600f * (float)i / 44100f) * 0.25f;
				float num6 = Mathf.Sin(MathF.PI * 11200f * (float)i / 44100f) * 0.18f;
				array[i] = (num4 + num5 + num6) * num3 * 0.5f;
			}
			AudioClip obj = AudioClip.Create("GlassBreakSynth", num, 1, 44100, false);
			obj.SetData(array, 0);
			return obj;
		}
	}
	internal static class StrengthArms
	{
		private static Image _left;

		private static Image _right;

		private static int _builtLevel = -1;

		private static Sprite[] _sprites;

		internal static void Tick()
		{
			int level = Plugin.LocalUpgrades.GetLevel(UpgradeSkill.Strength);
			if (level <= 0)
			{
				if ((Object)(object)_left != (Object)null)
				{
					((Behaviour)_left).enabled = false;
					((Behaviour)_right).enabled = false;
				}
				_builtLevel = 0;
				return;
			}
			if ((Object)(object)_left == (Object)null)
			{
				Build();
				if ((Object)(object)_left == (Object)null)
				{
					return;
				}
			}
			if (_builtLevel != level)
			{
				Sprite sprite = GetSprite(level);
				_left.sprite = sprite;
				_right.sprite = sprite;
				_builtLevel = level;
			}
			if (!((Behaviour)_left).enabled)
			{
				((Behaviour)_left).enabled = true;
				((Behaviour)_right).enabled = true;
			}
		}

		private static void Build()
		{
			//IL_000f: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: 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)
			RectTransform val = HudFigure.NewSibling("StrengthArmL[UpgradableStats]", new Vector2(0.38f, 0.34f), new Vector2(-0.34f, 0.12f), Vector2.zero);
			if (!((Object)(object)val == (Object)null))
			{
				RectTransform obj = HudFigure.NewSibling("StrengthArmR[UpgradableStats]", new Vector2(0.38f, 0.34f), new Vector2(0.34f, 0.12f), Vector2.zero);
				((Transform)obj).localScale = new Vector3(-1f, 1f, 1f);
				_left = ((Component)val).gameObject.AddComponent<Image>();
				_right = ((Component)obj).gameObject.AddComponent<Image>();
				Image[] array = (Image[])(object)new Image[2] { _left, _right };
				foreach (Image obj2 in array)
				{
					obj2.preserveAspect = true;
					((Graphic)obj2).raycastTarget = false;
					((Graphic)obj2).color = new Color(1f, 1f, 1f, 0.95f);
					((Behaviour)obj2).enabled = false;
				}
				Plugin.Log.LogInfo((object)"Brazos de fuerza creados en la figura del HUD.");
			}
		}

		private static Sprite GetSprite(int level)
		{
			if (_sprites == null)
			{
				_sprites = (Sprite[])(object)new Sprite[3];
			}
			int num = Mathf.Clamp(level, 1, 3) - 1;
			if ((Object)(object)_sprites[num] == (Object)null)
			{
				_sprites[num] = BuildArmSprite(level);
			}
			return _sprites[num];
		}

		private static Sprite BuildArmSprite(int level)
		{
			//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_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: 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)
			Color white = Color.white;
			return HudFigure.SpriteFromRows(level switch
			{
				1 => new string[12]
				{
					"....................", "....................", "..............ggg...", "...........gggggg...", "........ggggggg.....", ".....ggggggg........", "...ggggggg..........", "..gggggg............", "..ggggg.............", "..gggg..............",
					"...gg...............", "...................."
				}, 
				2 => new string[12]
				{
					"....................", "..............gggg..", "..........gggggggg..", ".......ggggggggg....", ".....gggggggggg.....", "....ggggggggg.......", "...gggggggg.........", "..ggggggg...........", "..gggggg............", "..ggggg.............",
					"...ggg..............", "...................."
				}, 
				_ => new string[12]
				{
					"...gggg.............", "..gggggg............", "..gggggg............", "..ggggggg...........", "...gggggg...........", "...ggggggg......ggg.", "....gggggggg..ggggg.", ".....ggggggggggggg..", "......ggggggggggg...", ".......ggggggggg....",
					"....................", "...................."
				}, 
			}, white, white, white);
		}
	}
	public class MachineScreenFx : MonoBehaviour
	{
		private static readonly Color Celeste = new Color(0.45f, 0.85f, 1f, 0.95f);

		private RectTransform _figure;

		private readonly RectTransform[] _particles = (RectTransform[])(object)new RectTransform[3];

		private readonly Quaternion[] _orbitTilts = (Quaternion[])(object)new Quaternion[3]
		{
			Quaternion.Euler(72f, 0f, 0f),
			Quaternion.Euler(72f, 0f, 60f),
			Quaternion.Euler(72f, 0f, -60f)
		};

		private readonly float[] _speeds = new float[3] { 2f, 2.6f, 3.3f };

		private readonly float[] _phases = new float[3] { 0f, 2.1f, 4.2f };

		private const float OrbitRadius = 16f;

		private float _t;

		private void Start()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_004c: 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_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_00e9: 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)
			GameObject val = new GameObject("Empleado", new Type[1] { typeof(RectTransform) });
			_figure = val.GetComponent<RectTransform>();
			((Transform)_figure).SetParent(((Component)this).transform, false);
			_figure.sizeDelta = new Vector2(20f, 30f);
			Image obj = val.AddComponent<Image>();
			obj.sprite = FindEmployeeSprite();
			((Graphic)obj).color = Celeste;
			obj.preserveAspect = true;
			((Graphic)obj).raycastTarget = false;
			Sprite sprite = BuildDotSprite();
			for (int i = 0; i < _particles.Length; i++)
			{
				GameObject val2 = new GameObject($"Particula{i}", new Type[1] { typeof(RectTransform) });
				_particles[i] = val2.GetComponent<RectTransform>();
				((Transform)_particles[i]).SetParent(((Component)this).transform, false);
				_particles[i].sizeDelta = new Vector2(3.2f, 3.2f);
				Image obj2 = val2.AddComponent<Image>();
				obj2.sprite = sprite;
				((Graphic)obj2).color = Celeste;
				((Graphic)obj2).raycastTarget = false;
			}
		}

		private void Update()
		{
			//IL_003c: 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_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00d9: 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)
			_t += Time.deltaTime;
			if ((Object)(object)_figure != (Object)null)
			{
				((Transform)_figure).localRotation = Quaternion.Euler(0f, _t * 85f, 0f);
			}
			for (int i = 0; i < _particles.Length; i++)
			{
				if (!((Object)(object)_particles[i] == (Object)null))
				{
					float num = _t * _speeds[i] + _phases[i];
					Vector3 val = _orbitTilts[i] * new Vector3(Mathf.Cos(num) * 16f, 0f, Mathf.Sin(num) * 16f);
					((Transform)_particles[i]).localPosition = val;
					float num2 = Mathf.InverseLerp(16f, -16f, val.z);
					((Transform)_particles[i]).localScale = Vector3.one * Mathf.Lerp(0.7f, 1.25f, num2);
				}
			}
		}

		private static Sprite FindEmployeeSprite()
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.selfRedCanvasGroup != (Object)null)
			{
				Image componentInChildren = ((Component)instance.selfRedCanvasGroup).GetComponentInChildren<Image>(true);
				if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.sprite != (Object)null)
				{
					return componentInChildren.sprite;
				}
				Transform parent = ((Component)instance.selfRedCanvasGroup).transform.parent;
				if ((Object)(object)parent != (Object)null)
				{
					Image[] componentsInChildren = ((Component)parent).GetComponentsInChildren<Image>(true);
					foreach (Image val in componentsInChildren)
					{
						if ((Object)(object)val.sprite != (Object)null)
						{
							return val.sprite;
						}
					}
				}
			}
			Plugin.Log.LogWarning((object)"No encontré el sprite del empleado; uso el de respaldo.");
			return BuildFallbackFigure();
		}

		private static Sprite BuildFallbackFigure()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			return HudFigure.SpriteFromRows(new string[15]
			{
				"....gggg....", "...g....g...", "...g....g...", "....gggg....", ".....gg.....", "..gggggggg..", ".g...gg...g.", "g....gg....g", "g....gg....g", ".....gg.....",
				"....g..g....", "....g..g....", "...g....g...", "...g....g...", "..g......g.."
			}, Color.white, Color.white, Color.white);
		}

		private static Sprite BuildDotSprite()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0097: 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_0025: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(12, 12, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1
			};
			float num = 5.5f;
			for (int i = 0; i < 12; i++)
			{
				for (int j = 0; j < 12; j++)
				{
					float num2 = Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(num, num)) / num;
					float num3 = Mathf.Clamp01(1f - num2);
					val.SetPixel(j, i, new Color(1f, 1f, 1f, num3 * num3));
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 12f, 12f), new Vector2(0.5f, 0.5f), 100f);
		}
	}
	internal static class Patches
	{
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		internal static class GameNetworkManager_Start
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				TokenItem.RegisterNetworkPrefab();
				UpgradesMachine.RegisterNetworkPrefab();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		internal static class StartOfRound_Awake
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				TokenItem.SetupEarlyInGame();
				UpgradesMachine.RegisterUnlockable();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		internal static class StartOfRound_Start
		{
			[HarmonyPostfix]
			private static void Postfix(StartOfRound __instance)
			{
				TokenItem.SetupInGame();
				((MonoBehaviour)__instance).StartCoroutine(UpgradesMachine.SpawnRoutine());
				((MonoBehaviour)__instance).StartCoroutine(UpgradeSync.SessionStartRoutine());
				((MonoBehaviour)__instance).StartCoroutine(FixRemoteSlotsWhenReady());
			}

			private static IEnumerator FixRemoteSlotsWhenReady()
			{
				yield return (object)new WaitForSeconds(2f);
				UpgradeSync.EnsureRemotePlayersSlots();
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		internal static class PlayerControllerB_Jump
		{
			[HarmonyPrefix]
			private static void Prefix(PlayerControllerB __instance, ref float __state)
			{
				__state = -1f;
				if (StatsEffects.IsLocal(__instance) && Plugin.LocalUpgrades.HasGoodLegs)
				{
					__state = __instance.sprintMeter;
				}
			}

			[HarmonyPostfix]
			private static void Postfix(PlayerControllerB __instance, float __state)
			{
				if (__state >= 0f && __instance.sprintMeter < __state)
				{
					__instance.sprintMeter = __state;
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "AutoSaveShipData")]
		internal static class StartOfRound_AutoSaveShipData
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				UpgradeSync.SaveNow();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ResetShip")]
		internal static class StartOfRound_ResetShip
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				StatsEffects.ResetEverything();
				UpgradeSync.ClearAllSavedLevels();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "ReviveDeadPlayers")]
		internal static class StartOfRound_ReviveDeadPlayers
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				StatsEffects.ReapplyAll(((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			}
		}

		internal struct DamageState
		{
			internal int Prev;

			internal int Expected;

			internal bool SecondWind;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
		internal static class PlayerControllerB_DamagePlayer
		{
			[HarmonyPrefix]
			private static void Prefix(PlayerControllerB __instance, ref int damageNumber, ref DamageState __state)
			{
				__state = new DamageState
				{
					Prev = -1,
					Expected = -1
				};
				if (!StatsEffects.IsLocal(__instance) || !((NetworkBehaviour)__instance).IsOwner || __instance.isPlayerDead)
				{
					return;
				}
				int health = __instance.health;
				bool secondWind = false;
				int expected;
				if (health - damageNumber <= 0)
				{
					if (!__instance.criticallyInjured && damageNumber < 50)
					{
						expected = 5;
					}
					else if (StatsEffects.HasSecondWind && !StatsEffects.SecondWindActive && health > 1)
					{
						expected = 1;
						secondWind = true;
						damageNumber = health - 1;
						Plugin.Log.LogInfo((object)"¡Segundo aliento! Sobrevives con 1 HP.");
					}
					else
					{
						expected = 0;
					}
				}
				else
				{
					expected = Mathf.Clamp(health - damageNumber, 0, StatsEffects.MaxHealth);
				}
				__state = new DamageState
				{
					Prev = health,
					Expected = expected,
					SecondWind = secondWind
				};
			}

			[HarmonyPostfix]
			private static void Postfix(PlayerControllerB __instance, DamageState __state)
			{
				if (__state.SecondWind && !__instance.isPlayerDead)
				{
					StatsEffects.NotifySecondWind();
				}
				if (__state.Prev >= 0 && __state.Expected > 0 && !__instance.isPlayerDead && __instance.health != __state.Prev && __instance.health != __state.Expected)
				{
					__instance.health = __state.Expected;
					if ((Object)(object)HUDManager.Instance != (Object)null)
					{
						HUDManager.Instance.UpdateHealthUI(__instance.health, false);
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		internal static class PlayerControllerB_KillPlayer
		{
			[HarmonyPrefix]
			private static bool Prefix(PlayerControllerB __instance, CauseOfDeath causeOfDeath, int deathAnimation)
			{
				//IL_00b7: 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)
				if (!StatsEffects.IsLocal(__instance))
				{
					return true;
				}
				if (!((NetworkBehaviour)__instance).IsOwner || __instance.isPlayerDead)
				{
					return true;
				}
				if (!StatsEffects.HasSecondWind || StatsEffects.SecondWindActive)
				{
					return true;
				}
				if (__instance.health <= 1)
				{
					return true;
				}
				if (!IsSurvivable(__instance, causeOfDeath, deathAnimation))
				{
					return true;
				}
				__instance.health = 1;
				if ((Object)(object)HUDManager.Instance != (Object)null)
				{
					HUDManager.Instance.UpdateHealthUI(1, true);
				}
				StatsEffects.NotifySecondWind();
				EnemyAI inAnimationWithEnemy = __instance.inAnimationWithEnemy;
				__instance.inAnimationWithEnemy = null;
				__instance.inSpecialInteractAnimation = false;
				__instance.snapToServerPosition = false;
				__instance.disableMoveInput = false;
				__instance.disableLookInput = false;
				if ((Object)(object)inAnimationWithEnemy != (Object)null)
				{
					try
					{
						inAnimationWithEnemy.SetEnemyStunned(true, 5f, __instance);
					}
					catch
					{
					}
				}
				Plugin.Log.LogInfo((object)$"¡Segundo aliento! Sobreviviste a una muerte instantánea ({causeOfDeath}).");
				return false;
			}

			private static bool IsSurvivable(PlayerControllerB p, CauseOfDeath cause, int deathAnimation)
			{
				//IL_0000: 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_0004: Invalid comparison between Unknown and I4
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Invalid comparison between Unknown and I4
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				if (cause - 3 <= 1 || (int)cause == 8)
				{
					return true;
				}
				if ((int)cause == 0 && deathAnimation == 1)
				{
					DressGirlAI[] array = Object.FindObjectsOfType<DressGirlAI>();
					foreach (DressGirlAI val in array)
					{
						if ((Object)(object)val != (Object)null && (Object)(object)val.hauntingPlayer == (Object)(object)p)
						{
							return true;
						}
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(Shovel), "HitShovel")]
		internal static class Shovel_HitShovel
		{
			[HarmonyPrefix]
			private static void Prefix(Shovel __instance, ref int __state)
			{
				__state = -1;
				if (StatsEffects.IsLocal(__instance.previousPlayerHeldBy))
				{
					float meleeMultiplier = StatsEffects.MeleeMultiplier;
					if (!(meleeMultiplier <= 1f))
					{
						__state = __instance.shovelHitForce;
						__instance.shovelHitForce = Mathf.Max(1, Mathf.RoundToInt((float)__state * meleeMultiplier));
					}
				}
			}

			[HarmonyPostfix]
			private static void Postfix(Shovel __instance, int __state)
			{
				if (__state >= 0)
				{
					__instance.shovelHitForce = __state;
				}
			}
		}

		[HarmonyPatch(typeof(KnifeItem), "HitKnife")]
		internal static class KnifeItem_HitKnife
		{
			[HarmonyPrefix]
			private static void Prefix(KnifeItem __instance, ref int __state)
			{
				__state = -1;
				if (StatsEffects.IsLocal(__instance.previousPlayerHeldBy))
				{
					float meleeMultiplier = StatsEffects.MeleeMultiplier;
					if (!(meleeMultiplier <= 1f))
					{
						__state = __instance.knifeHitForce;
						__instance.knifeHitForce = Mathf.Max(1, Mathf.RoundToInt((float)__state * meleeMultiplier));
					}
				}
			}

			[HarmonyPostfix]
			private static void Postfix(KnifeItem __instance, int __state)
			{
				if (__state >= 0)
				{
					__instance.knifeHitForce = __state;
				}
			}
		}

		[HarmonyPatch(typeof(TetraChemicalItem), "Update")]
		internal static class TetraChemicalItem_Update
		{
			private static float _healAccumulator;

			[HarmonyPostfix]
			private static void Postfix(TetraChemicalItem __instance)
			{
				if (!__instance.emittingGas || __instance.fuel <= 0f)
				{
					return;
				}
				PlayerControllerB playerHeldBy = ((GrabbableObject)__instance).playerHeldBy;
				if (!StatsEffects.IsLocal(playerHeldBy) || playerHeldBy.isPlayerDead || playerHeldBy.health >= StatsEffects.MaxHealth)
				{
					return;
				}
				_healAccumulator += Time.deltaTime / 38f * 198f;
				int num = (int)_healAccumulator;
				if (num <= 0)
				{
					StatsEffects.LastTzpHealTime = Time.time;
					return;
				}
				_healAccumulator -= num;
				playerHeldBy.health = Mathf.Min(playerHeldBy.health + num, StatsEffects.MaxHealth);
				StatsEffects.LastTzpHealTime = Time.time;
				if (playerHeldBy.health >= 20 && playerHeldBy.criticallyInjured)
				{
					playerHeldBy.MakeCriticallyInjured(false);
				}
				if ((Object)(object)HUDManager.Instance != (Object)null)
				{
					HUDManager.Instance.UpdateHealthUI(playerHeldBy.health, false);
				}
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "Start")]
		internal static class GrabbableObject_Start
		{
			[HarmonyPostfix]
			private static void Postfix(GrabbableObject __instance)
			{
				if (TokenItem.IsToken(__instance))
				{
					__instance.SetScrapValue(Plugin.TokenSellValue.Value);
					if (Plugin.TokenGlowEnabled.Value && (Object)(object)((Component)__instance).GetComponent<TokenGlow>() == (Object)null)
					{
						((Component)__instance).gameObject.AddComponent<TokenGlow>();
					}
				}
			}
		}

		[HarmonyPatch(typeof(Terminal), "LoadNewNodeIfAffordable")]
		internal static class Terminal_LoadNewNodeIfAffordable
		{
			[HarmonyPrefix]
			private static void Prefix(Terminal __instance, TerminalNode node)
			{
				SecretCode.RememberAttempt(__instance, node);
				SecretCode.BeforePurchase(__instance);
			}

			[HarmonyPostfix]
			private static void Postfix(Terminal __instance, TerminalNode node)
			{
				SecretCode.AfterPurchase(__instance);
				SecretCode.AttemptFinished(__instance, node);
			}
		}

		[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
		internal static class Terminal_ParsePlayerSentence
		{
			[HarmonyPrefix]
			private static bool Prefix(Terminal __instance, ref TerminalNode __result)
			{
				if ((Object)(object)__instance.screenText == (Object)null)
				{
					return true;
				}
				string text = __instance.screenText.text;
				if (string.IsNullOrEmpty(text) || __instance.textAdded <= 0)
				{
					return true;
				}
				if (__instance.textAdded > text.Length)
				{
					return true;
				}
				if (!SecretCode.IsCode(text.Substring(text.Length - __instance.textAdded)))
				{
					return true;
				}
				TerminalNode val = SecretCode.OnCodeTyped(__instance);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				__result = val;
				return false;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetInSpecialMenu")]
		internal static class PlayerControllerB_SetInSpecialMenu
		{
			[HarmonyPostfix]
			private static void Postfix(bool setInMenu)
			{
				if (!setInMenu && UpgradeMenuUI.IsOpen)
				{
					UpgradeMenuUI.Close();
				}
			}
		}
	}
	[BepInPlugin("com.CommanderMechavala.upgradablestats", "Upgradable Stats", "1.1.4")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.CommanderMechavala.upgradablestats";

		public const string PluginName = "Upgradable Stats";

		public const string PluginVersion = "1.1.4";

		internal static ManualLogSource Log;

		internal static readonly PlayerUpgrades LocalUpgrades = new PlayerUpgrades();

		internal static ConfigEntry<float> OffsetX;

		internal static ConfigEntry<float> OffsetY;

		internal static ConfigEntry<float> OffsetZ;

		internal static ConfigEntry<float> MachineRotationY;

		internal static ConfigEntry<bool> FreeUpgrades;

		internal static ConfigEntry<int> TokenBuyPrice;

		internal static ConfigEntry<int> TokenSellValue;

		internal static ConfigEntry<int> TokenFallbackRarity;

		internal static ConfigEntry<int> RefundCredits;

		internal static ConfigEntry<bool> TokenGlowEnabled;

		internal static ConfigEntry<bool> StaminaBarVisual;

		internal static ConfigEntry<bool> PocketFlashlightEnabled;

		private readonly Harmony _harmony = new Harmony("com.CommanderMechavala.upgradablestats");

		internal static Vector3 MachineOffset => new Vector3(OffsetX.Value, OffsetY.Value, OffsetZ.Value);

		private void Awake()
		{
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			OffsetX = ((BaseUnityPlugin)this).Config.Bind<float>("Machine", "OffsetX", -1.6f, "Position relative to the terminal: sideways (negative = left).");
			OffsetY = ((BaseUnityPlugin)this).Config.Bind<float>("Machine", "OffsetY", 0f, "Position relative to the terminal: height.");
			OffsetZ = ((BaseUnityPlugin)this).Config.Bind<float>("Machine", "OffsetZ", 0f, "Position relative to the terminal: forward/back.");
			MachineRotationY = ((BaseUnityPlugin)this).Config.Bind<float>("Machine", "RotationY", 0f, "Extra rotation of the machine, in degrees.");
			FreeUpgrades = ((BaseUnityPlugin)this).Config.Bind<bool>("Fichas", "FreeUpgrades", false, "true = upgrades don't consume Fichas (for testing).");
			TokenBuyPrice = ((BaseUnityPlugin)this).Config.Bind<int>("Fichas", "BuyPrice", 450, "Credits a Ficha costs at the terminal (\"buy ficha\").");
			TokenSellValue = ((BaseUnityPlugin)this).Config.Bind<int>("Fichas", "ScrapValue", 200, "Scrap value of a Ficha — what the Company pays for it.");
			TokenGlowEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Fichas", "FloorGlow", true, "Golden legendary-style aura on Fichas lying on the floor.");
			RefundCredits = ((BaseUnityPlugin)this).Config.Bind<int>("Fichas", "RefundCredits", 200, "Credits refunded to the terminal when removing an upgrade with [-].");
			TokenFallbackRarity = ((BaseUnityPlugin)this).Config.Bind<int>("Fichas", "FallbackRarity", 8, "Spawn rarity used only on moons that have no Gift to copy it from.");
			StaminaBarVisual = ((BaseUnityPlugin)this).Config.Bind<bool>("Interface", "StaminaBar", true, "Show the extra stamina bar granted by your upgrades.");
			PocketFlashlightEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Extras", "FlashlightKeyF", true, "Toggle the flashlight with [F] even while it's stowed in your inventory.");
			TokenItem.CreateEarly();
			UpgradesMachine.CreatePrefabEarly();
			GameObject val = new GameObject("UpgradableStats_Runtime");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			val.AddComponent<UpgradeRuntime>();
			_harmony.PatchAll(typeof(Patches).Assembly);
			Log.LogInfo((object)"¡Upgradable Stats v1.1.4 cargado correctamente!");
			Log.LogInfo((object)"Fase 3: fichas (aparecen como el Regalo, \"buy ficha\" 450, venta 400) + efectos reales.");
		}
	}
	internal static class PocketFlashlight
	{
		internal static void Tick()
		{
			if (!Plugin.PocketFlashlightEnabled.Value || Keyboard.current == null || !((ButtonControl)Keyboard.current.fKey).wasPressedThisFrame)
			{
				return;
			}
			PlayerControllerB val = (((Object)(object)GameNetworkManager.Instance != (Object)null) ? GameNetworkManager.Instance.localPlayerController : null);
			if ((Object)(object)val == (Object)null || !((NetworkBehaviour)val).IsOwner || val.isPlayerDead || val.ItemSlots == null || val.isTypingChat || val.inTerminalMenu || val.inSpecialMenu || ((Object)(object)val.quickMenuManager != (Object)null && val.quickMenuManager.isMenuOpen))
			{
				return;
			}
			FlashlightItem val2 = FindBestFlashlight(val);
			if (!((Object)(object)val2 == (Object)null))
			{
				if ((Object)(object)val.currentlyHeldObjectServer == (Object)(object)val2)
				{
					((GrabbableObject)val2).UseItemOnClient(true);
				}
				else
				{
					TogglePocketed(val, val2);
				}
			}
		}

		private static FlashlightItem FindBestFlashlight(PlayerControllerB p)
		{
			FlashlightItem val = null;
			for (int i = 0; i < p.ItemSlots.Length; i++)
			{
				GrabbableObject obj = p.ItemSlots[i];
				FlashlightItem val2 = (FlashlightItem)(object)((obj is FlashlightItem) ? obj : null);
				if (!((Object)(object)val2 == (Object)null))
				{
					if (((GrabbableObject)val2).isBeingUsed)
					{
						return val2;
					}
					bool flag = ((GrabbableObject)val2).insertedBattery != null && !((GrabbableObject)val2).insertedBattery.empty;
					if ((Object)(object)val == (Object)null && flag)
					{
						val = val2;
					}
				}
			}
			return val;
		}

		private static void TogglePocketed(PlayerControllerB p, FlashlightItem flashlight)
		{
			bool flag = !((GrabbableObject)flashlight).isBeingUsed;
			if (flag && (((GrabbableObject)flashlight).insertedBattery == null || ((GrabbableObject)flashlight).insertedBattery.empty))
			{
				return;
			}
			flashlight.SwitchFlashlight(false);
			((GrabbableObject)flashlight).isBeingUsed = flag;
			flashlight.usingPlayerHelmetLight = flag;
			if ((Object)(object)p.helmetLight != (Object)null)
			{
				((Behaviour)p.helmetLight).enabled = flag;
			}
			p.pocketedFlashlight = (GrabbableObject)(object)(flag ? flashlight : null);
			if ((Object)(object)flashlight.flashlightAudio != (Object)null && flashlight.flashlightClips != null && flashlight.flashlightClips.Length != 0)
			{
				flashlight.flashlightAudio.PlayOneShot(flashlight.flashlightClips[Random.Range(0, flashlight.flashlightClips.Length)]);
			}
			try
			{
				flashlight.PocketFlashlightServerRpc(flag);
			}
			catch
			{
			}
		}
	}
	internal static class SecretCode
	{
		private const string Code = "MECHAVALA24";

		private const string Reply = "Alr, Welcome Commander Mech\n\n";

		private const int LoanedCredits = 1000000;

		private static TerminalNode _pendingBuyNode;

		private static int _pendingAmount = 1;

		private static bool _freeMode;

		private static int _realCredits;

		private static bool _lending;

		private static bool _autoConfirming;

		private static TerminalNode _replyNode;

		private static bool IsPurchase(TerminalNode node)
		{
			if ((Object)(object)node == (Object)null)
			{
				return false;
			}
			if (node.buyItemIndex == -1 && node.shipUnlockableID == -1 && node.buyVehicleIndex == -1)
			{
				if (node.buyRerouteToMoon != -1)
				{
					return node.buyRerouteToMoon != -2;
				}
				return false;
			}
			return true;
		}

		internal static void RememberAttempt(Terminal terminal, TerminalNode node)
		{
			if (!((Object)(object)terminal == (Object)null) && IsPurchase(node))
			{
				_pendingBuyNode = node;
				_pendingAmount = Mathf.Max(1, terminal.playerDefinedAmount);
			}
		}

		internal static void AttemptFinished(Terminal terminal, TerminalNode node)
		{
			if (!((Object)(object)terminal == (Object)null) && !((Object)(object)node == (Object)null) && !((Object)(object)_pendingBuyNode != (Object)(object)node) && (Object)(object)terminal.currentNode == (Object)(object)node)
			{
				_pendingBuyNode = null;
			}
		}

		internal static bool IsCode(string typed)
		{
			if (string.IsNullOrEmpty(typed))
			{
				return false;
			}
			StringBuilder stringBuilder = new StringBuilder(typed.Length);
			foreach (char c in typed)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(char.ToUpperInvariant(c));
				}
			}
			return stringBuilder.ToString() == "MECHAVALA24";
		}

		internal static TerminalNode OnCodeTyped(Terminal terminal)
		{
			if ((Object)(object)terminal == (Object)null)
			{
				return null;
			}
			_freeMode = true;
			TerminalNode val = ResolvePurchase(terminal);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogInfo((object)"[código] Modo gratis armado: la próxima compra será gratuita.");
				return BuildReply();
			}
			terminal.playerDefinedAmount = Mathf.Max(1, _pendingAmount);
			Plugin.Log.LogInfo((object)("[código] Reintentando gratis '" + ((Object)val).name + "' " + $"(item={val.buyItemIndex} unlockable={val.shipUnlockableID} " + $"vehiculo={val.buyVehicleIndex} luna={val.buyRerouteToMoon} " + $"cantidad={terminal.playerDefinedAmount})"));
			return val;
		}

		private static TerminalNode ResolvePurchase(Terminal terminal)
		{
			TerminalNode currentNode = terminal.currentNode;
			if (IsPurchase(currentNode))
			{
				return currentNode;
			}
			if ((Object)(object)currentNode != (Object)null && currentNode.terminalOptions != null)
			{
				CompatibleNoun[] terminalOptions = currentNode.terminalOptions;
				foreach (CompatibleNoun val in terminalOptions)
				{
					if (val != null && !((Object)(object)val.noun == (Object)null) && !(val.noun.word != "confirm") && IsPurchase(val.result))
					{
						return val.result;
					}
				}
			}
			return _pendingBuyNode;
		}

		internal static void BeforePurchase(Terminal terminal)
		{
			if (_freeMode && !_lending && !((Object)(object)terminal == (Object)null))
			{
				_lending = true;
				_realCredits = terminal.groupCredits;
				terminal.groupCredits = 1000000;
			}
		}

		internal static void AfterPurchase(Terminal terminal)
		{
			if (!_lending || (Object)(object)terminal == (Object)null)
			{
				return;
			}
			_lending = false;
			bool flag = terminal.groupCredits < 1000000;
			string arg = (((Object)(object)terminal.currentNode != (Object)null) ? ((Object)terminal.currentNode).name : "(null)");
			Plugin.Log.LogInfo((object)$"[código] Nodo final '{arg}' · ¿compró?: {flag}");
			terminal.groupCredits = _realCredits;
			if (((NetworkBehaviour)terminal).IsServer)
			{
				terminal.SyncGroupCreditsClientRpc(_realCredits, terminal.numberOfItemsInDropship);
			}
			else
			{
				terminal.SyncGroupCreditsServerRpc(_realCredits, terminal.numberOfItemsInDropship);
			}
			if (flag)
			{
				_freeMode = false;
				_pendingBuyNode = null;
				_pendingAmount = 1;
				terminal.LoadNewNode(BuildReply());
			}
			else
			{
				if (_autoConfirming)
				{
					return;
				}
				TerminalNode val = FindConfirmTarget(terminal.currentNode);
				if (!((Object)(object)val == (Object)null))
				{
					Plugin.Log.LogInfo((object)("[código] Confirmando automáticamente '" + ((Object)val).name + "'."));
					_autoConfirming = true;
					try
					{
						terminal.LoadNewNodeIfAffordable(val);
					}
					finally
					{
						_autoConfirming = false;
					}
				}
			}
		}

		private static TerminalNode FindConfirmTarget(TerminalNode node)
		{
			if ((Object)(object)node == (Object)null || node.terminalOptions == null)
			{
				return null;
			}
			CompatibleNoun[] terminalOptions = node.terminalOptions;
			foreach (CompatibleNoun val in terminalOptions)
			{
				if (val != null && !((Object)(object)val.noun == (Object)null) && !(val.noun.word != "confirm") && IsPurchase(val.result))
				{
					return val.result;
				}
			}
			return null;
		}

		private static TerminalNode BuildReply()
		{
			if ((Object)(object)_replyNode == (Object)null)
			{
				_replyNode = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)_replyNode).name = "MechCodeNode";
				_replyNode.clearPreviousText = true;
				_replyNode.maxCharactersToType = 25;
				_replyNode.playSyncedClip = 0;
			}
			_replyNode.displayText = "Alr, Welcome Commander Mech\n\n";
			return _replyNode;
		}
	}
	internal static class StatsEffects
	{
		private const int BaseHealth = 100;

		private const float BaseSprintTime = 5f;

		private const int BaseSlots = 4;

		internal static bool SecondWindActive;

		internal static float LastTzpHealTime = -10f;

		private static float _lastRawExcess;

		private static readonly Color HudGreen = new Color(0.31f, 0.88f, 0.42f, 1f);

		private static GameObject _meleeRoot;

		private static TextMeshProUGUI _meleeText;

		private static Image _meleeSword;

		private static int _meleeShownLevel = -1;

		private static Image _staminaExtraBar;

		private static readonly List<GameObject> _hudSlotClones = new List<GameObject>();

		private static int _baseHudSlots = -1;

		private static PlayerControllerB Local
		{
			get
			{
				if (!((Object)(object)GameNetworkManager.Instance != (Object)null))
				{
					return null;
				}
				return GameNetworkManager.Instance.localPlayerController;
			}
		}

		internal static int MaxHealth => 100 + 33 * Mathf.Min(Plugin.LocalUpgrades.GetLevel(UpgradeSkill.Health), 3);

		internal static bool HasSecondWind => Plugin.LocalUpgrades.HasSecondWind;

		internal static float MeleeMultiplier => Plugin.LocalUpgrades.MeleeMultiplier;

		internal static float WeightFactor => 1f - 0.25f * (float)Plugin.LocalUpgrades.GetLevel(UpgradeSkill.Strength);

		internal static int TargetSlots => 4 + Plugin.LocalUpgrades.ExtraSlots;

		internal static bool IsLocal(PlayerControllerB p)
		{
			if ((Object)(object)p != (Object)null)
			{
				return (Object)(object)p == (Object)(object)Local;
			}
			return false;
		}

		internal static void OnUpgraded(UpgradeSkill skill)
		{
			PlayerControllerB local = Local;
			if ((Object)(object)local == (Object)null)
			{
				return;
			}
			switch (skill)
			{
			case UpgradeSkill.Health:
				if (Plugin.LocalUpgrades.GetLevel(UpgradeSkill.Health) <= 3)
				{
					local.health = Mathf.Min(local.health + 33, MaxHealth);
					HUDManager.Instance.UpdateHealthUI(local.health, false);
				}
				break;
			case UpgradeSkill.Stamina:
				ApplyStamina(local);
				break;
			case UpgradeSkill.Inventory:
				EnsureInventorySize(local);
				break;
			case UpgradeSkill.Strength:
				break;
			}
		}

		internal static void NotifySecondWind()
		{
			if (!SecondWindActive)
			{
				SecondWindActive = true;
				CrownIndicator.PlayBreakSound();
			}
		}

		internal static void UpdateVignettes()
		{
			PlayerControllerB local = Local;
			if (SecondWindActive && ((Object)(object)local == (Object)null || local.isPlayerDead || local.health >= 20))
			{
				SecondWindActive = false;
			}
			bool num = SecondWindActive && (Object)(object)local != (Object)null && !local.isPlayerDead;
			VignetteOverlay.SetTargets(pink: (Time.time - LastTzpHealTime < 0.35f) ? 0.35f : 0f, green: num ? 0.55f : 0f);
			VignetteOverlay.Tick(Time.deltaTime);
			CrownIndicator.Tick();
			StrengthArms.Tick();
		}

		internal static void ReapplyAll(PlayerControllerB p)
		{
			SecondWindActive = false;
			if (!((Object)(object)p == (Object)null) && IsLocal(p))
			{
				p.health = MaxHealth;
				if ((Object)(object)HUDManager.Instance != (Object)null)
				{
					HUDManager.Instance.UpdateHealthUI(p.health, false);
				}
				ApplyStamina(p);
				EnsureInventorySize(p);
			}
		}

		private static void ApplyStamina(PlayerControllerB p)
		{
			p.sprintTime = 5f * Plugin.LocalUpgrades.StaminaMultiplier;
		}

		internal static void EnforceCarryWeight()
		{
			PlayerControllerB local = Local;
			if ((Object)(object)local == (Object)null || local.isPlayerDead || local.ItemSlots == null)
			{
				return;
			}
			float num = 0f;
			for (int i = 0; i < local.ItemSlots.Length; i++)
			{
				GrabbableObject val = local.ItemSlots[i];
				if ((Object)(object)val != (Object)null && (Object)(object)val.itemProperties != (Object)null)
				{
					num += Mathf.Max(val.itemProperties.weight - 1f, 0f);
				}
			}
			_lastRawExcess = num;
			local.carryWeight = 1f + num * WeightFactor;
		}

		internal static void UpdateWeightLabel()
		{
			PlayerControllerB local = Local;
			HUDManager instance = HUDManager.Instance;
			if (!((Object)(object)local == (Object)null) && !((Object)(object)instance == (Object)null) && !((Object)(object)instance.weightCounter == (Object)null) && Plugin.LocalUpgrades.GetLevel(UpgradeSkill.Strength) > 0)
			{
				int num = Mathf.RoundToInt(_lastRawExcess * (1f - WeightFactor) * 105f);
				if (num > 0)
				{
					float num2 = Mathf.RoundToInt(Mathf.Clamp(local.carryWeight - 1f, 0f, 100f) * 105f);
					((TMP_Text)instance.weightCounter).text = $"{num2} lb <color=#4EE06A>(-{num} lb)</color>";
				}
			}
		}

		internal static void UpdateMeleeLabel()
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)instance.weightCounter == (Object)null)
			{
				return;
			}
			int level = Plugin.LocalUpgrades.GetLevel(UpgradeSkill.Strength);
			if (level <= 0)
			{
				if ((Object)(object)_meleeRoot != (Object)null)
				{
					_meleeRoot.SetActive(false);
				}
				_meleeShownLevel = 0;
				return;
			}
			if ((Object)(object)_meleeRoot == (Object)null)
			{
				BuildMeleeLabel(instance);
			}
			if (!((Object)(object)_meleeRoot == (Object)null))
			{
				if (!_meleeRoot.activeSelf)
				{
					_meleeRoot.SetActive(true);
				}
				if (_meleeShownLevel != level)
				{
					((TMP_Text)_meleeText).text = $"(+{level * 50}%";
					_meleeShownLevel = level;
				}
			}
		}

		private static void BuildMeleeLabel(HUDManager hud)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Invalid comparison between Unknown and I4
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Invalid comparison between Unknown and I4
			//IL_016f: 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_0181: 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)
			TextMeshProUGUI weightCounter = hud.weightCounter;
			RectTransform rectTransform = ((TMP_Text)weightCounter).rectTransform;
			_meleeRoot = new GameObject("MeleeBonus[UpgradableStats]", new Type[1] { typeof(RectTransform) });
			RectTransform component = _meleeRoot.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)rectTransform, false);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 1f);
			component.anchorMax = val;
			component.anchorMin = val;
			component.pivot = new Vector2(0.5f, 0f);
			Rect rect = rectTransform.rect;
			component.sizeDelta = new Vector2(Mathf.Max(((Rect)(ref rect)).width, 120f), ((TMP_Text)weightCounter).fontSize * 1.3f);
			component.anchoredPosition = new Vector2(0f, ((TMP_Text)weightCounter).fontSize * 0.35f);
			((Transform)component).localRotation = Quaternion.identity;
			((Transform)component).localScale = Vector3.one;
			HorizontalLayoutGroup obj = _meleeRoot.AddComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)obj).spacing = ((TMP_Text)weightCounter).fontSize * 0.12f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			((LayoutGroup)obj).childAlignment = (TextAnchor)(((int)((TMP_Text)weightCounter).alignment == 513) ? 3 : (((int)((TMP_Text)weightCounter).alignment == 516) ? 5 : 4));
			_meleeText = MakeMeleeTmp("Texto", component, weightCounter);
			((TMP_Text)_meleeText).text = "(+50%";
			GameObject val2 = new GameObject("Espada", new Type[1] { typeof(RectTransform) });
			val2.transform.SetParent((Transform)(object)component, false);
			_meleeSword = val2.AddComponent<Image>();
			_meleeSword.sprite = BuildSwordSprite();
			((Graphic)_meleeSword).color = HudGreen;
			_meleeSword.preserveAspect = true;
			((Graphic)_meleeSword).raycastTarget = false;
			LayoutElement obj2 = val2.AddComponent<LayoutElement>();
			obj2.preferredHeight = ((TMP_Text)weightCounter).fontSize * 1.1f;
			obj2.preferredWidth = ((TMP_Text)weightCounter).fontSize * 0.85f;
			((TMP_Text)MakeMeleeTmp("Cierre", component, weightCounter)).text = ")";
			Plugin.Log.LogInfo((object)"Indicador de daño melee creado sobre el contador de peso.");
		}

		private static TextMeshProUGUI MakeMeleeTmp(string name, RectTransform parent, TextMeshProUGUI copyFrom)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_0047: 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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			val.transform.SetParent((Transform)(object)parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).font = ((TMP_Text)copyFrom).font;
			((TMP_Text)obj).fontSize = ((TMP_Text)copyFrom).fontSize;
			((TMP_Text)obj).fontStyle = ((TMP_Text)copyFrom).fontStyle;
			((Graphic)obj).color = HudGreen;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)4098;
			((TMP_Text)obj).enableWordWrapping = false;
			((Graphic)obj).raycastTarget = false;
			ContentSizeFitter obj2 = val.AddComponent<ContentSizeFitter>();
			obj2.horizontalFit = (FitMode)2;
			obj2.verticalFit = (FitMode)2;
			return obj;
		}

		private static Sprite BuildSwordSprite()
		{
			//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_0098: Unknown result type (might be due to invalid IL or missing references)
			return HudFigure.SpriteFromRows(new string[16]
			{
				".....g.....", "....g.g....", "....g.g....", "....g.g....", "....g.g....", "....g.g....", "....g.g....", "....g.g....", "....g.g....", "..ggggggg..",
				"..g.....g..", "..ggggggg..", "....g.g....", "....g.g....", "....ggg....", "..........."
			}, Color.white, Color.white, Color.white);
		}

		internal static void UpdateStaminaBarVisual()
		{
			//IL_0153: 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_0158: 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_0170: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB local = Local;
			if ((Object)(object)local == (Object)null || (Object)(object)local.sprintMeterUI == (Object)null)
			{
				return;
			}
			float staminaMultiplier = Plugin.LocalUpgrades.StaminaMultiplier;
			if (staminaMultiplier <= 1f || !Plugin.StaminaBarVisual.Value)
			{
				if ((Object)(object)_staminaExtraBar != (Object)null)
				{
					((Behaviour)_staminaExtraBar).enabled = false;
				}
				return;
			}
			if ((Object)(object)_staminaExtraBar != (Object)null && (Object)(object)((Component)_staminaExtraBar).transform.parent != (Object)(object)((Component)local.sprintMeterUI).transform.parent)
			{
				Object.Destroy((Object)(object)((Component)_staminaExtraBar).gameObject);
				_staminaExtraBar = null;
			}
			if ((Object)(object)_staminaExtraBar == (Object)null)
			{
				CreateStaminaExtraBar(local);
			}
			if ((Object)(object)_staminaExtraBar == (Object)null)
			{
				return;
			}
			float alpha = ((Graphic)local.sprintMeterUI).canvasRenderer.GetAlpha();
			if (!((Behaviour)local.sprintMeterUI).enabled || !((Component)local.sprintMeterUI).gameObject.activeInHierarchy || !(alpha > 0.02f))
			{
				((Behaviour)_staminaExtraBar).enabled = false;
				return;
			}
			((Graphic)_staminaExtraBar).canvasRenderer.SetAlpha(alpha);
			Color val = (Plugin.LocalUpgrades.HasGoodLegs ? new Color(1f, 0.84f, 0.2f, 0.95f) : new Color(0.25f, 1f, 0.3f, 0.95f));
			if (((Graphic)_staminaExtraBar).color != val)
			{
				((Graphic)_staminaExtraBar).color = val;
			}
			float num = staminaMultiplier - 1f;
			float num2 = Mathf.Clamp01(local.sprintMeter) * staminaMultiplier;
			local.sprintMeterUI.fillAmount = Mathf.Min(num2, 1f);
			_staminaExtraBar.fillAmount = Mathf.Clamp(num2 - 1f, 0f, num);
			((Behaviour)_staminaExtraBar).enabled = true;
		}

		private static void CreateStaminaExtraBar(PlayerControllerB p)
		{
			//IL_00ad: 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_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)
			GameObject val = Object.Instantiate<GameObject>(((Component)p.sprintMeterUI).gameObject, ((Component)p.sprintMeterUI).transform.parent);
			((Object)val).name = "SprintMeterExtra[UpgradableStats]";
			for (int num = val.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)val.transform.GetChild(num)).gameObject);
			}
			Animator component = val.GetComponent<Animator>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			_staminaExtraBar = val.GetComponent<Image>();
			if ((Object)(object)_staminaExtraBar == (Object)null)
			{
				Object.Destroy((Object)(object)val);
				return;
			}
			((Graphic)_staminaExtraBar).color = new Color(0.25f, 1f, 0.3f, 0.95f);
			_staminaExtraBar.fillAmount = 0f;
			_staminaExtraBar.fillClockwise = !p.sprintMeterUI.fillClockwise;
			CanvasGroup component2 = val.GetComponent<CanvasGroup>();
			if ((Object)(object)component2 != (Object)null)
			{
				component2.ignoreParentGroups = false;
				component2.interactable = false;
				component2.blocksRaycasts = false;
			}
			RectTransform component3 = val.GetComponent<RectTransform>();
			RectTransform rectTransform = ((Graphic)p.sprintMeterUI).rectTransform;
			component3.anchoredPosition = rectTransform.anchoredPosition;
			((Transform)component3).localScale = ((Transform)rectTransform).localScale * 1.13f;
			val.transform.SetSiblingIndex(((Component)p.sprintMeterUI).transform.GetSiblingIndex());
			Plugin.Log.LogInfo((object)"Barra de estamina extra creada.");
		}

		internal static void EnsureInventorySize(PlayerControllerB p)
		{
			if (!((Object)(object)p == (Object)null) && IsLocal(p) && p.ItemSlots != null)
			{
				int targetSlots = TargetSlots;
				if (p.ItemSlots.Length < targetSlots)
				{
					GrabbableObject[] array = p.ItemSlots;
					Array.Resize(ref array, targetSlots);
					p.ItemSlots = array;
					GrowHud(targetSlots);
					Plugin.Log.LogInfo((object)$"Inventario ampliado a {targetSlots} espacios.");
				}
			}
		}

		private static void GrowHud(int target)
		{
			//IL_0076: 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_0059: 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_0094: 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_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)
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null || instance.itemSlotIconFrames == null || instance.itemSlotIconFrames.Length == 0 || instance.itemSlotIconFrames.Length >= target)
			{
				return;
			}
			int num = instance.itemSlotIconFrames.Length;
			if (_baseHudSlots < 0)
			{
				_baseHudSlots = num;
			}
			RectTransform rectTransform = ((Graphic)instance.itemSlotIconFrames[num - 1]).rectTransform;
			Vector2 val = (Vector2)((num >= 2) ? (rectTransform.anchoredPosition - ((Graphic)instance.itemSlotIconFrames[num - 2]).rectTransform.anchoredPosition) : new Vector2(rectTransform.sizeDelta.x + 10f, 0f));
			List<Image> list = new List<Image>(instance.itemSlotIconFrames);
			List<Image> list2 = new List<Image>(instance.itemSlotIcons);
			for (int i = num; i < target; i++)
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)rectTransform).gameObject, ((Transform)rectTransform).parent);
				((Object)val2).name = $"Slot{i}[UpgradableStats]";
				val2.GetComponent<RectTransform>().anchoredPosition = rectTransform.anchoredPosition + val * (float)(i - num + 1);
				Image component = val2.GetComponent<Image>();
				Image val3 = null;
				Image[] componentsInChildren = val2.GetComponentsInChildren<Image>(true);
				foreach (Image val4 in componentsInChildren)
				{
					if ((Object)(object)val4 != (Object)(object)component)
					{
						val3 = val4;
						break;
					}
				}
				if ((Object)(object)val3 != (Object)null)
				{
					val3.sprite = null;
					((Behaviour)val3).enabled = false;
				}
				list.Add(component);
				list2.Add(((Object)(object)val3 != (Object)null) ? val3 : component);
				_hudSlotClones.Add(val2);
			}
			instance.itemSlotIconFrames = list.ToArray();
			instance.itemSlotIcons = list2.ToArray();
		}

		internal static void ApplyInventorySize()
		{
			//IL_004d: 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)
			PlayerControllerB local = Local;
			int targetSlots = TargetSlots;
			if ((Object)(object)local != (Object)null && local.ItemSlots != null && local.ItemSlots.Length > targetSlots)
			{
				for (int i = targetSlots; i < local.ItemSlots.Length; i++)
				{
					if ((Object)(object)local.ItemSlots[i] != (Object)null)
					{
						if (local.currentItemSlot == i)
						{
							local.DiscardHeldObject(false, (NetworkObject)null, default(Vector3), true);
						}
						else
						{
							local.ItemSlots[i] = null;
						}
					}
				}
				GrabbableObject[] array = local.ItemSlots;
				Array.Resize(ref array, targetSlots);
				local.ItemSlots = array;
				if (local.currentItemSlot >= targetSlots)
				{
					local.currentItemSlot = 0;
				}
			}
			else if ((Object)(object)local != (Object)null)
			{
				EnsureInventorySize(local);
			}
			ShrinkHud(targetSlots);
		}

		private static void ShrinkHud(int target)
		{
			HUDManager instance = HUDManager.Instance;
			if ((Object)(object)instance == (Object)null || _baseHudSlots < 0 || instance.itemSlotIconFrames == null)
			{
				return;
			}
			int num = Mathf.Max(target, _baseHudSlots);
			if (instance.itemSlotIconFrames.Length <= num)
			{
				return;
			}
			List<Image> list = new List<Image>(instance.itemSlotIconFrames);
			List<Image> list2 = new List<Image>(instance.itemSlotIcons);
			for (int num2 = list.Count - 1; num2 >= num; num2--)
			{
				Image val = list[num2];
				list.RemoveAt(num2);
				if (num2 < list2.Count)
				{
					list2.RemoveAt(num2);
				}
				if ((Object)(object)val != (Object)null)
				{
					_hudSlotClones.Remove(((Component)val).gameObject);
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			instance.itemSlotIconFrames = list.ToArray();
			instance.itemSlotIcons = list2.ToArray();
		}

		internal static void OnLevelsEdited()
		{
			PlayerControllerB local = Local;
			if (!((Object)(object)local == (Object)null))
			{
				local.sprintTime = 5f * Plugin.LocalUpgrades.StaminaMultiplier;
				local.health = Mathf.Min(local.health, MaxHealth);
				if ((Object)(object)HUDManager.Instance != (Object)null)
				{
					HUDManager.Instance.UpdateHealthUI(local.health, false);
				}
				ApplyInventorySize();
			}
		}

		internal static void ResetEverything()
		{
			Plugin.LocalUpgrades.ResetAll();
			SecondWindActive = false;
			ApplyInventorySize();
			PlayerControllerB local = Local;
			if ((Object)(object)local != (Object)null)
			{
				local.sprintTime = 5f;
				local.health = Mathf.Min(local.health, 100);
				if ((Object)(object)HUDManager.Instance != (Object)null)
				{
					HUDManager.Instance.UpdateHealthUI(local.health, false);
				}
			}
			Plugin.Log.LogInfo((object)"Partida perdida: mejoras y estadísticas reiniciadas.");
		}
	}
	public class UpgradeRuntime : MonoBehaviour
	{
		private void Update()
		{
			PocketFlashlight.Tick();
		}

		private void LateUpdate()
		{
			StatsEffects.EnforceCarryWeight();
			StatsEffects.UpdateWeightLabel();
			StatsEffects.UpdateMeleeLabel();
			StatsEffects.UpdateStaminaBarVisual();
			StatsEffects.UpdateVignettes();
		}
	}
	public class TokenGlow : MonoBehaviour
	{
		private const float FloorIntensity = 320f;

		private const float HeldIntensity = 45f;

		private const float LightRange = 5.5f;

		private static readonly Color Gold = new Color(1f, 0.82f, 0.25f);

		private GrabbableObject _item;

		private Light _light;

		private Transform _beam;

		private Transform _halo;

		private Transform _base;

		private Renderer[] _auraParts;

		private static Material _auraMat;

		private void Start()
		{
			_item = ((Component)this).GetComponent<GrabbableObject>();
			Build();
		}

		private void Build()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0032: 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_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_00fd: 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)
			GameObject val = new GameObject("TokenLight");
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = new Vector3(0f, 0.25f, 0f);
			_light = val.AddComponent<Light>();
			_light.type = (LightType)2;
			_light.color = Gold;
			_light.range = 5.5f;
			_light.intensity = 320f;
			_light.shadows = (LightShadows)0;
			SetHdrpIntensity(val, 320f);
			Material auraMaterial = GetAuraMaterial();
			_beam = MakeMeshPart("Beam", BuildTaperedBeamMesh(), auraMaterial, new Vector3(0f, 0f, 0f), Vector3.one);
			_base = MakePart("BaseGlow", (PrimitiveType)2, auraMaterial, new Vector3(0f, 0.012f, 0f), new Vector3(0.55f, 0.01f, 0.55f));
			_halo = MakePart("Halo", (PrimitiveType)2, auraMaterial, new Vector3(0f, 0.22f, 0f), new Vector3(0.38f, 0.005f, 0.38f));
			_auraParts = (Renderer[])(object)new Renderer[3]
			{
				((Component)_beam).GetComponent<Renderer>(),
				((Component)_base).GetComponent<Renderer>(),
				((Component)_halo).GetComponent<Renderer>()
			};
		}

		private static Mesh BuildTaperedBeamMesh()
		{
			//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_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_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_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_00e6: 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_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			Vector3[] array = (Vector3[])(object)new Vector3[16]
			{
				Vector3.zero,
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				new Vector3(0f, 3.1f, 0f)
			};
			for (int i = 0; i < 14; i++)
			{
				float num = (float)i / 14f * MathF.PI * 2f;
				array[i + 1] = new Vector3(Mathf.Cos(num) * 0.17f, 0f, Mathf.Sin(num) * 0.17f);
			}
			List<int> list = new List<int>(84);
			for (int j = 0; j < 14; j++)
			{
				int item = j + 1;
				int item2 = (j + 1) % 14 + 1;
				list.Add(0);
				list.Add(item2);
				list.Add(item);
				list.Add(item);
				list.Add(item2);
				list.Add(15);
			}
			Mesh val = new Mesh
			{
				name = "TokenBeam"
			};
			val.SetVertices(new List<Vector3>(array));
			val.SetTriangles(list, 0);
			val.RecalculateNormals();
			val.RecalculateBounds();
			return val;
		}

		private Transform MakeMeshPart(string name, Mesh mesh, Material mat, Vector3 pos, Vector3 scale)
		{
			//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_0018: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = pos;
			val.transform.localScale = scale;
			val.AddComponent<MeshFilter>().sharedMesh = mesh;
			MeshRenderer obj = val.AddComponent<MeshRenderer>();
			((Renderer)obj).sharedMaterial = mat;
			((Renderer)obj).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)obj).receiveShadows = false;
			return val.transform;
		}

		private Transform MakePart(string name, PrimitiveType type, Material mat, Vector3 pos, Vector3 scale)
		{
			//IL_0000: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive(type);
			((Object)obj).name = name;
			obj.transform.SetParent(((Component)this).transform, false);
			obj.transform.localPosition = pos;
			obj.transform.localScale = scale;
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.Destroy((Object)(object)component);
			}
			Renderer component2 = obj.GetComponent<Renderer>();
			component2.sharedMaterial = mat;
			component2.shadowCastingMode = (ShadowCastingMode)0;
			component2.receiveShadows = false;
			return obj.transform;
		}

		private void LateUpdate()
		{
			//IL_0052: 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_0067: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_item == (Object)null)
			{
				return;
			}
			bool flag = !_item.isHeld && !_item.isPocketed;
			if (flag && Plugin.TokenGlowEnabled.Value)
			{
				Camera main = Camera.main;
				if ((Object)(object)main != (Object)null)
				{
					Vector3 val = ((Component)main).transform.position - ((Component)this).transform.position;
					if (((Vector3)(ref val)).sqrMagnitude > 2025f)
					{
						flag = false;
					}
				}
			}
			else if (!Plugin.TokenGlowEnabled.Value)
			{
				flag = false;
			}
			if (_auraParts != null)
			{
				Renderer[] auraParts = _auraParts;
				foreach (Renderer val2 in auraParts)
				{
					if ((Object)(object)val2 != (Object)null && val2.enabled != flag)
					{
						val2.enabled = flag;
					}
				}
			}
			if ((Object)(object)_light != (Object)null)
			{
				float num = (flag ? 320f : 45f);
				if (!Mathf.Approximately(_light.intensity, num))
				{
					_light.intensity = num;
					SetHdrpIntensity(((Component)_light).gameObject, num);
				}
			}
			if (flag)
			{
				float time = Time.time;
				float num2 = 1f + Mathf.Sin(time * 2.2f) * 0.06f;
				if ((Object)(object)_beam != (Object)null)
				{
					_beam.localScale = new Vector3(num2, 1f, num2);
					_beam.Rotate(Vector3.up, 25f * Time.deltaTime, (Space)1);
				}
				if ((Object)(object)_halo != (Object)null)
				{
					float num3 = Mathf.PingPong(time * 0.35f, 0.55f);
					_halo.localPosition = new Vector3(0f, 0.18f + num3, 0f);
					float num4 = Mathf.Lerp(0.42f, 0.18f, num3 / 0.55f);
					_halo.localScale = new Vector3(num4, 0.005f, num4);
					_halo.Rotate(Vector3.up, -40f * Time.deltaTime, (Space)1);
				}
				if ((Object)(object)_base != (Object)null)
				{
					_base.localScale = new Vector3(0.55f * num2, 0.01f, 0.55f * num2);
				}
			}
		}

		private static Material GetAuraMaterial()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0088: 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_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)
			if ((Object)(object)_auraMat != (Object)null)
			{
				return _auraMat;
			}
			_auraMat = new Material(Shader.Find("HDRP/Unlit") ?? Shader.Find("Unlit/Color") ?? Shader.Find("Sprites/Default"));
			Color val = default(Color);
			((Color)(ref val))..ctor(Gold.r, Gold.g, Gold.b, 0.12f);
			if (_auraMat.HasProperty("_UnlitColor"))
			{
				_auraMat.SetColor("_UnlitColor", val);
			}
			if (_auraMat.HasProperty("_BaseColor"))
			{
				_auraMat.SetColor("_BaseColor", val);
			}
			if (_auraMat.HasProperty("_Color"))
			{
				_auraMat.SetColor("_Color", val);
			}
			if (_auraMat.HasProperty("_EmissiveColor"))
			{
				if (_auraMat.HasProperty("_UseEmissiveIntensity"))
				{
					_auraMat.SetFloat("_UseEmissiveIntensity", 0f);
				}
				_auraMat.SetColor("_EmissiveColor", Gold * 3.2f);
			}
			if (_auraMat.HasProperty("_SurfaceType"))
			{
				_auraMat.SetFloat("_SurfaceType", 1f);
			}
			if (_auraMat.HasProperty("_BlendMode"))
			{
				_auraMat.SetFloat("_BlendMode", 1f);
			}
			if (_auraMat.HasProperty("_ZWrite"))
			{
				_auraMat.SetFloat("_ZWrite", 0f);
			}
			if (_auraMat.HasProperty("_CullMode"))
			{
				_auraMat.SetFloat("_CullMode", 0f);
			}
			if (_auraMat.HasProperty("_SrcBlend"))
			{
				_auraMat.SetFloat("_SrcBlend", 5f);
			}
			if (_auraMat.HasProperty("_DstBlend"))
			{
				_auraMat.SetFloat("_DstBlend", 1f);
			}
			_auraMat.renderQueue = 3000;
			_auraMat.EnableKeyword("_EMISSION");
			_auraMat.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
			_auraMat.EnableKeyword("_BLENDMODE_ADD");
			return _auraMat;
		}

		private static void SetHdrpIntensity(GameObject lightGo, float lumens)
		{
			Component[] components = lightGo.GetComponents<Component>();
			foreach (Component val in components)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				if (!(type.Name != "HDAdditionalLightData"))
				{
					PropertyInfo property = type.GetProperty("intensity");
					if (property != null && property.CanWrite)
					{
						property.SetValue(val, lumens);
					}
					break;
				}
			}
		}
	}
	internal static class TokenItem
	{
		internal static Item Token;

		internal static GameObject TokenPrefab;

		private static GameObject _prefabContainer;

		private static Sprite _icon;

		private static bool _enriched;

		private static TerminalNode _buyNode1;

		private static TerminalNode _buyNode2;

		internal static bool IsToken(GrabbableObject obj)
		{
			if ((Object)(object)obj != (Object)null && (Object)(object)Token != (Object)null)
			{
				return (Object)(object)obj.itemProperties == (Object)(object)Token;
			}
			return false;
		}

		internal static int CountInInventory(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null || player.ItemSlots == null)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				if (IsToken(player.ItemSlots[i]))
				{
					num++;
				}
			}
			return num;
		}

		internal static bool ConsumeOne(PlayerControllerB player)
		{
			if ((Object)(object)player == (Object)null || player.ItemSlots == null)
			{
				return false;
			}
			int num = -1;
			if (player.currentItemSlot >= 0 && player.currentItemSlot < player.ItemSlots.Length && IsToken(player.ItemSlots[player.currentItemSlot]))
			{
				num = player.currentItemSlot;
			}
			else
			{
				for (int i = 0; i < player.ItemSlots.Length; i++)
				{
					if (IsToken(player.ItemSlots[i]))
					{
						num = i;
						break;
					}
				}
			}
			if (num < 0)
			{
				return false;
			}
			player.DestroyItemInSlotAndSync(num);
			return true;
		}

		internal static void CreateEarly()
		{
			//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)
			if (!((Object)(object)Token != (Object)null))
			{
				Token = ScriptableObject.CreateInstance<Item>();
				((Object)Token).name = "UpgradeTokenItem";
				Token.itemName = "Ficha";
				Token.itemId = 613001;
				Token.isScrap = true;
				Token.twoHanded = false;
				Token.twoHandedAnimation = false;
				Token.weight = 1f;
				Token.creditsWorth = Plugin.TokenBuyPrice.Value;
				Token.minValue = Plugin.TokenSellValue.Value;
				Token.maxValue = Plugin.TokenSellValue.Value;
				Token.requiresBattery = false;
				Token.saveItemVariable = false;
				Token.isConductiveMetal = true;
				Token.itemSpawnsOnGround = true;
				Token.canBeGrabbedBeforeGameStart = true;
				Token.highestSalePercentage = 100;
				Token.itemIcon = GetIcon();
				Token.spawnPositionTypes = new List<ItemGroup>();
				Token.toolTips = new string[0];
				Token.restingRotation = new Vector3(0f, 0f, 0f);
				TokenPrefab = BuildPrefab();
				Token.spawnPrefab = TokenPrefab;
				Plugin.Log.LogInfo((object)"Ficha de mejora creada.");
			}
		}

		private static GameObject BuildPrefab()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//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_00ab: 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_00c7: 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_00fa: 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_0131: 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_0181: 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_01ad: 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_01bd: Unknown result type (might be due to invalid IL or missing references)
			_prefabContainer = new GameObject("UpgradableStats_Prefabs");
			_prefabContainer.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_prefabContainer);
			((Object)_prefabContainer).hideFlags = (HideFlags)61;
			GameObject val = new GameObject("UpgradeTokenProp");
			val.transform.SetParent(_prefabContainer.transform, false);
			val.tag = "PhysicsProp";
			val.layer = 6;
			NetworkObject obj = val.AddComponent<NetworkObject>();
			byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes("com.CommanderMechavala.upgradablestatsUpgradeTokenProp"));
			obj.GlobalObjectIdHash = BitConverter.ToUInt32(value, 0);
			GameObject val2 = new GameObject("Gema");
			val2.transform.SetParent(val.transform, false);
			val2.layer = 6;
			val2.transform.localScale = new Vector3(1f, 0.45f, 1f);
			val2.AddComponent<MeshFilter>().sharedMesh = BuildIcosahedronMesh(0.09f);
			((Renderer)val2.AddComponent<MeshRenderer>()).sharedMaterial = UpgradesMachine.MakeMaterial(new Color(0.83f, 0.62f, 0.14f), 1f, 0.62f);
			val.AddComponent<BoxCollider>().size = new Vector3(0.16f, 0.09f, 0.16f);
			AudioSource obj2 = val.AddComponent<AudioSource>();
			obj2.playOnAwake = false;
			obj2.spatialBlend = 1f;
			PhysicsProp obj3 = val.AddComponent<PhysicsProp>();
			((GrabbableObject)obj3).grabbable = true;
			((GrabbableObject)obj3).grabbableToEnemies = true;
			((GrabbableObject)obj3).itemProperties = Token;
			val.AddComponent<TokenShipAnchor>();
			GameObject val3 = new GameObject("ScanNode");
			val3.transform.SetParent(val.transform, false);
			int num = LayerMask.NameToLayer("ScanNode");
			val3.layer = ((num >= 0) ? num : 22);
			val3.AddComponent<BoxCollider>().size = Vector3.one * 0.6f;
			ScanNodeProperties obj4 = val3.AddComponent<ScanNodeProperties>();
			obj4.headerText = "Ficha de mejora";
			obj4.subText = "";
			obj4.nodeType = 2;
			obj4.minRange = 1;
			obj4.maxRange = 13;
			obj4.requiresLineOfSight = true;
			return val;
		}

		private static Mesh BuildIcosahedronMesh(float radius)
		{
			//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_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_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_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_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_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_00b8: 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_00d0: 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_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_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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: 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_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Unknown result type (might be due to invalid IL or missing references)
			//IL_035d: 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_036a: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			float num = (1f + Mathf.Sqrt(5f)) / 2f;
			Vector3[] array = (Vector3[])(object)new Vector3[12]
			{
				new Vector3(-1f, num, 0f),
				new Vector3(1f, num, 0f),
				new Vector3(-1f, 0f - num, 0f),
				new Vector3(1f, 0f - num, 0f),
				new Vector3(0f, -1f, num),
				new Vector3(0f, 1f, num),
				new Vector3(0f, -1f, 0f - num),
				new Vector3(0f, 1f, 0f - num),
				new Vector3(num, 0f, -1f),
				new Vector3(num, 0f, 1f),
				new Vector3(0f - num, 0f, -1f),
				new Vector3(0f - num, 0f, 1f)
			};
			int[][] obj = new int[20][]
			{
				new int[3] { 0, 11, 5 },
				new int[3] { 0, 5, 1 },
				new int[3] { 0, 1, 7 },
				new int[3] { 0, 7, 10 },
				new int[3] { 0, 10, 11 },
				new int[3] { 1, 5, 9 },
				new int[3] { 5, 11, 4 },
				new int[3] { 11, 10, 2 },
				new int[3] { 10, 7, 6 },
				new int[3] { 7, 1, 8 },
				new int[3] { 3, 9, 4 },
				new int[3] { 3, 4, 2 },
				new int[3] { 3, 2, 6 },
				new int[3] { 3, 6, 8 },
				new int[3] { 3, 8, 9 },
				new int[3] { 4, 9, 5 },
				new int[3] { 2, 4, 11 },
				new int[3] { 6, 2, 10 },
				new int[3] { 8, 6, 7 },
				new int[3] { 9, 8, 1 }
			};
			List<Vector3> list = new List<Vector3>(60);
			List<int> list2 = new List<int>(60);
			int[][] array2 = obj;
			foreach (int[] array3 in array2)
			{
				foreach (int num2 in array3)
				{
					list2.Add(list.Count);
					list.Add(((Vector3)(ref array[num2])).normalized * radius);
				}
			}
			Mesh val = new Mesh
			{
				name = "FichaIcosaedro"
			};
			val.SetVertices(list);
			val.SetTriangles(list2, 0);
			val.RecalculateNormals();
			val.RecalculateBounds();
			return val;
		}

		private static Sprite GetIcon()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_00e1: 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_009c: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_icon != (Object)null)
			{
				return _icon;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.9f, 0.72f, 0.2f, 1f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.55f, 0.4f, 0.08f, 1f);
			Color val4 = default(Color);
			((Color)(ref val4))..ctor(0f, 0f, 0f, 0f);
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					int num = Mathf.Abs(j - 32) + Mathf.Abs(i - 32);
					val.SetPixel(j, i, (num <= 26) ? ((num > 22) ? val3 : val2) : val4);
				}
			}
			val.Apply();
			_icon = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f), 100f);
			return _icon;
		}

		internal static void RegisterNetworkPrefab()
		{
			if (!((Object)(object)TokenPrefab == (Object)null) && !((Object)(object)NetworkManager.Singleton == (Object)null) && !NetworkManager.Singleton.NetworkConfig.Prefabs.Contains(TokenPrefab))
			{
				NetworkManager.Singleton.AddNetworkPrefab(TokenPrefab);
				Plugin.Log.LogInfo((object)"Prefab de la Ficha registrado en red.");
			}
		}

		internal static void SetupEarlyInGame()
		{
			if (!((Object)(object)Token == (Object)null) && !((Object)(object)StartOfRound.Instance == (Object)null))
			{
				EnrichFromGift();
				RegisterInAllItemsList();
			}
		}

		internal static void SetupInGame()
		{
			if (!((Object)(object)Token == (Object)null) && !((Object)(object)StartOfRound.Instance == (Object)null))
			{
				SetupEarlyInGame();
				AddToLevels();
				Terminal val = Object.FindObjectOfType<Terminal>();
				if ((Object)(object)val != (Object)null)
				{
					RegisterInShop(val);
				}
				else
				{
					Plugin.Log.LogWarning((object)"No encontré la Terminal para registrar la compra de fichas.");
				}
			}
		}

		private static void EnrichFromGift()
		{
			if (!_enriched)
			{
				List<Item> itemsList = StartOfRound.Instance.allItemsList.itemsList;
				Item val = ((IEnumerable<Item>)itemsList).FirstOrDefault((Func<Item, bool>)((Item x) => (Object)(object)x != (Object)null && (Object)(object)x.spawnPrefab != (Object)null && (Object)(object)x.spawnPrefab.GetComponent<GiftBoxItem>() != (Object)null)) ?? ((IEnumerable<Item>)itemsList).FirstOrDefault((Func<Item, bool>)((Item x) => (Object)(object)x != (Object)null && x.itemName == "Gift"));
				if ((Object)(object)val == (Object)null)
				{
					Plugin.Log.LogWarning((object)"No encontré el ítem 'Gift'; la Ficha usará valores por defecto.");
					return;
				}
				Token.spawnPositionTypes = new List<ItemGroup>(val.spawnPositionTypes);
				Token.grabSFX = val.grabSFX;
				Token.dropSFX = val.dropSFX;
				Token.pocketSFX = val.pocketSFX;
				Token.throwSFX = val.throwSFX;
				Token.grabAnim = val.grabAnim;
				Token.pocketAnim = val.pocketAnim;
				Token.grabAnimationTime = val.grabAnimationTime;
				Token.floorYOffset = val.floorYOffset;
				_enriched = true;
			}
		}

		private static void RegisterInAllItemsList()
		{
			List<Item> itemsList = StartOfRound.Instance.allItemsList.itemsList;
			if (!itemsList.Contains(Token))
			{
				itemsList.Add(Token);
			}
		}

		private static void AddToLevels()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel val in levels)
			{
				if (!((Object)(object)val == (Object)null) && val.spawnableScrap != null && !val.spawnableScrap.Any((SpawnableItemWithRarity s) => s != null && (Object)(object)s.spawnableItem == (Object)(object)Token))
				{
					int num = ((IEnumerable<SpawnableItemWithRarity>)val.spawnableScrap).FirstOrDefault((Func<SpawnableItemWithRarity, bool>)((SpawnableItemWithRarity s) => s != null && (Object)(object)s.spawnableItem != (Object)null && (s.spawnableItem.itemName == "Gift" || ((Object)(object)s.spawnableItem.spawnPrefab != (Object)null && (Object)(object)s.spawnableItem.spawnPrefab.GetComponent<GiftBoxItem>() != (Object)null))))?.rarity ?? Plugin.TokenFallbackRarity.Value;
					if (num > 0)
					{
						val.spawnableScrap.Add(new SpawnableItemWithRarity(Token, num));
					}
				}
			}
			Plugin.Log.LogInfo((object)"Ficha añadida a las lunas con la rareza del Regalo.");
		}

		private static void RegisterInShop(Terminal terminal)
		{
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Expected O, but got Unknown
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Expected O, but got Unknown
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Expected O, but got Unknown
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Expected O, but got Unknown
			List<Item> list = terminal.buyableItemsList.ToList();
			if (!list.Contains(Token))
			{
				list.Add(Token);
			}
			terminal.buyableItemsList = list.ToArray();
			int buyItemIndex = list.IndexOf(Token);
			int num = terminal.buyableItemsList.Length + terminal.buyableVehicles.Length;
			if (terminal.itemSalesPercentages == null || terminal.itemSalesPercentages.Length < num)
			{
				int num2 = ((terminal.itemSalesPercentages != null) ? terminal.itemSalesPercentages.Length : 0);
				int[] array = terminal.itemSalesPercentages ?? new int[0];
				Array.Resize(ref array, num);
				for (int i = num2; i < num; i++)
				{
					array[i] = 100;
				}
				terminal.itemSalesPercentages = array;
				Plugin.Log.LogInfo((object)$"Array de ofertas del terminal ampliado a {num}.");
			}
			if ((Object)(object)_buyNode1 != (Object)null && (Object)(object)_buyNode2 != (Object)null)
			{
				_buyNode1.buyItemIndex = buyItemIndex;
				_buyNode2.buyItemIndex = buyItemIndex;
			}
			else if (!terminal.terminalNodes.allKeywords.Any((TerminalKeyword k) => (Object)(object)k != (Object)null && k.word == "ficha"))
			{
				TerminalKeyword val = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "buy");
				TerminalKeyword val2 = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "confirm");
				TerminalKeyword val3 = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "deny");
				TerminalKeyword val4 = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "info");
				TerminalNode result = val.compatibleNouns[0].result.terminalOptions[1].result;
				int value = Plugin.TokenBuyPrice.Value;
				_buyNode2 = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)_buyNode2).name = "FichaBuyNode2";
				_buyNode2.displayText = "Ordered [variableAmount] Fichas. Your new balance is [playerCredits].\n\nLa maquina de mejoras espera tu proxima visita.\r\n\r\n";
				_buyNode2.clearPreviousText = true;
				_buyNode2.maxCharactersToType = 15;
				_buyNode2.buyItemIndex = buyItemIndex;
				_buyNode2.isConfirmationNode = false;
				_buyNode2.itemCost = value;
				_buyNode2.playSyncedClip = 0;
				_buyNode1 = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)_buyNode1).name = "FichaBuyNode1";
				_buyNode1.displayText = "You have requested to order Fichas. Amount: [variableAmount].\nTotal cost of items: [totalCost].\n\nPlease CONFIRM or DENY.\r\n\r\n";
				_buyNode1.clearPreviousText = true;
				_buyNode1.maxCharactersToType = 35;
				_buyNode1.buyItemIndex = buyItemIndex;
				_buyNode1.isConfirmationNode = true;
				_buyNode1.overrideOptions = true;
				_buyNode1.itemCost = value;
				_buyNode1.terminalOptions = (CompatibleNoun[])(object)new CompatibleNoun[2]
				{
					new CompatibleNoun(val2, _buyNode2),
					new CompatibleNoun(val3, result)
				};
				TerminalKeyword val5 = ScriptableObject.CreateInstance<TerminalKeyword>();
				((Object)val5).name = "FichaKeyword";
				val5.word = "ficha";
				val5.isVerb = false;
				val5.defaultVerb = val;
				List<TerminalKeyword> list2 = terminal.terminalNodes.allKeywords.ToList();
				list2.Add(val5);
				terminal.terminalNodes.allKeywords = list2.ToArray();
				List<CompatibleNoun> list3 = val.compatibleNouns.ToList();
				list3.Add(new CompatibleNoun(val5, _buyNode1));
				val.compatibleNouns = list3.ToArray();
				TerminalNode val6 = ScriptableObject.CreateInstance<TerminalNode>();
				((Object)val6).name = "FichaInfoNode";
				val6.displayText = "FICHA\nMoneda romboidal de oro.\nInsertala en la maquina de mejoras de la nave para potenciar tus habilidades... o vendela a la Compania.\n\n";
				val6.clearPreviousText = true;
				val6.maxCharactersToType = 25;
				List<CompatibleNoun> list4 = val4.compatibleNouns.ToList();
				list4.Add(new CompatibleNoun(val5, val6));
				val4.compatibleNouns = list4.ToArray();
				Plugin.Log.LogInfo((object)$"Ficha en la terminal: \"buy ficha\" por {value} créditos.");
			}
		}
	}
	public class TokenShipAnchor : MonoBehaviour
	{
		private GrabbableObject _item;

		private float _timer;

		private void Start()
		{
			_item = ((Component)this).GetComponent<GrabbableObject>();
		}

		private void LateUpdate()
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_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)
			if ((Object)(object)_item == (Object)null || _item.isHeld || _item.isPocketed || _item.isHeldByEnemy)
			{
				return;
			}
			_timer += Time.deltaTime;
			if (_timer < 0.25f)
			{
				return;
			}
			_timer = 0f;
			StartOfRound instance = StartOfRound.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Transform val = (_item.isInElevator ? instance.elevatorTransform : instance.propsContainer);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)this).transform.parent == (Object)(object)val))
			{
				Transform parent = ((Component)this).transform.parent;
				if (!((Object)(object)parent != (Object)null) || !((Object)(object)parent != (Object)(object)instance.elevatorTransform) || !((Object)(object)parent != (Object)(object)instance.propsContainer))
				{
					Vector3 position = ((Component)this).transform.position;
					((Component)this).transform.SetParent(val, true);
					_item.targetFloorPosition = val.InverseTransformPoint(position);
					_item.startFallingPosition = _item.targetFloorPosition;
				}
			}
		}
	}
	public enum UpgradeSkill
	{
		Health,
		Stamina,
		Strength,
		Inventory
	}
	public static class UpgradeInfo
	{
		public const int SkillCount = 4;

		public static int MaxLevel(UpgradeSkill skill)
		{
			if (skill != UpgradeSkill.Health && skill != UpgradeSkill.Stamina)
			{
				return 3;
			}
			return 4;
		}

		public static string DisplayName(UpgradeSkill skill)
		{
			return skill switch
			{
				UpgradeSkill.Health => "HEALTH", 
				UpgradeSkill.Stamina => "STAMINA", 
				UpgradeSkill.Strength => "STRENGTH", 
				UpgradeSkill.Inventory => "INVENTORY", 
				_ => "???", 
			};
		}

		public static string NextEffect(UpgradeSkill skill, int currentLevel)
		{
			if (currentLevel >= MaxLevel(skill))
			{
				return "MAX LEVEL REACHED";
			}
			switch (skill)
			{
			case UpgradeSkill.Health:
				if (currentLevel >= 3)
				{
					return "SECOND WIND: survive a lethal hit with 1 HP";
				}
				return "+33% max health";
			case UpgradeSkill.Stamina:
				if (currentLevel >= 3)
				{
					return "GOOD LEGS: jumping costs no stamina";
				}
				return "+33% stamina bar";
			case UpgradeSkill.Strength:
				return "-25% carry weight + 50% melee damage";
			case UpgradeSkill.Inventory:
				return "+1 inventory slot";
			default:
				return "";
			}
		}
	}
	public class PlayerUpgrades
	{
		private readonly int[] _levels = new int[4];

		public float HealthMultiplier => 1f + 0.33f * (float)Mathf.Min(GetLevel(UpgradeSkill.Health), 3);

		public bool HasSecondWind => GetLevel(UpgradeSkill.Health) >= 4;

		public float StaminaMultiplier => 1f + 1f / 3f * (float)Mathf.Min(GetLevel(UpgradeSkill.Stamina), 3);

		public bool HasGoodLegs => GetLevel(UpgradeSkill.Stamina) >= 4;

		public float MeleeMultiplier => 1f + 0.5f * (float)GetLevel(UpgradeSkill.Strength);

		public int ExtraSlots => GetLevel(UpgradeSkill.Inventory);

		public int GetLevel(UpgradeSkill skill)
		{
			return _levels[(int)skill];
		}

		public bool CanUpgrade(UpgradeSkill skill)
		{
			return GetLevel(skill) < UpgradeInfo.MaxLevel(skill);
		}

		public bool TryUpgrade(UpgradeSkill skill)
		{
			if (!CanUpgrade(skill))
			{
				return false;
			}
			_levels[(int)skill]++;
			return true;
		}

		public bool TryDowngrade(UpgradeSkill skill)
		{
			if (_levels[(int)skill] <= 0)
			{
				return false;
			}
			_levels[(int)skill]--;
			return true;
		}

		public void ResetAll()
		{
			for (int i = 0; i < _levels.Length; i++)
			{
				_levels[i] = 0;
			}
		}

		public int[] ExportLevels()
		{
			return (int[])_levels.Clone();
		}

		public void ImportLevels(int[] levels)
		{
			if (levels != null)
			{
				for (int i = 0; i < _levels.Length && i < levels.Length; i++)
				{
					_levels[i] = Mathf.Clamp(levels[i], 0, UpgradeInfo.MaxLevel((UpgradeSkill)i));
				}
			}
		}
	}
	public class UpgradeMenuUI : MonoBehaviour
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__Close;
		}

		private GameObject _root;

		private PlayerControllerB _player;

		private readonly TextMeshProUGUI[] _effectLabels = (TextMeshProUGUI[])(object)new TextMeshProUGUI[4];

		private readonly TextMeshProUGUI[] _buttonLabels = (TextMeshProUGUI[])(object)new TextMeshProUGUI[4];

		private readonly Button[] _buttons = (Button[])(object)new Button[4];

		private readonly Button[] _minusButtons = (Button[])(object)new Button[4];

		private readonly Image[][] _pips = new Image[4][];

		private TextMeshProUGUI _tokensLabel;

		private TextMeshProUGUI _statusLabel;

		private TextMeshProUGUI _subtitle;

		private static readonly Color BronzeGreen = new Color(0.24f, 0.4f, 0.31f, 1f);

		private static readonly Color Bronze = new Color(0.72f, 0.53f, 0.22f, 1f);

		private static readonly Color PanelBg = new Color(0.05f, 0.07f, 0.06f, 0.94f);

		private static readonly Color PipEmpty = new Color(0.16f, 0.18f, 0.16f, 1f);

		private static readonly Color TextDim = new Color(0.62f, 0.68f, 0.62f, 1f);

		private static readonly Color WarnRed = new Color(0.85f, 0.35f, 0.25f, 1f);

		private static readonly Color OkGreen = new Color(0.45f, 0.85f, 0.45f, 1f);

		private static TMP_FontAsset _cachedFont;

		public static UpgradeMenuUI Instance { get; private set; }

		public static bool IsOpen
		{
			get
			{
				if ((Object)(object)Instance != (Object)null && (Object)(object)Instance._root != (Object)null)
				{
					return Instance._root.activeSelf;
				}
				return false;
			}
		}

		public static void Open(PlayerControllerB player)
		{
			//IL_0056: 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_001d: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				GameObject val = new GameObject("UpgradableStats_MenuHost");
				Object.DontDestroyOnLoad((Object)val);
				Instance = val.AddComponent<UpgradeMenuUI>();
				Instance.Build();
			}
			Instance._player = player;
			Instance._root.SetActive(true);
			Instance.SetStatus("", Color.clear);
			Instance.Refresh();
			player.inSpecialMenu = true;
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
			if ((Object)(object)player.cursorIcon != (Object)null)
			{
				((Behaviour)player.cursorIcon).enabled = false;
			}
			if ((Object)(object)player.cursorTip != (Object)null)
			{
				((TMP_Text)player.cursorTip).text = "";
			}
			player.hoveringOverTrigger = null;
		}

		public static void Close()
		{
			if (IsOpen)
			{
				Instance._root.SetActive(false);
				PlayerControllerB player = Instance._player;
				if ((Object)(object)player != (Object)null)
				{
					player.inSpecialMenu = false;
					Cursor.lockState = (CursorLockMode)1;
					Cursor.visible = false;
				}
				Instance._player = null;
			}
		}

		private void OnUpgradeClicked(UpgradeSkill skill)
		{
			//IL_0020: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			PlayerUpgrades localUpgrades = Plugin.LocalUpgrades;
			if (!localUpgrades.CanUpgrade(skill))
			{
				SetStatus(UpgradeInfo.DisplayName(skill) + " is already at max level.", TextDim);
				return;
			}
			if (!Plugin.FreeUpgrades.Value && !TokenItem.ConsumeOne(_player))
			{
				SetStatus("YOU NEED A FICHA — found on moons, or type \"buy ficha\" in the terminal.", WarnRed);
				return;
			}
			localUpgrades.TryUpgrade(skill);
			StatsEffects.OnUpgraded(skill);
			UpgradeSync.OnLocalLevelsChanged();
			int level = localUpgrades.GetLevel(skill);
			SetStatus($"{UpgradeInfo.DisplayName(skill)} upgraded to level {level}.", OkGreen);
			Plugin.Log.LogInfo((object)$"Mejora aplicada: {UpgradeInfo.DisplayName(skill)} -> nivel {level}");
			Refresh();
		}

		private void OnDowngradeClicked(UpgradeSkill skill)
		{
			//IL_0020: 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)
			PlayerUpgrades localUpgrades = Plugin.LocalUpgrades;
			if (!localUpgrades.TryDowngrade(skill))
			{
				SetStatus(UpgradeInfo.DisplayName(skill) + " has no upgrades to remove.", TextDim);
				return;
			}
			StatsEffects.OnLevelsEdited();
			UpgradeSync.OnLocalLevelsChanged();
			if (!Plugin.FreeUpgrades.Value)
			{
				UpgradeSync.RequestRefund(Plugin.RefundCredits.Value);
			}
			SetStatus("Upgrade refunded  at the terminal", OkGreen);
			Plugin.Log.LogInfo((object)$"Mejora retirada: {UpgradeInfo.DisplayName(skill)} -> nivel {localUpgrades.GetLevel(skill)}");
			Refresh();
		}

		private void Refresh()
		{
			//IL_005d: 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_004f: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_01a9: Unknown result type (might be due to invalid IL or missing references)
			PlayerUpgrades localUpgrades = Plugin.LocalUpgrades;
			bool value = Plugin.FreeUpgrades.Value;
			int num = TokenItem.CountInInventory(_player);
			((TMP_Text)_tokensLabel).text = (value ? "TEST MODE: FREE UPGRADES" : $"FICHAS IN YOUR INVENTORY: {num}");
			((Graphic)_tokensLabel).color = (value ? TextDim : ((num > 0) ? Bronze : TextDim));
			((TMP_Text)_subtitle).text = (value ? "UPGRADE MACHINE  //  CONFIG: MejorasGratis = true" : "UPGRADE MACHINE  //  1 FICHA PER UPGRADE");
			for (int i = 0; i < 4; i++)
			{
				UpgradeSkill skill = (UpgradeSkill)i;
				int level = localUpgrades.GetLevel(skill);
				bool flag = localUpgrades.CanUpgrade(skill);
				for (int j = 0; j < _pips[i].Length; j++)
				{
					((Graphic)_pips[i][j]).color = ((j < level) ? Bronze : PipEmpty);
				}
				((TMP_Text)_effectLabels[i]).text = UpgradeInfo.NextEffect(skill, level);
				((Selectable)_buttons[i]).interactable = flag;
				((TMP_Text)_buttonLabels[i]).text = ((!flag) ? "MAX" : (value ? "UPGRADE" : "UPGRADE · 1 FICHA"));
				Image component = ((Component)_buttons[i]).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Graphic)component).color = (Color)(flag ? BronzeGreen : new Color(0.12f, 0.13f, 0.12f));
				}
				bool flag2 = level > 0;
				((Selectable)_minusButtons[i]).interactable = flag2;
				Image component2 = ((Component)_minusButtons[i]).GetComponent<Image>();
				if ((Object)(object)component2 != (Object)null)
				{
					((Graphic)component2).color = (flag2 ? new Color(0.42f, 0.22f, 0.2f) : new Color(0.12f, 0.13f, 0.12f));
				}
			}
		}

		private void SetStatus(string text, Color color)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)_statusLabel).text = text;
			((Graphic)_statusLabel).color = color;
		}

		private void Build()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_005f: 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_00bc: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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_0124: 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_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: 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_0192: 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_01c6: 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_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: 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_0244: 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_027c: 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_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Expected O, but got Unknown
			_root = new GameObject("UpgradeCanvas");
			_root.transform.SetParent(((Component)this).transform, false);
			Canvas obj = _root.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 1000;
			CanvasScaler obj2 = _root.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			_root.AddComponent<GraphicRaycaster>();
			if ((Object)(object)EventSystem.current == (Object)null)
			{
				Plugin.Log.LogWarning((object)"No hay EventSystem en la escena: los botones podrían no responder.");
			}
			RectTransform val = NewRect("Panel", _root.transform, new Vector2(940f, 640f), Vector2.zero);
			AddImage(val, PanelBg);
			AddImage(NewRect("BarraSup", (Transform)(object)val, new Vector2(940f, 6f), new Vector2(0f, 317f)), Bronze);
			AddImage(NewRect("BarraInf", (Transform)(object)val, new Vector2(940f, 6f), new Vector2(0f, -317f)), Bronze);
			AddText((Transform)(object)val, "Titulo", "UPGRADES", new Vector2(600f, 60f), new Vector2(0f, 265f), 40f, Bronze, (TextAlignmentOptions)514);
			_subtitle = AddText((Transform)(object)val, "Sub", "UPGRADE MACHINE", new Vector2(900f, 30f), new Vector2(0f, 225f), 18f, TextDim, (TextAlignmentOptions)514);
			_tokensLabel = AddText((Transform)(object)val, "Fichas", "", new Vector2(900f, 30f), new Vector2(0f, 193f), 20f, Bronze, (TextAlignmentOptions)514);
			for (int i = 0; i < 4; i++)
			{
				BuildSkillRow(val, (UpgradeSkill)i, 128f - (float)i * 92f);
			}
			_statusLabel = AddText((Transform)(object)val, "Estado", "", new Vector2(900f, 30f), new Vector2(0f, -245f), 17f, TextDim, (TextAlignmentOptions)514);
			ButtonClickedEvent onClick = AddButton((Transform)(object)val, "Cerrar", "CLOSE  [ESC]", new Vector2(260f, 46f), new Vector2(0f, -285f), 20f).onClick;
			object obj3 = <>O.<0>__Close;
			if (obj3 == null)
			{
				UnityAction val2 = Close;
				<>O.<0>__Close = val2;
				obj3 = (object)val2;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
		}

		private void BuildSkillRow(RectTransform parent, UpgradeSkill skill, float y)
		{
			//IL_0030: 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_004b: 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_0093: 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_00e9: 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_011c: 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_015d: 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_01a2: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: 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_0200: Expected O, but got Unknown
			AddText((Transform)(object)parent, $"Nombre{(int)skill}", UpgradeInfo.DisplayName(skill), new Vector2(260f, 40f), new Vector2(-320f, y + 12f), 26f, Color.white, (TextAlignmentOptions)513);
			_effectLabels[(int)skill] = AddText((Transform)(object)parent, $"Efecto{(int)skill}", "", new Vector2(560f, 28f), new Vector2(-170f, y - 18f), 16f, TextDim, (TextAlignmentOptions)513);
			int num = UpgradeInfo.MaxLevel(skill);
			_pips[(int)skill] = (Image[])(object)new Image[num];
			for (int i = 0; i < num; i++)
			{
				RectTransform rt = NewRect($"Pip{(int)skill}_{i}", (Transform)(object)parent, new Vector2(26f, 26f), new Vector2(50f + (float)i * 34f, y + 12f));
				_pips[(int)skill][i] = AddImage(rt, PipEmpty);
			}
			Button val = AddButton((Transform)(object)parent, $"Btn{(int)skill}", "MEJORAR", new Vector2(230f, 52f), new Vector2(300f, y), 18f);
			_buttons[(int)skill] = val;
			_buttonLabels[(int)skill] = ((Component)val).GetComponentInChildren<TextMeshProUGUI>();
			UpgradeSkill captured = skill;
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				OnUpgradeClicked(captured);
			});
			Button val2 = AddButton((Transform)(object)parent, $"Minus{(int)skill}", "-", new Vector2(52f, 52f), new Vector2(440f, y), 26f);
			_minusButtons[(int)skill] = val2;
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				OnDowngradeClicked(captured);
			});
		}

		private static RectTransform NewRect(string name, Transform parent, Vector2 size, Vector2 anchoredPos)
		{
			//IL_0014: 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_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)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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)
			RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0.5f, 0.5f);
			component.pivot = val;
			Vector2 anchorMin = (component.anchorMax = val);
			component.anchorMin = anchorMin;
			component.sizeDelta = size;
			component.anchoredPosition = anchoredPos;
			return component;
		}

		private static Image AddImage(RectTransform rt, Color color)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Image obj = ((Component)rt).gameObject.AddComponent<Image>();
			((Graphic)obj).color = color;
			return obj;
		}

		private static TextMeshProUGUI AddText(Transform parent, string name, string text, Vector2 size, Vector2 pos, float fontSize, Color color, TextAlignmentOptions align)
		{
			//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_0025: 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)
			TextMeshProUGUI val = ((Component)NewRect(name, parent, size, pos)).gameObject.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val).text = text;
			((TMP_Text)val).fontSize = fontSize;
			((Graphic)val).color = color;
			((TMP_Text)val).alignment = align;
			((TMP_Text)val).enableWordWrapping = false;
			((Graphic)val).raycastTarget = false;
			TMP_FontAsset font = GetFont();
			if ((Object)(object)font != (Object)null)
			{
				((TMP_Text)val).font = font;
			}
			return val;
		}

		private static Button AddButton(Transform parent, string name, string label, Vector2 size, Vector2 pos, float fontSize)
		{
			//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_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_002f: 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_004d: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = NewRect(name, parent, size, pos);
			Image targetGraphic = AddImage(val, BronzeGreen);
			Button obj = ((Component)val).gameObject.AddComponent<Button>();
			((Selectable)obj).targetGraphic = (Graphic)(object)targetGraphic;
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.4f, 1.4f, 1.4f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.7f, 0.7f, 0.7f);
			((ColorBlock)(ref colors)).disabledColor = new Color(0.6f, 0.6f, 0.6f);
			((Selectable)obj).colors = colors;
			AddText((Transform)(object)val, "Label", label, size, Vector2.zero, fontSize, Color.white, (TextAlignmentOptions)514);
			return obj;
		}

		private static TMP_FontAsset GetFont()
		{
			if ((Object)(object)_cachedFont != (Object)null)
			{
				return _cachedFont;
			}
			_cachedFont = Resources.FindObjectsOfTypeAll<TMP_FontAsset>().FirstOrDefault();
			if ((Object)(object)_cachedFont == (Object)null)
			{
				Plugin.Log.LogWarning((object)"No encontré ninguna fuente TMP; los textos podrían no verse.");
			}
			return _cachedFont;
		}
	}
	public class UpgradesMachine : MonoBehaviour
	{
		internal static GameObject MachinePrefab;

		internal static int UnlockableIndex = -1;

		private static GameObject _prefabContainer;

		private const float Scale = 1.18f;

		private InteractTrigger _trigger;

		public static UpgradesMachine Instance { get; private set; }

		public Transform SlotTransform { get; private set; }

		private void Awake()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			Instance = this;
			Transform val = ((Component)this).transform.Find("RanuraHueco");
			if ((Object)(object)val != (Object)null)
			{
				SlotTransform = val;
			}
			_trigger = ((Component)this).GetComponentInChildren<InteractTrigger>();
			if ((Object)(object)_trigger != (Object)null)
			{
				if (_trigger.onInteract == null)
				{
					_trigger.onInteract = new InteractEvent();
				}
				if (_trigger.onInteractEarly == null)
				{
					_trigger.onInteractEarly = new InteractEvent();
				}
				if (_trigger.onInteractEarlyOtherClients == null)
				{
					_trigger.onInteractEarlyOtherClients = new InteractEvent();
				}
				if (_trigger.onStopInteract == null)
				{
					_trigger.onStopInteract = new InteractEvent();
				}
				if (_trigger.onCancelAnimation == null)
				{
					_trigger.onCancelAnimation = new InteractEvent();
				}
				if (_trigger.holdingInteractEvent == null)
				{
					_trigger.holdingInteractEvent = new InteractEventFloat();
				}
				((UnityEvent<PlayerControllerB>)(object)_trigger.onInteract).AddListener((UnityAction<PlayerControllerB>)OnPlayerInteract);
				((MonoBehaviour)this).StartCoroutine(GrabHoverIconWhenReady());
			}
			((MonoBehaviour)this).StartCoroutine(PlaceInShipRoutine());
		}

		private IEnumerator PlaceInShipRoutine()
		{
			AutoParentToShip autoParent = ((Component)this).GetComponent<AutoParentToShip>();
			if ((Object)(object)autoParent == (Object)null)
			{
				yield break;
			}
			autoParent.overrideOffset = true;
			Terminal terminal = null;
			Transform ship = null;
			for (int i = 0; i < 60; i++)
			{
				if ((Object)(object)StartOfRound.Instance != (Object)null)
				{
					ship = StartOfRound.Instance.elevatorTransform;
				}
				terminal = Object.FindObjectOfType<Terminal>();
				if ((Object)(object)ship != (Object)null && (Object)(object)terminal != (Object)null)
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.5f);
			}
			if ((Object)(object)ship == (Object)null || (Object)(object)terminal == (Object)null)
			{
				Plugin.Log.LogWarning((object)"No encontré la nave o el terminal; dejo la máquina donde está.");
				yield break;
			}
			yield return (object)new WaitForSeconds(0.5f);
			Vector3 val = ship.InverseTransformPoint(((Component)terminal).transform.position) + Plugin.MachineOffset;
			Vector3 val2 = ship.TransformPoint(val);
			float num = 180f + Plugin.MachineRotationY.Value;
			Quaternion val3 = ship.rotation * Quaternion.Euler(0f, num, 0f);
			int collidersAndRoomMaskAndDefault = StartOfRound.Instance.collidersAndRoomMaskAndDefault;
			RaycastHit val4 = default(RaycastHit);
			if (Physics.Raycast(val2 + Vector3.up * 0.6f, Vector3.down, ref val4, 6f, collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				((Vector3)(ref val2))..ctor(val2.x, ((RaycastHit)(ref val4)).point.y + 0.005f, val2.z);
			}
			Vector3 val5 = val3 * Vector3.forward;
			RaycastHit val6 = default(RaycastHit);
			if (Physics.Raycast(val2 + Vector3.up * 1f, val5, ref val6, 3f, collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				val2 += val5 * (((RaycastHit)(ref val6)).distance - 0.4248f - 0.02f);
			}
			autoParent.positionOffset = ship.InverseTransformPoint(val2);
			autoParent.rotationOffset = new Vector3(0f, num, 0f);
			autoParent.MoveToOffset();
			Plugin.Log.LogInfo((object)$"Máquina colocada en la nave. offset={autoParent.positionOffset}");
		}

		private IEnumerator GrabHoverIconWhenReady()
		{
			for (int i = 0; i < 40; i++)
			{
				if (!((Object)(object)_trigger.hoverIcon == (Object)null))
				{
					break;
				}
				Terminal val = Object.FindObjectOfType<Terminal>();
				if ((Object)(object)val != (Object)null)
				{
					InteractTrigger component = ((Component)val).GetComponent<InteractTrigger>();
					if ((Object)(object)component != (Object)null)
					{
						_trigger.hoverIcon = component.hoverIcon;
					}
					break;
				}
				yield return (object)new WaitForSeconds(0.5f);
			}
		}

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

		private void OnPlayerInteract(PlayerControllerB player)
		{
			if (!((Object)(object)player == (Object)null) && !UpgradeMenuUI.IsOpen)
			{
				UpgradeMenuUI.Open(player);
			}
		}

		internal static void RegisterNetworkPrefab()
		{
			if ((Object)(object)MachinePrefab == (Object)null)
			{
				CreatePrefabEarly();
			}
			if (!((Object)(object)MachinePrefab == (Object)null) && !((Object)(object)NetworkManager.Singleton == (Object)null) && !NetworkManager.Singleton.NetworkConfig.Prefabs.Contains(MachinePrefab))
			{
				NetworkManager.Singleton.AddNetworkPrefab(MachinePrefab);
				Plugin.Log.LogInfo((object)"Prefab de la máquina registrado en red.");
			}
		}

		internal static void RegisterUnlockable()
		{
			//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_0060: 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_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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			if (!((Object)(object)StartOfRound.Instance == (Object)null))
			{
				List<UnlockableItem> unlockables = StartOfRound.Instance.unlockablesList.unlockables;
				int num = unlockables.FindIndex((UnlockableItem u) => u != null && u.unlockableName == "Maquina de mejoras");
				if (num >= 0)
				{
					UnlockableIndex = num;
					return;
				}
				unlockables.Add(new UnlockableItem
				{
					unlockableName = "Maquina de mejoras",
					unlockableType = 1,
					IsPlaceable = false,
					alreadyUnlocked = true,
					spawnPrefab = false,
					canBeStored = false,
					maxNumber = 1
				});
				UnlockableIndex = unlockables.Count - 1;
				Plugin.Log.LogInfo((object)$"Unlockable de la máquina registrado (id {UnlockableIndex}).");
			}
		}

		internal static IEnumerator SpawnRoutine()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				yield break;
			}
			yield return (object)new WaitForSeconds(1.5f);
			if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer || (Object)(object)Instance != (Object)null)
			{
				yield break;
			}
			if ((Object)(object)MachinePrefab == (Object)null)
			{
				Plugin.Log.LogError((object)"MachinePrefab es null: no puedo spawnear la máquina.");
				yield break;
			}
			Transform val = (((Object)(object)StartOfRound.Instance != (Object)null) ? StartOfRound.Instance.elevatorTransform : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"Sin nave; no puedo spawnear la máquina.");
				yield break;
			}
			Object.Instantiate<GameObject>(MachinePrefab, val.position, val.rotation).GetComponent<NetworkObject>().Spawn(false);
			Plugin.Log.LogInfo((object)"Máquina spawneada en red.");
		}

		internal static void CreatePrefabEarly()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//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_005e: 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_0078: 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_00b7: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			if (!((Object)(object)MachinePrefab != (Object)null))
			{
				_prefabContainer = new GameObject("UpgradableStats_MachinePrefab");
				_prefabContainer.SetActive(false);
				Object.DontDestroyOnLoad((Object)(object)_prefabContainer);
				((Object)_prefabContainer).hideFlags = (HideFlags)61;
				GameObject val = new GameObject("UpgradesMachine");
				val.transform.SetParent(_prefabContainer.transform, false);
				val.transform.localScale = Vector3.one * 1.18f;
				NetworkObject obj = val.AddComponent<NetworkObject>();
				byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes("com.CommanderMechavala.upgradablestatsUpgradesMachine"));
				obj.GlobalObjectIdHash = BitConverter.ToUInt32(value, 0);
				AutoParentToShip obj2 = val.AddComponent<AutoParentToShip>();
				obj2.overrideOffset = true;
				obj2.unlockableID = -1;
				BuildColliders(torre: BuildVisuals(val.transform), parent: val.transform);
				val.AddComponent<UpgradesMachine>();
				MachinePrefab = val;
				Plugin.Log.LogInfo((object)"Prefab de la máquina construido.");
			}
		}

		private static GameObject BuildVisuals(Transform parent)
		{
			//IL_000f: 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_0026: 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_004e: 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_007c: 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_0099: 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_00d1: 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_010a: 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_0121: 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_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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_018b: 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_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_01d9: 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_020e: 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_021c: 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_024e: 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_025c: 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_028e: 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_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: 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_02dc: 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_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_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: 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_0389: 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_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: 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_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_045e: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: 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_04c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_050d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0558: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e3: 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_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0605: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Unknown result type (might be due to invalid IL or missing references)
			//IL_0640: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_0661: Unknown result type (might be due to invalid IL or missing references)
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_0695: Unknown result type (might be due to invalid IL or missing references)
			//IL_069e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0714: Unknown result type (might be due to invalid IL or missing references)
			//IL_071e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0724: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0738: Unknown result type (might be due to invalid IL or missing references)
			//IL_0744: 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)
			Material mat = MakeMaterial(new Color(0.1f, 0.42f, 0.33f), 0.25f, 0.55f);
			Material mat2 = MakeMaterial(new Color(0.06f, 0.28f, 0.22f), 0.25f, 0.5f);
			Material mat3 = MakeMaterial(new Color(0.32f, 0.86f, 0.64f), 0.2f, 0.65f);
			Material mat4 = MakeMaterial(new Color(0.55f, 0.95f, 0.8f), 0.1f, 0.7f, new Color(0.35f, 0.8f, 0.6f));
			Material mat5 = MakeMaterial(new Color(0.03f, 0.09f, 0.11f), 0.05f, 0.92f, new Color(0.05f, 0.13f, 0.17f));
			Material mat6 = MakeMaterial(new Color(0.02f, 0.02f, 0.02f), 0.2f, 0.3f);
			Material mat7 = MakeMaterial(new Color(0.75f, 0.55f, 0.12f), 1f, 0.7f);
			GameObject result = AddPrim(parent, (PrimitiveType)3, "Torre", new Vector3(0f, 0.86f, 0.1f), new Vector3(0.78f, 1.72f, 0.5f), mat);
			AddPrim(parent, (PrimitiveType)2, "TorreRedondeo", new Vector3(0f, 1.69f, 0.1f), new Vector3(0.5f, 0.39f, 0.5f), mat, new Vector3(0f, 0f, 90f));
			AddPrim(parent, (PrimitiveType)3, "Marquesina", new Vector3(0f, 1.55f, -0.24f), new Vector3(0.82f, 0.26f, 0.34f), mat);
			AddPrim(parent, (PrimitiveType)3, "MarquesinaMarco", new Vector3(0f, 1.55f, -0.415f), new Vector3(0.7f, 0.18f, 0.03f), mat3);
			AddPrim(parent, (PrimitiveType)3, "MarquesinaLuz", new Vector3(0f, 1.55f, -0.428f), new Vector3(0.62f, 0.11f, 0.02f), mat4);
			AddPrim(parent, (PrimitiveType)3, "PantallaMarco", new Vector3(0f, 1.13f, -0.155f), new Vector3(0.71999997f, 0.5f, 0.07f), mat2).transform.localRotation = Quaternion.Euler(15f, 0f, 0f);
			AddPrim(parent, (PrimitiveType)3, "PantallaCristal", new Vector3(0f, 1.13f, -0.195f), new Vector3(0.55999994f, 0.38f, 0.02f), mat5).transform.localRotation = Quaternion.Euler(15f, 0f, 0f);
			AddPrim(parent, (PrimitiveType)3, "LateralIzq", new Vector3(-0.36659998f, 1.13f, -0.1f), new Vector3(0.06f, 0.55f, 0.42f), mat);
			AddPrim(parent, (PrimitiveType)3, "LateralDer", new Vector3(0.36659998f, 1.13f, -0.1f), new Vector3(0.06f, 0.55f, 0.42f), mat);
			AddPrim(parent, (PrimitiveType)3, "Pod", new Vector3(0f, 0.85f, -0.43f), new Vector3(0.78f, 0.15f, 0.32f), mat3);
			AddPrim(parent, (PrimitiveType)2, "PodBorde", new Vector3(0f, 0.85f, -0.585f), new Vector3(0.15f, 0.39f, 0.15f), mat3, new Vector3(0f, 0f, 90f));
			for (int i = 0; i < 2; i++)
			{
				float num = ((i == 0) ? (-0.16f) : 0.16f);
				AddPrim(parent, (PrimitiveType)2, $"JoystickPalo{i}", new Vector3(num, 0.965f, -0.47f), new Vector3(0.025f, 0.045f, 0.025f), mat2);
				AddPrim(parent, (PrimitiveType)0, $"JoystickBola{i}", new Vector3(num, 1.02f, -0.47f), new Vector3(0.055f, 0.055f, 0.055f), mat3);
			}
			for (int j = 0; j < 4; j++)
			{
				float num2 = -0.24f + (float)j * 0.16f;
				AddPrim(parent, (PrimitiveType)0, $"Boton{j}", new Vector3(num2, 0.87f, -0.6f), new Vector3(0.045f, 0.045f, 0.045f), mat4);
			}
			AddPrim(parent, (PrimitiveType)3, "CuerpoBajo", new Vector3(0f, 0.4f, -0.1f), new Vector3(0.78f, 0.8f, 0.56f), mat);
			AddPrim(parent, (PrimitiveType)3, "Base", new Vector3(0f, 0.05f, -0.02f), new Vector3(0.82f, 0.1f, 0.62f), mat2);
			AddPrim(parent, (PrimitiveType)3, "RanuraBisel", new Vector3(0f, 0.62f, -0.385f), new Vector3(0.15f, 0.15f, 0.03f), mat7).transform.localRotation = Quaternion.Euler(0f, 0f, 45f);
			AddPrim(parent, (PrimitiveType)3, "RanuraHueco", new Vector3(0f, 0.62f, -0.4f), new Vector3(0.1f, 0.1f, 0.03f), mat6).transform.localRotation = Quaternion.Euler(0f, 0f, 45f);
			GameObject val = new GameObject("PantallaHolo");
			val.transform.SetParent(parent, false);
			val.transform.localPosition = new Vector3(0f, 1.13f, -0.218f);
			val.transform.localRotation = Quaternion.Euler(15f, 0f, 0f);
			val.transform.localScale = Vector3.one * 0.01f;
			val.AddComponent<Canvas>().renderMode = (RenderMode)2;
			val.GetComponent<RectTransform>().sizeDelta = new Vector2(52f, 36f);
			val.AddComponent<MachineScreenFx>();
			return result;
		}

		private static void BuildColliders(Transform parent, GameObject torre)
		{
			//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_0022: 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: 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_0072: 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_00f0: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("InteractTrigger");
			val.transform.SetParent(parent, false);
			int num = LayerMask.NameToLayer("InteractableObject");
			val.layer = ((num >= 0) ? num : 9);
			val.tag = "InteractTrigger";
			BoxCollider obj = val.AddComponent<BoxCollider>();
			((Collider)obj).isTrigger = true;
			obj.center = new Vector3(0f, 0.95f, -0.1f);
			obj.size = new Vector3(0.95f, 1.95f, 1.05f);
			InteractTrigger obj2 = val.AddComponent<InteractTrigger>();
			obj2.interactable = true;
			obj2.hoverTip = "Upgrades : [E]";
			obj2.disabledHoverTip = "";
			obj2.holdInteraction = false;
			obj2.interactCooldown = false;
			obj2.currentCooldownValue = -1f;
			obj2.triggerOnce = false;
			obj2.touchTrigger = false;
			obj2.specialCharacterAnimation = false;
			obj2.oneHandedItemAllowed = true;
			obj2.twoHandedItemAllowed = false;
			GameObject val2 = new GameObject("Blocker");
			val2.transform.SetParent(parent, false);
			val2.layer = 0;
			BoxCollider obj3 = val2.AddComponent<BoxCollider>();
			((Collider)obj3).isTrigger = false;
			obj3.center = new Vector3(0f, 0.88f, 0f);
			obj3.size = new Vector3(0.8f, 1.74f, 0.75f);
		}

		private static GameObject AddPrim(Transform parent, PrimitiveType type, string name, Vector3 localPos, Vector3 scale, Material mat, Vector3 rotEuler = default(Vector3))
		{
			//IL_0000: 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_0040: 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)
			GameObject obj = GameObject.CreatePrimitive(type);
			((Object)obj).name = name;
			obj.layer = 0;
			obj.transform.SetParent(parent, false);
			obj.transform.localPosition = localPos;
			obj.transform.localScale = scale;
			obj.transform.localRotation = Quaternion.Euler(rotEuler);
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				Object.DestroyImmediate((Object)(object)component);
			}
			MeshRenderer component2 = obj.GetComponent<MeshRenderer>();
			if ((Object)(object)component2 != (Object)null && (Object)(object)mat != (Object)null)
			{
				((Renderer)component2).sharedMaterial = mat;
			}
			return obj;
		}

		internal static Material MakeMaterial(Color color, float metallic, float smooth, Color emission = default(Color))
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_003f: 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_00a9: 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_00b2: 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_00f0: Unknown result type (might be due to invalid IL or missing references)
			Material val = new Material(Shader.Find("HDRP/Lit") ?? Shader.Find("Standard") ?? Shader.Find("Diffuse"));
			if (val.HasProperty("_BaseColor"))
			{
				val.SetColor("_BaseColor", color);
			}
			if (val.HasProperty("_Color"))
			{
				val.SetColor("_Color", color);
			}
			if (val.HasProperty("_Metallic"))
			{
				val.SetFloat("_Metallic", metallic);
			}
			if (val.HasProperty("_Smoothness"))
			{
				val.SetFloat("_Smoothness", smooth);
			}
			if (val.HasProperty("_Glossiness"))
			{
				val.SetFloat("_Glossiness", smooth);
			}
			if (emission != default(Color) && val.HasProperty("_EmissiveColor"))
			{
				if (val.HasProperty("_UseEmissiveIntensity"))
				{
					val.SetFloat("_UseEmissiveIntensity", 0f);
				}
				val.SetColor("_EmissiveColor", emission * 1.6f);
			}
			return val;
		}
	}
	internal static class UpgradeSync
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static HandleNamedMessageDelegate <0>__OnReport;

			public static HandleNamedMessageDelegate <1>__OnRequest;

			public static HandleNamedMessageDelegate <2>__OnRestore;

			public static HandleNamedMessageDelegate <3>__OnRefund;
		}

		private const string MsgReport = "UpgStats_Report";

		private const string MsgRequest = "UpgStats_Request";

		private const string MsgRestore = "UpgStats_Restore";

		private const string MsgRefund = "UpgStats_Refund";

		private const string SaveKey = "UpgradableStats_Levels";

		private static readonly Dictionary<ulong, int[]> AllPlayerLevels = new Dictionary<ulong, int[]>();

		private static bool _handlersRegistered;

		private static ulong _resolvedId;

		private static bool _restored;

		private static NetworkManager Net => NetworkManager.Singleton;

		private static PlayerControllerB Local
		{
			get
			{
				if (!((Object)(object)GameNetworkManager.Instance != (Object)null))
				{
					return null;
				}
				return GameNetworkManager.Instance.localPlayerController;
			}
		}

		private static ulong LocalPlayerId()
		{
			if (_resolvedId != 0L)
			{
				return _resolvedId;
			}
			PlayerControllerB local = Local;
			if ((Object)(object)local == (Object)null)
			{
				return 0uL;
			}
			if (local.playerSteamId != 0L)
			{
				return local.playerSteamId;
			}
			return (uint)(local.playerUsername ?? "player").GetHashCode();
		}

		private static IEnumerator ResolveIdRoutine()
		{
			_resolvedId = 0uL;
			for (int i = 0; i < 40; i++)
			{
				PlayerControllerB local = Local;
				if ((Object)(object)local != (Object)null && local.playerSteamId != 0L)
				{
					_resolvedId = local.playerSteamId;
					Plugin.Log.LogInfo((object)$"Identidad de guardado: SteamID {_resolvedId}");
					yield break;
				}
				yield return (object)new WaitForSeconds(0.25f);
			}
			PlayerControllerB local2 = Local;
			_resolvedId = (uint)((((Object)(object)local2 != (Object)null) ? local2.playerUsername : null) ?? "player").GetHashCode();
			Plugin.Log.LogInfo((object)$"Identidad de guardado (sin SteamID): {_resolvedId}");
		}

		internal static IEnumerator SessionStartRoutine()
		{
			Plugin.LocalUpgrades.ResetAll();
			_restored = false;
			for (int i = 0; i < 40; i++)
			{
				if (!((Object)(object)Net == (Object)null) && Net.IsListening && !((Object)(object)Local == (Object)null))
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.25f);
			}
			if ((Object)(object)Net == (Object)null || !Net.IsListening || (Object)(object)Local == (Object)null)
			{
				yield break;
			}
			_handlersRegistered = false;
			RegisterHandlers();
			yield return ResolveIdRoutine();
			if (Net.IsServer)
			{
				LoadFromFile();
				if (AllPlayerLevels.TryGetValue(LocalPlayerId(), out var value))
				{
					Plugin.LocalUpgrades.ImportLevels(value);
					_restored = true;
					Plugin.Log.LogInfo((object)("Mejoras del host restauradas: [" + string.Join(",", value) + "]"));
				}
			}
			else
			{
				for (int i = 0; i < 10; i++)
				{
					if (_restored)
					{
						break;
					}
					SendRequest();
					yield return (object)new WaitForSeconds(1.5f);
				}
				if (!_restored)
				{
					Plugin.Log.LogInfo((object)"El host no tiene mejoras guardadas para mí (o soy nuevo en esta partida).");
				}
			}
			yield return (object)new WaitForSeconds(0.5f);
			StatsEffects.ReapplyAll(Local);
		}

		private unsafe static void SendRequest()
		{
			//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_004d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Net == (Object)null || !Net.IsListening)
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(8, (Allocator)2, -1);
			try
			{
				ulong num = LocalPlayerId();
				((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref num, default(ForPrimitives));
				Net.CustomMessagingManager.SendNamedMessage("UpgStats_Request", 0uL, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		internal unsafe static void RequestRefund(int credits)
		{
			//IL_004e: 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)
			if (credits <= 0)
			{
				return;
			}
			if ((Object)(object)Net != (Object)null && Net.IsServer)
			{
				GiveCredits(credits);
			}
			else if ((Object)(object)Net != (Object)null && Net.IsListening)
			{
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(4, (Allocator)2, -1);
				try
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref credits, default(ForPrimitives));
					Net.CustomMessagingManager.SendNamedMessage("UpgStats_Refund", 0uL, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}

		private static void OnRefund(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Net == (Object)null) && Net.IsServer)
			{
				int credits = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref credits, default(ForPrimitives));
				GiveCredits(credits);
			}
		}

		private static void GiveCredits(int credits)
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			if (!((Object)(object)val == (Object)null))
			{
				val.groupCredits += credits;
				val.SyncGroupCreditsServerRpc(val.groupCredits, val.numberOfItemsInDropship);
				Plugin.Log.LogInfo((object)$"Reembolso: +{credits} créditos (saldo {val.groupCredits}).");
			}
		}

		internal static void SaveNow()
		{
			if (!((Object)(object)Net == (Object)null) && Net.IsServer)
			{
				SaveToFile();
				Plugin.Log.LogInfo((object)$"Mejoras guardadas con la partida ({AllPlayerLevels.Count} jugador(es)).");
			}
		}

		internal static void ClearAllSavedLevels()
		{
			_restored = false;
			if (!((Object)(object)Net == (Object)null) && Net.IsServer)
			{
				AllPlayerLevels.Clear();
				SaveToFile();
				Plugin.Log.LogInfo((object)"Partida perdida: borradas las mejoras guardadas de todos los jugadores.");
			}
		}

		private static void RegisterHandlers()
		{
			//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: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//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_00a3: Expected O, but got Unknown
			//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_00d2: Expected O, but got Unknown
			if (!_handlersRegistered && !((Object)(object)Net == (Object)null))
			{
				_handlersRegistered = true;
				CustomMessagingManager customMessagingManager = Net.CustomMessagingManager;
				object obj = <>O.<0>__OnReport;
				if (obj == null)
				{
					HandleNamedMessageDelegate val = OnReport;
					<>O.<0>__OnReport = val;
					obj = (object)val;
				}
				customMessagingManager.RegisterNamedMessageHandler("UpgStats_Report", (HandleNamedMessageDelegate)obj);
				CustomMessagingManager customMessagingManager2 = Net.CustomMessagingManager;
				object obj2 = <>O.<1>__OnRequest;
				if (obj2 == null)
				{
					HandleNamedMessageDelegate val2 = OnRequest;
					<>O.<1>__OnRequest = val2;
					obj2 = (object)val2;
				}
				customMessagingManager2.RegisterNamedMessageHandler("UpgStats_Request", (HandleNamedMessageDelegate)obj2);
				CustomMessagingManager customMessagingManager3 = Net.CustomMessagingManager;
				object obj3 = <>O.<2>__OnRestore;
				if (obj3 == null)
				{
					HandleNamedMessageDelegate val3 = OnRestore;
					<>O.<2>__OnRestore = val3;
					obj3 = (object)val3;
				}
				customMessagingManager3.RegisterNamedMessageHandler("UpgStats_Restore", (HandleNamedMessageDelegate)obj3);
				CustomMessagingManager customMessagingManager4 = Net.CustomMessagingManager;
				object obj4 = <>O.<3>__OnRefund;
				if (obj4 == null)
				{
					HandleNamedMessageDelegate val4 = OnRefund;
					<>O.<3>__OnRefund = val4;
					obj4 = (object)val4;
				}
				customMessagingManager4.RegisterNamedMessageHandler("UpgStats_Refund", (HandleNamedMessageDelegate)obj4);
				Plugin.Log.LogInfo((object)"Canales de sincronización registrados.");
			}
		}

		internal unsafe static void OnLocalLevelsChanged()
		{
			//IL_0061: 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_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_00a6: Unknown result type (might be due to invalid IL or missing references)
			int[] array = Plugin.LocalUpgrades.ExportLevels();
			ulong key = LocalPlayerId();
			if ((Object)(object)Net != (Object)null && Net.IsServer)
			{
				AllPlayerLevels[key] = array;
			}
			else
			{
				if (!((Object)(object)Net != (Object)null) || !Net.IsListening)
				{
					return;
				}
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(24, (Allocator)2, -1);
				try
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<ulong>(ref key, default(ForPrimitives));
					for (int i = 0; i < 4; i++)
					{
						((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref array[i], default(ForPrimitives));
					}
					Net.CustomMessagingManager.SendNamedMessage("UpgStats_Report", 0uL, val, (NetworkDelivery)3);
				}
				finally
				{
					((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}

		private static void OnReport(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0020: 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_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Net == (Object)null) && Net.IsServer)
			{
				ulong num = default(ulong);
				((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref num, default(ForPrimitives));
				int[] array = new int[4];
				for (int i = 0; i < 4; i++)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref array[i], default(ForPrimitives));
				}
				AllPlayerLevels[num] = array;
				Plugin.Log.LogInfo((object)string.Format("Niveles recibidos de {0}: [{1}]", num, string.Join(",", array)));
			}
		}

		private unsafe static void OnRequest(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0020: 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_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_007f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Net == (Object)null || !Net.IsServer)
			{
				return;
			}
			ulong key = default(ulong);
			((FastBufferReader)(ref reader)).ReadValueSafe<ulong>(ref key, default(ForPrimitives));
			if (!AllPlayerLevels.TryGetValue(key, out var value))
			{
				return;
			}
			FastBufferWriter val = default(FastBufferWriter);
			((FastBufferWriter)(ref val))..ctor(16, (Allocator)2, -1);
			try
			{
				for (int i = 0; i < 4; i++)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref value[i], default(ForPrimitives));
				}
				Net.CustomMessagingManager.SendNamedMessage("UpgStats_Restore", senderClientId, val, (NetworkDelivery)3);
			}
			finally
			{
				((IDisposable)(*(FastBufferWriter*)(&val))/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static void OnRestore(ulong senderClientId, FastBufferReader reader)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			int[] array = new int[4];
			for (int i = 0; i < 4; i++)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref array[i], default(ForPrimitives));
			}
			_restored = true;
			Plugin.LocalUpgrades.ImportLevels(array);
			StatsEffects.ReapplyAll(Local);
			Plugin.Log.LogInfo((object)("Mejoras restauradas desde el host: [" + string.Join(",", array) + "]"));
		}

		private static void SaveToFile()
		{
			if (!((Object)(object)GameNetworkManager.Instance == (Object)null))
			{
				string text = string.Join(";", AllPlayerLevels.Select((KeyValuePair<ulong, int[]> kv) => string.Format("{0}:{1}", kv.Key, string.Join(",", kv.Value))));
				ES3.Save<string>("UpgradableStats_Levels", text, GameNetworkManager.Instance.currentSaveFileName);
			}
		}

		private static void LoadFromFile()
		{
			AllPlayerLevels.Clear();
			if ((Object)(object)GameNetworkManager.Instance == (Object)null)
			{
				return;
			}
			string text = ES3.Load<string>("UpgradableStats_Levels", GameNetworkManager.Instance.currentSaveFileName, "");
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			string[] array = text.Split(';');
			for (int i = 0; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(':');
				if (array2.Length == 2 && ulong.TryParse(array2[0], out var result))
				{
					int[] array3 = new int[4];
					string[] array4 = array2[1].Split(',');
					for (int j = 0; j < 4 && j < array4.Length; j++)
					{
						int.TryParse(array4[j], out array3[j]);
					}
					AllPlayerLevels[result] = array3;
				}
			}
			Plugin.Log.LogInfo((object)$"Mejoras cargadas de la partida: {AllPlayerLevels.Count} jugador(es).");
		}

		internal static void EnsureRemotePlayersSlots()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val == (Object)(object)Local) && val.ItemSlots != null && val.ItemSlots.Length < 7)
				{
					GrabbableObject[] array = val.ItemSlots;
					Array.Resize(ref array, 7);
					val.ItemSlots = array;
				}
			}
		}
	}
	internal static class VignetteOverlay
	{
		private static readonly Color GreenEdge = new Color(0.05f, 0.32f, 0.1f, 1f);

		private static readonly Color PinkEdge = new Color(1f, 0.45f, 0.7f, 1f);

		private const float FadeSpeed = 3f;

		private static Image _green;

		private static Image _pink;

		private static float _greenAlpha;

		private static float _pinkAlpha;

		private static float _greenTarget;

		private static float _pinkTarget;

		internal static void SetTargets(float green, float pink)
		{
			_greenTarget = green;
			_pinkTarget = pink;
		}

		internal static void Tick(float dt)
		{
			//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)
			if (!((Object)(object)_green == (Object)null) || !(_greenTarget <= 0f) || !(_pinkTarget <= 0f))
			{
				if ((Object)(object)_green == (Object)null)
				{
					Build();
				}
				if (!((Object)(object)_green == (Object)null))
				{
					_greenAlpha = Mathf.MoveTowards(_greenAlpha, _greenTarget, 3f * dt);
					_pinkAlpha = Mathf.MoveTowards(_pinkAlpha, _pinkTarget, 3f * dt);
					Apply(_green, GreenEdge, _greenAlpha);
					Apply(_pink, PinkEdge, _pinkAlpha);
				}
			}
		}

		private static void Apply(Image img, Color edge, float alpha)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			bool flag = alpha > 0.005f;
			if (((Behaviour)img).enabled != flag)
			{
				((Behaviour)img).enabled = flag;
			}
			if (flag)
			{
				((Graphic)img).color = new Color(edge.r, edge.g, edge.b, alpha);
			}
		}

		private static void Build()
		{
			//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_0010: Expected O, but got Unknown
			//IL_0010: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("UpgradableStats_Vignettes");
			Object.DontDestroyOnLoad((Object)val);
			((Object)val).hideFlags = (HideFlags)61;
			Canvas obj = val.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 300;
			Sprite sprite = BuildVignetteSprite();
			_green = MakeLayer(val.transform, "VerdeSegundoAliento", sprite);
			_pink = MakeLayer(val.transform, "RosaCuracion", sprite);
		}

		private static Image MakeLayer(Transform parent, string name, Sprite sprite)
		{
			//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_0028: 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_003e: 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)
			GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image obj = val.AddComponent<Image>();
			obj.sprite = sprite;
			((Graphic)obj).raycastTarget = false;
			((Behaviour)obj).enabled = false;
			return obj;
		}

		private static Sprite BuildVignetteSprite()
		{
			//IL_000c: 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_0019: Expected O, but got Unknown
			//IL_00b7: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(256, 256, (TextureFormat)4, false)
			{
				wrapMode = (TextureWrapMode)1
			};
			float num = 128f;
			for (int i = 0; i < 256; i++)
			{
				for (int j = 0; j < 256; j++)
				{
					float num2 = ((float)j - num) / num;
					float num3 = ((float)i - num) / num;
					float num4 = Mathf.Sqrt(num2 * num2 + num3 * num3);
					float num5 = Mathf.SmoothStep(0f, 1f, Mathf.InverseLerp(0.68f, 1.25f, num4));
					val.SetPixel(j, i, new Color(1f, 1f, 1f, num5));
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 256f, 256f), new Vector2(0.5f, 0.5f), 100f);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}