using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using HowToFish.CombatModes.Core.Arena;
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("HowToFish.CombatModes.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d1a74e7102bbfa4f5efbca13639093f1f31d4ac8")]
[assembly: AssemblyProduct("HowToFish.CombatModes.Core")]
[assembly: AssemblyTitle("HowToFish.CombatModes.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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;
		}
	}
	internal static class IsExternalInit
	{
	}
}
namespace HowToFish.CombatModes.Core
{
	public sealed record SpawnPoint(Vector3 Position, float Yaw);
	public static class ArenaGeometry
	{
		public const float FallDepth = 10f;

		public static (SpawnPoint A, SpawnPoint B) AutoSpawns(Vector3 center, float radius)
		{
			Vector3 vector = new Vector3(radius / 2f, 0f, 0f);
			return Facing(center - vector, center + vector);
		}

		public static (SpawnPoint A, SpawnPoint B) Facing(Vector3 a, Vector3 b)
		{
			return (A: new SpawnPoint(a, YawTowards(a, b)), B: new SpawnPoint(b, YawTowards(b, a)));
		}

		public static SpawnPoint For(Side side, bool hostAtSpawnA, (SpawnPoint A, SpawnPoint B) spawns)
		{
			if (side == Side.Host != hostAtSpawnA)
			{
				return spawns.B;
			}
			return spawns.A;
		}

		public static bool IsOutside(Vector3 position, Vector3 center, float radius)
		{
			float num = position.X - center.X;
			float num2 = position.Z - center.Z;
			if (!(num * num + num2 * num2 > radius * radius))
			{
				return position.Y < center.Y - 10f;
			}
			return true;
		}

		public static float YawTowards(Vector3 from, Vector3 to)
		{
			return ((float)(Math.Atan2(to.X - from.X, to.Z - from.Z) * 180.0 / Math.PI) + 360f) % 360f;
		}
	}
	public enum CombatScreen
	{
		None,
		Lobby,
		Countdown,
		Fight,
		End
	}
	public enum BannerTone
	{
		Good,
		Bad,
		Neutral
	}
	public static class CombatUiRules
	{
		public static CombatScreen ScreenFor(DuelPhase? phase)
		{
			switch (phase)
			{
			case null:
			case DuelPhase.Waiting:
				return CombatScreen.Lobby;
			case DuelPhase.Preparing:
			case DuelPhase.Countdown:
				return CombatScreen.Countdown;
			case DuelPhase.MatchEnd:
				return CombatScreen.End;
			default:
				return CombatScreen.Fight;
			}
		}

		public static CombatScreen ScreenFor(ArenaPhase? phase)
		{
			switch (phase)
			{
			case null:
			case ArenaPhase.Lobby:
				return CombatScreen.Lobby;
			case ArenaPhase.Preparing:
			case ArenaPhase.Countdown:
				return CombatScreen.Countdown;
			case ArenaPhase.Ended:
				return CombatScreen.End;
			default:
				return CombatScreen.Fight;
			}
		}

		public static bool BlocksJournal(bool inCombatLobby)
		{
			return inCombatLobby;
		}

		public static bool FreesCursor(CombatScreen screen)
		{
			if (screen == CombatScreen.Lobby || screen == CombatScreen.End)
			{
				return true;
			}
			return false;
		}

		public static bool BlocksInputs(CombatScreen screen)
		{
			return FreesCursor(screen);
		}

		public static bool BlocksGameRespawn(bool inCombatLobby)
		{
			return inCombatLobby;
		}

		public static bool HidesServerButtons(bool inCombatLobby)
		{
			return inCombatLobby;
		}
	}
	public static class DuelCodec
	{
		public const string Prefix = "HTFCM";

		public const int ProtocolVersion = 1;

		private const int StateFieldCount = 14;

		private static readonly int[] NumericFields = new int[10] { 3, 4, 5, 6, 7, 9, 10, 11, 12, 13 };

		public static string Encode(DuelMessage m)
		{
			return m.Kind switch
			{
				MessageKind.Hello => string.Format("{0}|{1}|HELLO", "HTFCM", 1), 
				MessageKind.Rematch => string.Format("{0}|{1}|REQ|REMATCH", "HTFCM", 1), 
				_ => EncodeState(m.State ?? throw new ArgumentException("STATE without state", "m")), 
			};
		}

		private static string EncodeState(WireState s)
		{
			return string.Join("|", "HTFCM", 1, "STATE", (int)s.Phase, s.Round, s.HostScore, s.GuestScore, s.RemainingMs, s.KitName, SideCode(s.LastRoundWinner), Bit(s.LastRoundDraw), SideCode(s.MatchWinner), Bit(s.Forfeit), Bit(s.HostAtSpawnA));
		}

		public static bool TryDecode(string text, out DuelMessage? message, out string error)
		{
			message = null;
			string[] array = text.Split('|');
			if (array.Length < 3 || array[0] != "HTFCM")
			{
				return Fail("missing prefix", out error);
			}
			if (!int.TryParse(array[1], NumberStyles.None, CultureInfo.InvariantCulture, out var result) || result != 1)
			{
				return Fail("unknown version '" + array[1] + "'", out error);
			}
			if (array.Length == 3 && array[2] == "HELLO")
			{
				message = DuelMessage.Hello();
			}
			else
			{
				if (array.Length != 4 || !(array[2] == "REQ") || !(array[3] == "REMATCH"))
				{
					if (array[2] == "STATE")
					{
						return TryDecodeState(array, out message, out error);
					}
					return Fail("unknown message type '" + array[2] + "'", out error);
				}
				message = DuelMessage.Rematch();
			}
			error = "";
			return true;
		}

		private static bool TryDecodeState(string[] p, out DuelMessage? message, out string error)
		{
			message = null;
			if (p.Length != 14)
			{
				return Fail($"field count {p.Length} instead of {14}", out error);
			}
			int[] array = new int[NumericFields.Length];
			for (int i = 0; i < NumericFields.Length; i++)
			{
				string text = p[NumericFields[i]];
				if (!int.TryParse(text, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out array[i]))
				{
					return Fail("invalid number '" + text + "'", out error);
				}
			}
			if (!Enum.IsDefined(typeof(DuelPhase), array[0]))
			{
				return Fail($"unknown phase {array[0]}", out error);
			}
			if (array[1] < 0 || array[2] < 0 || array[3] < 0 || array[4] < 0)
			{
				return Fail("negative value", out error);
			}
			if (!IsSide(array[5]) || !IsSide(array[7]))
			{
				return Fail("invalid side", out error);
			}
			if (!IsBit(array[6]) || !IsBit(array[8]) || !IsBit(array[9]))
			{
				return Fail("invalid boolean", out error);
			}
			WireState state = new WireState((DuelPhase)array[0], array[1], array[2], array[3], array[4], p[8], ToSide(array[5]), array[6] == 1, ToSide(array[7]), array[8] == 1, array[9] == 1);
			message = DuelMessage.Of(state);
			error = "";
			return true;
		}

		private static bool Fail(string reason, out string error)
		{
			error = reason;
			return false;
		}

		private static int SideCode(Side? side)
		{
			if (side.HasValue)
			{
				return (int)side.Value;
			}
			return -1;
		}

		private static Side? ToSide(int code)
		{
			if (code >= 0)
			{
				return (Side)code;
			}
			return null;
		}

		private static bool IsSide(int code)
		{
			if (code >= -1)
			{
				return code <= 1;
			}
			return false;
		}

		private static bool IsBit(int value)
		{
			if (value != 0)
			{
				return value == 1;
			}
			return true;
		}

		private static int Bit(bool value)
		{
			return value ? 1 : 0;
		}
	}
	public enum DuelPhase
	{
		Waiting,
		Preparing,
		Countdown,
		Fighting,
		RoundEnd,
		MatchEnd
	}
	public enum DuelEffect
	{
		None,
		PrepareRound,
		StartFight,
		AnnounceRoundResult,
		AnnounceMatchResult,
		ResetToWaiting
	}
	public sealed record DuelSnapshot(DuelPhase Phase, int Round, int HostScore, int GuestScore, double PhaseEndsAt, Kit? Kit, Side? LastRoundWinner, bool LastRoundDraw, Side? MatchWinner, bool Forfeit, bool HostAtSpawnA, double RoundDecidedAt, int Island)
	{
		public static DuelSnapshot Initial { get; } = new DuelSnapshot(DuelPhase.Waiting, 0, 0, 0, 0.0, null, null, LastRoundDraw: false, null, Forfeit: false, HostAtSpawnA: true, 0.0, 0);

		public int ScoreOf(Side side)
		{
			if (side != Side.Host)
			{
				return GuestScore;
			}
			return HostScore;
		}

		[CompilerGenerated]
		private DuelSnapshot(DuelSnapshot original)
		{
			Phase = original.Phase;
			Round = original.Round;
			HostScore = original.HostScore;
			GuestScore = original.GuestScore;
			PhaseEndsAt = original.PhaseEndsAt;
			Kit = original.Kit;
			LastRoundWinner = original.LastRoundWinner;
			LastRoundDraw = original.LastRoundDraw;
			MatchWinner = original.MatchWinner;
			Forfeit = original.Forfeit;
			HostAtSpawnA = original.HostAtSpawnA;
			RoundDecidedAt = original.RoundDecidedAt;
			Island = original.Island;
		}
	}
	public abstract record DuelEvent;
	public sealed record PlayersReady : DuelEvent;
	public sealed record PlayerLeft(Side Side) : DuelEvent();
	public sealed record PlayerDied(Side Side) : DuelEvent();
	public sealed record Tick(int HostHealth, int GuestHealth) : DuelEvent();
	public sealed record RematchRequested : DuelEvent;
	public sealed record DuelStep(DuelSnapshot Snapshot, DuelEffect Effect);
	public sealed class DuelRules
	{
		private readonly DuelSettings _settings;

		private readonly IRandomSource _random;

		public DuelRules(DuelSettings settings, IRandomSource random)
		{
			_settings = settings;
			_random = random;
		}

		public DuelStep Apply(DuelSnapshot snapshot, DuelEvent duelEvent, double now)
		{
			if (!(duelEvent is PlayerLeft playerLeft))
			{
				if (!(duelEvent is PlayersReady))
				{
					if (!(duelEvent is RematchRequested))
					{
						if (!(duelEvent is PlayerDied playerDied))
						{
							if (duelEvent is Tick tick)
							{
								return OnTick(snapshot, tick, now);
							}
							return Same(snapshot);
						}
						return OnPlayerDied(snapshot, playerDied.Side, now);
					}
					return (snapshot.Phase == DuelPhase.MatchEnd) ? StartMatch(snapshot.Island, now) : Same(snapshot);
				}
				return (snapshot.Phase == DuelPhase.Waiting) ? StartMatch(null, now) : Same(snapshot);
			}
			return OnPlayerLeft(snapshot, playerLeft.Side);
		}

		public static bool AllowsDamage(DuelSnapshot s, double now)
		{
			if (s.Phase != DuelPhase.Fighting)
			{
				if (s.Phase == DuelPhase.RoundEnd && !s.LastRoundDraw)
				{
					return now - s.RoundDecidedAt <= 1.0;
				}
				return false;
			}
			return true;
		}

		private static DuelStep Same(DuelSnapshot s)
		{
			return new DuelStep(s, DuelEffect.None);
		}

		private DuelStep StartMatch(int? previousIsland, double now)
		{
			Kit kit = KitPicker.Pick(_settings.Kits, null, _random);
			return new DuelStep(DuelSnapshot.Initial with
			{
				Phase = DuelPhase.Preparing,
				Round = 1,
				Kit = kit,
				PhaseEndsAt = now + 1.0,
				Island = IslandPicker.Pick(_settings.Islands, previousIsland, _random)
			}, DuelEffect.PrepareRound);
		}

		private static DuelStep OnPlayerLeft(DuelSnapshot s, Side side)
		{
			if (s.Phase == DuelPhase.Waiting)
			{
				return Same(s);
			}
			return new DuelStep(DuelSnapshot.Initial with
			{
				Forfeit = true,
				MatchWinner = side.Other()
			}, DuelEffect.ResetToWaiting);
		}

		private static DuelStep OnPlayerDied(DuelSnapshot s, Side side, double now)
		{
			if (s.Phase == DuelPhase.Fighting)
			{
				return EndRound(s, side.Other(), now);
			}
			if (s.Phase != DuelPhase.RoundEnd || s.LastRoundDraw || s.LastRoundWinner != side || !(now - s.RoundDecidedAt <= 1.0))
			{
				return Same(s);
			}
			return new DuelStep(s with
			{
				HostScore = ((side == Side.Host) ? (s.HostScore - 1) : s.HostScore),
				GuestScore = ((side == Side.Guest) ? (s.GuestScore - 1) : s.GuestScore),
				LastRoundWinner = null,
				LastRoundDraw = true
			}, DuelEffect.AnnounceRoundResult);
		}

		private static DuelStep EndRound(DuelSnapshot s, Side? winner, double now)
		{
			return new DuelStep(s with
			{
				Phase = DuelPhase.RoundEnd,
				HostScore = ((winner == Side.Host) ? (s.HostScore + 1) : s.HostScore),
				GuestScore = ((winner == Side.Guest) ? (s.GuestScore + 1) : s.GuestScore),
				LastRoundWinner = winner,
				LastRoundDraw = !winner.HasValue,
				RoundDecidedAt = now,
				PhaseEndsAt = now + 3.0
			}, DuelEffect.AnnounceRoundResult);
		}

		private DuelStep OnTick(DuelSnapshot s, Tick tick, double now)
		{
			if (now < s.PhaseEndsAt)
			{
				return Same(s);
			}
			return s.Phase switch
			{
				DuelPhase.Preparing => Same(s with
				{
					Phase = DuelPhase.Countdown,
					PhaseEndsAt = now + (double)_settings.CountdownSeconds
				}), 
				DuelPhase.Countdown => new DuelStep(s with
				{
					Phase = DuelPhase.Fighting,
					PhaseEndsAt = now + (double)_settings.RoundTimeSeconds
				}, DuelEffect.StartFight), 
				DuelPhase.Fighting => EndRound(s, TimeoutWinner(tick), now), 
				DuelPhase.RoundEnd => AfterRound(s, now), 
				_ => Same(s), 
			};
		}

		private static Side? TimeoutWinner(Tick tick)
		{
			if (tick.HostHealth != tick.GuestHealth)
			{
				return (tick.HostHealth <= tick.GuestHealth) ? Side.Guest : Side.Host;
			}
			return null;
		}

		private DuelStep AfterRound(DuelSnapshot s, double now)
		{
			Side? lastRoundWinner = s.LastRoundWinner;
			if (lastRoundWinner.HasValue)
			{
				Side valueOrDefault = lastRoundWinner.GetValueOrDefault();
				if (s.ScoreOf(valueOrDefault) >= _settings.RoundsToWin)
				{
					return new DuelStep(s with
					{
						Phase = DuelPhase.MatchEnd,
						MatchWinner = valueOrDefault
					}, DuelEffect.AnnounceMatchResult);
				}
			}
			return new DuelStep(s with
			{
				Phase = DuelPhase.Preparing,
				Round = (s.LastRoundDraw ? s.Round : (s.Round + 1)),
				Kit = KitPicker.Pick(_settings.Kits, s.Kit, _random),
				Island = IslandPicker.Pick(_settings.Islands, s.Island, _random),
				HostAtSpawnA = !s.HostAtSpawnA,
				LastRoundWinner = null,
				LastRoundDraw = false,
				PhaseEndsAt = now + 1.0
			}, DuelEffect.PrepareRound);
		}
	}
	public sealed record RawDuelSettings(int RoundsToWin, int RoundTimeSeconds, int CountdownSeconds, float ArenaRadius, int IslandIndex, string Kits, string SpawnA, string SpawnB, bool DebugSolo, bool IslandRotation, bool RandomUpgrades);
	public sealed record DuelSettings(int RoundsToWin, int RoundTimeSeconds, int CountdownSeconds, float ArenaRadius, int IslandIndex, IReadOnlyList<Kit> Kits, Vector3? SpawnA, Vector3? SpawnB, bool DebugSolo, bool IslandRotation, IReadOnlyList<int> Islands, bool RandomUpgrades)
	{
		public static RawDuelSettings Defaults { get; } = new RawDuelSettings(5, 90, 3, 60f, 0, "pistol+knife;shotgun+knife;smg+knife;assaultrifle+knife;sniperrifle+pistol;bow+knife;knife", "", "", DebugSolo: false, IslandRotation: true, RandomUpgrades: true);

		public const double PrepareSeconds = 1.0;

		public const double RoundEndSeconds = 3.0;

		public const double DoubleKoWindowSeconds = 1.0;

		public const double StateBroadcastSeconds = 2.0;

		public const double HelloTimeoutSeconds = 5.0;

		public const string DefaultKits = "pistol+knife;shotgun+knife;smg+knife;assaultrifle+knife;sniperrifle+pistol;bow+knife;knife";

		public const int DefaultIslandIndex = 0;

		public DuelSettings WithKits(IReadOnlyList<Kit> kits)
		{
			return this with
			{
				Kits = kits
			};
		}

		public static DuelSettings FromRaw(RawDuelSettings raw, out IReadOnlyList<string> warnings)
		{
			List<string> list = new List<string>();
			RawDuelSettings defaults = Defaults;
			int num = SettingRange.Int("IslandIndex", raw.IslandIndex, 0, 255, defaults.IslandIndex, list);
			DuelSettings result = new DuelSettings(SettingRange.Int("RoundsToWin", raw.RoundsToWin, 1, 15, defaults.RoundsToWin, list), SettingRange.Int("RoundTimeSeconds", raw.RoundTimeSeconds, 15, 600, defaults.RoundTimeSeconds, list), SettingRange.Int("CountdownSeconds", raw.CountdownSeconds, 0, 10, defaults.CountdownSeconds, list), SettingRange.Float("ArenaRadius", raw.ArenaRadius, 10f, 500f, defaults.ArenaRadius, list), num, ParseKits(raw.Kits, list), ParseSpawn("SpawnA", raw.SpawnA, list), ParseSpawn("SpawnB", raw.SpawnB, list), raw.DebugSolo, raw.IslandRotation, new int[1] { num }, raw.RandomUpgrades);
			warnings = list;
			return result;
		}

		private static IReadOnlyList<Kit> ParseKits(string text, List<string> warnings)
		{
			string error;
			IReadOnlyList<Kit> readOnlyList = KitParser.Parse(text, out error);
			if (readOnlyList != null)
			{
				return readOnlyList;
			}
			warnings.Add("Invalid Kits (" + error + "), using default kits");
			string error2;
			return KitParser.Parse("pistol+knife;shotgun+knife;smg+knife;assaultrifle+knife;sniperrifle+pistol;bow+knife;knife", out error2);
		}

		private static Vector3? ParseSpawn(string name, string text, List<string> warnings)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return null;
			}
			string[] array = text.Split(',');
			if (array.Length == 3 && TryFloat(array[0], out var value) && TryFloat(array[1], out var value2) && TryFloat(array[2], out var value3))
			{
				return new Vector3(value, value2, value3);
			}
			warnings.Add(name + "='" + text + "' invalid (expected format x,y,z), using automatic calculation");
			return null;
		}

		private static bool TryFloat(string text, out float value)
		{
			return float.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out value);
		}

		[CompilerGenerated]
		private DuelSettings(DuelSettings original)
		{
			RoundsToWin = original.RoundsToWin;
			RoundTimeSeconds = original.RoundTimeSeconds;
			CountdownSeconds = original.CountdownSeconds;
			ArenaRadius = original.ArenaRadius;
			IslandIndex = original.IslandIndex;
			Kits = original.Kits;
			SpawnA = original.SpawnA;
			SpawnB = original.SpawnB;
			DebugSolo = original.DebugSolo;
			IslandRotation = original.IslandRotation;
			Islands = original.Islands;
			RandomUpgrades = original.RandomUpgrades;
		}
	}
	public enum GameMode
	{
		Duel,
		Deathmatch,
		GunGame
	}
	public static class GameModes
	{
		public const int ArenaMaxMembers = 8;

		private const int DuelMaxMembers = 2;

		public static IReadOnlyList<GameMode> All { get; } = new GameMode[3]
		{
			GameMode.Duel,
			GameMode.Deathmatch,
			GameMode.GunGame
		};

		public static string Tag(GameMode mode)
		{
			return mode switch
			{
				GameMode.Duel => "duel", 
				GameMode.Deathmatch => "ffa", 
				_ => "gungame", 
			};
		}

		public static bool TryParseTag(string? tag, out GameMode mode)
		{
			foreach (GameMode item in All)
			{
				if (!(Tag(item) != tag))
				{
					mode = item;
					return true;
				}
			}
			mode = GameMode.Duel;
			return false;
		}

		public static int MaxMembers(GameMode mode)
		{
			if (mode != GameMode.Duel)
			{
				return 8;
			}
			return 2;
		}
	}
	public static class HudFormatter
	{
		public static string Clock(double seconds)
		{
			int num = (int)Math.Ceiling(Math.Max(0.0, seconds));
			return $"{num / 60}:{num % 60:00}";
		}

		public static int CountdownNumber(double seconds)
		{
			return (int)Math.Ceiling(Math.Max(0.0, seconds));
		}

		public static string ScoreLine(WireState s, Side local, string localName, string opponentName)
		{
			return $"{localName} {Score(s, local)} - {Score(s, local.Other())} {opponentName}";
		}

		public static string RoundBanner(UiText t, WireState s, Side local)
		{
			if (!s.LastRoundDraw && s.LastRoundWinner.HasValue)
			{
				if (s.LastRoundWinner != local)
				{
					return t.RoundLost;
				}
				return t.RoundWon;
			}
			return t.RoundDraw;
		}

		public static string MatchBanner(UiText t, WireState s, Side local)
		{
			return $"{((s.MatchWinner == local) ? t.Victory : t.Defeat)} {Score(s, local)} - {Score(s, local.Other())}";
		}

		public static string WaitingText(UiText t, WireState? s, Side local)
		{
			if ((object)s == null || !s.Forfeit || s.MatchWinner != local)
			{
				return t.WaitingForOpponent;
			}
			return t.ForfeitWin + " " + t.WaitingForOpponent;
		}

		public static BannerTone RoundTone(WireState s, Side local)
		{
			if (!s.LastRoundDraw && s.LastRoundWinner.HasValue)
			{
				if (s.LastRoundWinner != local)
				{
					return BannerTone.Bad;
				}
				return BannerTone.Good;
			}
			return BannerTone.Neutral;
		}

		public static BannerTone MatchTone(WireState s, Side local)
		{
			if (s.MatchWinner != local)
			{
				return BannerTone.Bad;
			}
			return BannerTone.Good;
		}

		public static IReadOnlyList<string> ScoreboardRows(UiText t, WireState s, Side local, string localName, string opponentName)
		{
			return new string[3]
			{
				localName + " — " + t.Rounds(Score(s, local)),
				opponentName + " — " + t.Rounds(Score(s, local.Other())),
				t.RoundKit(s.Round, s.KitName)
			};
		}

		private static int Score(WireState s, Side side)
		{
			if (side != Side.Host)
			{
				return s.GuestScore;
			}
			return s.HostScore;
		}
	}
	public static class ItemNames
	{
		public static string KeyOf(string objectName)
		{
			return objectName.Replace("(Clone)", "").Replace(" ", "").Trim()
				.ToLowerInvariant();
		}
	}
	public sealed record Kit(string Name, IReadOnlyList<string> Items);
	public static class KitFilter
	{
		public static IReadOnlyList<Kit> KeepAvailable(IReadOnlyList<Kit> kits, Func<string, bool> itemExists, out IReadOnlyList<string> missingItems)
		{
			List<string> missing = (from i in kits.SelectMany((Kit k) => k.Items)
				where !itemExists(i)
				select i).Distinct().ToList();
			missingItems = missing;
			return kits.Where((Kit k) => k.Items.All((string i) => !missing.Contains(i))).ToList();
		}
	}
	public static class KitParser
	{
		public static IReadOnlyList<Kit>? Parse(string text, out string error)
		{
			if (text.Contains('|'))
			{
				error = "the '|' character is not allowed in kits";
				return null;
			}
			List<Kit> list = new List<Kit>();
			string[] array = text.Split(';');
			foreach (string text2 in array)
			{
				if (!string.IsNullOrWhiteSpace(text2))
				{
					List<string> list2 = text2.Split('+').Select(Normalize).ToList();
					if (list2.Any((string text3) => text3.Length == 0))
					{
						error = "empty item in kit '" + text2.Trim() + "'";
						return null;
					}
					list.Add(new Kit(string.Join("+", list2), list2));
				}
			}
			if (list.Count == 0)
			{
				error = "no kit defined";
				return null;
			}
			error = "";
			return list;
		}

		private static string Normalize(string item)
		{
			return item.Replace(" ", "").Trim().ToLowerInvariant();
		}
	}
	public interface IRandomSource
	{
		int Next(int maxExclusive);
	}
	public sealed class SystemRandomSource : IRandomSource
	{
		private readonly Random _random;

		public SystemRandomSource(Random random)
		{
			_random = random;
		}

		public int Next(int maxExclusive)
		{
			return _random.Next(maxExclusive);
		}
	}
	public static class KitPicker
	{
		public static Kit Pick(IReadOnlyList<Kit> kits, Kit? previous, IRandomSource random)
		{
			return RandomPicker.PickAvoiding(kits, (Kit k) => previous != null && k.Name == previous.Name, random, "kits");
		}
	}
	public static class IslandPicker
	{
		public static int Pick(IReadOnlyList<int> islands, int? previous, IRandomSource random)
		{
			return RandomPicker.PickAvoiding(islands, (int i) => i == previous, random, "islands");
		}
	}
	internal static class RandomPicker
	{
		public static T PickAvoiding<T>(IReadOnlyList<T> items, Func<T, bool> isPrevious, IRandomSource random, string paramName)
		{
			if (items.Count == 0)
			{
				throw new ArgumentException("At least one element is required.", paramName);
			}
			List<T> list = items.Where((T i) => !isPrevious(i)).ToList();
			if (list.Count != 0)
			{
				return list[random.Next(list.Count)];
			}
			return items[random.Next(items.Count)];
		}
	}
	public static class MessagePolicy
	{
		public static bool IsAccepted(MessageKind kind, bool senderIsLobbyOwner, bool localIsHost)
		{
			switch (kind)
			{
			case MessageKind.State:
				return senderIsLobbyOwner && !localIsHost;
			case MessageKind.Hello:
			case MessageKind.Rematch:
				return !senderIsLobbyOwner && localIsHost;
			default:
				return false;
			}
		}
	}
	public sealed record OpenLobby(ulong Id, int Members);
	public static class QuickMatchPolicy
	{
		public static ulong? MergeTarget(ulong ownLobby, IEnumerable<ulong> openLobbies)
		{
			List<ulong> list = openLobbies.Where((ulong id) => id < ownLobby).ToList();
			if (list.Count != 0)
			{
				return list.Min();
			}
			return null;
		}

		public static ulong? MergeTarget(ulong ownLobby, IEnumerable<OpenLobby> openLobbies, bool arena)
		{
			List<OpenLobby> source = openLobbies.Where((OpenLobby l) => l.Id != ownLobby).ToList();
			if (arena)
			{
				OpenLobby openLobby = (from l in source
					where l.Members > 1
					orderby l.Members descending, l.Id
					select l).FirstOrDefault();
				if (openLobby != null)
				{
					return openLobby.Id;
				}
			}
			return MergeTarget(ownLobby, source.Select((OpenLobby l) => l.Id));
		}
	}
	internal static class SettingRange
	{
		public static int Int(string name, int value, int min, int max, int fallback, List<string> warnings)
		{
			if (value >= min && value <= max)
			{
				return value;
			}
			warnings.Add($"{name}={value} out of range [{min}-{max}], using default {fallback}");
			return fallback;
		}

		public static float Float(string name, float value, float min, float max, float fallback, List<string> warnings)
		{
			if (value >= min && value <= max)
			{
				return value;
			}
			warnings.Add($"{name}={value} out of range [{min}-{max}], using default {fallback}");
			return fallback;
		}
	}
	public enum Side
	{
		Host,
		Guest
	}
	public static class SideExtensions
	{
		public static Side Other(this Side side)
		{
			if (side != Side.Host)
			{
				return Side.Host;
			}
			return Side.Guest;
		}
	}
	public enum Language
	{
		English,
		French
	}
	public abstract class UiText
	{
		private sealed class EnglishText : UiText
		{
			public override string CombatModes => "Combat Modes";

			public override string InviteFriends => "Invite friends";

			public override string QuickMatch => "Quick match";

			public override string Back => "Back";

			public override string Cancel => "Cancel";

			public override string Incompatible => "This mod is not compatible with this version of the game.";

			public override string DuelTitle => "1V1 DUEL";

			public override string HostSuffix => " (host)";

			public override string WaitingForHost => "Waiting for the host…";

			public override string WaitingForOpponent => "Waiting for an opponent…";

			public override string ForfeitWin => "Your opponent left — you win by forfeit.";

			public override string ConnectingToHost => "Connecting to the host…";

			public override string Start => "Start";

			public override string Quit => "Quit";

			public override string Rematch => "Rematch";

			public override string PlayAgain => "Play again";

			public override string Scoreboard => "SCOREBOARD";

			public override string Opponent => "Opponent";

			public override string Bot => "Bot";

			public override string PreparingIsland => "Preparing the island…";

			public override string Go => "GO!";

			public override string RoundWon => "YOU WIN THE ROUND";

			public override string RoundLost => "YOUR OPPONENT WINS THE ROUND";

			public override string RoundDraw => "DRAW";

			public override string Victory => "VICTORY";

			public override string Defeat => "DEFEAT";

			public override string GameOver => "GAME OVER";

			public override string Kill => "KILL";

			public override string Eliminated => "ELIMINATED";

			public override string FinalLevel => "FINAL LEVEL: knife";

			public override string Bare => "bare";

			public override string Laser => "laser";

			public override string ExtendedMag => "extended mag";

			public override string OpponentWithoutMod => "Your opponent does not have the Combat Modes mod";

			public override string LobbyUnavailable => "This lobby is no longer available, start a new quick match";

			public override string LobbyOtherGameVersion => "This lobby uses a different version of the game";

			public override string SteamRefusedLobby => "Steam refused to create the lobby";

			public override string NoValidKits => "No valid weapon kit in htf.combatmodes.cfg (see the log)";

			public override string InvalidLadder => "Invalid gun game ladder in htf.combatmodes.cfg (at least 2 levels, the last one must be knife)";

			public override string ModeLabel(GameMode mode)
			{
				return mode switch
				{
					GameMode.Duel => "1v1 Duel", 
					GameMode.Deathmatch => "Free-for-all", 
					_ => "Gun Game", 
				};
			}

			public override string SearchingLobby(string modeLabel)
			{
				return "Searching for a " + modeLabel + " lobby…";
			}

			public override string LobbyTitle(string modeLabel, int players, int maxPlayers)
			{
				return $"LOBBY — {modeLabel} ({players}/{maxPlayers})";
			}

			public override string PlayerWins(string name)
			{
				return name.ToUpperInvariant() + " WINS";
			}

			public override string LevelUp(int level, string weapon)
			{
				return $"LEVEL {level}: {weapon}";
			}

			public override string Rounds(int count)
			{
				if (count != 1)
				{
					return $"{count} rounds";
				}
				return "1 round";
			}

			public override string RoundKit(int round, string kit)
			{
				return $"Round {round}  ·  Kit: {kit}";
			}

			public override string RoundClockKit(int round, string clock, string kit)
			{
				return $"Round {round}  ·  {clock}  ·  Kit: {kit}";
			}

			public override string ClockKit(string clock, string kit)
			{
				return clock + "  ·  Kit: " + kit;
			}

			public override string LevelScore(int level)
			{
				return $"level {level}";
			}

			public override string LocalAndLeader(string localScore, string leaderName, string leaderScore)
			{
				return "You: " + localScore + "  ·  Leader: " + leaderName + " " + leaderScore;
			}

			public override string LevelLine(int level, int levels, string weapon, string? next)
			{
				if (next != null)
				{
					return $"Level {level}/{levels}: {weapon}, next {next}";
				}
				return $"Level {level}/{levels}: knife, one kill to win";
			}

			public override string DeathmatchRow(int rank, string name, int kills, int deaths)
			{
				return $"{rank}. {name} — {kills} kills / {deaths} deaths";
			}

			public override string GunGameRow(int rank, string name, int level, int kills)
			{
				return $"{rank}. {name} — level {level} — {kills} kills";
			}

			public override string Sharpness(int level)
			{
				return $"sharpness {level}";
			}

			public override string AmmoLevel(int level)
			{
				return $"ammo lvl {level}";
			}

			public override string QuiverLevel(int level)
			{
				return $"quiver lvl {level}";
			}

			public override string MatchImpossible(string error)
			{
				return error + " — the match cannot start, go back to the menu";
			}

			public override string PlayerWithoutMod(string name)
			{
				return name + " does not have the Combat Modes mod";
			}

			public override string Position(string coordinates)
			{
				return "Position: " + coordinates;
			}
		}

		private sealed class FrenchText : UiText
		{
			public override string CombatModes => "Mods de combat";

			public override string InviteFriends => "Inviter des amis";

			public override string QuickMatch => "Partie rapide";

			public override string Back => "Retour";

			public override string Cancel => "Annuler";

			public override string Incompatible => "Mod incompatible avec cette version du jeu.";

			public override string DuelTitle => "DUEL 1V1";

			public override string HostSuffix => " (hôte)";

			public override string WaitingForHost => "En attente de l'hôte…";

			public override string WaitingForOpponent => "En attente d'un adversaire…";

			public override string ForfeitWin => "L'adversaire a quitté — victoire par forfait.";

			public override string ConnectingToHost => "Connexion à l'hôte…";

			public override string Start => "Lancer";

			public override string Quit => "Quitter";

			public override string Rematch => "Revanche";

			public override string PlayAgain => "Rejouer";

			public override string Scoreboard => "CLASSEMENT";

			public override string Opponent => "Adversaire";

			public override string Bot => "Bot";

			public override string PreparingIsland => "Préparation de l'île…";

			public override string Go => "GO !";

			public override string RoundWon => "TU GAGNES LA MANCHE";

			public override string RoundLost => "L'ADVERSAIRE GAGNE LA MANCHE";

			public override string RoundDraw => "MANCHE NULLE";

			public override string Victory => "VICTOIRE";

			public override string Defeat => "DÉFAITE";

			public override string GameOver => "PARTIE TERMINÉE";

			public override string Kill => "KILL";

			public override string Eliminated => "ÉLIMINÉ";

			public override string FinalLevel => "NIVEAU FINAL : couteau";

			public override string Bare => "nu";

			public override string Laser => "laser";

			public override string ExtendedMag => "chargeur étendu";

			public override string OpponentWithoutMod => "Ton adversaire n'a pas le mod Combat Modes";

			public override string LobbyUnavailable => "Ce salon n'est plus disponible, relance une partie rapide";

			public override string LobbyOtherGameVersion => "Ce salon utilise une autre version du jeu";

			public override string SteamRefusedLobby => "Steam a refusé la création du salon";

			public override string NoValidKits => "Aucun kit d'armes valide dans htf.combatmodes.cfg (voir le log)";

			public override string InvalidLadder => "Échelle d'armes invalide dans htf.combatmodes.cfg (2 niveaux minimum, le dernier doit être knife)";

			public override string ModeLabel(GameMode mode)
			{
				return mode switch
				{
					GameMode.Duel => "Duel 1v1", 
					GameMode.Deathmatch => "Mêlée générale", 
					_ => "Course à l'armement", 
				};
			}

			public override string SearchingLobby(string modeLabel)
			{
				return "Recherche d'un salon " + modeLabel + "…";
			}

			public override string LobbyTitle(string modeLabel, int players, int maxPlayers)
			{
				return $"SALON — {modeLabel} ({players}/{maxPlayers})";
			}

			public override string PlayerWins(string name)
			{
				return name.ToUpperInvariant() + " GAGNE";
			}

			public override string LevelUp(int level, string weapon)
			{
				return $"NIVEAU {level} : {weapon}";
			}

			public override string Rounds(int count)
			{
				if (count > 1)
				{
					return $"{count} manches";
				}
				return $"{count} manche";
			}

			public override string RoundKit(int round, string kit)
			{
				return $"Manche {round}  ·  Kit : {kit}";
			}

			public override string RoundClockKit(int round, string clock, string kit)
			{
				return $"Manche {round}  ·  {clock}  ·  Kit : {kit}";
			}

			public override string ClockKit(string clock, string kit)
			{
				return clock + "  ·  Kit : " + kit;
			}

			public override string LevelScore(int level)
			{
				return $"niveau {level}";
			}

			public override string LocalAndLeader(string localScore, string leaderName, string leaderScore)
			{
				return "Toi : " + localScore + "  ·  Leader : " + leaderName + " " + leaderScore;
			}

			public override string LevelLine(int level, int levels, string weapon, string? next)
			{
				if (next != null)
				{
					return $"Niveau {level}/{levels} : {weapon}, ensuite {next}";
				}
				return $"Niveau {level}/{levels} : couteau, un kill pour gagner";
			}

			public override string DeathmatchRow(int rank, string name, int kills, int deaths)
			{
				return $"{rank}. {name} — {kills} kills / {deaths} morts";
			}

			public override string GunGameRow(int rank, string name, int level, int kills)
			{
				return $"{rank}. {name} — niveau {level} — {kills} kills";
			}

			public override string Sharpness(int level)
			{
				return $"affûtage {level}";
			}

			public override string AmmoLevel(int level)
			{
				return $"munitions niv. {level}";
			}

			public override string QuiverLevel(int level)
			{
				return $"carquois niv. {level}";
			}

			public override string MatchImpossible(string error)
			{
				return error + " — partie impossible, retourne au menu";
			}

			public override string PlayerWithoutMod(string name)
			{
				return name + " n'a pas le mod Combat Modes";
			}

			public override string Position(string coordinates)
			{
				return "Position : " + coordinates;
			}
		}

		public static UiText English { get; } = new EnglishText();

		public static UiText French { get; } = new FrenchText();

		public abstract string CombatModes { get; }

		public abstract string InviteFriends { get; }

		public abstract string QuickMatch { get; }

		public abstract string Back { get; }

		public abstract string Cancel { get; }

		public abstract string Incompatible { get; }

		public abstract string DuelTitle { get; }

		public abstract string HostSuffix { get; }

		public abstract string WaitingForHost { get; }

		public abstract string WaitingForOpponent { get; }

		public abstract string ForfeitWin { get; }

		public abstract string ConnectingToHost { get; }

		public abstract string Start { get; }

		public abstract string Quit { get; }

		public abstract string Rematch { get; }

		public abstract string PlayAgain { get; }

		public abstract string Scoreboard { get; }

		public abstract string Opponent { get; }

		public abstract string Bot { get; }

		public abstract string PreparingIsland { get; }

		public abstract string Go { get; }

		public abstract string RoundWon { get; }

		public abstract string RoundLost { get; }

		public abstract string RoundDraw { get; }

		public abstract string Victory { get; }

		public abstract string Defeat { get; }

		public abstract string GameOver { get; }

		public abstract string Kill { get; }

		public abstract string Eliminated { get; }

		public abstract string FinalLevel { get; }

		public abstract string Bare { get; }

		public abstract string Laser { get; }

		public abstract string ExtendedMag { get; }

		public abstract string OpponentWithoutMod { get; }

		public abstract string LobbyUnavailable { get; }

		public abstract string LobbyOtherGameVersion { get; }

		public abstract string SteamRefusedLobby { get; }

		public abstract string NoValidKits { get; }

		public abstract string InvalidLadder { get; }

		public static UiText For(Language language)
		{
			if (language != Language.French)
			{
				return English;
			}
			return French;
		}

		public static Language LanguageFromLocale(string? localeCode)
		{
			if (localeCode == null || !localeCode.StartsWith("fr", StringComparison.OrdinalIgnoreCase))
			{
				return Language.English;
			}
			return Language.French;
		}

		public abstract string ModeLabel(GameMode mode);

		public abstract string SearchingLobby(string modeLabel);

		public abstract string LobbyTitle(string modeLabel, int players, int maxPlayers);

		public abstract string PlayerWins(string name);

		public abstract string LevelUp(int level, string weapon);

		public abstract string Rounds(int count);

		public abstract string RoundKit(int round, string kit);

		public abstract string RoundClockKit(int round, string clock, string kit);

		public abstract string ClockKit(string clock, string kit);

		public abstract string LevelScore(int level);

		public abstract string LocalAndLeader(string localScore, string leaderName, string leaderScore);

		public abstract string LevelLine(int level, int levels, string weapon, string? next);

		public abstract string DeathmatchRow(int rank, string name, int kills, int deaths);

		public abstract string GunGameRow(int rank, string name, int level, int kills);

		public abstract string Sharpness(int level);

		public abstract string AmmoLevel(int level);

		public abstract string QuiverLevel(int level);

		public abstract string MatchImpossible(string error);

		public abstract string PlayerWithoutMod(string name);

		public abstract string Position(string coordinates);
	}
	public sealed record WeaponOptions(int Sights, int Barrels, int BulletLevels, int QuiverLevels, bool HasExtendedMag, bool HasLaser, int SharpnessLevels)
	{
		public static WeaponOptions None { get; } = new WeaponOptions(0, 0, 0, 0, HasExtendedMag: false, HasLaser: false, 0);

		[CompilerGenerated]
		private WeaponOptions(WeaponOptions original)
		{
			Sights = original.Sights;
			Barrels = original.Barrels;
			BulletLevels = original.BulletLevels;
			QuiverLevels = original.QuiverLevels;
			HasExtendedMag = original.HasExtendedMag;
			HasLaser = original.HasLaser;
			SharpnessLevels = original.SharpnessLevels;
		}
	}
	public sealed record Loadout(int Sight, int Barrel, int Bullet, int Quiver, bool ExtendedMag, bool Laser, int Sharpness)
	{
		public static Loadout Bare { get; } = new Loadout(0, 0, 0, 0, ExtendedMag: false, Laser: false, 0);

		[CompilerGenerated]
		private Loadout(Loadout original)
		{
			Sight = original.Sight;
			Barrel = original.Barrel;
			Bullet = original.Bullet;
			Quiver = original.Quiver;
			ExtendedMag = original.ExtendedMag;
			Laser = original.Laser;
			Sharpness = original.Sharpness;
		}
	}
	public static class UpgradeRoller
	{
		public static Loadout Roll(WeaponOptions options, IRandomSource random)
		{
			return new Loadout(Level(options.Sights, random), Level(options.Barrels, random), Level(options.BulletLevels, random), Level(options.QuiverLevels, random), Toggle(options.HasExtendedMag, random), Toggle(options.HasLaser, random), Level(options.SharpnessLevels, random));
		}

		private static int Level(int count, IRandomSource random)
		{
			if (count <= 1)
			{
				return 0;
			}
			return random.Next(count);
		}

		private static bool Toggle(bool available, IRandomSource random)
		{
			if (available)
			{
				return random.Next(2) == 1;
			}
			return false;
		}
	}
	public sealed record WireState(DuelPhase Phase, int Round, int HostScore, int GuestScore, int RemainingMs, string KitName, Side? LastRoundWinner, bool LastRoundDraw, Side? MatchWinner, bool Forfeit, bool HostAtSpawnA)
	{
		public static WireState From(DuelSnapshot s, double now)
		{
			return new WireState(s.Phase, s.Round, s.HostScore, s.GuestScore, (int)Math.Round(Math.Max(0.0, s.PhaseEndsAt - now) * 1000.0), s.Kit?.Name ?? "", s.LastRoundWinner, s.LastRoundDraw, s.MatchWinner, s.Forfeit, s.HostAtSpawnA);
		}
	}
	public enum MessageKind
	{
		Hello,
		State,
		Rematch
	}
	public sealed record DuelMessage(MessageKind Kind, WireState? State)
	{
		public static DuelMessage Hello()
		{
			return new DuelMessage(MessageKind.Hello, null);
		}

		public static DuelMessage Rematch()
		{
			return new DuelMessage(MessageKind.Rematch, null);
		}

		public static DuelMessage Of(WireState state)
		{
			return new DuelMessage(MessageKind.State, state);
		}
	}
}
namespace HowToFish.CombatModes.Core.Arena
{
	public static class ArenaCodec
	{
		public const int ProtocolVersion = 2;

		private const string Kind = "ARENA";

		private const int FieldCount = 10;

		private const int PlayerFieldCount = 5;

		private static readonly string Header = string.Format("{0}|{1}|{2}|", "HTFCM", 2, "ARENA");

		private static readonly CultureInfo Inv = CultureInfo.InvariantCulture;

		public static bool IsArena(string text)
		{
			return text.StartsWith(Header, StringComparison.Ordinal);
		}

		public static string Encode(ArenaWire w)
		{
			return string.Join("|", "HTFCM", 2.ToString(Inv), "ARENA", ((int)w.Mode).ToString(Inv), ((int)w.Phase).ToString(Inv), w.RemainingMs.ToString(Inv), w.KitName, w.Winner.GetValueOrDefault().ToString(Inv), string.Join(",", w.Players.Select(EncodePlayer)), string.Join(";", w.Ladder));
		}

		private static string EncodePlayer(ArenaWirePlayer p)
		{
			return string.Join(":", p.SteamId.ToString(Inv), p.Kills.ToString(Inv), p.Deaths.ToString(Inv), p.Level.ToString(Inv), p.Alive ? "1" : "0");
		}

		public static bool TryDecode(string text, out ArenaWire? wire, out string error)
		{
			wire = null;
			string[] array = text.Split('|');
			if (!IsArena(text) || array.Length != 10)
			{
				return Fail($"malformed arena message ({array.Length} fields)", out error);
			}
			if (!TryInt(array[3], out var value) || !Enum.IsDefined(typeof(GameMode), value) || value == 0)
			{
				return Fail("invalid mode '" + array[3] + "'", out error);
			}
			if (!TryInt(array[4], out var value2) || !Enum.IsDefined(typeof(ArenaPhase), value2))
			{
				return Fail("invalid phase '" + array[4] + "'", out error);
			}
			if (!TryInt(array[5], out var value3) || value3 < 0)
			{
				return Fail("invalid time '" + array[5] + "'", out error);
			}
			if (!ulong.TryParse(array[7], NumberStyles.None, Inv, out var result))
			{
				return Fail("invalid winner '" + array[7] + "'", out error);
			}
			if (!TryPlayers(array[8], out IReadOnlyList<ArenaWirePlayer> players, out error))
			{
				return false;
			}
			string[] ladder = ((array[9].Length == 0) ? Array.Empty<string>() : array[9].Split(';'));
			wire = new ArenaWire((GameMode)value, (ArenaPhase)value2, value3, array[6], (result == 0L) ? ((ulong?)null) : new ulong?(result), players, ladder);
			return true;
		}

		private static bool TryPlayers(string field, out IReadOnlyList<ArenaWirePlayer> players, out string error)
		{
			List<ArenaWirePlayer> list = (List<ArenaWirePlayer>)(players = new List<ArenaWirePlayer>());
			if (field.Length == 0)
			{
				error = "";
				return true;
			}
			string[] array = field.Split(',');
			if (array.Length > 8)
			{
				return Fail($"{array.Length} players, maximum {8}", out error);
			}
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (!TryPlayer(text, out ArenaWirePlayer player))
				{
					return Fail("invalid player '" + text + "'", out error);
				}
				list.Add(player);
			}
			error = "";
			return true;
		}

		private static bool TryPlayer(string entry, out ArenaWirePlayer? player)
		{
			player = null;
			string[] array = entry.Split(':');
			if (array.Length != 5 || !ulong.TryParse(array[0], NumberStyles.None, Inv, out var result))
			{
				return false;
			}
			if (!TryInt(array[1], out var value) || !TryInt(array[2], out var value2) || !TryInt(array[3], out var value3))
			{
				return false;
			}
			if (value2 < 0 || value3 < 0 || (array[4] != "0" && array[4] != "1"))
			{
				return false;
			}
			player = new ArenaWirePlayer(result, value, value2, value3, array[4] == "1");
			return true;
		}

		private static bool TryInt(string text, out int value)
		{
			return int.TryParse(text, NumberStyles.AllowLeadingSign, Inv, out value);
		}

		private static bool Fail(string reason, out string error)
		{
			error = reason;
			return false;
		}
	}
	public static class ArenaHudFormatter
	{
		public static IReadOnlyList<ArenaWirePlayer> Ranking(ArenaWire w)
		{
			if (w.Mode != GameMode.GunGame)
			{
				return (from p in w.Players
					orderby p.Kills descending, p.Deaths, p.SteamId
					select p).ToList();
			}
			return (from p in w.Players
				orderby p.Level descending, p.Kills descending, p.SteamId
				select p).ToList();
		}

		public static string TopLine(UiText t, ArenaWire w, ulong local, Func<ulong, string> name)
		{
			ArenaWirePlayer arenaWirePlayer = w.Players.FirstOrDefault((ArenaWirePlayer p) => p.SteamId == local);
			ArenaWirePlayer arenaWirePlayer2 = Ranking(w).FirstOrDefault();
			if (arenaWirePlayer == null || arenaWirePlayer2 == null)
			{
				return t.ModeLabel(w.Mode);
			}
			return t.LocalAndLeader(Score(t, arenaWirePlayer, w.Mode), name(arenaWirePlayer2.SteamId), Score(t, arenaWirePlayer2, w.Mode));
		}

		public static string SubLine(UiText t, ArenaWire w, ulong local, double remainingSeconds)
		{
			if (w.Mode == GameMode.Deathmatch)
			{
				return t.ClockKit(HudFormatter.Clock(remainingSeconds), w.KitName);
			}
			ArenaWirePlayer arenaWirePlayer = w.Players.FirstOrDefault((ArenaWirePlayer p) => p.SteamId == local);
			if (!(arenaWirePlayer == null) && w.Ladder.Count != 0)
			{
				return LevelLine(t, w.Ladder, arenaWirePlayer.Level);
			}
			return "";
		}

		public static string LevelLine(UiText t, IReadOnlyList<string> ladder, int level)
		{
			int num = ladder.Count - 1;
			int num2 = Math.Max(0, Math.Min(level, num));
			return t.LevelLine(num2 + 1, ladder.Count, ladder[num2], (num2 == num) ? null : ladder[num2 + 1]);
		}

		public static string Row(UiText t, int rank, ArenaWirePlayer p, GameMode mode, Func<ulong, string> name)
		{
			if (mode != GameMode.GunGame)
			{
				return t.DeathmatchRow(rank, name(p.SteamId), p.Kills, p.Deaths);
			}
			return t.GunGameRow(rank, name(p.SteamId), p.Level + 1, p.Kills);
		}

		public static string EndBanner(UiText t, ArenaWire w, ulong local, Func<ulong, string> name)
		{
			ulong? winner = w.Winner;
			if (winner.HasValue)
			{
				ulong valueOrDefault = winner.GetValueOrDefault();
				if (valueOrDefault != local)
				{
					return t.PlayerWins(name(valueOrDefault));
				}
				return t.Victory;
			}
			return t.GameOver;
		}

		public static (string Text, BannerTone Tone)? BannerFor(UiText t, ArenaWire? before, ArenaWire after, ulong local)
		{
			if (before == null || before.Phase != ArenaPhase.Playing || after.Phase != ArenaPhase.Playing)
			{
				return null;
			}
			ArenaWirePlayer arenaWirePlayer = before.Players.FirstOrDefault((ArenaWirePlayer p) => p.SteamId == local);
			ArenaWirePlayer arenaWirePlayer2 = after.Players.FirstOrDefault((ArenaWirePlayer p) => p.SteamId == local);
			if (arenaWirePlayer == null || arenaWirePlayer2 == null)
			{
				return null;
			}
			if (arenaWirePlayer.Alive && !arenaWirePlayer2.Alive)
			{
				return (t.Eliminated, BannerTone.Bad);
			}
			if (after.Mode == GameMode.GunGame && arenaWirePlayer2.Level > arenaWirePlayer.Level && after.Ladder.Count > 0)
			{
				return (LevelUpText(t, after.Ladder, arenaWirePlayer2.Level), BannerTone.Good);
			}
			if (arenaWirePlayer2.Kills > arenaWirePlayer.Kills)
			{
				return (t.Kill, BannerTone.Good);
			}
			return null;
		}

		private static string LevelUpText(UiText t, IReadOnlyList<string> ladder, int level)
		{
			if (level < ladder.Count - 1)
			{
				return t.LevelUp(level + 1, ladder[level]);
			}
			return t.FinalLevel;
		}

		private static string Score(UiText t, ArenaWirePlayer p, GameMode mode)
		{
			if (mode != GameMode.GunGame)
			{
				return p.Kills.ToString();
			}
			return t.LevelScore(p.Level + 1);
		}
	}
	public enum ArenaPhase
	{
		Lobby,
		Preparing,
		Countdown,
		Playing,
		Ended
	}
	public sealed record ArenaPlayer(ulong SteamId, int Kills, int Deaths, int Level, bool Alive, double RespawnAt, double ProtectedUntil);
	public sealed record ArenaSnapshot(GameMode Mode, ArenaPhase Phase, IReadOnlyList<ArenaPlayer> Players, Kit? Kit, double KitChangesAt, double PhaseEndsAt, double EndsAt, int Island, ulong? Winner)
	{
		public bool IsLive
		{
			get
			{
				ArenaPhase phase = Phase;
				if ((uint)(phase - 1) <= 2u)
				{
					return true;
				}
				return false;
			}
		}

		public static ArenaSnapshot Lobby(GameMode mode)
		{
			return new ArenaSnapshot(mode, ArenaPhase.Lobby, Array.Empty<ArenaPlayer>(), null, 0.0, 0.0, 0.0, -1, null);
		}

		public ArenaPlayer? Find(ulong id)
		{
			return Players.FirstOrDefault((ArenaPlayer p) => p.SteamId == id);
		}

		public ArenaSnapshot WithPlayer(ArenaPlayer player)
		{
			return this with
			{
				Players = (from p in Players.Where((ArenaPlayer p) => p.SteamId != player.SteamId).Append(player)
					orderby p.SteamId
					select p).ToList()
			};
		}

		public ArenaSnapshot Without(ulong id)
		{
			return this with
			{
				Players = Players.Where((ArenaPlayer p) => p.SteamId != id).ToList()
			};
		}
	}
	public abstract record ArenaEvent;
	public sealed record ArenaStart : ArenaEvent;
	public sealed record ArenaJoin(ulong Id) : ArenaEvent();
	public sealed record ArenaLeave(ulong Id) : ArenaEvent();
	public sealed record ArenaKill(ulong Killer, ulong Victim, string Weapon) : ArenaEvent();
	public sealed record ArenaDeath(ulong Victim) : ArenaEvent();
	public sealed record ArenaHit(ulong Attacker) : ArenaEvent();
	public sealed record ArenaTick : ArenaEvent;
	public abstract record ArenaAction;
	public sealed record PrepareIsland(int Island) : ArenaAction();
	public sealed record Respawn(ulong Id, Kit Kit) : ArenaAction();
	public sealed record Equip(ulong Id, Kit Kit) : ArenaAction();
	public sealed record RotateKit(Kit Kit) : ArenaAction();
	public sealed record Strip(ulong Id) : ArenaAction();
	public sealed record StartFight : ArenaAction;
	public sealed record EndGame(ulong Winner) : ArenaAction();
	public sealed record ArenaStep(ArenaSnapshot Snapshot, IReadOnlyList<ArenaAction> Actions);
	public sealed class ArenaRules
	{
		public const int MinPlayers = 2;

		private readonly ArenaSettings _settings;

		private readonly IRandomSource _random;

		public ArenaRules(ArenaSettings settings, IRandomSource random)
		{
			_settings = settings;
			_random = random;
		}

		public ArenaStep Apply(ArenaSnapshot s, ArenaEvent e, double now)
		{
			if (!(e is ArenaStart))
			{
				if (!(e is ArenaJoin arenaJoin))
				{
					if (!(e is ArenaLeave arenaLeave))
					{
						if (!(e is ArenaKill k))
						{
							if (!(e is ArenaDeath arenaDeath))
							{
								if (e is ArenaHit arenaHit)
								{
									return Unprotect(s, arenaHit.Attacker);
								}
								if (e is ArenaTick)
								{
									return OnTick(s, now);
								}
							}
							else if (s.Phase == ArenaPhase.Playing)
							{
								return OnDeath(s, arenaDeath.Victim, now, penalize: true);
							}
						}
						else if (s.Phase == ArenaPhase.Playing)
						{
							return OnKill(s, k, now);
						}
						return Same(s);
					}
					return Leave(s, arenaLeave.Id);
				}
				return Join(s, arenaJoin.Id, now);
			}
			return CanStart(s) ? Start(s, now) : Same(s);
		}

		public static bool AllowsDamage(ArenaSnapshot s, ulong victim, double now)
		{
			if (s.Phase == ArenaPhase.Playing)
			{
				ArenaPlayer arenaPlayer = s.Find(victim);
				if ((object)arenaPlayer != null && arenaPlayer.Alive)
				{
					return now >= arenaPlayer.ProtectedUntil;
				}
			}
			return false;
		}

		private Kit KitFor(ArenaSnapshot s, ArenaPlayer p)
		{
			if (s.Mode != GameMode.GunGame)
			{
				return s.Kit;
			}
			return _settings.Ladder.KitAt(p.Level);
		}

		private static bool CanStart(ArenaSnapshot s)
		{
			ArenaPhase phase = s.Phase;
			if ((phase == ArenaPhase.Lobby || phase == ArenaPhase.Ended) ? true : false)
			{
				return s.Players.Count >= 2;
			}
			return false;
		}

		private ArenaStep Start(ArenaSnapshot s, double now)
		{
			int? previous = ((s.Island >= 0) ? new int?(s.Island) : ((int?)null));
			int island = IslandPicker.Pick(_settings.Islands, previous, _random);
			Kit kit = ((s.Mode == GameMode.Deathmatch) ? KitPicker.Pick(_settings.Kits, null, _random) : null);
			List<ArenaPlayer> players = s.Players.Select((ArenaPlayer p) => new ArenaPlayer(p.SteamId, 0, 0, 0, Alive: false, 0.0, 0.0)).ToList();
			return Step(s with
			{
				Phase = ArenaPhase.Preparing,
				Players = players,
				Kit = kit,
				Island = island,
				Winner = null,
				PhaseEndsAt = now + 1.0,
				EndsAt = 0.0,
				KitChangesAt = 0.0
			}, new PrepareIsland(island));
		}

		private ArenaStep OnTick(ArenaSnapshot s, double now)
		{
			return s.Phase switch
			{
				ArenaPhase.Preparing => (now >= s.PhaseEndsAt) ? BeginCountdown(s, now) : Same(s), 
				ArenaPhase.Countdown => Chain(Respawns(s, now), (ArenaSnapshot r) => (!(now >= r.PhaseEndsAt)) ? Same(r) : BeginPlay(r, now)), 
				ArenaPhase.Playing => Chain(Respawns(s, now), (ArenaSnapshot r) => Clock(r, now)), 
				_ => Same(s), 
			};
		}

		private ArenaStep BeginCountdown(ArenaSnapshot s, double now)
		{
			List<ArenaPlayer> list = s.Players.Select((ArenaPlayer p) => p with
			{
				Alive = true,
				RespawnAt = 0.0,
				ProtectedUntil = 0.0
			}).ToList();
			ArenaSnapshot next = s with
			{
				Phase = ArenaPhase.Countdown,
				Players = list,
				PhaseEndsAt = now + (double)_settings.CountdownSeconds
			};
			return new ArenaStep(next, ((IEnumerable<ArenaPlayer>)list).Select((Func<ArenaPlayer, ArenaAction>)((ArenaPlayer p) => new Respawn(p.SteamId, KitFor(next, p)))).ToList());
		}

		private ArenaStep BeginPlay(ArenaSnapshot s, double now)
		{
			return Step(s with
			{
				Phase = ArenaPhase.Playing,
				EndsAt = ((s.Mode == GameMode.Deathmatch) ? (now + (double)_settings.TimeLimitSeconds) : 0.0),
				KitChangesAt = now + (double)_settings.KitRotationSeconds
			}, new StartFight());
		}

		private ArenaStep Clock(ArenaSnapshot s, double now)
		{
			if (s.Mode != GameMode.Deathmatch || s.Players.Count == 0)
			{
				return Same(s);
			}
			if (now >= s.EndsAt)
			{
				return End(s, Leader(s), Array.Empty<ArenaAction>());
			}
			if (now < s.KitChangesAt)
			{
				return Same(s);
			}
			Kit kit = KitPicker.Pick(_settings.Kits, s.Kit, _random);
			return Step(s with
			{
				Kit = kit,
				KitChangesAt = s.KitChangesAt + (double)_settings.KitRotationSeconds
			}, new RotateKit(kit));
		}

		private static ulong Leader(ArenaSnapshot s)
		{
			return (from p in s.Players
				orderby p.Kills descending, p.Deaths, p.SteamId
				select p).First().SteamId;
		}

		private ArenaStep Respawns(ArenaSnapshot s, double now)
		{
			ArenaSnapshot arenaSnapshot = s;
			List<ArenaAction> list = new List<ArenaAction>();
			foreach (ArenaPlayer item in s.Players.Where((ArenaPlayer p) => !p.Alive && p.RespawnAt <= now))
			{
				ArenaPlayer arenaPlayer = item with
				{
					Alive = true,
					ProtectedUntil = now + (double)_settings.SpawnProtectionSeconds
				};
				arenaSnapshot = arenaSnapshot.WithPlayer(arenaPlayer);
				list.Add(new Respawn(item.SteamId, KitFor(arenaSnapshot, arenaPlayer)));
			}
			if (list.Count != 0)
			{
				return new ArenaStep(arenaSnapshot, list);
			}
			return Same(s);
		}

		private static ArenaStep Join(ArenaSnapshot s, ulong id, double now)
		{
			if (s.Find(id) != null || s.Players.Count >= 8)
			{
				return Same(s);
			}
			int level = ((s.Mode == GameMode.GunGame && s.IsLive && s.Players.Count > 0) ? s.Players.Min((ArenaPlayer p) => p.Level) : 0);
			return Same(s.WithPlayer(new ArenaPlayer(id, 0, 0, level, Alive: false, now, 0.0)));
		}

		private static ArenaStep Leave(ArenaSnapshot s, ulong id)
		{
			if (s.Find(id) == null)
			{
				return Same(s);
			}
			ArenaSnapshot arenaSnapshot = s.Without(id);
			if (arenaSnapshot.Players.Count == 0)
			{
				return Same(ArenaSnapshot.Lobby(s.Mode)with
				{
					Island = s.Island
				});
			}
			if (s.IsLive && arenaSnapshot.Players.Count == 1)
			{
				return End(arenaSnapshot, arenaSnapshot.Players[0].SteamId, new ArenaAction[1]
				{
					new Strip(id)
				});
			}
			return Step(arenaSnapshot, new Strip(id));
		}

		private ArenaStep OnDeath(ArenaSnapshot s, ulong id, double now, bool penalize)
		{
			ArenaPlayer arenaPlayer = s.Find(id);
			if ((object)arenaPlayer == null || !arenaPlayer.Alive)
			{
				return Same(s);
			}
			ArenaPlayer player = Dead(arenaPlayer, now)with
			{
				Kills = ((penalize && s.Mode == GameMode.Deathmatch) ? (arenaPlayer.Kills - 1) : arenaPlayer.Kills)
			};
			return Step(s.WithPlayer(player), new Strip(id));
		}

		private ArenaStep OnKill(ArenaSnapshot s, ArenaKill k, double now)
		{
			if (k.Killer == k.Victim)
			{
				return OnDeath(s, k.Victim, now, penalize: true);
			}
			ArenaPlayer arenaPlayer = s.Find(k.Killer);
			if (arenaPlayer == null)
			{
				return OnDeath(s, k.Victim, now, penalize: false);
			}
			ArenaPlayer arenaPlayer2 = s.Find(k.Victim);
			if ((object)arenaPlayer2 == null || !arenaPlayer2.Alive)
			{
				return Same(s);
			}
			List<ArenaAction> actions = new List<ArenaAction>
			{
				new Strip(arenaPlayer2.SteamId)
			};
			ArenaPlayer arenaPlayer3 = Dead(arenaPlayer2, now);
			if (s.Mode == GameMode.GunGame)
			{
				return GunGameKill(s, arenaPlayer, arenaPlayer3, k.Weapon == "knife", actions);
			}
			ArenaPlayer arenaPlayer4 = arenaPlayer with
			{
				Kills = arenaPlayer.Kills + 1
			};
			ArenaSnapshot arenaSnapshot = s.WithPlayer(arenaPlayer3).WithPlayer(arenaPlayer4);
			if (arenaPlayer4.Kills < _settings.KillTarget)
			{
				return new ArenaStep(arenaSnapshot, actions);
			}
			return End(arenaSnapshot, arenaPlayer4.SteamId, actions);
		}

		private ArenaStep GunGameKill(ArenaSnapshot s, ArenaPlayer killer, ArenaPlayer dead, bool knife, List<ArenaAction> actions)
		{
			int lastLevel = _settings.Ladder.LastLevel;
			ArenaPlayer player = (knife ? dead with
			{
				Level = Math.Max(0, dead.Level - 1)
			} : dead);
			ArenaPlayer arenaPlayer = killer with
			{
				Kills = killer.Kills + 1,
				Level = Math.Min(killer.Level + 1, lastLevel)
			};
			ArenaSnapshot arenaSnapshot = s.WithPlayer(player).WithPlayer(arenaPlayer);
			if (knife && killer.Level >= lastLevel)
			{
				return End(arenaSnapshot, killer.SteamId, actions);
			}
			if (arenaPlayer.Alive && arenaPlayer.Level != killer.Level)
			{
				actions.Add(new Equip(arenaPlayer.SteamId, _settings.Ladder.KitAt(arenaPlayer.Level)));
			}
			return new ArenaStep(arenaSnapshot, actions);
		}

		private ArenaPlayer Dead(ArenaPlayer p, double now)
		{
			return p with
			{
				Deaths = p.Deaths + 1,
				Alive = false,
				RespawnAt = now + (double)_settings.RespawnSeconds,
				ProtectedUntil = 0.0
			};
		}

		private static ArenaStep Unprotect(ArenaSnapshot s, ulong id)
		{
			ArenaPlayer arenaPlayer = s.Find(id);
			if ((object)arenaPlayer == null || !(arenaPlayer.ProtectedUntil > 0.0))
			{
				return Same(s);
			}
			return Same(s.WithPlayer(arenaPlayer with
			{
				ProtectedUntil = 0.0
			}));
		}

		private static ArenaStep End(ArenaSnapshot s, ulong winner, IEnumerable<ArenaAction> actions)
		{
			return new ArenaStep(s with
			{
				Phase = ArenaPhase.Ended,
				Winner = winner
			}, actions.Append(new EndGame(winner)).ToList());
		}

		private static ArenaStep Chain(ArenaStep first, Func<ArenaSnapshot, ArenaStep> next)
		{
			ArenaStep arenaStep = next(first.Snapshot);
			return new ArenaStep(arenaStep.Snapshot, first.Actions.Concat(arenaStep.Actions).ToList());
		}

		private static ArenaStep Step(ArenaSnapshot s, ArenaAction action)
		{
			return new ArenaStep(s, new ArenaAction[1] { action });
		}

		private static ArenaStep Same(ArenaSnapshot s)
		{
			return new ArenaStep(s, Array.Empty<ArenaAction>());
		}
	}
	public sealed record RawArenaSettings(int KillTarget, int TimeLimitSeconds, int KitRotationSeconds, int RespawnSeconds, int SpawnProtectionSeconds, string Ladder);
	public sealed record ArenaSettings(int KillTarget, int TimeLimitSeconds, int KitRotationSeconds, int RespawnSeconds, int SpawnProtectionSeconds, int CountdownSeconds, GunGameLadder Ladder, IReadOnlyList<Kit> Kits, IReadOnlyList<int> Islands, bool RandomUpgrades)
	{
		public static RawArenaSettings Defaults { get; } = new RawArenaSettings(20, 600, 120, 3, 2, "sniperrifle;assaultrifle;smg;shotgun;bow;pistol;knife");

		public const int MaxPlayers = 8;

		public const double PrepareSeconds = 1.0;

		public const double KillCreditSeconds = 10.0;

		public const string DefaultLadder = "sniperrifle;assaultrifle;smg;shotgun;bow;pistol;knife";

		public static ArenaSettings FromRaw(RawArenaSettings raw, DuelSettings shared, out IReadOnlyList<string> warnings)
		{
			List<string> list = new List<string>();
			RawArenaSettings defaults = Defaults;
			string error;
			GunGameLadder gunGameLadder = GunGameLadder.Parse(raw.Ladder, out error);
			if (gunGameLadder == null)
			{
				list.Add("Invalid Ladder (" + error + "), using default ladder");
				gunGameLadder = GunGameLadder.Parse("sniperrifle;assaultrifle;smg;shotgun;bow;pistol;knife", out string _);
			}
			ArenaSettings result = new ArenaSettings(SettingRange.Int("KillTarget", raw.KillTarget, 1, 100, defaults.KillTarget, list), SettingRange.Int("TimeLimitSeconds", raw.TimeLimitSeconds, 60, 3600, defaults.TimeLimitSeconds, list), SettingRange.Int("KitRotationSeconds", raw.KitRotationSeconds, 30, 600, defaults.KitRotationSeconds, list), SettingRange.Int("RespawnSeconds", raw.RespawnSeconds, 0, 15, defaults.RespawnSeconds, list), SettingRange.Int("SpawnProtectionSeconds", raw.SpawnProtectionSeconds, 0, 10, defaults.SpawnProtectionSeconds, list), shared.CountdownSeconds, gunGameLadder, shared.Kits, shared.Islands, shared.RandomUpgrades);
			warnings = list;
			return result;
		}

		[CompilerGenerated]
		private ArenaSettings(ArenaSettings original)
		{
			KillTarget = original.KillTarget;
			TimeLimitSeconds = original.TimeLimitSeconds;
			KitRotationSeconds = original.KitRotationSeconds;
			RespawnSeconds = original.RespawnSeconds;
			SpawnProtectionSeconds = original.SpawnProtectionSeconds;
			CountdownSeconds = original.CountdownSeconds;
			Ladder = original.Ladder;
			Kits = original.Kits;
			Islands = original.Islands;
			RandomUpgrades = original.RandomUpgrades;
		}
	}
	public sealed record ArenaWirePlayer(ulong SteamId, int Kills, int Deaths, int Level, bool Alive);
	public sealed record ArenaWire(GameMode Mode, ArenaPhase Phase, int RemainingMs, string KitName, ulong? Winner, IReadOnlyList<ArenaWirePlayer> Players, IReadOnlyList<string> Ladder)
	{
		public static ArenaWire From(ArenaSnapshot s, double now, IReadOnlyList<string> ladder)
		{
			double num = ((s.Phase != ArenaPhase.Playing) ? s.PhaseEndsAt : ((s.Mode == GameMode.Deathmatch) ? s.EndsAt : now));
			List<ArenaWirePlayer> players = s.Players.Select((ArenaPlayer p) => new ArenaWirePlayer(p.SteamId, p.Kills, p.Deaths, p.Level, p.Alive)).ToList();
			GameMode mode = s.Mode;
			ArenaPhase phase = s.Phase;
			int remainingMs = (int)Math.Round(Math.Max(0.0, num - now) * 1000.0);
			string kitName = s.Kit?.Name ?? "";
			ulong? winner = s.Winner;
			IReadOnlyList<string> ladder2;
			if (s.Mode != GameMode.GunGame)
			{
				IReadOnlyList<string> readOnlyList = Array.Empty<string>();
				ladder2 = readOnlyList;
			}
			else
			{
				ladder2 = ladder;
			}
			return new ArenaWire(mode, phase, remainingMs, kitName, winner, players, ladder2);
		}
	}
	public sealed record GunGameLadder(IReadOnlyList<string> Weapons)
	{
		public int LastLevel => Weapons.Count - 1;

		public const string FinalWeapon = "knife";

		private const int MinLevels = 2;

		public static GunGameLadder? Parse(string text, out string error)
		{
			return Validate((from w in (text ?? "").Split(';')
				select w.Replace(" ", "").Trim().ToLowerInvariant() into w
				where w.Length > 0
				select w).ToList(), out error);
		}

		public GunGameLadder? KeepAvailable(Func<string, bool> exists, out IReadOnlyList<string> missing)
		{
			missing = Weapons.Where((string w) => !exists(w)).Distinct().ToList();
			string error;
			return Validate(Weapons.Where(exists).ToList(), out error);
		}

		public Kit KitAt(int level)
		{
			int num = Math.Max(0, Math.Min(level, LastLevel));
			string text = Weapons[num];
			string[] array = ((num != LastLevel) ? new string[2] { text, "knife" } : new string[1] { text });
			return new Kit(string.Join("+", array), array);
		}

		private static GunGameLadder? Validate(List<string> weapons, out string error)
		{
			if (weapons.Count < 2)
			{
				error = $"at least {2} levels required";
				return null;
			}
			if (weapons[weapons.Count - 1] != "knife")
			{
				error = "the last level must be knife";
				return null;
			}
			error = "";
			return new GunGameLadder(weapons);
		}

		[CompilerGenerated]
		private GunGameLadder(GunGameLadder original)
		{
			Weapons = original.Weapons;
		}
	}
	public static class SpawnPicker
	{
		public static IReadOnlyList<Vector3> Ring(Vector3 center, float radius, int count)
		{
			return Enumerable.Range(0, count).Select(delegate(int i)
			{
				double num = Math.PI * 2.0 * (double)i / (double)count;
				return new Vector3(center.X + radius * (float)Math.Cos(num), center.Y, center.Z + radius * (float)Math.Sin(num));
			}).ToList();
		}

		public static int Farthest(IReadOnlyList<Vector3> candidates, IReadOnlyList<Vector3> occupied)
		{
			if (candidates.Count == 0)
			{
				throw new ArgumentException("At least one spawn is required.", "candidates");
			}
			if (occupied.Count == 0)
			{
				return 0;
			}
			int result = 0;
			float num = -1f;
			int i;
			for (i = 0; i < candidates.Count; i++)
			{
				float num2 = occupied.Min((Vector3 o) => Vector3.DistanceSquared(candidates[i], o));
				if (!(num2 <= num))
				{
					result = i;
					num = num2;
				}
			}
			return result;
		}
	}
}