using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
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.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.Configurations;
using Silksong.BingoSync.Data;
using Silksong.BingoSync.Exceptions;
using Silksong.BingoSync.Extensions;
using Silksong.BingoSync.Helpers;
using Silksong.BingoSync.Patches;
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.1.0")]
[assembly: AssemblyInformationalVersion("1.2.1+ba48522cc26b3a1d273431498be59bf018289fee")]
[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 Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	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")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
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 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			Events = new EventDispatcher();
			SubscribeToEvents(Events);
			_tracker = new GoalTracker();
			_tracker.OnGoalMarked += new GoalChangedCallback(OnGoalMarked);
			_tracker.OnGoalCleared += new GoalChangedCallback(OnGoalCleared);
			_session = new Session(Events);
		}

		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_0017: Unknown result type (might be due to invalid IL or missing references)
			Card? card = _card;
			if (card != null)
			{
				card.Mark(square.Slot.Index, team);
			}
			this.OnCardUpdated?.Invoke(_card);
		}

		private void OnSquareCleared(Player player, Square square, Team team)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Card? card = _card;
			if (card != null)
			{
				card.Unmark(square.Slot.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);
			_session.Dispose();
		}
	}
	internal static class ConfigMenu
	{
		public static AbstractMenuScreen Create(Configuration configuration)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			AbstractMenuScreen[] array = (AbstractMenuScreen[])(object)new AbstractMenuScreen[4]
			{
				CreateGeneralConfig(configuration.General),
				CreateJoinConfig(configuration.Join),
				CreateBoardConfig(configuration.Board),
				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.GenerateKeyCodeElement((ConfigEntryBase)(object)config.ToggleUI, ref val3))
			{
				val.Add(val3);
			}
			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();
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("dev.warpersan.silksong.bingosync", "Silksong.BingoSync", "1.2.1")]
	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.1";

		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()
		{
			ConditionAttribute.AddAll();
			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));
			Controller.Pool = val;
			Log.Info($"Loaded '{val.Count}' goals.");
		}
	}
}
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);
			}
		}

		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 = "OwO";
			val12.alignment = (TextAnchor)3;
			((Graphic)val12).color = Color.white;
			val12.font = Fonts.Normal;
			bingoCell._text = val12;
			bingoCell._teamMarks = dictionary;
			return bingoCell;
		}
	}
	internal class TeamPickerButton : MonoBehaviour
	{
		private Outline? _outline;

		private Action<Team>? _onClick;

		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)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_outline != (Object)null)
			{
				((Shadow)_outline).effectColor = Team.GetColor();
			}
		}

		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_002e: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0071: 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_008e: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: 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;
			Image val2 = val.AddComponent<Image>();
			Color black = Color.black;
			black.a = 0.6f;
			((Graphic)val2).color = black;
			Button val3 = val.AddComponent<Button>();
			((Selectable)val3).targetGraphic = (Graphic)(object)val2;
			((UnityEvent)val3.onClick).AddListener(new UnityAction(teamPickerButton.OnClick));
			ColorBlock colors = ((Selectable)val3).colors;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.3f, 0.3f, 0.3f, 1f);
			((Selectable)val3).colors = colors;
			Outline outline = ((Component)val3).gameObject.AddComponent<Outline>();
			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 = Vector2.zero;
			val5.offsetMax = Vector2.zero;
			Text val6 = val4.AddComponent<Text>();
			val6.font = Fonts.Normal;
			val6.fontSize = 17;
			((Graphic)val6).color = Color.white;
			val6.alignment = (TextAnchor)4;
			val6.text = team.GetDisplayName();
			teamPickerButton._outline = outline;
			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_0017: Unknown result type (might be due to invalid IL or missing references)
			BingoCell[]? cells = _cells;
			if (cells != null)
			{
				cells[square.Slot.Index].AddTeam(team);
			}
		}

		private void OnSquareCleared(Player player, Square square, Team team)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			BingoCell[]? cells = _cells;
			if (cells != null)
			{
				cells[square.Slot.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_0050: 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_0076: 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_00a4: 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;
			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;
			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 Lazy<(Font? Bold, Font? Normal)> TrajanFonts = new Lazy<(Font, Font)>(delegate
		{
			Font item = null;
			Font item2 = null;
			Font[] array = Resources.FindObjectsOfTypeAll<Font>();
			foreach (Font val in array)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = ((Object)val).name;
					if (!(name == "TrajanPro-Bold"))
					{
						if (name == "TrajanPro-Regular")
						{
							item2 = val;
						}
					}
					else
					{
						item = val;
					}
				}
			}
			return (Bold: item, Normal: item2);
		});

		public static Font? Normal => TrajanFonts.Value.Normal;

		public static Font? Bold => TrajanFonts.Value.Bold;
	}
}
namespace Silksong.BingoSync.UI.Components
{
	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.Patches
{
	[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_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_00b8: 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);
			JoinRoomSettings settings = new JoinRoomSettings
			{
				Nickname = (Configuration.Instance?.Join.Nickname.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.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));
			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.Extensions
{
	public static class PlayerDataExtensions
	{
		public static bool HasAncestralArt(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 IsBossKilled(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.IsEndingCompleted(Ending.WeaverQueen) || data.IsEndingCompleted(Ending.SnaredSilk) || data.IsEndingCompleted(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.IsEndingCompleted(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 HasCrest(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 IsEndingCompleted(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), 
			};
		}

		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 HasMemento(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 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 HasSilkSkill(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);
		}

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

		public static bool HasVesticrest(this PlayerData data, Vesticrest vesticrest)
		{
			return vesticrest switch
			{
				Vesticrest.Basic => data.UnlockedExtraYellowSlot, 
				Vesticrest.Upgraded => data.UnlockedExtraBlueSlot, 
				_ => throw new InvalidCheckException<Vesticrest>(vesticrest), 
			};
		}
	}
}
namespace Silksong.BingoSync.Exceptions
{
	public class InvalidCheckException<T> : InvalidOperationException
	{
		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 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 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 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 Vesticrest
	{
		[EnumMember(Value = "basic")]
		Basic,
		[EnumMember(Value = "upgraded")]
		Upgraded
	}
}
namespace Silksong.BingoSync.Configurations
{
	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 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);
		}

		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<KeyCode> ToggleUI;

		public JoinConfig(ConfigFile cfg)
		{
			Nickname = cfg.Bind<string>("Join", "DefaultNickname", "", "Defines the default nickname in the join panel");
			ToggleUI = cfg.Bind<KeyCode>("Join", "ToggleJoinUI", (KeyCode)104, "Defines the keybind to toggle the join panel");
		}
	}
}
namespace Silksong.BingoSync.Conditions
{
	internal sealed class HasCompletedEndingCondition : ICondition
	{
		private readonly Ending _ending;

		[Condition("has_completed_ending")]
		public HasCompletedEndingCondition(ConditionData data)
		{
			_ending = data.GetRequiredParameter<Ending>("ending");
		}

		public bool IsMet()
		{
			return PlayerData.instance.IsEndingCompleted(_ending);
		}
	}
	internal sealed class HasDepositedMementoCondition : ICondition
	{
		private readonly Memento _memento;

		[Condition("has_deposited_memento")]
		public HasDepositedMementoCondition(ConditionData data)
		{
			_memento = data.GetRequiredParameter<Memento>("memento");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasDepositedMemento(_memento);
		}
	}
	internal sealed class HasKilledBossCondition : ICondition
	{
		private readonly Boss _boss;

		[Condition("has_killed_boss")]
		public HasKilledBossCondition(ConditionData data)
		{
			_boss = data.GetRequiredParameter<Boss>("boss");
		}

		public bool IsMet()
		{
			return PlayerData.instance.IsBossKilled(_boss);
		}
	}
	internal sealed class HasObtainedAncestralArt : ICondition
	{
		private readonly AncestralArt _art;

		[Condition("has_obtained_ancestral_art")]
		public HasObtainedAncestralArt(ConditionData data)
		{
			_art = data.GetRequiredParameter<AncestralArt>("art");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasAncestralArt(_art);
		}
	}
	internal sealed class HasObtainedCrestCondition : ICondition
	{
		private readonly Crest _crest;

		[Condition("has_obtained_crest")]
		public HasObtainedCrestCondition(ConditionData data)
		{
			_crest = data.GetRequiredParameter<Crest>("crest");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasCrest(_crest);
		}
	}
	internal sealed class HasObtainedMementoCondition : ICondition
	{
		private readonly Memento _memento;

		[Condition("has_obtained_memento")]
		public HasObtainedMementoCondition(ConditionData data)
		{
			_memento = data.GetRequiredParameter<Memento>("memento");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasMemento(_memento);
		}
	}
	internal sealed class HasObtainedNeedleCondition : ICondition
	{
		private readonly Needle _needle;

		[Condition("has_obtained_needle")]
		public HasObtainedNeedleCondition(ConditionData data)
		{
			_needle = data.GetRequiredParameter<Needle>("needle");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasObtainedNeedle(_needle);
		}
	}
	internal sealed class HasObtainedSilkSkillCondition : ICondition
	{
		private readonly SilkSkill _skill;

		[Condition("has_obtained_silk_skill")]
		public HasObtainedSilkSkillCondition(ConditionData data)
		{
			_skill = data.GetRequiredParameter<SilkSkill>("skill");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasSilkSkill(_skill);
		}
	}
	internal sealed class HasObtainedToolCondition : ICondition
	{
		private readonly Tool _tool;

		[Condition("has_obtained_tool")]
		public HasObtainedToolCondition(ConditionData data)
		{
			_tool = data.GetRequiredParameter<Tool>("tool");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasTool(_tool);
		}
	}
	internal sealed class HasObtainedVesticrestCondition : ICondition
	{
		private readonly Vesticrest _vesticrest;

		[Condition("has_obtained_vesticrest")]
		public HasObtainedVesticrestCondition(ConditionData data)
		{
			_vesticrest = data.GetRequiredParameter<Vesticrest>("vesticrest");
		}

		public bool IsMet()
		{
			return PlayerData.instance.HasVesticrest(_vesticrest);
		}
	}
}