using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using SkillsPreview.App.Data;
using SkillsPreview.App.Locale;
using SkillsPreview.App.Logging;
using SkillsPreview.App.Store;
using SkillsPreview.App.UI.CharacterStatsPanel;
using SkillsPreview.App.UI.FavoriteSkillsHud;
using SkillsPreview.App.UI.LevelUpToast;
using SkillsPreview.App.UI.SettingsPanel;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("SkillsPreview")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.5.2.0")]
[assembly: AssemblyInformationalVersion("0.5.2+567001adb8542b5d7ba2b0a1ba05ef5ad0025561")]
[assembly: AssemblyProduct("SkillsPreview")]
[assembly: AssemblyTitle("SkillsPreview")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
	internal static class IsExternalInit
	{
	}
}
namespace SkillsPreview.App
{
	[BepInPlugin("godzki.skills_preview", "Skills Preview", "0.5.2")]
	public class Plugin : BaseUnityPlugin
	{
		internal static Plugin Instance;

		internal static ManualLogSource Log;

		private readonly Harmony _harmony = new Harmony("godzki.skills_preview");

		internal static void SaveConfig()
		{
			((BaseUnityPlugin)Instance).Config.Save();
			FavoriteSkillsStore.NotifyConfigChanged();
		}

		private void Awake()
		{
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			Config.Bind((BaseUnityPlugin)(object)this);
			_harmony.PatchAll();
			Log.LogInfo((object)"Skills Preview 0.5.2 loaded.");
		}

		private void OnDestroy()
		{
			_harmony.UnpatchSelf();
		}
	}
}
namespace SkillsPreview.App.UI
{
	internal static class SpriteUtils
	{
		private static readonly Dictionary<int, Sprite> RoundedRectCache = new Dictionary<int, Sprite>();

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

		internal static Sprite RoundedRect(int radius)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			//IL_00a6: 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_00c1: 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)
			if (RoundedRectCache.TryGetValue(radius, out Sprite value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			int num = radius * 2 + 2;
			Texture2D val = new Texture2D(num, num, (TextureFormat)5, false);
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[num * num];
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					array[i * num + j] = SampleRoundedRectPixel(j, i, num, num, radius);
				}
			}
			val.SetPixels32(array);
			val.Apply(false);
			Vector4 val2 = default(Vector4);
			((Vector4)(ref val2))..ctor((float)radius, (float)radius, (float)radius, (float)radius);
			Sprite val3 = Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val2);
			RoundedRectCache[radius] = val3;
			return val3;
		}

		internal static Sprite ResetIcon(int size = 24)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)5, false);
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[size * size];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Color32((byte)0, (byte)0, (byte)0, (byte)0);
			}
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor((byte)160, (byte)115, (byte)55, byte.MaxValue);
			float num = (float)(size - 1) * 0.5f;
			float num2 = (float)(size - 1) * 0.5f;
			float num3 = (float)size * 0.44f;
			float num4 = (float)size * 0.27f;
			float num5 = (num3 + num4) * 0.5f;
			float num6 = (num3 - num4) * 0.5f;
			for (int j = 0; j < size; j++)
			{
				for (int k = 0; k < size; k++)
				{
					float num7 = (float)k - num;
					float num8 = (float)j - num2;
					float num9 = Mathf.Sqrt(num7 * num7 + num8 * num8);
					if (!(num9 < num4 - 1f) && !(num9 > num3 + 1f))
					{
						float num10 = Mathf.Atan2(num8, num7) * 57.29578f;
						if (num10 < 0f)
						{
							num10 += 360f;
						}
						if (!(num10 >= 60f) || !(num10 <= 105f))
						{
							float num11 = Mathf.Min(num9 - num4, num3 - num9);
							byte b = (byte)((num11 >= 1f) ? byte.MaxValue : ((num11 > 0f) ? ((byte)(255f * num11)) : 0));
							array[j * size + k] = new Color32(val2.r, val2.g, val2.b, b);
						}
					}
				}
			}
			float num12 = (float)Math.PI / 3f;
			float num13 = num + num5 * Mathf.Cos(num12);
			float num14 = num2 + num5 * Mathf.Sin(num12);
			float num15 = Mathf.Sin(num12);
			float num16 = 0f - Mathf.Cos(num12);
			float num17 = Mathf.Cos(num12);
			float num18 = Mathf.Sin(num12);
			float num19 = num6 * 2.8f;
			float num20 = num6 * 1.5f;
			Vector2 a = default(Vector2);
			((Vector2)(ref a))..ctor(num13 + num15 * num19, num14 + num16 * num19);
			Vector2 b2 = default(Vector2);
			((Vector2)(ref b2))..ctor(num13 + num17 * num20, num14 + num18 * num20);
			Vector2 c = default(Vector2);
			((Vector2)(ref c))..ctor(num13 - num17 * num20, num14 - num18 * num20);
			FillTriangle(array, size, a, b2, c, val2);
			val.SetPixels32(array);
			val.Apply(false);
			return Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), 100f);
		}

		private static void FillTriangle(Color32[] pixels, int size, Vector2 a, Vector2 b, Vector2 c, Color32 color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.x, Mathf.Min(b.x, c.x))));
			int num2 = Mathf.Min(size - 1, Mathf.CeilToInt(Mathf.Max(a.x, Mathf.Max(b.x, c.x))));
			int num3 = Mathf.Max(0, Mathf.FloorToInt(Mathf.Min(a.y, Mathf.Min(b.y, c.y))));
			int num4 = Mathf.Min(size - 1, Mathf.CeilToInt(Mathf.Max(a.y, Mathf.Max(b.y, c.y))));
			for (int i = num3; i <= num4; i++)
			{
				for (int j = num; j <= num2; j++)
				{
					if (PointInTriangle(new Vector2((float)j, (float)i), a, b, c))
					{
						pixels[i * size + j] = color;
					}
				}
			}
		}

		private static bool PointInTriangle(Vector2 p, Vector2 a, Vector2 b, Vector2 c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			float num = Cross(p - a, b - a);
			float num2 = Cross(p - b, c - b);
			float num3 = Cross(p - c, a - c);
			if (!(num >= 0f) || !(num2 >= 0f) || !(num3 >= 0f))
			{
				if (num <= 0f && num2 <= 0f)
				{
					return num3 <= 0f;
				}
				return false;
			}
			return true;
		}

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

		internal static Sprite RoundedRectFrame(int radius, int frameWidth)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: 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_0080: 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_00f5: 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)
			(int, int) key = (radius, frameWidth);
			if (RoundedRectFrameCache.TryGetValue(key, out Sprite value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			int num = Mathf.Max(radius * 2 + 2, frameWidth * 2 + 3);
			int r = Mathf.Max(0, radius - frameWidth);
			int num2 = num - frameWidth * 2;
			Texture2D val = new Texture2D(num, num, (TextureFormat)5, false);
			((Texture)val).filterMode = (FilterMode)1;
			((Texture)val).wrapMode = (TextureWrapMode)1;
			Color32[] array = (Color32[])(object)new Color32[num * num];
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					byte a = SampleRoundedRectPixel(j, i, num, num, radius).a;
					int num3 = j - frameWidth;
					int num4 = i - frameWidth;
					byte b = (byte)((num3 >= 0 && num4 >= 0 && num3 < num2 && num4 < num2) ? SampleRoundedRectPixel(num3, num4, num2, num2, r).a : 0);
					array[i * num + j] = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)(a * (255 - b) / 255));
				}
			}
			val.SetPixels32(array);
			val.Apply(false);
			Vector4 val2 = default(Vector4);
			((Vector4)(ref val2))..ctor((float)radius, (float)radius, (float)radius, (float)radius);
			Sprite val3 = Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), 100f, 0u, (SpriteMeshType)0, val2);
			RoundedRectFrameCache[key] = val3;
			return val3;
		}

		private static Color32 SampleRoundedRectPixel(int x, int y, int w, int h, int r)
		{
			//IL_0059: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(x, r, w - r - 1);
			float num2 = Mathf.Clamp(y, r, h - r - 1);
			float num3 = Mathf.Sqrt(((float)x - num) * ((float)x - num) + ((float)y - num2) * ((float)y - num2));
			if (num3 <= (float)r - 1f)
			{
				return new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			}
			if (num3 >= (float)r + 0.5f)
			{
				return new Color32((byte)0, (byte)0, (byte)0, (byte)0);
			}
			byte b = (byte)(255f * Mathf.Clamp01((float)r + 0.5f - num3));
			return new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, b);
		}
	}
}
namespace SkillsPreview.App.UI.SettingsPanel
{
	internal class SettingsPanel
	{
		private static Log.Scoped Logger { get; } = Log.For("SettingsPanel");


		public GameObject Root { get; private set; }

		internal bool IsAlive => (Object)(object)Root != (Object)null;

		internal bool IsVisible
		{
			get
			{
				if ((Object)(object)Root != (Object)null)
				{
					return Root.activeSelf;
				}
				return false;
			}
		}

		private SettingsPanel(GameObject root)
		{
			Root = root;
		}

		internal void Show()
		{
			if ((Object)(object)Root != (Object)null)
			{
				Root.SetActive(true);
			}
		}

		internal void Hide()
		{
			if ((Object)(object)Root != (Object)null)
			{
				Root.SetActive(false);
			}
		}

		internal static SettingsPanel Create(Transform skillsFrame)
		{
			Font builtinResource = Resources.GetBuiltinResource<Font>("Arial.ttf");
			GameObject val = SettingsPanelLayout.BuildRoot(skillsFrame);
			SettingsPanelLayout.BuildBackground(val, skillsFrame);
			ILabels current = L.Current;
			Transform content = SettingsPanelLayout.AddScrollView(val.transform);
			List<Action> resets = new List<Action>();
			List<Action> refreshes = new List<Action>();
			SettingsPanelLayout.AddTitle(val.transform, skillsFrame, current.SectionSkillsPanel);
			SettingsPanelRows.Populate(content, builtinResource, resets, refreshes, skillsFrame, current);
			SettingsPanelLayout.AddResetAllButton(val.transform, current.ResetAll, resets, skillsFrame);
			SettingsPanelLayout.AddCloseButton(val.transform, val, skillsFrame);
			Logger.Debug("Settings panel created.");
			return new SettingsPanel(val);
		}
	}
	internal static class SettingsPanelLayout
	{
		private const float PanelWidth = 500f;

		private const float PanelHeight = 620f;

		private const int SectionFontSize = 12;

		private static readonly Color PanelBgColor = new Color(0.08f, 0.06f, 0.04f, 0.97f);

		private static readonly Color SectionColor = new Color(0.65f, 0.52f, 0.28f);

		internal static GameObject BuildRoot(Transform skillsFrame)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_004d: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			GameObject val = new GameObject("godzki_SettingsPanel", new Type[1] { typeof(RectTransform) });
			val.SetActive(false);
			val.transform.SetParent(skillsFrame, false);
			val.transform.SetAsLastSibling();
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(500f, 620f);
			component.anchoredPosition = Vector2.zero;
			return val;
		}

		internal static void BuildBackground(GameObject root, Transform skillsFrame)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0043: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = skillsFrame.Find("bkg");
			Image val = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			if ((Object)(object)val != (Object)null)
			{
				GameObject obj2 = Object.Instantiate<GameObject>(((Component)val).gameObject, root.transform);
				((Object)obj2).name = "bkg";
				RectTransform component = obj2.GetComponent<RectTransform>();
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				Vector2 offsetMin = (component.offsetMax = Vector2.zero);
				component.offsetMin = offsetMin;
			}
			else
			{
				GameObject val2 = new GameObject("bkg", new Type[3]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image)
				});
				val2.transform.SetParent(root.transform, false);
				SettingsPanelWidgets.Stretch(val2.GetComponent<RectTransform>());
				((Graphic)val2.GetComponent<Image>()).color = PanelBgColor;
			}
		}

		internal static void AddTitle(Transform parent, Transform skillsFrame, string label)
		{
			//IL_0046: 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_0070: 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)
			Transform obj = skillsFrame.Find("topic");
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("topic not found in SkillsFrame");
			}
			GameObject obj2 = Object.Instantiate<GameObject>(((Component)obj).gameObject, parent);
			((Object)obj2).name = "Topic";
			RectTransform component = obj2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -10f);
			obj2.GetComponentInChildren<TMP_Text>().text = label;
		}

		internal static Transform AddScrollView(Transform parent)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_016c: 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_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ScrollView", new Type[2]
			{
				typeof(RectTransform),
				typeof(ScrollRect)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(8f, 90f);
			component.offsetMax = new Vector2(-8f, -62f);
			GameObject val2 = new GameObject("Viewport", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Mask)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			SettingsPanelWidgets.Stretch(component2);
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.01f);
			val2.GetComponent<Mask>().showMaskGraphic = false;
			GameObject val3 = new GameObject("Content", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = Vector2.zero;
			VerticalLayoutGroup component4 = val3.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 2f;
			((LayoutGroup)component4).padding = new RectOffset(24, 24, 24, 24);
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			val3.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect component5 = val.GetComponent<ScrollRect>();
			component5.content = component3;
			component5.viewport = component2;
			component5.horizontal = false;
			component5.vertical = true;
			component5.scrollSensitivity = 30f;
			component5.movementType = (MovementType)2;
			component5.inertia = false;
			return val3.transform;
		}

		internal static void AddSection(Transform parent, Font font, string label)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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)
			GameObject val = new GameObject("Section_" + label, new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			float preferredHeight = (component.minHeight = 22f);
			component.preferredHeight = preferredHeight;
			Text component2 = val.GetComponent<Text>();
			component2.font = font;
			component2.fontSize = 12;
			component2.fontStyle = (FontStyle)1;
			component2.alignment = (TextAnchor)6;
			((Graphic)component2).color = SectionColor;
			component2.text = "— " + label;
			((Graphic)component2).raycastTarget = false;
		}

		internal static void AddResetAllButton(Transform parent, string label, List<Action> resets, Transform skillsFrame)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a6: 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_00cc: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			List<Action> resets2 = resets;
			Transform obj = skillsFrame.Find("Closebutton");
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("Closebutton not found in SkillsFrame");
			}
			GameObject obj2 = Object.Instantiate<GameObject>(((Component)obj).gameObject, parent);
			((Object)obj2).name = "ResetBtn";
			RectTransform component = obj2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(0f, 0f);
			component.pivot = new Vector2(0f, 0f);
			component.sizeDelta = new Vector2(130f, 40f);
			component.anchoredPosition = new Vector2(15f, 30f);
			obj2.GetComponentInChildren<TMP_Text>().text = label;
			Button component2 = obj2.GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				foreach (Action item in resets2)
				{
					item();
				}
			});
		}

		internal static void AddCloseButton(Transform parent, GameObject panelRoot, Transform skillsFrame)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			GameObject panelRoot2 = panelRoot;
			Transform obj = skillsFrame.Find("Closebutton");
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("Closebutton not found in SkillsFrame");
			}
			GameObject obj2 = Object.Instantiate<GameObject>(((Component)obj).gameObject, parent);
			((Object)obj2).name = "CloseBtn";
			RectTransform component = obj2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0f);
			component.anchorMax = new Vector2(0.5f, 0f);
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(0f, 25f);
			Button component2 = obj2.GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				panelRoot2.SetActive(false);
			});
		}
	}
	internal static class ColorPickerPopup
	{
		private const float SwatchSize = 22f;

		private const float SwatchSpacing = 0f;

		private const int GridColumns = 12;

		private const int GridRows = 8;

		private const float AlphaBarWidth = 18f;

		private const float PopupPadding = 8f;

		private const float GridToBarGap = 14f;

		private static readonly Color PopupBgColor = new Color(0.08f, 0.06f, 0.04f, 0.97f);

		private static GameObject? CurrentlyOpenOverlay;

		private static Sprite? CachedGradient;

		private static Sprite AlphaGradientSprite => CachedGradient ?? (CachedGradient = BuildAlphaGradientSprite());

		internal static (GameObject overlay, Action<Color> syncAlpha) Build(Transform panelRoot, Func<Color> getColor, Action<Color> applyColor)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			Func<Color> getColor2 = getColor;
			Action<Color> applyColor2 = applyColor;
			GameObject overlayGo = BuildOverlay(panelRoot);
			GameObject val = BuildPopupPanel(overlayGo.transform);
			float gridWidth = 264f;
			float gridHeight = 176f;
			GameObject obj = BuildGrid(val.transform, gridWidth, gridHeight);
			GameObject sliderGo = BuildAlphaSlider(val.transform, gridWidth, gridHeight);
			Slider slider = sliderGo.GetComponent<Slider>();
			slider.value = getColor2().a;
			AddSwatches(obj.transform, slider, applyColor2);
			((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate(float alpha)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0035: Unknown result type (might be due to invalid IL or missing references)
				Color val2 = getColor2();
				applyColor2(new Color(val2.r, val2.g, val2.b, alpha));
				UpdateSliderTint(sliderGo, val2);
			});
			((UnityEvent)overlayGo.GetComponent<Button>().onClick).AddListener((UnityAction)delegate
			{
				CloseOverlay(overlayGo);
			});
			return (overlayGo, SyncAlpha);
			void SyncAlpha(Color c)
			{
				//IL_0006: 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)
				slider.value = c.a;
				UpdateSliderTint(sliderGo, c);
			}
		}

		internal static void OpenOverlay(GameObject overlay, Color currentColor, Action<Color> syncAlpha)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CurrentlyOpenOverlay != (Object)null && (Object)(object)CurrentlyOpenOverlay != (Object)(object)overlay)
			{
				CurrentlyOpenOverlay.SetActive(false);
			}
			CurrentlyOpenOverlay = overlay;
			overlay.SetActive(true);
			syncAlpha(currentColor);
		}

		private static void CloseOverlay(GameObject overlay)
		{
			overlay.SetActive(false);
			if ((Object)(object)CurrentlyOpenOverlay == (Object)(object)overlay)
			{
				CurrentlyOpenOverlay = null;
			}
		}

		private static GameObject BuildOverlay(Transform panelRoot)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: 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_00ac: Expected O, but got Unknown
			GameObject val = new GameObject("ColorPickerOverlay", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(panelRoot, false);
			val.SetActive(false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			Vector2 offsetMin = (component.offsetMax = Vector2.zero);
			component.offsetMin = offsetMin;
			((Graphic)val.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			return val;
		}

		private static GameObject BuildPopupPanel(Transform overlayTransform)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			float num = 264f;
			float num2 = 176f;
			float num3 = 8f + num + 14f + 18f + 8f;
			float num4 = 8f + num2 + 8f;
			GameObject val = new GameObject("ColorPickerPopup", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button)
			});
			val.transform.SetParent(overlayTransform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(num3, num4);
			component.anchoredPosition = Vector2.zero;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = PopupBgColor;
			((Selectable)val.GetComponent<Button>()).targetGraphic = (Graphic)(object)component2;
			return val;
		}

		private static GameObject BuildGrid(Transform popupTransform, float gridWidth, float gridHeight)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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_005d: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			GameObject val = new GameObject("ColorGrid", new Type[2]
			{
				typeof(RectTransform),
				typeof(GridLayoutGroup)
			});
			val.transform.SetParent(popupTransform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(0f, 0f);
			component.pivot = new Vector2(0f, 0f);
			component.anchoredPosition = new Vector2(8f, 8f);
			component.sizeDelta = new Vector2(gridWidth, gridHeight);
			GridLayoutGroup component2 = val.GetComponent<GridLayoutGroup>();
			component2.cellSize = new Vector2(22f, 22f);
			component2.spacing = new Vector2(0f, 0f);
			component2.startCorner = (Corner)0;
			component2.startAxis = (Axis)0;
			component2.constraint = (Constraint)1;
			component2.constraintCount = 12;
			((LayoutGroup)component2).childAlignment = (TextAnchor)0;
			return val;
		}

		private static void AddSwatches(Transform gridTransform, Slider alphaSlider, Action<Color> applyColor)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			Slider alphaSlider2 = alphaSlider;
			Action<Color> applyColor2 = applyColor;
			for (int i = 0; i < ColorPicker.Palette.Length; i++)
			{
				Color swatchColor = ColorPicker.Palette[i];
				GameObject val = new GameObject($"Swatch_{i}", new Type[4]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Image),
					typeof(Button)
				});
				val.transform.SetParent(gridTransform, false);
				Image component = val.GetComponent<Image>();
				((Graphic)component).color = swatchColor;
				Button component2 = val.GetComponent<Button>();
				((Selectable)component2).targetGraphic = (Graphic)(object)component;
				((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
				{
					//IL_0043: Unknown result type (might be due to invalid IL or missing references)
					Color obj = default(Color);
					((Color)(ref obj))..ctor(swatchColor.r, swatchColor.g, swatchColor.b, alphaSlider2.value);
					applyColor2(obj);
				});
			}
		}

		private static GameObject BuildAlphaSlider(Transform popupTransform, float gridWidth, float gridHeight)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0049: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Expected O, but got Unknown
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Expected O, but got Unknown
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("AlphaSlider", new Type[2]
			{
				typeof(RectTransform),
				typeof(Slider)
			});
			val.transform.SetParent(popupTransform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(0f, 0f);
			component.pivot = new Vector2(0f, 0f);
			component.anchoredPosition = new Vector2(8f + gridWidth + 14f, 8f);
			component.sizeDelta = new Vector2(18f, gridHeight);
			GameObject val2 = new GameObject("Background", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			SettingsPanelWidgets.Stretch(val2.GetComponent<RectTransform>());
			Image component2 = val2.GetComponent<Image>();
			component2.sprite = AlphaGradientSprite;
			component2.type = (Type)0;
			component2.preserveAspect = false;
			((Graphic)component2).color = Color.white;
			GameObject val3 = new GameObject("Fill Area", new Type[1] { typeof(RectTransform) });
			val3.transform.SetParent(val.transform, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			Vector2 offsetMin = (component3.offsetMax = Vector2.zero);
			component3.offsetMin = offsetMin;
			GameObject val4 = new GameObject("Fill", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val4.transform.SetParent(val3.transform, false);
			RectTransform component4 = val4.GetComponent<RectTransform>();
			component4.anchorMin = Vector2.zero;
			component4.anchorMax = new Vector2(1f, 0f);
			component4.sizeDelta = Vector2.zero;
			((Graphic)val4.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
			GameObject val5 = new GameObject("Handle Slide Area", new Type[1] { typeof(RectTransform) });
			val5.transform.SetParent(val.transform, false);
			RectTransform component5 = val5.GetComponent<RectTransform>();
			component5.anchorMin = Vector2.zero;
			component5.anchorMax = Vector2.one;
			component5.offsetMin = new Vector2(0f, 8f);
			component5.offsetMax = new Vector2(0f, -8f);
			GameObject val6 = new GameObject("Handle", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val6.transform.SetParent(val5.transform, false);
			val6.GetComponent<RectTransform>().sizeDelta = new Vector2(24f, 7f);
			Image component6 = val6.GetComponent<Image>();
			((Graphic)component6).color = Color.white;
			SettingsPanelWidgets.ApplyRoundedSprite(component6);
			Slider component7 = val.GetComponent<Slider>();
			component7.direction = (Direction)2;
			component7.minValue = 0f;
			component7.maxValue = 1f;
			component7.value = 1f;
			component7.wholeNumbers = false;
			component7.fillRect = val4.GetComponent<RectTransform>();
			component7.handleRect = val6.GetComponent<RectTransform>();
			((Selectable)component7).targetGraphic = (Graphic)(object)component6;
			return val;
		}

		private static void UpdateSliderTint(GameObject sliderGo, Color color)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = sliderGo.transform.Find("Background");
			Image val = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
			if ((Object)(object)val != (Object)null)
			{
				((Graphic)val).color = new Color(color.r, color.g, color.b, 1f);
			}
		}

		private static Sprite BuildAlphaGradientSprite()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(1, 64, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			for (int i = 0; i < 64; i++)
			{
				val.SetPixel(0, i, new Color(1f, 1f, 1f, (float)i / 63f));
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, 1f, 64f), new Vector2(0.5f, 0.5f));
		}
	}
	internal sealed class RowContext
	{
		public Transform Content { get; init; }

		public Font Font { get; init; }

		public List<Action> Resets { get; init; }

		public List<Action> Refreshes { get; init; }

		public Transform SkillsFrame { get; init; }

		public ILabels Labels { get; init; }
	}
	internal sealed class ConfigBinding<T>
	{
		public Func<T> Get { get; }

		public Action<T> Set { get; }

		public Func<T> Default { get; }

		public ConfigBinding(Func<T> get, Action<T> set, Func<T> getDefault)
		{
			Get = get;
			Set = set;
			Default = getDefault;
		}
	}
	internal static class ConfigBinding
	{
		public static ConfigBinding<T> Of<T>(ConfigEntry<T> entry)
		{
			ConfigEntry<T> entry2 = entry;
			return new ConfigBinding<T>(() => entry2.Value, delegate(T v)
			{
				entry2.Value = v;
			}, () => (T)((ConfigEntryBase)entry2).DefaultValue);
		}
	}
	internal static class SettingsPanelRows
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static OnValidateInput <>9__15_0;

			internal char <AddFloatRow>b__15_0(string _, int _, char c)
			{
				if ("0123456789.-".IndexOf(c) < 0)
				{
					return '\0';
				}
				return c;
			}

			internal string <.cctor>b__19_0(ILabels t)
			{
				return t.ThemeValheim;
			}

			internal string <.cctor>b__19_1(ILabels t)
			{
				return t.ThemeDark;
			}

			internal string <.cctor>b__19_2(ILabels t)
			{
				return t.ThemeMinimal;
			}

			internal string <.cctor>b__19_3(ILabels t)
			{
				return t.ThemeHighContrast;
			}
		}

		private static readonly (ThemePresets.Theme Theme, Func<ILabels, string> Label)[] ThemeButtons = new(ThemePresets.Theme, Func<ILabels, string>)[4]
		{
			(ThemePresets.Valheim, (ILabels t) => t.ThemeValheim),
			(ThemePresets.Dark, (ILabels t) => t.ThemeDark),
			(ThemePresets.Minimal, (ILabels t) => t.ThemeMinimal),
			(ThemePresets.HighContrast, (ILabels t) => t.ThemeHighContrast)
		};

		private static Log.Scoped Logger { get; } = Log.For("SettingsPanelRows");


		internal static void Populate(Transform content, Font font, List<Action> resets, List<Action> refreshes, Transform skillsFrame, ILabels labels)
		{
			RowContext ctx = new RowContext
			{
				Content = content,
				Font = font,
				Resets = resets,
				Refreshes = refreshes,
				SkillsFrame = skillsFrame,
				Labels = labels
			};
			AddThemePresetsRow(ctx);
			PopulateGeneral(ctx);
			PopulateSkillsPanel(ctx);
			PopulateHudPosition(ctx);
			PopulateHudSize(ctx);
			PopulateHudColors(ctx);
			PopulateToast(ctx);
		}

		private static void PopulateGeneral(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionGeneral);
			AddToggleRow(ctx, ctx.Labels.DebugMode, ConfigBinding.Of<bool>(Config.DebugMode));
			AddToggleRow(ctx, ctx.Labels.HudWidgetsVisible, ConfigBinding.Of<bool>(Config.HudWidgetsVisible));
		}

		private static void PopulateSkillsPanel(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionSkillsPanel);
			AddColorRow(ctx, ctx.Labels.StarFavorite, ConfigBinding.Of<Color>(Config.FavoriteStarColor));
			AddColorRow(ctx, ctx.Labels.StarUnfavorite, ConfigBinding.Of<Color>(Config.UnfavoriteStarColor));
		}

		private static void PopulateHudPosition(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionHudPosition);
			AddFloatRow(ctx, ctx.Labels.PositionX, ConfigBinding.Of<float>(Config.HudPositionX));
			AddFloatRow(ctx, ctx.Labels.PositionY, ConfigBinding.Of<float>(Config.HudPositionY));
			AddSliderFloatRow(ctx, ctx.Labels.HudScale, ConfigBinding.Of<float>(Config.HudScale), 50f, 150f, 0);
		}

		private static void PopulateHudSize(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionHudSize);
			AddSliderFloatRow(ctx, ctx.Labels.Width, ConfigBinding.Of<float>(Config.WidgetWidth), 30f, 200f, 1);
			AddSliderFloatRow(ctx, ctx.Labels.Height, ConfigBinding.Of<float>(Config.WidgetHeight), 30f, 200f, 1);
			AddSliderFloatRow(ctx, ctx.Labels.IconSize, ConfigBinding.Of<float>(Config.WidgetIconSize), 10f, 100f, 1);
			AddSliderIntRow(ctx, ctx.Labels.FontLevel, ConfigBinding.Of<int>(Config.WidgetFontSizeLevel), 6, 30);
			AddSliderIntRow(ctx, ctx.Labels.FontProgress, ConfigBinding.Of<int>(Config.WidgetFontSizeProgress), 6, 24);
			AddSliderFloatRow(ctx, ctx.Labels.WidgetSpacing, ConfigBinding.Of<float>(Config.WidgetSpacing), 0f, 30f, 1);
			AddSliderFloatRow(ctx, ctx.Labels.BorderThickness, ConfigBinding.Of<float>(Config.WidgetBorderSize), 0f, 10f, 1);
			AddSliderIntRow(ctx, ctx.Labels.CornerRadius, ConfigBinding.Of<int>(Config.WidgetCornerRadius), 0, 20);
			AddSliderFloatRow(ctx, ctx.Labels.LevelUpDuration, ConfigBinding.Of<float>(Config.WidgetLevelUpDuration), 0f, 5f, 2);
			AddToggleRow(ctx, ctx.Labels.ProgressBarVisible, ConfigBinding.Of<bool>(Config.WidgetProgressBarVisible));
			AddSliderFloatRow(ctx, ctx.Labels.ProgressBarHeight, ConfigBinding.Of<float>(Config.WidgetProgressBarHeight), 0f, 12f, 1);
		}

		private static void PopulateHudColors(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionHudColors);
			AddColorRow(ctx, ctx.Labels.ColorBorder, ConfigBinding.Of<Color>(Config.WidgetBorderColor));
			AddColorRow(ctx, ctx.Labels.ColorBackground, ConfigBinding.Of<Color>(Config.WidgetBgColor));
			AddColorRow(ctx, ctx.Labels.ColorLevelText, ConfigBinding.Of<Color>(Config.WidgetLevelColor));
			AddColorRow(ctx, ctx.Labels.ColorProgressText, ConfigBinding.Of<Color>(Config.WidgetProgressColor));
			AddColorRow(ctx, ctx.Labels.ColorMaxText, ConfigBinding.Of<Color>(Config.WidgetProgressMaxColor));
			AddColorRow(ctx, ctx.Labels.ColorLevelUpFlash, ConfigBinding.Of<Color>(Config.WidgetLevelUpColor));
			AddColorRow(ctx, ctx.Labels.ColorProgressBarBg, ConfigBinding.Of<Color>(Config.WidgetProgressBarBgColor));
		}

		private static void PopulateToast(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionToast);
			AddToggleRow(ctx, ctx.Labels.ToastEnabled, ConfigBinding.Of<bool>(Config.ToastEnabled));
			AddSliderFloatRow(ctx, ctx.Labels.ToastPositionTop, ConfigBinding.Of<float>(Config.ToastPositionTopPercent), 0f, 50f, 0);
			AddSliderFloatRow(ctx, ctx.Labels.ToastDuration, ConfigBinding.Of<float>(Config.ToastDuration), 1f, 10f, 1);
			AddSliderIntRow(ctx, ctx.Labels.ToastFontSize, ConfigBinding.Of<int>(Config.ToastFontSize), 14, 50);
			AddColorRow(ctx, ctx.Labels.ToastColor, ConfigBinding.Of<Color>(Config.ToastColor));
		}

		private static void Section(RowContext ctx, string label)
		{
			SettingsPanelLayout.AddSection(ctx.Content, ctx.Font, label);
		}

		private static void AddThemePresetsRow(RowContext ctx)
		{
			Section(ctx, ctx.Labels.SectionThemes);
			GameObject val = SettingsPanelWidgets.MakeRow(ctx.Content, "Themes");
			(ThemePresets.Theme, Func<ILabels, string>)[] themeButtons = ThemeButtons;
			for (int i = 0; i < themeButtons.Length; i++)
			{
				var (theme, func) = themeButtons[i];
				AddThemeButton(ctx, val.transform, func(ctx.Labels), theme);
			}
		}

		private static void AddThemeButton(RowContext ctx, Transform parent, string label, ThemePresets.Theme theme)
		{
			//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_0082: 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_00b0: 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_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			ThemePresets.Theme theme2 = theme;
			RowContext ctx2 = ctx;
			GameObject val = new GameObject("Theme_" + theme2.Key, new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.flexibleWidth = 1f;
			component.preferredWidth = 90f;
			component.minWidth = 60f;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = SettingsPanelWidgets.InputBgColor;
			SettingsPanelWidgets.ApplyRoundedSprite(component2);
			SettingsPanelWidgets.AddChildText(val.transform, ctx2.Font, label, 12, (FontStyle)1);
			Button component3 = val.GetComponent<Button>();
			((Selectable)component3).targetGraphic = (Graphic)(object)component2;
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				ThemePresets.Apply(theme2);
				Plugin.SaveConfig();
				foreach (Action refresh in ctx2.Refreshes)
				{
					refresh();
				}
				Logger.Debug("Applied theme '" + theme2.Key + "'.");
			});
		}

		private static void AddToggleRow(RowContext ctx, string label, ConfigBinding<bool> binding)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00dc: 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_0169: Expected O, but got Unknown
			ConfigBinding<bool> binding2 = binding;
			string label2 = label;
			GameObject val = SettingsPanelWidgets.MakeRow(ctx.Content, label2);
			SettingsPanelWidgets.MakeLabel(val.transform, ctx.Font, label2);
			GameObject val2 = new GameObject("Toggle", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button),
				typeof(LayoutElement)
			});
			val2.transform.SetParent(val.transform, false);
			LayoutElement component = val2.GetComponent<LayoutElement>();
			float preferredWidth = (component.minWidth = 68f);
			component.preferredWidth = preferredWidth;
			Image img = val2.GetComponent<Image>();
			((Graphic)img).color = SettingsPanelWidgets.ToggleColor(binding2.Get());
			SettingsPanelWidgets.ApplyRoundedSprite(img);
			ILabels labels = ctx.Labels;
			Text labelText = SettingsPanelWidgets.AddChildText(val2.transform, ctx.Font, binding2.Get() ? labels.ToggleOn : labels.ToggleOff, 12, (FontStyle)1);
			Button component2 = val2.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)img;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				bool flag2 = !binding2.Get();
				binding2.Set(flag2);
				Plugin.SaveConfig();
				((Graphic)img).color = SettingsPanelWidgets.ToggleColor(flag2);
				labelText.text = (flag2 ? labels.ToggleOn : labels.ToggleOff);
				Logger.Debug($"Toggle '{label2}' → {flag2}");
			});
			ctx.Refreshes.Add(Refresh);
			SettingsPanelWidgets.MakeResetButton(val.transform, Reset, ctx.SkillsFrame);
			ctx.Resets.Add(Reset);
			void Refresh()
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				bool flag = binding2.Get();
				((Graphic)img).color = SettingsPanelWidgets.ToggleColor(flag);
				labelText.text = (flag ? labels.ToggleOn : labels.ToggleOff);
			}
			void Reset()
			{
				binding2.Set(binding2.Default());
				Plugin.SaveConfig();
				Refresh();
			}
		}

		private static void AddFloatRow(RowContext ctx, string label, ConfigBinding<float> binding)
		{
			//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_009d: Expected O, but got Unknown
			ConfigBinding<float> binding2 = binding;
			GameObject obj = SettingsPanelWidgets.MakeRow(ctx.Content, label);
			SettingsPanelWidgets.MakeLabel(obj.transform, ctx.Font, label);
			GameObject val = SettingsPanelWidgets.MakeInputField(obj.transform, ctx.Font, binding2.Get().ToString("0.##"), "0.0");
			InputField input = val.GetComponent<InputField>();
			input.characterLimit = 10;
			InputField obj2 = input;
			object obj3 = <>c.<>9__15_0;
			if (obj3 == null)
			{
				OnValidateInput val2 = (string _, int _, char c) => ("0123456789.-".IndexOf(c) >= 0) ? c : '\0';
				<>c.<>9__15_0 = val2;
				obj3 = (object)val2;
			}
			obj2.onValidateInput = (OnValidateInput)obj3;
			SettingsPanelWidgets.ApplyRoundedSprite(((Component)input).GetComponent<Image>());
			((UnityEvent<string>)(object)input.onValueChanged).AddListener((UnityAction<string>)delegate(string raw)
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				if (float.TryParse(raw, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2))
				{
					((Graphic)input.textComponent).color = Color.white;
					binding2.Set(result2);
					Plugin.SaveConfig();
				}
				else
				{
					((Graphic)input.textComponent).color = SettingsPanelWidgets.ErrorColor;
				}
			});
			((UnityEvent<string>)(object)input.onEndEdit).AddListener((UnityAction<string>)delegate(string raw)
			{
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				if (!float.TryParse(raw, NumberStyles.Float, CultureInfo.InvariantCulture, out var _))
				{
					input.text = binding2.Get().ToString("0.##");
					((Graphic)input.textComponent).color = Color.white;
				}
			});
			ctx.Refreshes.Add(Refresh);
			SettingsPanelWidgets.MakeResetButton(obj.transform, Reset, ctx.SkillsFrame);
			ctx.Resets.Add(Reset);
			void Refresh()
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				input.text = binding2.Get().ToString("0.##");
				((Graphic)input.textComponent).color = Color.white;
			}
			void Reset()
			{
				binding2.Set(binding2.Default());
				Plugin.SaveConfig();
				Refresh();
			}
		}

		private static void AddSliderFloatRow(RowContext ctx, string label, ConfigBinding<float> binding, float min, float max, int decimals)
		{
			ConfigBinding<float> binding2 = binding;
			string fmt = "F" + decimals;
			GameObject obj = SettingsPanelWidgets.MakeRow(ctx.Content, label);
			SettingsPanelWidgets.MakeLabel(obj.transform, ctx.Font, label);
			var (slider, valueText) = SettingsPanelWidgets.MakeSlider(obj.transform, ctx.Font, min, max, binding2.Get(), fmt);
			((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate(float raw)
			{
				float obj2 = (float)Math.Round(raw, decimals);
				valueText.text = obj2.ToString(fmt);
				binding2.Set(obj2);
				Plugin.SaveConfig();
			});
			ctx.Refreshes.Add(Refresh);
			SettingsPanelWidgets.MakeResetButton(obj.transform, Reset, ctx.SkillsFrame);
			ctx.Resets.Add(Reset);
			void Refresh()
			{
				float num = binding2.Get();
				slider.SetValueWithoutNotify(Mathf.Clamp(num, min, max));
				valueText.text = num.ToString(fmt);
			}
			void Reset()
			{
				binding2.Set(binding2.Default());
				Plugin.SaveConfig();
				Refresh();
			}
		}

		private static void AddSliderIntRow(RowContext ctx, string label, ConfigBinding<int> binding, int min, int max)
		{
			ConfigBinding<int> binding2 = binding;
			GameObject obj = SettingsPanelWidgets.MakeRow(ctx.Content, label);
			SettingsPanelWidgets.MakeLabel(obj.transform, ctx.Font, label);
			var (slider, valueText) = SettingsPanelWidgets.MakeSlider(obj.transform, ctx.Font, min, max, binding2.Get(), "F0");
			slider.wholeNumbers = true;
			((UnityEvent<float>)(object)slider.onValueChanged).AddListener((UnityAction<float>)delegate(float raw)
			{
				int obj2 = Mathf.RoundToInt(raw);
				valueText.text = obj2.ToString();
				binding2.Set(obj2);
				Plugin.SaveConfig();
			});
			ctx.Refreshes.Add(Refresh);
			SettingsPanelWidgets.MakeResetButton(obj.transform, Reset, ctx.SkillsFrame);
			ctx.Resets.Add(Reset);
			void Refresh()
			{
				int num = binding2.Get();
				slider.SetValueWithoutNotify((float)Mathf.Clamp(num, min, max));
				valueText.text = num.ToString();
			}
			void Reset()
			{
				binding2.Set(binding2.Default());
				Plugin.SaveConfig();
				Refresh();
			}
		}

		private static void AddColorRow(RowContext ctx, string label, ConfigBinding<Color> binding)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			ConfigBinding<Color> binding2 = binding;
			GameObject val = SettingsPanelWidgets.MakeRow(ctx.Content, label);
			SettingsPanelWidgets.MakeLabel(val.transform, ctx.Font, label);
			GameObject val2 = new GameObject("Preview", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(LayoutElement),
				typeof(Button)
			});
			val2.transform.SetParent(val.transform, false);
			LayoutElement component = val2.GetComponent<LayoutElement>();
			float preferredWidth = (component.minWidth = 22f);
			component.preferredWidth = preferredWidth;
			Image previewImg = val2.GetComponent<Image>();
			((Graphic)previewImg).color = binding2.Get();
			SettingsPanelWidgets.ApplyRoundedSprite(previewImg);
			GameObject val3 = SettingsPanelWidgets.MakeInputField(val.transform, ctx.Font, ColorUtility.ToHtmlStringRGBA(binding2.Get()));
			val3.transform.SetSiblingIndex(1);
			InputField input = val3.GetComponent<InputField>();
			Text inputText = input.textComponent;
			SettingsPanelWidgets.ApplyRoundedSprite(((Component)input).GetComponent<Image>());
			(GameObject, Action<Color>) tuple = ColorPickerPopup.Build(ctx.SkillsFrame, binding2.Get, delegate(Color chosen)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				binding2.Set(chosen);
				Plugin.SaveConfig();
				((Graphic)previewImg).color = chosen;
				input.text = ColorUtility.ToHtmlStringRGBA(chosen);
				((Graphic)inputText).color = Color.white;
			});
			GameObject pickerOverlay = tuple.Item1;
			Action<Color> syncAlpha = tuple.Item2;
			Button component2 = val2.GetComponent<Button>();
			((Selectable)component2).targetGraphic = (Graphic)(object)previewImg;
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				ColorPickerPopup.OpenOverlay(pickerOverlay, binding2.Get(), syncAlpha);
			});
			((UnityEvent<string>)(object)input.onValueChanged).AddListener((UnityAction<string>)delegate(string hex)
			{
				//IL_004f: 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_0010: 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_0031: 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)
				if (SettingsPanelWidgets.TryParseColor(hex, out var color2))
				{
					((Graphic)previewImg).color = color2;
					((Graphic)inputText).color = Color.white;
					binding2.Set(color2);
					Plugin.SaveConfig();
					syncAlpha(color2);
				}
				else
				{
					((Graphic)previewImg).color = SettingsPanelWidgets.ErrorPreviewColor;
					((Graphic)inputText).color = SettingsPanelWidgets.ErrorColor;
				}
			});
			((UnityEvent<string>)(object)input.onEndEdit).AddListener((UnityAction<string>)delegate(string hex)
			{
				//IL_001b: 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_004b: Unknown result type (might be due to invalid IL or missing references)
				if (!SettingsPanelWidgets.TryParseColor(hex, out var _))
				{
					input.text = ColorUtility.ToHtmlStringRGBA(binding2.Get());
					((Graphic)previewImg).color = binding2.Get();
					((Graphic)inputText).color = Color.white;
				}
			});
			ctx.Refreshes.Add(Refresh);
			SettingsPanelWidgets.MakeResetButton(val.transform, Reset, ctx.SkillsFrame);
			ctx.Resets.Add(Reset);
			void Refresh()
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				Color val4 = binding2.Get();
				input.text = ColorUtility.ToHtmlStringRGBA(val4);
				((Graphic)previewImg).color = val4;
				((Graphic)inputText).color = Color.white;
				syncAlpha(val4);
			}
			void Reset()
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				binding2.Set(binding2.Default());
				Plugin.SaveConfig();
				Refresh();
			}
		}
	}
	internal static class SettingsPanelWidgets
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static OnValidateInput <>9__18_0;

			internal char <MakeInputField>b__18_0(string _, int _, char c)
			{
				if ("0123456789ABCDEFabcdef".IndexOf(c) < 0)
				{
					return '\0';
				}
				return char.ToUpper(c);
			}
		}

		internal static readonly Color ErrorColor = new Color(1f, 0.4f, 0.4f);

		internal static readonly Color ErrorPreviewColor = new Color(0.4f, 0f, 0f);

		private static readonly Color ToggleOnColor = new Color(0.18f, 0.58f, 0.18f);

		private static readonly Color ToggleOffColor = new Color(0.48f, 0.14f, 0.14f);

		private static readonly Color LabelColor = new Color(0.9f, 0.88f, 0.82f);

		internal static readonly Color InputBgColor = new Color(0.1f, 0.08f, 0.06f);

		private static readonly Color SliderTrackColor = new Color(0.1f, 0.08f, 0.06f);

		private static readonly Color SliderFillColor = new Color(0.58f, 0.44f, 0.18f);

		private static readonly Color SliderHandleColor = new Color(0.76f, 0.6f, 0.3f);

		private static readonly Color SliderHandleHighlight = new Color(0.92f, 0.76f, 0.44f);

		private static readonly Color SliderHandlePressed = new Color(0.46f, 0.34f, 0.12f);

		private const int LabelFontSize = 14;

		private const int InputFontSize = 11;

		private const int PlaceholderFontSize = 10;

		internal static Color ToggleColor(bool on)
		{
			//IL_0009: 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)
			if (!on)
			{
				return ToggleOffColor;
			}
			return ToggleOnColor;
		}

		internal static void MakeResetButton(Transform parent, Action onClick, Transform skillsFrame)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_0107: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			Action onClick2 = onClick;
			Transform obj = skillsFrame.Find("Closebutton");
			if ((Object)(object)obj == (Object)null)
			{
				throw new InvalidOperationException("Closebutton not found in SkillsFrame");
			}
			GameObject val = Object.Instantiate<GameObject>(((Component)obj).gameObject, parent);
			((Object)val).name = "ResetBtn";
			LayoutElement obj2 = val.GetComponent<LayoutElement>() ?? val.AddComponent<LayoutElement>();
			float num2 = (obj2.minWidth = 28f);
			float num4 = (obj2.preferredWidth = num2);
			float preferredHeight = (obj2.minHeight = num4);
			obj2.preferredHeight = preferredHeight;
			TMP_Text componentInChildren = val.GetComponentInChildren<TMP_Text>();
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Component)componentInChildren).gameObject.SetActive(false);
			}
			GameObject val2 = new GameObject("Icon", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.2f, 0.2f);
			component.anchorMax = new Vector2(0.8f, 0.8f);
			Vector2 offsetMin = (component.offsetMax = Vector2.zero);
			component.offsetMin = offsetMin;
			val2.GetComponent<Image>().sprite = SpriteUtils.ResetIcon(10);
			Button component2 = val.GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				onClick2();
			});
		}

		internal static GameObject MakeRow(Transform parent, string name)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_0098: Expected O, but got Unknown
			GameObject val = new GameObject("Row_" + name, new Type[3]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			float preferredHeight = (component.minHeight = 28f);
			component.preferredHeight = preferredHeight;
			HorizontalLayoutGroup component2 = val.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = true;
			((LayoutGroup)component2).childAlignment = (TextAnchor)3;
			((LayoutGroup)component2).padding = new RectOffset(0, 0, 1, 1);
			return val;
		}

		internal static void MakeLabel(Transform parent, Font font, string text)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Label", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			val.GetComponent<LayoutElement>().flexibleWidth = 1f;
			Text component = val.GetComponent<Text>();
			component.font = font;
			component.fontSize = 14;
			component.alignment = (TextAnchor)3;
			((Graphic)component).color = LabelColor;
			component.text = text;
			((Graphic)component).raycastTarget = false;
		}

		internal static GameObject MakeInputField(Transform parent, Font font, string initialValue, string placeholder = "RRGGBBAA")
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007e: 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_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			GameObject val = new GameObject("Input", new Type[5]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(InputField),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			float preferredWidth = (component.minWidth = 86f);
			component.preferredWidth = preferredWidth;
			((Graphic)val.GetComponent<Image>()).color = InputBgColor;
			GameObject val2 = new GameObject("Placeholder", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val2.transform.SetParent(val.transform, false);
			StretchInset(val2.GetComponent<RectTransform>(), 3f);
			Text component2 = val2.GetComponent<Text>();
			component2.font = font;
			component2.fontSize = 10;
			((Graphic)component2).color = new Color(0.35f, 0.35f, 0.35f);
			component2.text = placeholder;
			component2.alignment = (TextAnchor)4;
			((Graphic)component2).raycastTarget = false;
			GameObject val3 = new GameObject("Text", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val3.transform.SetParent(val.transform, false);
			StretchInset(val3.GetComponent<RectTransform>(), 3f);
			Text component3 = val3.GetComponent<Text>();
			component3.font = font;
			component3.fontSize = 11;
			((Graphic)component3).color = Color.white;
			component3.alignment = (TextAnchor)4;
			component3.supportRichText = false;
			((Graphic)component3).raycastTarget = false;
			InputField component4 = val.GetComponent<InputField>();
			component4.textComponent = component3;
			component4.placeholder = (Graphic)(object)component2;
			component4.characterLimit = 8;
			component4.lineType = (LineType)0;
			component4.text = initialValue;
			ApplyRoundedSprite(((Component)component4).GetComponent<Image>());
			object obj = <>c.<>9__18_0;
			if (obj == null)
			{
				OnValidateInput val4 = (string _, int _, char c) => ("0123456789ABCDEFabcdef".IndexOf(c) >= 0) ? char.ToUpper(c) : '\0';
				<>c.<>9__18_0 = val4;
				obj = (object)val4;
			}
			component4.onValidateInput = (OnValidateInput)obj;
			return val;
		}

		internal static Text AddChildText(Transform parent, Font font, string text, int fontSize, FontStyle style)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Text", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			Stretch(val.GetComponent<RectTransform>());
			Text component = val.GetComponent<Text>();
			component.font = font;
			component.fontSize = fontSize;
			component.fontStyle = style;
			component.alignment = (TextAnchor)4;
			((Graphic)component).color = Color.white;
			component.text = text;
			((Graphic)component).raycastTarget = false;
			return component;
		}

		internal static void ApplyRoundedSprite(Image img)
		{
			Sprite val = SpriteUtils.RoundedRect(6);
			if (!((Object)(object)val == (Object)null))
			{
				img.sprite = val;
				img.type = (Type)1;
			}
		}

		internal static bool TryParseColor(string hex, out Color color)
		{
			//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)
			color = Color.white;
			if (hex.Length != 8)
			{
				return false;
			}
			return ColorUtility.TryParseHtmlString("#" + hex, ref color);
		}

		internal static void Stretch(RectTransform rt)
		{
			//IL_0001: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			Vector2 offsetMin = (rt.offsetMax = Vector2.zero);
			rt.offsetMin = offsetMin;
		}

		internal static void StretchInset(RectTransform rt, float inset)
		{
			//IL_0001: 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_001d: 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)
			rt.anchorMin = Vector2.zero;
			rt.anchorMax = Vector2.one;
			rt.offsetMin = new Vector2(inset, 0f);
			rt.offsetMax = new Vector2(0f - inset, 0f);
		}

		internal static (Slider slider, Text valueText) MakeSlider(Transform parent, Font font, float min, float max, float initialValue, string valueFormat)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: 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_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Expected O, but got Unknown
			//IL_01e1: 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_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: 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_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: 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_02e3: Expected O, but got Unknown
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: 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_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fd: 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_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_054c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SliderWrap", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredWidth = 160f;
			component.minWidth = 80f;
			GameObject val2 = new GameObject("Slider", new Type[2]
			{
				typeof(RectTransform),
				typeof(Slider)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.5f);
			component2.anchorMax = new Vector2(1f, 0.5f);
			component2.offsetMin = new Vector2(0f, -7f);
			component2.offsetMax = new Vector2(0f, 7f);
			GameObject val3 = new GameObject("Background", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0.5f);
			component3.anchorMax = new Vector2(1f, 0.5f);
			component3.offsetMin = new Vector2(0f, -1.5f);
			component3.offsetMax = new Vector2(0f, 1.5f);
			Image component4 = val3.GetComponent<Image>();
			((Graphic)component4).color = SliderTrackColor;
			ApplyRoundedSprite(component4);
			GameObject val4 = new GameObject("Fill Area", new Type[1] { typeof(RectTransform) });
			val4.transform.SetParent(val2.transform, false);
			RectTransform component5 = val4.GetComponent<RectTransform>();
			component5.anchorMin = new Vector2(0f, 0.5f);
			component5.anchorMax = new Vector2(1f, 0.5f);
			component5.offsetMin = new Vector2(0f, -1.5f);
			component5.offsetMax = new Vector2(-7f, 1.5f);
			GameObject val5 = new GameObject("Fill", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val5.transform.SetParent(val4.transform, false);
			RectTransform component6 = val5.GetComponent<RectTransform>();
			component6.anchorMin = Vector2.zero;
			component6.anchorMax = new Vector2(0f, 1f);
			Vector2 offsetMin = (component6.offsetMax = Vector2.zero);
			component6.offsetMin = offsetMin;
			Image component7 = val5.GetComponent<Image>();
			((Graphic)component7).color = SliderFillColor;
			ApplyRoundedSprite(component7);
			GameObject val6 = new GameObject("Handle Slide Area", new Type[1] { typeof(RectTransform) });
			val6.transform.SetParent(val2.transform, false);
			RectTransform component8 = val6.GetComponent<RectTransform>();
			component8.anchorMin = Vector2.zero;
			component8.anchorMax = Vector2.one;
			component8.offsetMin = new Vector2(7f, 0f);
			component8.offsetMax = new Vector2(-7f, 0f);
			GameObject val7 = new GameObject("Handle", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val7.transform.SetParent(val6.transform, false);
			RectTransform component9 = val7.GetComponent<RectTransform>();
			component9.anchorMin = new Vector2(0f, 0.5f);
			component9.anchorMax = new Vector2(0f, 0.5f);
			component9.pivot = new Vector2(0.5f, 0.5f);
			component9.sizeDelta = new Vector2(14f, 14f);
			Image component10 = val7.GetComponent<Image>();
			((Graphic)component10).color = SliderHandleColor;
			ApplyRoundedSprite(component10);
			Slider component11 = val2.GetComponent<Slider>();
			component11.fillRect = component6;
			component11.handleRect = component9;
			((Selectable)component11).targetGraphic = (Graphic)(object)component10;
			component11.direction = (Direction)0;
			component11.minValue = min;
			component11.maxValue = max;
			component11.value = Mathf.Clamp(initialValue, min, max);
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = SliderHandleColor;
			((ColorBlock)(ref colors)).highlightedColor = SliderHandleHighlight;
			((ColorBlock)(ref colors)).pressedColor = SliderHandlePressed;
			((ColorBlock)(ref colors)).selectedColor = SliderHandleColor;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.4f, 0.4f, 0.4f);
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.1f;
			((Selectable)component11).colors = colors;
			GameObject val8 = new GameObject("SliderValue", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text),
				typeof(LayoutElement)
			});
			val8.transform.SetParent(parent, false);
			LayoutElement component12 = val8.GetComponent<LayoutElement>();
			float preferredWidth = (component12.minWidth = 44f);
			component12.preferredWidth = preferredWidth;
			Text component13 = val8.GetComponent<Text>();
			component13.font = font;
			component13.fontSize = 11;
			component13.alignment = (TextAnchor)5;
			((Graphic)component13).color = LabelColor;
			component13.text = initialValue.ToString(valueFormat);
			((Graphic)component13).raycastTarget = false;
			return (component11, component13);
		}
	}
}
namespace SkillsPreview.App.UI.CharacterStatsPanel
{
	internal class CharacterStatsPanel
	{
		private static readonly Log.Scoped _log = Log.For("CharacterStatsPanel");

		private static readonly Color SkillNameColor = new Color(0.85f, 0.78f, 0.62f, 1f);

		private static readonly Color SkillLevelColor = new Color(1f, 1f, 1f, 1f);

		private static readonly Color ZeroLevelColor = new Color(0.4f, 0.4f, 0.4f, 1f);

		private static readonly Color HintColor = new Color(0.55f, 0.5f, 0.4f, 1f);

		private const int FontSizeName = 14;

		private const int FontSizeLevel = 14;

		private const int RowHeight = 21;

		private readonly Font _font;

		private readonly Transform _content;

		private readonly List<(Text nameText, Text levelText)> _rows = new List<(Text, Text)>();

		private const string HintObjectName = "godzki_StatsHint";

		internal GameObject Root { get; }

		internal bool IsAlive => (Object)(object)Root != (Object)null;

		private CharacterStatsPanel(GameObject root, Transform content, Font font)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			Root = root;
			_content = content;
			_font = font;
			foreach (SkillType allSkillType in SkillProfileReader.AllSkillTypes)
			{
				SkillType current = allSkillType;
				string text = "$skill_" + ((object)(SkillType)(ref current)).ToString().ToLower();
				string skillName = ((Localization.instance != null) ? Localization.instance.Localize(text) : ((object)(SkillType)(ref current)).ToString());
				var (item, item2) = AddSkillRow(skillName);
				_rows.Add((item, item2));
			}
		}

		internal static CharacterStatsPanel Create(Transform parent)
		{
			Font builtinResource = Resources.GetBuiltinResource<Font>("Arial.ttf");
			GameObject root = CharacterStatsPanelLayout.BuildRoot(parent);
			CharacterStatsPanelLayout.BuildBackground(root);
			CharacterStatsPanelLayout.AddTitle(root, L.Current.StatsTitle);
			Transform content = CharacterStatsPanelLayout.AddScrollView(root);
			CharacterStatsPanel result = new CharacterStatsPanel(root, content, builtinResource);
			_log.Debug("CharacterStatsPanel created.");
			return result;
		}

		internal void Refresh(PlayerProfile? profile)
		{
			//IL_003d: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			if (profile == null)
			{
				ShowHint(L.Current.StatsNoCharacter);
				_log.Debug("Refresh — no profile.");
				return;
			}
			HideHint();
			Dictionary<SkillType, float> dictionary = SkillProfileReader.ReadSkills(profile);
			IReadOnlyList<SkillType> allSkillTypes = SkillProfileReader.AllSkillTypes;
			for (int i = 0; i < _rows.Count && i < allSkillTypes.Count; i++)
			{
				dictionary.TryGetValue(allSkillTypes[i], out var value);
				bool flag = value < 0.5f;
				_rows[i].levelText.text = (flag ? "0" : Mathf.FloorToInt(value).ToString());
				((Graphic)_rows[i].levelText).color = (flag ? ZeroLevelColor : SkillLevelColor);
			}
			_log.Debug("Refreshed for '" + profile.GetFilename() + "'.");
		}

		private (Text nameText, Text levelText) AddSkillRow(string skillName)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00b1: 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)
			GameObject val = new GameObject("Row", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			});
			val.transform.SetParent(_content, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			float preferredHeight = (component.minHeight = 21f);
			component.preferredHeight = preferredHeight;
			Text item = MakeLabel(val.transform, "Name", new Vector2(0f, 0f), new Vector2(0.75f, 1f), skillName, (TextAnchor)3, SkillNameColor);
			Text item2 = MakeLabel(val.transform, "Level", new Vector2(0.75f, 0f), new Vector2(1f, 1f), "0", (TextAnchor)5, ZeroLevelColor);
			return (item, item2);
		}

		private Text MakeLabel(Transform parent, string goName, Vector2 anchorMin, Vector2 anchorMax, string text, TextAnchor alignment, Color color)
		{
			//IL_002e: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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)
			GameObject val = new GameObject(goName, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = anchorMin;
			component.anchorMax = anchorMax;
			Vector2 offsetMin = (component.offsetMax = Vector2.zero);
			component.offsetMin = offsetMin;
			Text component2 = val.GetComponent<Text>();
			component2.font = _font;
			component2.fontSize = ((goName == "Name") ? 14 : 14);
			component2.alignment = alignment;
			((Graphic)component2).color = color;
			component2.text = text;
			((Graphic)component2).raycastTarget = false;
			return component2;
		}

		private void ShowHint(string message)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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)
			Transform val = Root.transform.Find("godzki_StatsHint");
			if ((Object)(object)val == (Object)null)
			{
				GameObject val2 = new GameObject("godzki_StatsHint", new Type[3]
				{
					typeof(RectTransform),
					typeof(CanvasRenderer),
					typeof(Text)
				});
				val2.transform.SetParent(Root.transform, false);
				RectTransform component = val2.GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 0.5f);
				component.anchorMax = new Vector2(1f, 0.5f);
				component.pivot = new Vector2(0.5f, 0.5f);
				component.sizeDelta = new Vector2(0f, 30f);
				component.anchoredPosition = Vector2.zero;
				Text component2 = val2.GetComponent<Text>();
				component2.font = _font;
				component2.fontSize = 12;
				component2.alignment = (TextAnchor)4;
				component2.fontStyle = (FontStyle)2;
				((Graphic)component2).color = HintColor;
				component2.text = message;
				((Graphic)component2).raycastTarget = false;
				val = val2.transform;
			}
			((Component)val).gameObject.SetActive(true);
			((Component)_content).gameObject.SetActive(false);
		}

		private void HideHint()
		{
			Transform obj = Root.transform.Find("godzki_StatsHint");
			if (obj != null)
			{
				((Component)obj).gameObject.SetActive(false);
			}
			((Component)_content).gameObject.SetActive(true);
		}
	}
	internal static class CharacterStatsPanelLayout
	{
		private const float PanelWidth = 260f;

		private const float PanelHeight = 560f;

		private static readonly Vector2 PanelAnchor = new Vector2(1f, 0.5f);

		private static readonly Vector2 PanelPivot = new Vector2(1f, 0.5f);

		private static readonly Vector2 PanelAnchoredPos = new Vector2(-10f, 30f);

		private static readonly Color BgColor = new Color(0.05f, 0.04f, 0.03f, 0.9f);

		private static readonly Color TitleColor = new Color(0.75f, 0.62f, 0.35f, 1f);

		internal static GameObject BuildRoot(Transform parent)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_003c: 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_0052: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			GameObject val = new GameObject("godzki_CharacterStatsPanel", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(parent, false);
			val.transform.SetAsLastSibling();
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = PanelAnchor;
			component.anchorMax = PanelAnchor;
			component.pivot = PanelPivot;
			component.sizeDelta = new Vector2(260f, 560f);
			component.anchoredPosition = PanelAnchoredPos;
			return val;
		}

		internal static void BuildBackground(GameObject root)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("bkg", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val.transform.SetParent(root.transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			Vector2 offsetMin = (component.offsetMax = Vector2.zero);
			component.offsetMin = offsetMin;
			((Graphic)val.GetComponent<Image>()).color = BgColor;
		}

		internal static void AddTitle(GameObject root, string text)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Title", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val.transform.SetParent(root.transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.sizeDelta = new Vector2(0f, 38f);
			component.anchoredPosition = Vector2.zero;
			Text component2 = val.GetComponent<Text>();
			component2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			component2.fontSize = 15;
			component2.fontStyle = (FontStyle)1;
			component2.alignment = (TextAnchor)4;
			((Graphic)component2).color = TitleColor;
			component2.text = text;
			((Graphic)component2).raycastTarget = false;
		}

		internal static Transform AddScrollView(GameObject root)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0044: 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_0064: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00e1: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ScrollView", new Type[2]
			{
				typeof(RectTransform),
				typeof(ScrollRect)
			});
			val.transform.SetParent(root.transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(6f, 6f);
			component.offsetMax = new Vector2(-6f, -44f);
			GameObject val2 = new GameObject("Viewport", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Mask)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component2 = val2.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			Vector2 offsetMin = (component2.offsetMax = Vector2.zero);
			component2.offsetMin = offsetMin;
			((Graphic)val2.GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.01f);
			val2.GetComponent<Mask>().showMaskGraphic = false;
			GameObject val3 = new GameObject("Content", new Type[3]
			{
				typeof(RectTransform),
				typeof(VerticalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform component3 = val3.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = Vector2.zero;
			VerticalLayoutGroup component4 = val3.GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 1f;
			((LayoutGroup)component4).padding = new RectOffset(10, 10, 6, 6);
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			val3.GetComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect component5 = val.GetComponent<ScrollRect>();
			component5.content = component3;
			component5.viewport = component2;
			component5.horizontal = false;
			component5.vertical = true;
			component5.scrollSensitivity = 30f;
			component5.movementType = (MovementType)2;
			component5.inertia = false;
			return val3.transform;
		}
	}
	internal static class SkillProfileReader
	{
		private static readonly Log.Scoped _log = Log.For("SkillProfileReader");

		internal static IReadOnlyList<SkillType> AllSkillTypes { get; } = (from t in Enum.GetValues(typeof(SkillType)).Cast<SkillType>().Where(delegate(SkillType t)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Expected I4, but got Unknown
				int num = (int)t;
				return num > 0 && num < 900;
			})
			orderby (int)t
			select t).ToList().AsReadOnly();


		internal static Dictionary<SkillType, float> ReadSkills(PlayerProfile profile)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			try
			{
				byte[] rawPlayerData = GetRawPlayerData(profile);
				if (rawPlayerData == null || rawPlayerData.Length == 0)
				{
					_log.Warn("m_playerData is null or empty — no skills available.");
					return new Dictionary<SkillType, float>();
				}
				return ParseSkills(new ZPackage(rawPlayerData));
			}
			catch (Exception ex)
			{
				_log.Warn("ReadSkills failed: " + ex.Message);
				return new Dictionary<SkillType, float>();
			}
		}

		private static byte[]? GetRawPlayerData(PlayerProfile profile)
		{
			return ((object)profile).GetType().GetField("m_playerData", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(profile) as byte[];
		}

		private static Dictionary<SkillType, float> ParseSkills(ZPackage pkg)
		{
			//IL_005e: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			int num = pkg.ReadInt();
			if (num >= 7)
			{
				pkg.ReadSingle();
			}
			pkg.ReadSingle();
			if (num >= 10)
			{
				pkg.ReadSingle();
			}
			if (num >= 8 && num < 28)
			{
				pkg.ReadBool();
			}
			if (num >= 20)
			{
				pkg.ReadSingle();
			}
			if (num >= 23)
			{
				pkg.ReadString();
			}
			if (num >= 24)
			{
				pkg.ReadSingle();
			}
			if (num == 2)
			{
				pkg.ReadZDOID();
			}
			SkipInventory(pkg);
			SkipStringList(pkg);
			if (num < 15)
			{
				SkipStringList(pkg);
			}
			else
			{
				SkipStringIntMap(pkg);
			}
			SkipStringList(pkg);
			if (num < 19 || num >= 21)
			{
				SkipStringList(pkg);
			}
			if (num >= 6)
			{
				SkipStringList(pkg);
			}
			if (num >= 9)
			{
				SkipStringList(pkg);
			}
			if (num >= 18)
			{
				SkipIntList(pkg);
			}
			if (num >= 22)
			{
				SkipStringStringMap(pkg);
			}
			if (num >= 4)
			{
				pkg.ReadString();
				pkg.ReadString();
			}
			if (num >= 5)
			{
				pkg.ReadVector3();
				pkg.ReadVector3();
			}
			if (num >= 11)
			{
				pkg.ReadInt();
			}
			if (num >= 12)
			{
				SkipFoods(pkg, num);
			}
			if (num < 17)
			{
				return new Dictionary<SkillType, float>();
			}
			return ReadSkillsSection(pkg);
		}

		private static Dictionary<SkillType, float> ReadSkillsSection(ZPackage pkg)
		{
			//IL_001f: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			int num = pkg.ReadInt();
			int num2 = pkg.ReadInt();
			Dictionary<SkillType, float> dictionary = new Dictionary<SkillType, float>(num2);
			for (int i = 0; i < num2; i++)
			{
				SkillType val = (SkillType)pkg.ReadInt();
				float value = pkg.ReadSingle();
				if (num >= 2)
				{
					pkg.ReadSingle();
				}
				if (Enum.IsDefined(typeof(SkillType), val))
				{
					dictionary[val] = value;
				}
			}
			return dictionary;
		}

		private static void SkipInventory(ZPackage pkg)
		{
			int num = pkg.ReadInt();
			int num2 = pkg.ReadInt();
			for (int i = 0; i < num2; i++)
			{
				pkg.ReadString();
				pkg.ReadInt();
				pkg.ReadSingle();
				pkg.ReadInt();
				pkg.ReadInt();
				pkg.ReadBool();
				if (num == 106)
				{
					pkg.ReadInt();
					pkg.ReadInt();
					pkg.ReadLong();
					pkg.ReadString();
					SkipStringStringMap(pkg);
					pkg.ReadInt();
					pkg.ReadBool();
					continue;
				}
				if (num >= 101)
				{
					pkg.ReadInt();
				}
				if (num >= 102)
				{
					pkg.ReadInt();
				}
				if (num >= 103)
				{
					pkg.ReadLong();
					pkg.ReadString();
				}
				if (num >= 104)
				{
					SkipStringStringMap(pkg);
				}
				if (num >= 105)
				{
					pkg.ReadInt();
				}
			}
		}

		private static void SkipFoods(ZPackage pkg, int playerVersion)
		{
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				if (playerVersion >= 14)
				{
					pkg.ReadString();
					if (playerVersion >= 25)
					{
						pkg.ReadSingle();
						continue;
					}
					pkg.ReadSingle();
					if (playerVersion >= 16)
					{
						pkg.ReadSingle();
					}
					continue;
				}
				pkg.ReadString();
				pkg.ReadSingle();
				pkg.ReadSingle();
				pkg.ReadSingle();
				pkg.ReadSingle();
				pkg.ReadSingle();
				pkg.ReadSingle();
				if (playerVersion >= 13)
				{
					pkg.ReadSingle();
				}
			}
		}

		private static void SkipStringList(ZPackage pkg)
		{
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				pkg.ReadString();
			}
		}

		private static void SkipIntList(ZPackage pkg)
		{
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				pkg.ReadInt();
			}
		}

		private static void SkipStringIntMap(ZPackage pkg)
		{
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				pkg.ReadString();
				pkg.ReadInt();
			}
		}

		private static void SkipStringStringMap(ZPackage pkg)
		{
			int num = pkg.ReadInt();
			for (int i = 0; i < num; i++)
			{
				pkg.ReadString();
				pkg.ReadString();
			}
		}
	}
}
namespace SkillsPreview.App.UI.LevelUpToast
{
	internal class LevelUpToast : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <AnimateBanner>d__17 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public LevelUpToast <>4__this;

			private float <holdFor>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AnimateBanner>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Expected O, but got Unknown
				int num = <>1__state;
				LevelUpToast levelUpToast = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					float num2 = Mathf.Max(0.95000005f, Config.ToastDuration.Value);
					<holdFor>5__2 = num2 - 0.25f - 0.6f;
					<>2__current = levelUpToast.FadeGroup(0f, 1f, 0.25f);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					if (<holdFor>5__2 > 0f)
					{
						<>2__current = (object)new WaitForSeconds(<holdFor>5__2);
						<>1__state = 2;
						return true;
					}
					goto IL_00ae;
				case 2:
					<>1__state = -1;
					goto IL_00ae;
				case 3:
					{
						<>1__state = -1;
						levelUpToast._animation = null;
						return false;
					}
					IL_00ae:
					<>2__current = levelUpToast.FadeGroup(1f, 0f, 0.6f);
					<>1__state = 3;
					return true;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <FadeGroup>d__18 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public LevelUpToast <>4__this;

			public float from;

			public float to;

			public float duration;

			private float <elapsed>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <FadeGroup>d__18(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				LevelUpToast levelUpToast = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<elapsed>5__2 = 0f;
					levelUpToast._group.alpha = from;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__2 < duration)
				{
					<elapsed>5__2 += Time.deltaTime;
					levelUpToast._group.alpha = Mathf.Lerp(from, to, Mathf.Clamp01(<elapsed>5__2 / duration));
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				levelUpToast._group.alpha = to;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly Log.Scoped Logger = Log.For("LevelUpToast");

		private const float FadeInSeconds = 0.25f;

		private const float FadeOutSeconds = 0.6f;

		private const float MinDuration = 0.95000005f;

		private GameObject _root;

		private RectTransform _rootRt;

		private Text _text;

		private Text _shadowText;

		private Outline _outline;

		private CanvasGroup _group;

		private Coroutine? _animation;

		private void Awake()
		{
			BuildBanner();
			Logger.Debug("Awake — banner created.");
		}

		internal void Show(string skillName, int newLevel)
		{
			if (Config.ToastEnabled.Value)
			{
				ApplyStyle(skillName, newLevel);
				ApplyPosition();
				if (_animation != null)
				{
					((MonoBehaviour)this).StopCoroutine(_animation);
				}
				_animation = ((MonoBehaviour)this).StartCoroutine(AnimateBanner());
			}
		}

		private void BuildBanner()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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_012a: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			Font builtinResource = Resources.GetBuiltinResource<Font>("Arial.ttf");
			_root = new GameObject("godzki_LevelUpToast", new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasGroup)
			});
			_root.transform.SetParent(((Component)this).transform, false);
			_rootRt = _root.GetComponent<RectTransform>();
			_rootRt.anchorMin = new Vector2(0.5f, 0.8f);
			_rootRt.anchorMax = new Vector2(0.5f, 0.8f);
			_rootRt.pivot = new Vector2(0.5f, 0.5f);
			_rootRt.sizeDelta = new Vector2(800f, 80f);
			_group = _root.GetComponent<CanvasGroup>();
			_group.alpha = 0f;
			_group.interactable = false;
			_group.blocksRaycasts = false;
			_shadowText = BuildText(_root.transform, builtinResource, "Shadow", new Color(0f, 0f, 0f, 0.85f), new Vector2(2f, -3f));
			_text = BuildText(_root.transform, builtinResource, "Label", Color.white, Vector2.zero);
			_outline = ((Component)_text).gameObject.AddComponent<Outline>();
			((Shadow)_outline).effectColor = new Color(0f, 0f, 0f, 0.95f);
			((Shadow)_outline).effectDistance = new Vector2(1.2f, -1.2f);
		}

		private static Text BuildText(Transform parent, Font font, string goName, Color color, Vector2 offset)
		{
			//IL_002e: 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_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)
			//IL_005d: 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_0086: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(goName, new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = offset;
			component.offsetMax = offset;
			Text component2 = val.GetComponent<Text>();
			component2.font = font;
			component2.fontStyle = (FontStyle)1;
			component2.alignment = (TextAnchor)4;
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = false;
			component2.horizontalOverflow = (HorizontalWrapMode)1;
			component2.verticalOverflow = (VerticalWrapMode)1;
			return component2;
		}

		private void ApplyStyle(string skillName, int newLevel)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			string text = $"{skillName} — Lv.{newLevel}";
			int fontSize = Mathf.Max(8, Config.ToastFontSize.Value);
			_text.text = text;
			_text.fontSize = fontSize;
			((Graphic)_text).color = Config.ToastColor.Value;
			_shadowText.text = text;
			_shadowText.fontSize = fontSize;
		}

		private void ApplyPosition()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(Config.ToastPositionTopPercent.Value, 0f, 50f) / 100f;
			float num2 = 1f - num;
			_rootRt.anchorMin = new Vector2(0.5f, num2);
			_rootRt.anchorMax = new Vector2(0.5f, num2);
			_rootRt.anchoredPosition = Vector2.zero;
		}

		[IteratorStateMachine(typeof(<AnimateBanner>d__17))]
		private IEnumerator AnimateBanner()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AnimateBanner>d__17(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<FadeGroup>d__18))]
		private IEnumerator FadeGroup(float from, float to, float duration)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeGroup>d__18(0)
			{
				<>4__this = this,
				from = from,
				to = to,
				duration = duration
			};
		}
	}
}
namespace SkillsPreview.App.UI.FavoriteSkillsHud
{
	internal class FavoriteSkillsHud : MonoBehaviour
	{
		private static readonly Log.Scoped Logger = Log.For("FavoriteSkillsHud");

		private const float RefreshInterval = 0.5f;

		private GameObject _panel;

		private SkillsPreview.App.UI.LevelUpToast.LevelUpToast? _toast;

		private readonly Dictionary<string, SkillWidget> _widgets = new Dictionary<string, SkillWidget>();

		private readonly Dictionary<string, Coroutine> _levelUpCoroutines = new Dictionary<string, Coroutine>();

		private float _refreshTimer;

		private bool _dirty = true;

		private SkillsPreview.App.UI.LevelUpToast.LevelUpToast? Toast
		{
			get
			{
				if (!((Object)(object)_toast != (Object)null))
				{
					return _toast = ((Component)this).GetComponent<SkillsPreview.App.UI.LevelUpToast.LevelUpToast>();
				}
				return _toast;
			}
		}

		private void Awake()
		{
			BuildPanel();
			Logger.Debug("Awake — panel created.");
		}

		private void OnEnable()
		{
			FavoriteSkillsStore.OnFavoritesChanged += MarkDirty;
			FavoriteSkillsStore.OnConfigChanged += OnConfigChanged;
		}

		private void OnDisable()
		{
			FavoriteSkillsStore.OnFavoritesChanged -= MarkDirty;
			FavoriteSkillsStore.OnConfigChanged -= OnConfigChanged;
		}

		private void Update()
		{
			Player localPlayer = Player.m_localPlayer;
			if (_dirty)
			{
				if ((Object)(object)localPlayer != (Object)null)
				{
					RebuildWidgets(localPlayer);
					_dirty = false;
				}
				return;
			}
			_refreshTimer += Time.deltaTime;
			if (!(_refreshTimer < 0.5f))
			{
				_refreshTimer = 0f;
				if ((Object)(object)localPlayer != (Object)null)
				{
					RefreshWidgets(localPlayer);
				}
			}
		}

		private void MarkDirty()
		{
			_dirty = true;
		}

		private void OnConfigChanged()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			_panel.SetActive(Config.HudWidgetsVisible.Value);
			_panel.GetComponent<RectTransform>().anchoredPosition = new Vector2(Config.HudPositionX.Value, Config.HudPositionY.Value);
			((HorizontalOrVerticalLayoutGroup)_panel.GetComponent<HorizontalLayoutGroup>()).spacing = Config.WidgetSpacing.Value;
			ApplyScale();
			_dirty = true;
		}

		private void BuildPanel()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			_panel = new GameObject("godzki_FavoriteSkillsPanel", new Type[3]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup),
				typeof(ContentSizeFitter)
			});
			_panel.transform.SetParent(((Component)this).transform, false);
			_panel.SetActive(Config.HudWidgetsVisible.Value);
			RectTransform component = _panel.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.zero;
			component.pivot = Vector2.zero;
			component.anchoredPosition = new Vector2(Config.HudPositionX.Value, Config.HudPositionY.Value);
			component.sizeDelta = Vector2.zero;
			HorizontalLayoutGroup component2 = _panel.GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).spacing = Config.WidgetSpacing.Value;
			((LayoutGroup)component2).childAlignment = (TextAnchor)6;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			((LayoutGroup)component2).padding = new RectOffset(0, 0, 0, 0);
			ContentSizeFitter component3 = _panel.GetComponent<ContentSizeFitter>();
			component3.horizontalFit = (FitMode)2;
			component3.verticalFit = (FitMode)2;
			ApplyScale();
		}

		private void ApplyScale()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp(Config.HudScale.Value, 50f, 150f) / 100f;
			_panel.transform.localScale = new Vector3(num, num, 1f);
		}

		private void RebuildWidgets(Player player)
		{
			StopAllLevelUpCoroutines();
			DestroyAllWidgets();
			Dictionary<string, Skill> dictionary = BuildSkillLookup(player);
			foreach (string orderedFavorite in FavoriteSkillsStore.GetOrderedFavorites())
			{
				if (dictionary.TryGetValue(orderedFavorite, out var value))
				{
					SkillWidget value2 = SkillWidgetFactory.Create(_panel.transform, value);
					_widgets[orderedFavorite] = value2;
					Logger.Debug("Built widget for '" + orderedFavorite + "'.");
				}
			}
			Logger.Debug($"Rebuilt — {_widgets.Count} widget(s) shown.");
		}

		private void RefreshWidgets(Player player)
		{
			if (_widgets.Count == 0)
			{
				return;
			}
			foreach (Skill skill in ((Character)player).GetSkills().GetSkillList())
			{
				string text = ((object)(SkillType)(ref skill.m_info.m_skill)).ToString();
				if (_widgets.TryGetValue(text, out SkillWidget value) && value.Refresh(skill))
				{
					Logger.Debug("Level-up detected for '" + text + "' — triggering flash effect.");
					RestartLevelUpCoroutine(text, value);
					Toast?.Show(LocalizedSkillName(skill), (int)skill.m_level);
				}
			}
		}

		private static string LocalizedSkillName(Skill skill)
		{
			string text = ((object)(SkillType)(ref skill.m_info.m_skill)).ToString();
			if (Localization.instance == null)
			{
				return text;
			}
			return Localization.instance.Localize("$skill_" + text.ToLower());
		}

		private void StopAllLevelUpCoroutines()
		{
			foreach (Coroutine value in _levelUpCoroutines.Values)
			{
				if (value != null)
				{
					((MonoBehaviour)this).StopCoroutine(value);
				}
			}
			_levelUpCoroutines.Clear();
		}

		private void DestroyAllWidgets()
		{
			foreach (SkillWidget value in _widgets.Values)
			{
				Object.Destroy((Object)(object)value.Root);
			}
			_widgets.Clear();
		}

		private void RestartLevelUpCoroutine(string name, SkillWidget widget)
		{
			if (_levelUpCoroutines.TryGetValue(name, out Coroutine value) && value != null)
			{
				((MonoBehaviour)this).StopCoroutine(value);
			}
			_levelUpCoroutines[name] = ((MonoBehaviour)this).StartCoroutine(widget.LevelUpEffect());
		}

		private static Dictionary<string, Skill> BuildSkillLookup(Player player)
		{
			Dictionary<string, Skill> dictionary = new Dictionary<string, Skill>(StringComparer.OrdinalIgnoreCase);
			foreach (Skill skill in ((Character)player).GetSkills().GetSkillList())
			{
				dictionary[((object)(SkillType)(ref skill.m_info.m_skill)).ToString()] = skill;
			}
			return dictionary;
		}
	}
	internal sealed class SkillWidgetParts
	{
		public GameObject Root { get; init; }

		public Image BorderImage { get; init; }

		public Image Icon { get; init; }

		public Text LevelText { get; init; }

		public Text ProgressText { get; init; }

		public int InitialLevel { get; init; }

		public Image? ProgressBarFillImage { get; init; }
	}
	internal sealed class SkillWidget
	{
		[CompilerGenerated]
		private sealed class <LevelUpEffect>d__15 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public SkillWidget <>4__this;

			private Color <from>5__2;

			private Color <to>5__3;

			private float <duration>5__4;

			private float <elapsed>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LevelUpEffect>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				SkillWidget skillWidget = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<from>5__2 = Config.WidgetLevelUpColor.Value;
					<to>5__3 = Config.WidgetBorderColor.Value;
					<duration>5__4 = Mathf.Max(0.1f, Config.WidgetLevelUpDuration.Value);
					((Graphic)skillWidget._borderImage).color = <from>5__2;
					<elapsed>5__5 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__5 < <duration>5__4)
				{
					<elapsed>5__5 += Time.deltaTime;
					float num2 = Mathf.Clamp01(<elapsed>5__5 / <duration>5__4);
					((Graphic)skillWidget._borderImage).color = Color.Lerp(<from>5__2, <to>5__3, num2);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Graphic)skillWidget._borderImage).color = <to>5__3;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const int ProgressTextResolution = 10000;

		internal readonly GameObject Root;

		private readonly Image _icon;

		private readonly Text _levelText;

		private readonly Text _progressText;

		private readonly Image _borderImage;

		private readonly Image? _progressBarFillImage;

		private int _lastLevel;

		private int _lastDisplayedLevel = int.MinValue;

		private int _lastProgressCode = int.MinValue;

		private float _lastProgressFraction = -1f;

		internal SkillWidget(SkillWidgetParts parts)
		{
			Root = parts.Root;
			_borderImage = parts.BorderImage;
			_icon = parts.Icon;
			_levelText = parts.LevelText;
			_progressText = parts.ProgressText;
			_progressBarFillImage = parts.ProgressBarFillImage;
			_lastLevel = parts.InitialLevel;
		}

		internal bool Refresh(Skill skill)
		{
			int num = (int)skill.m_level;
			bool result = num > _lastLevel;
			_lastLevel = num;
			Sprite icon = skill.m_info.m_icon;
			if ((Object)(object)icon != (Object)null && (Object)(object)_icon.sprite != (Object)(object)icon)
			{
				_icon.sprite = icon;
			}
			if (num != _lastDisplayedLevel)
			{
				_levelText.text = $"Lv.{num}";
				_lastDisplayedLevel = num;
			}
			bool flag = SkillMath.IsMaxLevel(skill.m_level);
			float progress = (flag ? 1f : SkillMath.LevelProgress(skill));
			UpdateProgressText(flag, progress);
			UpdateProgressBar(flag, progress);
			return result;
		}

		private void UpdateProgressText(bool isMax, float progress)
		{
			//IL_0066: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			int num = (isMax ? int.MaxValue : Mathf.RoundToInt(progress * 10000f));
			if (num != _lastProgressCode)
			{
				_lastProgressCode = num;
				_progressText.text = (isMax ? "MAX" : $"{progress * 100f:F2}%");
			}
			Color val = (isMax ? Config.WidgetProgressMaxColor.Value : Config.WidgetProgressColor.Value);
			if (((Graphic)_progressText).color != val)
			{
				((Graphic)_progressText).color = val;
			}
		}

		private void UpdateProgressBar(bool isMax, float progress)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_progressBarFillImage == (Object)null))
			{
				if (!Mathf.Approximately(progress, _lastProgressFraction))
				{
					((Graphic)_progressBarFillImage).rectTransform.anchorMax = new Vector2(progress, 1f);
					_lastProgressFraction = progress;
				}
				Color val = (isMax ? Config.WidgetProgressMaxColor.Value : Config.WidgetProgressColor.Value);
				if (((Graphic)_progressBarFillImage).color != val)
				{
					((Graphic)_progressBarFillImage).color = val;
				}
			}
		}

		[IteratorStateMachine(typeof(<LevelUpEffect>d__15))]
		internal IEnumerator LevelUpEffect()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LevelUpEffect>d__15(0)
			{
				<>4__this = this
			};
		}
	}
	internal static class SkillWidgetFactory
	{
		private const float ProgressBarBottomGap = 2f;

		internal static SkillWidget Create(Transform parent, Skill skill)
		{
			Font builtinResource = Resources.GetBuiltinResource<Font>("Arial.ttf");
			float value = Config.WidgetBorderSize.Value;
			float value2 = Config.WidgetIconSize.Value;
			float height = (float)Config.WidgetFontSizeLevel.Value + 3f;
			float height2 = (float)Config.WidgetFontSizeProgress.Value + 3f;
			int num = Mathf.Max(0, Config.WidgetCornerRadius.Value);
			int frameWidth = Mathf.RoundToInt(value);
			Sprite roundedSprite = ((num > 0) ? SpriteUtils.RoundedRect(num) : null);
			Sprite roundedSprite2 = ((num > 0) ? SpriteUtils.RoundedRectFrame(num, frameWidth) : null);
			bool value3 = Config.WidgetProgressBarVisible.Value;
			float num2 = Mathf.Max(0f, Config.WidgetProgressBarHeight.Value);
			GameObject val = BuildOuter(parent, roundedSprite2);
			GameObject val2 = BuildInner(val.transform, value, roundedSprite, value3 ? (num2 + 2f) : 0f);
			Image icon = BuildIcon(val2.transform, value2);
			Text levelText = BuildLevelText(val2.transform, builtinResource, height);
			Text progressText = BuildProgressText(val2.transform, builtinResource, height2);
			Image component = val.GetComponent<Image>();
			Image progressBarFillImage = null;
			if (value3 && num2 > 0f)
			{
				progressBarFillImage = BuildProgressBar(val2.transform, num2);
			}
			SkillWidget skillWidget = new SkillWidget(new SkillWidgetParts
			{
				Root = val,
				BorderImage = component,
				Icon = icon,
				LevelText = levelText,
				ProgressText = progressText,
				InitialLevel = (int)skill.m_level,
				ProgressBarFillImage = progressBarFillImage
			});
			skillWidget.Refresh(skill);
			return skillWidget;
		}

		private static GameObject BuildOuter(Transform parent, Sprite? roundedSprite)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			GameObject val = new GameObject("godzki_SkillWidget", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			LayoutElement component = val.GetComponent<LayoutElement>();
			component.preferredWidth = Config.WidgetWidth.Value;
			component.preferredHeight = Config.WidgetHeight.Value;
			component.minWidth = Config.WidgetWidth.Value;
			component.minHeight = Config.WidgetHeight.Value;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = Config.WidgetBorderColor.Value;
			((Graphic)component2).raycastTarget = false;
			if ((Object)(object)roundedSprite != (Object)null)
			{
				component2.sprite = roundedSprite;
				component2.type = (Type)1;
			}
			return val;
		}

		private static GameObject BuildInner(Transform parent, float border, Sprite? roundedSprite, float extraBottomPadding)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_0063: 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_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_00f9: Expected O, but got Unknown
			GameObject val = new GameObject("Inner", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(VerticalLayoutGroup)
			});
			val.transform.SetParent(parent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = new Vector2(border, border);
			component.offsetMax = new Vector2(0f - border, 0f - border);
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = Config.WidgetBgColor.Value;
			((Graphic)component2).raycastTarget = false;
			if ((Object)(object)roundedSprite != (Object)null)
			{
				component2.sprite = roundedSprite;
				component2.type = (Type)1;
			}
			VerticalLayoutGroup component3 = val.GetComponent<VerticalLayoutGroup>();
			((LayoutGroup)component3).childAlignment = (TextAnchor)1;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component3).spacing = 2f;
			((LayoutGroup)component3).padding = new RectOffset(3, 3, 4, 4 + Mathf.RoundToInt(extraBottomPadding));
			return val;
		}

		private static Image BuildIcon(Transform parent, float iconSize)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Icon", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Image component = val.GetComponent<Image>();
			component.preserveAspect = true;
			((Graphic)component).raycastTarget = false;
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.preferredWidth = iconSize;
			component2.preferredHeight = iconSize;
			component2.minHeight = iconSize;
			return component;
		}

		private static Text BuildLevelText(Transform parent, Font font, float height)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Level", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Text component = val.GetComponent<Text>();
			component.font = font;
			component.fontSize = Config.WidgetFontSizeLevel.Value;
			component.alignment = (TextAnchor)4;
			((Graphic)component).color = Config.WidgetLevelColor.Value;
			((Graphic)component).raycastTarget = false;
			component.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.preferredHeight = height;
			component2.minHeight = height;
			return component;
		}

		private static Text BuildProgressText(Transform parent, Font font, float height)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			GameObject val = new GameObject("Progress", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text),
				typeof(LayoutElement)
			});
			val.transform.SetParent(parent, false);
			Text component = val.GetComponent<Text>();
			component.font = font;
			component.fontSize = Config.WidgetFontSizeProgress.Value;
			component.alignment = (TextAnchor)4;
			((Graphic)component).raycastTarget = false;
			component.verticalOverflow = (VerticalWrapMode)1;
			LayoutElement component2 = val.GetComponent<LayoutElement>();
			component2.preferredHeight = height;
			component2.minHeight = height;
			return component;
		}

		private static Image BuildProgressBar(Transform innerParent, float height)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_0063: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_010c: 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_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ProgressBar", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(LayoutElement)
			});
			val.transform.SetParent(innerParent, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0f);
			component.anchorMax = new Vector2(1f, 0f);
			component.pivot = new Vector2(0.5f, 0f);
			component.sizeDelta = new Vector2(0f, height);
			component.anchoredPosition = Vector2.zero;
			val.GetComponent<LayoutElement>().ignoreLayout = true;
			Image component2 = val.GetComponent<Image>();
			((Graphic)component2).color = Config.WidgetProgressBarBgColor.Value;
			((Graphic)component2).raycastTarget = false;
			GameObject val2 = new GameObject("Fill", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = new Vector2(0f, 0f);
			component3.anchorMax = new Vector2(0f, 1f);
			component3.pivot = new Vector2(0f, 0.5f);
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			Image component4 = val2.GetComponent<Image>();
			((Graphic)component4).color = Config.WidgetProgressColor.Value;
			((Graphic)component4).raycastTarget = false;
			return component4;
		}
	}
}
namespace SkillsPreview.App.Store
{
	internal static class FavoriteSkillsStore
	{
		private static readonly Log.Scoped _log = Log.For("FavoriteSkillsStore");

		private static readonly string CacheDirectory = Path.Combine(Paths.BepInExRootPath, "cache");

		private static string? _currentCharacterFilename;

		private static readonly List<string> _ordered = new List<string>();

		private static readonly HashSet<string> _lookup = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal static event Action? OnFavoritesChanged;

		internal static event Action? OnConfigChanged;

		internal static void NotifyConfigChanged()
		{
			FavoriteSkillsStore.OnConfigChanged?.Invoke();
		}

		internal static void LoadForCharacter(string characterFilename)
		{
			if (_currentCharacterFilename == characterFilename)
			{
				_log.Debug("Favorites already loaded for '" + characterFilename + "', skipping.");
				return;
			}
			_currentCharacterFilename = characterFilename;
			ReadFromDisk(characterFilename);
			_log.Info($"Loaded {_ordered.Count} favorite(s) for character '{characterFilename}'.");
			_log.Debug("Favorites: [" + string.Join(", ", _ordered) + "]");
			FavoriteSkillsStore.OnFavoritesChanged?.Invoke();
		}

		internal static bool IsFavorite(string skillName)
		{
			return _lookup.Contains(skillName);
		}

		internal static IReadOnlyList<string> GetOrderedFavorites()
		{
			return _ordered;
		}

		internal static bool Toggle(string skillName)
		{
			bool flag;
			if (_lookup.Contains(skillName))
			{
				_ordered.Remove(skillName);
				_lookup.Remove(skillName);
				flag = false;
			}
			else
			{
				_ordered.Add(skillName);
				_lookup.Add(skillName);
				flag = true;
			}
			_log.Debug(string.Format("Toggled '{0}' → {1} ({2} total).", skillName, flag ? "favorited" : "unfavorited", _ordered.Count));
			SaveToDisk();
			FavoriteSkillsStore.OnFavoritesChanged?.Invoke();
			return flag;
		}

		internal static void Clear()
		{
			_log.Debug("Clearing favorites for '" + (_currentCharacterFilename ?? "unknown") + "'.");
			_currentCharacterFilename = null;
			_ordered.Clear();
			_lookup.Clear();
			FavoriteSkillsStore.OnFavoritesChanged?.Invoke();
		}

		private static string GetFilePath(string characterFilename)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(characterFilename);
			return Path.Combine(CacheDirectory, "skills_preview.favorites." + fileNameWithoutExtension + ".data");
		}

		private static void ReadFromDisk(string characterFilename)
		{
			_ordered.Clear();
			_lookup.Clear();
			string filePath = GetFilePath(characterFilename);
			if (!File.Exists(filePath))
			{
				_log.Debug("No favorites file found at '" + filePath + "', starting empty.");
				return;
			}
			try
			{
				string[] array = File.ReadAllLines(filePath);
				for (int i = 0; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (!string.IsNullOrEmpty(text) && !_lookup.Contains(text))
					{
						_ordered.Add(text);
						_lookup.Add(text);
					}
				}
				_log.Debug($"Read {_ordered.Count} favorite(s) from '{filePath}'.");
			}
			catch (Exception ex)
			{
				_log.Error("Failed to read favorites from '" + filePath + "': " + ex.Message);
			}
		}

		private static void SaveToDisk()
		{
			if (_currentCharacterFilename == null)
			{
				_log.Warn("SaveToDisk called with no character loaded — skipping.");
				return;
			}
			string filePath = GetFilePath(_currentCharacterFilename);
			try
			{
				Directory.CreateDirectory(CacheDirectory);
				File.WriteAllLines(filePath, _ordered);
				_log.Debug($"Saved {_ordered.Count} favorite(s) to '{filePath}'.");
			}
			catch (Exception ex)
			{
				_log.Error("Failed to save favorites to '" + filePath + "': " + ex.Message);
			}
		}
	}
}
namespace SkillsPreview.App.Patch
{
	[HarmonyPatch]
	internal class CharacterLoadPatch
	{
		private static readonly Log.Scoped _log = Log.For("CharacterLoadPatch");

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static void Player_OnSpawned_Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				Game instance = Game.instance;
				PlayerProfile val = ((instance != null) ? instance.GetPlayerProfile() : null);
				if (val == null)
				{
					_log.Warn("OnSpawned — PlayerProfile is null, cannot load favorites.");
					return;
				}
				string filename = val.GetFilename();
				_log.Debug("Player spawned — loading favorites for '" + filename + "'.");
				FavoriteSkillsStore.LoadForCharacter(filename);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Player), "OnDestroy")]
		private static void Player_OnDestroy_Postfix(Player __instance)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				_log.Debug("Player destroyed — clearing favorites.");
				FavoriteSkillsStore.Clear();
			}
		}
	}
	[HarmonyPatch]
	internal class FejdStartupPatch
	{
		private static readonly Log.Scoped _log = Log.For("FejdStartupPatch");

		private static CharacterStatsPanel? _statsPanel;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FejdStartup), "UpdateCharacterList")]
		private static void UpdateCharacterList_Postfix(FejdStartup __instance, List<PlayerProfile> ___m_profiles, int ___m_profileIndex)
		{
			EnsurePanel(__instance);
			PlayerProfile profile = ((___m_profiles != null && ___m_profiles.Count > 0 && ___m_profileIndex >= 0 && ___m_profileIndex < ___m_profiles.Count) ? ___m_profiles[___m_profileIndex] : null);
			_statsPanel?.Refresh(profile);
		}

		internal static void Invalidate()
		{
			CharacterStatsPanel statsPanel = _statsPanel;
			if (statsPanel != null && statsPanel.IsAlive)
			{
				Object.Destroy((Object)(object)_statsPanel.Root);
			}
			_statsPanel = null;
		}

		private static void EnsurePanel(FejdStartup instance)
		{
			CharacterStatsPanel statsPanel = _statsPanel;
			if (statsPanel == null || !statsPanel.IsAlive)
			{
				Transform val = ResolveParent(instance);
				_statsPanel = CharacterStatsPanel.Create(val);
				_log.Debug("CharacterStatsPanel attached to '" + ((Object)val).name + "'.");
			}
		}

		private static Transform ResolveParent(FejdStartup instance)
		{
			GameObject value = Traverse.Create((object)instance).Field<GameObject>("m_selectCharacterPanel").Value;
			if (!((Object)(object)value != (Object)null))
			{
				return ((Component)instance).transform;
			}
			return value.transform;
		}
	}
	[HarmonyPatch]
	internal class HudPatch
	{
		private static readonly Log.Scoped _log = Log.For("HudPatch");

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Hud), "Awake")]
		private static void Hud_Awake_Postfix(Hud __instance)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("godzki_FavoriteSkillsHud", new Type[1] { typeof(RectTransform) });
			val.transform.SetParent(__instance.m_rootObject.transform, false);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			val.AddComponent<FavoriteSkillsHud>();
			val.AddComponent<LevelUpToast>();
			_log.Debug("FavoriteSkillsHud and LevelUpToast injected into Hud.m_rootObject.");
		}
	}
	[HarmonyPatch]
	internal class LocalizationPatch
	{
		private static readonly Log.Scoped _log = Log.For("LocalizationPatch");

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Localization), "SetLanguage")]
		private static void SetLanguage_Prefix()
		{
			_log.Debug("Language changing — invalidating mod panels.");
			FejdStartupPatch.Invalidate();
			SkillsPanelPatch.Invalidate();
		}
	}
	[HarmonyPatch]
	internal class SkillsPanelPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__17_0;

			internal void <InjectSettingsButton>b__17_0()
			{
				if (_settingsPanel != null && _settingsPanel.IsAlive)
				{
					if (_settingsPanel.IsVisible)
					{
						_settingsPanel.Hide();
					}
					else
					{
						_settingsPanel.Show();
					}
					_log.Debug($"Settings panel toggled → {_settingsPanel.IsVisible}.");
				}
			}
		}

		private static readonly Log.Scoped _log = Log.For("SkillsPanelPatch");

		private static SettingsPanel? _settingsPanel;

		private static readonly Vector2 StarAnchorMin = new Vector2(0f, 0.5f);

		private static readonly Vector2 StarAnchorMax = new Vector2(0f, 0.5f);

		private static readonly Vector2 StarPivot = new Vector2(0f, 0.5f);

		private static readonly Vector2 StarAnchoredPos = new Vector2(6f, 0f);

		private static readonly Vector2 StarSize = new Vector2(34f, 34f);

		private const string StarFavorited = "★";

		private const string StarUnfavorited = "☆";

		private const string StarObjectName = "godzki_FavoriteStar";

		private const string OverlayObjectName = "godzki_RowOverlay";

		private static readonly Color OverlayFavoriteColor = new Color(1f, 0.85f, 0f, 0.12f);

		private static readonly Color OverlayHighlightColor = new Color(1f, 0.92f, 0.5f, 0.18f);

		private static readonly Color OverlayPressedColor = new Color(1f, 0.85f, 0f, 0.28f);

		private const string SettingsBtnName = "godzki_SettingsButton";

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SkillsDialog), "Setup")]
		private static void SkillsDialog_Setup_Postfix(SkillsDialog __instance, Player? player, List<GameObject> ___m_elements)
		{
			if (player == null)
			{
				return;
			}
			List<Skill> skillList = ((Character)player).GetSkills().GetSkillList();
			_log.Debug($"Setup called — {___m_elements.Count} row(s), {skillList.Count} skill(s).");
			for (int i = 0; i < ___m_elements.Count && i < skillList.Count; i++)
			{
				string skillName = ((object)(SkillType)(ref skillList[i].m_info.m_skill)).ToString();
				InjectRowOverlay(___m_elements[i], skillName);
				InjectStarIntoRow(___m_elements[i], skillName);
			}
			Transform val = ((Component)__instance).transform.Find("SkillsFrame");
			if ((Object)(object)val == (Object)null)
			{
				_log.Warn("SkillsFrame not found — settings panel skipped.");
				return;
			}
			InjectSettingsButton(val, __instance);
			if (_settingsPanel == null || !_settingsPanel.IsAlive)
			{
				_settingsPanel = SettingsPanel.Create(val);
			}
			else
			{
				_settingsPanel.Hide();
			}
		}

		internal static void Invalidate()
		{
			SettingsPanel settingsPanel = _settingsPanel;
			if (settingsPanel != null && settingsPanel.IsAlive)
			{
				Object.Destroy((Object)(object)_settingsPanel.Root);
			}
			_settingsPanel = null;
		}

		private static void InjectSettingsButton(Transform skillsFrame, SkillsDialog dialog)
		{
			//IL_005a: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			if ((Object)(object)skillsFrame.Find("godzki_SettingsButton") != (Object)null)
			{
				return;
			}
			Transform obj = skillsFrame.Find("Closebutton");
			if ((Object)(object)obj == (Object)null)
			{
				throw new Exception("Closebutton not found");
			}
			GameObject obj2 = Object.Instantiate<GameObject>(((Component)obj).gameObject, skillsFrame);
			((Object)obj2).name = "godzki_SettingsButton";
			RectTransform component = obj2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 1f);
			component.sizeDelta = new Vector2(40f, 40f);
			component.anchoredPosition = new Vector2(-25f, -3f);
			obj2.GetComponentInChildren<TMP_Text>().text = "⚙";
			Button component2 = obj2.GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			ButtonClickedEvent onClick = component2.onClick;
			object obj3 = <>c.<>9__17_0;
			if (obj3 == null)
			{
				UnityAction val = delegate
				{
					if (_settingsPanel != null && _settingsPanel.IsAlive)
					{
						if (_settingsPanel.IsVisible)
						{
							_settingsPanel.Hide();
						}
						else
						{
							_settingsPanel.Show();
						}
						_log.Debug($"Settings panel toggled → {_settingsPanel.IsVisible}.");
					}
				};
				<>c.<>9__17_0 = val;
				obj3 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			_log.Debug("Settings button injected.");
		}

		private static void InjectRowOverlay(GameObject row, string skillName)
		{
			//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_00be: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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_0104: 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_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			GameObject row2 = row;
			string skillName2 = skillName;
			Transform val = row2.transform.Find("godzki_RowOverlay");
			if (val != null)
			{
				_log.Debug("Refreshing overlay for '" + skillName2 + "'.");
				UpdateOverlayColors(((Component)val).GetComponent<Button>(), FavoriteSkillsStore.IsFavorite(skillName2));
				return;
			}
			GameObject val2 = new GameObject("godzki_RowOverlay", new Type[4]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Image),
				typeof(Button)
			});
			val2.transform.SetParent(row2.transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			Image component2 = val2.GetComponent<Image>();
			((Graphic)component2).raycastTarget = true;
			Button component3 = val2.GetComponent<Button>();
			((Selectable)component3).targetGraphic = (Graphic)(object)component2;
			((Selectable)component3).transition = (Transition)1;
			UpdateOverlayColors(component3, FavoriteSkillsStore.IsFavorite(skillName2));
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				OnRowClicked(row2, skillName2);
			});
			val2.transform.SetAsLastSibling();
			_log.Debug("Injected row overlay for '" + skillName2 + "'.");
		}

		private static void UpdateOverlayColors(Button? button, bool isFavorited)
		{
			//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_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (button != null)
			{
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).normalColor = (isFavorited ? OverlayFavoriteColor : Color.clear);
				((ColorBlock)(ref colors)).highlightedColor = OverlayHighlightColor;
				((ColorBlock)(ref colors)).pressedColor = OverlayPressedColor;
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).normalColor;
				((ColorBlock)(ref colors)).fadeDuration = 0.1f;
				((ColorBlock)(ref colors)).colorMultiplier = 1f;
				((Selectable)button).colors = colors;
			}
		}

		private static void InjectStarIntoRow(GameObject row, string skillName)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			Transform val = row.transform.Find("godzki_FavoriteStar");
			if (val != null)
			{
				_log.Debug("Refreshing star for '" + skillName + "'.");
				UpdateStarVisual(((Component)val).GetComponent<Text>(), skillName);
				return;
			}
			GameObject val2 = new GameObject("godzki_FavoriteStar", new Type[3]
			{
				typeof(RectTransform),
				typeof(CanvasRenderer),
				typeof(Text)
			});
			val2.transform.SetParent(row.transform, false);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = StarAnchorMin;
			component.anchorMax = StarAnchorMax;
			component.pivot = StarPivot;
			component.anchoredPosition = StarAnchoredPos;
			component.sizeDelta = StarSize;
			Text component2 = val2.GetComponent<Text>();
			component2.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
			component2.fontSize = 22;
			component2.alignment = (TextAnchor)4;
			((Graphic)component2).raycastTarget = false;
			UpdateStarVisual(component2, skillName);
			val2.transform.SetAsLastSibling();
			_log.Debug("Injected star for '" + skillName + "'.");
		}

		private static void OnRowClicked(GameObject row, string skillName)
		{
			_log.Debug("Row clicked — skill: '" + skillName + "'.");
			bool flag = FavoriteSkillsStore.Toggle(skillName);
			_log.Debug("'" + skillName + "' favorite toggled → " + (flag ? "ON" : "OFF") + ".");
			Transform obj = row.transform.Find("godzki_RowOverlay");
			UpdateOverlayColors((obj != null) ? ((Component)obj).GetComponent<Button>() : null, flag);
			Transform obj2 = row.transform.Find("godzki_FavoriteStar");
			UpdateStarVisual((obj2 != null) ? ((Component)obj2).GetComponent<Text>() : null, flag);
		}

		private static void UpdateStarVisual(Text? starText, string skillName)
		{
			UpdateStarVisual(starText, FavoriteSkillsStore.IsFavorite(skillName));
		}

		private static void UpdateStarVisual(Text? starText, bool isFavorited)
		{
			//IL_002e: 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)
			if (starText != null)
			{
				starText.text = (isFavorited ? "★" : "☆");
				((Graphic)starText).color = (isFavorited ? Config.FavoriteStarColor.Value : Config.UnfavoriteStarColor.Value);
			}
		}
	}
}
namespace SkillsPreview.App.Logging
{
	internal static class Log
	{
		internal readonly struct Scoped
		{
			private readonly string _tag;

			public Scoped(string tag)
			{
				_tag = tag;
			}

			internal void Debug(string message)
			{
				Log.Debug(_tag, message);
			}

			internal void Info(string message)
			{
				Log.Info(_tag, message);
			}

			internal void Warn(string message)
			{
				Log.Warn(_tag, message);
			}

			internal void Error(string message)
			{
				Log.Error(_tag, message);
			}
		}

		internal static Scoped For(string tag)
		{
			return new Scoped(tag);
		}

		internal static void Debug(string tag, string message)
		{
			if (Config.DebugMode.Value)
			{
				Debug.Log((object)("[SkillsPreview] · " + tag + " › " + message));
			}
		}

		internal static void Info(string tag, string message)
		{
			Debug.Log((object)("[SkillsPreview] ◆ " + tag + " › " + message));
		}

		internal static void Warn(string tag, string message)
		{
			Debug.LogWarning((object)("[SkillsPreview] ⚠ " + tag + " › " + message));
		}

		internal static void Error(string tag, string message)
		{
			Debug.LogError((object)("[SkillsPreview] ✖ " + tag + " › " + message));
		}
	}
}
namespace SkillsPreview.App.Locale
{
	internal interface ILabels
	{
		string SectionGeneral { get; }

		string SectionSkillsPanel { get; }

		string SectionHudPosition { get; }

		string SectionHudSize { get; }

		string SectionHudColors { get; }

		string SectionToast { get; }

		string SectionThemes { get; }

		string DebugMode { get; }

		string HudWidgetsVisible { get; }

		string ToggleOn { get; }

		string ToggleOff { get; }

		string StarFavorite { get; }

		string StarUnfavorite { get; }

		string PositionX { get; }

		string PositionY { get; }

		string HudScale { get; }

		string Width { get; }

		string Height { get; }

		string IconSize { get; }

		string FontLevel { get; }

		string FontProgress { get; }

		string WidgetSpacing { get; }

		string BorderThickness { get; }

		string CornerRadius { get; }

		string LevelUpDuration { get; }

		string ProgressBarVisible { get; }

		string ProgressBarHeight { get; }

		string ColorBorder { get; }

		string ColorBackground { get; }

		string ColorLevelText { get; }

		string ColorProgressText { get; }

		string ColorMaxText { get; }

		string ColorLevelUpFlash { get; }

		string ColorProgressBarBg { get; }

		string ToastEnabled { get; }

		string ToastPositionTop { get; }

		string ToastDuration { get; }

		string ToastFontSize { get; }

		string ToastColor { get; }

		string ThemeValheim { get; }

		string ThemeDark { get; }

		string ThemeMinimal { get; }

		string ThemeHighContrast { get; }

		string ResetAll { get; }

		string StatsTitle { get; }

		string StatsNoCharacter { get; }
	}
	internal static class L
	{
		private static readonly ILabels _en = new LabelsEn();

		private static readonly ILabels _pl = new LabelsPl();

		private static readonly ILabels _de = new LabelsDe();

		private static readonly ILabels _fr = new LabelsFr();

		private static readonly ILabels _uk = new LabelsUk();

		private static readonly ILabels _es = new LabelsEs();

		private static readonly ILabels _pt = new LabelsPt();

		private static readonly ILabels _it = new LabelsIt();

		public static ILabels Current => ((Localization.instance != null) ? Localization.instance.GetSelectedLanguage() : "English") switch
		{
			"Polish" => _pl, 
			"German" => _de, 
			"French" => _fr, 
			"Ukrainian" => _uk, 
			"Spanish" => _es, 
			"Portuguese_European" => _pt, 
			"Portuguese_Brazilian" => _pt, 
			"Italian" => _it, 
			_ => _en, 
		};
	}
	internal sealed class LabelsEn : ILabels
	{
		public string SectionGeneral => "General";

		public string SectionSkillsPanel => "Skills panel";

		public string SectionHudPosition => "HUD position";

		public string SectionHudSize => "HUD widget settings";

		public string SectionHudColors => "HUD widget colors";

		public string SectionToast => "Level-up banner";

		public string SectionThemes => "Theme presets";

		public string DebugMode => "Debug mode";

		public string HudWidgetsVisible => "Show HUD widgets";

		public string ToggleOn => "ON";

		public string ToggleOff => "OFF";

		public string StarFavorite => "Star — favorite";

		public string StarUnfavorite => "Star — not favorite";

		public string PositionX => "Position X";

		public string PositionY => "Position Y";

		public string HudScale => "Scale (%)";

		public string Width => "Width";

		public string Height => "Height";

		public string IconSize => "Icon size";

		public string FontLevel => "Font — level";

		public string FontProgress => "Font — progress";

		public string WidgetSpacing => "Widget spacing";

		public string BorderThickness => "Border thickness";

		public string CornerRadius => "Corner radius";

		public string LevelUpDuration => "Level-up flash (s)";

		public string ProgressBarVisible => "Progress bar";

		public string ProgressBarHeight => "Progress bar height";

		public string ColorBorder => "Border";

		public string ColorBackground => "Background";

		public string ColorLevelText => "Level text";

		public string ColorProgressText => "Progress text";

		public string ColorMaxText => "MAX text";

		public string ColorLevelUpFlash => "Level-up flash";

		public string ColorProgressBarBg => "Progress bar track";

		public string ToastEnabled => "Show banner on level-up";

		public string ToastPositionTop => "Distance from top (%)";

		public string ToastDuration => "Banner duration (s)";

		public string ToastFontSize => "Banner font size";

		public string ToastColor => "Banner color";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Dark";

		public string ThemeMinimal => "Minimal";

		public string ThemeHighContrast => "High contrast";

		public string ResetAll => "Reset all";

		public string StatsTitle => "Statistics";

		public string StatsNoCharacter => "Select a character";
	}
	internal sealed class LabelsPl : ILabels
	{
		public string SectionGeneral => "Ogólne";

		public string SectionSkillsPanel => "Panel umiejętności";

		public string SectionHudPosition => "Pozycja HUD";

		public string SectionHudSize => "Ustawienia widgetów HUD";

		public string SectionHudColors => "Kolory widgetów HUD";

		public string SectionToast => "Baner awansu";

		public string SectionThemes => "Motywy";

		public string DebugMode => "Tryb debug";

		public string HudWidgetsVisible => "Pokaż widgety HUD";

		public string ToggleOn => "Wł";

		public string ToggleOff => "Wył";

		public string StarFavorite => "Gwiazdka — ulubiony";

		public string StarUnfavorite => "Gwiazdka — nieulubiony";

		public string PositionX => "Pozycja X";

		public string PositionY => "Pozycja Y";

		public string HudScale => "Skala (%)";

		public string Width => "Szerokość";

		public string Height => "Wysokość";

		public string IconSize => "Rozmiar ikony";

		public string FontLevel => "Czcionka — poziom";

		public string FontProgress => "Czcionka — postęp";

		public string WidgetSpacing => "Odstęp między widgetami";

		public string BorderThickness => "Grubość obramowania";

		public string CornerRadius => "Zaokrąglenie narożników";

		public string LevelUpDuration => "Czas błysku awansu (s)";

		public string ProgressBarVisible => "Pasek postępu";

		public string ProgressBarHeight => "Wysokość paska postępu";

		public string ColorBorder => "Obramowanie";

		public string ColorBackground => "Tło";

		public string ColorLevelText => "Tekst poziomu";

		public string ColorProgressText => "Tekst postępu";

		public string ColorMaxText => "Tekst MAX";

		public string ColorLevelUpFlash => "Błysk awansu";

		public string ColorProgressBarBg => "Tło paska postępu";

		public string ToastEnabled => "Pokaż baner przy awansie";

		public string ToastPositionTop => "Odległość od góry (%)";

		public string ToastDuration => "Czas trwania banera (s)";

		public string ToastFontSize => "Rozmiar czcionki banera";

		public string ToastColor => "Kolor banera";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Ciemny";

		public string ThemeMinimal => "Minimalny";

		public string ThemeHighContrast => "Wysoki kontrast";

		public string ResetAll => "Przywróć domyślne";

		public string StatsTitle => "Statystyki";

		public string StatsNoCharacter => "Wybierz postać";
	}
	internal sealed class LabelsDe : ILabels
	{
		public string SectionGeneral => "Allgemein";

		public string SectionSkillsPanel => "Fähigkeiten-Panel";

		public string SectionHudPosition => "HUD-Position";

		public string SectionHudSize => "HUD-Widget-Einstellungen";

		public string SectionHudColors => "HUD-Widget-Farben";

		public string SectionToast => "Aufstiegs-Banner";

		public string SectionThemes => "Designvorlagen";

		public string DebugMode => "Debug-Modus";

		public string HudWidgetsVisible => "HUD-Widgets anzeigen";

		public string ToggleOn => "AN";

		public string ToggleOff => "AUS";

		public string StarFavorite => "Stern — Favorit";

		public string StarUnfavorite => "Stern — kein Favorit";

		public string PositionX => "Position X";

		public string PositionY => "Position Y";

		public string HudScale => "Skalierung (%)";

		public string Width => "Breite";

		public string Height => "Höhe";

		public string IconSize => "Symbolgröße";

		public string FontLevel => "Schrift — Stufe";

		public string FontProgress => "Schrift — Fortschritt";

		public string WidgetSpacing => "Widget-Abstand";

		public string BorderThickness => "Rahmendicke";

		public string CornerRadius => "Eckenradius";

		public string LevelUpDuration => "Aufstiegsblitz (s)";

		public string ProgressBarVisible => "Fortschrittsleiste";

		public string ProgressBarHeight => "Höhe der Fortschrittsleiste";

		public string ColorBorder => "Rahmen";

		public string ColorBackground => "Hintergrund";

		public string ColorLevelText => "Stufentext";

		public string ColorProgressText => "Fortschrittstext";

		public string ColorMaxText => "MAX-Text";

		public string ColorLevelUpFlash => "Aufstiegsblitz";

		public string ColorProgressBarBg => "Fortschrittsleisten-Schiene";

		public string ToastEnabled => "Banner bei Aufstieg zeigen";

		public string ToastPositionTop => "Abstand vom oberen Rand (%)";

		public string ToastDuration => "Banner-Dauer (s)";

		public string ToastFontSize => "Banner-Schriftgröße";

		public string ToastColor => "Banner-Farbe";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Dunkel";

		public string ThemeMinimal => "Minimal";

		public string ThemeHighContrast => "Hoher Kontrast";

		public string ResetAll => "Alle zurücksetzen";

		public string StatsTitle => "Statistiken";

		public string StatsNoCharacter => "Charakter auswählen";
	}
	internal sealed class LabelsFr : ILabels
	{
		public string SectionGeneral => "Général";

		public string SectionSkillsPanel => "Panneau des compétences";

		public string SectionHudPosition => "Position du HUD";

		public string SectionHudSize => "Paramètres des widgets HUD";

		public string SectionHudColors => "Couleurs des widgets HUD";

		public string SectionToast => "Bannière de montée";

		public string SectionThemes => "Thèmes";

		public string DebugMode => "Mode débogage";

		public string HudWidgetsVisible => "Afficher les widgets HUD";

		public string ToggleOn => "ON";

		public string ToggleOff => "OFF";

		public string StarFavorite => "Étoile — favori";

		public string StarUnfavorite => "Étoile — non favori";

		public string PositionX => "Position X";

		public string PositionY => "Position Y";

		public string HudScale => "Échelle (%)";

		public string Width => "Largeur";

		public string Height => "Hauteur";

		public string IconSize => "Taille de l'icône";

		public string FontLevel => "Police — niveau";

		public string FontProgress => "Police — progression";

		public string WidgetSpacing => "Espacement des widgets";

		public string BorderThickness => "Épaisseur du contour";

		public string CornerRadius => "Rayon des coins";

		public string LevelUpDuration => "Flash de montée (s)";

		public string ProgressBarVisible => "Barre de progression";

		public string ProgressBarHeight => "Hauteur de la barre";

		public string ColorBorder => "Contour";

		public string ColorBackground => "Arrière-plan";

		public string ColorLevelText => "Texte du niveau";

		public string ColorProgressText => "Texte de progression";

		public string ColorMaxText => "Texte MAX";

		public string ColorLevelUpFlash => "Flash de montée";

		public string ColorProgressBarBg => "Piste de la barre";

		public string ToastEnabled => "Afficher la bannière à la montée";

		public string ToastPositionTop => "Distance depuis le haut (%)";

		public string ToastDuration => "Durée de la bannière (s)";

		public string ToastFontSize => "Taille de police de la bannière";

		public string ToastColor => "Couleur de la bannière";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Sombre";

		public string ThemeMinimal => "Minimal";

		public string ThemeHighContrast => "Contraste élevé";

		public string ResetAll => "Tout réinitialiser";

		public string StatsTitle => "Statistiques";

		public string StatsNoCharacter => "Sélectionner un personnage";
	}
	internal sealed class LabelsUk : ILabels
	{
		public string SectionGeneral => "Загальне";

		public string SectionSkillsPanel => "Панель навичок";

		public string SectionHudPosition => "Позиція HUD";

		public string SectionHudSize => "Налаштування віджетів HUD";

		public string SectionHudColors => "Кольори віджетів HUD";

		public string SectionToast => "Банер підвищення";

		public string SectionThemes => "Теми";

		public string DebugMode => "Режим налагодження";

		public string HudWidgetsVisible => "Показати віджети HUD";

		public string ToggleOn => "Увімк";

		public string ToggleOff => "Вимкн";

		public string StarFavorite => "Зірка — улюблений";

		public string StarUnfavorite => "Зірка — не улюблений";

		public string PositionX => "Позиція X";

		public string PositionY => "Позиція Y";

		public string HudScale => "Масштаб (%)";

		public string Width => "Ширина";

		public string Height => "Висота";

		public string IconSize => "Розмір іконки";

		public string FontLevel => "Шрифт — рівень";

		public string FontProgress => "Шрифт — прогрес";

		public string WidgetSpacing => "Відступ між віджетами";

		public string BorderThickness => "Товщина рамки";

		public string CornerRadius => "Радіус кутів";

		public string LevelUpDuration => "Спалах підвищення (с)";

		public string ProgressBarVisible => "Смуга прогресу";

		public string ProgressBarHeight => "Висота смуги прогресу";

		public string ColorBorder => "Рамка";

		public string ColorBackground => "Фон";

		public string ColorLevelText => "Текст рівня";

		public string ColorProgressText => "Текст прогресу";

		public string ColorMaxText => "Текст MAX";

		public string ColorLevelUpFlash => "Спалах підвищення";

		public string ColorProgressBarBg => "Доріжка смуги прогресу";

		public string ToastEnabled => "Показувати банер при підвищенні";

		public string ToastPositionTop => "Відстань від верху (%)";

		public string ToastDuration => "Тривалість банера (с)";

		public string ToastFontSize => "Розмір шрифту банера";

		public string ToastColor => "Колір банера";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Темна";

		public string ThemeMinimal => "Мінімальна";

		public string ThemeHighContrast => "Високий контраст";

		public string ResetAll => "Скинути все";

		public string StatsTitle => "Статистика";

		public string StatsNoCharacter => "Оберіть персонажа";
	}
	internal sealed class LabelsEs : ILabels
	{
		public string SectionGeneral => "General";

		public string SectionSkillsPanel => "Panel de habilidades";

		public string SectionHudPosition => "Posición del HUD";

		public string SectionHudSize => "Ajustes de widgets HUD";

		public string SectionHudColors => "Colores de widgets HUD";

		public string SectionToast => "Banner de subida de nivel";

		public string SectionThemes => "Temas";

		public string DebugMode => "Modo depuración";

		public string HudWidgetsVisible => "Mostrar widgets HUD";

		public string ToggleOn => "ON";

		public string ToggleOff => "OFF";

		public string StarFavorite => "Estrella — favorito";

		public string StarUnfavorite => "Estrella — no favorito";

		public string PositionX => "Posición X";

		public string PositionY => "Posición Y";

		public string HudScale => "Escala (%)";

		public string Width => "Anchura";

		public string Height => "Altura";

		public string IconSize => "Tamaño del icono";

		public string FontLevel => "Fuente — nivel";

		public string FontProgress => "Fuente — progreso";

		public string WidgetSpacing => "Espaciado de widgets";

		public string BorderThickness => "Grosor del borde";

		public string CornerRadius => "Radio de esquinas";

		public string LevelUpDuration => "Destello de subida (s)";

		public string ProgressBarVisible => "Barra de progreso";

		public string ProgressBarHeight => "Altura de la barra";

		public string ColorBorder => "Borde";

		public string ColorBackground => "Fondo";

		public string ColorLevelText => "Texto del nivel";

		public string ColorProgressText => "Texto de progreso";

		public string ColorMaxText => "Texto MAX";

		public string ColorLevelUpFlash => "Destello de subida";

		public string ColorProgressBarBg => "Pista de la barra";

		public string ToastEnabled => "Mostrar banner al subir nivel";

		public string ToastPositionTop => "Distancia desde arriba (%)";

		public string ToastDuration => "Duración del banner (s)";

		public string ToastFontSize => "Tamaño de fuente del banner";

		public string ToastColor => "Color del banner";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Oscuro";

		public string ThemeMinimal => "Minimal";

		public string ThemeHighContrast => "Alto contraste";

		public string ResetAll => "Restablecer todo";

		public string StatsTitle => "Estadísticas";

		public string StatsNoCharacter => "Selecciona un personaje";
	}
	internal sealed class LabelsPt : ILabels
	{
		public string SectionGeneral => "Geral";

		public string SectionSkillsPanel => "Painel de habilidades";

		public string SectionHudPosition => "Posição do HUD";

		public string SectionHudSize => "Ajustes dos widgets HUD";

		public string SectionHudColors => "Cores dos widgets HUD";

		public string SectionToast => "Banner de evolução";

		public string SectionThemes => "Temas";

		public string DebugMode => "Modo de depuração";

		public string HudWidgetsVisible => "Mostrar widgets HUD";

		public string ToggleOn => "ON";

		public string ToggleOff => "OFF";

		public string StarFavorite => "Estrela — favorito";

		public string StarUnfavorite => "Estrela — não favorito";

		public string PositionX => "Posição X";

		public string PositionY => "Posição Y";

		public string HudScale => "Escala (%)";

		public string Width => "Largura";

		public string Height => "Altura";

		public string IconSize => "Tamanho do ícone";

		public string FontLevel => "Fonte — nível";

		public string FontProgress => "Fonte — progresso";

		public string WidgetSpacing => "Espaçamento dos widgets";

		public string BorderThickness => "Espessura da borda";

		public string CornerRadius => "Raio dos cantos";

		public string LevelUpDuration => "Flash de evolução (s)";

		public string ProgressBarVisible => "Barra de progresso";

		public string ProgressBarHeight => "Altura da barra";

		public string ColorBorder => "Borda";

		public string ColorBackground => "Fundo";

		public string ColorLevelText => "Texto do nível";

		public string ColorProgressText => "Texto de progresso";

		public string ColorMaxText => "Texto MAX";

		public string ColorLevelUpFlash => "Flash de evolução";

		public string ColorProgressBarBg => "Trilho da barra";

		public string ToastEnabled => "Mostrar banner ao subir de nível";

		public string ToastPositionTop => "Distância do topo (%)";

		public string ToastDuration => "Duração do banner (s)";

		public string ToastFontSize => "Tamanho da fonte do banner";

		public string ToastColor => "Cor do banner";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Escuro";

		public string ThemeMinimal => "Minimal";

		public string ThemeHighContrast => "Alto contraste";

		public string ResetAll => "Restaurar tudo";

		public string StatsTitle => "Estatísticas";

		public string StatsNoCharacter => "Selecione um personagem";
	}
	internal sealed class LabelsIt : ILabels
	{
		public string SectionGeneral => "Generale";

		public string SectionSkillsPanel => "Pannello abilità";

		public string SectionHudPosition => "Posizione HUD";

		public string SectionHudSize => "Impostazioni widget HUD";

		public string SectionHudColors => "Colori widget HUD";

		public string SectionToast => "Banner di livello";

		public string SectionThemes => "Temi";

		public string DebugMode => "Modalità debug";

		public string HudWidgetsVisible => "Mostra widget HUD";

		public string ToggleOn => "ON";

		public string ToggleOff => "OFF";

		public string StarFavorite => "Stella — preferito";

		public string StarUnfavorite => "Stella — non preferito";

		public string PositionX => "Posizione X";

		public string PositionY => "Posizione Y";

		public string HudScale => "Scala (%)";

		public string Width => "Larghezza";

		public string Height => "Altezza";

		public string IconSize => "Dimensione icona";

		public string FontLevel => "Carattere — livello";

		public string FontProgress => "Carattere — progresso";

		public string WidgetSpacing => "Spaziatura widget";

		public string BorderThickness => "Spessore bordo";

		public string CornerRadius => "Raggio angoli";

		public string LevelUpDuration => "Flash di livello (s)";

		public string ProgressBarVisible => "Barra di progresso";

		public string ProgressBarHeight => "Altezza della barra";

		public string ColorBorder => "Bordo";

		public string ColorBackground => "Sfondo";

		public string ColorLevelText => "Testo livello";

		public string ColorProgressText => "Testo progresso";

		public string ColorMaxText => "Testo MAX";

		public string ColorLevelUpFlash => "Flash di livello";

		public string ColorProgressBarBg => "Pista della barra";

		public string ToastEnabled => "Mostra banner al level-up";

		public string ToastPositionTop => "Distanza dall'alto (%)";

		public string ToastDuration => "Durata banner (s)";

		public string ToastFontSize => "Dimensione carattere banner";

		public string ToastColor => "Colore banner";

		public string ThemeValheim => "Valheim";

		public string ThemeDark => "Scuro";

		public string ThemeMinimal => "Minimal";

		public string ThemeHighContrast => "Alto contrasto";

		public string ResetAll => "Ripristina tutto";

		public string StatsTitle => "Statistiche";

		public string StatsNoCharacter => "Seleziona un personaggio";
	}
}
namespace SkillsPreview.App.Data
{
	public class ColorPicker
	{
		internal static readonly Color[] Palette = (Color[])(object)new Color[96]
		{
			Color.white,
			new Color(0.92f, 0.92f, 0.92f),
			new Color(0.83f, 0.83f, 0.83f),
			new Color(0.75f, 0.75f, 0.75f),
			new Color(0.67f, 0.67f, 0.67f),
			new Color(0.58f, 0.58f, 0.58f),
			new Color(0.5f, 0.5f, 0.5f),
			new Color(0.42f, 0.42f, 0.42f),
			new Color(0.33f, 0.33f, 0.33f),
			new Color(0.25f, 0.25f, 0.25f),
			new Color(0.17f, 0.17f, 0.17f),
			Color.black,
			new Color(1f, 0f, 0f),
			new Color(1f, 0.42f, 0f),
			new Color(1f, 0.83f, 0f),
			new Color(0.58f, 1f, 0f),
			new Color(0.17f, 1f, 0f),
			new Color(0f, 1f, 0.25f),
			new Color(0f, 1f, 0.67f),
			new Color(0f, 0.83f, 1f),
			new Color(0f, 0.42f, 1f),
			new Color(0.17f, 0f, 1f),
			new Color(0.58f, 0f, 1f),
			new Color(1f, 0f, 0.83f),
			new Color(1f, 0.5f, 0.5f),
			new Color(1f, 0.71f, 0.5f),
			new Color(1f, 0.92f, 0.5f),
			new Color(0.79f, 1f, 0.5f),
			new Color(0.58f, 1f, 0.5f),
			new Color(0.5f, 1f, 0.62f),
			new Color(0.5f, 1f, 0.83f),
			new Color(0.5f, 0.92f, 1f),
			new Color(0.5f, 0.71f, 1f),
			new Color(0.58f, 0.5f, 1f),
			new Color(0.79f, 0.5f, 1f),
			new Color(1f, 0.5f, 0.92f),
			new Color(0.7f, 0f, 0f),
			new Color(0.7f, 0.29f, 0f),
			new Color(0.7f, 0.58f, 0f),
			new Color(0.41f, 0.7f, 0f),
			new Color(0.12f, 0.7f, 0f),
			new Color(0f, 0.7f, 0.17f),
			new Color(0f, 0.7f, 0.47f),
			new Color(0f, 0.58f, 0.7f),
			new Color(0f, 0.29f, 0.7f),
			new Color(0.12f, 0f, 0.7f),
			new Color(0.41f, 0f, 0.7f),
			new Color(0.7f, 0f, 0.58f),
			new Color(0.8f, 0.24f, 0.24f),
			new Color(0.8f, 0.52f, 0.24f),
			new Color(0.8f, 0.8f, 0.24f),
			new Color(0.52f, 0.8f, 0.24f),
			new Color(0.24f, 0.8f, 0.24f),
			new Color(0.24f, 0.8f, 0.52f),
			new Color(0.24f, 0.8f, 0.8f),
			new Color(0.24f, 0.52f, 0.8f),
			new Color(0.24f, 0.24f, 0.8f),
			new Color(0.52f, 0.24f, 0.8f),
			new Color(0.8f, 0.24f, 0.8f),
			new Color(0.8f, 0.24f, 0.52f),
			new Color(0.4f, 0f, 0f),
			new Color(0.4f, 0.17f, 0f),
			new Color(0.4f, 0.33f, 0f),
			new Color(0.23f, 0.4f, 0f),
			new Color(0.07f, 0.4f, 0f),
			new Color(0f, 0.4f, 0.1f),
			new Color(0f, 0.4f, 0.27f),
			new Color(0f, 0.33f, 0.4f),
			new Color(0f, 0.17f, 0.4f),
			new Color(0.07f, 0f, 0.4f),
			new Color(0.23f, 0f, 0.4f),
			new Color(0.4f, 0f, 0.33f),
			new Color(0.95f, 0.67f, 0.67f),
			new Color(0.95f, 0.81f, 0.67f),
			new Color(0.95f, 0.95f, 0.67f),
			new Color(0.81f, 0.95f, 0.67f),
			new Color(0.67f, 0.95f, 0.67f),
			new Color(0.67f, 0.95f, 0.81f),
			new Color(0.67f, 0.95f, 0.95f),
			new Color(0.67f, 0.81f, 0.95f),
			new Color(0.67f, 0.67f, 0.95f),
			new Color(0.81f, 0.67f, 0.95f),
			new Color(0.95f, 0.67f, 0.95f),
			new Color(0.95f, 0.67f, 0.81f),
			new Color(0.82f, 0.71f, 0.45f),
			new Color(0.56f, 0.35f, 0.15f),
			new Color(0.25f, 0.18f, 0.1f),
			new Color(0.15f, 0.12f, 0.08f),
			new Color(0.7f, 0.85f, 1f),
			new Color(0.3f, 0.6f, 0.9f),
			new Color(0.9f, 0.8f, 0.6f),
			new Color(0.55f, 0.8f, 0.45f),
			new Color(1f, 0.9f, 0.4f),
			new Color(0.9f, 0.4f, 0.2f),
			new Color(0.5f, 0.2f, 0.7f),
			new Color(0.25f, 0.65f, 0.75f)
		};
	}
	internal static class Config
	{
		private const string SectionGeneral = "1 - General";

		private const string SectionVisuals = "2 - Skill Panel";

		private const string SectionHud = "3 - HUD Position";

		private const string SectionHudWidget = "4 - HUD Widget";

		private const string SectionToast = "5 - Level-up Toast";

		internal static ConfigEntry<bool> DebugMode;

		internal static ConfigEntry<bool> HudWidgetsVisible;

		internal static ConfigEntry<Color> FavoriteStarColor;

		internal static ConfigEntry<Color> UnfavoriteStarColor;

		internal static ConfigEntry<float> HudPositionX;

		internal static ConfigEntry<float> HudPositionY;

		internal static ConfigEntry<float> HudScale;

		internal static ConfigEntry<float> WidgetWidth;

		internal static ConfigEntry<float> WidgetHeight;

		internal static ConfigEntry<float> WidgetIconSize;

		internal static ConfigEntry<int> WidgetFontSizeLevel;

		internal static ConfigEntry<int> WidgetFontSizeProgress;

		internal static ConfigEntry<float> WidgetSpacing;

		internal static ConfigEntry<float> WidgetBorderSize;

		internal static ConfigEntry<int> WidgetCornerRadius;

		internal static ConfigEntry<Color> WidgetBorderColor;

		internal static ConfigEntry<Color> WidgetBgColor;

		internal static ConfigEntry<Color> WidgetLevelColor;

		internal static ConfigEntry<Color> WidgetProgressColor;

		internal static ConfigEntry<Color> WidgetProgressMaxColor;

		internal static ConfigEntry<Color> WidgetLevelUpColor;

		internal static ConfigEntry<float> WidgetLevelUpDuration;

		internal static ConfigEntry<bool> WidgetProgressBarVisible;

		internal static ConfigEntry<float> WidgetProgressBarHeight;

		internal static ConfigEntry<Color> WidgetProgressBarBgColor;

		internal static ConfigEntry<bool> ToastEnabled;

		internal static ConfigEntry<float> ToastPositionTopPercent;

		internal static ConfigEntry<float> ToastDuration;

		internal static ConfigEntry<int> ToastFontSize;

		internal static ConfigEntry<Color> ToastColor;

		internal static void Bind(BaseUnityPlugin plugin)
		{
			//IL_0072: 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_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: 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_04d8: Unknown result type (might be due to invalid IL or missing references)
			bool flag = Version.Parse("0.5.2").Major < 1;
			DebugMode = plugin.Config.Bind<bool>("1 - General", "DebugMode", flag, "Enable verbose debug logging in the BepInEx console.");
			HudWidgetsVisible = plugin.Config.Bind<bool>("1 - General", "HudWidgetsVisible", true, "Show or hide the favorite skill widgets in the HUD. Does not affect the skills panel.");
			FavoriteStarColor = plugin.Config.Bind<Color>("2 - Skill Panel", "FavoriteStarColor", new Color(1f, 0.85f, 0f), "Color of the star icon when a skill is marked as a favorite.");
			UnfavoriteStarColor = plugin.Config.Bind<Color>("2 - Skill Panel", "UnfavoriteStarColor", new Color(0.55f, 0.55f, 0.55f), "Color of the star icon when a skill is not marked as a favorite.");
			HudPositionX = plugin.Config.Bind<float>("3 - HUD Position", "PositionX", 150f, "Horizontal position of the favorite skills panel (pixels from the left edge).");
			HudPositionY = plugin.Config.Bind<float>("3 - HUD Position", "PositionY", 200f, "Vertical position of the favorite skills panel (pixels from the bottom edge).");
			HudScale = plugin.Config.Bind<float>("3 - HUD Position", "Scale", 100f, "Scale of the HUD widget panel in percent (50–150). Does not affect individual widget settings.");
			WidgetWidth = plugin.Config.Bind<float>("4 - HUD Widget", "Width", 60f, "Width of each skill widget in pixels.");
			WidgetHeight = plugin.Config.Bind<float>("4 - HUD Widget", "Height", 86f, "Height of each skill widget in pixels.");
			WidgetIconSize = plugin.Config.Bind<float>("4 - HUD Widget", "IconSize", 40f, "Size (width and height) of the skill icon inside the widget.");
			WidgetFontSizeLevel = plugin.Config.Bind<int>("4 - HUD Widget", "FontSizeLevel", 13, "Font size for the skill level text (e.g. \"Lv.45\").");
			WidgetFontSizeProgress = plugin.Config.Bind<int>("4 - HUD Widget", "FontSizeProgress", 11, "Font size for the progress percentage text (e.g. \"72.00%\" or \"MAX\").");
			WidgetSpacing = plugin.Config.Bind<float>("4 - HUD Widget", "Spacing", 6f, "Gap between widgets in the horizontal panel.");
			WidgetBorderSize = plugin.Config.Bind<float>("4 - HUD Widget", "BorderSize", 2f, "Thickness of the decorative border around each widget in pixels.");
			WidgetCornerRadius = plugin.Config.Bind<int>("4 - HUD Widget", "CornerRadius", 6, "Radius of the rounded corners in pixels. Set to 0 to disable rounding.");
			WidgetBorderColor = plugin.Config.Bind<Color>("4 - HUD Widget", "BorderColor", new Color(0.56f, 0.37f, 0.17f, 0.95f), "Border color. Default is a warm Valheim-brown.");
			WidgetBgColor = plugin.Config.Bind<Color>("4 - HUD Widget", "BackgroundColor", new Color(0.05f, 0.04f, 0.03f, 0.88f), "Background color (RGBA) of the widget interior.");
			WidgetLevelColor = plugin.Config.Bind<Color>("4 - HUD Widget", "LevelColor", new Color(1f, 1f, 1f, 1f), "Text color for the skill level line.");
			WidgetProgressColor = plugin.Config.Bind<Color>("4 - HUD Widget", "ProgressColor", new Color(0.85f, 0.85f, 0.85f, 0.85f), "Text color for the progress percentage.");
			WidgetProgressMaxColor = plugin.Config.Bind<Color>("4 - HUD Widget", "ProgressMaxColor", new Color(1f, 0.85f, 0f, 1f), "Text color for \"MAX\" when the skill reaches level 100.");
			WidgetLevelUpColor = plugin.Config.Bind<Color>("4 - HUD Widget", "LevelUpColor", new Color(1f, 1f, 0.6f, 1f), "Border flash color when a skill levels up.");
			WidgetLevelUpDuration = plugin.Config.Bind<float>("4 - HUD Widget", "LevelUpDuration", 1.5f, "How long (seconds) the level-up flash effect lasts.");
			WidgetProgressBarVisible = plugin.Config.Bind<bool>("4 - HUD Widget", "ProgressBarVisible", true, "Show a thin progress bar at the bottom of each widget.");
			WidgetProgressBarHeight = plugin.Config.Bind<float>("4 - HUD Widget", "ProgressBarHeight", 4f, "Height in pixels of the progress bar at the bottom of each widget.");
			WidgetProgressBarBgColor = plugin.Config.Bind<Color>("4 - HUD Widget", "ProgressBarBgColor", new Color(0f, 0f, 0f, 0.55f), "Background colour (RGBA) of the progress bar track.");
			ToastEnabled = plugin.Config.Bind<bool>("5 - Level-up Toast", "Enabled", true, "Show a Valheim-style banner in the centre of the screen when a favourited skill levels up.");
			ToastPositionTopPercent = plugin.Config.Bind<float>("5 - Level-up Toast", "PositionTopPercent", 20f, "Vertical position of the banner as a percentage of screen height measured from the top (0–50).");
			ToastDuration = plugin.Config.Bind<float>("5 - Level-up Toast", "Duration", 3f, "How long (seconds) the level-up banner stays on screen, including fade-in/out.");
			ToastFontSize = plugin.Config.Bind<int>("5 - Level-up Toast", "FontSize", 28, "Font size of the level-up banner text.");
			ToastColor = plugin.Config.Bind<Color>("5 - Level-up Toast", "Color", new Color(1f, 0.78f, 0.3f, 1f), "Banner text colour. Default is a warm Valheim gold.");
		}
	}
	internal static class Info
	{
		internal const string PluginGuid = "godzki.skills_preview";

		internal const string PluginName = "Skills Preview";

		internal const string PluginVersion = "0.5.2";
	}
	internal static class SkillMath
	{
		internal const int MaxLevel = 100;

		internal static float NextLevelRequirement(float level)
		{
			return Mathf.Pow(Mathf.Floor(level + 1f), 1.5f) * 0.5f + 0.5f;
		}

		internal static float LevelProgress(Skill skill)
		{
			return LevelProgress(skill.m_level, skill.m_accumulator);
		}

		internal static float LevelProgress(float level, float accumulator)
		{
			if (IsMaxLevel(level))
			{
				return 1f;
			}
			float num = NextLevelRequirement(level);
			return Mathf.Clamp01(accumulator / num);
		}

		internal static bool IsMaxLevel(float level)
		{
			return level >= 100f;
		}
	}
	internal static class ThemePresets
	{
		internal sealed class Theme
		{
			public string Key { get; init; } = "";


			public Color FavoriteStar { get; init; }

			public Color UnfavoriteStar { get; init; }

			public Color Border { get; init; }

			public Color Background { get; init; }

			public Color LevelText { get; init; }

			public Color ProgressText { get; init; }

			public Color ProgressMaxText { get; init; }

			public Color LevelUpFlash { get; init; }

			public Color ProgressBarBg { get; init; }

			public Color Toast { get; init; }

			public float BorderSize { get; init; }

			public int CornerRadius { get; init; }

			public float ProgressBarHeight { get; init; }

			public bool ProgressBarVisible { get; init; }
		}

		internal static readonly Theme Valheim = new Theme
		{
			Key = "Valheim",
			FavoriteStar = new Color(1f, 0.85f, 0f, 1f),
			UnfavoriteStar = new Color(0.55f, 0.55f, 0.55f, 1f),
			Border = new Color(0.56f, 0.37f, 0.17f, 0.95f),
			Background = new Color(0.05f, 0.04f, 0.03f, 0.88f),
			LevelText = new Color(1f, 1f, 1f, 1f),
			ProgressText = new Color(0.85f, 0.85f, 0.85f, 0.85f),
			ProgressMaxText = new Color(1f, 0.85f, 0f, 1f),
			LevelUpFlash = new Color(1f, 1f, 0.6f, 1f),
			ProgressBarBg = new Color(0f, 0f, 0f, 0.55f),
			Toast = new Color(1f, 0.78f, 0.3f, 1f),
			BorderSize = 2f,
			CornerRadius = 6,
			ProgressBarHeight = 4f,
			ProgressBarVisible = true
		};

		internal static readonly Theme Dark = new Theme
		{
			Key = "Dark",
			FavoriteStar = new Color(0.95f, 0.95f, 1f, 1f),
			UnfavoriteStar = new Color(0.4f, 0.4f, 0.4f, 1f),
			Border = new Color(0.15f, 0.15f, 0.18f, 0.95f),
			Background = new Color(0.05f, 0.05f, 0.07f, 0.92f),
			LevelText = new Color(0.92f, 0.92f, 0.95f, 1f),
			ProgressText = new Color(0.7f, 0.7f, 0.75f, 0.9f),
			ProgressMaxText = new Color(0.8f, 0.85f, 1f, 1f),
			LevelUpFlash = new Color(0.7f, 0.85f, 1f, 1f),
			ProgressBarBg = new Color(0f, 0f, 0f, 0.6f),
			Toast = new Color(0.85f, 0.9f, 1f, 1f),
			BorderSize = 1f,
			CornerRadius = 4,
			ProgressBarHeight = 3f,
			ProgressBarVisible = true
		};

		internal static readonly Theme Minimal = new Theme
		{
			Key = "Minimal",
			FavoriteStar = new Color(1f, 0.85f, 0f, 1f),
			UnfavoriteStar = new Color(0.45f, 0.45f, 0.45f, 1f),
			Border = new Color(0f, 0f, 0f, 0f),
			Background = new Color(0f, 0f, 0f, 0.4f),
			LevelText = new Color(1f, 1f, 1f, 0.95f),
			ProgressText = new Color(0.85f, 0.85f, 0.85f, 0.7f),
			ProgressMaxText = new Color(1f, 0.9f, 0.4f, 0.95f),
			LevelUpFlash = new Color(1f, 1f, 0.5f, 0.9f),
			ProgressBarBg = new Color(0f, 0f, 0f, 0.3f),
			Toast = new Color(1f, 0.95f, 0.8f, 0.95f),
			BorderSize = 0f,
			CornerRadius = 3,
			ProgressBarHeight = 2f,
			ProgressBarVisible = true
		};

		internal static readonly Theme HighContrast = new Theme
		{
			Key = "HighContrast",
			FavoriteStar = new Color(1f, 0.85f, 0f, 1f),
			UnfavoriteStar = new Color(0.6f, 0.6f, 0.6f, 1f),
			Border = new Color(1f, 1f, 1f, 1f),
			Background = new Color(0f, 0f, 0f, 1f),
			LevelText = new Color(1f, 1f, 1f, 1f),
			ProgressText = new Color(1f, 1f, 0.4f, 1f),
			ProgressMaxText = new Color(0f, 1f, 0.4f, 1f),
			LevelUpFlash = new Color(0f, 1f, 0f, 1f),
			ProgressBarBg = new Color(0.15f, 0.15f, 0.15f, 1f),
			Toast = new Color(1f, 1f, 0.4f, 1f),
			BorderSize = 3f,
			CornerRadius = 0,
			ProgressBarHeight = 5f,
			ProgressBarVisible = true
		};

		internal static void Apply(Theme theme)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			Config.FavoriteStarColor.Value = theme.FavoriteStar;
			Config.UnfavoriteStarColor.Value = theme.UnfavoriteStar;
			Config.WidgetBorderColor.Value = theme.Border;
			Config.WidgetBgColor.Value = theme.Background;
			Config.WidgetLevelColor.Value = theme.LevelText;
			Config.WidgetProgressColor.Value = theme.ProgressText;
			Config.WidgetProgressMaxColor.Value = theme.ProgressMaxText;
			Config.WidgetLevelUpColor.Value = theme.LevelUpFlash;
			Config.WidgetProgressBarBgColor.Value = theme.ProgressBarBg;
			Config.ToastColor.Value = theme.Toast;
			Config.WidgetBorderSize.Value = theme.BorderSize;
			Config.WidgetCornerRadius.Value = theme.CornerRadius;
			Config.WidgetProgressBarHeight.Value = theme.ProgressBarHeight;
			Config.WidgetProgressBarVisible.Value = theme.ProgressBarVisible;
		}
	}
}