using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BingoAPI.Conditions;
using BingoAPI.Conditions.Attributes;
using BingoAPI.Conditions.BuiltIn;
using BingoAPI.Conditions.Factories;
using BingoAPI.Conditions.Interfaces;
using BingoAPI.Events;
using BingoAPI.Goals;
using BingoAPI.Helpers;
using BingoAPI.Models;
using BingoAPI.Models.Settings;
using BingoAPI.Networking;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Silksong.BingoSync.Conditions;
using Silksong.BingoSync.Configurations;
using Silksong.BingoSync.Data;
using Silksong.BingoSync.Exceptions;
using Silksong.BingoSync.Extensions;
using Silksong.BingoSync.Helpers;
using Silksong.BingoSync.Networking;
using Silksong.BingoSync.Patches;
using Silksong.BingoSync.UI.Abstract;
using Silksong.BingoSync.UI.Components;
using Silksong.BingoSync.UI.Constants;
using Silksong.BingoSync.UI.Containers;
using Silksong.BingoSync.UI.Items;
using Silksong.BingoSync.UI.Menus;
using Silksong.ModMenu.Elements;
using Silksong.ModMenu.Plugin;
using Silksong.ModMenu.Screens;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[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("WarperSan")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Connects Silksong to BingoSync, letting you play bingo directly in-game")]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: AssemblyInformationalVersion("1.2.2+7a8cc8dd5a9fba0ece2a5b6d060ccb2c843417d9")]
[assembly: AssemblyProduct("Silksong.BingoSync")]
[assembly: AssemblyTitle("Silksong.BingoSync")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/WarperSan/Silksong.BingoSync")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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 System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class RequiresPreviewFeaturesAttribute : Attribute
	{
		public string? Message { get; }

		public string? Url { get; set; }

		public RequiresPreviewFeaturesAttribute()
		{
		}

		public RequiresPreviewFeaturesAttribute(string? message)
		{
			Message = message;
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.All, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CompilerFeatureRequiredAttribute : Attribute
	{
		public const string RefStructs = "RefStructs";

		public const string RequiredMembers = "RequiredMembers";

		public string FeatureName { get; }

		public bool IsOptional { get; set; }

		public CompilerFeatureRequiredAttribute(string featureName)
		{
			FeatureName = featureName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ParamCollectionAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class RequiredMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CompilerLoweringPreserveAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class RequiresLocationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class InterpolatedStringHandlerArgumentAttribute : Attribute
	{
		public string[] Arguments { get; }

		public InterpolatedStringHandlerArgumentAttribute(string argument)
		{
			Arguments = new string[1] { argument };
		}

		public InterpolatedStringHandlerArgumentAttribute(params string[] arguments)
		{
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class SkipLocalsInitAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ModuleInitializerAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class OverloadResolutionPriorityAttribute : Attribute
	{
		public int Priority { get; }

		public OverloadResolutionPriorityAttribute(int priority)
		{
			Priority = priority;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CallerArgumentExpressionAttribute : Attribute
	{
		public string ParameterName { get; }

		public CallerArgumentExpressionAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class InterpolatedStringHandlerAttribute : Attribute
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal static class IsExternalInit
	{
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ExtensionMarkerAttribute : Attribute
	{
		public string Name { get; }

		public ExtensionMarkerAttribute(string name)
		{
			Name = name;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class CollectionBuilderAttribute : Attribute
	{
		public Type BuilderType { get; }

		public string MethodName { get; }

		public CollectionBuilderAttribute(Type builderType, string methodName)
		{
			BuilderType = builderType;
			MethodName = methodName;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class SetsRequiredMembersAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class UnscopedRefAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class StringSyntaxAttribute : Attribute
	{
		public const string CompositeFormat = "CompositeFormat";

		public const string DateOnlyFormat = "DateOnlyFormat";

		public const string DateTimeFormat = "DateTimeFormat";

		public const string EnumFormat = "EnumFormat";

		public const string GuidFormat = "GuidFormat";

		public const string Json = "Json";

		public const string NumericFormat = "NumericFormat";

		public const string Regex = "Regex";

		public const string TimeOnlyFormat = "TimeOnlyFormat";

		public const string TimeSpanFormat = "TimeSpanFormat";

		public const string Uri = "Uri";

		public const string Xml = "Xml";

		public string Syntax { get; }

		public object?[] Arguments { get; }

		public StringSyntaxAttribute(string syntax)
		{
			Syntax = syntax;
			Arguments = new object[0];
		}

		public StringSyntaxAttribute(string syntax, params object?[] arguments)
		{
			Syntax = syntax;
			Arguments = arguments;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ConstantExpectedAttribute : Attribute
	{
		public object? Min { get; set; }

		public object? Max { get; set; }
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface | AttributeTargets.Delegate, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[Embedded]
	internal sealed class ExperimentalAttribute : Attribute
	{
		public string DiagnosticId { get; }

		public string? UrlFormat { get; set; }

		public ExperimentalAttribute(string diagnosticId)
		{
			DiagnosticId = diagnosticId;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	[AttributeUsage(AttributeTargets.All)]
	[ExcludeFromCodeCoverage]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace Silksong.BingoSync
{
	internal class Controller : IDisposable
	{
		public delegate void CardCallback(Card? card);

		public GoalPool Pool = new GoalPool();

		public readonly EventDispatcher Events;

		private readonly Session _session;

		private readonly HttpClient _client;

		private Card? _card;

		private Task<Card?>? _runningCardUpdate;

		private readonly GoalTracker _tracker;

		public Team Team => _session.Team;

		public bool IsConnected => _session.IsInRoom;

		public event CardCallback? OnCardUpdated;

		public Controller()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			Events = new EventDispatcher();
			SubscribeToEvents(Events);
			_tracker = new GoalTracker();
			_tracker.OnGoalMarked += new GoalChangedCallback(OnGoalMarked);
			_tracker.OnGoalCleared += new GoalChangedCallback(OnGoalCleared);
			_client = new HttpClient(new LoggingHandler(new HttpClientHandler()))
			{
				Timeout = TimeSpan.FromSeconds(30.0),
				BaseAddress = new Uri("https://bingosync.com"),
				DefaultRequestHeaders = 
				{
					UserAgent = 
					{
						new ProductInfoHeaderValue("dev.warpersan.silksong.bingosync", Plugin.Version)
					}
				}
			};
			_session = new Session(Events, _client, new Uri("wss://sockets.bingosync.com"));
		}

		private void SubscribeToEvents(EventDispatcher events)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			events.OnSelfConnected += new ConnectionCallback(OnConnected);
			events.OnSelfSquareMarked += new MarkCallback(OnSquareMarked);
			events.OnOtherSquareMarked += new MarkCallback(OnSquareMarked);
			events.OnSelfSquareCleared += new ClearCallback(OnSquareCleared);
			events.OnOtherSquareCleared += new ClearCallback(OnSquareCleared);
			events.OnSelfCardGenerated += new GenerateCallback(OnCardGenerated);
			events.OnOtherCardGenerated += new GenerateCallback(OnCardGenerated);
		}

		private void UnsubscribeFromEvents(EventDispatcher events)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			events.OnSelfConnected -= new ConnectionCallback(OnConnected);
			events.OnSelfSquareMarked -= new MarkCallback(OnSquareMarked);
			events.OnOtherSquareMarked -= new MarkCallback(OnSquareMarked);
			events.OnSelfSquareCleared -= new ClearCallback(OnSquareCleared);
			events.OnOtherSquareCleared -= new ClearCallback(OnSquareCleared);
			events.OnSelfCardGenerated -= new GenerateCallback(OnCardGenerated);
			events.OnOtherCardGenerated -= new GenerateCallback(OnCardGenerated);
		}

		private void OnConnected(Player player)
		{
			UpdateCard();
		}

		private void OnGoalMarked(Goal goal)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (_card == null)
			{
				return;
			}
			int[] array = _card.FindByGoal(goal);
			int[] array2 = array;
			foreach (int num in array2)
			{
				if (!_card.IsMarkedBy(num, _session.Team))
				{
					_session.MarkSquare(num, default(CancellationToken));
				}
			}
		}

		private void OnGoalCleared(Goal goal)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (_card == null)
			{
				return;
			}
			int[] array = _card.FindByGoal(goal);
			int[] array2 = array;
			foreach (int num in array2)
			{
				if (_card.IsMarkedBy(num, _session.Team))
				{
					_session.ClearSquare(num, default(CancellationToken));
				}
			}
		}

		private void OnSquareMarked(Player player, Square square, Team team)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Card? card = _card;
			if (card != null)
			{
				card.Mark(square.Index, team);
			}
			this.OnCardUpdated?.Invoke(_card);
		}

		private void OnSquareCleared(Player player, Square square, Team team)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			Card? card = _card;
			if (card != null)
			{
				card.Unmark(square.Index, team);
			}
			this.OnCardUpdated?.Invoke(_card);
		}

		private void OnCardGenerated(Player player, bool isHidden)
		{
			UpdateCard();
		}

		public Task<bool> Join(JoinRoomSettings settings)
		{
			return _session.JoinRoom(settings, default(CancellationToken));
		}

		public Task<bool> Exit()
		{
			return _session.LeaveRoom(default(CancellationToken));
		}

		public Task<bool> SetTeam(Team team)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return _session.ChangeTeam(team, default(CancellationToken));
		}

		private void UpdateCard()
		{
			if (_runningCardUpdate != null && !_runningCardUpdate.IsCompleted)
			{
				Log.Warning("An update of 'Card' is already pending.");
				return;
			}
			_runningCardUpdate = Task.Run(() => _session.GetCard(Pool, default(CancellationToken)));
			_runningCardUpdate.ContinueWith(delegate(Task<Card?> task)
			{
				Card result = task.Result;
				_tracker.Clear();
				if (result != null)
				{
					Goal[] allGoals = result.GetAllGoals();
					foreach (Goal val in allGoals)
					{
						_tracker.TryAdd(val);
					}
				}
				_card = result;
				this.OnCardUpdated?.Invoke(_card);
			});
		}

		public void Evaluate()
		{
			_tracker.Evaluate();
		}

		public void Dispose()
		{
			UnsubscribeFromEvents(Events);
			_client.Dispose();
			_session.Dispose();
		}
	}
	internal static class ConfigMenu
	{
		public static AbstractMenuScreen Create(Configuration configuration)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			AbstractMenuScreen[] array = (AbstractMenuScreen[])(object)new AbstractMenuScreen[5]
			{
				CreateGeneralConfig(configuration.General),
				CreateJoinConfig(configuration.Join),
				CreateBoardConfig(configuration.Board),
				CreateAccessibilityConfig(configuration.Accessibility),
				CreateExperimentalConfig(configuration.Experimental)
			};
			PaginatedMenuScreenBuilder val = new PaginatedMenuScreenBuilder(LocalizedText.op_Implicit(Plugin.Name), 8);
			AbstractMenuScreen[] array2 = array;
			foreach (AbstractMenuScreen val2 in array2)
			{
				TextButton val3 = new TextButton(val2);
				val.Add((MenuElement)(object)val3);
			}
			return (AbstractMenuScreen)(object)val.Build();
		}

		private static AbstractMenuScreen CreateGeneralConfig(GeneralConfig config)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			PaginatedMenuScreenBuilder val = new PaginatedMenuScreenBuilder(LocalizedText.op_Implicit("General"), 8);
			MenuElement val2 = default(MenuElement);
			if (ConfigEntryFactory.GenerateBoolElement((ConfigEntryBase)(object)config.UseAdvancedTeams, ref val2))
			{
				val.Add(val2);
			}
			return (AbstractMenuScreen)(object)val.Build();
		}

		private static AbstractMenuScreen CreateJoinConfig(JoinConfig config)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			PaginatedMenuScreenBuilder val = new PaginatedMenuScreenBuilder(LocalizedText.op_Implicit("Join"), 8);
			MenuElement val2 = default(MenuElement);
			if (ConfigEntryFactory.GenerateStringElement((ConfigEntryBase)(object)config.Nickname, ref val2))
			{
				val.Add(val2);
			}
			MenuElement val3 = default(MenuElement);
			if (ConfigEntryFactory.GenerateStringElement((ConfigEntryBase)(object)config.Code, ref val3))
			{
				val.Add(val3);
			}
			MenuElement val4 = default(MenuElement);
			if (ConfigEntryFactory.GenerateStringElement((ConfigEntryBase)(object)config.Password, ref val4))
			{
				val.Add(val4);
			}
			MenuElement val5 = default(MenuElement);
			if (ConfigEntryFactory.GenerateKeyCodeElement((ConfigEntryBase)(object)config.ToggleUI, ref val5))
			{
				val.Add(val5);
			}
			return (AbstractMenuScreen)(object)val.Build();
		}

		private static AbstractMenuScreen CreateBoardConfig(BoardConfig config)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			PaginatedMenuScreenBuilder val = new PaginatedMenuScreenBuilder(LocalizedText.op_Implicit("Board"), 8);
			MenuElement val2 = default(MenuElement);
			if (ConfigEntryFactory.GenerateKeyCodeElement((ConfigEntryBase)(object)config.ToggleUI, ref val2))
			{
				val.Add(val2);
			}
			return (AbstractMenuScreen)(object)val.Build();
		}

		private static AbstractMenuScreen CreateExperimentalConfig(ExperimentalConfig config)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			PaginatedMenuScreenBuilder val = new PaginatedMenuScreenBuilder(LocalizedText.op_Implicit("Experimental"), 8);
			TextLabel val2 = new TextLabel(LocalizedText.op_Implicit("Theses settings are experimental and can cause performance issues"));
			((Graphic)val2.Text).color = Color.yellow;
			val2.Text.fontSize = 30;
			val.Add((MenuElement)(object)val2);
			MenuElement val3 = default(MenuElement);
			if (ConfigEntryFactory.GenerateBoolElement((ConfigEntryBase)(object)config.EvaluateOnHeroUpdate, ref val3))
			{
				val.Add(val3);
			}
			return (AbstractMenuScreen)(object)val.Build();
		}

		private static AbstractMenuScreen CreateAccessibilityConfig(AccessibilityConfig config)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			PaginatedMenuScreenBuilder val = new PaginatedMenuScreenBuilder(LocalizedText.op_Implicit("Accessibility"), 8);
			MenuElement val2 = default(MenuElement);
			if (ConfigEntryFactory.GenerateEnumChoiceElement((ConfigEntryBase)(object)config.BoardCellFont, ref val2))
			{
				val.Add(val2);
			}
			MenuElement val3 = default(MenuElement);
			if (ConfigEntryFactory.GenerateEnumChoiceElement((ConfigEntryBase)(object)config.BoardPosition, ref val3))
			{
				val.Add(val3);
			}
			MenuElement val4 = default(MenuElement);
			if (ConfigEntryFactory.GenerateEnumChoiceElement((ConfigEntryBase)(object)config.BoardScale, ref val4))
			{
				val.Add(val4);
			}
			MenuElement val5 = default(MenuElement);
			if (MenuElementGenerators.CreateIntSliderGenerator().Invoke((ConfigEntryBase)(object)config.BoardOpacity, ref val5))
			{
				val.Add(val5);
			}
			return (AbstractMenuScreen)(object)val.Build();
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("dev.warpersan.silksong.bingosync", "Silksong.BingoSync", "1.2.2")]
	public class Plugin : BaseUnityPlugin, IModMenuCustomMenu, IModMenuInterface
	{
		internal static readonly Controller Controller = new Controller();

		public const string Id = "dev.warpersan.silksong.bingosync";

		public static string Name => "Silksong.BingoSync";

		public static string Version => "1.2.2";

		public AbstractMenuScreen BuildCustomMenu()
		{
			return ConfigMenu.Create(Configuration.SafeInstance);
		}

		private void Awake()
		{
			Log.Logger = Log.LogCore;
			Configuration.Load(((BaseUnityPlugin)this).Config);
			Patch.ApplyAll();
			Log.Info("dev.warpersan.silksong.bingosync v" + Version + " has loaded!");
		}

		private void Start()
		{
			ConditionRegistry.RegisterAll();
		}
	}
}
namespace Silksong.BingoSync.UI.Menus
{
	internal class ConnectionMenu : MonoBehaviour
	{
		private enum State
		{
			Offline,
			Connecting,
			Online,
			Disconnecting
		}

		private State _state;

		private CanvasGroup? _canvasGroup;

		private Button? _actionButton;

		private JoinForm? _joinForm;

		private TeamPicker? _teamPicker;

		private void SetOnline()
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			_state = State.Online;
			_joinForm?.DisableInputs();
			if ((Object)(object)_teamPicker != (Object)null)
			{
				_teamPicker.EnableInputs();
				_teamPicker.SetTeam(Plugin.Controller.Team);
			}
		}

		private void SetOffline()
		{
			_state = State.Offline;
			_joinForm?.EnableInputs();
			if ((Object)(object)_teamPicker != (Object)null)
			{
				_teamPicker.DisableInputs();
				_teamPicker.SetTeam((Team)0);
			}
		}

		private void OnActionClicked()
		{
			State state = _state;
			if ((state == State.Connecting || state == State.Disconnecting) ? true : false)
			{
				Log.Warning($"State '{_state}' has no action assigned.");
			}
			else if (_state == State.Offline)
			{
				JoinRoom();
			}
			else if (_state == State.Online)
			{
				LeaveRoom();
			}
		}

		private void OnTeamSelected(Team team)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (_state != State.Online)
			{
				Log.Warning("Cannot change team without being online.");
			}
			else
			{
				ChangeTeam(team);
			}
		}

		private void ToggleVisibility()
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				bool flag = _canvasGroup.alpha > 0f;
				_canvasGroup.alpha = (flag ? 0f : 1f);
				_canvasGroup.blocksRaycasts = !flag;
			}
		}

		private void Update()
		{
			switch (_state)
			{
			case State.Offline:
				_actionButton?.SetText("Join");
				break;
			case State.Connecting:
				_actionButton?.SetText("Connecting...");
				break;
			case State.Online:
				_actionButton?.SetText("Leave");
				break;
			case State.Disconnecting:
				_actionButton?.SetText("Disconnecting...");
				break;
			default:
				throw new ArgumentOutOfRangeException();
			}
		}

		private async Task JoinRoom()
		{
			if (_state != State.Offline)
			{
				throw new InvalidOperationException();
			}
			if ((Object)(object)_joinForm == (Object)null)
			{
				throw new NullReferenceException("No 'JoinForm' assigned.");
			}
			_joinForm.DisableInputs();
			JoinRoomSettings settings = _joinForm.GetSettings();
			try
			{
				_state = State.Connecting;
				if (!(await Plugin.Controller.Join(settings)))
				{
					SetOffline();
					Log.Error("Failed to join the room '" + settings.Code + "'.");
				}
				else
				{
					SetOnline();
				}
			}
			catch (Exception arg)
			{
				SetOffline();
				Log.Error($"Error while joining the room '{settings.Code}': {arg}");
			}
		}

		private async Task LeaveRoom()
		{
			if (_state != State.Online)
			{
				throw new InvalidOperationException();
			}
			_teamPicker?.DisableInputs();
			try
			{
				_state = State.Disconnecting;
				if (!(await Plugin.Controller.Exit()))
				{
					SetOnline();
					Log.Error("Failed to exit the room.");
				}
				else
				{
					SetOffline();
				}
			}
			catch (Exception arg)
			{
				SetOnline();
				Log.Error($"Error while joining the room: {arg}");
			}
		}

		private async Task ChangeTeam(Team team)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (_state != State.Online)
			{
				throw new InvalidOperationException();
			}
			Controller controller = Plugin.Controller;
			if (controller == null)
			{
				throw new NullReferenceException("No 'Controller' assigned.");
			}
			if ((Object)(object)_teamPicker == (Object)null)
			{
				throw new NullReferenceException("No 'TeamPicker' assigned.");
			}
			_teamPicker.DisableInputs();
			try
			{
				if (!(await controller.SetTeam(team)))
				{
					Log.Error("Failed to change team.");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"Error while joining the room: {arg}");
			}
			_teamPicker.SetTeam(controller.Team);
			_teamPicker.EnableInputs();
		}

		public static ConnectionMenu Create(JoinRoomSettings settings)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ConnectionMenu");
			ConnectionMenu connectionMenu = val.AddComponent<ConnectionMenu>();
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			VerticalLayoutGroup val3 = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val3).spacing = 10f;
			((LayoutGroup)val3).childAlignment = (TextAnchor)7;
			((HorizontalOrVerticalLayoutGroup)val3).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val3).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val3).childForceExpandHeight = false;
			connectionMenu._canvasGroup = val.AddComponent<CanvasGroup>();
			JoinForm joinForm = JoinForm.Create();
			((Component)joinForm).transform.SetParent(((Component)val3).transform, false);
			joinForm.SetSettings(settings);
			connectionMenu._joinForm = joinForm;
			TeamPicker teamPicker = TeamPicker.Create(connectionMenu.OnTeamSelected);
			((Component)teamPicker).transform.SetParent(((Component)val3).transform, false);
			connectionMenu._teamPicker = teamPicker;
			Button button = Button.Create(connectionMenu.OnActionClicked);
			((Component)button).transform.SetParent(val.transform, false);
			connectionMenu._actionButton = button;
			CallOnInput callOnInput = val.AddComponent<CallOnInput>();
			callOnInput.SetInput(Configuration.SafeInstance.Join.ToggleUI, connectionMenu.ToggleVisibility);
			connectionMenu.SetOffline();
			return connectionMenu;
		}
	}
}
namespace Silksong.BingoSync.UI.Items
{
	internal class BingoCell : MonoBehaviour
	{
		private Text? _text;

		private Dictionary<Team, Image>? _teamMarks;

		public void SetSquare(Goal goal, Team teams)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			Text? text = _text;
			if (text != null)
			{
				text.text = goal.Name;
			}
			if (_teamMarks == null)
			{
				return;
			}
			foreach (KeyValuePair<Team, Image> teamMark in _teamMarks)
			{
				teamMark.Deconstruct(out var key, out var value);
				Team val = key;
				Image val2 = value;
				bool active = ((Enum)teams).HasFlag((Enum)(object)val);
				((Component)val2).gameObject.SetActive(active);
			}
		}

		public void AddTeam(Team team)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (_teamMarks != null && _teamMarks.TryGetValue(team, out Image value))
			{
				((Component)value).gameObject.SetActive(true);
			}
		}

		public void RemoveTeam(Team team)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (_teamMarks != null && _teamMarks.TryGetValue(team, out Image value))
			{
				((Component)value).gameObject.SetActive(false);
			}
		}

		public static BingoCell Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BingoCell");
			val.AddComponent<RectTransform>();
			BingoCell bingoCell = val.AddComponent<BingoCell>();
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(val.transform, false);
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.1f, 0.1f, 0.1f, 1f);
			VerticalLayoutGroup val4 = val2.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)val4).childAlignment = (TextAnchor)4;
			Dictionary<Team, Image> dictionary = new Dictionary<Team, Image>();
			foreach (Team value in Enum.GetValues(typeof(Team)))
			{
				if ((int)value != 0)
				{
					GameObject val6 = new GameObject(((object)value/*cast due to .constrained prefix*/).ToString());
					val6.transform.SetParent(((Component)val4).transform, false);
					Image val7 = val6.AddComponent<Image>();
					((Graphic)val7).color = Colors.GetColor(value);
					dictionary.Add(value, val7);
				}
			}
			GameObject val8 = new GameObject("Darkener");
			val8.transform.SetParent(val.transform, false);
			Image val9 = val8.AddComponent<Image>();
			((Graphic)val9).color = new Color(0f, 0f, 0f, 0.4f);
			GameObject val10 = new GameObject("Text");
			val10.transform.SetParent(val.transform, false);
			RectTransform val11 = val10.AddComponent<RectTransform>();
			val11.anchorMin = Vector2.zero;
			val11.anchorMax = Vector2.one;
			val11.offsetMin = Vector2.one * 5f;
			val11.offsetMax = -Vector2.one * 5f;
			Text val12 = val10.AddComponent<Text>();
			val12.fontSize = 12;
			val12.text = "Placeholder";
			val12.alignment = (TextAnchor)3;
			((Graphic)val12).color = Color.white;
			val12.font = Fonts.Normal;
			AccessibilityTextFont accessibilityTextFont = val10.AddComponent<AccessibilityTextFont>();
			accessibilityTextFont.Bind(Configuration.SafeInstance.Accessibility.BoardCellFont);
			bingoCell._text = val12;
			bingoCell._teamMarks = dictionary;
			return bingoCell;
		}
	}
	internal class TeamPickerButton : MonoBehaviour
	{
		private Outline? _outline;

		private Action<Team>? _onClick;

		private Color _teamColor = Color.white;

		public Team Team { get; private set; }

		public void Select()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_outline != (Object)null)
			{
				((Shadow)_outline).effectColor = Color.white;
			}
		}

		public void Unselect()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_outline != (Object)null)
			{
				((Shadow)_outline).effectColor = _teamColor;
			}
		}

		private void OnClick()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			_onClick?.Invoke(Team);
		}

		public static TeamPickerButton Create(Team team, Action<Team> onClick)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("TeamPickerButton");
			val.AddComponent<RectTransform>();
			TeamPickerButton teamPickerButton = val.AddComponent<TeamPickerButton>();
			teamPickerButton.Team = team;
			teamPickerButton._onClick = onClick;
			Color val2 = (teamPickerButton._teamColor = team.GetColor());
			Image val3 = val.AddComponent<Image>();
			Color color = val2 * 0.6f;
			color.a = 1f;
			((Graphic)val3).color = color;
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			((UnityEvent)val4.onClick).AddListener(new UnityAction(teamPickerButton.OnClick));
			ColorBlock colors = ((Selectable)val4).colors;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((Selectable)val4).colors = colors;
			teamPickerButton._outline = ((Component)val4).gameObject.AddComponent<Outline>();
			GameObject val5 = new GameObject("Text");
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			Text val7 = val5.AddComponent<Text>();
			val7.font = Fonts.Normal;
			val7.fontSize = 17;
			((Graphic)val7).color = Color.white;
			val7.alignment = (TextAnchor)4;
			val7.text = team.GetDisplayName();
			teamPickerButton.Unselect();
			return teamPickerButton;
		}
	}
}
namespace Silksong.BingoSync.UI.Containers
{
	public class BingoBoard : MonoBehaviour
	{
		private BingoCell[]? _cells;

		private void Awake()
		{
			Subscribe(Plugin.Controller);
		}

		private void DisplayCard(Card? card)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (card != null && _cells != null)
			{
				for (int i = 0; i < _cells.Length; i++)
				{
					Goal goalAt = card.GetGoalAt(i);
					Team teamsAt = card.GetTeamsAt(i);
					_cells[i].SetSquare(goalAt, teamsAt);
				}
			}
		}

		private void Subscribe(Controller controller)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			controller.OnCardUpdated += DisplayCard;
			EventDispatcher events = controller.Events;
			events.OnSelfSquareMarked += new MarkCallback(OnSquareMarked);
			events.OnOtherSquareMarked += new MarkCallback(OnSquareMarked);
			events.OnSelfSquareCleared += new ClearCallback(OnSquareCleared);
			events.OnOtherSquareCleared += new ClearCallback(OnSquareCleared);
		}

		private void OnSquareMarked(Player player, Square square, Team team)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			BingoCell[]? cells = _cells;
			if (cells != null)
			{
				cells[square.Index].AddTeam(team);
			}
		}

		private void OnSquareCleared(Player player, Square square, Team team)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			BingoCell[]? cells = _cells;
			if (cells != null)
			{
				cells[square.Index].RemoveTeam(team);
			}
		}

		public static BingoBoard Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BingoBoard");
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMax = Vector2.one;
			val2.anchorMin = Vector2.one;
			val2.pivot = Vector2.one;
			AccessibilityElementPosition accessibilityElementPosition = val.AddComponent<AccessibilityElementPosition>();
			accessibilityElementPosition.Bind(Configuration.SafeInstance.Accessibility.BoardPosition);
			AccessibilityElementScale accessibilityElementScale = val.AddComponent<AccessibilityElementScale>();
			accessibilityElementScale.Bind(Configuration.SafeInstance.Accessibility.BoardScale);
			ContentSizeFitter val3 = val.AddComponent<ContentSizeFitter>();
			val3.horizontalFit = (FitMode)2;
			val3.verticalFit = (FitMode)2;
			Image val4 = val.AddComponent<Image>();
			((Graphic)val4).color = Color.black;
			BingoBoard bingoBoard = val.AddComponent<BingoBoard>();
			GridLayoutGroup val5 = val.AddComponent<GridLayoutGroup>();
			val5.cellSize = Vector2.one * 100f;
			val5.constraint = (Constraint)1;
			val5.constraintCount = 5;
			((LayoutGroup)val5).childAlignment = (TextAnchor)0;
			val5.spacing = Vector2.one * 5f;
			BingoCell[] array = new BingoCell[25];
			for (int i = 0; i < array.Length; i++)
			{
				BingoCell bingoCell = BingoCell.Create();
				((Component)bingoCell).transform.SetParent(((Component)val5).transform, false);
				array[i] = bingoCell;
			}
			bingoBoard._cells = array;
			CanvasGroup val6 = val.AddComponent<CanvasGroup>();
			val6.blocksRaycasts = false;
			AccessibilityOpacity accessibilityOpacity = val.AddComponent<AccessibilityOpacity>();
			accessibilityOpacity.Bind(Configuration.SafeInstance.Accessibility.BoardOpacity);
			return bingoBoard;
		}
	}
	internal class BoardContainer : MonoBehaviour
	{
		private BingoBoard? _board;

		private CallOnInput? _toggleInput;

		private void Awake()
		{
			Subscribe(Plugin.Controller.Events);
		}

		private void ToggleVisibility()
		{
			if (!((Object)(object)_board == (Object)null))
			{
				bool activeInHierarchy = ((Component)_board).gameObject.activeInHierarchy;
				SetVisibility(!activeInHierarchy);
			}
		}

		private void SetVisibility(bool isVisible)
		{
			if (!((Object)(object)_board == (Object)null))
			{
				((Component)_board).gameObject.SetActive(isVisible);
			}
		}

		private void EnableVisibility()
		{
			if ((Object)(object)_toggleInput != (Object)null)
			{
				((Behaviour)_toggleInput).enabled = true;
			}
			SetVisibility(isVisible: true);
		}

		private void DisableVisibility()
		{
			if ((Object)(object)_toggleInput != (Object)null)
			{
				((Behaviour)_toggleInput).enabled = false;
			}
			SetVisibility(isVisible: false);
		}

		private void Subscribe(EventDispatcher dispatcher)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			dispatcher.OnSelfConnected += (ConnectionCallback)delegate
			{
				EnableVisibility();
			};
			dispatcher.OnSelfDisconnected += (DisconnectionCallback)delegate
			{
				DisableVisibility();
			};
		}

		public static BoardContainer Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("BoardContainer");
			BoardContainer boardContainer = val.AddComponent<BoardContainer>();
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.offsetMin = Vector2.zero;
			val2.offsetMax = Vector2.zero;
			CallOnInput callOnInput = val.AddComponent<CallOnInput>();
			callOnInput.SetInput(Configuration.SafeInstance.Board.ToggleUI, boardContainer.ToggleVisibility);
			boardContainer._toggleInput = callOnInput;
			BingoBoard bingoBoard = BingoBoard.Create();
			((Component)bingoBoard).transform.SetParent((Transform)(object)val2, false);
			boardContainer._board = bingoBoard;
			boardContainer.DisableVisibility();
			return boardContainer;
		}
	}
	internal class JoinForm : MonoBehaviour
	{
		private CanvasGroup? _canvasGroup;

		private TextField? _roomCodeInput;

		private TextField? _nicknameInput;

		private TextField? _passwordInput;

		public void SetSettings(JoinRoomSettings settings)
		{
			if ((Object)(object)_roomCodeInput != (Object)null)
			{
				_roomCodeInput.Text = settings.Code;
			}
			if ((Object)(object)_nicknameInput != (Object)null)
			{
				_nicknameInput.Text = settings.Nickname;
			}
			if ((Object)(object)_passwordInput != (Object)null)
			{
				_passwordInput.Text = settings.Password;
			}
		}

		public JoinRoomSettings GetSettings()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			JoinRoomSettings val = new JoinRoomSettings();
			if ((Object)(object)_roomCodeInput != (Object)null)
			{
				string text = _roomCodeInput.Text;
				string text2 = default(string);
				if (Network.TryGetRoomCode(text, ref text2))
				{
					text = text2;
				}
				val.Code = text;
			}
			if ((Object)(object)_nicknameInput != (Object)null)
			{
				val.Nickname = _nicknameInput.Text;
			}
			if ((Object)(object)_passwordInput != (Object)null)
			{
				val.Password = _passwordInput.Text;
			}
			return val;
		}

		public void EnableInputs()
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				_canvasGroup.interactable = true;
			}
		}

		public void DisableInputs()
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				_canvasGroup.interactable = false;
			}
		}

		public static JoinForm Create()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("JoinForm");
			JoinForm joinForm = val.AddComponent<JoinForm>();
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.pivot = new Vector2(0.5f, 0f);
			ContentSizeFitter val3 = val.AddComponent<ContentSizeFitter>();
			val3.verticalFit = (FitMode)2;
			VerticalLayoutGroup val4 = val.AddComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)val4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)val4).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)val4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)val4).spacing = 10f;
			joinForm._canvasGroup = val.AddComponent<CanvasGroup>();
			TextField textField = TextField.Create("Room Code / Link", (ContentType)0);
			((Component)textField).transform.SetParent(val.transform, false);
			joinForm._roomCodeInput = textField;
			TextField textField2 = TextField.Create("Nickname", (ContentType)0);
			((Component)textField2).transform.SetParent(val.transform, false);
			joinForm._nicknameInput = textField2;
			TextField textField3 = TextField.Create("Password", (ContentType)7);
			((Component)textField3).transform.SetParent(val.transform, false);
			joinForm._passwordInput = textField3;
			return joinForm;
		}
	}
	internal class TeamPicker : MonoBehaviour
	{
		private CanvasGroup? _canvasGroup;

		private Dictionary<Team, TeamPickerButton>? _buttons;

		private Action<Team>? _onTeamSelected;

		private Team _team;

		public void SetTeam(Team team)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (TryGetButton(_team, out TeamPickerButton button))
			{
				button.Unselect();
			}
			if (TryGetButton(team, out TeamPickerButton button2))
			{
				button2.Select();
			}
			_team = team;
		}

		public void EnableInputs()
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				_canvasGroup.interactable = true;
			}
		}

		public void DisableInputs()
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				_canvasGroup.interactable = false;
			}
		}

		private bool TryGetButton(Team team, [NotNullWhen(true)] out TeamPickerButton? button)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (_buttons == null)
			{
				button = null;
				return false;
			}
			return _buttons.TryGetValue(team, out button);
		}

		private void OnTeamSelected(Team team)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			_onTeamSelected?.Invoke(team);
		}

		public static TeamPicker Create(Action<Team> onTeamSelected)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("TeamPicker");
			TeamPicker teamPicker = val.AddComponent<TeamPicker>();
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.pivot = new Vector2(0.5f, 0f);
			GridLayoutGroup val3 = val.AddComponent<GridLayoutGroup>();
			((LayoutGroup)val3).childAlignment = (TextAnchor)4;
			val3.cellSize = new Vector2(125f, 50f);
			val3.spacing = Vector2.one * 10f;
			ContentSizeFitter val4 = val.AddComponent<ContentSizeFitter>();
			val4.verticalFit = (FitMode)2;
			teamPicker._canvasGroup = val.AddComponent<CanvasGroup>();
			Dictionary<Team, TeamPickerButton> dictionary = new Dictionary<Team, TeamPickerButton>();
			List<Team> list = new List<Team>(4)
			{
				(Team)2,
				(Team)128,
				(Team)32,
				(Team)16
			};
			if (Configuration.SafeInstance.General.UseAdvancedTeams.Value)
			{
				list.Add((Team)512);
				list.Add((Team)256);
				list.Add((Team)1);
				list.Add((Team)8);
			}
			foreach (Team item in list)
			{
				TeamPickerButton teamPickerButton = TeamPickerButton.Create(item, teamPicker.OnTeamSelected);
				((Component)teamPickerButton).transform.SetParent(val.transform, false);
				dictionary[item] = teamPickerButton;
			}
			teamPicker._buttons = dictionary;
			teamPicker._onTeamSelected = onTeamSelected;
			return teamPicker;
		}
	}
}
namespace Silksong.BingoSync.UI.Constants
{
	internal static class Colors
	{
		public static Color GetColor(this Team team)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Invalid comparison between Unknown and I4
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_010a: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Invalid comparison between Unknown and I4
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_0188: 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)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if ((int)team <= 32)
			{
				switch ((int)team)
				{
				default:
					if ((int)team != 16)
					{
						if ((int)team != 32)
						{
							break;
						}
						return new Color(0.22f, 0.75f, 0.47f);
					}
					return new Color(0.89f, 0.63f, 0f);
				case 4:
					return new Color(0.96f, 0.6f, 0.2f);
				case 2:
					return new Color(1f, 0.28f, 0.27f);
				case 8:
					return new Color(0.37f, 0.29f, 0.27f);
				case 1:
					return new Color(0.93f, 0.52f, 0.67f);
				case 0:
					return Color.black;
				case 3:
				case 5:
				case 6:
				case 7:
					break;
				}
			}
			else if ((int)team <= 128)
			{
				if ((int)team == 64)
				{
					return new Color(0.71f, 0.71f, 0.71f);
				}
				if ((int)team == 128)
				{
					return new Color(0f, 0.71f, 1f);
				}
			}
			else
			{
				if ((int)team == 256)
				{
					return new Color(0.16f, 0.33f, 0.53f);
				}
				if ((int)team == 512)
				{
					return new Color(0.51f, 0.17f, 0.75f);
				}
			}
			throw new ArgumentOutOfRangeException("team", team, null);
		}

		public static string GetDisplayName(this Team team)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected I4, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			if ((int)team <= 32)
			{
				switch ((int)team)
				{
				default:
					if ((int)team != 16)
					{
						if ((int)team != 32)
						{
							break;
						}
						return "Mossberry";
					}
					return "Flintgem";
				case 2:
					return "Rosary";
				case 4:
					return "Flintstone";
				case 1:
					return "Voltridian";
				case 8:
					return "Pilgrim";
				case 0:
					return "???";
				case 3:
				case 5:
				case 6:
				case 7:
					break;
				}
			}
			else if ((int)team <= 128)
			{
				if ((int)team == 64)
				{
					return "Growstone";
				}
				if ((int)team == 128)
				{
					return "Plasmium";
				}
			}
			else
			{
				if ((int)team == 256)
				{
					return "Magnetite";
				}
				if ((int)team == 512)
				{
					return "Pollip";
				}
			}
			throw new ArgumentOutOfRangeException("team", team, null);
		}
	}
	internal static class Fonts
	{
		private static readonly Dictionary<string, Font> CachedFonts = new Dictionary<string, Font>();

		public static Font? Normal => GetFont("TrajanPro-Regular");

		public static Font? Bold => GetFont("TrajanPro-Bold");

		public static Font? Arial => GetFont("ARIAL");

		public static Font? Default => Font.GetDefault();

		private static Font? GetFont(string name)
		{
			if (CachedFonts.TryGetValue(name, out Font value))
			{
				return value;
			}
			Font[] array = Resources.FindObjectsOfTypeAll<Font>();
			foreach (Font val in array)
			{
				CachedFonts[((Object)val).name] = val;
			}
			return CachedFonts.GetValueOrDefault(name);
		}
	}
}
namespace Silksong.BingoSync.UI.Components
{
	[RequireComponent(typeof(RectTransform))]
	internal class AccessibilityElementPosition : SettingUpdateNotifier<AccessibilityConfig.ElementPosition>
	{
		private RectTransform? _rectTransform;

		protected override void OnSettingChanged(AccessibilityConfig.ElementPosition value)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rectTransform == (Object)null))
			{
				switch (value)
				{
				case AccessibilityConfig.ElementPosition.TopLeft:
					_rectTransform.anchorMax = new Vector2(0f, 1f);
					_rectTransform.anchorMin = new Vector2(0f, 1f);
					_rectTransform.pivot = new Vector2(0f, 1f);
					break;
				case AccessibilityConfig.ElementPosition.TopRight:
					_rectTransform.anchorMax = Vector2.one;
					_rectTransform.anchorMin = Vector2.one;
					_rectTransform.pivot = Vector2.one;
					break;
				case AccessibilityConfig.ElementPosition.BottomLeft:
					_rectTransform.anchorMax = Vector2.zero;
					_rectTransform.anchorMin = Vector2.zero;
					_rectTransform.pivot = Vector2.zero;
					break;
				case AccessibilityConfig.ElementPosition.BottomRight:
					_rectTransform.anchorMax = new Vector2(1f, 0f);
					_rectTransform.anchorMin = new Vector2(1f, 0f);
					_rectTransform.pivot = new Vector2(1f, 0f);
					break;
				default:
					throw new ArgumentOutOfRangeException("value", value, null);
				}
			}
		}

		private void Awake()
		{
			_rectTransform = ((Component)this).GetComponent<RectTransform>();
		}
	}
	[RequireComponent(typeof(RectTransform))]
	internal class AccessibilityElementScale : SettingUpdateNotifier<AccessibilityConfig.ElementScale>
	{
		private RectTransform? _rectTransform;

		protected override void OnSettingChanged(AccessibilityConfig.ElementScale value)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: 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_0056: 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)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_rectTransform == (Object)null))
			{
				RectTransform rectTransform = _rectTransform;
				((Transform)rectTransform).localScale = Vector2.op_Implicit((Vector2)(value switch
				{
					AccessibilityConfig.ElementScale.VerySmall => Vector2.one * 0.5f, 
					AccessibilityConfig.ElementScale.Small => Vector2.one * 0.75f, 
					AccessibilityConfig.ElementScale.Normal => Vector2.one, 
					AccessibilityConfig.ElementScale.Large => Vector2.one * 1.25f, 
					AccessibilityConfig.ElementScale.VeryLarge => Vector2.one * 1.5f, 
					_ => throw new ArgumentOutOfRangeException("value", value, null), 
				}));
			}
		}

		private void Awake()
		{
			_rectTransform = ((Component)this).GetComponent<RectTransform>();
		}
	}
	[RequireComponent(typeof(CanvasGroup))]
	internal class AccessibilityOpacity : SettingUpdateNotifier<int>
	{
		private CanvasGroup? _canvasGroup;

		protected override void OnSettingChanged(int value)
		{
			if (!((Object)(object)_canvasGroup == (Object)null))
			{
				_canvasGroup.alpha = Mathf.Clamp((float)value / 100f, 0f, 1f);
			}
		}

		private void Awake()
		{
			_canvasGroup = ((Component)this).GetComponent<CanvasGroup>();
		}
	}
	[RequireComponent(typeof(Text))]
	internal class AccessibilityTextFont : SettingUpdateNotifier<AccessibilityConfig.TextFont>
	{
		private Text? _text;

		protected override void OnSettingChanged(AccessibilityConfig.TextFont value)
		{
			if (!((Object)(object)_text == (Object)null))
			{
				Text text = _text;
				text.font = (Font)(value switch
				{
					AccessibilityConfig.TextFont.Normal => Fonts.Normal, 
					AccessibilityConfig.TextFont.Bold => Fonts.Bold, 
					AccessibilityConfig.TextFont.Arial => Fonts.Arial, 
					AccessibilityConfig.TextFont.Default => Fonts.Default, 
					_ => throw new ArgumentOutOfRangeException("value", value, null), 
				});
			}
		}

		private void Awake()
		{
			_text = ((Component)this).GetComponent<Text>();
		}
	}
	internal class Button : MonoBehaviour
	{
		private Action? _onClick;

		private Text? _label;

		public void SetText(string text)
		{
			Text? label = _label;
			if (label != null)
			{
				label.text = text;
			}
		}

		private void OnClick()
		{
			_onClick?.Invoke();
		}

		public static Button Create(Action onClick)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			GameObject val = new GameObject("Button");
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = Vector2.zero;
			val2.anchorMax = Vector2.one;
			val2.sizeDelta = new Vector2(300f, 50f);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0f, 0f, 0f, 0.6f);
			Button val4 = val.AddComponent<Button>();
			((Selectable)val4).targetGraphic = (Graphic)(object)val3;
			GameObject val5 = new GameObject("Text");
			val5.transform.SetParent(val.transform, false);
			RectTransform val6 = val5.AddComponent<RectTransform>();
			val6.anchorMin = Vector2.zero;
			val6.anchorMax = Vector2.one;
			val6.offsetMin = Vector2.zero;
			val6.offsetMax = Vector2.zero;
			Text val7 = val5.AddComponent<Text>();
			val7.font = Fonts.Normal;
			val7.fontSize = 18;
			((Graphic)val7).color = Color.white;
			val7.alignment = (TextAnchor)4;
			Button button = val.AddComponent<Button>();
			button._onClick = onClick;
			button._label = val7;
			((UnityEvent)val4.onClick).AddListener(new UnityAction(button.OnClick));
			return button;
		}
	}
	internal class CallOnInput : MonoBehaviour
	{
		private Func<KeyCode>? _key;

		private Action? _onInput;

		public void SetInput(ConfigEntry<KeyCode> entry, Action? onInput)
		{
			_key = () => entry.Value;
			_onInput = onInput;
		}

		private void Update()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (_key != null)
			{
				KeyCode val = _key();
				if (Input.GetKeyDown(val))
				{
					_onInput?.Invoke();
				}
			}
		}
	}
	internal class TextField : MonoBehaviour
	{
		private InputField? _inputField;

		public string Text
		{
			get
			{
				if ((Object)(object)_inputField == (Object)null)
				{
					return string.Empty;
				}
				return _inputField.text;
			}
			set
			{
				if (!((Object)(object)_inputField == (Object)null))
				{
					_inputField.text = value;
				}
			}
		}

		public static TextField Create(string placeholder = "", ContentType type = (ContentType)0)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("TextField");
			TextField textField = val.AddComponent<TextField>();
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0f, 0.5f);
			val2.anchorMax = new Vector2(1f, 0.5f);
			val2.sizeDelta = new Vector2(300f, 40f);
			Image val3 = val.AddComponent<Image>();
			((Graphic)val3).color = new Color(0f, 0f, 0f, 0.6f);
			GameObject val4 = new GameObject("Text");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = Vector2.zero;
			val5.anchorMax = Vector2.one;
			val5.offsetMin = new Vector2(10f, 5f);
			val5.offsetMax = new Vector2(-10f, 5f);
			Text val6 = val4.AddComponent<Text>();
			val6.font = Fonts.Normal;
			val6.fontSize = 18;
			((Graphic)val6).color = Color.white;
			val6.alignment = (TextAnchor)3;
			val6.supportRichText = false;
			GameObject val7 = new GameObject("Placeholder");
			val7.transform.SetParent(val.transform, false);
			RectTransform val8 = val7.AddComponent<RectTransform>();
			val8.anchorMin = Vector2.zero;
			val8.anchorMax = Vector2.one;
			val8.offsetMin = new Vector2(10f, 0f);
			val8.offsetMax = new Vector2(-10f, 0f);
			Text val9 = val7.AddComponent<Text>();
			val9.font = val6.font;
			val9.fontSize = val6.fontSize;
			((Graphic)val9).color = new Color(1f, 1f, 1f, 0.5f);
			val9.alignment = (TextAnchor)3;
			val9.text = placeholder;
			val9.fontStyle = (FontStyle)2;
			InputField val10 = val.AddComponent<InputField>();
			val10.textComponent = val6;
			val10.placeholder = (Graphic)(object)val9;
			((Selectable)val10).targetGraphic = (Graphic)(object)val3;
			val10.contentType = type;
			textField._inputField = val10;
			return textField;
		}
	}
}
namespace Silksong.BingoSync.UI.Abstract
{
	internal abstract class SettingUpdateNotifier<T> : MonoBehaviour
	{
		private ConfigEntry<T>? _config;

		public void Bind(ConfigEntry<T> config)
		{
			Unbind();
			_config = config;
			_config.SettingChanged += OnRawSettingChanged;
			SettingChanged(_config.Value);
		}

		public void Unbind()
		{
			ConfigEntry<T>? config = _config;
			if (config != null)
			{
				config.SettingChanged -= OnRawSettingChanged;
			}
			_config = null;
		}

		private void OnRawSettingChanged(object sender, EventArgs e)
		{
			SettingChangedEventArgs e2 = (SettingChangedEventArgs)(object)((e is SettingChangedEventArgs) ? e : null);
			if (e2 != null && e2.ChangedSetting is ConfigEntry<T> val)
			{
				SettingChanged(val.Value);
			}
		}

		private void SettingChanged(T value)
		{
			OnSettingChanged(value);
		}

		protected abstract void OnSettingChanged(T value);

		protected virtual void OnDestroy()
		{
			Unbind();
		}
	}
}
namespace Silksong.BingoSync.Patches
{
	[HarmonyPatch(typeof(GameManager))]
	internal class GameManager_Patches
	{
		private static bool hasInitialized;

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Start_Postfix(GameManager __instance)
		{
			if (hasInitialized)
			{
				return;
			}
			string absolutePath = Silksong.BingoSync.Helpers.Path.GetAbsolutePath("Goals/");
			GoalPool val = GoalLoader.LoadPoolFromFolder(absolutePath);
			List<object> list = new List<object>();
			foreach (Goal item in val)
			{
				list.Add(new
				{
					name = item.Name
				});
			}
			Log.Info(JsonConvert.SerializeObject((object)list));
			Plugin.Controller.Pool = val;
			Log.Info($"Loaded '{val.Count}' goals.");
			hasInitialized = true;
		}
	}
	[HarmonyPatch(typeof(HeroController))]
	internal class HeroController_Patches
	{
		[HarmonyPrefix]
		[HarmonyPatch("FixedUpdate")]
		private static void FixedUpdate_Prefix(HeroController __instance)
		{
			Configuration instance = Configuration.Instance;
			if (instance != null && instance.Experimental.EvaluateOnHeroUpdate.Value)
			{
				Plugin.Controller.Evaluate();
			}
		}
	}
	[HarmonyPatch(typeof(PlayerData))]
	internal class PlayerData_Patches
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetBool")]
		private static void SetBool_Postfix()
		{
			Plugin.Controller.Evaluate();
		}
	}
	[HarmonyPatch(typeof(ToolItemManager))]
	internal class ToolItemManager_Patches
	{
		[HarmonyPostfix]
		[HarmonyPatch("ReportCrestUnlocked")]
		private static void ReportCrestUnlocked_Postfix()
		{
			Plugin.Controller.Evaluate();
		}
	}
	[HarmonyPatch(typeof(UIManager))]
	internal class UIManager_Patches
	{
		private static Canvas? _bingoCanvas;

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void Awake_Postfix(UIManager __instance)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_bingoCanvas != (Object)null))
			{
				GameObject val = new GameObject("BingoSync.Canvas");
				Object.DontDestroyOnLoad((Object)(object)val);
				Canvas val2 = val.AddComponent<Canvas>();
				val2.renderMode = (RenderMode)0;
				CanvasScaler val3 = val.AddComponent<CanvasScaler>();
				val3.referenceResolution = __instance.canvasScaler.referenceResolution;
				val3.uiScaleMode = (ScaleMode)1;
				val3.screenMatchMode = (ScreenMatchMode)1;
				val.AddComponent<GraphicRaycaster>();
				_bingoCanvas = val2;
				CreateConnectionMenu(val.transform);
				BoardContainer boardContainer = BoardContainer.Create();
				((Component)boardContainer).transform.SetParent(val.transform, false);
			}
		}

		private static void CreateConnectionMenu(Transform parent)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			GameObject val = new GameObject("ConnectionMenu-Container");
			val.transform.SetParent(parent, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.anchorMin = new Vector2(0.75f, 0f);
			val2.anchorMax = new Vector2(1f, 0.5f);
			val2.offsetMin = new Vector2(-20f, 0f);
			val2.offsetMax = new Vector2(0f, 20f);
			val2.pivot = new Vector2(1f, 0f);
			JoinConfig joinConfig = Configuration.Instance?.Join;
			JoinRoomSettings settings = new JoinRoomSettings
			{
				Nickname = (joinConfig?.Nickname.Value ?? ""),
				Code = (joinConfig?.Code.Value ?? ""),
				Password = (joinConfig?.Password.Value ?? "")
			};
			ConnectionMenu connectionMenu = ConnectionMenu.Create(settings);
			((Component)connectionMenu).transform.SetParent(val.transform, false);
			RectTransform val3 = default(RectTransform);
			if (((Component)connectionMenu).TryGetComponent<RectTransform>(ref val3))
			{
				Canvas.ForceUpdateCanvases();
				LayoutRebuilder.ForceRebuildLayoutImmediate(val3);
			}
		}
	}
}
namespace Silksong.BingoSync.Networking
{
	internal class LoggingHandler : DelegatingHandler
	{
		public LoggingHandler(HttpMessageHandler innerHandler)
			: base(innerHandler)
		{
		}

		protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
		{
			string arg = "";
			if (request.Content != null)
			{
				arg = await request.Content.ReadAsStringAsync();
			}
			Log.Debug($"Request:\n{request}\n{arg}");
			HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
			string arg2 = "";
			if (response.Content != null)
			{
				arg2 = await response.Content.ReadAsStringAsync();
			}
			Log.Debug($"Response:\n{response}\n{arg2}");
			return response;
		}
	}
}
namespace Silksong.BingoSync.Helpers
{
	internal static class GoalLoader
	{
		public static GoalPool LoadPoolFromFolder(string folder)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			GoalPool val = new GoalPool();
			if (!Directory.Exists(folder))
			{
				Log.Warning("Folder '" + folder + "' does not exist.");
				return val;
			}
			string[] files = Directory.GetFiles(folder, "*.json", SearchOption.AllDirectories);
			string[] array = files;
			foreach (string text in array)
			{
				try
				{
					GoalSet val2 = LoadSetFromFile(text);
					Goal[] goals = val2.Goals;
					foreach (Goal val3 in goals)
					{
						val.TryAdd(val3);
					}
				}
				catch (Exception arg)
				{
					Log.Error($"Error while loading '{text}': {arg}");
				}
			}
			return val;
		}

		public static GoalSet LoadSetFromFile(string file)
		{
			string text = File.ReadAllText(file);
			GoalSet val = JsonConvert.DeserializeObject<GoalSet>(text);
			if (val == (GoalSet)null)
			{
				throw new InvalidOperationException("Must parse a valid 'GoalSet'.");
			}
			return val;
		}
	}
	internal static class Log
	{
		private static readonly Lazy<ManualLogSource> Logger = new Lazy<ManualLogSource>((Func<ManualLogSource>)(() => Logger.CreateLogSource("dev.warpersan.silksong.bingosync")));

		public static void LogCore(LogLevel level, string message)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			switch ((int)level)
			{
			case 0:
				Debug(message);
				break;
			case 2:
				Warning(message);
				break;
			case 3:
				Error(message);
				break;
			default:
				Info(message);
				break;
			}
		}

		public static void Debug(string? message)
		{
			Logger.Value.LogDebug((object)message);
		}

		public static void Info(string? message)
		{
			Logger.Value.LogInfo((object)message);
		}

		public static void Warning(string? message)
		{
			Logger.Value.LogWarning((object)message);
		}

		public static void Error(string? message)
		{
			Logger.Value.LogError((object)message);
		}
	}
	internal static class Patch
	{
		public static void ApplyAll()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony val = new Harmony("dev.warpersan.silksong.bingosync");
			val.PatchAll(typeof(UIManager_Patches));
			val.PatchAll(typeof(PlayerData_Patches));
			val.PatchAll(typeof(ToolItemManager_Patches));
			val.PatchAll(typeof(HeroController_Patches));
			val.PatchAll(typeof(GameManager_Patches));
			Log.Debug("All patches applied.");
		}
	}
	internal static class Path
	{
		public static string GetPluginFolder()
		{
			string location = Assembly.GetExecutingAssembly().Location;
			string directoryName = System.IO.Path.GetDirectoryName(location);
			return directoryName ?? string.Empty;
		}

		public static string GetAbsolutePath(string relativePath)
		{
			string pluginFolder = GetPluginFolder();
			return System.IO.Path.Combine(pluginFolder, relativePath);
		}
	}
}
namespace Silksong.BingoSync.Factories
{
	[ConditionFactory("has_completed_wish_count")]
	internal sealed class HasCompletedWishCountCondition : ParameterizedConditionFactory<HasCompletedWishCountCondition.Parameters>
	{
		public sealed class Parameters
		{
			[JsonProperty("amount")]
			[JsonRequired]
			[Description("Minimum number of conditions that must be met")]
			public uint Amount { get; init; }

			[JsonProperty("type")]
			[Description("Type of the wish to keep")]
			public WishType? Type { get; init; }
		}

		private static ICondition CreateCondition(Wish wish)
		{
			return (ICondition)(object)new HasCompletedWishCondition
			{
				Wish = wish
			};
		}

		private static IEnumerable<Wish> GetWishes(Parameters parameters)
		{
			foreach (Wish value in Enum.GetValues(typeof(Wish)))
			{
				if (parameters.Type.HasValue)
				{
					WishType wishType = value.GetWishType();
					if (parameters.Type.Value != wishType)
					{
						continue;
					}
				}
				yield return value;
			}
		}

		protected override ICondition Generate(Parameters parameters)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			List<ICondition> conditions = GetWishes(parameters).Select(CreateCondition).ToList();
			SomeCondition val = new SomeCondition();
			val.set_Amount(parameters.Amount);
			val.set_Conditions((IReadOnlyCollection<ICondition>)conditions);
			return (ICondition)val;
		}
	}
	[ConditionFactory("has_found_flea_count")]
	internal sealed class HasFoundFleaCountCondition : ParameterizedConditionFactory<HasFoundFleaCountCondition.Parameters>
	{
		public sealed class Parameters
		{
			[JsonProperty("amount")]
			[JsonRequired]
			[Description("Minimum number of conditions that must be met")]
			public uint Amount { get; init; }

			[JsonProperty("area")]
			[Description("Area of the fleas to keep")]
			public Area? Area { get; init; }

			[JsonProperty("include_unique")]
			[Description("Defines if the unique fleas must be included")]
			public bool? IncludeUnique { get; init; }
		}

		private static ICondition CreateCondition(Flea flea)
		{
			return (ICondition)(object)new HasFoundFleaCondition
			{
				Flea = flea
			};
		}

		private static IEnumerable<Flea> GetFleas(Parameters parameters)
		{
			foreach (Flea value in Enum.GetValues(typeof(Flea)))
			{
				if (parameters.Area.HasValue)
				{
					Area area = value.GetArea();
					if (parameters.Area.Value != area)
					{
						continue;
					}
				}
				if (!parameters.IncludeUnique.HasValue || !value.IsUnique() || parameters.IncludeUnique.Value)
				{
					yield return value;
				}
			}
		}

		protected override ICondition Generate(Parameters parameters)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			List<ICondition> conditions = GetFleas(parameters).Select(CreateCondition).ToList();
			SomeCondition val = new SomeCondition();
			val.set_Amount(parameters.Amount);
			val.set_Conditions((IReadOnlyCollection<ICondition>)conditions);
			return (ICondition)val;
		}
	}
	[ConditionFactory("has_obtained_tool_count")]
	internal sealed class HasObtainedToolCountCondition : ParameterizedConditionFactory<HasObtainedToolCountCondition.Parameters>
	{
		public sealed class Parameters
		{
			[JsonProperty("amount")]
			[JsonRequired]
			[Description("Minimum number of conditions that must be met")]
			public uint Amount { get; init; }

			[JsonProperty("type")]
			[Description("Type of the tool to keep")]
			public ToolType? Type { get; init; }
		}

		private static ICondition CreateCondition(Tool tool)
		{
			return (ICondition)(object)new HasObtainedToolCondition
			{
				Tool = tool
			};
		}

		private static IEnumerable<Tool> GetTools(Parameters parameters)
		{
			foreach (Tool value in Enum.GetValues(typeof(Tool)))
			{
				if (parameters.Type.HasValue)
				{
					ToolType toolType = value.GetToolType();
					if (parameters.Type.Value != toolType)
					{
						continue;
					}
				}
				yield return value;
			}
		}

		protected override ICondition Generate(Parameters parameters)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			List<ICondition> conditions = GetTools(parameters).Select(CreateCondition).ToList();
			SomeCondition val = new SomeCondition();
			val.set_Amount(parameters.Amount);
			val.set_Conditions((IReadOnlyCollection<ICondition>)conditions);
			return (ICondition)val;
		}
	}
}
namespace Silksong.BingoSync.Extensions
{
	public static class PlayerDataExtensions
	{
		public static bool HasObtainedAncestralArt(this PlayerData data, AncestralArt art)
		{
			return art switch
			{
				AncestralArt.SwiftStep => data.hasDash, 
				AncestralArt.ClingGrip => data.hasWalljump, 
				AncestralArt.Needolin => data.hasNeedolin, 
				AncestralArt.Clawline => data.hasHarpoonDash, 
				AncestralArt.SilkSoar => data.hasSuperJump, 
				AncestralArt.Sylphsong => data.HasSeenEvaHeal, 
				_ => throw new InvalidCheckException<AncestralArt>(art), 
			};
		}

		public static bool HasObtainedMap(this PlayerData data, Area area)
		{
			return area switch
			{
				Area.TheAbyss => data.HasAbyssMap, 
				Area.Bellhart => data.HasBellhartMap, 
				Area.Bilewater => data.HasSwampMap, 
				Area.BlastedSteps => data.HasJudgeStepsMap, 
				Area.BoneBottom => data.HasMossGrottoMap, 
				Area.TheCradle => data.HasCradleMap, 
				Area.DeepDocks => data.HasDocksMap, 
				Area.FarFields => data.HasWildsMap, 
				Area.Greymoor => data.HasGreymoorMap, 
				Area.HuntersMarch => data.HasHuntersNestMap, 
				Area.TheMarrow => data.HasBoneforestMap, 
				Area.TheMist => false, 
				Area.MossGrotto => false, 
				Area.MountFay => data.HasPeakMap, 
				Area.PutrifiedDucts => data.HasAqueductMap, 
				Area.RedMemory => false, 
				Area.SandsOfKarak => data.HasCoralMap, 
				Area.Shellwood => data.HasShellwoodMap, 
				Area.SinnersRoad => data.HasDustpensMap, 
				Area.TheSlab => data.HasSlabMap, 
				Area.Underworks => data.HasCitadelUnderstoreMap, 
				Area.Verdania => data.HasCloverMap, 
				Area.WeavenestAtla => data.HasWeavehomeMap, 
				Area.WispThicket => false, 
				Area.Wormways => data.HasCrawlMap, 
				Area.ChoralChambers => data.HasHallsMap, 
				Area.CogworkCore => data.HasCogMap, 
				Area.GrandGate => data.HasSongGateMap, 
				Area.HighHalls => data.HasHangMap, 
				Area.Memorium => data.HasArboriumMap, 
				Area.WhisperingVaults => data.HasLibraryMap, 
				Area.Whiteward => data.HasWardMap, 
				_ => throw new InvalidCheckException<Area>(area), 
			};
		}

		public static bool HasKilledBoss(this PlayerData data, Boss boss)
		{
			return boss switch
			{
				Boss.BellBeast => data.defeatedBellBeast, 
				Boss.FourthChorus => data.defeatedSongGolem, 
				Boss.GreatConchflies => data.defeatedCoralDrillers, 
				Boss.Lace1 => data.defeatedLace1, 
				Boss.LastJudge => data.defeatedLastJudge, 
				Boss.Moorwing => data.defeatedVampireGnatBoss, 
				Boss.MossMother => data.defeatedMossMother, 
				Boss.MossMothers => data.HasJournalEntry(Boss.MossMothers), 
				Boss.Phantom => data.defeatedPhantom, 
				Boss.SavageBeastfly1 => data.defeatedBoneFlyerGiant, 
				Boss.SisterSplinter => data.defeatedSplinterQueen, 
				Boss.SkullTyrant1 => data.skullKingDefeated, 
				Boss.SkullTyrant2 => data.HasJournalEntry(Boss.SkullTyrant2), 
				Boss.Widow => data.spinnerDefeated, 
				Boss.Broodmother => data.defeatedBroodMother, 
				Boss.CogworkDancers => data.defeatedCogworkDancers, 
				Boss.DisgracedChefLugoli => data.defeatedRoachkeeperChef, 
				Boss.FatherOfTheFlame => data.defeatedWispPyreEffigy, 
				Boss.FirstSinner => data.defeatedFirstWeaver, 
				Boss.Forebrothers => data.defeatedDockForemen, 
				Boss.Garmond => data.HasJournalEntry(Boss.Garmond), 
				Boss.GrandMotherSilk => data.HasCompletedEnding(Ending.WeaverQueen) || data.HasCompletedEnding(Ending.SnaredSilk) || data.HasCompletedEnding(Ending.TwistedChild), 
				Boss.Groal => data.DefeatedSwampShaman, 
				Boss.Lace2 => data.defeatedLaceTower, 
				Boss.RagingConchfly => data.defeatedCoralDrillerSolo, 
				Boss.SavageBeastfly2 => data.defeatedBoneFlyerGiantGolemScene, 
				Boss.SecondSentinel => data.defeatedSongChevalierBoss, 
				Boss.Shakra => data.HasJournalEntry(Boss.Shakra), 
				Boss.TheUnravelled => data.wardBossDefeated, 
				Boss.Trobbio => data.defeatedTrobbio, 
				Boss.Voltvyrm => data.defeatedZapCoreEnemy, 
				Boss.BellEater => data.HasJournalEntry(Boss.BellEater), 
				Boss.CloverDancers => data.defeatedCloverDancers, 
				Boss.Crawfather => data.defeatedCrowCourt, 
				Boss.CrustKingKhann => data.defeatedCoralKing, 
				Boss.GurrTheOutcast => data.defeatedAntTrapper, 
				Boss.LostGarmond => data.garmondBlackThreadDefeated, 
				Boss.LostLace => data.HasCompletedEnding(Ending.SisterOfTheVoid), 
				Boss.Nyleth => data.defeatedFlowerQueen, 
				Boss.Palestag => data.defeatedWhiteCloverstag, 
				Boss.Pinstress => data.HasJournalEntry(Boss.Pinstress), 
				Boss.PlasmifiedZango => data.BlueScientistDead, 
				Boss.ShrineGuardianSeth => data.defeatedSeth, 
				Boss.SkarrsingerKarmelita => data.defeatedAntQueen, 
				Boss.TormentedTrobbio => data.defeatedTormentedTrobbio, 
				Boss.Watcher => data.defeatedGreyWarrior, 
				_ => throw new InvalidCheckException<Boss>(boss), 
			};
		}

		private static string GetCrestId(Crest crest)
		{
			return crest switch
			{
				Crest.Hunter => "Hunter", 
				Crest.HunterEvolved => "Hunter_v2", 
				Crest.HunterFullyEvolved => "Hunter_v3", 
				Crest.Reaper => "Reaper", 
				Crest.Wanderer => "Wanderer", 
				Crest.Beast => "Warrior", 
				Crest.Cursed => "Cursed", 
				Crest.Witch => "Witch", 
				Crest.Architect => "Toolmaster", 
				Crest.Shaman => "Spell", 
				Crest.Cloakless => "Cloakless", 
				_ => throw new InvalidCheckException<Crest>(crest), 
			};
		}

		private static Data? GetCrestData(this PlayerData data, Crest crest)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			string crestId = GetCrestId(crest);
			return ((SerializableNamedList<Data, NamedData>)(object)data.ToolEquips).GetData(crestId);
		}

		public static bool HasObtainedCrest(this PlayerData data, Crest crest)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Data? crestData = data.GetCrestData(crest);
			if (!crestData.HasValue)
			{
				return false;
			}
			return crestData.Value.IsUnlocked;
		}

		public static bool HasCompletedEnding(this PlayerData data, Ending ending)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			return ending switch
			{
				Ending.WeaverQueen => ((Enum)data.CompletedEndings).HasFlag((Enum)(object)(CompletionState)1), 
				Ending.SnaredSilk => ((Enum)data.CompletedEndings).HasFlag((Enum)(object)(CompletionState)4), 
				Ending.TwistedChild => ((Enum)data.CompletedEndings).HasFlag((Enum)(object)(CompletionState)2), 
				Ending.SisterOfTheVoid => ((Enum)data.CompletedEndings).HasFlag((Enum)(object)(CompletionState)8), 
				Ending.PassingOfTheAge => data.MushroomQuestCompleted, 
				_ => throw new InvalidCheckException<Ending>(ending), 
			};
		}

		public static bool HasFoundFlea(this PlayerData data, Flea flea)
		{
			return flea switch
			{
				Flea.AboveMarrowBellways => data.SavedFlea_Bone_06, 
				Flea.BehindDeepDocksBellways => data.SavedFlea_Dock_16, 
				Flea.LeftOfSwiftStep => data.SavedFlea_Bone_East_05, 
				Flea.BehindDeepDocksFurnaceGauntlet => data.SavedFlea_Dock_03d, 
				Flea.BehindSkarrgard => data.SavedFlea_Ant_03, 
				Flea.BehindHunterBoobyTrap => data.SavedFlea_Bone_East_17b, 
				Flea.NextToPilgrimsRest => data.SavedFlea_Bone_East_10_Church, 
				Flea.CarriedByAknid => data.SavedFlea_Crawl_06, 
				Flea.AboveCrawLake => data.SavedFlea_Greymoor_15b, 
				Flea.TopOfGreymoorLeftTower => data.SavedFlea_Greymoor_06, 
				Flea.Kratt => data.CaravanLechSaved, 
				Flea.AboveBellhart => data.SavedFlea_Belltown_04, 
				Flea.InGahliaPit => data.SavedFlea_Shellwood_03, 
				Flea.AboveGrindle => data.SavedFlea_Coral_35, 
				Flea.TrappedInSinnersRoad => data.SavedFlea_Dust_12, 
				Flea.GuardedBySnitchflies => data.SavedFlea_Shadow_28, 
				Flea.BesideExhaustOrgan => data.SavedFlea_Dust_09, 
				Flea.AboveSecretBilewaterBench => data.SavedFlea_Shadow_10, 
				Flea.AfterWispThicket => data.SavedFlea_Under_23, 
				Flea.AcrossCogworkHaulersRoom => data.SavedFlea_Under_21, 
				Flea.AfterChoralChambersPlatforming => data.SavedFlea_Song_14, 
				Flea.AfterVerticalSawbladesRoom => data.SavedFlea_Song_11, 
				Flea.HugeFlea => data.tamedGiantFlea, 
				Flea.JailedInSlab => data.SavedFlea_Slab_Cell, 
				Flea.AboveSlabBench => data.SavedFlea_Slab_06, 
				Flea.FrozenInIce => data.SavedFlea_Peak_05c, 
				Flea.UnderVoltnest => data.SavedFlea_Coral_24, 
				Flea.Vog => data.MetTroupeHunterWild, 
				Flea.RightOfSongclave => data.SavedFlea_Library_09, 
				Flea.RightOfBoxPuzzle => data.SavedFlea_Library_01, 
				_ => throw new InvalidCheckException<Flea>(flea), 
			};
		}

		public static Area GetArea(this Flea flea)
		{
			return flea switch
			{
				Flea.AboveMarrowBellways => Area.TheMarrow, 
				Flea.BehindDeepDocksBellways => Area.DeepDocks, 
				Flea.LeftOfSwiftStep => Area.DeepDocks, 
				Flea.BehindDeepDocksFurnaceGauntlet => Area.DeepDocks, 
				Flea.BehindSkarrgard => Area.HuntersMarch, 
				Flea.BehindHunterBoobyTrap => Area.FarFields, 
				Flea.NextToPilgrimsRest => Area.FarFields, 
				Flea.CarriedByAknid => Area.Wormways, 
				Flea.AboveCrawLake => Area.Greymoor, 
				Flea.TopOfGreymoorLeftTower => Area.Greymoor, 
				Flea.Kratt => Area.Greymoor, 
				Flea.AboveBellhart => Area.Bellhart, 
				Flea.InGahliaPit => Area.Shellwood, 
				Flea.AboveGrindle => Area.BlastedSteps, 
				Flea.TrappedInSinnersRoad => Area.SinnersRoad, 
				Flea.GuardedBySnitchflies => Area.Bilewater, 
				Flea.BesideExhaustOrgan => Area.Bilewater, 
				Flea.AboveSecretBilewaterBench => Area.Bilewater, 
				Flea.AfterWispThicket => Area.Underworks, 
				Flea.AcrossCogworkHaulersRoom => Area.Underworks, 
				Flea.AfterChoralChambersPlatforming => Area.ChoralChambers, 
				Flea.AfterVerticalSawbladesRoom => Area.ChoralChambers, 
				Flea.HugeFlea => Area.Memorium, 
				Flea.JailedInSlab => Area.TheSlab, 
				Flea.AboveSlabBench => Area.TheSlab, 
				Flea.FrozenInIce => Area.MountFay, 
				Flea.UnderVoltnest => Area.SandsOfKarak, 
				Flea.Vog => Area.PutrifiedDucts, 
				Flea.RightOfSongclave => Area.WhisperingVaults, 
				Flea.RightOfBoxPuzzle => Area.WhisperingVaults, 
				_ => throw new InvalidCheckException<Flea>(flea), 
			};
		}

		public static bool IsUnique(this Flea flea)
		{
			if (flea == Flea.Kratt || flea == Flea.HugeFlea || flea == Flea.Vog)
			{
				return true;
			}
			return false;
		}

		private static KillData GetKillData(this PlayerData data, string key)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return data.EnemyJournalKillData.GetKillData(key);
		}

		private static int GetKillCount(this PlayerData data, string key)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return data.GetKillData(key).Kills;
		}

		private static bool HasJournalEntry(this PlayerData data, string key)
		{
			return data.GetKillCount(key) > 0;
		}

		public static bool HasJournalEntry(this PlayerData data, Boss boss)
		{
			return boss switch
			{
				Boss.Shakra => data.HasJournalEntry("Shakra"), 
				Boss.BellBeast => throw new NotImplementedException(), 
				Boss.FourthChorus => throw new NotImplementedException(), 
				Boss.GreatConchflies => throw new NotImplementedException(), 
				Boss.Lace1 => throw new NotImplementedException(), 
				Boss.LastJudge => throw new NotImplementedException(), 
				Boss.Moorwing => throw new NotImplementedException(), 
				Boss.MossMother => data.HasJournalEntry("Mossbone Mother"), 
				Boss.MossMothers => data.GetKillCount("Mossbone Mother") >= 3, 
				Boss.Phantom => throw new NotImplementedException(), 
				Boss.SavageBeastfly1 => throw new NotImplementedException(), 
				Boss.SisterSplinter => throw new NotImplementedException(), 
				Boss.SkullTyrant1 => data.HasJournalEntry("Skull King"), 
				Boss.SkullTyrant2 => data.GetKillCount("Skull King") >= 2, 
				Boss.Widow => throw new NotImplementedException(), 
				Boss.Broodmother => throw new NotImplementedException(), 
				Boss.CogworkDancers => throw new NotImplementedException(), 
				Boss.DisgracedChefLugoli => throw new NotImplementedException(), 
				Boss.FatherOfTheFlame => throw new NotImplementedException(), 
				Boss.FirstSinner => throw new NotImplementedException(), 
				Boss.Forebrothers => throw new NotImplementedException(), 
				Boss.Garmond => data.HasJournalEntry("Garmond"), 
				Boss.GrandMotherSilk => throw new NotImplementedException(), 
				Boss.Groal => throw new NotImplementedException(), 
				Boss.Lace2 => throw new NotImplementedException(), 
				Boss.RagingConchfly => throw new NotImplementedException(), 
				Boss.SavageBeastfly2 => throw new NotImplementedException(), 
				Boss.SecondSentinel => throw new NotImplementedException(), 
				Boss.TheUnravelled => throw new NotImplementedException(), 
				Boss.Trobbio => throw new NotImplementedException(), 
				Boss.Voltvyrm => throw new NotImplementedException(), 
				Boss.BellEater => data.HasJournalEntry("Giant Centipede"), 
				Boss.CloverDancers => throw new NotImplementedException(), 
				Boss.Crawfather => throw new NotImplementedException(), 
				Boss.CrustKingKhann => throw new NotImplementedException(), 
				Boss.GurrTheOutcast => throw new NotImplementedException(), 
				Boss.LostGarmond => throw new NotImplementedException(), 
				Boss.LostLace => throw new NotImplementedException(), 
				Boss.Nyleth => throw new NotImplementedException(), 
				Boss.Palestag => throw new NotImplementedException(), 
				Boss.Pinstress => data.HasJournalEntry("Pinstress Boss"), 
				Boss.PlasmifiedZango => throw new NotImplementedException(), 
				Boss.ShrineGuardianSeth => throw new NotImplementedException(), 
				Boss.SkarrsingerKarmelita => throw new NotImplementedException(), 
				Boss.TormentedTrobbio => throw new NotImplementedException(), 
				Boss.Watcher => throw new NotImplementedException(), 
				_ => throw new InvalidCheckException<Boss>(boss), 
			};
		}

		private static string GetMementoId(Memento memento)
		{
			return memento switch
			{
				Memento.Sprintmaster => "Sprintmaster Memento", 
				Memento.Guardian => "Memento Seth", 
				Memento.Hero => "Memento Garmond", 
				Memento.Hunter => "Hunter Memento", 
				Memento.Grey => "Grey Memento", 
				Memento.Surface => "Memento Surface", 
				Memento.Craw => "Crowman Memento", 
				Memento.EncrustedHeart => "Coral Heart", 
				Memento.PollenHeart => "Flower Heart", 
				Memento.HunterHeart => "Hunter Heart", 
				Memento.ConjoinedHeart => "Clover Heart", 
				_ => throw new InvalidCheckException<Memento>(memento), 
			};
		}

		private static Data? GetMementoData(this PlayerData data, Memento memento)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			string mementoId = GetMementoId(memento);
			return ((SerializableNamedList<Data, NamedData>)(object)data.MementosDeposited).GetData(mementoId);
		}

		public static bool HasObtainedMemento(this PlayerData data, Memento memento)
		{
			return memento switch
			{
				Memento.Sprintmaster => data.CollectedMementoSprintmaster, 
				Memento.Guardian => data.FleaGamesMementoGiven, 
				Memento.Hero => throw new NotImplementedException(), 
				Memento.Hunter => data.nuuMementoAwarded, 
				Memento.Grey => data.CollectedMementoGrey, 
				Memento.Surface => throw new NotImplementedException(), 
				Memento.Craw => data.PickedUpCrowMemento, 
				Memento.EncrustedHeart => data.CollectedHeartCoral, 
				Memento.PollenHeart => data.CollectedHeartFlower, 
				Memento.HunterHeart => data.CollectedHeartHunter, 
				Memento.ConjoinedHeart => data.CollectedHeartClover, 
				_ => throw new InvalidCheckException<Memento>(memento), 
			};
		}

		public static bool HasDepositedMemento(this PlayerData data, Memento memento)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Data? mementoData = data.GetMementoData(memento);
			if (!mementoData.HasValue)
			{
				return false;
			}
			return mementoData.Value.IsDeposited;
		}

		private static int GetNeedleUpgradeIndex(Needle needle)
		{
			return needle switch
			{
				Needle.Needle => 0, 
				Needle.SharpenedNeedle => 1, 
				Needle.ShiningNeedle => 2, 
				Needle.HivesteelNeedle => 3, 
				Needle.PaleSteelNeedle => 4, 
				_ => throw new InvalidCheckException<Needle>(needle), 
			};
		}

		public static bool HasObtainedNeedle(this PlayerData data, Needle needle)
		{
			int needleUpgradeIndex = GetNeedleUpgradeIndex(needle);
			return data.nailUpgrades >= needleUpgradeIndex;
		}

		private static int GetQuillState(Quill quill)
		{
			return quill switch
			{
				Quill.White => 1, 
				Quill.Red => 2, 
				Quill.Purple => 3, 
				_ => throw new InvalidCheckException<Quill>(quill), 
			};
		}

		public static bool HasObtainedQuill(this PlayerData data, Quill quill)
		{
			if (!data.hasQuill)
			{
				return false;
			}
			return data.QuillState == GetQuillState(quill);
		}

		private static string GetSilkSkillId(SilkSkill skill)
		{
			return skill switch
			{
				SilkSkill.Silkspear => "Silk Spear", 
				SilkSkill.ThreadStorm => "Thread Sphere", 
				SilkSkill.CrossStitch => "Parry", 
				SilkSkill.Sharpdart => "Silk Charge", 
				SilkSkill.RuneRage => "Silk Bomb", 
				SilkSkill.PaleNails => "Silk Boss Needle", 
				_ => throw new InvalidCheckException<SilkSkill>(skill), 
			};
		}

		private static Data? GetSilkSkillData(this PlayerData data, SilkSkill skill)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			string silkSkillId = GetSilkSkillId(skill);
			return ((SerializableNamedList<Data, NamedData>)(object)data.Tools).GetData(silkSkillId);
		}

		public static bool HasObtainedSilkSkill(this PlayerData data, SilkSkill skill)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Data? silkSkillData = data.GetSilkSkillData(skill);
			if (!silkSkillData.HasValue)
			{
				return false;
			}
			return silkSkillData.Value.IsUnlocked;
		}

		private static string GetToolId(Tool tool)
		{
			return tool switch
			{
				Tool.StraightPin => "Straight Pin", 
				Tool.ThreefoldPin => "Tri Pin", 
				Tool.StingShard => "Sting Shard", 
				Tool.Tacks => "Tack", 
				Tool.Longpin => "Harpoon", 
				Tool.Curveclaw => "Curve Claws", 
				Tool.Curvesickle => "Curve Claws Upgraded", 
				Tool.ThrowingRing => "Shakra Ring", 
				Tool.Pimpillo => "Pimpilo", 
				Tool.Conchcutter => "Conch Drill", 
				Tool.WeaverSilkshot => "WebShot Weaver", 
				Tool.ForgeSilkshot => "WebShot Forge", 
				Tool.ArchitectSilkshot => "WebShot Architect", 
				Tool.DelversDrill => "Screw Attack", 
				Tool.CogworkWheel => "Cogwork Saw", 
				Tool.Cogfly => "Cogwork Flier", 
				Tool.RosaryCannon => "Rosary Cannon", 
				Tool.Voltvessels => "Lightning Rod", 
				Tool.Flintslate => "Flintstone", 
				Tool.SnareSetter => "Silk Snare", 
				Tool.FleaBrew => "Flea Brew", 
				Tool.PlasmiumPhial => "Lifeblood Syringe", 
				Tool.NeedlePhial => "Extractor", 
				Tool.DruidsEye => "Mosscreep Tool 1", 
				Tool.DruidsEyes => "Mosscreep Tool 2", 
				Tool.MagmaBell => "Lava Charm", 
				Tool.WardingBell => "Bell Bind", 
				Tool.PollipPouch => "Poison Pouch", 
				Tool.FracturedMask => "Fractured Mask", 
				Tool.Multibinder => "Multibind", 
				Tool.Weavelight => "White Ring", 
				Tool.SawtoothCirclet => "Brolly Spike", 
				Tool.InjectorBand => "Quickbind", 
				Tool.SpoolExtender => "Spool Extender", 
				Tool.ReserveBind => "Reserve Bind", 
				Tool.ClawMirror => "Dazzle Bind", 
				Tool.ClawMirrors => "Dazzle Bind Upgraded", 
				Tool.MemoryCrystal => "Revenge Crystal", 
				Tool.SnitchPick => "Thief Claw", 
				Tool.VoltFilament => "Zap Imbuement", 
				Tool.QuickSling => "Quick Sling", 
				Tool.WreathOfPurity => "Maggot Charm", 
				Tool.Longclaw => "Longneedle", 
				Tool.WispfireLantern => "Wisp Lantern", 
				Tool.EggOfFlealia => "Flea Charm", 
				Tool.PinBadge => "Pinstress Tool", 
				Tool.Compass => "Compass", 
				Tool.ShardPendant => "Bone Necklace", 
				Tool.MagnetiteBrooch => "Rosary Magnet", 
				Tool.WeightedBelt => "Weighted Anklet", 
				Tool.BarbedBracelet => "Barbed Wire", 
				Tool.DeadBugsPurse => "Dead Mans Purse", 
				Tool.ShellSatchel => "Shell Satchel", 
				Tool.MagnetiteDice => "Magnetite Dice", 
				Tool.Scuttlebrace => "Scuttlebrace", 
				Tool.AscendantsGrip => "Wallcling", 
				Tool.SpiderStrings => "Musician Charm", 
				Tool.SilkspeedAnklets => "Sprintmaster", 
				Tool.ThiefsMark => "Thief Charm", 
				_ => throw new InvalidCheckException<Tool>(tool), 
			};
		}

		private static Data? GetToolData(this PlayerData data, Tool tool)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			string toolId = GetToolId(tool);
			return ((SerializableNamedList<Data, NamedData>)(object)data.Tools).GetData(toolId);
		}

		private static ToolItem? GetToolItem(Tool tool)
		{
			string toolId = GetToolId(tool);
			return ToolItemManager.GetToolByName(toolId);
		}

		public static ToolType GetToolType(this Tool tool)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected I4, but got Unknown
			ToolItem toolItem = GetToolItem(tool);
			if ((Object)(object)toolItem == (Object)null)
			{
				throw new ArgumentException(string.Format("No instance of '{0}' was found for '{1}'.", "ToolItem", tool));
			}
			ToolItemType type = toolItem.Type;
			return (int)type switch
			{
				0 => ToolType.Red, 
				1 => ToolType.Blue, 
				2 => ToolType.Yellow, 
				3 => throw new InvalidOperationException(string.Format("The tool type '{0}' cannot be converted to '{1}'.", (object)(ToolItemType)3, "ToolType")), 
				_ => throw new InvalidCheckException<Tool>(tool), 
			};
		}

		public static bool HasObtainedTool(this PlayerData data, Tool tool)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Data? toolData = data.GetToolData(tool);
			if (!toolData.HasValue)
			{
				return false;
			}
			if (toolData.Value.IsUnlocked)
			{
				return !toolData.Value.IsHidden;
			}
			return false;
		}

		public static bool HasUnlockedStation(this PlayerData data, VentricaStation station)
		{
			return station switch
			{
				VentricaStation.Memorium => data.UnlockedArboriumTube, 
				VentricaStation.HighHalls => data.UnlockedHangTube, 
				VentricaStation.FirstShrine => data.UnlockedEnclaveTube, 
				VentricaStation.ChoralChambers => data.UnlockedSongTube, 
				VentricaStation.GrandBellway => data.UnlockedCityBellwayTube, 
				VentricaStation.Underworks => data.UnlockedUnderTube, 
				_ => throw new InvalidCheckException<VentricaStation>(station), 
			};
		}

		public static bool HasObtainedVesticrest(this PlayerData data, Vesticrest vesticrest)
		{
			return vesticrest switch
			{
				Vesticrest.Basic => data.UnlockedExtraYellowSlot, 
				Vesticrest.Upgraded => data.UnlockedExtraBlueSlot, 
				_ => throw new InvalidCheckException<Vesticrest>(vesticrest), 
			};
		}

		private static string GetWishId(Wish wish)
		{
			return wish switch
			{
				Wish.FlexileSpines => "Brolly Get", 
				Wish.Broodfeast => "Huntress Quest", 
				Wish.SilverBells => "Shiny Bell Goomba", 
				Wish.VolatileFlintbeetles => "Rock Rollers", 
				Wish.GarbOfThePilgrims => "Pilgrim Rags", 
				Wish.FinePins => "Fine Pins", 
				Wish.CloaksOfTheChoir => "Song Pilgrim Cloaks", 
				Wish.RoachGuts => "Roach Killing", 
				Wish.CrawbugClearing => "Crow Feathers", 
				Wish.AdvancedAlchemy => "Extractor Blue Worms", 
				Wish.RiteOfThePollip => "Shell Flowers", 
				Wish.AlchemistsAssistant => "Extractor Blue", 
				Wish.HerosCall => "Garmond Black Threaded", 
				Wish.Runtfeast => "Huntress Quest Runt", 
				Wish.GreatTasteOfPharloom => "Great Gourmand", 
				Wish.TheLostFleas => "Save the Fleas", 
				Wish.EcstasyOfTheEnd => "Flea Games", 
				Wish.TheWanderingMerchant => "Save City Merchant", 
				Wish.FinalAudience => "Song Knight", 
				Wish.PassingOfTheAge => "Mr Mushroom", 
				Wish.PinmastersOil => "A Pinsmiths Tools", 
				Wish.SilkAndSoul => "Soul Snare", 
				Wish.MyMissingCourier => "Save Courier Short", 
				Wish.MyMissingBrother => "Save Courier Tall", 
				Wish.SongclaveSupplies => "Courier Delivery Songclave", 
				Wish.BellhartsGlory => "Belltown House Mid", 
				Wish.RestorationOfBellhart => "Belltown House Start", 
				Wish.BuildingUpSongclave => "Songclave Donation 1", 
				Wish.TheTerribleTyrant => "Skull King", 
				Wish.TheLostMerchant => "Save City Merchant Bridge", 
				Wish.SavageBeastfly => "Beastfly Hunt", 
				Wish.TrailsEnd => "Shakra Final Quest", 
				Wish.StrengtheningSongclave => "Songclave Donation 2", 
				Wish.TheHiddenHunter => "Ant Trapper", 
				Wish.PainAnguishAndMisery => "Tormented Trobbio", 
				Wish.AnIconOfHope => "Building Materials (Statue)", 
				Wish.ALifesavingBridge => "Building Materials (Bridge)", 
				Wish.DarkHearts => "Destroy Thread Cores", 
				Wish.BoneBottomRepairs => "Building Materials", 
				Wish.FastestInPharloom => "Sprintmaster Race", 
				Wish.LiquidLacquer => "Courier Delivery Mask Maker", 
				Wish.FleatopiaSupplies => "Courier Delivery Fleatopia", 
				Wish.BugsOfPharloom => "Journal", 
				Wish.BalmForTheWounded => "Save Sherma", 
				Wish.QueensEgg => "Courier Delivery Dustpens Slave", 
				Wish.PilgrimsRestSupplies => "Courier Delivery Pilgrims Rest", 
				Wish.BerryPicking => "Mossberry Collection 1", 
				Wish.InfestationOperation => "Doctor Curse Cure", 
				Wish.BoneBottomSupplies => "Courier Delivery Bonebottom", 
				Wish.SurvivorsCampSupplies => "Courier Delivery Fixer", 
				Wish.RiteOfRebirth => "Wood Witch Curse", 
				Wish.TheWailingMother => "Broodmother Hunt", 
				Wish.AVassalLost => "Steel Sentinel Pt2", 
				Wish.FatalResolve => "Pinstress Battle", 
				_ => throw new InvalidCheckException<Wish>(wish), 
			};
		}

		private static Completion? GetWishData(this PlayerData data, Wish wish)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			string wishId = GetWishId(wish);
			return ((SerializableNamedList<Completion, NamedCompletion>)(object)data.QuestCompletionData).GetData(wishId);
		}

		private static FullQuestBase? GetWishItem(Wish wish)
		{
			string wishId = GetWishId(wish);
			return QuestManager.GetQuest(wishId);
		}

		public static WishType GetWishType(this Wish wish)
		{
			FullQuestBase wishItem = GetWishItem(wish);
			if ((Object)(object)wishItem == (Object)null)
			{
				throw new ArgumentException(string.Format("No instance of '{0}' was found for '{1}'.", "FullQuestBase", wish));
			}
			return ((Object)((BasicQuestBase)wishItem).QuestType).name switch
			{
				"Wayfarer" => WishType.Wayfarer, 
				"Gather" => WishType.Gather, 
				"Hunt" => WishType.Hunt, 
				"Grand Hunt" => WishType.GrandHunt, 
				"Donate" => WishType.Donate, 
				"Courier" => WishType.Delivery, 
				"Journal" => WishType.Unique, 
				"Sprint" => WishType.Unique, 
				"Herald" => WishType.Unique, 
				"Steel Sentinel" => WishType.Unique, 
				_ => throw new InvalidCheckException<Wish>(wish), 
			};
		}

		public static bool HasCompletedWish(this PlayerData data, Wish wish)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			Completion? wishData = data.GetWishData(wish);
			if (!wishData.HasValue)
			{
				return false;
			}
			return wishData.Value.IsCompleted;
		}
	}
}
namespace Silksong.BingoSync.Exceptions
{
	public class InvalidCheckException<T> : InvalidOperationException
	{
		private const string MESSAGE = "No {0} check is implemented for the value '{1}'.";

		public InvalidCheckException(T data)
			: base($"No {typeof(T)} check is implemented for the value '{data}'.")
		{
		}
	}
}
namespace Silksong.BingoSync.Data
{
	[JsonConverter(typeof(StringEnumConverter))]
	public enum AncestralArt
	{
		[EnumMember(Value = "swift_step")]
		SwiftStep,
		[EnumMember(Value = "cling_grip")]
		ClingGrip,
		[EnumMember(Value = "needolin")]
		Needolin,
		[EnumMember(Value = "clawline")]
		Clawline,
		[EnumMember(Value = "silk_soar")]
		SilkSoar,
		[EnumMember(Value = "sylphsong")]
		Sylphsong
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Area
	{
		[EnumMember(Value = "the_abyss")]
		TheAbyss,
		[EnumMember(Value = "bellhart")]
		Bellhart,
		[EnumMember(Value = "bilewater")]
		Bilewater,
		[EnumMember(Value = "blasted_steps")]
		BlastedSteps,
		[EnumMember(Value = "bone_bottom")]
		BoneBottom,
		[EnumMember(Value = "the_cradle")]
		TheCradle,
		[EnumMember(Value = "deep_docks")]
		DeepDocks,
		[EnumMember(Value = "far_fields")]
		FarFields,
		[EnumMember(Value = "greymoor")]
		Greymoor,
		[EnumMember(Value = "hunters_march")]
		HuntersMarch,
		[EnumMember(Value = "the_marrow")]
		TheMarrow,
		[EnumMember(Value = "the_mist")]
		TheMist,
		[EnumMember(Value = "moss_grotto")]
		MossGrotto,
		[EnumMember(Value = "mount_fay")]
		MountFay,
		[EnumMember(Value = "putrified_ducts")]
		PutrifiedDucts,
		[EnumMember(Value = "red_memory")]
		RedMemory,
		[EnumMember(Value = "sands_of_karak")]
		SandsOfKarak,
		[EnumMember(Value = "shellwood")]
		Shellwood,
		[EnumMember(Value = "sinners_road")]
		SinnersRoad,
		[EnumMember(Value = "the_slab")]
		TheSlab,
		[EnumMember(Value = "underworks")]
		Underworks,
		[EnumMember(Value = "verdania")]
		Verdania,
		[EnumMember(Value = "weavenest_atla")]
		WeavenestAtla,
		[EnumMember(Value = "wisp_thicket")]
		WispThicket,
		[EnumMember(Value = "wormways")]
		Wormways,
		[EnumMember(Value = "choral_chambers")]
		ChoralChambers,
		[EnumMember(Value = "cogwork_core")]
		CogworkCore,
		[EnumMember(Value = "grand_gate")]
		GrandGate,
		[EnumMember(Value = "high_halls")]
		HighHalls,
		[EnumMember(Value = "memorium")]
		Memorium,
		[EnumMember(Value = "whispering_vaults")]
		WhisperingVaults,
		[EnumMember(Value = "whiteward")]
		Whiteward
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Boss
	{
		[EnumMember(Value = "bell_beast")]
		BellBeast,
		[EnumMember(Value = "fourth_chorus")]
		FourthChorus,
		[EnumMember(Value = "great_conchflies")]
		GreatConchflies,
		[EnumMember(Value = "lace_1")]
		Lace1,
		[EnumMember(Value = "last_judge")]
		LastJudge,
		[EnumMember(Value = "moorwing")]
		Moorwing,
		[EnumMember(Value = "moss_mother")]
		MossMother,
		[EnumMember(Value = "moss_mothers")]
		MossMothers,
		[EnumMember(Value = "phantom")]
		Phantom,
		[EnumMember(Value = "savage_beastfly_1")]
		SavageBeastfly1,
		[EnumMember(Value = "sister_splinter")]
		SisterSplinter,
		[EnumMember(Value = "skull_tyrant_1")]
		SkullTyrant1,
		[EnumMember(Value = "skull_tyrant_2")]
		SkullTyrant2,
		[EnumMember(Value = "widow")]
		Widow,
		[EnumMember(Value = "broodmother")]
		Broodmother,
		[EnumMember(Value = "cogwork_dancers")]
		CogworkDancers,
		[EnumMember(Value = "disgraced_chef_lugoli")]
		DisgracedChefLugoli,
		[EnumMember(Value = "father_of_the_flame")]
		FatherOfTheFlame,
		[EnumMember(Value = "first_sinner")]
		FirstSinner,
		[EnumMember(Value = "forebrothers")]
		Forebrothers,
		[EnumMember(Value = "garmond")]
		Garmond,
		[EnumMember(Value = "grand_mother_silk")]
		GrandMotherSilk,
		[EnumMember(Value = "groal_the_great")]
		Groal,
		[EnumMember(Value = "lace_2")]
		Lace2,
		[EnumMember(Value = "raging_conchfly")]
		RagingConchfly,
		[EnumMember(Value = "savage_beastfly_2")]
		SavageBeastfly2,
		[EnumMember(Value = "second_sentinel")]
		SecondSentinel,
		[EnumMember(Value = "shakra")]
		Shakra,
		[EnumMember(Value = "the_unravelled")]
		TheUnravelled,
		[EnumMember(Value = "trobbio")]
		Trobbio,
		[EnumMember(Value = "voltvyrm")]
		Voltvyrm,
		[EnumMember(Value = "bell_eater")]
		BellEater,
		[EnumMember(Value = "clover_dancers")]
		CloverDancers,
		[EnumMember(Value = "crawfather")]
		Crawfather,
		[EnumMember(Value = "crust_king_khann")]
		CrustKingKhann,
		[EnumMember(Value = "gurr_the_outcast")]
		GurrTheOutcast,
		[EnumMember(Value = "lost_garmond")]
		LostGarmond,
		[EnumMember(Value = "lost_lace")]
		LostLace,
		[EnumMember(Value = "nyleth")]
		Nyleth,
		[EnumMember(Value = "palestag")]
		Palestag,
		[EnumMember(Value = "pinstress")]
		Pinstress,
		[EnumMember(Value = "plasmified_zango")]
		PlasmifiedZango,
		[EnumMember(Value = "shrine_guardian_seth")]
		ShrineGuardianSeth,
		[EnumMember(Value = "skarrsinger_karmelita")]
		SkarrsingerKarmelita,
		[EnumMember(Value = "tormented_trobbio")]
		TormentedTrobbio,
		[EnumMember(Value = "watcher_at_the_edge")]
		Watcher
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Crest
	{
		[EnumMember(Value = "hunter")]
		Hunter,
		[EnumMember(Value = "hunter_evolved")]
		HunterEvolved,
		[EnumMember(Value = "hunter_fully_evolved")]
		HunterFullyEvolved,
		[EnumMember(Value = "reaper")]
		Reaper,
		[EnumMember(Value = "wanderer")]
		Wanderer,
		[EnumMember(Value = "beast")]
		Beast,
		[EnumMember(Value = "cursed")]
		Cursed,
		[EnumMember(Value = "witch")]
		Witch,
		[EnumMember(Value = "architect")]
		Architect,
		[EnumMember(Value = "shaman")]
		Shaman,
		[EnumMember(Value = "cloakless")]
		Cloakless
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Ending
	{
		[EnumMember(Value = "weaver_queen")]
		WeaverQueen,
		[EnumMember(Value = "snared_silk")]
		SnaredSilk,
		[EnumMember(Value = "twisted_child")]
		TwistedChild,
		[EnumMember(Value = "sister_of_the_void")]
		SisterOfTheVoid,
		[EnumMember(Value = "passing_of_the_age")]
		PassingOfTheAge
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Flea
	{
		[EnumMember(Value = "above_marrow_bellways")]
		AboveMarrowBellways,
		[EnumMember(Value = "behind_deep_docks_bellways")]
		BehindDeepDocksBellways,
		[EnumMember(Value = "left_of_swift_step")]
		LeftOfSwiftStep,
		[EnumMember(Value = "behind_deep_docks_furnace_gauntlet")]
		BehindDeepDocksFurnaceGauntlet,
		[EnumMember(Value = "behind_skarrgard")]
		BehindSkarrgard,
		[EnumMember(Value = "behind_hunter_booby_trap")]
		BehindHunterBoobyTrap,
		[EnumMember(Value = "next_to_pilgrims_rest")]
		NextToPilgrimsRest,
		[EnumMember(Value = "carried_by_aknid")]
		CarriedByAknid,
		[EnumMember(Value = "above_craw_lake")]
		AboveCrawLake,
		[EnumMember(Value = "top_of_greymoor_left_tower")]
		TopOfGreymoorLeftTower,
		[EnumMember(Value = "kratt")]
		Kratt,
		[EnumMember(Value = "above_bellhart")]
		AboveBellhart,
		[EnumMember(Value = "in_gahlia_pit")]
		InGahliaPit,
		[EnumMember(Value = "above_grindle")]
		AboveGrindle,
		[EnumMember(Value = "trapped_in_sinners_road")]
		TrappedInSinnersRoad,
		[EnumMember(Value = "guarded_by_snitchflies")]
		GuardedBySnitchflies,
		[EnumMember(Value = "beside_exhaust_organ")]
		BesideExhaustOrgan,
		[EnumMember(Value = "above_secret_bilewater_bench")]
		AboveSecretBilewaterBench,
		[EnumMember(Value = "after_wisp_thicket")]
		AfterWispThicket,
		[EnumMember(Value = "across_cogwork_haulers_room")]
		AcrossCogworkHaulersRoom,
		[EnumMember(Value = "after_choral_chambers_platforming")]
		AfterChoralChambersPlatforming,
		[EnumMember(Value = "after_vertical_sawblades_room")]
		AfterVerticalSawbladesRoom,
		[EnumMember(Value = "huge_flea")]
		HugeFlea,
		[EnumMember(Value = "jailed_in_slab")]
		JailedInSlab,
		[EnumMember(Value = "above_slab_bench")]
		AboveSlabBench,
		[EnumMember(Value = "frozen_in_ice")]
		FrozenInIce,
		[EnumMember(Value = "under_voltnest")]
		UnderVoltnest,
		[EnumMember(Value = "vog")]
		Vog,
		[EnumMember(Value = "right_of_songclave")]
		RightOfSongclave,
		[EnumMember(Value = "right_of_box_puzzle")]
		RightOfBoxPuzzle
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Memento
	{
		[EnumMember(Value = "sprintmaster")]
		Sprintmaster,
		[EnumMember(Value = "guardian")]
		Guardian,
		[EnumMember(Value = "hero")]
		Hero,
		[EnumMember(Value = "hunter")]
		Hunter,
		[EnumMember(Value = "grey")]
		Grey,
		[EnumMember(Value = "surface")]
		Surface,
		[EnumMember(Value = "craw")]
		Craw,
		[EnumMember(Value = "encrusted_heart")]
		EncrustedHeart,
		[EnumMember(Value = "pollen_heart")]
		PollenHeart,
		[EnumMember(Value = "hunter_heart")]
		HunterHeart,
		[EnumMember(Value = "conjoined_heart")]
		ConjoinedHeart
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Needle
	{
		[EnumMember(Value = "needle")]
		Needle,
		[EnumMember(Value = "sharpened_needle")]
		SharpenedNeedle,
		[EnumMember(Value = "shining_needle")]
		ShiningNeedle,
		[EnumMember(Value = "hivesteel_needle")]
		HivesteelNeedle,
		[EnumMember(Value = "pale_steel_needle")]
		PaleSteelNeedle
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Quill
	{
		[EnumMember(Value = "white")]
		White,
		[EnumMember(Value = "red")]
		Red,
		[EnumMember(Value = "purple")]
		Purple
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum SilkSkill
	{
		[EnumMember(Value = "silkspear")]
		Silkspear,
		[EnumMember(Value = "thread_storm")]
		ThreadStorm,
		[EnumMember(Value = "cross_stitch")]
		CrossStitch,
		[EnumMember(Value = "sharpdart")]
		Sharpdart,
		[EnumMember(Value = "rune_rage")]
		RuneRage,
		[EnumMember(Value = "pale_nails")]
		PaleNails
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Tool
	{
		[EnumMember(Value = "straight_pin")]
		StraightPin,
		[EnumMember(Value = "threefold_pin")]
		ThreefoldPin,
		[EnumMember(Value = "sting_shard")]
		StingShard,
		[EnumMember(Value = "tacks")]
		Tacks,
		[EnumMember(Value = "longpin")]
		Longpin,
		[EnumMember(Value = "curveclaw")]
		Curveclaw,
		[EnumMember(Value = "curvesickle")]
		Curvesickle,
		[EnumMember(Value = "throwing_ring")]
		ThrowingRing,
		[EnumMember(Value = "pimpillo")]
		Pimpillo,
		[EnumMember(Value = "conchcutter")]
		Conchcutter,
		[EnumMember(Value = "weaver_silkshot")]
		WeaverSilkshot,
		[EnumMember(Value = "architect_silkshot")]
		ArchitectSilkshot,
		[EnumMember(Value = "forge_silkshot")]
		ForgeSilkshot,
		[EnumMember(Value = "delvers_drill")]
		DelversDrill,
		[EnumMember(Value = "cogwork_wheel")]
		CogworkWheel,
		[EnumMember(Value = "cogfly")]
		Cogfly,
		[EnumMember(Value = "rosary_cannon")]
		RosaryCannon,
		[EnumMember(Value = "voltvessels")]
		Voltvessels,
		[EnumMember(Value = "flintslate")]
		Flintslate,
		[EnumMember(Value = "snare_setter")]
		SnareSetter,
		[EnumMember(Value = "flea_brew")]
		FleaBrew,
		[EnumMember(Value = "plasmium_phial")]
		PlasmiumPhial,
		[EnumMember(Value = "needle_phial")]
		NeedlePhial,
		[EnumMember(Value = "druids_eye")]
		DruidsEye,
		[EnumMember(Value = "druids_eyes")]
		DruidsEyes,
		[EnumMember(Value = "magma_bell")]
		MagmaBell,
		[EnumMember(Value = "warding_bell")]
		WardingBell,
		[EnumMember(Value = "pollip_pouch")]
		PollipPouch,
		[EnumMember(Value = "fractured_mask")]
		FracturedMask,
		[EnumMember(Value = "multibinder")]
		Multibinder,
		[EnumMember(Value = "weavelight")]
		Weavelight,
		[EnumMember(Value = "sawtooth_circlet")]
		SawtoothCirclet,
		[EnumMember(Value = "injector_band")]
		InjectorBand,
		[EnumMember(Value = "spool_extender")]
		SpoolExtender,
		[EnumMember(Value = "reserve_bind")]
		ReserveBind,
		[EnumMember(Value = "claw_mirror")]
		ClawMirror,
		[EnumMember(Value = "claw_mirrors")]
		ClawMirrors,
		[EnumMember(Value = "memory_crystal")]
		MemoryCrystal,
		[EnumMember(Value = "snitch_pick")]
		SnitchPick,
		[EnumMember(Value = "volt_filament")]
		VoltFilament,
		[EnumMember(Value = "quick_sling")]
		QuickSling,
		[EnumMember(Value = "wreath_of_purity")]
		WreathOfPurity,
		[EnumMember(Value = "longclaw")]
		Longclaw,
		[EnumMember(Value = "wispfire_lantern")]
		WispfireLantern,
		[EnumMember(Value = "egg_of_flealia")]
		EggOfFlealia,
		[EnumMember(Value = "pin_badge")]
		PinBadge,
		[EnumMember(Value = "compass")]
		Compass,
		[EnumMember(Value = "shard_pendant")]
		ShardPendant,
		[EnumMember(Value = "magnetite_brooch")]
		MagnetiteBrooch,
		[EnumMember(Value = "weighted_belt")]
		WeightedBelt,
		[EnumMember(Value = "barbed_bracelet")]
		BarbedBracelet,
		[EnumMember(Value = "dead_bugs_purse")]
		DeadBugsPurse,
		[EnumMember(Value = "shell_satchel")]
		ShellSatchel,
		[EnumMember(Value = "magnetite_dice")]
		MagnetiteDice,
		[EnumMember(Value = "scuttlebrace")]
		Scuttlebrace,
		[EnumMember(Value = "ascendants_grip")]
		AscendantsGrip,
		[EnumMember(Value = "spider_strings")]
		SpiderStrings,
		[EnumMember(Value = "silkspeed_anklets")]
		SilkspeedAnklets,
		[EnumMember(Value = "thiefs_mark")]
		ThiefsMark
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum ToolType
	{
		[EnumMember(Value = "red")]
		Red,
		[EnumMember(Value = "blue")]
		Blue,
		[EnumMember(Value = "yellow")]
		Yellow
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum VentricaStation
	{
		[EnumMember(Value = "memorium")]
		Memorium,
		[EnumMember(Value = "high_halls")]
		HighHalls,
		[EnumMember(Value = "first_shrine")]
		FirstShrine,
		[EnumMember(Value = "choral_chambers")]
		ChoralChambers,
		[EnumMember(Value = "grand_bellway")]
		GrandBellway,
		[EnumMember(Value = "underworks")]
		Underworks
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Vesticrest
	{
		[EnumMember(Value = "basic")]
		Basic,
		[EnumMember(Value = "upgraded")]
		Upgraded
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum Wish
	{
		[EnumMember(Value = "the_lost_fleas")]
		TheLostFleas,
		[EnumMember(Value = "pinmasters_oil")]
		PinmastersOil,
		[EnumMember(Value = "my_missing_courier")]
		MyMissingCourier,
		[EnumMember(Value = "my_missing_brother")]
		MyMissingBrother,
		[EnumMember(Value = "balm_for_the_wounded")]
		BalmForTheWounded,
		[EnumMember(Value = "the_wandering_merchant")]
		TheWanderingMerchant,
		[EnumMember(Value = "the_lost_merchant")]
		TheLostMerchant,
		[EnumMember(Value = "rite_of_rebirth")]
		RiteOfRebirth,
		[EnumMember(Value = "infestation_operation")]
		InfestationOperation,
		[EnumMember(Value = "trails_end")]
		TrailsEnd,
		[EnumMember(Value = "final_audience")]
		FinalAudience,
		[EnumMember(Value = "silk_and_soul")]
		SilkAndSoul,
		[EnumMember(Value = "fatal_resolve")]
		FatalResolve,
		[EnumMember(Value = "pain_anguish_and_misery")]
		PainAnguishAndMisery,
		[EnumMember(Value = "heros_call")]
		HerosCall,
		[EnumMember(Value = "ecstasy_of_the_end")]
		EcstasyOfTheEnd,
		[EnumMember(Value = "berry_picking")]
		BerryPicking,
		[EnumMember(Value = "rite_of_the_pollip")]
		RiteOfThePollip,
		[EnumMember(Value = "silver_bells")]
		SilverBells,
		[EnumMember(Value = "alchemists_assistant")]
		AlchemistsAssistant,
		[EnumMember(Value = "great_taste_of_pharloom")]
		GreatTasteOfPharloom,
		[EnumMember(Value = "advanced_alchemy")]
		AdvancedAlchemy,
		[EnumMember(Value = "garb_of_the_pilgrims")]
		GarbOfThePilgrims,
		[EnumMember(Value = "flexile_spines")]
		FlexileSpines,
		[EnumMember(Value = "volatile_flintbeetles")]
		VolatileFlintbeetles,
		[EnumMember(Value = "crawbug_clearing")]
		CrawbugClearing,
		[EnumMember(Value = "roach_guts")]
		RoachGuts,
		[EnumMember(Value = "fine_pins")]
		FinePins,
		[EnumMember(Value = "cloaks_of_the_choir")]
		CloaksOfTheChoir,
		[EnumMember(Value = "broodfeast")]
		Broodfeast,
		[EnumMember(Value = "runtfeast")]
		Runtfeast,
		[EnumMember(Value = "dark_hearts")]
		DarkHearts,
		[EnumMember(Value = "the_terrible_tyrant")]
		TheTerribleTyrant,
		[EnumMember(Value = "savage_beastfly")]
		SavageBeastfly,
		[EnumMember(Value = "the_wailing_mother")]
		TheWailingMother,
		[EnumMember(Value = "the_hidden_hunter")]
		TheHiddenHunter,
		[EnumMember(Value = "bone_bottom_repairs")]
		BoneBottomRepairs,
		[EnumMember(Value = "a_lifesaving_bridge")]
		ALifesavingBridge,
		[EnumMember(Value = "restoration_of_bellhart")]
		RestorationOfBellhart,
		[EnumMember(Value = "an_icon_of_hope")]
		AnIconOfHope,
		[EnumMember(Value = "bellharts_glory")]
		BellhartsGlory,
		[EnumMember(Value = "building_up_songclave")]
		BuildingUpSongclave,
		[EnumMember(Value = "strengthening_songclave")]
		StrengtheningSongclave,
		[EnumMember(Value = "bone_bottom_supplies")]
		BoneBottomSupplies,
		[EnumMember(Value = "pilgrims_rest_supplies")]
		PilgrimsRestSupplies,
		[EnumMember(Value = "queens_egg")]
		QueensEgg,
		[EnumMember(Value = "songclave_supplies")]
		SongclaveSupplies,
		[EnumMember(Value = "fleatopia_supplies")]
		FleatopiaSupplies,
		[EnumMember(Value = "liquid_lacquer")]
		LiquidLacquer,
		[EnumMember(Value = "survivors_camp_supplies")]
		SurvivorsCampSupplies,
		[EnumMember(Value = "bugs_of_pharloom")]
		BugsOfPharloom,
		[EnumMember(Value = "fastest_in_pharloom")]
		FastestInPharloom,
		[EnumMember(Value = "passing_of_the_age")]
		PassingOfTheAge,
		[EnumMember(Value = "a_vassal_lost")]
		AVassalLost
	}
	[JsonConverter(typeof(StringEnumConverter))]
	public enum WishType
	{
		[EnumMember(Value = "wayfarer")]
		Wayfarer,
		[EnumMember(Value = "gather")]
		Gather,
		[EnumMember(Value = "hunt")]
		Hunt,
		[EnumMember(Value = "grand_hunt")]
		GrandHunt,
		[EnumMember(Value = "donate")]
		Donate,
		[EnumMember(Value = "delivery")]
		Delivery,
		[EnumMember(Value = "unique")]
		Unique
	}
}
namespace Silksong.BingoSync.Configurations
{
	internal class AccessibilityConfig
	{
		public enum TextFont
		{
			Normal,
			Bold,
			Arial,
			Default
		}

		public enum ElementPosition
		{
			TopLeft,
			TopRight,
			BottomLeft,
			BottomRight
		}

		public enum ElementScale
		{
			VerySmall,
			Small,
			Normal,
			Large,
			VeryLarge
		}

		private const string SECTION = "Accessibility";

		public readonly ConfigEntry<TextFont> BoardCellFont;

		public readonly ConfigEntry<ElementPosition> BoardPosition;

		public readonly ConfigEntry<ElementScale> BoardScale;

		public readonly ConfigEntry<int> BoardOpacity;

		public AccessibilityConfig(ConfigFile cfg)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			BoardCellFont = cfg.Bind<TextFont>("Accessibility", "BoardCellFont", TextFont.Normal, "Defines what font to use for the board cells");
			BoardPosition = cfg.Bind<ElementPosition>("Accessibility", "BoardPosition", ElementPosition.TopRight, "Defines where the board is located on the screen");
			BoardScale = cfg.Bind<ElementScale>("Accessibility", "BoardScale", ElementScale.Normal, "Defines the scale of the board");
			BoardOpacity = cfg.Bind<int>("Accessibility", "BoardOpacity", 100, new ConfigDescription("Defines the opacity of the board", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
		}
	}
	internal class BoardConfig
	{
		private const string SECTION = "Board";

		public readonly ConfigEntry<KeyCode> ToggleUI;

		public BoardConfig(ConfigFile cfg)
		{
			ToggleUI = cfg.Bind<KeyCode>("Board", "ToggleBoard", (KeyCode)98, "Defines the keybind to toggle the board");
		}
	}
	internal class Configuration
	{
		public readonly GeneralConfig General;

		public readonly BoardConfig Board;

		public readonly JoinConfig Join;

		public readonly ExperimentalConfig Experimental;

		public readonly AccessibilityConfig Accessibility;

		public static Configuration? Instance { get; private set; }

		public static Configuration SafeInstance
		{
			get
			{
				if (Instance == null)
				{
					throw new InvalidOperationException("Tried to access 'Configuration' before it was loaded.");
				}
				return Instance;
			}
		}

		private Configuration(ConfigFile cfg)
		{
			General = new GeneralConfig(cfg);
			Board = new BoardConfig(cfg);
			Join = new JoinConfig(cfg);
			Experimental = new ExperimentalConfig(cfg);
			Accessibility = new AccessibilityConfig(cfg);
		}

		public static void Load(ConfigFile cfg)
		{
			Instance = new Configuration(cfg);
		}
	}
	internal class ExperimentalConfig
	{
		private const string SECTION = "Experimental";

		public readonly ConfigEntry<bool> EvaluateOnHeroUpdate;

		public ExperimentalConfig(ConfigFile cfg)
		{
			EvaluateOnHeroUpdate = cfg.Bind<bool>("Experimental", "evaluateOnHeroUpdate", false, "Defines if the goals should be checked on each frame the player is loaded");
		}
	}
	internal class GeneralConfig
	{
		private const string SECTION = "General";

		public readonly ConfigEntry<bool> UseAdvancedTeams;

		public GeneralConfig(ConfigFile cfg)
		{
			UseAdvancedTeams = cfg.Bind<bool>("General", "AddMoreTeams", false, "Defines if 4 extra teams are added upon loading");
		}
	}
	internal class JoinConfig
	{
		private const string SECTION = "Join";

		public readonly ConfigEntry<string> Nickname;

		public readonly ConfigEntry<string> Code;

		public readonly ConfigEntry<string> Password;

		public readonly ConfigEntry<KeyCode> ToggleUI;

		public JoinConfig(ConfigFile cfg)
		{
			Nickname = cfg.Bind<string>("Join", "DefaultNickname", "", "Defines the default nickname in the join panel");
			Code = cfg.Bind<string>("Join", "DefaultCode", "", "Defines the default code in the join panel");
			Password = cfg.Bind<string>("Join", "DefaultPassword", "", "Defines the default password in the join panel");
			ToggleUI = cfg.Bind<KeyCode>("Join", "ToggleJoinUI", (KeyCode)104, "Defines the keybind to toggle the join panel");
		}
	}
}
namespace Silksong.BingoSync.Conditions
{
	[Condition("has_completed_ending")]
	internal sealed class HasCompletedEndingCondition : ICondition
	{
		[JsonProperty("ending")]
		[JsonRequired]
		[Description("Name of the ending to complete")]
		public required Ending Ending { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasCompletedEnding(Ending);
		}
	}
	[Condition("has_completed_wish")]
	internal class HasCompletedWishCondition : ICondition
	{
		[JsonProperty("wish")]
		[JsonRequired]
		[Description("Name of the wish to complete")]
		public required Wish Wish { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasCompletedWish(Wish);
		}
	}
	[Condition("has_deposited_memento")]
	internal sealed class HasDepositedMementoCondition : ICondition
	{
		[JsonProperty("memento")]
		[JsonRequired]
		[Description("Name of the memento to deposit")]
		public required Memento Memento { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasDepositedMemento(Memento);
		}
	}
	[Condition("has_found_flea")]
	internal sealed class HasFoundFleaCondition : ICondition
	{
		[JsonProperty("flea")]
		[JsonRequired]
		[Description("Name of the flea to find")]
		public required Flea Flea { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasFoundFlea(Flea);
		}
	}
	[Condition("has_killed_boss")]
	internal sealed class HasKilledBossCondition : ICondition
	{
		[JsonProperty("boss")]
		[JsonRequired]
		[Description("Name of the boss to kill")]
		public required Boss Boss { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasKilledBoss(Boss);
		}
	}
	[Condition("has_obtained_ancestral_art")]
	internal sealed class HasObtainedAncestralArt : ICondition
	{
		[JsonProperty("art")]
		[JsonRequired]
		[Description("Name of the ancestral art to obtain")]
		public required AncestralArt Art { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedAncestralArt(Art);
		}
	}
	[Condition("has_obtained_crest")]
	internal sealed class HasObtainedCrestCondition : ICondition
	{
		[JsonProperty("crest")]
		[JsonRequired]
		[Description("Name of the crest to obtain")]
		public required Crest Crest { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedCrest(Crest);
		}
	}
	[Condition("has_obtained_map")]
	internal sealed class HasObtainedMapCondition : ICondition
	{
		[JsonProperty("area")]
		[JsonRequired]
		[Description("Name of the area for which to obtain the map")]
		public required Area Area { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedMap(Area);
		}
	}
	[Condition("has_obtained_memento")]
	internal sealed class HasObtainedMementoCondition : ICondition
	{
		[JsonProperty("memento")]
		[JsonRequired]
		[Description("Name of the memento to obtain")]
		public required Memento Memento { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedMemento(Memento);
		}
	}
	[Condition("has_obtained_needle")]
	internal sealed class HasObtainedNeedleCondition : ICondition
	{
		[JsonProperty("needle")]
		[JsonRequired]
		[Description("Name of the needle to obtain")]
		public required Needle Needle { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedNeedle(Needle);
		}
	}
	[Condition("has_obtained_quill")]
	internal sealed class HasObtainedQuillCondition : ICondition
	{
		[JsonProperty("quill")]
		[JsonRequired]
		[Description("Name of the quill to obtain")]
		public required Quill Quill { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedQuill(Quill);
		}
	}
	[Condition("has_obtained_silk_skill")]
	internal sealed class HasObtainedSilkSkillCondition : ICondition
	{
		[JsonProperty("skill")]
		[JsonRequired]
		[Description("Name of the silk skill to obtain")]
		public required SilkSkill Skill { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedSilkSkill(Skill);
		}
	}
	[Condition("has_obtained_tool")]
	internal sealed class HasObtainedToolCondition : ICondition
	{
		[JsonProperty("tool")]
		[JsonRequired]
		[Description("Name of the tool to obtain")]
		public required Tool Tool { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedTool(Tool);
		}
	}
	[Condition("has_obtained_vesticrest")]
	internal sealed class HasObtainedVesticrestCondition : ICondition
	{
		[JsonProperty("vesticrest")]
		[JsonRequired]
		[Description("Name of the vesticrest to obtain")]
		public required Vesticrest Vesticrest { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedVesticrest(Vesticrest);
		}
	}
	[Condition("has_unlocked_ventrica_station")]
	internal sealed class HasUnlockedVentricaStationCondition : ICondition
	{
		[JsonProperty("station")]
		[JsonRequired]
		[Description("Name of the Ventrica station to unlock")]
		public required VentricaStation Station { get; init; }

		public bool IsMet()
		{
			return PlayerData.instance.HasUnlockedStation(Station);
		}
	}
}