using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Assets.RoR2.Scripts.Platform;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.AI;
using HG;
using HG.Reflection;
using HarmonyLib;
using HighCommand.Army;
using HighCommand.Client;
using HighCommand.Dev;
using HighCommand.Mode;
using HighCommand.Net;
using HighCommand.Orders;
using HighCommand.UI;
using Microsoft.CodeAnalysis;
using RiskOfOptions;
using RiskOfOptions.OptionConfigs;
using RiskOfOptions.Options;
using RoR2;
using RoR2.CharacterAI;
using RoR2.ContentManagement;
using RoR2.Navigation;
using RoR2.Stats;
using RoR2.UI;
using RoR2.UI.MainMenu;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.Profiling;
using UnityEngine.Rendering;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: OptIn]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HighCommand
{
	internal static class AiTuning
	{
		private sealed class NameSet
		{
			private string source;

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

			internal bool Contains(ConfigEntry<string> entry, string name)
			{
				string text = ((entry != null) ? (entry.Value ?? string.Empty) : string.Empty);
				if ((object)text != source)
				{
					source = text;
					names.Clear();
					string[] array = text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
					for (int i = 0; i < array.Length; i++)
					{
						string text2 = array[i].Trim();
						if (text2.Length > 0)
						{
							names.Add(text2);
						}
					}
				}
				if (name != null)
				{
					return names.Contains(name);
				}
				return false;
			}
		}

		internal static ConfigEntry<float> ThinkInterval;

		internal static ConfigEntry<float> HoldRadius;

		internal static ConfigEntry<float> AttackMoveRange;

		internal static ConfigEntry<float> AttackMoveLeash;

		internal static ConfigEntry<float> AssistRange;

		internal static ConfigEntry<float> FocusFireWeight;

		internal static ConfigEntry<float> UnreachableSeconds;

		internal static ConfigEntry<float> BurstHoardSeconds;

		internal static ConfigEntry<float> FleeMaxSeconds;

		internal static ConfigEntry<float> FleeCooldownSeconds;

		internal static ConfigEntry<float> StuckSeconds;

		internal static ConfigEntry<bool> UnstuckTeleport;

		internal static ConfigEntry<float> TeleportAfterSeconds;

		internal static ConfigEntry<bool> AutoEquipment;

		internal static ConfigEntry<string> EquipmentInCombat;

		internal static ConfigEntry<string> EquipmentWhenHurt;

		internal static ConfigEntry<string> EquipmentVsBoss;

		private static readonly NameSet InCombat = new NameSet();

		private static readonly NameSet WhenHurt = new NameSet();

		private static readonly NameSet VsBoss = new NameSet();

		internal static void Bind(ConfigFile cfg)
		{
			ThinkInterval = F(cfg, "ThinkInterval", 0.1f, 0.05f, 0.5f, "Seconds between two decisions of a hero (target, order, retreat). Lower = quicker reactions, a little more CPU.");
			HoldRadius = F(cfg, "HoldRadius", 4f, 0f, 15f, "Hold position: how far a hero may step from its spot to hit an enemy (melee heroes). Pushed farther, it walks back. Skills that move the hero are not used.");
			AttackMoveRange = F(cfg, "AttackMoveRange", 40f, 10f, 100f, "Attack-move and patrol: enemies this close to a marching hero are fought.");
			AttackMoveLeash = F(cfg, "AttackMoveLeash", 30f, 5f, 100f, "Attack-move and patrol: how far a hero may chase from the place where it met the enemy; then it goes on.");
			AssistRange = F(cfg, "AssistRange", 45f, 0f, 150f, "A hero without orders joins the fights of its friends this close: monsters already fighting the army count even when this hero does not see them.");
			FocusFireWeight = F(cfg, "FocusFireWeight", 1f, 0f, 3f, "How much heroes prefer the enemy their friends already fire at (focus fire). 0 = every hero picks its own target.");
			UnreachableSeconds = F(cfg, "UnreachableSeconds", 4f, 1f, 20f, "A hero that neither hits nor gets closer to its target for this long gives it up for a while (a flier over a pit, a monster on a ledge) and takes another one.");
			BurstHoardSeconds = F(cfg, "BurstHoardSeconds", 8f, 0f, 60f, "Skills with the profile rule 'burst' wait for a group or a big target, but not longer than this many seconds of a fight.");
			FleeMaxSeconds = F(cfg, "FleeMaxSeconds", 15f, 3f, 60f, "A hurt hero runs from a fight at most this long, then fights again whatever its health.");
			FleeCooldownSeconds = F(cfg, "FleeCooldownSeconds", 6f, 0f, 60f, "After running away for the longest allowed time a hero does not run again for this many seconds.");
			StuckSeconds = F(cfg, "StuckSeconds", 2f, 0.5f, 10f, "A walking hero that gets nowhere for this long is stuck: it jumps, looks for a new way, then sidesteps.");
			UnstuckTeleport = cfg.Bind<bool>("AI", "UnstuckTeleport", true, "The last resort for a stuck hero: a short hop to walkable ground further along its way.");
			TeleportAfterSeconds = F(cfg, "TeleportAfterSeconds", 5f, 2f, 30f, "Seconds of being stuck before that hop.");
			AutoEquipment = cfg.Bind<bool>("AI", "AutoEquipment", true, "Heroes use their equipment by themselves: the pieces listed in EquipmentInCombat in a fight, EquipmentWhenHurt when badly hurt, EquipmentVsBoss against a boss.");
			EquipmentInCombat = cfg.Bind<string>("AI", "EquipmentInCombat", "CommandMissile,Saw,Blackhole,BFG,Lightning,CritOnUse,DroneBackup,TeamWarCry,CrippleWard,LifestealOnHit,DeathProjectile,Molotov,GummyClone", "Equipment (internal names, comma separated) a hero uses on its own when it fights.");
			EquipmentWhenHurt = cfg.Bind<string>("AI", "EquipmentWhenHurt", "Fruit,PassiveHealing,GainArmor", "Equipment a hero uses on its own when it is below half health in a fight.");
			EquipmentVsBoss = cfg.Bind<string>("AI", "EquipmentVsBoss", "BossHunter", "Equipment a hero uses on its own only against a boss.");
		}

		private static ConfigEntry<float> F(ConfigFile cfg, string key, float value, float min, float max, string description)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			return cfg.Bind<float>("AI", key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>()));
		}

		internal static bool UseInCombat(string equipmentName)
		{
			return InCombat.Contains(EquipmentInCombat, equipmentName);
		}

		internal static bool UseWhenHurt(string equipmentName)
		{
			return WhenHurt.Contains(EquipmentWhenHurt, equipmentName);
		}

		internal static bool UseVsBoss(string equipmentName)
		{
			return VsBoss.Contains(EquipmentVsBoss, equipmentName);
		}
	}
	internal static class Loc
	{
		public const string Prefix = "HIGHCOMMAND_";

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

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

		internal static string Add(string token, string en, string ru = null)
		{
			En[token] = en;
			Ru[token] = ru ?? en;
			return token;
		}

		internal static bool IsRussianName(string name)
		{
			if (!string.IsNullOrEmpty(name))
			{
				if (!name.StartsWith("ru", StringComparison.OrdinalIgnoreCase))
				{
					return name.IndexOf("russ", StringComparison.OrdinalIgnoreCase) >= 0;
				}
				return true;
			}
			return false;
		}

		internal static bool IsRussian()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			string currentLanguageName = Language.currentLanguageName;
			if (!string.IsNullOrEmpty(currentLanguageName))
			{
				return IsRussianName(currentLanguageName);
			}
			return (int)Application.systemLanguage == 30;
		}

		internal static string Get(string token)
		{
			if (!(IsRussian() ? Ru : En).TryGetValue(token, out var value))
			{
				return token;
			}
			return value;
		}

		internal static string Format(string token, params object[] args)
		{
			try
			{
				return string.Format(Get(token), args);
			}
			catch (FormatException)
			{
				return Get(token);
			}
		}

		internal static bool TryGet(string languageName, string token, out string text)
		{
			string currentLanguageName = Language.currentLanguageName;
			return (IsRussianName((!string.IsNullOrEmpty(currentLanguageName)) ? currentLanguageName : languageName) ? Ru : En).TryGetValue(token, out text);
		}
	}
	[HarmonyPatch(typeof(Language))]
	internal static class LanguagePatches
	{
		private static bool IsOurToken(string token)
		{
			if (token != null && token.Length > 12 && token[0] == 'H')
			{
				return token.StartsWith("HIGHCOMMAND_", StringComparison.Ordinal);
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch("GetLocalizedStringByToken")]
		private static bool GetString(Language __instance, string token, ref string __result)
		{
			if (IsOurToken(token) && Loc.TryGet(__instance.name, token, out var text))
			{
				__result = text;
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("TokenIsRegistered")]
		private static bool IsRegistered(string token, ref bool __result)
		{
			if (IsOurToken(token))
			{
				__result = true;
				return false;
			}
			return true;
		}
	}
	internal static class MiniJson
	{
		internal static object Parse(string json)
		{
			if (json == null)
			{
				throw new ArgumentNullException("json");
			}
			int i = 0;
			object result = ReadValue(json, ref i);
			SkipWhite(json, ref i);
			if (i != json.Length)
			{
				throw new FormatException("unexpected text after the JSON value at " + i);
			}
			return result;
		}

		private static void SkipWhite(string s, ref int i)
		{
			while (i < s.Length)
			{
				switch (s[i])
				{
				case '\t':
				case '\n':
				case '\r':
				case ' ':
					i++;
					break;
				case '/':
					if (i + 1 < s.Length && s[i + 1] == '/')
					{
						while (i < s.Length && s[i] != '\n')
						{
							i++;
						}
						break;
					}
					return;
				default:
					return;
				}
			}
		}

		private static object ReadValue(string s, ref int i)
		{
			SkipWhite(s, ref i);
			if (i >= s.Length)
			{
				throw new FormatException("unexpected end of JSON");
			}
			switch (s[i])
			{
			case '{':
				return ReadObject(s, ref i);
			case '[':
				return ReadArray(s, ref i);
			case '"':
				return ReadString(s, ref i);
			case 't':
				Expect(s, ref i, "true");
				return true;
			case 'f':
				Expect(s, ref i, "false");
				return false;
			case 'n':
				Expect(s, ref i, "null");
				return null;
			default:
				return ReadNumber(s, ref i);
			}
		}

		private static void Expect(string s, ref int i, string word)
		{
			if (string.CompareOrdinal(s, i, word, 0, word.Length) != 0)
			{
				throw new FormatException("expected '" + word + "' at " + i);
			}
			i += word.Length;
		}

		private static Dictionary<string, object> ReadObject(string s, ref int i)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
			i++;
			SkipWhite(s, ref i);
			if (i < s.Length && s[i] == '}')
			{
				i++;
				return dictionary;
			}
			while (true)
			{
				SkipWhite(s, ref i);
				if (i >= s.Length || s[i] != '"')
				{
					throw new FormatException("property name expected at " + i);
				}
				string key = ReadString(s, ref i);
				SkipWhite(s, ref i);
				if (i >= s.Length || s[i] != ':')
				{
					throw new FormatException("':' expected at " + i);
				}
				i++;
				dictionary[key] = ReadValue(s, ref i);
				SkipWhite(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("unterminated object");
				}
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == '}')
			{
				i++;
				return dictionary;
			}
			throw new FormatException("',' or '}' expected at " + i);
		}

		private static List<object> ReadArray(string s, ref int i)
		{
			List<object> list = new List<object>();
			i++;
			SkipWhite(s, ref i);
			if (i < s.Length && s[i] == ']')
			{
				i++;
				return list;
			}
			while (true)
			{
				list.Add(ReadValue(s, ref i));
				SkipWhite(s, ref i);
				if (i >= s.Length)
				{
					throw new FormatException("unterminated array");
				}
				if (s[i] != ',')
				{
					break;
				}
				i++;
			}
			if (s[i] == ']')
			{
				i++;
				return list;
			}
			throw new FormatException("',' or ']' expected at " + i);
		}

		private static string ReadString(string s, ref int i)
		{
			StringBuilder stringBuilder = new StringBuilder();
			i++;
			while (i < s.Length)
			{
				char c = s[i++];
				switch (c)
				{
				case '"':
					return stringBuilder.ToString();
				default:
					stringBuilder.Append(c);
					continue;
				case '\\':
					break;
				}
				if (i >= s.Length)
				{
					break;
				}
				char c2 = s[i++];
				switch (c2)
				{
				case 'n':
					stringBuilder.Append('\n');
					break;
				case 't':
					stringBuilder.Append('\t');
					break;
				case 'r':
					stringBuilder.Append('\r');
					break;
				case 'b':
					stringBuilder.Append('\b');
					break;
				case 'f':
					stringBuilder.Append('\f');
					break;
				case 'u':
					if (i + 4 > s.Length)
					{
						throw new FormatException("bad \\u escape");
					}
					stringBuilder.Append((char)Convert.ToInt32(s.Substring(i, 4), 16));
					i += 4;
					break;
				default:
					stringBuilder.Append(c2);
					break;
				}
			}
			throw new FormatException("unterminated string");
		}

		private static double ReadNumber(string s, ref int i)
		{
			int num = i;
			while (i < s.Length && "+-0123456789.eE".IndexOf(s[i]) >= 0)
			{
				i++;
			}
			if (num == i)
			{
				throw new FormatException("unexpected character '" + s[i] + "' at " + i);
			}
			return double.Parse(s.Substring(num, i - num), CultureInfo.InvariantCulture);
		}

		internal static float Float(Dictionary<string, object> o, string key, float fallback)
		{
			if (o == null || !o.TryGetValue(key, out var value) || !(value is double num))
			{
				return fallback;
			}
			return (float)num;
		}

		internal static int Int(Dictionary<string, object> o, string key, int fallback)
		{
			if (o == null || !o.TryGetValue(key, out var value) || !(value is double a))
			{
				return fallback;
			}
			return (int)Math.Round(a);
		}

		internal static string String(Dictionary<string, object> o, string key, string fallback)
		{
			if (o == null || !o.TryGetValue(key, out var value) || !(value is string result))
			{
				return fallback;
			}
			return result;
		}

		internal static string Quote(string s)
		{
			StringBuilder stringBuilder = new StringBuilder("\"");
			string text = s ?? "";
			foreach (char c in text)
			{
				switch (c)
				{
				case '"':
					stringBuilder.Append("\\\"");
					continue;
				case '\\':
					stringBuilder.Append("\\\\");
					continue;
				case '\n':
					stringBuilder.Append("\\n");
					continue;
				case '\r':
					stringBuilder.Append("\\r");
					continue;
				case '\t':
					stringBuilder.Append("\\t");
					continue;
				}
				if (c < ' ')
				{
					StringBuilder stringBuilder2 = stringBuilder.Append("\\u");
					int num = c;
					stringBuilder2.Append(num.ToString("x4"));
				}
				else
				{
					stringBuilder.Append(c);
				}
			}
			return stringBuilder.Append('"').ToString();
		}

		internal static string Number(float v)
		{
			return v.ToString("0.###", CultureInfo.InvariantCulture);
		}
	}
	internal static class OptionsIntegration
	{
		internal const string RiskOfOptionsGuid = "com.rune580.riskofoptions";

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void Register()
		{
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Expected O, but got Unknown
			try
			{
				ModSettingsManager.SetModDescription("High Command: a strategy mode. Settings of the camera, economy, loot and the army. Key bindings are in the .cfg file.", "kantemiir.HighCommand", "HighCommand");
				Slider(Settings.CameraPanSpeed, 0.2f, 4f);
				Slider(Settings.CameraZoomSpeed, 0.2f, 4f);
				Slider(Settings.CameraRotateSpeed, 0.2f, 4f);
				Slider(Settings.CameraSmoothing, 0f, 0.6f);
				Slider(Settings.CameraPitch, 25f, 85f, "{0:0}");
				Slider(Settings.CameraFov, 20f, 100f, "{0:0}");
				Slider(Settings.CameraMinDistance, 4f, 60f, "{0:0}");
				Slider(Settings.CameraMaxDistance, 30f, 500f, "{0:0}");
				Check(Settings.EdgeScroll);
				IntSlider(Settings.EdgeScrollPixels, 1, 40);
				Check(Settings.FollowGround);
				Check(Settings.ListenerAtFocus);
				Slider(Settings.UiScale, 0.6f, 1.6f);
				Check(Settings.AlwaysShowRoutes);
				Check(Settings.MinimapEnabled);
				Slider(Settings.MinimapSize, 140f, 520f, "{0:0}");
				IntSlider(Settings.StartingGold, 0, 5000);
				Slider(Settings.GoldMultiplier, 0.1f, 10f);
				IntSlider(Settings.HeroBasePrice, 10, 3000);
				Slider(Settings.HeroPriceGrowth, 1f, 4f);
				Slider(Settings.PriceMultiplier, 0.1f, 10f);
				Slider(Settings.ReviveCostFraction, 0f, 3f);
				IntSlider(Settings.ArmyLimit, 1, 20);
				IntSlider(Settings.StartingHeroes, 1, 4);
				Check(Settings.AllowDuplicates);
				Check(Settings.IgnoreUnlocks);
				Check(Settings.AllowHiddenSurvivors);
				Check(Settings.AutoRetreat);
				Slider(AiTuning.HoldRadius, 0f, 15f, "{0:0.0}");
				Slider(AiTuning.AttackMoveRange, 10f, 100f, "{0:0}");
				Slider(AiTuning.AttackMoveLeash, 5f, 100f, "{0:0}");
				Slider(AiTuning.AssistRange, 0f, 150f, "{0:0}");
				Slider(AiTuning.FocusFireWeight, 0f, 3f, "{0:0.0}");
				Slider(AiTuning.UnreachableSeconds, 1f, 20f, "{0:0.0}");
				Slider(AiTuning.BurstHoardSeconds, 0f, 60f, "{0:0}");
				Slider(AiTuning.FleeMaxSeconds, 3f, 60f, "{0:0}");
				Check(AiTuning.UnstuckTeleport);
				Check(AiTuning.AutoEquipment);
				Slider(Settings.ThreatPerExtraHero, 0f, 2f);
				Slider(Settings.DefeatGraceBroke, 0f, 120f, "{0:0}");
				Slider(Settings.DefeatGraceRevive, 0f, 600f, "{0:0}");
				Check(Settings.AutoRevive);
				Slider(Settings.AutoReviveDelay, 0f, 30f, "{0:0}");
				Check(Settings.EnemiesHunt);
				Slider(Settings.EnemyHuntRange, 30f, 1000f, "{0:0}");
				Check(Settings.ItemDropsEnabled);
				Slider(Settings.ItemGoldFactor, 0.2f, 30f);
				Slider(Settings.ItemDropMultiplier, 0f, 10f);
				Check(Settings.RemovePaidInteractables);
				Check(Settings.RebalanceOnRecruit);
				ModSettingsManager.AddOption((BaseOption)new ChoiceOption((ConfigEntryBase)(object)Settings.ItemSharing));
				Check(Settings.VerboseLog);
				Plugin.Log.LogInfo((object)"Settings are available in Mod Options (Risk of Options).");
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("Risk of Options integration failed: " + ex.Message));
			}
		}

		private static void Check(ConfigEntry<bool> entry)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			if (entry != null)
			{
				ModSettingsManager.AddOption((BaseOption)new CheckBoxOption(entry));
			}
		}

		private static void Slider(ConfigEntry<float> entry, float min, float max, string format = "{0:0.00}")
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (entry != null)
			{
				ModSettingsManager.AddOption((BaseOption)new SliderOption(entry, new SliderConfig
				{
					min = min,
					max = max,
					FormatString = format
				}));
			}
		}

		private static void IntSlider(ConfigEntry<int> entry, int min, int max)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			if (entry != null)
			{
				ModSettingsManager.AddOption((BaseOption)new IntSliderOption(entry, new IntSliderConfig
				{
					min = min,
					max = max
				}));
			}
		}
	}
	internal static class Settings
	{
		private static ConfigFile cfg;

		internal static ConfigEntry<float> CameraPanSpeed;

		internal static ConfigEntry<float> CameraZoomSpeed;

		internal static ConfigEntry<float> CameraMinDistance;

		internal static ConfigEntry<float> CameraMaxDistance;

		internal static ConfigEntry<bool> ZoomToCursor;

		internal static ConfigEntry<bool> ZoomTilt;

		internal static ConfigEntry<bool> FollowGround;

		internal static ConfigEntry<float> CameraPitch;

		internal static ConfigEntry<float> CameraFov;

		internal static ConfigEntry<float> CameraRotateSpeed;

		internal static ConfigEntry<float> CameraSmoothing;

		internal static ConfigEntry<bool> EdgeScroll;

		internal static ConfigEntry<int> EdgeScrollPixels;

		internal static ConfigEntry<KeyCode> KeyUp;

		internal static ConfigEntry<KeyCode> KeyDown;

		internal static ConfigEntry<KeyCode> KeyLeft;

		internal static ConfigEntry<KeyCode> KeyRight;

		internal static ConfigEntry<KeyCode> KeyRotateLeft;

		internal static ConfigEntry<KeyCode> KeyRotateRight;

		internal static ConfigEntry<KeyCode> KeyTiltUp;

		internal static ConfigEntry<KeyCode> KeyTiltDown;

		internal static ConfigEntry<float> CameraTiltSpeed;

		internal static ConfigEntry<bool> InvertTilt;

		internal static ConfigEntry<KeyCode> KeyFocusSelected;

		internal static ConfigEntry<KeyCode> KeyHelp;

		internal static ConfigEntry<KeyCode> KeyFastCamera;

		internal static ConfigEntry<KeyCode> KeyAttackMove;

		internal static ConfigEntry<KeyCode> KeyStop;

		internal static ConfigEntry<KeyCode> KeyHold;

		internal static ConfigEntry<KeyCode> KeyFocusFire;

		internal static ConfigEntry<KeyCode> KeyRetreat;

		internal static ConfigEntry<KeyCode> KeyPatrol;

		internal static ConfigEntry<KeyCode> KeyRally;

		internal static ConfigEntry<KeyCode> KeySeekEnemies;

		internal static ConfigEntry<KeyCode> KeySeekChests;

		internal static ConfigEntry<KeyCode> KeyCastSecondary;

		internal static ConfigEntry<KeyCode> KeyCastUtility;

		internal static ConfigEntry<KeyCode> KeyCastSpecial;

		internal static ConfigEntry<KeyCode> KeyCastEquipment;

		internal static ConfigEntry<KeyCode> KeyStanceAggressive;

		internal static ConfigEntry<KeyCode> KeyStanceDefensive;

		internal static ConfigEntry<KeyCode> KeyStancePassive;

		internal static ConfigEntry<KeyCode> KeyToggleAuto;

		internal static ConfigEntry<KeyCode> KeyBarracks;

		internal static ConfigEntry<KeyCode> KeyInventory;

		internal static ConfigEntry<KeyCode> KeyRevive;

		internal static ConfigEntry<KeyCode> KeyTeleporter;

		internal static readonly ConfigEntry<KeyCode>[] KeyAbility = new ConfigEntry<KeyCode>[4];

		internal static ConfigEntry<KeyCode> KeyFormationCycle;

		internal static ConfigEntry<KeyCode> KeyCycleSelection;

		internal static ConfigEntry<KeyCode> KeySelectAll;

		internal static ConfigEntry<KeyCode> KeyLastAlert;

		internal static ConfigEntry<KeyCode> KeyResetCamera;

		internal static ConfigEntry<float> UiScale;

		internal static ConfigEntry<bool> Alerts;

		internal static ConfigEntry<bool> AlwaysShowRoutes;

		internal static ConfigEntry<int> StartingGold;

		internal static ConfigEntry<float> GoldMultiplier;

		internal static ConfigEntry<int> HeroBasePrice;

		internal static ConfigEntry<float> HeroPriceGrowth;

		internal static ConfigEntry<float> PriceMultiplier;

		internal static ConfigEntry<int> ArmyLimit;

		internal static ConfigEntry<int> StartingHeroes;

		internal static ConfigEntry<bool> AllowDuplicates;

		internal static ConfigEntry<bool> IgnoreUnlocks;

		internal static ConfigEntry<bool> AllowHiddenSurvivors;

		internal static ConfigEntry<float> ReviveCostFraction;

		internal static ConfigEntry<bool> AutoRetreat;

		internal static ConfigEntry<float> DefeatGraceBroke;

		internal static ConfigEntry<float> DefeatGraceRevive;

		internal static ConfigEntry<bool> AutoRevive;

		internal static ConfigEntry<float> AutoReviveDelay;

		internal static ConfigEntry<float> ThreatPerExtraHero;

		internal static ConfigEntry<bool> EnemiesHunt;

		internal static ConfigEntry<float> EnemyHuntRange;

		internal static ConfigEntry<bool> ItemDropsEnabled;

		internal static ConfigEntry<float> ItemGoldFactor;

		internal static ConfigEntry<float> ItemDropMultiplier;

		internal static ConfigEntry<bool> RemovePaidInteractables;

		internal static ConfigEntry<string> KeepInteractables;

		internal static ConfigEntry<ItemDistributor.SharingMode> ItemSharing;

		internal static ConfigEntry<bool> RebalanceOnRecruit;

		internal static ConfigEntry<bool> AutoOpenBarrels;

		internal static ConfigEntry<bool> AutoOpenChests;

		internal static ConfigEntry<int> ConfigVersion;

		private static string[] keepCache;

		private static string keepCacheSource;

		internal static ConfigEntry<bool> MinimapEnabled;

		internal static ConfigEntry<float> MinimapSize;

		internal static ConfigEntry<bool> ListenerAtFocus;

		internal static ConfigEntry<bool> VerboseLog;

		internal static string[] KeptInteractables()
		{
			string text = KeepInteractables.Value ?? string.Empty;
			if (keepCache == null || keepCacheSource != text)
			{
				keepCacheSource = text;
				keepCache = text.Split(new char[2] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries);
				for (int i = 0; i < keepCache.Length; i++)
				{
					keepCache[i] = keepCache[i].Trim();
				}
			}
			return keepCache;
		}

		internal static void Init(ConfigFile file)
		{
			cfg = file;
			CameraPanSpeed = F("Camera", "PanSpeed", 1f, 0.2f, 4f, "Camera pan speed multiplier (WASD and screen edge). The speed also scales with zoom.");
			CameraZoomSpeed = F("Camera", "ZoomSpeed", 1f, 0.2f, 4f, "Mouse wheel zoom speed multiplier.");
			CameraMinDistance = F("Camera", "MinDistance", 6f, 3f, 60f, "Closest camera distance to the ground focus point, meters.");
			ZoomToCursor = cfg.Bind<bool>("Camera", "ZoomToCursor", true, "The wheel zooms towards the point under the mouse (it stays under the mouse), as in Company of Heroes or Total War. Off: towards the middle of the screen.");
			ZoomTilt = cfg.Bind<bool>("Camera", "ZoomTilt", true, "Zooming in close also lowers the view towards the ground (a side view of the heroes at the closest zoom); zooming out brings your tilt back.");
			FollowGround = cfg.Bind<bool>("Camera", "FollowGround", false, "Off (free camera): panning never changes the camera's height or tilt; the height is set by you (flying to heroes, the minimap, zooming towards the cursor, Home), and the camera only steps up onto ground higher than itself. On: the height follows a smoothed copy of the ground and the camera tilts up a little over slopes.");
			CameraMaxDistance = F("Camera", "MaxDistance", 220f, 30f, 500f, "Farthest camera distance, meters.");
			CameraPitch = F("Camera", "Pitch", 58f, 25f, 85f, "Camera tilt in degrees (90 = straight down). The starting tilt: middle mouse drag up / down and PageUp / PageDown change it during the game.");
			CameraTiltSpeed = F("Camera", "TiltSpeed", 1f, 0.2f, 4f, "Tilt speed multiplier for middle mouse drag up / down and the tilt keys.");
			InvertTilt = cfg.Bind<bool>("Camera", "InvertTilt", false, "Swap the direction of the tilt (middle mouse drag up looks more down).");
			CameraFov = F("Camera", "FieldOfView", 50f, 20f, 100f, "Camera field of view in degrees.");
			CameraRotateSpeed = F("Camera", "RotateSpeed", 1f, 0.2f, 4f, "Rotation speed multiplier for middle mouse drag and the rotate keys.");
			CameraSmoothing = F("Camera", "Smoothing", 0.12f, 0f, 0.6f, "Camera smoothing time in seconds (0 = snappy).");
			EdgeScroll = cfg.Bind<bool>("Camera", "EdgeScroll", true, "Pan the camera when the mouse touches the screen edge.");
			EdgeScrollPixels = I("Camera", "EdgeScrollPixels", 4, 1, 40, "Width of the screen edge zone in pixels.");
			KeyUp = cfg.Bind<KeyCode>("Keys", "CameraUp", (KeyCode)119, "Camera forward.");
			KeyDown = cfg.Bind<KeyCode>("Keys", "CameraDown", (KeyCode)115, "Camera back.");
			KeyLeft = cfg.Bind<KeyCode>("Keys", "CameraLeft", (KeyCode)97, "Camera left.");
			KeyRight = cfg.Bind<KeyCode>("Keys", "CameraRight", (KeyCode)100, "Camera right.");
			KeyRotateLeft = cfg.Bind<KeyCode>("Keys", "RotateLeft", (KeyCode)91, "Rotate the camera left (middle mouse drag also rotates).");
			KeyRotateRight = cfg.Bind<KeyCode>("Keys", "RotateRight", (KeyCode)93, "Rotate the camera right.");
			KeyTiltUp = cfg.Bind<KeyCode>("Keys", "TiltUp", (KeyCode)280, "Tilt the camera up: a flatter view towards the horizon (middle mouse drag up does the same).");
			KeyTiltDown = cfg.Bind<KeyCode>("Keys", "TiltDown", (KeyCode)281, "Tilt the camera down: a view more from above (middle mouse drag down).");
			KeyAttackMove = cfg.Bind<KeyCode>("Keys", "AttackMove", (KeyCode)113, "Attack-move: press, then left click a point (A would clash with camera panning).");
			KeyStop = cfg.Bind<KeyCode>("Keys", "Stop", (KeyCode)101, "Stop: drop all orders.");
			KeyHold = cfg.Bind<KeyCode>("Keys", "HoldPosition", (KeyCode)114, "Hold position: stand and fight only what comes into range.");
			KeyFocusFire = cfg.Bind<KeyCode>("Keys", "FocusFire", (KeyCode)102, "Focus fire: attack the enemy under the cursor (or press, then click an enemy).");
			KeyRetreat = cfg.Bind<KeyCode>("Keys", "Retreat", (KeyCode)118, "Retreat to the rally point.");
			KeySeekEnemies = cfg.Bind<KeyCode>("Keys", "SeekEnemies", (KeyCode)107, "Seek enemies: the selected heroes go after the nearest enemy anywhere on the map, then the next one.");
			KeySeekChests = cfg.Bind<KeyCode>("Keys", "SeekChests", (KeyCode)108, "Seek chests: the selected heroes open the chests of the map the purse can pay for, nearest first.");
			KeyPatrol = cfg.Bind<KeyCode>("Keys", "Patrol", (KeyCode)116, "Patrol: press, then left click the far point.");
			KeyRally = cfg.Bind<KeyCode>("Keys", "RallyPoint", (KeyCode)103, "Set the rally point: press, then left click.");
			KeyCastSecondary = cfg.Bind<KeyCode>("Keys", "CastSecondary", (KeyCode)122, "Use the selected heroes' secondary skill (then click a target).");
			KeyCastUtility = cfg.Bind<KeyCode>("Keys", "CastUtility", (KeyCode)120, "Use the selected heroes' utility skill.");
			KeyCastSpecial = cfg.Bind<KeyCode>("Keys", "CastSpecial", (KeyCode)99, "Use the selected heroes' special skill.");
			KeyCastEquipment = cfg.Bind<KeyCode>("Keys", "CastEquipment", (KeyCode)121, "Use the selected heroes' equipment.");
			KeyBarracks = cfg.Bind<KeyCode>("Keys", "Barracks", (KeyCode)98, "Open / close the recruiting panel.");
			KeyInventory = cfg.Bind<KeyCode>("Keys", "Inventory", (KeyCode)105, "Open / close the item panel (the army's items, per hero; drag an item onto a hero to give it).");
			KeyAbility[0] = cfg.Bind<KeyCode>("Keys", "AbilityStrike", (KeyCode)286, "Commander ability: orbital strike (click a point).");
			KeyAbility[1] = cfg.Bind<KeyCode>("Keys", "AbilityMedic", (KeyCode)287, "Commander ability: field medic (heals every hero).");
			KeyAbility[2] = cfg.Bind<KeyCode>("Keys", "AbilityWarCry", (KeyCode)288, "Commander ability: war cry (attack and move speed for every hero).");
			KeyAbility[3] = cfg.Bind<KeyCode>("Keys", "AbilityMark", (KeyCode)289, "Commander ability: mark an enemy (everybody focuses it, it takes more damage).");
			KeyRevive = cfg.Bind<KeyCode>("Keys", "Revive", (KeyCode)117, "Revive the first fallen hero (costs gold).");
			KeyTeleporter = cfg.Bind<KeyCode>("Keys", "Teleporter", (KeyCode)104, "Teleporter: activate it, gather the army in the zone, or leave the stage - whatever is possible now.");
			KeyStanceAggressive = cfg.Bind<KeyCode>("Keys", "StanceAggressive", (KeyCode)283, "Stance: aggressive (chase anything seen).");
			KeyStanceDefensive = cfg.Bind<KeyCode>("Keys", "StanceDefensive", (KeyCode)284, "Stance: defensive (fight near the post, then return).");
			KeyStancePassive = cfg.Bind<KeyCode>("Keys", "StancePassive", (KeyCode)285, "Stance: passive (never start a fight).");
			KeyToggleAuto = cfg.Bind<KeyCode>("Keys", "ToggleAutoSkills", (KeyCode)308, "Hold with Z / X / C / Y to switch that skill's automatic use on or off.");
			KeyFormationCycle = cfg.Bind<KeyCode>("Keys", "FormationCycle", (KeyCode)110, "Cycle the formation used by move orders: blob / line / column.");
			KeyFocusSelected = cfg.Bind<KeyCode>("Keys", "FocusSelected", (KeyCode)32, "Fly the camera to the selected heroes (or the whole army).");
			KeyHelp = cfg.Bind<KeyCode>("Keys", "Help", (KeyCode)282, "Show / hide the hotkey cheat sheet.");
			KeyFastCamera = cfg.Bind<KeyCode>("Keys", "FastCamera", (KeyCode)304, "Hold to pan the camera faster.");
			KeyCycleSelection = cfg.Bind<KeyCode>("Keys", "CycleSelection", (KeyCode)9, "Select the next hero (hold Shift: the previous one).");
			KeySelectAll = cfg.Bind<KeyCode>("Keys", "SelectAll", (KeyCode)97, "Together with Ctrl: select the whole army. (Digits 1-0 are the control groups: Ctrl+digit sets, digit recalls.)");
			KeyLastAlert = cfg.Bind<KeyCode>("Keys", "LastAlert", (KeyCode)8, "Fly the camera to the place of the last alert (a fallen or nearly dead hero).");
			KeyResetCamera = cfg.Bind<KeyCode>("Keys", "ResetCamera", (KeyCode)278, "Reset the camera's turn, tilt and zoom to the start view and bring its height back onto the ground under it (it stays where it looks).");
			Alerts = cfg.Bind<bool>("Interface", "Alerts", true, "Message, sound and a mark on the map when a hero falls or is nearly dead.");
			AlwaysShowRoutes = cfg.Bind<bool>("Interface", "AlwaysShowRoutes", false, "Always draw the selected heroes' routes to their orders. Off: an order shows only as a mark at its place, the routes and the queued orders appear while Shift is held.");
			UiScale = F("Interface", "UiScale", 1f, 0.6f, 1.6f, "Size of the whole interface of the mode: 1 = normal, 1.25 = bigger text and panels, 0.8 = smaller. It comes on top of the automatic scaling to the screen resolution.");
			StartingGold = I("Economy", "StartingGold", 100, 0, 100000, "Gold the army starts the run with.");
			GoldMultiplier = F("Economy", "GoldMultiplier", 1f, 0.1f, 10f, "Multiplier on all gold the army receives.");
			HeroBasePrice = I("Economy", "HeroBasePrice", 250, 10, 100000, "Price of the first recruit at the start of the run (scales with the run's difficulty).");
			HeroPriceGrowth = F("Economy", "HeroPriceGrowth", 1.4f, 1f, 4f, "Every hero bought makes the next one this many times more expensive.");
			PriceMultiplier = F("Economy", "PriceMultiplier", 1f, 0.1f, 10f, "Multiplier on all hero prices (recruiting and reviving).");
			ArmyLimit = I("Army", "ArmyLimit", 6, 1, 20, "Largest army size (including the starting hero).");
			AllowDuplicates = cfg.Bind<bool>("Army", "AllowDuplicates", false, "Allow recruiting several heroes of the same kind.");
			IgnoreUnlocks = cfg.Bind<bool>("Army", "IgnoreUnlocks", false, "Offer survivors you have not unlocked yet.");
			AllowHiddenSurvivors = cfg.Bind<bool>("Army", "AllowHiddenSurvivors", false, "Offer hidden survivors (for example Heretic). Experimental: they are not meant to be played and may misbehave.");
			ReviveCostFraction = F("Economy", "ReviveCostFraction", 0.4f, 0f, 3f, "A fallen hero's revival costs this fraction of the price of a first recruit (it grows with time and stages, not with the army size).");
			StartingHeroes = I("Army", "StartingHeroes", 2, 1, 4, "Heroes the army starts with: the survivor chosen in the lobby plus random unlocked survivors (free; recruit prices are not raised by them).");
			AutoRetreat = cfg.Bind<bool>("Army", "AutoRetreat", true, "A badly hurt hero (threshold per survivor in profiles\\hero_profiles.json) runs to its friends until it recovers. Explicit move / hold / interact orders are never interrupted.");
			DefeatGraceBroke = F("Run", "DefeatGraceSecondsBroke", 6f, 0f, 120f, "When every hero is dead and the army cannot pay for a revival, the run is lost after this many seconds.");
			DefeatGraceRevive = F("Run", "DefeatGraceSecondsCanRevive", 45f, 0f, 600f, "When every hero is dead but a revival is affordable, the commander has this many seconds to pay for it.");
			AutoRevive = cfg.Bind<bool>("Run", "AutoRevive", true, "When every hero has fallen and the army can pay for a revival, the first fallen hero is revived automatically (after AutoReviveDelay seconds) instead of waiting for the Revive key.");
			AutoReviveDelay = F("Run", "AutoReviveDelay", 4f, 0f, 30f, "Seconds between the fall of the last hero and the automatic revival.");
			ThreatPerExtraHero = F("Run", "ThreatPerExtraHero", 0.65f, 0f, 2f, "How much each hero beyond the first counts as an extra player for the game's difficulty scaling (monster credits, boss count, loot). 1 = like a real co-op player.");
			EnemiesHunt = cfg.Bind<bool>("Run", "EnemiesHunt", true, "Monsters with no target go for the nearest hero, seen or not, so they come at the army from all sides like at a player in a normal run. Off: the stock rule, a monster attacks only what it has seen.");
			EnemyHuntRange = F("Run", "EnemyHuntRange", 250f, 30f, 2000f, "With EnemiesHunt: monsters farther than this from every hero (meters) stay where they are until they see one.");
			ItemDropsEnabled = cfg.Bind<bool>("Loot", "ItemDropsEnabled", false, "Enemies also drop items straight into the army's pool (the old way of the mode; normally items come from chests).");
			ItemGoldFactor = F("Loot", "ItemGoldFactor", 2.5f, 0.2f, 30f, "With ItemDropsEnabled: an item is worth this many chests' worth of gold: bigger = fewer drops.");
			ItemDropMultiplier = F("Loot", "ItemDropMultiplier", 1f, 0f, 10f, "With ItemDropsEnabled: multiplier on the chance of every item drop.");
			RemovePaidInteractables = cfg.Bind<bool>("Loot", "RemovePaidInteractables", false, "Do not place chests, printers, shrines of chance and other interactables that cost something (the old way of the mode).");
			KeepInteractables = cfg.Bind<string>("Loot", "KeepInteractables", "", "With RemovePaidInteractables: comma separated name fragments of paid interactables that should stay (for example: ShrineBoss,Duplicator).");
			AutoOpenBarrels = cfg.Bind<bool>("Loot", "AutoOpenBarrels", true, "Heroes with nothing to do open barrels (free gold) near their post by themselves.");
			AutoOpenChests = cfg.Bind<bool>("Loot", "AutoOpenChests", true, "Heroes with nothing to do, with no enemy near, open a chest near their post by themselves when the purse can pay for it. Only chests: shops, shrines, printers and drones wait for an order.");
			ConfigVersion = cfg.Bind<int>("Dev", "ConfigVersion", 0, "Version of this file's defaults (the mod updates old values once; do not change).");
			Migrate();
			ItemSharing = cfg.Bind<ItemDistributor.SharingMode>("Loot", "ItemSharing", ItemDistributor.SharingMode.Split, "Split: every item unit belongs to one hero (like a normal co-op run). Mirror: every hero gets a copy of every item (much stronger).");
			RebalanceOnRecruit = cfg.Bind<bool>("Loot", "RebalanceOnRecruit", true, "A newly recruited hero takes a fair share of items from the heroes who have the most.");
			MinimapEnabled = cfg.Bind<bool>("Minimap", "Enabled", true, "Show the minimap.");
			MinimapSize = F("Minimap", "Size", 260f, 140f, 520f, "Minimap size in reference pixels (1080p).");
			ListenerAtFocus = cfg.Bind<bool>("Audio", "ListenerAtFocus", true, "Place the audio listener on the ground below the camera focus instead of on the high camera, so battle sounds stay audible.");
			VerboseLog = cfg.Bind<bool>("Dev", "VerboseLog", false, "Write extra diagnostic lines to the BepInEx log.");
			AiTuning.Bind(cfg);
		}

		private static void Migrate()
		{
			if (ConfigVersion.Value < 4)
			{
				if (ConfigVersion.Value < 2)
				{
					ItemDropsEnabled.Value = false;
					RemovePaidInteractables.Value = false;
					Plugin.Log.LogInfo((object)"Config: loot switched to chests on the map (Loot/ItemDropsEnabled = false, Loot/RemovePaidInteractables = false).");
				}
				if (ConfigVersion.Value < 3 && Mathf.Approximately(CameraMinDistance.Value, 10f))
				{
					CameraMinDistance.Value = 6f;
					Plugin.Log.LogInfo((object)"Config: Camera/MinDistance 10 -> 6 (closer zoom).");
				}
				if (ConfigVersion.Value < 4 && Mathf.Approximately(CameraMaxDistance.Value, 95f))
				{
					CameraMaxDistance.Value = 220f;
					Plugin.Log.LogInfo((object)"Config: Camera/MaxDistance 95 -> 220 (farther zoom).");
				}
				ConfigVersion.Value = 4;
				cfg.Save();
			}
		}

		private static ConfigEntry<float> F(string section, string key, float value, float min, float max, string description)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			return cfg.Bind<float>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), Array.Empty<object>()));
		}

		private static ConfigEntry<int> I(string section, string key, int value, int min, int max, string description)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			return cfg.Bind<int>(section, key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(min, max), Array.Empty<object>()));
		}
	}
	internal static class Strings
	{
		internal static void Register()
		{
			Loc.Add("HIGHCOMMAND_GAMEMODE_NAME", "High Command", "Верховное командование");
			Loc.Add("HIGHCOMMAND_GAMEMODE_DESC", "Command an army of survivors from above. Buy new heroes with gold dropped by enemies.", "Командуйте армией выживших сверху. Покупайте новых героев за золото, выпадающее из врагов.");
			Loc.Add("HIGHCOMMAND_HELP_TITLE", "High Command - hotkeys", "Верховное командование - горячие клавиши");
			Loc.Add("HIGHCOMMAND_KEY_EDGE", "Screen edge", "Край экрана");
			Loc.Add("HIGHCOMMAND_KEY_WHEEL", "Mouse wheel", "Колесо мыши");
			Loc.Add("HIGHCOMMAND_KEY_MMB", "Middle mouse", "Средняя кнопка");
			Loc.Add("HIGHCOMMAND_KEY_MINIMAP", "Minimap click", "Клик по мини-карте");
			Loc.Add("HIGHCOMMAND_HELP_PAN", "Move the camera", "Двигать камеру");
			Loc.Add("HIGHCOMMAND_HELP_EDGE", "Move the camera", "Двигать камеру");
			Loc.Add("HIGHCOMMAND_HELP_ZOOM", "Zoom in / out (towards the point under the cursor, also up and down)", "Приблизить / отдалить (к точке под курсором, в том числе вверх и вниз)");
			Loc.Add("HIGHCOMMAND_HELP_ROTATE", "Rotate the camera", "Повернуть камеру");
			Loc.Add("HIGHCOMMAND_HELP_TILT", "Tilt the camera (flatter / from above)", "Наклонить камеру (ниже / сверху)");
			Loc.Add("HIGHCOMMAND_KEY_MMB_SIDE", "MMB sideways", "СКМ вбок");
			Loc.Add("HIGHCOMMAND_KEY_MMB_VERT", "MMB up / down", "СКМ вверх-вниз");
			Loc.Add("HIGHCOMMAND_KEY_RMB_OBJECT", "Right click a chest", "ПКМ по сундуку");
			Loc.Add("HIGHCOMMAND_HELP_LOOT", "The nearest hero goes to open it (Shift: a route)", "Ближайший герой идёт открыть (Shift — маршрут)");
			Loc.Add("HIGHCOMMAND_HELP_FOCUS", "Fly to the army (twice: follow it)", "К армии (дважды — следить за ней)");
			Loc.Add("HIGHCOMMAND_HELP_RESETCAM", "Reset the camera's turn, tilt and zoom, back onto the ground here", "Сбросить поворот, наклон и приближение, камера опускается на землю здесь");
			Loc.Add("HIGHCOMMAND_CAMERA_FOLLOW", "The camera follows the heroes (move it to let go)", "Камера следит за героями (сдвиньте её, чтобы отпустить)");
			Loc.Add("HIGHCOMMAND_HELP_MINIMAP", "Fly the camera there", "Перелёт камеры в эту точку");
			Loc.Add("HIGHCOMMAND_HELP_HELP", "This sheet", "Эта шпаргалка");
			Loc.Add("HIGHCOMMAND_HELP_PAUSE", "Pause menu", "Меню паузы");
			Loc.Add("HIGHCOMMAND_KEY_LMB", "Left click / drag", "ЛКМ / рамка");
			Loc.Add("HIGHCOMMAND_KEY_DOUBLE", "Double click", "Двойной клик");
			Loc.Add("HIGHCOMMAND_HELP_SELECT", "Select a hero / box select", "Выбрать героя / выделить рамкой");
			Loc.Add("HIGHCOMMAND_HELP_SELECT_ADD", "Add / remove from selection", "Добавить / убрать из выделения");
			Loc.Add("HIGHCOMMAND_HELP_SELECT_TYPE", "Select all of the same kind", "Выбрать всех такого же типа");
			Loc.Add("HIGHCOMMAND_HELP_SELECT_ALL", "Select all heroes", "Выбрать всех героев");
			Loc.Add("HIGHCOMMAND_HELP_GROUP_SET", "Set a control group", "Назначить группу");
			Loc.Add("HIGHCOMMAND_HELP_GROUP_RECALL", "Select group (twice: camera)", "Вызвать группу (дважды: камера)");
			Loc.Add("HIGHCOMMAND_HELP_CYCLE", "Next hero (Shift: previous)", "Следующий герой (Shift: предыдущий)");
			Loc.Add("HIGHCOMMAND_LEVEL_SHORT", "Lv {0}", "Ур. {0}");
			Loc.Add("HIGHCOMMAND_KEY_RMB", "Right click", "ПКМ");
			Loc.Add("HIGHCOMMAND_HELP_RMB", "Move / attack / follow / use", "Идти / атаковать / следовать / использовать");
			Loc.Add("HIGHCOMMAND_HELP_QUEUE", "Queue the order", "Добавить приказ в очередь");
			Loc.Add("HIGHCOMMAND_HELP_ATTACKMOVE", "Attack-move to a point", "Идти в точку, сражаясь");
			Loc.Add("HIGHCOMMAND_HELP_FOCUSFIRE", "Focus fire on the enemy under the cursor", "Фокус на враге под курсором");
			Loc.Add("HIGHCOMMAND_HELP_STOPHOLD", "Stop / hold position", "Стоп / держать позицию");
			Loc.Add("HIGHCOMMAND_HELP_RETREAT", "Retreat / patrol / rally point", "Отступить / патруль / точка сбора");
			Loc.Add("HIGHCOMMAND_HELP_CAST", "Use secondary / utility / special / equipment", "Умения: второе / рывок / особое / снаряжение");
			Loc.Add("HIGHCOMMAND_HELP_AUTO", "Switch a skill's auto-use", "Вкл/выкл автоприменение умения");
			Loc.Add("HIGHCOMMAND_HELP_STANCE", "Stance: aggressive / defensive / passive", "Стойка: агрессивная / защитная / пассивная");
			Loc.Add("HIGHCOMMAND_HELP_FORMATION", "Formation: blob / line / column", "Построение: кучка / линия / колонна");
			Loc.Add("HIGHCOMMAND_HINT_ATTACKMOVE", "Attack-move: left click a point (right click cancels)", "Атака-движение: ЛКМ по точке (ПКМ — отмена)");
			Loc.Add("HIGHCOMMAND_HINT_FOCUS", "Focus fire: left click an enemy", "Фокус: ЛКМ по врагу");
			Loc.Add("HIGHCOMMAND_HINT_PATROL", "Patrol: left click the far point", "Патруль: ЛКМ по дальней точке");
			Loc.Add("HIGHCOMMAND_HINT_RALLY", "Rally point: left click", "Точка сбора: ЛКМ");
			Loc.Add("HIGHCOMMAND_HINT_CAST", "Skill: left click a target or ground", "Умение: ЛКМ по цели или земле");
			Loc.Add("HIGHCOMMAND_RALLY_SET", "Rally point set", "Точка сбора задана");
			Loc.Add("HIGHCOMMAND_FORMATION_BLOB", "blob", "кучка");
			Loc.Add("HIGHCOMMAND_FORMATION_LINE", "line", "линия");
			Loc.Add("HIGHCOMMAND_FORMATION_COLUMN", "column", "колонна");
			Loc.Add("HIGHCOMMAND_FORMATION_SET", "Formation: {0}", "Построение: {0}");
			Loc.Add("HIGHCOMMAND_STANCE_AGGRESSIVE", "aggressive", "агрессивная");
			Loc.Add("HIGHCOMMAND_STANCE_DEFENSIVE", "defensive", "защитная");
			Loc.Add("HIGHCOMMAND_STANCE_PASSIVE", "passive", "пассивная");
			Loc.Add("HIGHCOMMAND_STANCE_SET", "Stance: {0}", "Стойка: {0}");
			Loc.Add("HIGHCOMMAND_AUTO_ON", "Auto-use ON: {0}", "Автоприменение ВКЛ: {0}");
			Loc.Add("HIGHCOMMAND_AUTO_OFF", "Auto-use OFF: {0}", "Автоприменение ВЫКЛ: {0}");
			Loc.Add("HIGHCOMMAND_SLOT_PRIMARY", "primary", "основное");
			Loc.Add("HIGHCOMMAND_SLOT_SECONDARY", "secondary", "вторичное");
			Loc.Add("HIGHCOMMAND_SLOT_UTILITY", "utility", "рывок");
			Loc.Add("HIGHCOMMAND_SLOT_SPECIAL", "special", "особое");
			Loc.Add("HIGHCOMMAND_SLOT_EQUIPMENT", "equipment", "экипировка");
			Loc.Add("HIGHCOMMAND_TOP_STAGE", "Stage {0}", "Стадия {0}");
			Loc.Add("HIGHCOMMAND_TOP_ARMY", "Army {0}/{1} (limit {2})", "Армия {0}/{1} (лимит {2})");
			Loc.Add("HIGHCOMMAND_TOP_NEXT", "next hero: ${0}", "след. герой: ${0}");
			Loc.Add("HIGHCOMMAND_TOP_PERMIN", "min", "мин");
			Loc.Add("HIGHCOMMAND_HELP_BARRACKS", "Barracks: recruit heroes", "Казарма: вербовка героев");
			Loc.Add("HIGHCOMMAND_BARRACKS_TITLE", "Barracks - next hero costs ${0}   (gold: ${1})", "Казарма - следующий герой стоит ${0}   (золото: ${1})");
			Loc.Add("HIGHCOMMAND_BARRACKS_NAME", "Barracks", "Казарма");
			Loc.Add("HIGHCOMMAND_BARRACKS_INFO", "next hero <color=#FFD94A>${0}</color>      gold <color=#FFD94A>${1}</color>", "следующий герой <color=#FFD94A>${0}</color>      золото <color=#FFD94A>${1}</color>");
			Loc.Add("HIGHCOMMAND_BARRACKS_HINT", "Click a survivor to recruit them. Esc closes this window.", "Нажмите на выжившего, чтобы нанять. Esc закрывает окно.");
			Loc.Add("HIGHCOMMAND_RECRUIT_BUY", "Recruit - ${0}", "Нанять - ${0}");
			Loc.Add("HIGHCOMMAND_RECRUIT_PRICE", "${0}", "${0}");
			Loc.Add("HIGHCOMMAND_RECRUIT_LOCKED", "Locked", "Закрыт");
			Loc.Add("HIGHCOMMAND_RECRUIT_NOTALLOWED", "Unavailable", "Недоступен");
			Loc.Add("HIGHCOMMAND_RECRUIT_OWNED", "In the army", "Уже в армии");
			Loc.Add("HIGHCOMMAND_RECRUIT_FULL", "Army is full", "Армия заполнена");
			Loc.Add("HIGHCOMMAND_RECRUIT_NEEDGOLD", "Not enough gold: ${0}", "Не хватает золота: ${0}");
			Loc.Add("HIGHCOMMAND_RECRUITED", "Recruited: {0}", "Нанят: {0}");
			Loc.Add("HIGHCOMMAND_UPGRADE_0_NAME", "Weapons", "Оружие");
			Loc.Add("HIGHCOMMAND_UPGRADE_0_DESC", "+10% damage for every hero per level.", "+10% урона каждому герою за уровень.");
			Loc.Add("HIGHCOMMAND_UPGRADE_1_NAME", "Armor", "Броня");
			Loc.Add("HIGHCOMMAND_UPGRADE_1_DESC", "+8 armor for every hero per level (about 7% less damage taken).", "+8 брони каждому герою за уровень (около 7% меньше урона).");
			Loc.Add("HIGHCOMMAND_UPGRADE_2_NAME", "Field medicine", "Полевая медицина");
			Loc.Add("HIGHCOMMAND_UPGRADE_2_DESC", "+0.6 health regeneration per second per level, growing with the hero's level.", "+0,6 здоровья в секунду за уровень, растёт с уровнем героя.");
			Loc.Add("HIGHCOMMAND_UPGRADE_3_NAME", "Logistics", "Логистика");
			Loc.Add("HIGHCOMMAND_UPGRADE_3_DESC", "+8% movement speed for every hero per level.", "+8% скорости бега каждому герою за уровень.");
			Loc.Add("HIGHCOMMAND_UPGRADE_HEADER", "Army upgrades - every hero, recruits too", "Улучшения армии - для всех героев, и новых тоже");
			Loc.Add("HIGHCOMMAND_UPGRADE_BUTTON", "{0} {1}/{2}\n${3}", "{0} {1}/{2}\n${3}");
			Loc.Add("HIGHCOMMAND_UPGRADE_BUTTON_MAX", "{0} {1}/{1}\nMAX", "{0} {1}/{1}\nМАКС.");
			Loc.Add("HIGHCOMMAND_UPGRADE_LEVEL", "level {0}/{1}", "ур. {0}/{1}");
			Loc.Add("HIGHCOMMAND_UPGRADE_MAXSHORT", "MAX", "МАКС.");
			Loc.Add("HIGHCOMMAND_DISTANCE", "{0} m", "{0} м");
			Loc.Add("HIGHCOMMAND_UPGRADE_MAXED", "Fully upgraded", "Уже максимум");
			Loc.Add("HIGHCOMMAND_UPGRADE_DONE", "{0}: level {1}", "{0}: уровень {1}");
			Loc.Add("HIGHCOMMAND_RANK_UP", "{0} is now a veteran: rank {1} (+10% damage, +5 armor per rank)", "{0}: ранг ветерана {1} (+10% урона и +5 брони за ранг)");
			Loc.Add("HIGHCOMMAND_RANK_INFO", "Veteran rank {0} ({1} kills). Next rank at {2} kills.", "Ранг ветерана {0} ({1} убийств). Следующий ранг: {2} убийств.");
			Loc.Add("HIGHCOMMAND_ERR_NORUN", "No run in progress", "Забег не идёт");
			Loc.Add("HIGHCOMMAND_ERR_FAILED", "Could not recruit (gold refunded)", "Не удалось нанять (золото возвращено)");
			Loc.Add("HIGHCOMMAND_ERR_NOLINK", "No connection to the host", "Нет связи с хостом");
			Loc.Add("HIGHCOMMAND_ROLE_RANGED", "Ranged damage", "Дальний урон");
			Loc.Add("HIGHCOMMAND_ROLE_ASSASSIN", "Assassin", "Убийца");
			Loc.Add("HIGHCOMMAND_ROLE_TANK", "Tank", "Танк");
			Loc.Add("HIGHCOMMAND_ROLE_MELEE", "Melee", "Ближний бой");
			Loc.Add("HIGHCOMMAND_ROLE_CASTER", "Caster", "Заклинатель");
			Loc.Add("HIGHCOMMAND_ROLE_SNIPER", "Sniper", "Снайпер");
			Loc.Add("HIGHCOMMAND_ROLE_SUPPORT", "Support", "Поддержка");
			Loc.Add("HIGHCOMMAND_ROLE_SUMMONER", "Summoner", "Призыватель");
			Loc.Add("HIGHCOMMAND_ROLE_GENERIC", "Survivor", "Выживший");
			Loc.Add("HIGHCOMMAND_RULES_HEADER", "High Command", "Верховное командование");
			Loc.Add("HIGHCOMMAND_RULES_SUBTITLE", "Rules of the strategy mode", "Правила стратегического режима");
			Loc.Add("HIGHCOMMAND_RULES_EDIT", "Edit the High Command rules", "Изменить правила «Верховного командования»");
			Loc.Add("HIGHCOMMAND_RULE_CONFIG_NAME", "From settings", "Из настроек");
			Loc.Add("HIGHCOMMAND_RULE_GOLD", "Starting gold", "Стартовое золото");
			Loc.Add("HIGHCOMMAND_RULE_GOLD_DESC", "Gold the army starts the run with. \"From settings\" uses the value of the config file.", "Золото армии в начале забега. «Из настроек» берёт значение из файла настроек.");
			Loc.Add("HIGHCOMMAND_RULE_PRICE", "Hero prices", "Цены героев");
			Loc.Add("HIGHCOMMAND_RULE_PRICE_DESC", "Multiplier on the price of recruiting and reviving heroes.", "Множитель цены найма и воскрешения героев.");
			Loc.Add("HIGHCOMMAND_RULE_ARMY", "Army size limit", "Предел размера армии");
			Loc.Add("HIGHCOMMAND_RULE_ARMY_DESC", "The most heroes the army can have, including the starting one.", "Наибольшее число героев в армии, включая стартового.");
			Loc.Add("HIGHCOMMAND_RULE_THREAT", "Difficulty per extra hero", "Сложность за каждого героя");
			Loc.Add("HIGHCOMMAND_RULE_THREAT_DESC", "How much each hero beyond the first counts as an extra player for the game's difficulty scaling. 1 = like a real co-op player.", "Сколько «игроков» добавляет каждый герой сверх первого при расчёте сложности. 1 = как живой игрок в кооперативе.");
			Loc.Add("HIGHCOMMAND_RULE_LOOT", "Item drop rate", "Частота выпадения предметов");
			Loc.Add("HIGHCOMMAND_RULE_LOOT_DESC", "Multiplier on the chance that an enemy drops an item.", "Множитель шанса, что враг выронит предмет.");
			Loc.Add("HIGHCOMMAND_RULE_SHARING", "Item sharing", "Раздача предметов");
			Loc.Add("HIGHCOMMAND_RULE_SHARING_DESC", "How the army's items are shared between the heroes.", "Как предметы армии делятся между героями.");
			Loc.Add("HIGHCOMMAND_RULE_SHARING_SPLIT", "Split", "Делить");
			Loc.Add("HIGHCOMMAND_RULE_SHARING_SPLIT_DESC", "Every item unit belongs to one hero, like in a normal co-op run.", "Каждая единица предмета принадлежит одному герою, как в обычном кооперативе.");
			Loc.Add("HIGHCOMMAND_RULE_SHARING_MIRROR", "Mirror", "Зеркало");
			Loc.Add("HIGHCOMMAND_RULE_SHARING_MIRROR_DESC", "Every hero gets a copy of every item (much stronger).", "Каждый герой получает копию каждого предмета (намного сильнее).");
			Loc.Add("HIGHCOMMAND_CARD_TITLE", "Orders: {0}", "Приказы: {0}");
			Loc.Add("HIGHCOMMAND_CARD_NOSELECTION", "Select heroes to give orders", "Выберите героев для приказов");
			Loc.Add("HIGHCOMMAND_CARD_AUTO_ON", "Automatic use: ON (the hero uses it by itself)", "Автоприменение: ВКЛ (герой жмёт сам)");
			Loc.Add("HIGHCOMMAND_CARD_AUTO_OFF", "Automatic use: OFF (only on your command)", "Автоприменение: ВЫКЛ (только по вашей команде)");
			Loc.Add("HIGHCOMMAND_CMD_ATTACKMOVE", "Attack", "Атака");
			Loc.Add("HIGHCOMMAND_CMD_ATTACKMOVE_DESC", "Attack-move: go to the clicked point and attack everything met on the way.", "Атака-движение: идти в указанную точку и атаковать всех по пути.");
			Loc.Add("HIGHCOMMAND_CMD_STOP", "Stop", "Стоп");
			Loc.Add("HIGHCOMMAND_CMD_STOP_DESC", "Cancel every order and stand where you are.", "Отменить все приказы и встать на месте.");
			Loc.Add("HIGHCOMMAND_CMD_CANCEL", "Cancel", "Отмена");
			Loc.Add("HIGHCOMMAND_CMD_CANCEL_DESC", "While a target is being chosen (attack-move, patrol, an ability): stop choosing it. Otherwise: the selected heroes drop what they were told to do (also queued orders) and stand where they are.", "Пока выбирается цель (атака с ходу, патруль, способность) — отменить выбор. Иначе выбранные герои бросают свои приказы (и очередь) и встают на месте.");
			Loc.Add("HIGHCOMMAND_CMD_HOLD", "Hold", "Держать");
			Loc.Add("HIGHCOMMAND_CMD_HOLD_DESC", "Hold position: stand still and fight only what comes into range.", "Держать позицию: стоять и бить только тех, кто подошёл.");
			Loc.Add("HIGHCOMMAND_CMD_FOCUS", "Focus", "Фокус");
			Loc.Add("HIGHCOMMAND_CMD_FOCUS_DESC", "Focus fire: everybody attacks the clicked enemy and ignores the rest.", "Фокус-огонь: все бьют выбранного врага и игнорируют остальных.");
			Loc.Add("HIGHCOMMAND_CMD_RETREAT", "Retreat", "Отход");
			Loc.Add("HIGHCOMMAND_CMD_RETREAT_DESC", "Run to the rally point without fighting.", "Бежать к точке сбора, не вступая в бой.");
			Loc.Add("HIGHCOMMAND_CMD_PATROL", "Patrol", "Патруль");
			Loc.Add("HIGHCOMMAND_CMD_PATROL_DESC", "Patrol between the current place and the clicked point, fighting on the way.", "Патрулировать между текущим местом и указанной точкой, сражаясь по пути.");
			Loc.Add("HIGHCOMMAND_CMD_RALLY", "Rally", "Сбор");
			Loc.Add("HIGHCOMMAND_CMD_RALLY_DESC", "Set the rally point: where reinforcements land and where heroes retreat to.", "Задать точку сбора: туда приземляются новобранцы и туда отходят герои.");
			Loc.Add("HIGHCOMMAND_CMD_FORMATION", "Formation", "Строй");
			Loc.Add("HIGHCOMMAND_CMD_FORMATION_DESC", "Cycle the formation used by move orders: blob, line, column.", "Переключить построение для приказов движения: куча, линия, колонна.");
			Loc.Add("HIGHCOMMAND_CMD_SEEKENEMIES", "Seek enemies", "Искать врагов");
			Loc.Add("HIGHCOMMAND_CMD_SEEKENEMIES_DESC", "Go after the nearest enemy anywhere on the map, fight everything on the way, then take the next one. The order stays until you give another.", "Идти к ближайшему врагу на всей карте, сражаясь по пути, затем к следующему. Приказ действует, пока не дадите другой.");
			Loc.Add("HIGHCOMMAND_CMD_SEEKCHESTS", "Seek chests", "Искать сундуки");
			Loc.Add("HIGHCOMMAND_CMD_SEEKCHESTS_DESC", "Open every chest of the map the gold can pay for, nearest first; each hero takes its own one. Shops, shrines and printers are not touched.", "Открыть все сундуки карты, на которые хватает золота, сначала ближние; каждый герой идёт к своему. Магазины, святыни и принтеры не трогаются.");
			Loc.Add("HIGHCOMMAND_SEEK_ENEMIES_GO", "Seeking enemies across the map", "Ищем врагов по всей карте");
			Loc.Add("HIGHCOMMAND_SEEK_CHESTS_GO", "Seeking chests: {0} affordable", "Ищем сундуки: по карману {0}");
			Loc.Add("HIGHCOMMAND_SEEK_CHESTS_START", "Seeking chests", "Ищем сундуки");
			Loc.Add("HIGHCOMMAND_SEEK_CHESTS_NONE", "No chest left that the gold can pay for", "Нет сундуков, на которые хватает золота");
			Loc.Add("HIGHCOMMAND_HELP_SEC_CAMERA", "Camera", "Камера");
			Loc.Add("HIGHCOMMAND_HELP_SEC_SELECT", "Selection", "Выделение");
			Loc.Add("HIGHCOMMAND_HELP_SEC_GENERAL", "General", "Общее");
			Loc.Add("HIGHCOMMAND_HELP_SEC_ORDERS", "Orders", "Приказы");
			Loc.Add("HIGHCOMMAND_HELP_SEC_ARMY", "Army and commander", "Армия и командир");
			Loc.Add("HIGHCOMMAND_HELP_CLOSE", "F1 or Esc to close", "F1 или Esc — закрыть");
			Loc.Add("HIGHCOMMAND_HELP_SEEK", "Seek enemies / chests across the map", "Искать врагов / сундуки по всей карте");
			Loc.Add("HIGHCOMMAND_CMD_STANCE_AGGRESSIVE", "Aggressive", "Агресс.");
			Loc.Add("HIGHCOMMAND_CMD_STANCE_AGGRESSIVE_DESC", "Stance: chase every enemy that is seen.", "Стойка: преследовать каждого замеченного врага.");
			Loc.Add("HIGHCOMMAND_CMD_STANCE_DEFENSIVE", "Defensive", "Защита");
			Loc.Add("HIGHCOMMAND_CMD_STANCE_DEFENSIVE_DESC", "Stance: fight near the post and return afterwards.", "Стойка: драться у своего поста и возвращаться.");
			Loc.Add("HIGHCOMMAND_CMD_STANCE_PASSIVE", "Passive", "Пассив");
			Loc.Add("HIGHCOMMAND_CMD_STANCE_PASSIVE_DESC", "Stance: never start a fight, defend only when hit.", "Стойка: не начинать бой, защищаться только когда бьют.");
			Loc.Add("HIGHCOMMAND_COMMANDER_TITLE", "Commander abilities", "Способности командира");
			Loc.Add("HIGHCOMMAND_ABILITY_0_NAME", "Orbital strike", "Удар с орбиты");
			Loc.Add("HIGHCOMMAND_ABILITY_0_DESC", "Three blasts at the clicked point after a short warning. Hits enemies only; the damage grows with the stage.", "Три взрыва в указанной точке после короткого предупреждения. Бьёт только врагов; урон растёт со стадией.");
			Loc.Add("HIGHCOMMAND_ABILITY_1_NAME", "Field medic", "Медик");
			Loc.Add("HIGHCOMMAND_ABILITY_1_DESC", "Heals every hero for 40% of their health and adds a small barrier.", "Лечит каждого героя на 40% здоровья и даёт небольшой барьер.");
			Loc.Add("HIGHCOMMAND_ABILITY_2_NAME", "War cry", "Боевой клич");
			Loc.Add("HIGHCOMMAND_ABILITY_2_DESC", "Every hero gets bonus attack and movement speed for 12 seconds.", "Каждый герой получает бонус к скорости атаки и движения на 12 секунд.");
			Loc.Add("HIGHCOMMAND_ABILITY_3_NAME", "Mark", "Метка");
			Loc.Add("HIGHCOMMAND_ABILITY_3_DESC", "Mark an enemy: it takes extra damage for 10 seconds and every hero attacks it.", "Пометить врага: он получает больше урона 10 секунд, и все герои атакуют его.");
			Loc.Add("HIGHCOMMAND_ABILITY_COOLDOWN", "Ability is recharging: {0} s", "Способность перезаряжается: {0} с");
			Loc.Add("HIGHCOMMAND_ABILITY_COOLDOWN_INFO", "Cooldown: {0} s", "Перезарядка: {0} с");
			Loc.Add("HIGHCOMMAND_ABILITY_NOHEROES", "No living heroes", "Нет живых героев");
			Loc.Add("HIGHCOMMAND_ABILITY_NOTARGET", "Click on an enemy", "Нажмите на врага");
			Loc.Add("HIGHCOMMAND_HINT_ABILITY_POINT", "Click a point for the strike (right click cancels)", "Нажмите точку для удара (правая кнопка - отмена)");
			Loc.Add("HIGHCOMMAND_HINT_ABILITY_TARGET", "Click an enemy to mark it (right click cancels)", "Нажмите на врага, чтобы пометить (правая кнопка - отмена)");
			Loc.Add("HIGHCOMMAND_HELP_ABILITIES", "Commander abilities", "Способности командира");
			Loc.Add("HIGHCOMMAND_CURSOR_MOVE", "Move", "Идти");
			Loc.Add("HIGHCOMMAND_CURSOR_ATTACK", "Attack", "Атаковать");
			Loc.Add("HIGHCOMMAND_CURSOR_FOLLOW", "Follow", "Следовать");
			Loc.Add("HIGHCOMMAND_CURSOR_INTERACT", "Use", "Использовать");
			Loc.Add("HIGHCOMMAND_CURSOR_SELECT", "Select", "Выбрать");
			Loc.Add("HIGHCOMMAND_CURSOR_QUEUE", " (queued)", " (в очередь)");
			Loc.Add("HIGHCOMMAND_MENU_ORDERS", "Orders", "Приказы");
			Loc.Add("HIGHCOMMAND_MENU_ORDERS_DESC", "Stop, hold, retreat, patrol, focus fire, seek enemies or chests, rally point, formation. The right mouse button already does the rest: move, attack, follow, use.", "Стоп, держать, отход, патруль, фокус, поиск врагов и сундуков, точка сбора, строй. Остальное делает правая кнопка мыши: идти, атаковать, следовать, использовать.");
			Loc.Add("HIGHCOMMAND_MENU_STANCE", "Stance", "Стойка");
			Loc.Add("HIGHCOMMAND_PRICE_LUNAR", "{0} lunar", "{0} лун.");
			Loc.Add("HIGHCOMMAND_PRICE_HEALTH", "{0}% HP", "{0}% здоровья");
			Loc.Add("HIGHCOMMAND_PRICE_ITEM", "{0} item", "предмет x{0}");
			Loc.Add("HIGHCOMMAND_LOOT_NEEDGOLD", "Not enough gold: ${0}", "Не хватает золота: ${0}");
			Loc.Add("HIGHCOMMAND_LOOT_CANNOTPAY", "The army cannot pay for this", "Армии нечем за это заплатить");
			Loc.Add("HIGHCOMMAND_LOOT_GOING", "{0} — {1}", "{0} — {1}");
			Loc.Add("HIGHCOMMAND_LOOT_FAILED_GOLD", "{0}: not enough gold (${1})", "{0}: не хватило золота (${1})");
			Loc.Add("HIGHCOMMAND_LOOT_FAILED_PRICE", "{0} has nothing to pay with", "{0}: нечем заплатить");
			Loc.Add("HIGHCOMMAND_LOOT_FAILED_REACH", "{0} cannot get there", "{0}: не может туда дойти");
			Loc.Add("HIGHCOMMAND_TOP_CHESTS", "chests {0}/{1}", "сундуки {0}/{1}");
			Loc.Add("HIGHCOMMAND_TOP_ARMYLIMIT", "limit {0}", "лимит {0}");
			Loc.Add("HIGHCOMMAND_TOP_NEXTHERO", "Next hero", "Следующий герой");
			Loc.Add("HIGHCOMMAND_TOP_ITEMS", "Items", "Предметы");
			Loc.Add("HIGHCOMMAND_TOP_ITEMS_COUNT", "the army has {0}", "у армии: {0}");
			Loc.Add("HIGHCOMMAND_TOP_INCOME", "+{0}/min", "+{0}/мин");
			Loc.Add("HIGHCOMMAND_TOP_BARRACKS_TIP", "Open the barracks: recruit heroes and buy army upgrades.", "Открыть казарму: нанять героев и купить улучшения армии.");
			Loc.Add("HIGHCOMMAND_REVIVE_NONE", "Nobody has fallen", "Никто не пал");
			Loc.Add("HIGHCOMMAND_REVIVE_ALIVE", "The hero is alive", "Герой жив");
			Loc.Add("HIGHCOMMAND_REVIVED", "Revived: {0}", "Воскрешён: {0}");
			Loc.Add("HIGHCOMMAND_ALERT_DIED", "{0} has fallen", "{0} погиб");
			Loc.Add("HIGHCOMMAND_ALERT_LOWHP", "{0} is almost dead", "{0} на грани гибели");
			Loc.Add("HIGHCOMMAND_HELP_ALERT", "Fly to the last alert", "Перелёт к последнему оповещению");
			Loc.Add("HIGHCOMMAND_HELP_REVIVE", "Revive the first fallen hero", "Воскресить первого павшего героя");
			Loc.Add("HIGHCOMMAND_HELP_TELEPORTER", "Teleporter: activate / gather / leave", "Телепорт: запустить / собраться / уйти");
			Loc.Add("HIGHCOMMAND_TP_NONE", "No teleporter on this stage", "На этой стадии нет телепорта");
			Loc.Add("HIGHCOMMAND_TP_NOHEROES", "No living heroes", "Нет живых героев");
			Loc.Add("HIGHCOMMAND_TP_ACTIVATING", "The nearest hero activates the teleporter", "Ближайший герой запускает телепорт");
			Loc.Add("HIGHCOMMAND_TP_LEAVING", "The nearest hero goes to leave the stage", "Ближайший герой идёт, чтобы покинуть стадию");
			Loc.Add("HIGHCOMMAND_TP_GATHER", "The army gathers at the teleporter", "Армия собирается у телепорта");
			Loc.Add("HIGHCOMMAND_TP_BUSY", "The teleporter is busy", "Телепорт занят");
			Loc.Add("HIGHCOMMAND_TP_BTN_ACTIVATE", "Start tele", "Запуск");
			Loc.Add("HIGHCOMMAND_TP_BTN_GATHER", "Gather", "Собраться");
			Loc.Add("HIGHCOMMAND_TP_BTN_LEAVE", "Leave", "Уйти");
			Loc.Add("HIGHCOMMAND_TP_BTN_LEAVING", "...", "...");
			Loc.Add("HIGHCOMMAND_TP_BTN_NONE", "No tele", "Нет");
			Loc.Add("HIGHCOMMAND_TP_TITLE", "Teleporter", "Телепорт");
			Loc.Add("HIGHCOMMAND_TP_DESC", "One button for the whole teleporter routine: the nearest hero activates it, the army gathers inside the zone while it charges, and once it is charged and the boss is dead the same button takes the army to the next stage.", "Одна кнопка на весь телепорт: ближайший герой запускает его, армия собирается в зоне, пока он заряжается, а когда он заряжен и босс убит, та же кнопка уводит армию на следующую стадию.");
			Loc.Add("HIGHCOMMAND_TP_STATE_IDLE", "Teleporter: click or [{0}] to start", "Телепорт: клик или [{0}] — запуск");
			Loc.Add("HIGHCOMMAND_TP_STATE_CHARGING", "Teleporter charging: {0}%", "Телепорт заряжается: {0}%");
			Loc.Add("HIGHCOMMAND_TP_STATE_BOSS", "Zone full - kill the boss!", "Зона заряжена - убейте босса!");
			Loc.Add("HIGHCOMMAND_TP_STATE_CHARGED", "Charged! Click or [{0}] to leave", "Заряжен! Клик или [{0}] — уйти");
			Loc.Add("HIGHCOMMAND_TP_STATE_LEAVING", "Leaving the stage...", "Уходим со стадии...");
			Loc.Add("HIGHCOMMAND_DEFEAT_CAN_REVIVE", "ALL HEROES HAVE FALLEN! Revive one within {0} s [{1}] or the run is lost (or click here)", "ВСЕ ГЕРОИ ПАЛИ! Воскресите одного за {0} с [{1}], иначе забег проигран (или нажмите сюда)");
			Loc.Add("HIGHCOMMAND_DEFEAT_AUTO_REVIVE", "ALL HEROES HAVE FALLEN! Automatic revival in {0} s (${1}), or press [{2}] now (or click here)", "ВСЕ ГЕРОИ ПАЛИ! Автовоскрешение через {0} с (${1}) или [{2}] сразу (или нажмите сюда)");
			Loc.Add("HIGHCOMMAND_DEFEAT_BROKE", "ALL HEROES HAVE FALLEN and there is no gold to revive: the run ends in {0} s", "ВСЕ ГЕРОИ ПАЛИ, а золота на воскрешение нет: забег закончится через {0} с");
			Loc.Add("HIGHCOMMAND_ROSTER_REVIVE", "Revive: ${0}", "Воскресить: ${0}");
			Loc.Add("HIGHCOMMAND_ROSTER_FALLEN", "Fallen. Click to revive for ${0}.", "Пал. Нажмите, чтобы воскресить за ${0}.");
			Loc.Add("HIGHCOMMAND_ROSTER_HINT", "Click: select. Shift+click: add to the selection. Double click: fly the camera to the hero.", "Клик: выбрать. Shift+клик: добавить. Двойной клик: перелететь камерой к герою.");
			Loc.Add("HIGHCOMMAND_ORDER_MOVE", "moving", "идёт");
			Loc.Add("HIGHCOMMAND_ORDER_ATTACKMOVE", "attack-move", "атака-движение");
			Loc.Add("HIGHCOMMAND_ORDER_ATTACK", "attacking", "атакует");
			Loc.Add("HIGHCOMMAND_ORDER_HOLD", "holding", "держит");
			Loc.Add("HIGHCOMMAND_ORDER_FOLLOW", "following", "следует");
			Loc.Add("HIGHCOMMAND_ORDER_RETREAT", "retreating", "отходит");
			Loc.Add("HIGHCOMMAND_ORDER_PATROL", "patrolling", "патрулирует");
			Loc.Add("HIGHCOMMAND_ORDER_INTERACT", "using an object", "использует объект");
			Loc.Add("HIGHCOMMAND_ORDER_CAST", "casting", "применяет умение");
			Loc.Add("HIGHCOMMAND_ORDER_SEEKENEMIES", "seeking enemies", "ищет врагов");
			Loc.Add("HIGHCOMMAND_ORDER_SEEKCHESTS", "seeking chests", "ищет сундуки");
			Loc.Add("HIGHCOMMAND_HELP_INVENTORY", "Items: who carries what, drag to give", "Предметы: у кого что, перетащите, чтобы передать");
			Loc.Add("HIGHCOMMAND_INV_TITLE", "Army items ({0} total)", "Предметы армии (всего {0})");
			Loc.Add("HIGHCOMMAND_INV_HINT_SPLIT", "Drag an item onto another hero to give it. Shift = the whole stack. Esc closes.", "Перетащите предмет на другого героя, чтобы отдать. Shift - вся стопка. Esc закрывает.");
			Loc.Add("HIGHCOMMAND_INV_HINT_MIRROR", "Mirror mode: every hero has every item, nothing to move. Esc closes.", "Режим «зеркало»: у каждого героя есть все предметы, передавать нечего. Esc закрывает.");
			Loc.Add("HIGHCOMMAND_INV_AUTO", "Auto-distribute", "Раздать заново");
			Loc.Add("HIGHCOMMAND_INV_AUTO_DONE", "Items redistributed by role", "Предметы розданы заново по ролям");
			Loc.Add("HIGHCOMMAND_INV_EMPTY", "no items yet", "предметов пока нет");
			Loc.Add("HIGHCOMMAND_INV_MORE", "+{0} more", "ещё +{0}");
			Loc.Add("HIGHCOMMAND_INV_EQUIPMENT", "Equipment", "Снаряжение");
			Loc.Add("HIGHCOMMAND_INV_SPARE", "Spare equipment (drag onto a hero):", "Запасное снаряжение (перетащите на героя):");
			Loc.Add("HIGHCOMMAND_INV_NOEQUIP", "no equipment", "без снаряжения");
			Loc.Add("HIGHCOMMAND_INV_MOVED", "{0} -> {1}: {2}", "{0} -> {1}: {2}");
			Loc.Add("HIGHCOMMAND_INV_COUNT", "Owned: {0}", "В наличии: {0}");
			Loc.Add("HIGHCOMMAND_INV_DEAD", "fallen", "пал");
		}
	}
	[BepInPlugin("kantemiir.HighCommand", "HighCommand", "0.16.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private class Provider : IContentPackProvider
		{
			public string identifier => "kantemiir.HighCommand";

			public IEnumerator LoadStaticContentAsync(LoadStaticContentAsyncArgs args)
			{
				yield return RunPrefabBuilder.Build(Pack);
				args.ReportProgress(1f);
			}

			public IEnumerator GenerateContentPackAsync(GetContentPackAsyncArgs args)
			{
				ContentPack.Copy(Pack, args.output);
				args.ReportProgress(1f);
				yield break;
			}

			public IEnumerator FinalizeAsync(FinalizeAsyncArgs args)
			{
				args.ReportProgress(1f);
				yield break;
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static CollectContentPackProvidersDelegate <>9__8_0;

			internal void <Awake>b__8_0(AddContentPackProviderDelegate add)
			{
				add.Invoke((IContentPackProvider)(object)new Provider());
			}
		}

		public const string Guid = "kantemiir.HighCommand";

		public const string Name = "HighCommand";

		public const string Version = "0.16.0";

		internal static Plugin Instance;

		internal static ManualLogSource Log;

		internal static string PluginDirectory;

		internal static ContentPack Pack;

		private Harmony harmony;

		private void Awake()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			PluginDirectory = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Pack = new ContentPack();
			typeof(ContentPack).GetField("_identifier", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(Pack, "kantemiir.HighCommand");
			object obj = <>c.<>9__8_0;
			if (obj == null)
			{
				CollectContentPackProvidersDelegate val = delegate(AddContentPackProviderDelegate add)
				{
					add.Invoke((IContentPackProvider)(object)new Provider());
				};
				<>c.<>9__8_0 = val;
				obj = (object)val;
			}
			ContentManager.collectContentPackProviders += (CollectContentPackProvidersDelegate)obj;
			harmony = new Harmony("kantemiir.HighCommand");
			Settings.Init(((BaseUnityPlugin)this).Config);
			Strings.Register();
			Pack.entityStateTypes.Add(new Type[1] { typeof(HeroAIState) });
			TryPatch(typeof(LanguagePatches), "language tokens");
			TryPatch(typeof(LobbyPatches.MultiplayerMenu), "game mode in the multiplayer menu");
			TryPatch(typeof(LobbyPatches.LocalMultiplayerMenu), "game mode in the local multiplayer menu");
			TryPatch(typeof(RunRulePatch), "forced rule choices");
			TryPatch(typeof(MenuButton), "Extra Game Mode menu button (on the screen switch)");
			TryPatch(typeof(RunPatches.NoCommanderBody), "commander has no body");
			TryPatch(typeof(RunPatches.LivingPlayerCount), "living player count = living heroes");
			TryPatch(typeof(LobbyRules.InitPatch), "lobby rules category");
			TryPatch(typeof(RunPatches.DirectorSpawnTarget), "director spawns around heroes");
			TryPatch(typeof(RunPatches.NoFriendlyFire), "no friendly fire inside the army");
			TryPatch(typeof(RunPatches.ActivityGameMode), "no platform-activity error for the game mode");
			ClientRoot.EscapeGuardActive = TryPatch(typeof(RunPatches.EscapeGuard), "Esc closes the mode's panels before it pauses");
			TryPatch(typeof(RunPatches.ZoneCountInRadius), "holdout zones count heroes inside");
			TryPatch(typeof(RunPatches.ZoneCountLiving), "holdout zones count living heroes");
			TryPatch(typeof(RunPatches.ParticipatingPlayers), "army size scales the run like extra players");
			TryPatch(typeof(EconomyPatches.KillGold), "kill gold goes to the army purse");
			TryPatch(typeof(EconomyPatches.RememberVictim), "gold popup position");
			TryPatch(typeof(EconomyPatches.DirectGold), "direct gold goes to the army purse");
			TryPatch(typeof(LootPatches.LostDroplets), "item droplets that never land go to the pool");
			TryPatch(typeof(LootPatches.WorldPickups), "world pickups go to the pool");
			TryPatch(typeof(LootPatches.KillDrops), "enemies drop items (option)");
			TryPatch(typeof(LootPatches.NoPaidInteractables), "no paid interactables (option)");
			TryPatch(typeof(Purse.Affordable), "heroes buy with the army purse");
			TryPatch(typeof(Purse.Pay), "heroes pay from the army purse");
			TryPatch(typeof(GameOverStatsPatch), "army statistics on the end-of-run screen");
			TryPatch(typeof(UpgradeStatsPatch), "army upgrades and veteran ranks");
			try
			{
				if (Chainloader.PluginInfos.ContainsKey("com.rune580.riskofoptions"))
				{
					OptionsIntegration.Register();
				}
			}
			catch (Exception ex)
			{
				Log.LogWarning((object)("Mod Options not registered: " + ex.Message));
			}
			try
			{
				AutoExec.Install();
			}
			catch (Exception ex2)
			{
				Log.LogWarning((object)("AutoExec not installed: " + ex2.Message));
			}
			Log.LogInfo((object)("HighCommand 0.16.0 loaded (game build " + RoR2Application.GetBuildId() + ")"));
		}

		private void OnDestroy()
		{
			try
			{
				Harmony obj = harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
			}
			catch (Exception)
			{
			}
		}

		internal static bool TryPatch(Type patchClass, string what)
		{
			try
			{
				Instance.harmony.CreateClassProcessor(patchClass).Patch();
				Log.LogInfo((object)("Patch applied: " + what));
				return true;
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Patch FAILED ({what}): {arg}");
				return false;
			}
		}
	}
}
namespace HighCommand.UI
{
	internal sealed class AbilityTile
	{
		internal static readonly Color[] Colors = (Color[])(object)new Color[4]
		{
			new Color(1f, 0.46f, 0.2f, 1f),
			new Color(0.36f, 0.92f, 0.5f, 1f),
			new Color(1f, 0.8f, 0.24f, 1f),
			new Color(0.76f, 0.48f, 1f, 1f)
		};

		internal static readonly Glyph[] Glyphs = new Glyph[4]
		{
			Glyph.OrbitalStrike,
			Glyph.Medic,
			Glyph.WarCry,
			Glyph.Mark
		};

		private const float Cut = 6f;

		private const float WellCut = 5f;

		private const float WellInset = 5f;

		private const float WellH = 48f;

		private const float GlyphSize = 36f;

		private const float FlashTime = 0.8f;

		private static readonly Color Base = new Color(0.07f, 0.09f, 0.12f, 0.96f);

		private static readonly Color WellBase = new Color(0.05f, 0.06f, 0.08f, 1f);

		private static readonly Color Spent = new Color(0.6f, 0.65f, 0.72f, 0.75f);

		internal readonly RectTransform Root;

		internal readonly TextMeshProUGUI Label;

		private readonly Image frame;

		private readonly Image fill;

		private readonly Image well;

		private readonly Image glow;

		private readonly Image glyph;

		private readonly Image sweep;

		private readonly Image barFill;

		private readonly TextMeshProUGUI seconds;

		private readonly TextMeshProUGUI hint;

		private readonly Image keyCap;

		private readonly Color color;

		private bool wasReady = true;

		private float flashUntil;

		private int shownSeconds = -1;

		private Color shownFrame;

		private Color shownFill;

		private Color shownWell;

		private Color shownGlow;

		private Color shownGlyph;

		private Color shownBar;

		private Color shownLabel;

		private bool colorsKnown;

		internal bool Hover { get; private set; }

		internal static Color ColorOf(int index)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return Colors[Mathf.Clamp(index, 0, Colors.Length - 1)];
		}

		internal static Glyph GlyphOf(int index)
		{
			return Glyphs[Mathf.Clamp(index, 0, Glyphs.Length - 1)];
		}

		internal AbilityTile(Transform parent, int index, Vector2 size)
		{
			//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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: 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_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: 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_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Unknown result type (might be due to invalid IL or missing references)
			color = ColorOf(index);
			Root = UiKit.NewRect("Ability" + index, parent);
			RectTransform root = Root;
			RectTransform root2 = Root;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(0f, 1f);
			root2.anchorMax = val;
			root.anchorMin = val;
			Root.pivot = new Vector2(0f, 1f);
			Root.sizeDelta = size;
			frame = ((Component)Root).gameObject.AddComponent<Image>();
			UiKit.StyleOutline(frame, 6f);
			((Graphic)frame).raycastTarget = false;
			fill = UiKit.NewFill("Fill", (Transform)(object)Root, Base, 6f);
			well = UiKit.NewImage("Well", (Transform)(object)Root, UiKit.Shape(5f), WellBase);
			well.type = (Type)1;
			RectTransform rectTransform = ((Graphic)well).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.offsetMin = new Vector2(5f, -53f);
			rectTransform.offsetMax = new Vector2(-5f, -5f);
			RectTransform rectTransform2 = ((Graphic)UiKit.NewImage("Sheen", (Transform)(object)rectTransform, UiKit.White, new Color(1f, 1f, 1f, 0.12f))).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 1f);
			rectTransform2.anchorMax = new Vector2(1f, 1f);
			rectTransform2.pivot = new Vector2(0.5f, 1f);
			rectTransform2.offsetMin = new Vector2(6f, -1f);
			rectTransform2.offsetMax = Vector2.zero;
			glow = UiKit.NewImage("Glow", (Transform)(object)rectTransform, UiKit.Glow, color);
			UiKit.Place(((Graphic)glow).rectTransform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(70f, 70f));
			glyph = UiKit.NewImage("Glyph", (Transform)(object)rectTransform, UiKit.GlyphSprite(GlyphOf(index)), Color.white);
			glyph.preserveAspect = true;
			UiKit.Place(((Graphic)glyph).rectTransform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(36f, 36f));
			sweep = UiKit.NewImage("Sweep", (Transform)(object)rectTransform, UiKit.Circle, new Color(0f, 0f, 0f, 0.6f));
			UiKit.Place(((Graphic)sweep).rectTransform, new Vector2(0.5f, 0.5f), new Vector2(0.5f, 0.5f), Vector2.zero, new Vector2(44f, 44f));
			sweep.type = (Type)3;
			sweep.fillMethod = (FillMethod)4;
			sweep.fillOrigin = 2;
			sweep.fillClockwise = false;
			sweep.fillAmount = 0f;
			seconds = UiKit.NewText("Seconds", (Transform)(object)rectTransform, "", 22f, UiKit.Gold, (TextAlignmentOptions)514);
			UiKit.Stretch(((TMP_Text)seconds).rectTransform);
			Label = UiKit.NewText("Label", (Transform)(object)Root, "", 12f, UiKit.Text, (TextAlignmentOptions)514);
			UiKit.Stretch(((TMP_Text)Label).rectTransform, 2f, 9f, 2f, 55f);
			((TMP_Text)Label).enableAutoSizing = true;
			((TMP_Text)Label).fontSizeMin = 9f;
			((TMP_Text)Label).fontSizeMax = 12f;
			RectTransform rectTransform3 = ((Graphic)UiKit.NewImage("ChargeBack", (Transform)(object)Root, UiKit.White, new Color(0f, 0f, 0f, 0.55f))).rectTransform;
			rectTransform3.anchorMin = new Vector2(0f, 0f);
			rectTransform3.anchorMax = new Vector2(1f, 0f);
			rectTransform3.pivot = new Vector2(0.5f, 0f);
			rectTransform3.offsetMin = new Vector2(5f, 4f);
			rectTransform3.offsetMax = new Vector2(-11f, 7f);
			barFill = UiKit.NewImage("Charge", (Transform)(object)rectTransform3, UiKit.White, color);
			UiKit.Stretch(((Graphic)barFill).rectTransform);
			barFill.type = (Type)3;
			barFill.fillMethod = (FillMethod)0;
			barFill.fillOrigin = 0;
			barFill.fillAmount = 1f;
			keyCap = UiKit.NewImage("KeyCap", (Transform)(object)Root, UiKit.White, new Color(0.02f, 0.03f, 0.05f, 0.85f));
			UiKit.Place(((Graphic)keyCap).rectTransform, new Vector2(1f, 1f), new Vector2(1f, 1f), new Vector2(-3f, -3f), new Vector2(18f, 14f));
			hint = UiKit.NewText("Hint", (Transform)(object)((Graphic)keyCap).rectTransform, "", 11f, UiKit.TextDim, (TextAlignmentOptions)514);
			UiKit.Stretch(((TMP_Text)hint).rectTransform);
		}

		internal void SetPosition(float x, float y)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			Root.anchoredPosition = new Vector2(x, 0f - y);
		}

		internal void SetHint(string key)
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			key = key ?? "";
			UiKit.SetText((TMP_Text)(object)hint, key);
			((Behaviour)keyCap).enabled = key.Length > 0;
			((Graphic)keyCap).rectTransform.sizeDelta = new Vector2(Mathf.Clamp((float)key.Length * 7f + 6f, 14f, 46f), 14f);
		}

		internal bool Refresh(Vector2 mouse, float left, float total, bool active)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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_00ee: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: 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_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cc: 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_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			Hover = UiKit.Contains(Root, mouse);
			bool flag = left <= 0f;
			float unscaledTime = Time.unscaledTime;
			if (flag && !wasReady)
			{
				flashUntil = unscaledTime + 0.8f;
			}
			wasReady = flag;
			float num = Mathf.Clamp01((flashUntil - unscaledTime) / 0.8f);
			float num2 = (active ? (0.5f + 0.5f * Mathf.Sin(unscaledTime * 7f)) : 0f);
			Color val = (active ? Color.Lerp(color, Color.white, 0.2f + 0.3f * num2) : (Hover ? Color.Lerp(color, Color.white, 0.4f) : color));
			val.a = ((active || Hover) ? 1f : (flag ? 0.7f : 0.35f));
			val = Color.Lerp(val, Color.white, num * 0.85f);
			Color val2 = Color.Lerp(Base, color, active ? 0.2f : (Hover ? 0.14f : 0.07f));
			val2.a = Base.a;
			Color val3 = Color.Lerp(WellBase, color, (!flag) ? 0.1f : (active ? 0.42f : (Hover ? 0.36f : 0.27f)));
			val3.a = 1f;
			Color val4 = color;
			val4.a = (flag ? Mathf.Clamp01(0.7f + (Hover ? 0.2f : 0f) + 0.3f * num2 + 0.5f * num) : 0.12f);
			Color val5 = (flag ? Color.Lerp(color, Color.white, (active || Hover) ? 0.8f : 0.6f) : Spent);
			Color val6 = color;
			val6.a = (flag ? 0.95f : 0.45f);
			Color val7 = (flag ? UiKit.Text : UiKit.TextDim);
			if (!colorsKnown || val != shownFrame)
			{
				((Graphic)frame).color = (shownFrame = val);
			}
			if (!colorsKnown || val2 != shownFill)
			{
				((Graphic)fill).color = (shownFill = val2);
			}
			if (!colorsKnown || val3 != shownWell)
			{
				((Graphic)well).color = (shownWell = val3);
			}
			if (!colorsKnown || val4 != shownGlow)
			{
				((Graphic)glow).color = (shownGlow = val4);
			}
			if (!colorsKnown || val5 != shownGlyph)
			{
				((Graphic)glyph).color = (shownGlyph = val5);
			}
			if (!colorsKnown || val6 != shownBar)
			{
				((Gra