using System;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("local.mmc.characterpanel", "Saga Vitals", "3.0.1")]
public sealed class MMCCharacterPanel : BaseUnityPlugin
{
	private sealed class BarBoost
	{
		public Image Icon;

		public Image Wipe;

		public TMP_Text Value;

		public readonly SagaBoostWipe Clock = new SagaBoostWipe();
	}

	private sealed class BarTextStroke
	{
		public TMP_Text Value;

		public readonly List<TMP_Text> Copies = new List<TMP_Text>();
	}

	public struct StaminaSnapshot
	{
		public bool Valid;

		public float Value;

		public float Maximum;
	}

	private sealed class SpendVisual
	{
		public RectTransform Root;

		public TMP_Text Text;

		public CanvasGroup Group;

		public float Born = -100f;

		public float Amount;
	}

	public struct SpendSnapshot
	{
		public bool Valid;

		public float Stamina;
	}

	private const float HealthY = 30f;

	private const float StaminaY = 72f;

	private const float BarX = 190f;

	private const float BarHeight = 28f;

	private BarBoost[] barBoosts;

	private static readonly FieldInfo barBoostTimer = AccessTools.Field(typeof(Player), "m_foodUpdateTimer");

	private ConfigEntry<bool> enabledPanel;

	private ConfigEntry<bool> previewEnabled;

	private ConfigEntry<bool> showPower;

	private ConfigEntry<float> scale;

	private ConfigEntry<float> bottomMargin;

	private ConfigEntry<float> barWidth;

	private Hud hud;

	private SagaPanelAppearance appearance;

	private ConfigEntry<bool> hideForTools;

	private ConfigEntry<float> toolHideDelay;

	private float toolEquippedAt = -1f;

	private Image panelBackground;

	private Image panelTop;

	private Image panelBottom;

	private Image panelLeft;

	private Image panelRight;

	private Image panelHeader;

	private TMP_Text panelTitle;

	private GameObject canvasObject;

	private RectTransform root;

	public static Rect HealthBarScreenRect;

	public static Vector2 HealingPopupScreenPosition;

	public static bool HealthBarVisible;

	private Image health;

	private Image stamina;

	private Image ghost;

	private Image marker;

	private TMP_Text hpValue;

	private TMP_Text staminaValue;

	private TMP_Text nextHeal;

	private TMP_Text ghostValue;

	private RectTransform eitrRoot;

	private RectTransform adrenalineRoot;

	private RectTransform weightRoot;

	private Image weightFill;

	private TMP_Text weightValue;

	private ConfigEntry<bool> showWeight;

	private Image eitr;

	private Image adrenaline;

	private TMP_Text eitrValue;

	private TMP_Text adrenalineValue;

	private float lastMaxEitr;

	private float lastMaxAdrenaline;

	private float builtWidth;

	private RectTransform nativePower;

	private Vector2 originalPowerPosition;

	private Vector3 originalPowerScale;

	private readonly List<BarTextStroke> strokes = new List<BarTextStroke>();

	private bool failed;

	private readonly Dictionary<GameObject, bool> nativeStamina = new Dictionary<GameObject, bool>();

	private readonly Dictionary<CanvasGroup, float> hidden = new Dictionary<CanvasGroup, float>();

	private readonly List<CanvasGroup> createdGroups = new List<CanvasGroup>();

	private readonly List<Object> owned = new List<Object>();

	private Sprite rounded;

	private Sprite gradient;

	private static MMCCharacterPanel instance;

	private Harmony harmony;

	private readonly MMCStaminaRate refill = new MMCStaminaRate();

	private RectTransform refillRoot;

	private TMP_Text refillValue;

	private TMP_Text healthRateValue;

	private float healthRateAlpha;

	private CanvasGroup healthRateGroup;

	private CanvasGroup refillGroup;

	private float refillAlpha;

	private CanvasGroup powerVisibility;

	private float originalPowerAlpha;

	private readonly SpendVisual[] spendVisuals = new SpendVisual[5];

	private int spendIndex;

	private float emptyUntil;

	private float pendingSpend;

	private float pendingSpendUntil;

	private float DesiredBarWidth => appearance.Size(new Vector2(barWidth.Value, 104f), 240f, 104f).x / appearance.Scale;

	private void BuildBarBoosts(Image heart, Image lightning)
	{
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Unknown result type (might be due to invalid IL or missing references)
		//IL_011a: Unknown result type (might be due to invalid IL or missing references)
		//IL_011f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0120: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		barBoosts = new BarBoost[2];
		Image[] array = (Image[])(object)new Image[2] { heart, lightning };
		for (int i = 0; i < 2; i++)
		{
			Image val = array[i];
			Texture2D texture = val.sprite.texture;
			Color[] pixels = texture.GetPixels();
			int tw = ((Texture)texture).width;
			int th = ((Texture)texture).height;
			Sprite sprite = MakeSprite(tw, th, delegate(float x, float y)
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				int num = Mathf.Clamp((int)(x * (float)tw), 0, tw - 1);
				int num2 = Mathf.Clamp((int)(y * (float)th), 0, th - 1);
				return new Color(0.45f, 0.45f, 0.45f, pixels[num2 * tw + num].a);
			}, sliced: false);
			Transform transform = ((Component)val).transform;
			Rect rect = ((Graphic)val).rectTransform.rect;
			float width = ((Rect)(ref rect)).width;
			Rect rect2 = ((Graphic)val).rectTransform.rect;
			Image val2 = ImageNode("Food bonus decrease wipe", transform, 0f, 0f, width, ((Rect)(ref rect2)).height, new Color(1f, 1f, 1f, 0.85f), sprite);
			((Graphic)val2).rectTransform.anchorMin = Vector2.zero;
			((Graphic)val2).rectTransform.anchorMax = Vector2.one;
			RectTransform rectTransform = ((Graphic)val2).rectTransform;
			Vector2 offsetMin = (((Graphic)val2).rectTransform.offsetMax = Vector2.zero);
			rectTransform.offsetMin = offsetMin;
			val2.type = (Type)3;
			val2.fillMethod = (FillMethod)4;
			val2.fillOrigin = 2;
			val2.fillClockwise = true;
			val2.fillAmount = 0f;
			TMP_Text val3 = Text((i == 0) ? "Food health bonus" : "Food stamina bonus", (Transform)(object)root, 99f, (i == 0) ? 30f : 72f, 43f, 28f, 15f, new Color(0.35f, 1f, 0.4f, 1f));
			val3.alignment = (TextAlignmentOptions)516;
			AddBarTextStroke(val3);
			barBoosts[i] = new BarBoost
			{
				Icon = val,
				Wipe = val2,
				Value = val3
			};
		}
	}

	private void UpdateBarBoosts(Player player)
	{
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		if (barBoosts == null)
		{
			return;
		}
		List<Food> foods = player.GetFoods();
		double timer = ((barBoostTimer == null) ? 0f : ((float)barBoostTimer.GetValue(player)));
		double num = 0.0;
		foreach (Food item in foods)
		{
			num += (double)item.m_time;
		}
		for (int i = 0; i < 2; i++)
		{
			SagaFoodBoostForecast.Food[] array = new SagaFoodBoostForecast.Food[foods.Count];
			for (int j = 0; j < foods.Count; j++)
			{
				Food val = foods[j];
				SharedData shared = val.m_item.m_shared;
				ref SagaFoodBoostForecast.Food reference = ref array[j];
				reference = new SagaFoodBoostForecast.Food
				{
					Remaining = val.m_time,
					Duration = shared.m_foodBurnTime,
					Base = ((i == 0) ? shared.m_food : shared.m_foodStamina),
					Current = ((i == 0) ? val.m_health : val.m_stamina)
				};
			}
			int num2 = SagaFoodBoostForecast.Bonus(array);
			double seconds;
			int drop;
			bool predicted = SagaFoodBoostForecast.Predict(array, timer, 1.0, out seconds, out drop);
			BarBoost barBoost = barBoosts[i];
			barBoost.Value.text = ((num2 > 0) ? ("+" + num2.ToString(CultureInfo.InvariantCulture)) : "");
			float num3 = barBoost.Clock.Update(num2, num, seconds, predicted);
			barBoost.Wipe.fillAmount = num3;
			((Graphic)barBoost.Icon).color = new Color(1f, 1f, 1f, 1f - 0.25f * num3);
		}
	}

	private static void BeforeStats(Player __instance, out StaminaSnapshot __state)
	{
		__state = default(StaminaSnapshot);
		if (!((Object)(object)instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			__state.Valid = true;
			__state.Value = __instance.GetStamina();
			__state.Maximum = ((Character)__instance).GetMaxStamina();
		}
	}

	private static void AfterStats(Player __instance, float __0, StaminaSnapshot __state)
	{
		if (!((Object)(object)instance == (Object)null) && __state.Valid)
		{
			instance.refill.Observe(Time.unscaledTime, __state.Value, __instance.GetStamina(), __state.Maximum, ((Character)__instance).GetMaxStamina(), __0);
		}
	}

	private void UpdateRefill(float stamina, float maximum)
	{
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_00df: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0141: Unknown result type (might be due to invalid IL or missing references)
		bool flag = refill.Visible(Time.unscaledTime) && stamina < maximum - 0.001f;
		refillAlpha = Mathf.MoveTowards(refillAlpha, (float)(flag ? 1 : 0), Time.unscaledDeltaTime / (flag ? 0.15f : 0.4f));
		if (flag)
		{
			refillValue.text = "+" + refill.Rate.ToString("0.0", CultureInfo.InvariantCulture) + "/s";
		}
		float num = ((flag && maximum > 0f) ? (1f - Mathf.Clamp01(stamina / maximum)) : 0f);
		Color val = Color.Lerp(new Color(0.62f, 0.52f, 0.18f, 1f), new Color(1f, 0.95f, 0.32f, 1f), num);
		((Graphic)refillValue).color = Color.Lerp(((Graphic)refillValue).color, val, 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) / 0.2f));
		refillGroup.alpha = refillAlpha;
		refillRoot.anchoredPosition = new Vector2(190f + builtWidth + 12f, -72f);
	}

	private void Awake()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Expected O, but got Unknown
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Expected O, but got Unknown
		//IL_0083: Unknown result type (might be due to invalid IL or missing references)
		//IL_008d: Expected O, but got Unknown
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ef: Expected O, but got Unknown
		//IL_00ef: Expected O, but got Unknown
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0172: Expected O, but got Unknown
		//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Expected O, but got Unknown
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Expected O, but got Unknown
		instance = this;
		appearance = new SagaPanelAppearance(((BaseUnityPlugin)this).Config, true, 0f);
		toolHideDelay = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "Build Tool Hide Delay", 0f, new ConfigDescription("Seconds after equipping a hoe or cultivator before vitals hide.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 30f), new object[0]));
		hideForTools = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Hide While Using Build Tools", true, "Hide the vitals panel while a hoe or cultivator is equipped. Automatically restore it on switching away. F1 preview stays visible.");
		harmony = new Harmony("local.mmc.characterpanel.refill");
		harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "UpdateStats", new Type[1] { typeof(float) }, (Type[])null), new HarmonyMethod(typeof(MMCCharacterPanel), "BeforeStats", (Type[])null), new HarmonyMethod(typeof(MMCCharacterPanel), "AfterStats", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		PatchFeedback();
		showWeight = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Show Carry Weight", true, "Show current inventory weight and maximum carrying capacity beneath the resource bars.");
		enabledPanel = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Enabled", true, "Use the bottom-center health, stamina, eitr and adrenaline HUD.");
		scale = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "Scale", 1f, new ConfigDescription("HUD size.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.6f, 2f), new object[0]));
		bottomMargin = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "Bottom Margin", 122f, new ConfigDescription("Pixels between the HUD and bottom screen edge.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 400f), new object[0]));
		barWidth = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "Bar Width", 380f, new ConfigDescription("Width of each bar before scaling.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(240f, 640f), new object[0]));
		previewEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Next Heal Preview", true, "Show the full incoming healing amount immediately, with its existing tick timer.");
		showPower = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "Show Forsaken Power", true, "Show selected power and ready/cooldown status to the left.");
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Bottom-center 2D vitals enabled. No portrait renderer, lights, camera or inventory assets.");
	}

	private RectTransform Node(string name, Transform parent, float x, float y, float w, float h)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
		((Transform)component).SetParent(parent, false);
		Vector2 anchorMin = (component.anchorMax = new Vector2(0f, 1f));
		component.anchorMin = anchorMin;
		component.pivot = new Vector2(0f, 1f);
		component.anchoredPosition = new Vector2(x, 0f - y);
		component.sizeDelta = new Vector2(w, h);
		return component;
	}

	private Image ImageNode(string name, Transform parent, float x, float y, float w, float h, Color color, Sprite sprite)
	{
		//IL_001b: Unknown result type (might be due to invalid IL or missing references)
		Image val = ((Component)Node(name, parent, x, y, w, h)).gameObject.AddComponent<Image>();
		((Graphic)val).color = color;
		val.sprite = sprite;
		((Graphic)val).raycastTarget = false;
		if ((Object)(object)sprite == (Object)(object)rounded)
		{
			val.type = (Type)1;
		}
		return val;
	}

	private TMP_Text Text(string name, Transform parent, float x, float y, float w, float h, float size, Color color)
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		TextMeshProUGUI val = ((Component)Node(name, parent, x, y, w, h)).gameObject.AddComponent<TextMeshProUGUI>();
		((TMP_Text)val).font = hud.m_healthText.font;
		((TMP_Text)val).fontSize = size;
		((TMP_Text)val).fontStyle = (FontStyles)1;
		((TMP_Text)val).alignment = (TextAlignmentOptions)514;
		((Graphic)val).color = color;
		((Graphic)val).raycastTarget = false;
		((TMP_Text)val).richText = false;
		((TMP_Text)val).enableAutoSizing = true;
		((TMP_Text)val).fontSizeMin = 10f;
		((TMP_Text)val).fontSizeMax = size;
		((TMP_Text)val).textWrappingMode = (TextWrappingModes)0;
		((TMP_Text)val).overflowMode = (TextOverflowModes)1;
		return (TMP_Text)(object)val;
	}

	private void AddBarTextStroke(TMP_Text value)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		BarTextStroke barTextStroke = new BarTextStroke();
		barTextStroke.Value = value;
		BarTextStroke barTextStroke2 = barTextStroke;
		for (int i = 0; i < 8; i++)
		{
			TMP_Text component = Object.Instantiate<GameObject>(((Component)value).gameObject, value.transform.parent).GetComponent<TMP_Text>();
			((Object)component).name = ((Object)value).name + " black outline " + i;
			((Graphic)component).color = Color.black;
			((Graphic)component).raycastTarget = false;
			component.transform.SetSiblingIndex(value.transform.GetSiblingIndex());
			barTextStroke2.Copies.Add(component);
		}
		strokes.Add(barTextStroke2);
	}

	private void UpdateBarTextStrokes(float factor)
	{
		//IL_0077: 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_00a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
		float num = 1f / Mathf.Max(0.01f, factor);
		foreach (BarTextStroke stroke in strokes)
		{
			int num2 = 0;
			for (int i = -1; i <= 1; i++)
			{
				for (int j = -1; j <= 1; j++)
				{
					if (j != 0 || i != 0)
					{
						TMP_Text val = stroke.Copies[num2++];
						val.text = stroke.Value.text;
						val.rectTransform.sizeDelta = stroke.Value.rectTransform.sizeDelta;
						val.rectTransform.anchoredPosition = stroke.Value.rectTransform.anchoredPosition + new Vector2((float)j * num, (float)i * num);
					}
				}
			}
		}
	}

	private Sprite MakeSprite(int width, int height, Func<float, float, Color> sample, bool sliced)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Expected O, but got Unknown
		//IL_007a: 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_00b4: 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_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		Texture2D val = new Texture2D(width, height, (TextureFormat)4, false);
		((Texture)val).wrapMode = (TextureWrapMode)1;
		Color[] array = (Color[])(object)new Color[width * height];
		for (int i = 0; i < height; i++)
		{
			for (int j = 0; j < width; j++)
			{
				ref Color reference = ref array[i * width + j];
				reference = sample(((float)j + 0.5f) / (float)width, ((float)i + 0.5f) / (float)height);
			}
		}
		val.SetPixels(array);
		val.Apply();
		Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)width, (float)height), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, (Vector4)(sliced ? new Vector4(8f, 8f, 8f, 8f) : Vector4.zero));
		owned.Add((Object)(object)val2);
		owned.Add((Object)(object)val);
		return val2;
	}

	private Sprite MakeWeightIcon()
	{
		Sprite val = MakeSprite(24, 28, delegate(float x, float y)
		{
			//IL_0048: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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)
			int num = Mathf.FloorToInt(x * 24f);
			int num2 = Mathf.FloorToInt(y * 28f);
			int[] array = new int[28]
			{
				0, 0, 7, 9, 10, 10, 10, 10, 9, 9,
				8, 8, 7, 7, 6, 5, 4, 3, 3, 4,
				4, 5, 6, 6, 0, 0, 0, 0
			};
			int num3 = array[num2];
			int num4 = Mathf.Abs(num * 2 - 23);
			if (num3 == 0 || num4 >= num3 * 2)
			{
				return Color.clear;
			}
			if (num4 >= (num3 - 1) * 2 || num2 == 2 || num2 == 23 || array[Mathf.Max(0, num2 - 1)] * 2 <= num4 || array[Mathf.Min(27, num2 + 1)] * 2 <= num4)
			{
				return new Color(0.1f, 0.065f, 0.035f, 1f);
			}
			if (num2 == 18 || num2 == 19)
			{
				return new Color(0.29f, 0.15f, 0.055f, 1f);
			}
			if (num2 > 19 && (num == 9 || num == 13))
			{
				return new Color(0.38f, 0.2f, 0.075f, 1f);
			}
			return (Color)((num2 > 5 && num2 < 13 && (num == 6 || num == 7)) ? new Color(1f, 0.72f, 0.36f, 1f) : Color.Lerp(new Color(0.65f, 0.34f, 0.12f, 1f), new Color(0.94f, 0.6f, 0.25f, 1f), 1f - x));
		}, sliced: false);
		((Texture)val.texture).filterMode = (FilterMode)0;
		return val;
	}

	private bool InsideBolt(float x, float y)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
		Vector2[] array = (Vector2[])(object)new Vector2[7]
		{
			new Vector2(0.55f, 1f),
			new Vector2(0.18f, 0.48f),
			new Vector2(0.46f, 0.48f),
			new Vector2(0.31f, 0f),
			new Vector2(0.86f, 0.61f),
			new Vector2(0.57f, 0.61f),
			new Vector2(0.77f, 1f)
		};
		bool flag = false;
		int num = 0;
		int num2 = array.Length - 1;
		while (num < array.Length)
		{
			if (array[num].y > y != array[num2].y > y && x < (array[num2].x - array[num].x) * (y - array[num].y) / (array[num2].y - array[num].y) + array[num].x)
			{
				flag = !flag;
			}
			num2 = num++;
		}
		return flag;
	}

	private Image Bar(string name, float y, Color color, Transform parent = null)
	{
		//IL_0051: 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_0109: Unknown result type (might be due to invalid IL or missing references)
		//IL_0157: Unknown result type (might be due to invalid IL or missing references)
		ImageNode(name + " shadow", (Transform)(((Object)(object)parent == (Object)null) ? ((object)root) : ((object)parent)), 188f, y - 2f, builtWidth + 4f, 32f, new Color(0f, 0f, 0f, 0.8f), rounded);
		ImageNode(name + " gold edge", (Transform)(((Object)(object)parent == (Object)null) ? ((object)root) : ((object)parent)), 190f, y, builtWidth, 28f, new Color(0.7f, 0.47f, 0.2f, 1f), rounded);
		ImageNode(name + " inner iron", (Transform)(((Object)(object)parent == (Object)null) ? ((object)root) : ((object)parent)), 192f, y + 2f, builtWidth - 4f, 24f, new Color(0.055f, 0.07f, 0.07f, 0.95f), rounded);
		return ImageNode(name + " fill", (Transform)(((Object)(object)parent == (Object)null) ? ((object)root) : ((object)parent)), 194f, y + 4f, builtWidth - 8f, 20f, color, gradient);
	}

	private RectTransform Resource(string name, Color color, out Image fill, out TMP_Text value)
	{
		//IL_003b: 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)
		RectTransform val = Node(name + " row", (Transform)(object)root, 0f, 114f, 190f + builtWidth, 42f);
		fill = Bar(name, 0f, color, (Transform)(object)val);
		value = Text(name + " amount", (Transform)(object)val, 194f, 0f, builtWidth - 8f, 28f, 22f, Color.white);
		AddBarTextStroke(value);
		return val;
	}

	private void UpdateResource(RectTransform group, Image fill, TMP_Text text, string name, float current, float maximum, float y)
	{
		//IL_0009: 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)
		group.anchoredPosition = new Vector2(0f, 0f - y);
		maximum = Mathf.Max(1f, maximum);
		current = Mathf.Clamp(current, 0f, maximum);
		((Graphic)fill).rectTransform.sizeDelta = new Vector2((builtWidth - 8f) * current / maximum, 20f);
		text.text = name + "  " + Mathf.CeilToInt(current) + " / " + Mathf.CeilToInt(maximum);
	}

	private void UpdateWeight(Player player, float y)
	{
		//IL_0034: 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_00cb: 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_0095: Unknown result type (might be due to invalid IL or missing references)
		float num = Mathf.Max(0f, ((Humanoid)player).GetInventory().GetTotalWeight());
		float num2 = Mathf.Max(1f, player.GetMaxCarryWeight());
		weightRoot.anchoredPosition = new Vector2(0f, 0f - y);
		((Graphic)weightFill).rectTransform.sizeDelta = new Vector2((builtWidth - 8f) * Mathf.Clamp01(num / num2), 20f);
		((Graphic)weightFill).color = ((num > num2) ? new Color(1f, 0.22f, 0.12f, 1f) : ((num >= num2 * 0.85f) ? new Color(1f, 0.72f, 0.22f, 1f) : new Color(0.56f, 0.48f, 0.32f, 1f)));
		weightValue.text = num.ToString("0.#", CultureInfo.InvariantCulture) + " / " + num2.ToString("0.#", CultureInfo.InvariantCulture);
	}

	private void DisableNativeStamina(GameObject obj)
	{
		if (!((Object)(object)obj == (Object)null))
		{
			if (!nativeStamina.ContainsKey(obj))
			{
				nativeStamina.Add(obj, obj.activeSelf);
			}
			if (obj.activeSelf)
			{
				obj.SetActive(false);
			}
		}
	}

	private void HideNativeStamina()
	{
		DisableNativeStamina(((Component)hud.m_staminaBar2Root).gameObject);
		if ((Object)(object)hud.m_staminaBar2Fast != (Object)null && !((Component)hud.m_staminaBar2Fast).transform.IsChildOf((Transform)(object)hud.m_staminaBar2Root))
		{
			DisableNativeStamina(((Component)hud.m_staminaBar2Fast).gameObject);
		}
		if ((Object)(object)hud.m_staminaBar2Slow != (Object)null && !((Component)hud.m_staminaBar2Slow).transform.IsChildOf((Transform)(object)hud.m_staminaBar2Root))
		{
			DisableNativeStamina(((Component)hud.m_staminaBar2Slow).gameObject);
		}
		if ((Object)(object)hud.m_staminaText != (Object)null && !hud.m_staminaText.transform.IsChildOf((Transform)(object)hud.m_staminaBar2Root))
		{
			DisableNativeStamina(((Component)hud.m_staminaText).gameObject);
		}
	}

	private void Remember(GameObject obj)
	{
		CanvasGroup val = obj.GetComponent<CanvasGroup>();
		if ((Object)(object)val == (Object)null)
		{
			val = obj.AddComponent<CanvasGroup>();
			createdGroups.Add(val);
		}
		if (!hidden.ContainsKey(val))
		{
			hidden.Add(val, val.alpha);
		}
	}

	private void Initialize(Hud current)
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Expected O, but got Unknown
		//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_012a: 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_018c: 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)
		//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_02de: Unknown result type (might be due to invalid IL or missing references)
		//IL_030a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0340: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Unknown result type (might be due to invalid IL or missing references)
		//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_043c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0478: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_0526: Unknown result type (might be due to invalid IL or missing references)
		//IL_0561: Unknown result type (might be due to invalid IL or missing references)
		//IL_0616: Unknown result type (might be due to invalid IL or missing references)
		//IL_06d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0730: Unknown result type (might be due to invalid IL or missing references)
		//IL_0772: Unknown result type (might be due to invalid IL or missing references)
		Cleanup();
		hud = current;
		builtWidth = DesiredBarWidth;
		canvasObject = new GameObject("MMC_BottomVitalsCanvas", new Type[2]
		{
			typeof(RectTransform),
			typeof(Canvas)
		});
		Canvas component = canvasObject.GetComponent<Canvas>();
		component.renderMode = (RenderMode)0;
		component.sortingOrder = 5;
		root = Node("MMC_BottomVitals", canvasObject.transform, 0f, 0f, 190f + builtWidth, 104f);
		panelBackground = ImageNode("Vitals background", (Transform)(object)root, 136f, 0f, builtWidth + 316f, 104f, Color.clear, null);
		panelTop = ImageNode("Vitals top border", (Transform)(object)root, 0f, 0f, 1f, 1f, Color.clear, null);
		panelBottom = ImageNode("Vitals bottom border", (Transform)(object)root, 0f, 0f, 1f, 1f, Color.clear, null);
		panelLeft = ImageNode("Vitals left border", (Transform)(object)root, 0f, 0f, 1f, 1f, Color.clear, null);
		panelRight = ImageNode("Vitals right border", (Transform)(object)root, 0f, 0f, 1f, 1f, Color.clear, null);
		panelHeader = ImageNode("Vitals header", (Transform)(object)root, 0f, 0f, 1f, 1f, Color.clear, null);
		panelTitle = Text("Vitals title", (Transform)(object)root, 144f, -28f, 200f, 24f, 16f, Color.white);
		panelTitle.text = "Vitals";
		panelTitle.alignment = (TextAlignmentOptions)513;
		rounded = MakeSprite(32, 32, delegate(float x, float y)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			float num2 = Mathf.Max(Mathf.Abs(x - 0.5f) * 32f - 10f, 0f);
			float num3 = Mathf.Max(Mathf.Abs(y - 0.5f) * 32f - 10f, 0f);
			return new Color(1f, 1f, 1f, Mathf.Clamp01(6f - Mathf.Sqrt(num2 * num2 + num3 * num3)));
		}, sliced: true);
		gradient = MakeSprite(4, 32, delegate(float x, float y)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			float num2 = Mathf.Lerp(0.65f, 1f, y);
			return new Color(num2, num2, num2, 1f);
		}, sliced: false);
		Sprite sprite = MakeSprite(64, 64, delegate(float x, float y)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			float num2 = (x - 0.5f) * 2.7f;
			float num3 = (y - 0.46f) * 2.7f;
			float num4 = num2 * num2 + num3 * num3 - 1f;
			bool flag = num4 * num4 * num4 - num2 * num2 * num3 * num3 * num3 <= 0f;
			return new Color(1f, 0.2f + y * 0.15f, 0.16f + y * 0.12f, (float)(flag ? 1 : 0));
		}, sliced: false);
		Sprite sprite2 = MakeSprite(48, 64, (float x, float y) => new Color(1f, 0.65f + y * 0.3f, 0.15f + y * 0.25f, (float)(InsideBolt(x, y) ? 1 : 0)), sliced: false);
		Image heart = ImageNode("Heart", (Transform)(object)root, 147f, 29f, 32f, 32f, Color.white, sprite);
		Image lightning = ImageNode("Lightning", (Transform)(object)root, 150f, 69f, 26f, 35f, Color.white, sprite2);
		BuildBarBoosts(heart, lightning);
		health = Bar("Health", 30f, new Color(0.8f, 0.12f, 0.105f, 1f));
		ghost = ImageNode("Next heal segment", (Transform)(object)root, 194f, 34f, 0f, 20f, new Color(1f, 0.65f, 0.58f, 0.5f), gradient);
		marker = ImageNode("Next heal marker", (Transform)(object)root, 194f, 28f, 2f, 32f, new Color(1f, 0.77f, 0.37f, 1f), null);
		stamina = Bar("Stamina", 72f, new Color(1f, 0.72f, 0.12f, 1f));
		hpValue = Text("Health amount", (Transform)(object)root, 194f, 30f, builtWidth - 8f, 28f, 22f, Color.white);
		staminaValue = Text("Stamina amount", (Transform)(object)root, 194f, 72f, builtWidth - 8f, 28f, 22f, Color.white);
		AddBarTextStroke(hpValue);
		AddBarTextStroke(staminaValue);
		eitrRoot = Resource("Eitr", new Color(0.62f, 0.23f, 0.95f, 1f), out eitr, out eitrValue);
		adrenalineRoot = Resource("Adrenaline", new Color(1f, 0.36f, 0.075f, 1f), out adrenaline, out adrenalineValue);
		weightRoot = Resource("Carry Weight", new Color(0.56f, 0.48f, 0.32f, 1f), out weightFill, out weightValue);
		ImageNode("Carry weight sack", (Transform)(object)weightRoot, 148f, -3f, 30f, 35f, Color.white, MakeWeightIcon());
		refillRoot = Node("Stamina refill rate", (Transform)(object)root, 190f + builtWidth + 12f, 72f, 110f, 28f);
		refillGroup = ((Component)refillRoot).gameObject.AddComponent<CanvasGroup>();
		refillGroup.alpha = 0f;
		refillGroup.blocksRaycasts = false;
		refillValue = Text("Refill per second", (Transform)(object)refillRoot, 0f, 0f, 110f, 28f, 19f, new Color(1f, 0.86f, 0.38f, 1f));
		refillValue.alignment = (TextAlignmentOptions)513;
		AddBarTextStroke(refillValue);
		RectTransform val = Node("Health rate", (Transform)(object)root, 190f + builtWidth + 140f, 30f, 110f, 28f);
		healthRateGroup = ((Component)val).gameObject.AddComponent<CanvasGroup>();
		healthRateGroup.alpha = 0f;
		healthRateGroup.blocksRaycasts = false;
		healthRateValue = Text("Health regeneration rate", (Transform)(object)val, 0f, 0f, 110f, 28f, 19f, new Color(0.35f, 1f, 0.4f, 1f));
		healthRateValue.alignment = (TextAlignmentOptions)513;
		AddBarTextStroke(healthRateValue);
		BuildFeedback();
		ghostValue = Text("Next heal amount", (Transform)(object)root, 190f, 30f, 50f, 28f, 18f, Color.white);
		nextHeal = Text("Next heal countdown", (Transform)(object)root, 190f + builtWidth + 12f, 30f, 70f, 28f, 17f, Color.white);
		nextHeal.alignment = (TextAlignmentOptions)4097;
		if ((Object)(object)hud.m_eitrBarRoot != (Object)null)
		{
			Remember(((Component)hud.m_eitrBarRoot).gameObject);
		}
		if ((Object)(object)hud.m_adrenalineBarRoot != (Object)null)
		{
			Remember(((Component)hud.m_adrenalineBarRoot).gameObject);
		}
		if ((Object)(object)hud.m_eitrText != (Object)null && ((Object)(object)hud.m_eitrBarRoot == (Object)null || !hud.m_eitrText.transform.IsChildOf((Transform)(object)hud.m_eitrBarRoot)))
		{
			Remember(((Component)hud.m_eitrText).gameObject);
		}
		if ((Object)(object)hud.m_adrenalineText != (Object)null && ((Object)(object)hud.m_adrenalineBarRoot == (Object)null || !hud.m_adrenalineText.transform.IsChildOf((Transform)(object)hud.m_adrenalineBarRoot)))
		{
			Remember(((Component)hud.m_adrenalineText).gameObject);
		}
		if ((Object)(object)hud.m_healthPanel != (Object)null)
		{
			Graphic[] componentsInChildren = ((Component)hud.m_healthPanel).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val2 in componentsInChildren)
			{
				Transform transform = ((Component)val2).transform;
				Transform val3 = (((Object)(object)hud.m_gpRoot != (Object)null) ? ((Component)hud.m_gpRoot).transform : null);
				Transform statusEffectListRoot = (Transform)(object)hud.m_statusEffectListRoot;
				if ((!((Object)(object)val3 != (Object)null) || (!transform.IsChildOf(val3) && !val3.IsChildOf(transform))) && (!((Object)(object)statusEffectListRoot != (Object)null) || (!transform.IsChildOf(statusEffectListRoot) && !statusEffectListRoot.IsChildOf(transform))))
				{
					Remember(((Component)val2).gameObject);
				}
			}
		}
		Remember(((Component)hud.m_healthBarRoot).gameObject);
		if (!hud.m_healthText.transform.IsChildOf((Transform)(object)hud.m_healthBarRoot))
		{
			Remember(((Component)hud.m_healthText).gameObject);
		}
		Remember(((Component)hud.m_staminaBar2Root).gameObject);
		if (!hud.m_staminaText.transform.IsChildOf((Transform)(object)hud.m_staminaBar2Root))
		{
			Remember(((Component)hud.m_staminaText).gameObject);
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Bottom-center 2D bars created; portrait rendering completely removed.");
	}

	private bool ShouldHideForTool(Player player)
	{
		ItemData rightItem = ((Humanoid)player).RightItem;
		if (rightItem == null)
		{
			toolEquippedAt = -1f;
			return false;
		}
		string text = (((Object)(object)rightItem.m_dropPrefab == (Object)null) ? rightItem.m_shared.m_name : ((Object)rightItem.m_dropPrefab).name);
		if (text.IndexOf("hoe", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("cultivator", StringComparison.OrdinalIgnoreCase) < 0)
		{
			toolEquippedAt = -1f;
			return false;
		}
		if (toolEquippedAt < 0f)
		{
			toolEquippedAt = Time.unscaledTime;
		}
		return Time.unscaledTime - toolEquippedAt >= toolHideDelay.Value;
	}

	private void LateUpdate()
	{
		//IL_0268: Unknown result type (might be due to invalid IL or missing references)
		//IL_0274: Unknown result type (might be due to invalid IL or missing references)
		//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_030b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0332: Unknown result type (might be due to invalid IL or missing references)
		//IL_0357: Unknown result type (might be due to invalid IL or missing references)
		//IL_0385: Unknown result type (might be due to invalid IL or missing references)
		//IL_03da: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0502: 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_0579: Unknown result type (might be due to invalid IL or missing references)
		//IL_058a: Unknown result type (might be due to invalid IL or missing references)
		//IL_058f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0594: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0622: Unknown result type (might be due to invalid IL or missing references)
		//IL_0627: Unknown result type (might be due to invalid IL or missing references)
		//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_071d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0739: Unknown result type (might be due to invalid IL or missing references)
		//IL_0755: Unknown result type (might be due to invalid IL or missing references)
		//IL_0908: Unknown result type (might be due to invalid IL or missing references)
		//IL_0924: Unknown result type (might be due to invalid IL or missing references)
		//IL_0957: Unknown result type (might be due to invalid IL or missing references)
		//IL_0972: Unknown result type (might be due to invalid IL or missing references)
		//IL_09e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a03: Unknown result type (might be due to invalid IL or missing references)
		HealthBarVisible = false;
		if (failed)
		{
			return;
		}
		try
		{
			Player localPlayer = Player.m_localPlayer;
			if (!enabledPanel.Value || (Object)(object)localPlayer == (Object)null || (Object)(object)Hud.instance == (Object)null)
			{
				Hide();
				return;
			}
			if ((Object)(object)hud != (Object)(object)Hud.instance || (Object)(object)root == (Object)null || builtWidth != DesiredBarWidth)
			{
				Initialize(Hud.instance);
			}
			bool flag = (SagaConfigPreview.Open || !hideForTools.Value || !ShouldHideForTool(localPlayer)) && appearance.InventoryVisible && (SagaConfigPreview.HudVisible(hud) || InventoryGui.IsVisible()) && !((Character)localPlayer).IsDead() && !SagaConfigPreview.MapVisible() && !SagaConfigPreview.StoreVisible() && !SagaConfigPreview.MenuVisible();
			((Component)root).gameObject.SetActive(flag);
			if (!flag)
			{
				refill.Reset();
				refillAlpha = 0f;
				healthRateAlpha = 0f;
				pendingSpend = 0f;
				pendingSpendUntil = 0f;
				SuppressNativeVitals();
				return;
			}
			float num = Mathf.Max(0f, ((Character)localPlayer).GetMaxEitr());
			float num2 = Mathf.Max(0f, localPlayer.GetEitr());
			float num3 = Mathf.Max(0f, ((Character)localPlayer).GetMaxAdrenaline());
			float num4 = Mathf.Max(0f, localPlayer.GetAdrenaline());
			if (num > 0f)
			{
				lastMaxEitr = num;
			}
			if (num3 > 0f)
			{
				lastMaxAdrenaline = num3;
			}
			bool flag2 = num > 0f || num2 > 0f;
			bool flag3 = num3 > 0f || num4 > 0f;
			((Component)eitrRoot).gameObject.SetActive(flag2);
			((Component)adrenalineRoot).gameObject.SetActive(flag3);
			((Component)weightRoot).gameObject.SetActive(showWeight.Value);
			if (showWeight.Value)
			{
				UpdateWeight(localPlayer, 114 + (flag2 ? 42 : 0) + (flag3 ? 42 : 0));
			}
			float num5 = 104 + (flag2 ? 42 : 0) + (flag3 ? 42 : 0) + (showWeight.Value ? 42 : 0);
			num5 = appearance.Size(new Vector2(builtWidth, num5), 240f, num5).y / appearance.Scale;
			root.sizeDelta = new Vector2(190f + builtWidth, num5);
			float num6 = 136f;
			float num7 = builtWidth + 316f;
			float headerHeight = appearance.HeaderHeight;
			SetPanelImage(panelBackground, num6, 0f - headerHeight, num7, num5 + headerHeight, appearance.Background(1f));
			SetPanelImage(panelTop, num6, 0f - headerHeight, num7, 1f, appearance.Border);
			SetPanelImage(panelBottom, num6, num5 - 1f, num7, 1f, appearance.Border);
			SetPanelImage(panelLeft, num6, 0f - headerHeight, 1f, num5 + headerHeight, appearance.Border);
			SetPanelImage(panelRight, num6 + num7 - 1f, 0f - headerHeight, 1f, num5 + headerHeight, appearance.Border);
			SetPanelImage(panelHeader, num6 + 1f, 0f - headerHeight + 1f, num7 - 2f, Mathf.Max(0f, headerHeight - 2f), appearance.ToolWindow ? Color.clear : appearance.Header);
			((Component)panelTitle).gameObject.SetActive(!appearance.ToolWindow);
			UpdateResource(eitrRoot, eitr, eitrValue, "Eitr", num2, (num > 0f) ? num : Mathf.Max(lastMaxEitr, num2), 114f);
			UpdateResource(adrenalineRoot, adrenaline, adrenalineValue, "Adrenaline", num4, (num3 > 0f) ? num3 : Mathf.Max(lastMaxAdrenaline, num4), flag2 ? 156 : 114);
			float num8 = Mathf.Min(scale.Value * appearance.Scale, Mathf.Min((float)(Screen.width - 32) / Mathf.Max(190f + builtWidth, builtWidth + 500f), Mathf.Max(0.1f, ((float)Screen.height - bottomMargin.Value - 16f) / (num5 + headerHeight))));
			((Transform)root).localScale = Vector3.one * num8;
			float num9 = Mathf.Max(8f, (float)Screen.width * 0.5f - (190f + builtWidth * 0.5f) * num8);
			float num10 = Mathf.Max(8f + headerHeight * num8, (float)Screen.height - bottomMargin.Value - num5 * num8);
			SagaPanelAppearance obj = appearance;
			float num11 = num9;
			float num12 = num10;
			Rect rect = root.rect;
			Rect val = obj.Position(new Rect(num11, num12, ((Rect)(ref rect)).width * num8, num5 * num8));
			num9 = ((Rect)(ref val)).x;
			num10 = ((Rect)(ref val)).y;
			root.anchoredPosition = new Vector2(num9, 0f - num10);
			HealthBarScreenRect = new Rect(num9 + 190f * num8, num10 + 30f * num8, builtWidth * num8, 28f * num8);
			HealingPopupScreenPosition = new Vector2(Mathf.Min((float)(Screen.width - 58), ((Rect)(ref HealthBarScreenRect)).xMax + 145f * num8), ((Rect)(ref HealthBarScreenRect)).y - 20f * num8);
			HealthBarVisible = true;
			foreach (KeyValuePair<CanvasGroup, float> item in hidden)
			{
				if ((Object)(object)item.Key != (Object)null)
				{
					item.Key.alpha = 0f;
				}
			}
			HideNativeStamina();
			float num13 = Mathf.Max(1f, ((Character)localPlayer).GetMaxHealth());
			float num14 = Mathf.Clamp(((Character)localPlayer).GetHealth(), 0f, num13);
			float num15 = Mathf.Max(1f, ((Character)localPlayer).GetMaxStamina());
			float num16 = Mathf.Clamp(localPlayer.GetStamina(), 0f, num15);
			float num17 = builtWidth - 8f;
			((Graphic)health).rectTransform.sizeDelta = new Vector2(num17 * num14 / num13, 20f);
			((Graphic)stamina).rectTransform.sizeDelta = new Vector2(num17 * num16 / num15, 20f);
			hpValue.rectTransform.sizeDelta = new Vector2(num17, 28f);
			staminaValue.rectTransform.sizeDelta = new Vector2(num17, 28f);
			hpValue.text = Mathf.CeilToInt(num14) + " / " + Mathf.CeilToInt(num13);
			staminaValue.text = Mathf.CeilToInt(num16) + " / " + Mathf.CeilToInt(num15);
			UpdateRefill(num16, num15);
			UpdateFeedback(num8);
			UpdateBarBoosts(localPlayer);
			UpdateBarTextStrokes(num8);
			float seconds = float.PositiveInfinity;
			float amount = 0f;
			float interval = 0f;
			float rate = 0f;
			MMCPanelHealing.Predict(localPlayer, out seconds, out amount, out interval, out rate);
			healthRateAlpha = Mathf.MoveTowards(healthRateAlpha, (rate > 0f && num14 < num13 - 0.001f) ? 1f : 0f, Time.unscaledDeltaTime / 0.25f);
			if (rate > 0f)
			{
				healthRateValue.text = "+" + rate.ToString("0.0", CultureInfo.InvariantCulture) + "/s";
			}
			healthRateGroup.alpha = healthRateAlpha;
			if (!previewEnabled.Value)
			{
				amount = 0f;
			}
			amount = MMCHealForecast.Cap(amount, num14, num13);
			bool flag4 = amount > 0f && !float.IsInfinity(seconds);
			Image obj2 = ghost;
			bool enabled = (((Behaviour)marker).enabled = flag4);
			((Behaviour)obj2).enabled = enabled;
			float num18 = 194f + num17 * num14 / num13;
			float num19 = num17 * amount / num13;
			((Graphic)ghost).rectTransform.anchoredPosition = new Vector2(num18, -34f);
			((Graphic)ghost).rectTransform.sizeDelta = new Vector2(num19, 20f);
			((Graphic)marker).rectTransform.anchoredPosition = new Vector2(Mathf.Min(190f + builtWidth - 4f, num18), -28f);
			float num20 = hpValue.GetPreferredValues(hpValue.text).x * 0.5f + 6f;
			float num21 = 190f + builtWidth * 0.5f;
			bool enabled2 = flag4 && num19 >= 24f && (num18 + num19 < num21 - num20 || num18 > num21 + num20);
			((Behaviour)ghostValue).enabled = enabled2;
			ghostValue.rectTransform.anchoredPosition = new Vector2(num18, -30f);
			ghostValue.rectTransform.sizeDelta = new Vector2(num19, 28f);
			ghostValue.text = "+" + amount.ToString("0.#", CultureInfo.InvariantCulture);
			((Behaviour)nextHeal).enabled = flag4;
			nextHeal.text = (flag4 ? (seconds.ToString("0.0", CultureInfo.InvariantCulture) + "s") : "");
			if (SagaPanelUI.PowerOnHotbar)
			{
				RestoreNativePower();
				SetNativePowerHidden(hide: true);
			}
			else
			{
				SetNativePowerHidden(hide: false);
				DockNativePower(num8);
			}
		}
		catch (Exception ex)
		{
			failed = true;
			((BaseUnityPlugin)this).Logger.LogError((object)("Bottom vitals disabled; native HUD restored. " + ex));
			Cleanup();
		}
	}

	private void SetNativePowerHidden(bool hide)
	{
		if ((Object)(object)hud == (Object)null || (Object)(object)hud.m_gpRoot == (Object)null)
		{
			return;
		}
		if ((Object)(object)powerVisibility == (Object)null)
		{
			powerVisibility = ((Component)hud.m_gpRoot).GetComponent<CanvasGroup>();
			if ((Object)(object)powerVisibility == (Object)null)
			{
				powerVisibility = ((Component)hud.m_gpRoot).gameObject.AddComponent<CanvasGroup>();
				createdGroups.Add(powerVisibility);
			}
			originalPowerAlpha = powerVisibility.alpha;
		}
		powerVisibility.alpha = (hide ? 0f : originalPowerAlpha);
	}

	private void SuppressNativeVitals()
	{
		foreach (KeyValuePair<CanvasGroup, float> item in hidden)
		{
			if ((Object)(object)item.Key != (Object)null)
			{
				item.Key.alpha = 0f;
			}
		}
		HideNativeStamina();
		SetNativePowerHidden(hide: true);
	}

	private void RestoreNativePower()
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)nativePower == (Object)null))
		{
			nativePower.anchoredPosition = originalPowerPosition;
			((Transform)nativePower).localScale = originalPowerScale;
			nativePower = null;
		}
	}

	private void DockNativePower(float factor)
	{
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Unknown result type (might be due to invalid IL or missing references)
		//IL_0097: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: 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_013a: 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_0157: 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_0161: Unknown result type (might be due to invalid IL or missing references)
		//IL_0179: Unknown result type (might be due to invalid IL or missing references)
		//IL_017e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0183: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: 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_0199: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_01af: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
		if (!showPower.Value || (Object)(object)hud.m_gpRoot == (Object)null)
		{
			RestoreNativePower();
			return;
		}
		Transform transform = ((Component)hud.m_gpRoot).transform;
		RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		if ((Object)(object)nativePower != (Object)(object)val)
		{
			RestoreNativePower();
			nativePower = val;
			originalPowerPosition = val.anchoredPosition;
			originalPowerScale = ((Transform)val).localScale;
		}
		Transform parent = ((Transform)val).parent;
		RectTransform val2 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
		if (!((Object)(object)val2 == (Object)null))
		{
			Bounds val3 = RectTransformUtility.CalculateRelativeRectTransformBounds((Transform)(object)val, (Transform)(object)val);
			float num = Mathf.Min(100f / Mathf.Max(1f, ((Bounds)(ref val3)).size.x), 103f / Mathf.Max(1f, ((Bounds)(ref val3)).size.y)) * factor;
			((Transform)val).localScale = new Vector3(num / Mathf.Max(0.001f, Mathf.Abs(((Transform)val2).lossyScale.x)), num / Mathf.Max(0.001f, Mathf.Abs(((Transform)val2).lossyScale.y)), originalPowerScale.z);
			Canvas componentInParent = ((Component)val).GetComponentInParent<Canvas>();
			Camera val4 = (((Object)(object)componentInParent == (Object)null || (int)componentInParent.renderMode == 0) ? null : componentInParent.worldCamera);
			Vector2 val5 = RectTransformUtility.WorldToScreenPoint(val4, ((Transform)val).TransformPoint(((Bounds)(ref val3)).center));
			Vector2 val6 = RectTransformUtility.WorldToScreenPoint((Camera)null, ((Transform)root).TransformPoint(new Vector3(42f, -51.5f, 0f)));
			Vector2 val7 = default(Vector2);
			Vector2 val8 = default(Vector2);
			if (RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, val5, val4, ref val7) && RectTransformUtility.ScreenPointToLocalPointInRectangle(val2, val6, val4, ref val8))
			{
				val.anchoredPosition += val8 - val7;
			}
		}
	}

	private void Restore(bool restoreStamina = true)
	{
		if ((Object)(object)powerVisibility != (Object)null)
		{
			powerVisibility.alpha = originalPowerAlpha;
		}
		RestoreNativePower();
		if (restoreStamina)
		{
			foreach (KeyValuePair<GameObject, bool> item in nativeStamina)
			{
				if ((Object)(object)item.Key != (Object)null)
				{
					item.Key.SetActive(item.Value);
				}
			}
			nativeStamina.Clear();
		}
		foreach (KeyValuePair<CanvasGroup, float> item2 in hidden)
		{
			if ((Object)(object)item2.Key != (Object)null)
			{
				item2.Key.alpha = item2.Value;
			}
		}
	}

	private static void SetPanelImage(Image image, float x, float y, float width, float height, Color color)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		((Graphic)image).rectTransform.anchoredPosition = new Vector2(x, 0f - y);
		((Graphic)image).rectTransform.sizeDelta = new Vector2(width, height);
		((Graphic)image).color = color;
	}

	private void Hide()
	{
		HealthBarVisible = false;
		refill.Reset();
		refillAlpha = 0f;
		healthRateAlpha = 0f;
		pendingSpend = 0f;
		pendingSpendUntil = 0f;
		if ((Object)(object)root != (Object)null)
		{
			((Component)root).gameObject.SetActive(false);
		}
		if (enabledPanel.Value && (Object)(object)hud != (Object)null && (Object)(object)hud == (Object)(object)Hud.instance)
		{
			SuppressNativeVitals();
		}
		else
		{
			Restore();
		}
	}

	private void Cleanup()
	{
		refill.Reset();
		refillAlpha = 0f;
		healthRateAlpha = 0f;
		pendingSpend = 0f;
		pendingSpendUntil = 0f;
		Restore();
		powerVisibility = null;
		hidden.Clear();
		strokes.Clear();
		lastMaxEitr = (lastMaxAdrenaline = 0f);
		foreach (CanvasGroup createdGroup in createdGroups)
		{
			if ((Object)(object)createdGroup != (Object)null)
			{
				Object.Destroy((Object)(object)createdGroup);
			}
		}
		createdGroups.Clear();
		if ((Object)(object)canvasObject != (Object)null)
		{
			Object.Destroy((Object)(object)canvasObject);
		}
		root = null;
		hud = null;
		HealthBarVisible = false;
		foreach (Object item in owned)
		{
			if (item != (Object)null)
			{
				Object.Destroy(item);
			}
		}
		owned.Clear();
	}

	private void OnDestroy()
	{
		Cleanup();
		if (harmony != null)
		{
			harmony.UnpatchSelf();
		}
		if ((Object)(object)instance == (Object)(object)this)
		{
			instance = null;
		}
	}

	private void PatchFeedback()
	{
		//IL_002c: 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_004e: Expected O, but got Unknown
		//IL_004e: Expected O, but got Unknown
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Expected O, but got Unknown
		harmony.Patch((MethodBase)AccessTools.Method(typeof(Player), "RPC_UseStamina", (Type[])null, (Type[])null), new HarmonyMethod(typeof(MMCCharacterPanel), "BeforeSpend", (Type[])null), new HarmonyMethod(typeof(MMCCharacterPanel), "AfterSpend", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		harmony.Patch((MethodBase)AccessTools.Method(typeof(Hud), "StaminaBarEmptyFlash", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(MMCCharacterPanel), "EmptyFlash", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
	}

	private static void BeforeSpend(Player __instance, out SpendSnapshot __state)
	{
		__state = default(SpendSnapshot);
		if (!((Object)(object)instance == (Object)null) && !((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
		{
			__state.Valid = true;
			__state.Stamina = __instance.GetStamina();
		}
	}

	private static void AfterSpend(Player __instance, SpendSnapshot __state)
	{
		if (!((Object)(object)instance == (Object)null) && __state.Valid && !((Object)(object)instance.root == (Object)null) && ((Component)instance.root).gameObject.activeInHierarchy)
		{
			float num = __state.Stamina - __instance.GetStamina();
			if (num > 0.0001f && !float.IsInfinity(num) && !float.IsNaN(num))
			{
				instance.refill.Reset();
				instance.refillAlpha = 0f;
				instance.refillGroup.alpha = 0f;
				instance.QueueSpend(num);
			}
		}
	}

	private static void EmptyFlash()
	{
		if ((Object)(object)instance != (Object)null && (Object)(object)instance.root != (Object)null && ((Component)instance.root).gameObject.activeInHierarchy)
		{
			instance.emptyUntil = Time.unscaledTime + 0.55f;
		}
	}

	private bool HasVisibleSpend()
	{
		if (pendingSpend > 0f)
		{
			return true;
		}
		SpendVisual[] array = spendVisuals;
		foreach (SpendVisual spendVisual in array)
		{
			if (spendVisual != null && Time.unscaledTime - spendVisual.Born < 1.2f)
			{
				return true;
			}
		}
		return false;
	}

	private void BuildFeedback()
	{
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		emptyUntil = 0f;
		spendIndex = 0;
		pendingSpend = 0f;
		pendingSpendUntil = 0f;
		for (int i = 0; i < spendVisuals.Length; i++)
		{
			SpendVisual spendVisual = new SpendVisual();
			spendVisual.Root = Node("Stamina cost " + i, (Transform)(object)root, 190f + builtWidth + 140f, 72f, 110f, 28f);
			spendVisual.Group = ((Component)spendVisual.Root).gameObject.AddComponent<CanvasGroup>();
			spendVisual.Group.alpha = 0f;
			spendVisual.Group.blocksRaycasts = false;
			spendVisual.Text = Text("Spent", (Transform)(object)spendVisual.Root, 0f, 0f, 110f, 28f, 20f, new Color(1f, 0.12f, 0.08f, 1f));
			spendVisual.Text.alignment = (TextAlignmentOptions)513;
			AddBarTextStroke(spendVisual.Text);
			spendVisuals[i] = spendVisual;
		}
	}

	private void FlushSpend()
	{
		if (!(pendingSpend <= 0f))
		{
			ShowSpend(pendingSpend);
			pendingSpend = 0f;
			pendingSpendUntil = 0f;
		}
	}

	private void QueueSpend(float amount)
	{
		if (pendingSpend > 0f && Time.unscaledTime >= pendingSpendUntil)
		{
			FlushSpend();
		}
		if (amount >= 1f)
		{
			FlushSpend();
			ShowSpend(amount);
			return;
		}
		if (pendingSpend <= 0f)
		{
			pendingSpendUntil = Time.unscaledTime + 0.35f;
		}
		pendingSpend += amount;
	}

	private void ShowSpend(float amount)
	{
		SpendVisual spendVisual = spendVisuals[spendIndex];
		if (spendVisual != null)
		{
			spendIndex = (spendIndex + 1) % spendVisuals.Length;
			spendVisual.Amount = amount;
			spendVisual.Born = Time.unscaledTime;
		}
	}

	private void UpdateFeedback(float factor)
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: 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_0164: Unknown result type (might be due to invalid IL or missing references)
		if (pendingSpend > 0f && Time.unscaledTime >= pendingSpendUntil)
		{
			FlushSpend();
		}
		float num = Mathf.Clamp01((emptyUntil - Time.unscaledTime) / 0.55f);
		((Graphic)staminaValue).color = Color.Lerp(Color.white, new Color(1f, 0.1f, 0.06f, 1f), Mathf.Min(1f, num * 3f));
		float num2 = ((num > 0f) ? (Mathf.Sin((0.55f - (emptyUntil - Time.unscaledTime)) * 55f) * 3f * num / Mathf.Max(0.1f, factor)) : 0f);
		staminaValue.rectTransform.anchoredPosition = new Vector2(194f + num2, -72f);
		SpendVisual[] array = spendVisuals;
		foreach (SpendVisual spendVisual in array)
		{
			float num3 = Time.unscaledTime - spendVisual.Born;
			spendVisual.Group.alpha = ((num3 < 0f || num3 > 1.2f) ? 0f : Mathf.Clamp01((1.2f - num3) / 0.45f));
			spendVisual.Root.anchoredPosition = new Vector2(190f + builtWidth + 140f, -72f + Mathf.Clamp(num3, 0f, 1.2f) * 12f);
			spendVisual.Text.text = "-" + spendVisual.Amount.ToString("0.#", CultureInfo.InvariantCulture);
		}
	}
}
internal static class MMCBuffTime
{
	public static string Format(double seconds)
	{
		if (double.IsNaN(seconds) || double.IsInfinity(seconds))
		{
			return "--";
		}
		seconds = Math.Max(0.0, seconds);
		if (!(seconds > 60.0))
		{
			return Math.Ceiling(seconds).ToString("0") + "s";
		}
		return Math.Ceiling(seconds / 60.0).ToString("0") + "m";
	}

	public static bool Warn(double seconds)
	{
		if (seconds > 0.0)
		{
			return seconds <= 60.0;
		}
		return false;
	}
}
public static class MMCFoodStaminaForecast
{
	public struct Food
	{
		public double Remaining;

		public double Duration;

		public double BaseStamina;

		public double CurrentStamina;
	}

	public static bool Predict(Food[] foods, double maximum, double timer, double rate, out double seconds, out int amount)
	{
		seconds = 0.0;
		amount = 0;
		if (rate <= 0.0 || foods.Length == 0)
		{
			return false;
		}
		double num = 0.0;
		double num2 = 0.0;
		for (int i = 0; i < foods.Length; i++)
		{
			Food food = foods[i];
			num += food.CurrentStamina;
			num2 = Math.Max(num2, food.Remaining);
		}
		double baseline = maximum - num;
		int num3 = (int)Math.Ceiling(maximum);
		int num4 = (int)Math.Min(1000000.0, Math.Ceiling(num2));
		if (num4 < 1 || Remaining(foods, baseline, num4) >= num3)
		{
			return false;
		}
		int num5 = 1;
		while (num5 < num4)
		{
			int num6 = num5 + (num4 - num5) / 2;
			if (Remaining(foods, baseline, num6) < num3)
			{
				num4 = num6;
			}
			else
			{
				num5 = num6 + 1;
			}
		}
		amount = num3 - Remaining(foods, baseline, num5);
		seconds = Math.Max(0.0, ((double)num5 - Math.Max(0.0, Math.Min(1.0, timer))) / rate);
		return amount > 0;
	}

	private static int Remaining(Food[] foods, double baseline, int ticks)
	{
		double num = baseline;
		for (int i = 0; i < foods.Length; i++)
		{
			Food food = foods[i];
			if (food.Remaining > (double)ticks && food.Duration > 0.0)
			{
				num += food.BaseStamina * Math.Pow(Math.Min(1.0, (food.Remaining - (double)ticks) / food.Duration), 0.3);
			}
		}
		return (int)Math.Ceiling(Math.Max(1.0, num));
	}
}
public static class MMCHealForecast
{
	public static void Include(float seconds, float amount, ref float nextSeconds, ref float nextAmount)
	{
		if (!(amount <= 0f) && !float.IsNaN(amount) && !float.IsInfinity(amount) && !float.IsNaN(seconds) && !float.IsInfinity(seconds))
		{
			seconds = Math.Max(0f, seconds);
			if (seconds < nextSeconds - 0.021f)
			{
				nextSeconds = seconds;
				nextAmount = amount;
			}
			else if (Math.Abs(seconds - nextSeconds) <= 0.021f)
			{
				nextSeconds = Math.Min(seconds, nextSeconds);
				nextAmount += amount;
			}
		}
	}

	public static void IncludeTimed(float seconds, float amount, float interval, ref float nextSeconds, ref float nextAmount, ref float nextInterval)
	{
		if (!(amount <= 0f) && !float.IsNaN(amount) && !float.IsInfinity(amount) && !float.IsNaN(seconds) && !float.IsInfinity(seconds))
		{
			seconds = Math.Max(0f, seconds);
			if (seconds < nextSeconds - 0.021f)
			{
				nextInterval = interval;
			}
			else if (Math.Abs(seconds - nextSeconds) <= 0.021f)
			{
				nextInterval = Math.Max(nextInterval, interval);
			}
			Include(seconds, amount, ref nextSeconds, ref nextAmount);
		}
	}

	public static float Progress(float seconds, float interval)
	{
		if (interval <= 0f || float.IsNaN(interval) || float.IsInfinity(interval) || float.IsNaN(seconds) || float.IsInfinity(seconds))
		{
			return 0f;
		}
		return Math.Max(0f, Math.Min(1f, 1f - seconds / interval));
	}

	public static float Cap(float amount, float health, float maxHealth)
	{
		return Math.Max(0f, Math.Min(amount, maxHealth - health));
	}
}
public static class MMCPanelHealing
{
	private static readonly FieldInfo foodTimer = AccessTools.Field(typeof(Player), "m_foodRegenTimer");

	private static readonly FieldInfo tickTimer = AccessTools.Field(typeof(SE_Stats), "m_tickTimer");

	private static readonly FieldInfo hotTimer = AccessTools.Field(typeof(SE_Stats), "m_healthOverTimeTimer");

	private static readonly FieldInfo hotTicks = AccessTools.Field(typeof(SE_Stats), "m_healthOverTimeTicks");

	private static readonly FieldInfo hotHP = AccessTools.Field(typeof(SE_Stats), "m_healthOverTimeTickHP");

	public static void Predict(Player player, out float seconds, out float amount, out float interval, out float rate)
	{
		seconds = float.PositiveInfinity;
		amount = 0f;
		interval = 0f;
		rate = 0f;
		if (((Character)player).IsTeleporting() || ((Character)player).InIntro())
		{
			return;
		}
		float num = Mathf.Max(0f, 10f - (float)foodTimer.GetValue(player));
		float num2 = 0f;
		foreach (Food food in player.GetFoods())
		{
			if (food.m_item != null && food.m_time > num * Game.m_foodRate)
			{
				num2 += food.m_item.m_shared.m_foodRegen;
			}
		}
		float num3 = 1f;
		((Character)player).GetSEMan().ModifyHealthRegen(ref num3);
		MMCHealForecast.IncludeTimed(num, num2 * num3, 10f, ref seconds, ref amount, ref interval);
		rate += Mathf.Max(0f, num2 * num3) / 10f;
		foreach (StatusEffect statusEffect in ((Character)player).GetSEMan().GetStatusEffects())
		{
			SE_Stats val = (SE_Stats)(object)((statusEffect is SE_Stats) ? statusEffect : null);
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			float num4 = ((statusEffect.m_ttl > 0f) ? statusEffect.GetRemaningTime() : float.PositiveInfinity);
			if (val.m_tickInterval > 0f && val.m_healthPerTick > 0f && ((Character)player).GetHealthPercentage() >= val.m_healthPerTickMinHealthPercentage)
			{
				float num5 = Mathf.Max(0f, val.m_tickInterval - (float)tickTimer.GetValue(val));
				if (num5 <= num4)
				{
					MMCHealForecast.IncludeTimed(num5, val.m_healthPerTick, val.m_tickInterval, ref seconds, ref amount, ref interval);
					rate += val.m_healthPerTick / val.m_tickInterval;
				}
			}
			if ((float)hotTicks.GetValue(val) > 0f)
			{
				float num6 = Mathf.Max(0f, val.m_healthOverTimeInterval - (float)hotTimer.GetValue(val));
				if (num6 <= num4 && val.m_healthOverTimeInterval > 0f)
				{
					float num7 = (float)hotHP.GetValue(val);
					MMCHealForecast.IncludeTimed(num6, num7, val.m_healthOverTimeInterval, ref seconds, ref amount, ref interval);
					rate += Mathf.Max(0f, num7) / val.m_healthOverTimeInterval;
				}
			}
		}
	}
}
public sealed class MMCStaminaRate
{
	private const double SampleGrace = 0.35;

	public double Rate;

	public double LastSample;

	public bool Refilling;

	private double recovered;

	public void Reset()
	{
		Rate = 0.0;
		LastSample = 0.0;
		Refilling = false;
		recovered = 0.0;
	}

	public void Observe(double now, double before, double after, double oldMaximum, double maximum, double dt)
	{
		double num = after - before;
		if (dt <= 0.0 || dt > 1.0 || double.IsNaN(num) || double.IsInfinity(num) || double.IsNaN(maximum) || double.IsInfinity(maximum) || maximum <= 0.0 || maximum > oldMaximum + 0.001 || after >= maximum - 0.001 || num < -1E-05)
		{
			Reset();
			return;
		}
		if (Refilling && (now - LastSample >= 0.35 || now < LastSample))
		{
			Reset();
		}
		if (!(num <= 1E-05))
		{
			double num2 = num / dt;
			Rate = ((!Refilling) ? num2 : (Rate + (num2 - Rate) * (1.0 - Math.Exp((0.0 - dt) / 0.2))));
			recovered += num;
			LastSample = now;
			Refilling = true;
		}
	}

	public bool Visible(double now)
	{
		if (Refilling && recovered >= 9.999999 && now >= LastSample)
		{
			return now - LastSample < 0.35;
		}
		return false;
	}
}
public sealed class SagaBoostWipe
{
	private bool initialized;

	private int previousBonus;

	private double previousFoodTime;

	private double span;

	public float Update(int bonus, double foodTime, double ticksRemaining, bool predicted)
	{
		if (bonus <= 0 || !predicted || double.IsNaN(ticksRemaining) || double.IsInfinity(ticksRemaining))
		{
			initialized = false;
			return 0f;
		}
		if (!initialized || bonus != previousBonus || foodTime > previousFoodTime + 0.5 || ticksRemaining > span + 0.01)
		{
			span = Math.Max(0.001, ticksRemaining);
		}
		initialized = true;
		previousBonus = bonus;
		previousFoodTime = foodTime;
		return (float)Math.Max(0.0, Math.Min(1.0, 1.0 - ticksRemaining / span));
	}
}
internal static class SagaConfigPreview
{
	private static BaseUnityPlugin manager;

	private static PropertyInfo displaying;

	private static float retry;

	private static int frame = -1;

	private static bool open;

	internal static bool Open
	{
		get
		{
			if (frame == Time.frameCount)
			{
				return open;
			}
			frame = Time.frameCount;
			open = false;
			if ((Object)(object)manager == (Object)null && Time.unscaledTime >= retry)
			{
				retry = Time.unscaledTime + 2f;
				if (Chainloader.PluginInfos.TryGetValue("com.bepis.bepinex.configurationmanager", out var value))
				{
					manager = value.Instance;
					displaying = ((object)manager).GetType().GetProperty("DisplayingWindow", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				}
			}
			if ((Object)(object)manager != (Object)null && displaying != null)
			{
				try
				{
					open = (bool)displaying.GetValue(manager, null);
				}
				catch
				{
					open = false;
				}
			}
			return open;
		}
	}

	internal static bool HudVisible(Hud hud)
	{
		if ((Object)(object)hud != (Object)null)
		{
			if (!Open)
			{
				return hud.IsVisible();
			}
			return true;
		}
		return false;
	}

	internal static bool MenuVisible()
	{
		if (!Open)
		{
			return Menu.IsVisible();
		}
		return false;
	}

	internal static bool MapVisible()
	{
		if (!Open)
		{
			return Minimap.IsOpen();
		}
		return false;
	}

	internal static bool StoreVisible()
	{
		if (!Open)
		{
			return StoreGui.IsVisible();
		}
		return false;
	}

	internal static bool InventoryHidesHud()
	{
		if (!Open)
		{
			return InventoryGui.IsVisible();
		}
		return false;
	}
}
public static class SagaFoodBoostForecast
{
	public struct Food
	{
		public float Remaining;

		public float Duration;

		public float Base;

		public float Current;
	}

	public static int Bonus(Food[] foods)
	{
		float num = 0f;
		for (int i = 0; i < foods.Length; i++)
		{
			Food food = foods[i];
			num += Math.Max(0f, food.Current);
		}
		return (int)Math.Ceiling(num);
	}

	private static int At(Food[] foods, int ticks)
	{
		float num = 0f;
		for (int i = 0; i < foods.Length; i++)
		{
			Food food = foods[i];
			if (!(food.Duration <= 0f) && !(food.Remaining <= (float)ticks))
			{
				float num2 = Math.Max(0f, Math.Min(1f, (food.Remaining - (float)ticks) / food.Duration));
				num += food.Base * (float)Math.Pow(num2, 0.30000001192092896);
			}
		}
		return (int)Math.Ceiling(Math.Max(0f, num));
	}

	public static bool Predict(Food[] foods, double timer, double rate, out double seconds, out int drop)
	{
		seconds = 0.0;
		drop = 0;
		if (foods == null || foods.Length == 0 || rate <= 0.0 || double.IsNaN(rate) || double.IsInfinity(rate) || double.IsNaN(timer) || double.IsInfinity(timer))
		{
			return false;
		}
		int num = Bonus(foods);
		if (num <= 0)
		{
			return false;
		}
		double num2 = 0.0;
		for (int i = 0; i < foods.Length; i++)
		{
			Food food = foods[i];
			num2 = Math.Max(num2, food.Remaining);
		}
		int num3 = (int)Math.Min(1000000.0, Math.Ceiling(num2));
		if (num3 < 1 || At(foods, num3) >= num)
		{
			return false;
		}
		int num4 = 1;
		while (num4 < num3)
		{
			int num5 = num4 + (num3 - num4) / 2;
			if (At(foods, num5) < num)
			{
				num3 = num5;
			}
			else
			{
				num4 = num5 + 1;
			}
		}
		drop = num - At(foods, num4);
		seconds = Math.Max(0.0, ((double)num4 - timer) / rate);
		return drop > 0;
	}
}