using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using Auuueser.EnemyHealthBars.Core.Configuration;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("EnemyHealthBars.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+acb061bd561295755ea67507eed9dd688145cd1f")]
[assembly: AssemblyProduct("EnemyHealthBars.Core")]
[assembly: AssemblyTitle("EnemyHealthBars.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Auuueser.EnemyHealthBars.Core.Presentation
{
	public static class HealthTextFormatter
	{
		public static string Format(int currentHealth, int maxHealth, HealthTextFormat format)
		{
			if (currentHealth < 0)
			{
				currentHealth = 0;
			}
			if (maxHealth < 0)
			{
				maxHealth = 0;
			}
			switch (format)
			{
			case HealthTextFormat.CurrentOnly:
				return currentHealth.ToString();
			case HealthTextFormat.PercentOnly:
			{
				if (maxHealth <= 0)
				{
					return "0%";
				}
				int num = (int)Math.Round((double)currentHealth * 100.0 / (double)maxHealth);
				if (num < 0)
				{
					num = 0;
				}
				else if (num > 100)
				{
					num = 100;
				}
				return num + "%";
			}
			default:
				return currentHealth + " / " + maxHealth;
			}
		}
	}
}
namespace Auuueser.EnemyHealthBars.Core.GameData
{
	public readonly record struct EnemyHealthDefault(string EnemyName, int MaxHealth);
	public static class EnemyHealthDefaults
	{
		public const string Source = "Lethal Company_Data; Unity 2022.3.62f2; Assembly-CSharp.dll; assets=41; generator=tools/generate_enemy_health_defaults.py";

		public static readonly EnemyHealthDefault[] Items = new EnemyHealthDefault[33]
		{
			new EnemyHealthDefault("Baboon hawk", 4),
			new EnemyHealthDefault("Blob", 3),
			new EnemyHealthDefault("Bunker Spider", 5),
			new EnemyHealthDefault("Bush Wolf", 7),
			new EnemyHealthDefault("Butler", 8),
			new EnemyHealthDefault("Butler Bees", 3),
			new EnemyHealthDefault("Cadaver Bloom", 4),
			new EnemyHealthDefault("Cadaver Growths", 3),
			new EnemyHealthDefault("Centipede", 3),
			new EnemyHealthDefault("Clay Surgeon", 3),
			new EnemyHealthDefault("Crawler", 4),
			new EnemyHealthDefault("Docile Locust Bees", 3),
			new EnemyHealthDefault("Earth Leviathan", 3),
			new EnemyHealthDefault("Feiopar", 4),
			new EnemyHealthDefault("Flowerman", 5),
			new EnemyHealthDefault("ForestGiant", 38),
			new EnemyHealthDefault("GiantKiwi", 28),
			new EnemyHealthDefault("Girl", 3),
			new EnemyHealthDefault("Hoarding bug", 3),
			new EnemyHealthDefault("Jester", 3),
			new EnemyHealthDefault("Lasso", 3),
			new EnemyHealthDefault("Maneater", 5),
			new EnemyHealthDefault("Manticoil", 2),
			new EnemyHealthDefault("Masked", 4),
			new EnemyHealthDefault("MouthDog", 12),
			new EnemyHealthDefault("Nutcracker", 5),
			new EnemyHealthDefault("Puffer", 3),
			new EnemyHealthDefault("RadMech", 3),
			new EnemyHealthDefault("Red Locust Bees", 3),
			new EnemyHealthDefault("Red pill", 3),
			new EnemyHealthDefault("Spring", 3),
			new EnemyHealthDefault("Stingray", 4),
			new EnemyHealthDefault("Tulip Snake", 3)
		};
	}
	public sealed class EnemyMaxHealthLookup
	{
		private readonly Dictionary<string, int> maxHealthByName = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

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

		public int UnresolvedCount => unresolvedNames.Count;

		public EnemyMaxHealthLookup(EnemyHealthDefault[] defaults)
		{
			if (defaults == null)
			{
				throw new ArgumentNullException("defaults");
			}
			for (int i = 0; i < defaults.Length; i++)
			{
				EnemyHealthDefault enemyHealthDefault = defaults[i];
				if (!string.IsNullOrWhiteSpace(enemyHealthDefault.EnemyName) && enemyHealthDefault.MaxHealth > 0)
				{
					maxHealthByName[enemyHealthDefault.EnemyName] = enemyHealthDefault.MaxHealth;
				}
			}
		}

		public int StoreResolvedStrictMaxHealth(string? key, int resolvedMaxHealth)
		{
			if (string.IsNullOrWhiteSpace(key))
			{
				return 0;
			}
			if (resolvedMaxHealth > 0)
			{
				unresolvedNames.Remove(key);
				maxHealthByName[key] = resolvedMaxHealth;
				return resolvedMaxHealth;
			}
			unresolvedNames.Add(key);
			return 0;
		}

		public bool TryGetStrictMaxHealth(string? key, out int maxHealth)
		{
			maxHealth = 0;
			if (!string.IsNullOrWhiteSpace(key))
			{
				return maxHealthByName.TryGetValue(key, out maxHealth);
			}
			return false;
		}

		public bool IsUnresolved(string? key)
		{
			if (!string.IsNullOrWhiteSpace(key))
			{
				return unresolvedNames.Contains(key);
			}
			return false;
		}

		public string FormatUnresolvedNamesForDiagnostics(int maxNames)
		{
			if (unresolvedNames.Count == 0)
			{
				return "none";
			}
			if (maxNames < 1)
			{
				maxNames = 1;
			}
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			foreach (string unresolvedName in unresolvedNames)
			{
				if (num >= maxNames)
				{
					break;
				}
				if (num > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(unresolvedName);
				num++;
			}
			if (unresolvedNames.Count > num)
			{
				stringBuilder.Append(", +");
				stringBuilder.Append(unresolvedNames.Count - num);
				stringBuilder.Append(" more");
			}
			return stringBuilder.ToString();
		}
	}
	public static class EnemySpecialMaxHealthRules
	{
		private const int ButlerSinglePlayerMaxHealth = 2;

		private const int ManeaterBabyKillableMaxHealth = -1;

		public static int ResolveButlerMaxHealth(int generatedMaxHealth, int connectedPlayersAmount)
		{
			if (connectedPlayersAmount != 0)
			{
				return generatedMaxHealth;
			}
			return 2;
		}

		public static int ResolveManeaterMaxHealth(int generatedMaxHealth, int currentBehaviourStateIndex)
		{
			if (currentBehaviourStateIndex != 0)
			{
				return generatedMaxHealth;
			}
			return -1;
		}
	}
}
namespace Auuueser.EnemyHealthBars.Core.Domain
{
	public readonly record struct EnemyHealthSample(int EnemyId, string DisplayName, int CurrentHealth, int MaxHealth, bool IsDead)
	{
		public EnemyHealthSample(int EnemyId, string DisplayName, int CurrentHealth, int MaxHealth, bool IsDead)
		{
			this.EnemyId = EnemyId;
			this.DisplayName = DisplayName;
			this.CurrentHealth = CurrentHealth;
			this.MaxHealth = MaxHealth;
			this.IsDead = IsDead;
		}

		public EnemyHealthSample(int EnemyId, string DisplayName, int CurrentHealth, bool IsDead)
			: this(EnemyId, DisplayName, CurrentHealth, 0, IsDead)
		{
		}
	}
	public readonly record struct EnemyHealthSnapshot(int EnemyId, string DisplayName, int CurrentHealth, int MaxHealth, bool IsDead)
	{
		public float HealthFraction
		{
			get
			{
				if (MaxHealth <= 0)
				{
					return 0f;
				}
				float num = (float)CurrentHealth / (float)MaxHealth;
				if (num < 0f)
				{
					return 0f;
				}
				if (!(num > 1f))
				{
					return num;
				}
				return 1f;
			}
		}

		public bool IsFullHealth
		{
			get
			{
				if (!IsDead && MaxHealth > 0)
				{
					return CurrentHealth >= MaxHealth;
				}
				return false;
			}
		}
	}
	public sealed class EnemyHealthTracker
	{
		private readonly Dictionary<int, ObservedEnemyHealth> trackedEnemies = new Dictionary<int, ObservedEnemyHealth>();

		private readonly List<int> removedEnemyIds = new List<int>();

		public EnemyHealthSnapshot Track(EnemyHealthSample sample, MaxHealthMode maxHealthMode = MaxHealthMode.VanillaStrict)
		{
			if (!trackedEnemies.TryGetValue(sample.EnemyId, out ObservedEnemyHealth value))
			{
				value = ObservedEnemyHealth.FromSample(sample.CurrentHealth);
				trackedEnemies.Add(sample.EnemyId, value);
			}
			else
			{
				value.ApplySample(sample.CurrentHealth);
			}
			int currentHealth = value.CurrentHealth;
			int maxHealth = ResolveMaxHealth(sample, value, maxHealthMode);
			return new EnemyHealthSnapshot(sample.EnemyId, sample.DisplayName, currentHealth, maxHealth, sample.IsDead);
		}

		private static int ResolveMaxHealth(EnemyHealthSample sample, ObservedEnemyHealth observedHealth, MaxHealthMode maxHealthMode)
		{
			if (sample.MaxHealth < 0)
			{
				return 0;
			}
			if (maxHealthMode == MaxHealthMode.Adaptive || maxHealthMode == MaxHealthMode.Hybrid)
			{
				return observedHealth.MaxObservedHealth;
			}
			int num = ((sample.MaxHealth > 0) ? sample.MaxHealth : observedHealth.MaxObservedHealth);
			if (num >= observedHealth.CurrentHealth)
			{
				return num;
			}
			return observedHealth.CurrentHealth;
		}

		public void Remove(int enemyId)
		{
			trackedEnemies.Remove(enemyId);
		}

		public void KeepOnly(ISet<int> activeEnemyIds)
		{
			removedEnemyIds.Clear();
			foreach (int key in trackedEnemies.Keys)
			{
				if (!activeEnemyIds.Contains(key))
				{
					removedEnemyIds.Add(key);
				}
			}
			foreach (int removedEnemyId in removedEnemyIds)
			{
				trackedEnemies.Remove(removedEnemyId);
			}
		}
	}
	public readonly struct HealthBarVisibilityRules
	{
		private readonly bool showWhenFullHealth;

		private readonly float maxDistance;

		private readonly float maxDistanceSquared;

		public HealthBarVisibilityRules(bool showWhenFullHealth, float maxDistance)
		{
			this.showWhenFullHealth = showWhenFullHealth;
			this.maxDistance = maxDistance;
			maxDistanceSquared = ((maxDistance > 0f) ? (maxDistance * maxDistance) : 0f);
		}

		public bool ShouldShow(EnemyHealthSnapshot snapshot, float distanceToCamera)
		{
			if (snapshot.IsDead || snapshot.CurrentHealth <= 0 || snapshot.MaxHealth <= 0)
			{
				return false;
			}
			if (!showWhenFullHealth && snapshot.IsFullHealth)
			{
				return false;
			}
			return IsWithinSquaredDistance(distanceToCamera * distanceToCamera);
		}

		public bool ShouldShowBySquaredDistance(EnemyHealthSnapshot snapshot, float squaredDistanceToCamera)
		{
			if (snapshot.IsDead || snapshot.CurrentHealth <= 0 || snapshot.MaxHealth <= 0)
			{
				return false;
			}
			if (!showWhenFullHealth && snapshot.IsFullHealth)
			{
				return false;
			}
			return IsWithinSquaredDistance(squaredDistanceToCamera);
		}

		public bool IsWithinSquaredDistance(float squaredDistanceToCamera)
		{
			if (!(maxDistance <= 0f))
			{
				return squaredDistanceToCamera <= maxDistanceSquared;
			}
			return true;
		}
	}
	public sealed class ObservedEnemyHealth
	{
		public int CurrentHealth { get; private set; }

		public int MaxObservedHealth { get; private set; }

		public float HealthFraction
		{
			get
			{
				if (MaxObservedHealth <= 0)
				{
					return 0f;
				}
				float num = (float)CurrentHealth / (float)MaxObservedHealth;
				if (num < 0f)
				{
					return 0f;
				}
				if (!(num > 1f))
				{
					return num;
				}
				return 1f;
			}
		}

		private ObservedEnemyHealth(int currentHealth, int maxObservedHealth)
		{
			CurrentHealth = currentHealth;
			MaxObservedHealth = maxObservedHealth;
		}

		public static ObservedEnemyHealth FromSample(int currentHealth)
		{
			int num = NormalizeHealth(currentHealth);
			return new ObservedEnemyHealth(num, num);
		}

		public void ApplySample(int currentHealth)
		{
			CurrentHealth = NormalizeHealth(currentHealth);
			if (CurrentHealth > MaxObservedHealth)
			{
				MaxObservedHealth = CurrentHealth;
			}
		}

		private static int NormalizeHealth(int health)
		{
			if (health >= 0)
			{
				return health;
			}
			return 0;
		}
	}
}
namespace Auuueser.EnemyHealthBars.Core.Configuration
{
	public static class ChineseProjectDetection
	{
		private const string CurrentKnownGuid = "cn.codex.v81testchn";

		private const string PackageName = "LC_Chinese_Project";

		private const string RepositoryUrl = "github.com/Auuueser/LC-Chinese-Project";

		public static bool IsChineseProjectPlugin(string? pluginGuid, string? pluginName, string? pluginLocation)
		{
			if (EqualsIgnoreCase(pluginGuid, "cn.codex.v81testchn"))
			{
				return true;
			}
			if (ContainsIgnoreCase(pluginName, "LC Chinese Project") || ContainsIgnoreCase(pluginName, "Chinese Project") || ContainsIgnoreCase(pluginName, "V81 TEST CHN"))
			{
				return true;
			}
			if (!ContainsIgnoreCase(pluginLocation, "LC_Chinese_Project") && !ContainsIgnoreCase(pluginLocation, "LC-Chinese-Project"))
			{
				return ContainsIgnoreCase(pluginLocation, "LC Chinese Project");
			}
			return true;
		}

		public static bool IsChineseProjectManifest(string? packageName, string? websiteUrl)
		{
			if (!EqualsIgnoreCase(packageName, "LC_Chinese_Project") && !ContainsIgnoreCase(packageName, "LC Chinese Project") && !ContainsIgnoreCase(packageName, "LC-Chinese-Project"))
			{
				return ContainsIgnoreCase(websiteUrl, "github.com/Auuueser/LC-Chinese-Project");
			}
			return true;
		}

		public static bool ContainsChineseProjectManifestText(string? manifestText)
		{
			if (!ContainsIgnoreCase(manifestText, "LC_Chinese_Project") && !ContainsIgnoreCase(manifestText, "LC Chinese Project") && !ContainsIgnoreCase(manifestText, "LC-Chinese-Project"))
			{
				return ContainsIgnoreCase(manifestText, "github.com/Auuueser/LC-Chinese-Project");
			}
			return true;
		}

		public static bool ContainsChineseConfigSections(string? configText)
		{
			if (!ContainsIgnoreCase(configText, "[通用]") && !ContainsIgnoreCase(configText, "[可见性]"))
			{
				return ContainsIgnoreCase(configText, "[诊断]");
			}
			return true;
		}

		private static bool EqualsIgnoreCase(string? value, string expected)
		{
			return string.Equals(value, expected, StringComparison.OrdinalIgnoreCase);
		}

		private static bool ContainsIgnoreCase(string? value, string expected)
		{
			if (value != null)
			{
				return value.IndexOf(expected, StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return false;
		}
	}
	public enum ConfigLanguage
	{
		English,
		Chinese
	}
	public static class ConfigTextCatalog
	{
		private static readonly ConfigTexts English = new ConfigTexts("General", "Visibility", "Performance", "Diagnostics", "Layout", "Debug", "Client-side enemy health bars. All settings apply immediately after saving.", "Enabled", "Show full-health enemies", "Show invulnerable enemies", "Max health mode", "Maximum display distance", "Scan interval", "Enable diagnostic logs", "Diagnostic log interval", "Vertical offset", "Bar width", "Bar height", "World scale", "Display mode", "Show health numbers", "Health text format", "Show enemy name", "Side bar width", "Side bar height", "Side bar horizontal offset", "Enable debug mode", "Show full-health enemies", "Enable diagnostic logs", "Diagnostic log interval", "Show test bar", "Enable enemy health bars. Applied immediately.", "Show bars for enemies that have not taken damage yet. Applied immediately.", "Show bars for enemies whose EnemyType cannot die. Applied immediately.", "How maximum health is resolved: VanillaStrict keeps base-game defaults, Adaptive uses observed instance health, Hybrid keeps special vanilla rules and adapts to observed modded health. Applied immediately.", "Maximum distance for rendering enemy health bars. Set 0 or below for no distance limit. Applied immediately.", "Seconds between enemy list refreshes. Applied immediately.", "Log low-frequency health bar scan counters for troubleshooting. Applied immediately.", "Seconds between diagnostic log lines when diagnostics are enabled. Applied immediately.", "World-space offset above the enemy eye transform. Applied immediately.", "World-space canvas width before scale is applied. Applied immediately.", "World-space canvas height before scale is applied. Applied immediately.", "World-space canvas scale. Applied immediately.", "Health bar layout mode: horizontal bar, side vertical bar, or numbers only. Applied immediately.", "Show current and max health text on enemy health bars. Applied immediately.", "Health text format: Current / max, current only, or percent only. Applied immediately.", "Show the enemy name beside the health number text. Applied immediately.", "Vertical side-bar width before scale is applied. Applied immediately.", "Vertical side-bar height before scale is applied. Applied immediately.", "Horizontal offset used by side vertical bar mode. Applied immediately.", "Enable test-only debug features. Keep this disabled during normal play. Applied immediately.", "Debug only: show bars for full-health enemies to verify enemy tracking. Requires debug mode. Applied immediately.", "Debug only: log low-frequency runtime, camera, scan, and active-bar counters. Requires debug mode. Applied immediately.", "Debug only: seconds between diagnostic log lines. Applied immediately.", "Debug only: render a fixed test health bar in front of the active camera. Requires debug mode. Applied immediately.");

		private static readonly ConfigTexts Chinese = new ConfigTexts("通用", "可见性", "性能", "诊断", "布局", "调试", "显示怪物血条的纯客户端模组。所有配置保存后立即生效。", "启用", "显示满血怪物", "显示不可死亡怪物", "最大血量模式", "最大显示距离", "扫描间隔", "启用诊断日志", "诊断日志间隔", "垂直偏移", "血条宽度", "血条高度", "世界缩放", "显示模式", "显示血量数字", "血量文字格式", "显示怪物名称", "侧边血条宽度", "侧边血条高度", "侧边血条水平偏移", "启用调试模式", "显示满血怪物", "启用诊断日志", "诊断日志间隔", "显示测试血条", "启用怪物血条。保存后立即生效。", "显示未受伤怪物的满血血条。保存后立即生效。", "显示 EnemyType 标记为不可死亡的怪物血条。保存后立即生效。", "最大血量计算方式：VanillaStrict 使用原版默认值，Adaptive 使用实际观察到的怪物血量，Hybrid 保留原版特殊规则并适应模组修改后的血量。保存后立即生效。", "血条最大显示距离。设置为 0 或更低表示不限制距离。保存后立即生效。", "刷新怪物列表的间隔秒数。保存后立即生效。", "输出低频血条扫描计数日志，用于排查问题。保存后立即生效。", "启用诊断时，两次诊断日志之间的秒数。保存后立即生效。", "血条相对怪物眼部锚点的世界空间高度偏移。保存后立即生效。", "应用缩放前的世界空间血条宽度。保存后立即生效。", "应用缩放前的世界空间血条高度。保存后立即生效。", "世界空间血条缩放。保存后立即生效。", "血条布局模式：横向血条、身旁竖条或纯数字。保存后立即生效。", "在怪物血条上显示当前血量和满血血量文字。保存后立即生效。", "血量文字格式：当前 / 满血、仅当前血量或仅百分比。保存后立即生效。", "在血量数字旁显示怪物名称。保存后立即生效。", "应用缩放前的竖向侧边血条宽度。保存后立即生效。", "应用缩放前的竖向侧边血条高度。保存后立即生效。", "身旁竖条模式使用的水平偏移。保存后立即生效。", "启用仅用于测试的调试功能。正常游玩时应保持关闭。保存后立即生效。", "仅调试：显示满血怪物血条，用于确认怪物追踪是否工作。需要启用调试模式。保存后立即生效。", "仅调试：输出低频运行时、相机、扫描和活动血条计数日志。需要启用调试模式。保存后立即生效。", "仅调试：两次诊断日志之间的秒数。保存后立即生效。", "仅调试：在活动相机前方渲染固定测试血条。需要启用调试模式。保存后立即生效。");

		public static ConfigTexts Get(ConfigLanguage language)
		{
			if (language != ConfigLanguage.Chinese)
			{
				return English;
			}
			return Chinese;
		}
	}
	public sealed class ConfigTexts
	{
		public string GeneralSection { get; }

		public string VisibilitySection { get; }

		public string PerformanceSection { get; }

		public string DiagnosticsSection { get; }

		public string LayoutSection { get; }

		public string DebugSection { get; }

		public string ModDescription { get; }

		public string EnabledName { get; }

		public string ShowWhenFullHealthName { get; }

		public string ShowInvulnerableEnemiesName { get; }

		public string MaxHealthModeName { get; }

		public string MaxDistanceName { get; }

		public string ScanIntervalName { get; }

		public string DiagnosticsEnabledName { get; }

		public string DiagnosticsLogIntervalName { get; }

		public string VerticalOffsetName { get; }

		public string BarWidthName { get; }

		public string BarHeightName { get; }

		public string WorldScaleName { get; }

		public string DisplayModeName { get; }

		public string ShowHealthNumbersName { get; }

		public string HealthTextFormatName { get; }

		public string ShowEnemyNameName { get; }

		public string SideBarWidthName { get; }

		public string SideBarHeightName { get; }

		public string SideBarHorizontalOffsetName { get; }

		public string DebugEnabledName { get; }

		public string DebugShowFullHealthEnemiesName { get; }

		public string DebugDiagnosticsEnabledName { get; }

		public string DebugDiagnosticsLogIntervalName { get; }

		public string DebugShowTestBarName { get; }

		public string EnabledDescription { get; }

		public string ShowWhenFullHealthDescription { get; }

		public string ShowInvulnerableEnemiesDescription { get; }

		public string MaxHealthModeDescription { get; }

		public string MaxDistanceDescription { get; }

		public string ScanIntervalDescription { get; }

		public string DiagnosticsEnabledDescription { get; }

		public string DiagnosticsLogIntervalDescription { get; }

		public string VerticalOffsetDescription { get; }

		public string BarWidthDescription { get; }

		public string BarHeightDescription { get; }

		public string WorldScaleDescription { get; }

		public string DisplayModeDescription { get; }

		public string ShowHealthNumbersDescription { get; }

		public string HealthTextFormatDescription { get; }

		public string ShowEnemyNameDescription { get; }

		public string SideBarWidthDescription { get; }

		public string SideBarHeightDescription { get; }

		public string SideBarHorizontalOffsetDescription { get; }

		public string DebugEnabledDescription { get; }

		public string DebugShowFullHealthEnemiesDescription { get; }

		public string DebugDiagnosticsEnabledDescription { get; }

		public string DebugDiagnosticsLogIntervalDescription { get; }

		public string DebugShowTestBarDescription { get; }

		public ConfigTexts(string generalSection, string visibilitySection, string performanceSection, string diagnosticsSection, string layoutSection, string debugSection, string modDescription, string enabledName, string showWhenFullHealthName, string showInvulnerableEnemiesName, string maxHealthModeName, string maxDistanceName, string scanIntervalName, string diagnosticsEnabledName, string diagnosticsLogIntervalName, string verticalOffsetName, string barWidthName, string barHeightName, string worldScaleName, string displayModeName, string showHealthNumbersName, string healthTextFormatName, string showEnemyNameName, string sideBarWidthName, string sideBarHeightName, string sideBarHorizontalOffsetName, string debugEnabledName, string debugShowFullHealthEnemiesName, string debugDiagnosticsEnabledName, string debugDiagnosticsLogIntervalName, string debugShowTestBarName, string enabledDescription, string showWhenFullHealthDescription, string showInvulnerableEnemiesDescription, string maxHealthModeDescription, string maxDistanceDescription, string scanIntervalDescription, string diagnosticsEnabledDescription, string diagnosticsLogIntervalDescription, string verticalOffsetDescription, string barWidthDescription, string barHeightDescription, string worldScaleDescription, string displayModeDescription, string showHealthNumbersDescription, string healthTextFormatDescription, string showEnemyNameDescription, string sideBarWidthDescription, string sideBarHeightDescription, string sideBarHorizontalOffsetDescription, string debugEnabledDescription, string debugShowFullHealthEnemiesDescription, string debugDiagnosticsEnabledDescription, string debugDiagnosticsLogIntervalDescription, string debugShowTestBarDescription)
		{
			GeneralSection = generalSection;
			VisibilitySection = visibilitySection;
			PerformanceSection = performanceSection;
			DiagnosticsSection = diagnosticsSection;
			LayoutSection = layoutSection;
			DebugSection = debugSection;
			ModDescription = modDescription;
			EnabledName = enabledName;
			ShowWhenFullHealthName = showWhenFullHealthName;
			ShowInvulnerableEnemiesName = showInvulnerableEnemiesName;
			MaxHealthModeName = maxHealthModeName;
			MaxDistanceName = maxDistanceName;
			ScanIntervalName = scanIntervalName;
			DiagnosticsEnabledName = diagnosticsEnabledName;
			DiagnosticsLogIntervalName = diagnosticsLogIntervalName;
			VerticalOffsetName = verticalOffsetName;
			BarWidthName = barWidthName;
			BarHeightName = barHeightName;
			WorldScaleName = worldScaleName;
			DisplayModeName = displayModeName;
			ShowHealthNumbersName = showHealthNumbersName;
			HealthTextFormatName = healthTextFormatName;
			ShowEnemyNameName = showEnemyNameName;
			SideBarWidthName = sideBarWidthName;
			SideBarHeightName = sideBarHeightName;
			SideBarHorizontalOffsetName = sideBarHorizontalOffsetName;
			DebugEnabledName = debugEnabledName;
			DebugShowFullHealthEnemiesName = debugShowFullHealthEnemiesName;
			DebugDiagnosticsEnabledName = debugDiagnosticsEnabledName;
			DebugDiagnosticsLogIntervalName = debugDiagnosticsLogIntervalName;
			DebugShowTestBarName = debugShowTestBarName;
			EnabledDescription = enabledDescription;
			ShowWhenFullHealthDescription = showWhenFullHealthDescription;
			ShowInvulnerableEnemiesDescription = showInvulnerableEnemiesDescription;
			MaxHealthModeDescription = maxHealthModeDescription;
			MaxDistanceDescription = maxDistanceDescription;
			ScanIntervalDescription = scanIntervalDescription;
			DiagnosticsEnabledDescription = diagnosticsEnabledDescription;
			DiagnosticsLogIntervalDescription = diagnosticsLogIntervalDescription;
			VerticalOffsetDescription = verticalOffsetDescription;
			BarWidthDescription = barWidthDescription;
			BarHeightDescription = barHeightDescription;
			WorldScaleDescription = worldScaleDescription;
			DisplayModeDescription = displayModeDescription;
			ShowHealthNumbersDescription = showHealthNumbersDescription;
			HealthTextFormatDescription = healthTextFormatDescription;
			ShowEnemyNameDescription = showEnemyNameDescription;
			SideBarWidthDescription = sideBarWidthDescription;
			SideBarHeightDescription = sideBarHeightDescription;
			SideBarHorizontalOffsetDescription = sideBarHorizontalOffsetDescription;
			DebugEnabledDescription = debugEnabledDescription;
			DebugShowFullHealthEnemiesDescription = debugShowFullHealthEnemiesDescription;
			DebugDiagnosticsEnabledDescription = debugDiagnosticsEnabledDescription;
			DebugDiagnosticsLogIntervalDescription = debugDiagnosticsLogIntervalDescription;
			DebugShowTestBarDescription = debugShowTestBarDescription;
		}
	}
	public enum HealthBarDisplayMode
	{
		HorizontalBar,
		VerticalSideBar,
		NumbersOnly
	}
	public enum HealthTextFormat
	{
		CurrentAndMax,
		CurrentOnly,
		PercentOnly
	}
	public enum MaxHealthMode
	{
		VanillaStrict,
		Adaptive,
		Hybrid
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class IsExternalInit
	{
	}
}