using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using On.HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("me.loaforc.diomedes")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("MMHOOK_0Harmony")]
[assembly: AssemblyCompany("Diomedes.Client.Preloader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.9.0.0")]
[assembly: AssemblyInformationalVersion("0.9.0+03a1858111402c9890133d64cf3f83ce16b9ffdb")]
[assembly: AssemblyProduct("Diomedes.Client.Preloader")]
[assembly: AssemblyTitle("Diomedes.Client.Preloader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Diomedes.Client.Preloader
{
	public static class CecilHelper
	{
		public static bool AddField(this TypeDefinition self, FieldAttributes fieldAttributes, string name, TypeReference type, Action<bool, string>? logCallback = null)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			logCallback?.Invoke(arg1: false, "Adding field '" + name + "' to " + ((MemberReference)self).FullName);
			if (Extensions.FindField(self, name) != null)
			{
				logCallback?.Invoke(arg1: true, "Field '" + name + "' already exists in " + ((MemberReference)self).FullName);
				return false;
			}
			self.Fields.Add(new FieldDefinition(name, fieldAttributes, type));
			return true;
		}

		public static bool AddMethod(this TypeDefinition self, string methodName, MethodAttributes attributes = (MethodAttributes)1, TypeReference? returnType = null, ParameterDefinition[]? parameters = null, Action<bool, string>? logCallback = null)
		{
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Invalid comparison between Unknown and I4
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			if (returnType == null)
			{
				returnType = ((MemberReference)self).Module.TypeSystem.Void;
			}
			if (parameters == null)
			{
				parameters = Array.Empty<ParameterDefinition>();
			}
			logCallback?.Invoke(arg1: false, "Adding method " + ((MemberReference)returnType).FullName + " " + methodName + "(" + string.Join(",", parameters.Select((ParameterDefinition p) => ((MemberReference)((ParameterReference)p).ParameterType).FullName)) + ") to " + ((MemberReference)self).FullName);
			if (Extensions.FindMethod(self, methodName, true) != null)
			{
				logCallback?.Invoke(arg1: true, "Method '" + methodName + "' already exists in " + ((MemberReference)self).FullName);
				return false;
			}
			MethodDefinition val = new MethodDefinition(methodName, (MethodAttributes)(attributes | 0x80), returnType);
			self.Methods.Add(val);
			Extensions.AddRange<ParameterDefinition>(((MethodReference)val).Parameters, (IEnumerable<ParameterDefinition>)parameters);
			ILProcessor iLProcessor = val.Body.GetILProcessor();
			Instruction val2 = iLProcessor.Create(OpCodes.Ret);
			if ((int)returnType.MetadataType != 1)
			{
				ConstructorInfo constructor = typeof(NotImplementedException).GetConstructor(new Type[1] { typeof(string) });
				MethodReference val3 = ((MemberReference)self).Module.ImportReference((MethodBase)constructor);
				iLProcessor.Emit(OpCodes.Ldstr, "This is a Stub");
				iLProcessor.Emit(OpCodes.Newobj, val3);
				iLProcessor.Emit(OpCodes.Throw);
			}
			iLProcessor.Append(val2);
			return true;
		}
	}
	internal class DiomedesPreloader
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Func<Hook, MethodBase, MethodBase, object, bool> <0>__GuardHook;

			public static Func<ILHook, MethodBase, Manipulator, bool> <1>__GuardILHook;

			public static Func<Detour, MethodBase, MethodBase, bool> <2>__GuardDetour;

			public static hook_UpdateWrapper <3>__GuardUpdateWrapper;
		}

		internal static readonly Harmony harmony = new Harmony("Diomedes.Client.Preloader");

		private static readonly string MainDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		internal static ManualLogSource Log { get; } = Logger.CreateLogSource("DiomedesPreloader");

		public static IEnumerable<string> TargetDLLs { get; } = Array.Empty<string>();

		public static void Patch(AssemblyDefinition assembly)
		{
		}

		public static void Initialize()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			Hook.OnDetour = (Func<Hook, MethodBase, MethodBase, object, bool>)Delegate.Combine(Hook.OnDetour, new Func<Hook, MethodBase, MethodBase, object, bool>(GuardHook));
			ILHook.OnDetour = (Func<ILHook, MethodBase, Manipulator, bool>)Delegate.Combine(ILHook.OnDetour, new Func<ILHook, MethodBase, Manipulator, bool>(GuardILHook));
			Detour.OnDetour = (Func<Detour, MethodBase, MethodBase, bool>)Delegate.Combine(Detour.OnDetour, new Func<Detour, MethodBase, MethodBase, bool>(GuardDetour));
			object obj = <>O.<3>__GuardUpdateWrapper;
			if (obj == null)
			{
				hook_UpdateWrapper val = GuardUpdateWrapper;
				<>O.<3>__GuardUpdateWrapper = val;
				obj = (object)val;
			}
			PatchFunctions.UpdateWrapper += (hook_UpdateWrapper)obj;
		}

		private static bool GuardDetour(Detour detour, MethodBase source, MethodBase target)
		{
			if (!IsProtectedMethod(source))
			{
				return true;
			}
			return false;
		}

		private static bool GuardILHook(ILHook hook, MethodBase source, Manipulator manipulator)
		{
			if (!IsProtectedMethod(source))
			{
				return true;
			}
			return false;
		}

		private static bool GuardHook(Hook hook, MethodBase source, MethodBase target, object arg4)
		{
			if (!IsProtectedMethod(source))
			{
				return true;
			}
			return false;
		}

		private static MethodInfo GuardUpdateWrapper(orig_UpdateWrapper orig, MethodBase original, PatchInfo patchInfo)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!IsProtectedMethod(original))
			{
				return orig.Invoke(original, patchInfo);
			}
			return orig.Invoke(original, new PatchInfo());
		}

		private static bool IsProtectedMethod(MethodBase? method)
		{
			string text = (method?.DeclaringType?.Assembly)?.GetName().Name.ToLowerInvariant();
			if (text == null)
			{
				return false;
			}
			if (!text.Contains("diomedes"))
			{
				return text.Contains("athena");
			}
			return true;
		}

		public static void Finish()
		{
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool IsPresent()
		{
			return true;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Diomedes.Client.Preloader";

		public const string PLUGIN_NAME = "Diomedes.Client.Preloader";

		public const string PLUGIN_VERSION = "0.9.0";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Athena;
using Diomedes.Shared.Data;
using Diomedes.Shared.Data.Settings;
using Diomedes.Shared.Data.User;
using Diomedes.Shared.GameMode;
using Diomedes.Shared.GameMode.GameSettings;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using Serilog;

[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("Diomedes.Shared")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.9.0.0")]
[assembly: AssemblyInformationalVersion("0.9.0+03a1858111402c9890133d64cf3f83ce16b9ffdb")]
[assembly: AssemblyProduct("Diomedes.Shared")]
[assembly: AssemblyTitle("Diomedes.Shared")]
[assembly: AssemblyVersion("0.9.0.0")]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Diomedes.Shared
{
	public static class DiomedesHelpers
	{
		public enum DurationFormat
		{
			AlwaysIncludeHours,
			IncludeHours,
			NeverIncludeHours
		}

		public const int LATEST_LC_VERSION = 81;

		public static readonly JsonSerializerSettings JSONSettings = new JsonSerializerSettings
		{
			ContractResolver = (IContractResolver)new DefaultContractResolver
			{
				NamingStrategy = (NamingStrategy)new SnakeCaseNamingStrategy()
			}
		};

		public static List<GameSettingsType> GetSettingsForGameMode<T>() where T : IGameMode
		{
			List<GameSettingsType> list = new List<GameSettingsType>();
			PropertyInfo[] properties = typeof(T).GetProperties();
			for (int i = 0; i < properties.Length; i++)
			{
				GameSettingsRefAttribute customAttribute = properties[i].GetCustomAttribute<GameSettingsRefAttribute>();
				if (customAttribute != null)
				{
					list.Add(customAttribute.SettingsType);
				}
			}
			return list;
		}

		public static bool TryUpdateGameSettings<T>(T gameInstance, GameSettingsType settingsType, BinaryReader reader, [NotNullWhen(true)] out IGameSettings? settings) where T : IGameMode
		{
			PropertyInfo[] properties = gameInstance.GetType().GetProperties();
			foreach (PropertyInfo propertyInfo in properties)
			{
				GameSettingsRefAttribute customAttribute = propertyInfo.GetCustomAttribute<GameSettingsRefAttribute>();
				if (customAttribute != null && customAttribute.SettingsType == settingsType)
				{
					settings = (IGameSettings)propertyInfo.PropertyType.GetMethod("AthenaReadFrom").Invoke(null, new object[1] { reader });
					propertyInfo.SetValue(gameInstance, settings);
					return true;
				}
			}
			settings = null;
			return false;
		}

		public static ushort GetMaxPacketID()
		{
			ushort num = 0;
			FieldInfo[] fields = typeof(PacketID).GetFields();
			for (int i = 0; i < fields.Length; i++)
			{
				ushort num2 = (ushort)fields[i].GetValue(null);
				if (num2 > num)
				{
					num = num2;
				}
			}
			return num;
		}

		public static string ToOrdinal(int number)
		{
			if (number < 0)
			{
				return number.ToString();
			}
			int num = number % 100;
			if (num == 11 || num == 12 || num == 13)
			{
				return number + "th";
			}
			return (number % 10) switch
			{
				1 => number + "st", 
				2 => number + "nd", 
				3 => number + "rd", 
				_ => number + "th", 
			};
		}

		public static string ToPercentage(float value)
		{
			return Math.Round(value * 100f) + "%";
		}

		public static string ToFormattedDifference(int target, int actual)
		{
			if (target == actual)
			{
				return "0";
			}
			if (target < actual)
			{
				return $"+{actual - target}";
			}
			return $"-{target - actual}";
		}

		public static string ToDuration(TimeSpan timer, DurationFormat format = DurationFormat.AlwaysIncludeHours)
		{
			if (format == DurationFormat.AlwaysIncludeHours || (format == DurationFormat.IncludeHours && timer.TotalHours > 0.0))
			{
				return $"{(int)timer.TotalHours:D2}:{timer.Minutes:D2}:{timer.Seconds:D2}";
			}
			return $"{timer.Minutes:D2}:{timer.Seconds:D2}";
		}

		public static string GroupSizeName(int number)
		{
			return number switch
			{
				1 => "Solo", 
				2 => "Duo", 
				3 => "Trio", 
				4 => "Squad", 
				_ => "Crowd", 
			};
		}

		public static string ToNaturalList(IList<string> items)
		{
			if (items == null || items.Count == 0)
			{
				return string.Empty;
			}
			if (items.Count == 1)
			{
				return items[0];
			}
			return string.Join(", ", items.Take(items.Count - 1)) + " and " + items.Last();
		}

		public static float GetProgress(DateTime start, DateTime end, DateTime now)
		{
			double totalSeconds = (end - start).TotalSeconds;
			return Math.Clamp((float)((now - start).TotalSeconds / totalSeconds), 0f, 1f);
		}
	}
	public static class DiomedesConstants
	{
		public const string VERSION = "0.9.0";
	}
}
namespace Diomedes.Shared.Util
{
	public static class SessionTokenHelpers
	{
		public static string GenerateSessionToken()
		{
			byte[] array = new byte[32];
			using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())
			{
				randomNumberGenerator.GetBytes(array);
			}
			return Convert.ToBase64String(array);
		}

		public static string HashSessionToken(string token)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(token);
			using SHA256 sHA = SHA256.Create();
			return BytesToHex(sHA.ComputeHash(bytes));
		}

		private static string BytesToHex(byte[] bytes)
		{
			StringBuilder stringBuilder = new StringBuilder(bytes.Length * 2);
			foreach (byte b in bytes)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}
	}
}
namespace Diomedes.Shared.Util.Extensions
{
	public static class EnumFlagExtensions
	{
		public static TEnum SetFlag<TEnum>(this TEnum flags, TEnum flag, bool enabled) where TEnum : struct, Enum
		{
			ulong num = Convert.ToUInt64(flags);
			ulong num2 = Convert.ToUInt64(flag);
			ulong value = (enabled ? (num | num2) : (num & ~num2));
			return (TEnum)Enum.ToObject(typeof(TEnum), value);
		}

		public static bool HasFlagFast<TEnum>(this TEnum flags, TEnum flag) where TEnum : struct, Enum
		{
			ulong num = Convert.ToUInt64(flags);
			ulong num2 = Convert.ToUInt64(flag);
			return (num & num2) == num2;
		}
	}
	public static class RandomExtensions
	{
		public static T NextItem<T>(this Random random, List<T> list)
		{
			return list[random.Next(0, list.Count)];
		}

		public static T NextWeighted<T>(this Random random, List<T> list) where T : IWeighted
		{
			int num = list.Sum((T it) => it.Weight);
			int num2 = random.Next(0, num + 1);
			T result = default(T);
			foreach (T item in list)
			{
				result = item;
				num2 -= item.Weight;
				if (num2 <= 0)
				{
					break;
				}
			}
			return result;
		}
	}
}
namespace Diomedes.Shared.Logging
{
	public class ConsoleLogger : IDiomedesLogger
	{
		public void LogDebug(object message)
		{
			ConsoleColor foregroundColor = Console.ForegroundColor;
			Console.ForegroundColor = ConsoleColor.DarkGray;
			Console.WriteLine($"[DEBUG] {message}");
			Console.ForegroundColor = foregroundColor;
		}

		public void LogInfo(object message)
		{
			Console.WriteLine($"[INFO] {message}");
		}

		public void LogWarn(object message)
		{
			ConsoleColor foregroundColor = Console.ForegroundColor;
			Console.ForegroundColor = ConsoleColor.Yellow;
			Console.WriteLine($"[WARN] {message}");
			Console.ForegroundColor = foregroundColor;
		}

		public void LogError(object message)
		{
			ConsoleColor foregroundColor = Console.ForegroundColor;
			Console.ForegroundColor = ConsoleColor.Red;
			Console.WriteLine($"[ERROR] {message}");
			Console.ForegroundColor = foregroundColor;
		}
	}
	public class FileLogger : IDiomedesLogger, IDisposable, IAsyncDisposable
	{
		private readonly FileStream? _stream;

		private readonly TextWriter? _writer;

		private readonly Timer? _timer;

		public FileLogger(string filePath)
		{
			try
			{
				_stream = new FileStream(filePath, FileMode.Create);
				_writer = TextWriter.Synchronized(new StreamWriter(_stream, Encoding.UTF8));
				_timer = new Timer(delegate
				{
					_writer.Flush();
				}, null, 2000, 2000);
			}
			catch (Exception)
			{
			}
		}

		public void LogDebug(object message)
		{
			_writer?.WriteLine($"[DEBUG] {message}");
		}

		public void LogInfo(object message)
		{
			_writer?.WriteLine($"[INFO] {message}");
		}

		public void LogWarn(object message)
		{
			_writer?.WriteLine($"[WARN] {message}");
		}

		public void LogError(object message)
		{
			_writer?.WriteLine($"[ERROR] {message}");
		}

		public void Dispose()
		{
			_stream?.Dispose();
			_writer?.Dispose();
			_timer?.Dispose();
		}

		public async ValueTask DisposeAsync()
		{
			if (_stream != null)
			{
				await _stream.DisposeAsync();
			}
			if (_writer != null)
			{
				await _writer.DisposeAsync();
			}
			if (_timer != null)
			{
				await _timer.DisposeAsync();
			}
		}
	}
	public interface IDiomedesLogger
	{
		void LogDebug(object message);

		void LogInfo(object message);

		void LogWarn(object message);

		void LogError(object message);
	}
	public class MultiLogger(params IDiomedesLogger[] loggers) : IDiomedesLogger
	{
		public void LogDebug(object message)
		{
			IDiomedesLogger[] array = loggers;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].LogDebug(message);
			}
		}

		public void LogInfo(object message)
		{
			IDiomedesLogger[] array = loggers;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].LogInfo(message);
			}
		}

		public void LogWarn(object message)
		{
			IDiomedesLogger[] array = loggers;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].LogWarn(message);
			}
		}

		public void LogError(object message)
		{
			IDiomedesLogger[] array = loggers;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].LogError(message);
			}
		}
	}
	public class PrefixWrappedLogger(string prefix, IDiomedesLogger passthrough) : IDiomedesLogger
	{
		public void LogDebug(object message)
		{
			passthrough.LogDebug($"[{prefix}] {message}");
		}

		public void LogInfo(object message)
		{
			passthrough.LogInfo($"[{prefix}] {message}");
		}

		public void LogWarn(object message)
		{
			passthrough.LogWarn($"[{prefix}] {message}");
		}

		public void LogError(object message)
		{
			passthrough.LogError($"[{prefix}] {message}");
		}
	}
	public class RemoveDebugLogsLogger(IDiomedesLogger passthrough) : IDiomedesLogger
	{
		public void LogDebug(object message)
		{
		}

		public void LogInfo(object message)
		{
			passthrough.LogInfo(message);
		}

		public void LogWarn(object message)
		{
			passthrough.LogWarn(message);
		}

		public void LogError(object message)
		{
			passthrough.LogError(message);
		}
	}
	public class WrapSerilogLogger(ILogger logger) : IDiomedesLogger
	{
		public void LogDebug(object message)
		{
			logger.Debug(message.ToString());
		}

		public void LogInfo(object message)
		{
			logger.Information(message.ToString());
		}

		public void LogWarn(object message)
		{
			logger.Warning(message.ToString());
		}

		public void LogError(object message)
		{
			logger.Error(message.ToString());
		}
	}
}
namespace Diomedes.Shared.GameMode
{
	[PacketSerializable]
	public class DayInfo
	{
		public bool IsCompanyDay { get; set; }

		public int Seed { get; set; }

		public string MoonKey { get; set; } = string.Empty;

		public string WeatherKey { get; set; } = string.Empty;

		public static bool operator ==(DayInfo day1, DayInfo day2)
		{
			return day1.Seed != day2.Seed;
		}

		public static bool operator !=(DayInfo day1, DayInfo day2)
		{
			return !(day1 == day2);
		}

		public override bool Equals(object? obj)
		{
			if (this == obj)
			{
				return true;
			}
			if (obj == null)
			{
				return false;
			}
			throw new NotImplementedException();
		}

		public override int GetHashCode()
		{
			throw new NotImplementedException();
		}

		public static DayInfo AthenaReadFrom(BinaryReader reader)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			bool isCompanyDay = reader.ReadBoolean();
			int seed = reader.ReadInt32();
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"MoonKey has a length of {num} exceeding the max 255");
			}
			string moonKey = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			int num2 = reader.ReadInt32();
			if (num2 >= 256)
			{
				throw new AthenaSerializationException($"WeatherKey has a length of {num2} exceeding the max 255");
			}
			string weatherKey = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num2)));
			return new DayInfo
			{
				IsCompanyDay = isCompanyDay,
				Seed = seed,
				MoonKey = moonKey,
				WeatherKey = weatherKey
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(IsCompanyDay);
			writer.Write(Seed);
			byte[] bytes = Encoding.Unicode.GetBytes(MoonKey);
			writer.Write(bytes.Length);
			writer.Write(bytes);
			byte[] bytes2 = Encoding.Unicode.GetBytes(WeatherKey);
			writer.Write(bytes2.Length);
			writer.Write(bytes2);
		}
	}
	public interface IGameMode
	{
		string Name { get; }
	}
}
namespace Diomedes.Shared.GameMode.Race
{
	public enum RaceCheckpointType : byte
	{
		Day,
		Quota,
		Race
	}
	[PacketSerializable]
	public class QuotaInfo
	{
		public DayInfo[] Days { get; init; } = Array.Empty<DayInfo>();

		public void DebugLog(ILogger logger)
		{
			for (int i = 0; i < Days.Length; i++)
			{
				DayInfo dayInfo = Days[i];
				logger.Information("\tDay {Day}: {Moon} ({Weather}); Seed = {Seed}", new object[4] { i, dayInfo.MoonKey, dayInfo.WeatherKey, dayInfo.Seed });
			}
		}

		public static QuotaInfo AthenaReadFrom(BinaryReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Days has a length of {num} exceeding the max 255");
			}
			DayInfo[] array = new DayInfo[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = DayInfo.AthenaReadFrom(reader);
			}
			return new QuotaInfo
			{
				Days = array
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Days.Length);
			DayInfo[] days = Days;
			for (int i = 0; i < days.Length; i++)
			{
				days[i].AthenaWriteTo(writer);
			}
		}
	}
	[PacketSerializable]
	public class RaceGameData
	{
		public QuotaInfo[] Quotas { get; init; } = Array.Empty<QuotaInfo>();

		public void DebugLog(ILogger logger)
		{
			for (int i = 0; i < Quotas.Length; i++)
			{
				QuotaInfo obj = Quotas[i];
				logger.Information<int>("Quota {Quota}:", i);
				obj.DebugLog(logger);
			}
		}

		public bool TryGetDay(int quota, int day, [NotNullWhen(true)] out DayInfo? dayInfo)
		{
			dayInfo = null;
			if (quota >= Quotas.Length)
			{
				return false;
			}
			if (day >= Quotas[quota].Days.Length)
			{
				return false;
			}
			dayInfo = Quotas[quota].Days[day];
			return true;
		}

		public static RaceGameData AthenaReadFrom(BinaryReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Quotas has a length of {num} exceeding the max 255");
			}
			QuotaInfo[] array = new QuotaInfo[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = QuotaInfo.AthenaReadFrom(reader);
			}
			return new RaceGameData
			{
				Quotas = array
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Quotas.Length);
			QuotaInfo[] quotas = Quotas;
			for (int i = 0; i < quotas.Length; i++)
			{
				quotas[i].AthenaWriteTo(writer);
			}
		}
	}
	[PacketSerializable]
	public class RaceGameResults
	{
		public byte[] CrewPlacements { get; set; } = Array.Empty<byte>();

		public static RaceGameResults AthenaReadFrom(BinaryReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"CrewPlacements has a length of {num} exceeding the max 255");
			}
			byte[] array = new byte[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = reader.ReadByte();
			}
			return new RaceGameResults
			{
				CrewPlacements = array
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(CrewPlacements.Length);
			byte[] crewPlacements = CrewPlacements;
			foreach (byte value in crewPlacements)
			{
				writer.Write(value);
			}
		}
	}
	public enum CompletionBroadcastMode : byte
	{
		Everytime,
		CrewNewHighest,
		MatchNewHighest
	}
	[PacketSerializable]
	public class RaceGameSettings : IGameSettings
	{
		public int TargetQuota { get; set; } = 3;

		public QuotaFormula Formula { get; set; } = new QuotaFormula();

		public bool AllowDuplicateMoonsInQuota { get; set; }

		public bool AllowDuplicateWeathersInQuota { get; set; }

		public bool IncludeDine { get; set; }

		public bool GenerateLocally { get; set; }

		public int MaxCompletions { get; set; } = 1;

		public CompletionBroadcastMode CompletionBroadcast { get; set; } = CompletionBroadcastMode.CrewNewHighest;

		public GameSettingsType SettingsType => GameSettingsType.Race;

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine($"Race to be the first {MaxCompletions} crew(s) to complete the target quota!");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"TargetQuota = {TargetQuota}");
			stringBuilder.AppendLine(Formula.Describe() ?? "");
			stringBuilder.AppendLine("Scrap is not kept between quotas");
			stringBuilder.AppendLine("Losing a quota restarts the current one.");
			switch (CompletionBroadcast)
			{
			case CompletionBroadcastMode.Everytime:
				stringBuilder.AppendLine("Everytime a crew completes a day/quota a message is broadcasted.");
				break;
			case CompletionBroadcastMode.CrewNewHighest:
				stringBuilder.AppendLine("When a crew reaches a new highest day/quota a message is broadcasted");
				break;
			case CompletionBroadcastMode.MatchNewHighest:
				stringBuilder.AppendLine("When a crew reaches a new highest day/quota across the entire match, a message is broadcasted.");
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
			return stringBuilder.ToString();
		}

		public static RaceGameSettings AthenaReadFrom(BinaryReader reader)
		{
			int targetQuota = reader.ReadInt32();
			QuotaFormula formula = QuotaFormula.AthenaReadFrom(reader);
			bool allowDuplicateMoonsInQuota = reader.ReadBoolean();
			bool allowDuplicateWeathersInQuota = reader.ReadBoolean();
			bool includeDine = reader.ReadBoolean();
			bool generateLocally = reader.ReadBoolean();
			int maxCompletions = reader.ReadInt32();
			CompletionBroadcastMode completionBroadcast = (CompletionBroadcastMode)reader.ReadByte();
			return new RaceGameSettings
			{
				TargetQuota = targetQuota,
				Formula = formula,
				AllowDuplicateMoonsInQuota = allowDuplicateMoonsInQuota,
				AllowDuplicateWeathersInQuota = allowDuplicateWeathersInQuota,
				IncludeDine = includeDine,
				GenerateLocally = generateLocally,
				MaxCompletions = maxCompletions,
				CompletionBroadcast = completionBroadcast
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(TargetQuota);
			Formula.AthenaWriteTo(writer);
			writer.Write(AllowDuplicateMoonsInQuota);
			writer.Write(AllowDuplicateWeathersInQuota);
			writer.Write(IncludeDine);
			writer.Write(GenerateLocally);
			writer.Write(MaxCompletions);
			writer.Write((byte)CompletionBroadcast);
		}
	}
}
namespace Diomedes.Shared.GameMode.Knockout
{
	[PacketSerializable]
	public class KnockoutGameResults
	{
		public byte WinningCrew { get; set; }

		public static KnockoutGameResults AthenaReadFrom(BinaryReader reader)
		{
			byte winningCrew = reader.ReadByte();
			return new KnockoutGameResults
			{
				WinningCrew = winningCrew
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(WinningCrew);
		}
	}
	[PacketSerializable]
	public class KnockoutGameSettings : IGameSettings
	{
		public int Lives { get; set; } = 3;

		public float DepreciationFactor { get; set; } = 0.4f;

		public float SafePercentage { get; set; } = 0.5f;

		public int SafeQuotas { get; set; }

		public bool IncludeDine { get; set; }

		public bool GenerateLocally { get; set; }

		public KnockoutOddStratergy OddStratergy { get; set; }

		public GameSettingsType SettingsType => GameSettingsType.Knockout;

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Fight to collect the most scrap in a quota, or lose a life and face elimination...");
			stringBuilder.AppendLine();
			stringBuilder.AppendLine($"{Lives} lives");
			stringBuilder.AppendLine("Bottom " + DiomedesHelpers.ToPercentage(1f - SafePercentage) + " lose a life.");
			if (SafeQuotas == 0)
			{
				stringBuilder.AppendLine("No safe quota.");
			}
			else if (SafeQuotas == 1)
			{
				stringBuilder.AppendLine("First quota no lives are lost.");
			}
			else
			{
				stringBuilder.AppendLine($"First {SafeQuotas} quotas have no lives lost.");
			}
			stringBuilder.AppendLine("Scrap is not kept between quotas");
			return stringBuilder.ToString();
		}

		public static KnockoutGameSettings AthenaReadFrom(BinaryReader reader)
		{
			int lives = reader.ReadInt32();
			float depreciationFactor = reader.ReadSingle();
			float safePercentage = reader.ReadSingle();
			int safeQuotas = reader.ReadInt32();
			bool includeDine = reader.ReadBoolean();
			bool generateLocally = reader.ReadBoolean();
			KnockoutOddStratergy oddStratergy = (KnockoutOddStratergy)reader.ReadByte();
			return new KnockoutGameSettings
			{
				Lives = lives,
				DepreciationFactor = depreciationFactor,
				SafePercentage = safePercentage,
				SafeQuotas = safeQuotas,
				IncludeDine = includeDine,
				GenerateLocally = generateLocally,
				OddStratergy = oddStratergy
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Lives);
			writer.Write(DepreciationFactor);
			writer.Write(SafePercentage);
			writer.Write(SafeQuotas);
			writer.Write(IncludeDine);
			writer.Write(GenerateLocally);
			writer.Write((byte)OddStratergy);
		}
	}
	[PacketSerializable]
	public class Placement
	{
		public byte CrewID;

		public int ScrapSold;

		public static Placement AthenaReadFrom(BinaryReader reader)
		{
			return new Placement();
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
		}
	}
	[PacketSerializable]
	public class KnockoutLeaderboard
	{
		public Placement[] Placements;

		[Obsolete]
		public int SafePlacement;

		public int RemainingCrews;

		public static KnockoutLeaderboard AthenaReadFrom(BinaryReader reader)
		{
			return new KnockoutLeaderboard();
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
		}
	}
	public enum KnockoutOddStratergy : byte
	{
		RoundUp,
		RoundDown
	}
}
namespace Diomedes.Shared.GameMode.GameSettings
{
	[PacketSerializable]
	public class ChatGameSettings : IGameSettings
	{
		public bool GlobalChat { get; set; } = true;

		public bool DeadAliveTalk { get; set; }

		public GameSettingsType SettingsType => GameSettingsType.Chat;

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (GlobalChat)
			{
				stringBuilder.Append("Players can talk to eachother from any distance");
			}
			if (DeadAliveTalk)
			{
				stringBuilder.Append("The dead can talk with the living");
			}
			return stringBuilder.ToString();
		}

		public static ChatGameSettings AthenaReadFrom(BinaryReader reader)
		{
			bool globalChat = reader.ReadBoolean();
			bool deadAliveTalk = reader.ReadBoolean();
			return new ChatGameSettings
			{
				GlobalChat = globalChat,
				DeadAliveTalk = deadAliveTalk
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(GlobalChat);
			writer.Write(DeadAliveTalk);
		}
	}
	[Flags]
	public enum CompanyFlags : byte
	{
		None = 0,
		CanAttack = 1,
		AlwaysMaxBuyRate = 2
	}
	[PacketSerializable]
	public class CompanyGameSettings : IGameSettings
	{
		public CompanyFlags Flags { get; set; } = CompanyFlags.AlwaysMaxBuyRate;

		public GameSettingsType SettingsType => GameSettingsType.Company;

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (!Flags.HasFlag(CompanyFlags.CanAttack))
			{
				stringBuilder.AppendLine("The company can not attack.");
			}
			if (Flags.HasFlag(CompanyFlags.AlwaysMaxBuyRate))
			{
				stringBuilder.AppendLine("The company always buys at 100%.");
			}
			return stringBuilder.ToString();
		}

		public static CompanyGameSettings AthenaReadFrom(BinaryReader reader)
		{
			CompanyFlags flags = (CompanyFlags)reader.ReadByte();
			return new CompanyGameSettings
			{
				Flags = flags
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write((byte)Flags);
		}
	}
	public enum GameModeType : byte
	{
		Knockout,
		Race,
		Bingo
	}
	[AttributeUsage(AttributeTargets.Property)]
	public sealed class GameSettingsRefAttribute(GameSettingsType settingsType) : Attribute()
	{
		public GameSettingsType SettingsType => settingsType;
	}
	public enum GameSettingsType : byte
	{
		Knockout,
		Race,
		ScrapClear,
		Company,
		Bingo,
		Main,
		Chat
	}
	public interface IGameSettings
	{
		GameSettingsType SettingsType { get; }

		string Description();

		void AthenaWriteTo(BinaryWriter writer);
	}
	[PacketSerializable]
	public class MainGameSettings : IGameSettings
	{
		public GameSettingsType SettingsType => GameSettingsType.Main;

		public bool AllowVanillaLogging { get; set; }

		public int StartingCredits { get; set; } = 60;

		public bool AllowOvertime { get; set; }

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("Starting Credits: ");
			stringBuilder.Append(StartingCredits);
			if (AllowVanillaLogging)
			{
				stringBuilder.Append("\nVanilla Logging is enabled (Should only be enabled for debug purposes).");
			}
			if (AllowOvertime)
			{
				stringBuilder.Append("\nOvertime is enabled.");
			}
			return stringBuilder.ToString();
		}

		public static MainGameSettings AthenaReadFrom(BinaryReader reader)
		{
			bool allowVanillaLogging = reader.ReadBoolean();
			int startingCredits = reader.ReadInt32();
			bool allowOvertime = reader.ReadBoolean();
			return new MainGameSettings
			{
				AllowVanillaLogging = allowVanillaLogging,
				StartingCredits = startingCredits,
				AllowOvertime = allowOvertime
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(AllowVanillaLogging);
			writer.Write(StartingCredits);
			writer.Write(AllowOvertime);
		}
	}
	[PacketSerializable]
	public class ScrapClearSettings : IGameSettings
	{
		public GameSettingsType SettingsType => GameSettingsType.ScrapClear;

		public bool ExcludeCertainWeapons { get; set; } = true;

		public bool AutoSell { get; set; } = true;

		public bool AllowSellingDeadPlayers { get; set; }

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("Scrap is not kept between quotas.");
			if (ExcludeCertainWeapons)
			{
				stringBuilder.Append(" (Shotguns and knives are excluded)");
			}
			if (AutoSell)
			{
				stringBuilder.Append("\nItems are automatically sold.");
			}
			if (AllowSellingDeadPlayers)
			{
				stringBuilder.Append("\nDead players can be sold for extra cash.");
			}
			return stringBuilder.ToString();
		}

		public static ScrapClearSettings AthenaReadFrom(BinaryReader reader)
		{
			bool excludeCertainWeapons = reader.ReadBoolean();
			bool autoSell = reader.ReadBoolean();
			bool allowSellingDeadPlayers = reader.ReadBoolean();
			return new ScrapClearSettings
			{
				ExcludeCertainWeapons = excludeCertainWeapons,
				AutoSell = autoSell,
				AllowSellingDeadPlayers = allowSellingDeadPlayers
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(ExcludeCertainWeapons);
			writer.Write(AutoSell);
			writer.Write(AllowSellingDeadPlayers);
		}
	}
}
namespace Diomedes.Shared.GameMode.Bingo
{
	[PacketSerializable]
	public class BingoBoard
	{
		public string[] Namespaces { get; init; } = Array.Empty<string>();

		public BingoSquare[,] Squares { get; init; }

		public static BingoBoard AthenaReadFrom(BinaryReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Namespaces has a length of {num} exceeding the max 255");
			}
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				int num2 = reader.ReadInt32();
				if (num2 >= 256)
				{
					throw new AthenaSerializationException($"element[NamespacesRank0] in array Namespaces has a length of {num2} exceeding the max 255");
				}
				array[i] = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num2)));
			}
			int num3 = reader.ReadInt32();
			if (num3 >= 256)
			{
				throw new AthenaSerializationException($"Squares has a length of {num3} exceeding the max 255");
			}
			int num4 = reader.ReadInt32();
			if (num4 >= 256)
			{
				throw new AthenaSerializationException($"Squares has a length of {num4} exceeding the max 255");
			}
			BingoSquare[,] array2 = new BingoSquare[num3, num4];
			for (int j = 0; j < num3; j++)
			{
				for (int k = 0; k < num4; k++)
				{
					array2[j, k] = BingoSquare.AthenaReadFrom(reader);
				}
			}
			return new BingoBoard
			{
				Namespaces = array,
				Squares = array2
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Namespaces.Length);
			string[] namespaces = Namespaces;
			foreach (string s in namespaces)
			{
				byte[] bytes = Encoding.Unicode.GetBytes(s);
				writer.Write(bytes.Length);
				writer.Write(bytes);
			}
			writer.Write(Squares.GetLength(0));
			writer.Write(Squares.GetLength(1));
			BingoSquare[,] squares = Squares;
			int i = squares.GetUpperBound(0);
			int upperBound = squares.GetUpperBound(1);
			for (int j = squares.GetLowerBound(0); j <= i; j++)
			{
				for (int k = squares.GetLowerBound(1); k <= upperBound; k++)
				{
					squares[j, k].AthenaWriteTo(writer);
				}
			}
		}
	}
	[PacketSerializable]
	public class BingoGameSettings : IGameSettings
	{
		public GameSettingsType SettingsType => GameSettingsType.Bingo;

		public string Description()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("Complete challenges along the bingo board to win!");
			stringBuilder.AppendLine("5x5 board");
			stringBuilder.AppendLine("Lockout Bingo: Once a challenge is completed, no other crew can claim it!");
			return stringBuilder.ToString();
		}

		public static BingoGameSettings AthenaReadFrom(BinaryReader reader)
		{
			return new BingoGameSettings();
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
		}
	}
	[PacketSerializable]
	public class BingoSquare
	{
		public byte NamespaceID { get; init; }

		public string Key { get; init; } = string.Empty;

		public override string ToString()
		{
			return Key;
		}

		public static BingoSquare AthenaReadFrom(BinaryReader reader)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			byte namespaceID = reader.ReadByte();
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Key has a length of {num} exceeding the max 255");
			}
			string key = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			return new BingoSquare
			{
				NamespaceID = namespaceID,
				Key = key
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(NamespaceID);
			byte[] bytes = Encoding.Unicode.GetBytes(Key);
			writer.Write(bytes.Length);
			writer.Write(bytes);
		}
	}
	public enum BingoWinCondition : byte
	{
		Line,
		Lockout
	}
	public enum ChallengeDifficulty : byte
	{
		ONE,
		TWO,
		THREE,
		FOUR,
		FIVE
	}
}
namespace Diomedes.Shared.Packets
{
	[PacketSerializable]
	public class ActiveClientRestriction
	{
		public required string LiftedAt { get; init; }

		public bool IsPermanent()
		{
			return string.IsNullOrEmpty(LiftedAt);
		}

		public ActiveClientRestriction()
		{
		}

		public ActiveClientRestriction(DateTime? dateTime)
		{
			LiftedAt = dateTime?.ToString() ?? string.Empty;
		}

		public DateTime AsDateTime()
		{
			return DateTime.Parse(LiftedAt);
		}

		public static ActiveClientRestriction AthenaReadFrom(BinaryReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"LiftedAt has a length of {num} exceeding the max 255");
			}
			string liftedAt = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			return new ActiveClientRestriction
			{
				LiftedAt = liftedAt
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			byte[] bytes = Encoding.Unicode.GetBytes(LiftedAt);
			writer.Write(bytes.Length);
			writer.Write(bytes);
		}
	}
	[PacketSerializable]
	public class ClientRestrictions
	{
		public ActiveClientRestriction? Access { get; set; }

		public ActiveClientRestriction? Text { get; set; }

		public ActiveClientRestriction? Voice { get; set; }

		public ActiveClientRestriction? Competitive { get; set; }

		public static ClientRestrictions Clean => new ClientRestrictions();

		public void DebugLog(ILogger logger)
		{
			logger.Information<bool>("Access Restricted? {Value}", Access != null);
			logger.Information<bool>("Text Chat Restricted? {Value}", Text != null);
			logger.Information<bool>("Voice Chat Restricted? {Value}", Voice != null);
			logger.Information<bool>("Competitive Restricted? {Value}", Competitive != null);
		}

		public bool IsClean()
		{
			if (Access == null && Text == null && Voice == null)
			{
				return Competitive == null;
			}
			return false;
		}

		public static ClientRestrictions AthenaReadFrom(BinaryReader reader)
		{
			bool num = reader.ReadBoolean();
			ActiveClientRestriction access = null;
			if (num)
			{
				access = ActiveClientRestriction.AthenaReadFrom(reader);
			}
			bool num2 = reader.ReadBoolean();
			ActiveClientRestriction text = null;
			if (num2)
			{
				text = ActiveClientRestriction.AthenaReadFrom(reader);
			}
			bool num3 = reader.ReadBoolean();
			ActiveClientRestriction voice = null;
			if (num3)
			{
				voice = ActiveClientRestriction.AthenaReadFrom(reader);
			}
			bool num4 = reader.ReadBoolean();
			ActiveClientRestriction competitive = null;
			if (num4)
			{
				competitive = ActiveClientRestriction.AthenaReadFrom(reader);
			}
			return new ClientRestrictions
			{
				Access = access,
				Text = text,
				Voice = voice,
				Competitive = competitive
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Access != null);
			if (Access != null)
			{
				Access.AthenaWriteTo(writer);
			}
			writer.Write(Text != null);
			if (Text != null)
			{
				Text.AthenaWriteTo(writer);
			}
			writer.Write(Voice != null);
			if (Voice != null)
			{
				Voice.AthenaWriteTo(writer);
			}
			writer.Write(Competitive != null);
			if (Competitive != null)
			{
				Competitive.AthenaWriteTo(writer);
			}
		}
	}
}
namespace Diomedes.Shared.Data
{
	[PacketSerializable]
	public class DayResults
	{
		public byte Quota { get; init; }

		public byte Day { get; init; }

		public override string ToString()
		{
			return $"Q{Quota}D{Day}";
		}

		public static bool operator >(DayResults r1, DayResults r2)
		{
			if (r1.Quota > r2.Quota)
			{
				return true;
			}
			if (r1.Day > r2.Day)
			{
				return true;
			}
			return false;
		}

		public static bool operator <(DayResults r1, DayResults r2)
		{
			if (r1.Quota < r2.Quota)
			{
				return true;
			}
			if (r1.Day < r2.Day)
			{
				return true;
			}
			return false;
		}

		public static DayResults AthenaReadFrom(BinaryReader reader)
		{
			byte quota = reader.ReadByte();
			byte day = reader.ReadByte();
			return new DayResults
			{
				Quota = quota,
				Day = day
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Quota);
			writer.Write(Day);
		}
	}
	[PacketSerializable]
	public class DColor
	{
		public byte Red { get; init; }

		public byte Green { get; init; }

		public byte Blue { get; init; }

		public static DColor FromHexCode(string hexCode)
		{
			string text = hexCode.Replace("#", string.Empty);
			string s = text.Substring(0, 2);
			string s2 = text.Substring(2, 2);
			string s3 = text.Substring(4, 2);
			return new DColor
			{
				Red = byte.Parse(s, NumberStyles.HexNumber),
				Green = byte.Parse(s2, NumberStyles.HexNumber),
				Blue = byte.Parse(s3, NumberStyles.HexNumber)
			};
		}

		public string ToHexCode()
		{
			return $"#{Red:X2}{Green:X2}{Blue:X2}";
		}

		public static DColor AthenaReadFrom(BinaryReader reader)
		{
			byte red = reader.ReadByte();
			byte green = reader.ReadByte();
			byte blue = reader.ReadByte();
			return new DColor
			{
				Red = red,
				Green = green,
				Blue = blue
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Red);
			writer.Write(Green);
			writer.Write(Blue);
		}
	}
	public interface IWeighted
	{
		int Weight { get; }
	}
	public class PossibleChoice<T>(T value, int weight) : IWeighted
	{
		public int Weight => <weight>P;

		public T Value => <value>P;
	}
	[PacketSerializable]
	public class QuotaResults
	{
		public int ScrapSold { get; init; }

		public bool Passed { get; init; }

		public static QuotaResults AthenaReadFrom(BinaryReader reader)
		{
			int scrapSold = reader.ReadInt32();
			bool passed = reader.ReadBoolean();
			return new QuotaResults
			{
				ScrapSold = scrapSold,
				Passed = passed
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(ScrapSold);
			writer.Write(Passed);
		}
	}
	[PacketSerializable]
	public class SerializableDateTime
	{
		public int Year { get; init; }

		public byte Month { get; init; }

		public byte Day { get; init; }

		public byte Hour { get; init; }

		public byte Minute { get; init; }

		public byte Second { get; init; }

		public static SerializableDateTime FromDateTime(DateTime dateTime)
		{
			return new SerializableDateTime
			{
				Year = dateTime.Year,
				Month = (byte)dateTime.Month,
				Day = (byte)dateTime.Day,
				Hour = (byte)dateTime.Hour,
				Minute = (byte)dateTime.Minute,
				Second = (byte)dateTime.Second
			};
		}

		public static SerializableDateTime Parse(string input)
		{
			return FromDateTime(DateTime.Parse(input));
		}

		public DateTime ToDateTime()
		{
			return new DateTime(Year, Month, Day, Hour, Minute, Second);
		}

		public static SerializableDateTime AthenaReadFrom(BinaryReader reader)
		{
			int year = reader.ReadInt32();
			byte month = reader.ReadByte();
			byte day = reader.ReadByte();
			byte hour = reader.ReadByte();
			byte minute = reader.ReadByte();
			byte second = reader.ReadByte();
			return new SerializableDateTime
			{
				Year = year,
				Month = month,
				Day = day,
				Hour = hour,
				Minute = minute,
				Second = second
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Year);
			writer.Write(Month);
			writer.Write(Day);
			writer.Write(Hour);
			writer.Write(Minute);
			writer.Write(Second);
		}
	}
	[PacketSerializable]
	public class ServerInfo
	{
		public string Version { get; init; } = "0.9.0";

		public string DiscordClientID { get; init; } = string.Empty;

		public static ServerInfo AthenaReadFrom(BinaryReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Version has a length of {num} exceeding the max 255");
			}
			string version = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			int num2 = reader.ReadInt32();
			if (num2 >= 256)
			{
				throw new AthenaSerializationException($"DiscordClientID has a length of {num2} exceeding the max 255");
			}
			string discordClientID = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num2)));
			return new ServerInfo
			{
				Version = version,
				DiscordClientID = discordClientID
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			byte[] bytes = Encoding.Unicode.GetBytes(Version);
			writer.Write(bytes.Length);
			writer.Write(bytes);
			byte[] bytes2 = Encoding.Unicode.GetBytes(DiscordClientID);
			writer.Write(bytes2.Length);
			writer.Write(bytes2);
		}
	}
}
namespace Diomedes.Shared.Data.User
{
	[PacketSerializable]
	public class CrewInfo
	{
		public byte ID { get; init; }

		public string Name { get; set; } = "A crew";

		public UserInfo[] Users { get; set; } = Array.Empty<UserInfo>();

		public Guid CaptainUUID { get; set; }

		public DColor Color { get; set; } = DColor.FromHexCode("#ffffff");

		public override string ToString()
		{
			return $"{Name} (captain: {CaptainUUID})";
		}

		public static CrewInfo AthenaReadFrom(BinaryReader reader)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			byte iD = reader.ReadByte();
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Name has a length of {num} exceeding the max 255");
			}
			string name = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			int num2 = reader.ReadInt32();
			if (num2 >= 256)
			{
				throw new AthenaSerializationException($"Users has a length of {num2} exceeding the max 255");
			}
			UserInfo[] array = new UserInfo[num2];
			for (int i = 0; i < num2; i++)
			{
				array[i] = UserInfo.AthenaReadFrom(reader);
			}
			Guid captainUUID = new Guid(reader.ReadBytes(16));
			DColor color = DColor.AthenaReadFrom(reader);
			return new CrewInfo
			{
				ID = iD,
				Name = name,
				Users = array,
				CaptainUUID = captainUUID,
				Color = color
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(ID);
			byte[] bytes = Encoding.Unicode.GetBytes(Name);
			writer.Write(bytes.Length);
			writer.Write(bytes);
			writer.Write(Users.Length);
			UserInfo[] users = Users;
			for (int i = 0; i < users.Length; i++)
			{
				users[i].AthenaWriteTo(writer);
			}
			writer.Write(CaptainUUID.ToByteArray());
			Color.AthenaWriteTo(writer);
		}
	}
	public enum LoginFailReason : byte
	{
		DisallowGuests,
		NotWhitelisted,
		DiscordAuthFail,
		SessionTokenInvalid,
		MismatchSteamID,
		AccessBanned,
		InternalServerFail,
		ServerFull
	}
	[PacketSerializable]
	public class UserInfo
	{
		public Guid UUID { get; init; }

		public string Username { get; init; } = string.Empty;

		public ulong SteamId { get; init; }

		public string DiscordID { get; init; }

		public override int GetHashCode()
		{
			return UUID.GetHashCode();
		}

		public override string ToString()
		{
			return $"{Username} ({UUID}) ({SteamId})";
		}

		public static UserInfo AthenaReadFrom(BinaryReader reader)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			Guid uUID = new Guid(reader.ReadBytes(16));
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Username has a length of {num} exceeding the max 255");
			}
			string username = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			ulong steamId = reader.ReadUInt64();
			int num2 = reader.ReadInt32();
			if (num2 >= 256)
			{
				throw new AthenaSerializationException($"DiscordID has a length of {num2} exceeding the max 255");
			}
			string discordID = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num2)));
			return new UserInfo
			{
				UUID = uUID,
				Username = username,
				SteamId = steamId,
				DiscordID = discordID
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(UUID.ToByteArray());
			byte[] bytes = Encoding.Unicode.GetBytes(Username);
			writer.Write(bytes.Length);
			writer.Write(bytes);
			writer.Write(SteamId);
			byte[] bytes2 = Encoding.Unicode.GetBytes(DiscordID);
			writer.Write(bytes2.Length);
			writer.Write(bytes2);
		}
	}
}
namespace Diomedes.Shared.Data.Settings
{
	[PacketSerializable]
	public class QuotaFormula
	{
		public int Starting { get; set; } = 400;

		public int LinearIncrease { get; set; } = 100;

		public int CalculateForQuota(int quota)
		{
			return Starting + LinearIncrease * quota;
		}

		public string Describe()
		{
			return $"Quota starts at {Starting} and increases by +{LinearIncrease}";
		}

		public static QuotaFormula AthenaReadFrom(BinaryReader reader)
		{
			int starting = reader.ReadInt32();
			int linearIncrease = reader.ReadInt32();
			return new QuotaFormula
			{
				Starting = starting,
				LinearIncrease = linearIncrease
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(Starting);
			writer.Write(LinearIncrease);
		}
	}
}
namespace Diomedes.Shared.Data.Match
{
	public enum LobbyJoinFailReason : byte
	{
		MatchFull,
		MatchDoesNotExist,
		AlreadyInAMatch,
		InProgress,
		TimedOut,
		InternalServerFail
	}
	[PacketSerializable]
	public class MatchInfo
	{
		public int JoinCode { get; init; }

		public GameModeType GameMode { get; init; }

		public CrewInfo[] Crews { get; init; }

		public Guid HostUUID { get; init; }

		public string Name { get; init; } = string.Empty;

		public bool IsDaily { get; init; }

		public bool IsComp { get; init; }

		public static MatchInfo AthenaReadFrom(BinaryReader reader)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			int joinCode = reader.ReadInt32();
			GameModeType gameMode = (GameModeType)reader.ReadByte();
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Crews has a length of {num} exceeding the max 255");
			}
			CrewInfo[] array = new CrewInfo[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = CrewInfo.AthenaReadFrom(reader);
			}
			Guid hostUUID = new Guid(reader.ReadBytes(16));
			int num2 = reader.ReadInt32();
			if (num2 >= 256)
			{
				throw new AthenaSerializationException($"Name has a length of {num2} exceeding the max 255");
			}
			string name = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num2)));
			bool isDaily = reader.ReadBoolean();
			bool isComp = reader.ReadBoolean();
			return new MatchInfo
			{
				JoinCode = joinCode,
				GameMode = gameMode,
				Crews = array,
				HostUUID = hostUUID,
				Name = name,
				IsDaily = isDaily,
				IsComp = isComp
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write(JoinCode);
			writer.Write((byte)GameMode);
			writer.Write(Crews.Length);
			CrewInfo[] crews = Crews;
			for (int i = 0; i < crews.Length; i++)
			{
				crews[i].AthenaWriteTo(writer);
			}
			writer.Write(HostUUID.ToByteArray());
			byte[] bytes = Encoding.Unicode.GetBytes(Name);
			writer.Write(bytes.Length);
			writer.Write(bytes);
			writer.Write(IsDaily);
			writer.Write(IsComp);
		}
	}
	public enum MatchState : byte
	{
		InLobby,
		PreGame,
		InGame,
		PostGame
	}
}
namespace Diomedes.Shared.Data.Chat
{
	public class ChatChannel : IEnumerable<ChatMessage>, IEnumerable
	{
		public ChatTarget Target;

		public string ChannelName = "Default Name";

		private List<ChatMessage> _messages = new List<ChatMessage>();

		public static ChatFilter? Filter { get; set; }

		public event Action<ChatMessage> OnNewMessage = delegate
		{
		};

		public void Add(ChatMessage message)
		{
			if (Filter != null)
			{
				message.Message = Filter.Filter(message.Message);
			}
			_messages.Add(message);
			this.OnNewMessage(message);
		}

		public IEnumerator<ChatMessage> GetEnumerator()
		{
			return _messages.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class ChatFilter
	{
		private record struct CompiledFilter(Regex Regex, string Replacement);

		private List<CompiledFilter> _regex = words.Select((string it) => new CompiledFilter(new Regex("\\b" + it.ToLowerInvariant() + "\\b"), new string('*', it.Length))).ToList();

		public ChatFilter(IEnumerable<string> words)
		{
		}

		public string Filter(string input)
		{
			foreach (CompiledFilter item in _regex)
			{
				input = item.Regex.Replace(input, item.Replacement);
			}
			return input;
		}
	}
	[PacketSerializable]
	public class ChatMessage
	{
		public ChatTarget Target { get; init; }

		public string Sender { get; init; } = string.Empty;

		public string Message { get; set; } = string.Empty;

		public bool IsServerMessage()
		{
			return string.IsNullOrEmpty(Sender);
		}

		public static ChatMessage AthenaReadFrom(BinaryReader reader)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			ChatTarget target = (ChatTarget)reader.ReadByte();
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Sender has a length of {num} exceeding the max 255");
			}
			string sender = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			int num2 = reader.ReadInt32();
			if (num2 >= 256)
			{
				throw new AthenaSerializationException($"Message has a length of {num2} exceeding the max 255");
			}
			string message = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num2)));
			return new ChatMessage
			{
				Target = target,
				Sender = sender,
				Message = message
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write((byte)Target);
			byte[] bytes = Encoding.Unicode.GetBytes(Sender);
			writer.Write(bytes.Length);
			writer.Write(bytes);
			byte[] bytes2 = Encoding.Unicode.GetBytes(Message);
			writer.Write(bytes2.Length);
			writer.Write(bytes2);
		}
	}
	[PacketSerializable]
	public class ChatRequest
	{
		public ChatTarget Target { get; init; }

		public string Message { get; init; } = string.Empty;

		public static ChatRequest AthenaReadFrom(BinaryReader reader)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			ChatTarget target = (ChatTarget)reader.ReadByte();
			int num = reader.ReadInt32();
			if (num >= 256)
			{
				throw new AthenaSerializationException($"Message has a length of {num} exceeding the max 255");
			}
			string message = new string(Encoding.Unicode.GetChars(reader.ReadBytes(num)));
			return new ChatRequest
			{
				Target = target,
				Message = message
			};
		}

		public void AthenaWriteTo(BinaryWriter writer)
		{
			writer.Write((byte)Target);
			byte[] bytes = Encoding.Unicode.GetBytes(Message);
			writer.Write(bytes.Length);
			writer.Write(bytes);
		}
	}
	public enum ChatTarget : byte
	{
		Match,
		Crew
	}
}