using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using EndlessDelivery.Api.Exceptions;
using EndlessDelivery.Api.Requests;
using EndlessDelivery.Common;
using EndlessDelivery.Common.Communication.Scores;
using EndlessDelivery.Common.ContentFile;
using EndlessDelivery.Common.Inventory.Items;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("EndlessDelivery.Api")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b5dc0c560e2a25aa15f1eef619719550a062d078")]
[assembly: AssemblyProduct("EndlessDelivery.Api")]
[assembly: AssemblyTitle("EndlessDelivery.Api")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class BadRequestException : Exception
{
	public BadRequestException(string reason)
		: base("Server rejected request as " + reason)
	{
	}
}
namespace EndlessDelivery.Api
{
	public class ApiContext
	{
		private const string ProdUrl = "https://delivery.wafflethings.dev/api/";

		public readonly Uri BaseUri;

		public readonly HttpClient Client;

		public string? Token;

		private readonly Func<string> _getTicket;

		public ApiContext(HttpClient client, Func<string> getTicket, Uri? baseUri = null)
		{
			Client = client;
			_getTicket = getTicket;
			if (baseUri != null && !baseUri.AbsoluteUri.EndsWith("/"))
			{
				baseUri = new Uri(baseUri.OriginalString + "/");
			}
			BaseUri = ((baseUri == null) ? new Uri("https://delivery.wafflethings.dev/api/") : baseUri);
		}

		public async Task Login()
		{
			Token = await this.GetToken(_getTicket());
		}

		public async Task AddAuth(HttpRequestMessage request)
		{
			try
			{
				if (Token == null)
				{
					throw new PermissionException("You must be logged in.");
				}
				request.Headers.Add("DeliveryToken", Token);
			}
			catch (InternalServerException ex)
			{
				await Task.FromException(ex);
			}
		}
	}
}
namespace EndlessDelivery.Api.Requests
{
	public static class Api
	{
		private const string PingEndpoint = "ping";

		private const string UpdateRequiredEndpoint = "update_required";

		public static async Task<bool> ServerOnline(this ApiContext context)
		{
			return (await context.Client.GetAsync(context.BaseUri?.ToString() + "ping")).IsSuccessStatusCode;
		}

		public static async Task<bool> UpdateRequired(this ApiContext context)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + $"update_required")).Content.ReadAsStringAsync();
			if (!bool.TryParse(content, out var result))
			{
				throw new BadResponseException(content);
			}
			return result;
		}
	}
	public static class Authentication
	{
		private const string LoginEndpoint = "auth/steam/login";

		public static async Task<string> GetToken(this ApiContext context, string ticket)
		{
			HttpResponseMessage response = await context.Client.PostAsync(context.BaseUri?.ToString() + "auth/steam/login", new StringContent(ticket));
			if (!response.IsSuccessStatusCode)
			{
				throw new InternalServerException();
			}
			return await response.Content.ReadAsStringAsync();
		}
	}
	public static class Content
	{
		private const string CmsRoot = "cms/";

		private const string UpdateRequiredEndpoint = "update_required?hash={0}";

		private const string DownloadCmsEndpoint = "content";

		public static async Task<bool> ContentUpdateRequired(this ApiContext context, string hash)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "cms/" + $"update_required?hash={hash}");
			if (response.IsSuccessStatusCode)
			{
				return false;
			}
			if (response.StatusCode != HttpStatusCode.UpgradeRequired)
			{
				throw new BadResponseException("CMS download error " + response.StatusCode);
			}
			return true;
		}

		public static async Task<Cms> DownloadCms(this ApiContext context)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + "cms/content")).Content.ReadAsStringAsync();
			return JsonConvert.DeserializeObject<Cms>(content) ?? throw new BadResponseException(content);
		}
	}
	public static class Items
	{
		private const string ItemsRoot = "users/items/";

		private const string BuyItemEndpoint = "buy_item";

		private const string ActiveShopEndpoint = "active_shop";

		private const string GetLoadoutEndpoint = "get_loadout?steamId={0}";

		private const string SetLoadoutEndpoint = "set_loadout";

		private const string GetInventoryEndpoint = "get_inventory?steamId={0}";

		private const string ClaimDailyRewardEndpoint = "claim_daily_reward";

		private const string GetClaimedRewardsEndpoint = "get_claimed_rewards";

		public static async Task BuyItem(this ApiContext context, string itemId)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, context.BaseUri?.ToString() + "users/items/buy_item");
			await context.AddAuth(request);
			request.Content = new StringContent(itemId);
			HttpResponseMessage response = await context.Client.SendAsync(request);
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
		}

		public static async Task<ShopRotation> GetActiveShop(this ApiContext context)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + "users/items/active_shop")).Content.ReadAsStringAsync();
			return JsonConvert.DeserializeObject<ShopRotation>(content) ?? throw new BadResponseException(content);
		}

		public static async Task<CosmeticLoadout> GetLoadout(this ApiContext context, ulong steamId)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + "users/items/" + $"get_loadout?steamId={steamId}")).Content.ReadAsStringAsync();
			CosmeticLoadout deserialized = JsonConvert.DeserializeObject<CosmeticLoadout>(content);
			return deserialized ?? throw new BadResponseException(content);
		}

		public static async Task SetLoadout(this ApiContext context, CosmeticLoadout loadout)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, context.BaseUri?.ToString() + "users/items/set_loadout");
			await context.AddAuth(request);
			request.Content = new StringContent(JsonConvert.SerializeObject((object)loadout));
			HttpResponseMessage response = await context.Client.SendAsync(request);
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
		}

		public static async Task<List<string>> GetInventory(this ApiContext context, ulong steamId)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "users/items/" + $"get_inventory?steamId={steamId}");
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
			if (response.StatusCode == HttpStatusCode.InternalServerError)
			{
				throw new InternalServerException();
			}
			string content = await response.Content.ReadAsStringAsync();
			List<string> deserialized = JsonConvert.DeserializeObject<List<string>>(content);
			if (deserialized == null)
			{
				throw new BadResponseException(content);
			}
			return deserialized;
		}

		public static async Task ClaimDailyReward(this ApiContext context)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, context.BaseUri?.ToString() + "users/items/claim_daily_reward");
			await context.AddAuth(request);
			HttpResponseMessage response = await context.Client.SendAsync(request);
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
		}

		public static async Task<List<string>> GetClaimedDailyRewards(this ApiContext context)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, context.BaseUri?.ToString() + "users/items/get_claimed_rewards");
			await context.AddAuth(request);
			HttpResponseMessage response = await context.Client.SendAsync(request);
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
			string content = await response.Content.ReadAsStringAsync();
			List<string> deserialized = JsonConvert.DeserializeObject<List<string>>(content);
			if (deserialized == null)
			{
				throw new BadResponseException(content);
			}
			return deserialized;
		}
	}
	public static class Scores
	{
		private const string ScoreRoot = "scores/";

		private const string GetRangeEndpoint = "get_range?start={0}&count={1}";

		private const string GetPositionEndpoint = "get_position?steamId={0}";

		private const string GetScoreEndpoint = "get_score?steamId={0}";

		private const string GetLengthEndpoint = "get_length";

		private const string SubmitScoreEndpoint = "submit_score";

		public static async Task<OnlineScore[]> GetScoreRange(this ApiContext context, int startIndex, int amount)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + "scores/" + $"get_range?start={startIndex}&count={amount}")).Content.ReadAsStringAsync();
			return JsonConvert.DeserializeObject<OnlineScore[]>(content) ?? throw new BadResponseException(content);
		}

		public static async Task<int> GetLeaderboardPosition(this ApiContext context, ulong userId)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + "scores/" + $"get_position?steamId={userId}")).Content.ReadAsStringAsync();
			if (!int.TryParse(content, out var pos))
			{
				throw new BadResponseException(content);
			}
			return pos;
		}

		public static async Task<OnlineScore> GetLeaderboardScore(this ApiContext context, ulong userId)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "scores/" + $"get_score?steamId={userId}");
			if (response.StatusCode == HttpStatusCode.NotFound)
			{
				throw new NotFoundException(await response.Content.ReadAsStringAsync());
			}
			string content = await response.Content.ReadAsStringAsync();
			OnlineScore deserialized = JsonConvert.DeserializeObject<OnlineScore>(content);
			return deserialized ?? throw new BadResponseException(content);
		}

		public static async Task<int> GetLeaderboardLength(this ApiContext context)
		{
			string content = await (await context.Client.GetAsync(context.BaseUri?.ToString() + "scores/get_length")).Content.ReadAsStringAsync();
			if (!int.TryParse(content, out var length))
			{
				throw new BadResponseException(content);
			}
			return length;
		}

		public static async Task<OnlineScore> SubmitScore(this ApiContext context, SubmitScoreData scoreData)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, context.BaseUri?.ToString() + "scores/submit_score");
			await context.AddAuth(request);
			request.Content = new StringContent(JsonConvert.SerializeObject((object)scoreData));
			string content = await (await context.Client.SendAsync(request)).Content.ReadAsStringAsync();
			OnlineScore score = JsonConvert.DeserializeObject<OnlineScore>(content);
			return score ?? throw new BadResponseException(content);
		}
	}
	public static class Users
	{
		private const string UsersRoot = "users/";

		private const string GetCurrencyAmountEndpoint = "get_currency_amount";

		private const string GetAchievementsEndpoint = "get_achievements?steamId={0}";

		private const string GrantAchievementEndpoint = "grant_achievement";

		private const string GetUsernameEndpoint = "get_username?steamId={0}";

		private const string LifetimeStatsEndpoint = "lifetime_stats?steamId={0}";

		private const string GetBestScoreEndpoint = "get_best_score?steamId={0}";

		public static async Task<int> GetCurrencyAmount(this ApiContext context)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, context.BaseUri?.ToString() + "users/get_currency_amount");
			await context.AddAuth(request);
			HttpResponseMessage response = await context.Client.SendAsync(request);
			if (response.StatusCode == HttpStatusCode.InternalServerError)
			{
				throw new InternalServerException();
			}
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
			string content = await response.Content.ReadAsStringAsync();
			if (!int.TryParse(content, out var amount))
			{
				throw new BadResponseException(content);
			}
			return amount;
		}

		public static async Task<List<OwnedAchievement>> GetAchievements(this ApiContext context, ulong userId)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "users/" + $"get_achievements?steamId={userId}");
			if (response.StatusCode == HttpStatusCode.NotFound)
			{
				throw new BadRequestException($"the user with ID {userId} was not found");
			}
			if (response.StatusCode == HttpStatusCode.InternalServerError)
			{
				throw new InternalServerException();
			}
			string content = await response.Content.ReadAsStringAsync();
			List<OwnedAchievement> list = JsonConvert.DeserializeObject<List<OwnedAchievement>>(content);
			return list ?? throw new BadResponseException(content);
		}

		public static async Task<string> GetUsername(this ApiContext context, ulong userId)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "users/" + $"get_username?steamId={userId}");
			if (response.StatusCode == HttpStatusCode.NotFound)
			{
				throw new BadRequestException($"the user with ID {userId} was not found");
			}
			return await response.Content.ReadAsStringAsync();
		}

		public static async Task GrantAchievement(this ApiContext context, string achievementId)
		{
			HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, context.BaseUri?.ToString() + "users/grant_achievement");
			await context.AddAuth(request);
			request.Content = new StringContent(achievementId);
			HttpResponseMessage response = await context.Client.SendAsync(request);
			if (response.StatusCode == HttpStatusCode.InternalServerError)
			{
				throw new InternalServerException();
			}
			if (response.StatusCode == HttpStatusCode.BadRequest)
			{
				throw new BadRequestException(await response.Content.ReadAsStringAsync());
			}
		}

		public static async Task<Score> GetLifetimeStats(this ApiContext context, ulong userId)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "users/" + $"lifetime_stats?steamId={userId}");
			if (response.StatusCode == HttpStatusCode.NotFound)
			{
				throw new BadRequestException($"the user with ID {userId} was not found");
			}
			if (response.StatusCode == HttpStatusCode.InternalServerError)
			{
				throw new InternalServerException();
			}
			string content = await response.Content.ReadAsStringAsync();
			Score deserialized = JsonConvert.DeserializeObject<Score>(content);
			return deserialized ?? throw new BadResponseException(content);
		}

		public static async Task<OnlineScore> GetBestScore(this ApiContext context, ulong userId)
		{
			HttpResponseMessage response = await context.Client.GetAsync(context.BaseUri?.ToString() + "users/" + $"get_best_score?steamId={userId}");
			if (response.StatusCode == HttpStatusCode.NotFound)
			{
				throw new BadRequestException($"the user with ID {userId} was not found");
			}
			if (response.StatusCode == HttpStatusCode.InternalServerError)
			{
				throw new InternalServerException();
			}
			string content = await response.Content.ReadAsStringAsync();
			OnlineScore deserialized = JsonConvert.DeserializeObject<OnlineScore>(content);
			return deserialized ?? throw new BadResponseException(content);
		}
	}
}
namespace EndlessDelivery.Api.Exceptions
{
	public class BadResponseException : Exception
	{
		public BadResponseException(string response)
			: base("Failed to parse response. Library may be out of date or server offline (\"" + response + "\").")
		{
		}
	}
	public class InternalServerException : Exception
	{
		public InternalServerException()
			: base("Internal server error.")
		{
		}
	}
	public class NotFoundException : Exception
	{
		public NotFoundException(string serverReason)
			: base("Not found - " + serverReason)
		{
		}
	}
	public class PermissionException : Exception
	{
		public PermissionException(string requirement = "")
			: base("The current user has insufficient permissions to perform this action. " + requirement)
		{
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using EndlessDelivery.Common.Communication.Scores;
using EndlessDelivery.Common.Inventory.Items;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("EndlessDelivery.Common")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+b5dc0c560e2a25aa15f1eef619719550a062d078")]
[assembly: AssemblyProduct("EndlessDelivery.Common")]
[assembly: AssemblyTitle("EndlessDelivery.Common")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EndlessDelivery.Common
{
	public class Achievement
	{
		public string Name;

		public string Id;

		public string Description;

		public ClientWebPair Icon;

		public string[] ItemGrants;

		public bool HideDetails;

		public bool Serverside;

		public bool Disabled = false;
	}
	public static class DdUtils
	{
		public static string IntToDifficulty(int diff)
		{
			if (1 == 0)
			{
			}
			string result = diff switch
			{
				0 => "HARMLESS", 
				1 => "LENIENT", 
				2 => "STANDARD", 
				3 => "VIOLENT", 
				4 => "BRUTAL", 
				5 => "UKMD", 
				_ => throw new Exception("Invalid difficulty."), 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public static string ToWordString(this TimeSpan timeSpan)
		{
			string text = string.Format("{0} minute{1}", timeSpan.Minutes, (timeSpan.Minutes == 1) ? string.Empty : "s");
			if (timeSpan.Hours > 0)
			{
				text = string.Format("{0} hour{1}, ", timeSpan.Hours, (timeSpan.Hours == 1) ? string.Empty : "s") + text;
			}
			if (timeSpan.Days > 0)
			{
				text = string.Format("{0} day{1}, ", timeSpan.Days, (timeSpan.Days == 1) ? string.Empty : "s") + text;
			}
			return text;
		}
	}
	public class OwnedAchievement
	{
		public DateTime Achieved;

		public string Id;

		public OwnedAchievement(DateTime achieved, string id)
		{
			Achieved = achieved;
			Id = id;
		}

		public OwnedAchievement()
		{
		}
	}
	public class Score
	{
		public readonly int Rooms;

		public readonly int Kills;

		public readonly int Deliveries;

		public readonly float Time;

		public readonly int StartRoom;

		[JsonIgnore]
		public int MoneyGain => Deliveries / 4 * 10 + Kills / 5;

		private static bool IsLargerThanOtherScore(Score score, Score other)
		{
			if (score.Rooms != other.Rooms)
			{
				if (score.Rooms > other.Rooms)
				{
					return true;
				}
				return false;
			}
			if (score.Deliveries != other.Deliveries)
			{
				if (score.Deliveries > other.Deliveries)
				{
					return true;
				}
				return false;
			}
			if (score.Kills != other.Kills)
			{
				if (score.Kills > other.Kills)
				{
					return true;
				}
				return false;
			}
			if (score.Time != other.Time)
			{
				if (score.Time < other.Time)
				{
					return true;
				}
				return false;
			}
			return false;
		}

		public Score(int rooms, int kills, int deliveries, float time, int startRoom = 0)
		{
			Rooms = rooms;
			Kills = kills;
			Deliveries = deliveries;
			Time = time;
			StartRoom = startRoom;
		}

		public static Score operator +(Score a, Score b)
		{
			return new Score(a.Rooms + b.Rooms, a.Kills + b.Kills, a.Deliveries + b.Deliveries, a.Time + b.Time);
		}

		public static Score operator -(Score a, Score b)
		{
			return new Score(a.Rooms - b.Rooms, a.Kills - b.Kills, a.Deliveries - b.Deliveries, a.Time - b.Time);
		}

		public static bool operator >(Score a, Score b)
		{
			return IsLargerThanOtherScore(a, b);
		}

		public static bool operator <(Score a, Score b)
		{
			return IsLargerThanOtherScore(b, a);
		}

		public override string ToString()
		{
			return $"[Score {Rooms} {Kills} {Deliveries} {Time}]";
		}
	}
}
namespace EndlessDelivery.Common.Inventory.Items
{
	public class Banner : Item
	{
		public ClientWebPair Asset;

		public Banner(ClientWebPair asset, ItemDescriptor descriptor)
			: base(descriptor)
		{
			Asset = asset;
		}

		public Banner()
		{
		}
	}
	[Serializable]
	public class ClientWebPair
	{
		public string AssetUri;

		public string AddressablePath;
	}
	public class CosmeticLoadout
	{
		public static readonly List<string> DefaultItems = new List<string>(10) { "revolver_default", "altrevolver_default", "shotgun_default", "altshotgun_default", "nailgun_default", "altnailgun_default", "railcannon_default", "rocket_default", "banner_default", "present_default" };

		public string BannerId;

		public string PresentId;

		public List<string> RevolverIds = new List<string>();

		public List<string> AltRevolverIds = new List<string>();

		public List<string> ShotgunIds = new List<string>();

		public List<string> AltShotgunIds = new List<string>();

		public List<string> NailgunIds = new List<string>();

		public List<string> AltNailgunIds = new List<string>();

		public List<string> RailcannonIds = new List<string>();

		public List<string> RocketIds = new List<string>();

		public static CosmeticLoadout Default => new CosmeticLoadout
		{
			BannerId = "banner_default",
			PresentId = "present_default",
			RevolverIds = new List<string>(3) { "revolver_default", "revolver_default", "revolver_default" },
			AltRevolverIds = new List<string>(3) { "altrevolver_default", "altrevolver_default", "altrevolver_default" },
			ShotgunIds = new List<string>(3) { "shotgun_default", "shotgun_default", "shotgun_default" },
			AltShotgunIds = new List<string>(3) { "altshotgun_default", "altshotgun_default", "altshotgun_default" },
			NailgunIds = new List<string>(3) { "nailgun_default", "nailgun_default", "nailgun_default" },
			AltNailgunIds = new List<string>(3) { "altnailgun_default", "altnailgun_default", "altnailgun_default" },
			RailcannonIds = new List<string>(3) { "railcannon_default", "railcannon_default", "railcannon_default" },
			RocketIds = new List<string>(3) { "rocket_default", "rocket_default", "rocket_default" }
		};
	}
	public abstract class Item
	{
		public ItemDescriptor Descriptor;

		public Item(ItemDescriptor descriptor)
		{
			Descriptor = descriptor;
		}

		protected Item()
		{
		}
	}
	public class ItemDescriptor
	{
		public StoreItemType Type;

		public string Id;

		public string Name;

		public int ShopPrice;

		public ClientWebPair Icon;

		public ItemDescriptor(string id, string name, ClientWebPair icon, StoreItemType type, int shopPrice = 0)
		{
			Id = id;
			Name = name;
			Icon = icon;
			Type = type;
			ShopPrice = shopPrice;
		}

		public ItemDescriptor()
		{
		}
	}
	public enum StoreItemType
	{
		Banner,
		Revolver,
		Shotgun,
		Nailgun,
		Rail,
		Rocket,
		Present,
		AltRevolver,
		AltShotgun,
		AltNailgun
	}
	public class WeaponSkinItem : Item
	{
	}
	public enum GunType
	{
		Revolver,
		AltRevolver,
		Shotgun,
		AltShotgun,
		Nailgun,
		AltNailgun,
		Railcannon,
		RocketLauncher
	}
}
namespace EndlessDelivery.Common.ContentFile
{
	public class CalendarReward
	{
		public bool IsLastDay;

		public DateTime Date;

		public string Name;

		public string Description;

		public string Subtitle;

		public ClientWebPair Icon;

		public string Id;

		public bool HasItem;

		public string ItemId;

		public bool HasCurrency;

		public int CurrencyAmount;
	}
	public class Cms
	{
		public List<DatedRoomPool> RoomPools = new List<DatedRoomPool>();

		public Dictionary<string, CalendarReward> CalendarRewards = new Dictionary<string, CalendarReward>();

		public Dictionary<string, Achievement> Achievements = new Dictionary<string, Achievement>();

		public Dictionary<string, Banner> Banners = new Dictionary<string, Banner>();

		public Dictionary<string, WeaponSkinItem> Revolvers = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> AltRevolvers = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> Shotguns = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> AltShotguns = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> Nailguns = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> AltNailguns = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> Railcannons = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> Rockets = new Dictionary<string, WeaponSkinItem>();

		public Dictionary<string, WeaponSkinItem> Presents = new Dictionary<string, WeaponSkinItem>();

		public List<ShopRotation> ShopRotations = new List<ShopRotation>();

		public Dictionary<string, string> Strings = new Dictionary<string, string>();

		public Dictionary<string, string> BannedMods = new Dictionary<string, string>();

		[JsonIgnore]
		public string Hash
		{
			get
			{
				using MD5 mD = MD5.Create();
				string s = JsonConvert.SerializeObject((object)this, (Formatting)0);
				byte[] bytes = Encoding.UTF8.GetBytes(s);
				byte[] array = mD.ComputeHash(bytes);
				return BitConverter.ToString(array).Replace("-", "").ToLowerInvariant();
			}
		}

		[JsonIgnore]
		public CalendarReward CurrentCalendarReward => CalendarRewards.FirstOrDefault((KeyValuePair<string, CalendarReward> x) => x.Value.Date == DateTime.UtcNow.Date).Value;

		[JsonIgnore]
		public ShopRotation ActiveShopRotation
		{
			get
			{
				foreach (ShopRotation shopRotation in ShopRotations)
				{
					if (shopRotation.Start > DateTime.UtcNow || shopRotation.Start + shopRotation.Length < DateTime.UtcNow)
					{
						continue;
					}
					return shopRotation;
				}
				return null;
			}
		}

		[JsonIgnore]
		public DatedRoomPool? CurrentRoomPool
		{
			get
			{
				DatedRoomPool datedRoomPool = null;
				foreach (DatedRoomPool roomPool in RoomPools)
				{
					if (datedRoomPool == null || (roomPool.After > datedRoomPool.After && roomPool.After <= DateTime.UtcNow))
					{
						datedRoomPool = roomPool;
					}
				}
				return datedRoomPool;
			}
		}

		public string GetString(string id)
		{
			return Strings.ContainsKey(id) ? Strings[id] : id;
		}

		public bool TryGetItem(string id, out Item item)
		{
			if (Banners.TryGetValue(id, out var value))
			{
				item = value;
				return true;
			}
			Dictionary<string, WeaponSkinItem>[] array = new Dictionary<string, WeaponSkinItem>[9] { Revolvers, AltRevolvers, Shotguns, AltShotguns, Nailguns, AltNailguns, Railcannons, Rockets, Presents };
			Dictionary<string, WeaponSkinItem>[] array2 = array;
			foreach (Dictionary<string, WeaponSkinItem> dictionary in array2)
			{
				if (dictionary.TryGetValue(id, out var value2))
				{
					item = value2;
					return true;
				}
			}
			item = null;
			return false;
		}
	}
	public class DatedRoomPool
	{
		public DateTime After;

		public string AssetPath;
	}
	public class ShopRotation
	{
		public List<string> ItemIds;

		public DateTime Start;

		public TimeSpan Length;

		[JsonIgnore]
		public DateTime End => Start + Length;
	}
}
namespace EndlessDelivery.Common.Communication.Scores
{
	public class OnlineScore
	{
		public ulong SteamId { get; set; }

		public Score Score { get; set; }

		public int Index { get; set; }

		public int CountryIndex { get; set; }

		public short Difficulty { get; set; }

		public DateTime Date { get; set; }
	}
	public class SubmitScoreData
	{
		public Score Score;

		public short Difficulty;

		public SubmitScoreData(Score score, short difficulty)
		{
			Score = score;
			Difficulty = difficulty;
		}
	}
}
namespace EndlessDelivery.Common.Achievements
{
	public class BestRoomAchievement : ServerSideAchievement
	{
		private string _id;

		private int _room;

		public override string Id => _id;

		public override bool ShouldGrant(OnlineScore score, OnlineScore bestScore, Score lifetimeStats)
		{
			return bestScore.Score.Rooms >= _room;
		}

		public BestRoomAchievement(string id, int room)
		{
			_id = id;
			_room = room;
		}
	}
	public class LifetimeRoomsAchievement : ServerSideAchievement
	{
		private string _id;

		private int _rooms;

		public override string Id => _id;

		public override bool ShouldGrant(OnlineScore score, OnlineScore bestScore, Score lifetimeStats)
		{
			return lifetimeStats.Rooms >= _rooms;
		}

		public LifetimeRoomsAchievement(string id, int rooms)
		{
			_id = id;
			_rooms = rooms;
		}
	}
	public class MoneyAchievement : ServerSideAchievement
	{
		private string _id;

		private float _money;

		public override string Id => _id;

		public override bool ShouldGrant(OnlineScore score, OnlineScore bestScore, Score lifetimeStats)
		{
			return (float)score.Score.MoneyGain > _money;
		}

		public MoneyAchievement(string id, int money)
		{
			_id = id;
			_money = money;
		}
	}
	public class PlaytimeAchievement : ServerSideAchievement
	{
		private string _id;

		private float _seconds;

		public override string Id => _id;

		public override bool ShouldGrant(OnlineScore score, OnlineScore bestScore, Score lifetimeStats)
		{
			return lifetimeStats.Time >= _seconds;
		}

		public PlaytimeAchievement(string id, TimeSpan time)
		{
			_id = id;
			_seconds = (float)time.TotalSeconds;
		}
	}
	public abstract class ServerSideAchievement
	{
		public static ServerSideAchievement[] AllAchievements = new ServerSideAchievement[10]
		{
			new BestRoomAchievement("first_place_ach", 60),
			new BestRoomAchievement("ach_top25", 45),
			new BestRoomAchievement("ach_top50", 30),
			new LifetimeRoomsAchievement("ach_100rooms", 100),
			new LifetimeRoomsAchievement("ach_500rooms", 500),
			new LifetimeRoomsAchievement("ach_1000rooms", 1000),
			new PlaytimeAchievement("ach_2hours", TimeSpan.FromHours(2.0)),
			new PlaytimeAchievement("ach_10hours", TimeSpan.FromHours(10.0)),
			new PlaytimeAchievement("ach_20hours", TimeSpan.FromHours(20.0)),
			new MoneyAchievement("ach_money1", 300)
		};

		public abstract string Id { get; }

		public abstract bool ShouldGrant(OnlineScore score, OnlineScore bestScore, Score lifetimeStats);
	}
}