using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.Colors;
using Archipelago.MultiClient.Net.Converters;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BreakInfinity;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Linq;
using TMPro;
using Tweens;
using Tweens.Core;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("UnfairFlipsAPMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+eb3f62bafd76662aa1768ee8a65f3bed619ba015")]
[assembly: AssemblyProduct("UnfairFlipsAPMod")]
[assembly: AssemblyTitle("UnfairFlipsAPMod")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public static class Mathy
{
	public static float Decay(float a, float b, float decay, float dt)
	{
		return b + (a - b) * Mathf.Exp((0f - decay) * dt);
	}

	public static Vector3 Decay(Vector3 a, Vector3 b, float decay, float dt)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		return b + (a - b) * Mathf.Exp((0f - decay) * dt);
	}

	public static Vector2 Decay(Vector2 a, Vector2 b, float decay, float dt)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		return b + (a - b) * Mathf.Exp((0f - decay) * dt);
	}

	public static Color Decay(Color a, Color b, float decay, float dt)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0002: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: 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_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		return b + (a - b) * Mathf.Exp((0f - decay) * dt);
	}

	public static float AngleBetween(Vector2 vector1, Vector2 vector2)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: 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_0021: 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_0030: 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)
		return Mathf.Atan2((float)((double)vector1.x * (double)vector2.y - (double)vector2.x * (double)vector1.y), (float)((double)vector1.x * (double)vector2.x + (double)vector1.y * (double)vector2.y)) * (180f / MathF.PI);
	}

	public static string CentsToDollarString(BigDouble totalCents)
	{
		BigDouble bigDouble = (totalCents / 100).Floor();
		BigDouble bigDouble2 = (totalCents - bigDouble * 100).Round();
		return (bigDouble < 10000) ? ("$" + bigDouble.ToString("F0") + "." + bigDouble2.ToString("F0").PadLeft(2, '0')) : ("$" + bigDouble.ToString("G4"));
	}

	public static string CentsToDollarString(int cents)
	{
		string text = (cents / 100).ToString();
		string text2 = (cents % 100).ToString("D2");
		return "$" + text + "." + text2;
	}
}
namespace BreakInfinity
{
	public struct BigDouble : IFormattable, IComparable, IComparable<BigDouble>, IEquatable<BigDouble>
	{
		private static class BigNumber
		{
			public static string FormatBigDouble(BigDouble value, string format, IFormatProvider formatProvider)
			{
				if (IsNaN(value))
				{
					return "NaN";
				}
				if (value.Exponent >= long.MaxValue)
				{
					return (value.Mantissa > 0.0) ? "Infinity" : "-Infinity";
				}
				int digits;
				char c = ParseFormatSpecifier(format, out digits);
				switch (c)
				{
				case 'G':
				case 'R':
					return FormatGeneral(value, digits);
				case 'E':
					return FormatExponential(value, digits);
				case 'F':
					return FormatFixed(value, digits);
				default:
					throw new FormatException($"Unknown string format '{c}'");
				}
			}

			private static char ParseFormatSpecifier(string format, out int digits)
			{
				digits = -1;
				if (string.IsNullOrEmpty(format))
				{
					return 'R';
				}
				int num = 0;
				char c = format[num];
				if ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z'))
				{
					return '\0';
				}
				num++;
				int num2 = -1;
				if (num < format.Length && format[num] >= '0' && format[num] <= '9')
				{
					num2 = format[num++] - 48;
					while (num < format.Length && format[num] >= '0' && format[num] <= '9')
					{
						num2 = num2 * 10 + (format[num++] - 48);
						if (num2 >= 10)
						{
							break;
						}
					}
				}
				if (num < format.Length && format[num] != 0)
				{
					return '\0';
				}
				digits = num2;
				return c;
			}

			private static string FormatGeneral(BigDouble value, int places)
			{
				if (value.Exponent <= -9223372036854775807L || IsZero(value.Mantissa))
				{
					return "0";
				}
				string text = ((places > 0) ? $"G{places}" : "G");
				if (value.Exponent < 21 && value.Exponent > -7)
				{
					return value.ToDouble().ToString(text, CultureInfo.InvariantCulture);
				}
				return value.Mantissa.ToString(text, CultureInfo.InvariantCulture) + "E" + ((value.Exponent >= 0) ? "+" : "") + value.Exponent.ToString(CultureInfo.InvariantCulture);
			}

			private static string ToFixed(double value, int places)
			{
				return value.ToString($"F{places}", CultureInfo.InvariantCulture);
			}

			private static string FormatExponential(BigDouble value, int places)
			{
				if (value.Exponent <= -9223372036854775807L || IsZero(value.Mantissa))
				{
					return "0" + ((places > 0) ? ".".PadRight(places + 1, '0') : "") + "E+0";
				}
				int num = ((places >= 0) ? places : 17) + 1;
				int num2 = (int)Math.Ceiling(Math.Log10(Math.Abs(value.Mantissa)));
				double value2 = Math.Round(value.Mantissa * Math.Pow(10.0, num - num2)) * Math.Pow(10.0, num2 - num);
				string text = ToFixed(value2, Math.Max(num - num2, 0));
				if (text != "0" && places < 0)
				{
					text = text.TrimEnd('0', '.');
				}
				return text + "E" + ((value.Exponent >= 0) ? "+" : "") + value.Exponent;
			}

			private static string FormatFixed(BigDouble value, int places)
			{
				if (places < 0)
				{
					places = 17;
				}
				if (value.Exponent <= -9223372036854775807L || IsZero(value.Mantissa))
				{
					return "0" + ((places > 0) ? ".".PadRight(places + 1, '0') : "");
				}
				if (value.Exponent >= 17)
				{
					return value.Mantissa.ToString(CultureInfo.InvariantCulture).Replace(".", "").PadRight((int)value.Exponent + 1, '0') + ((places > 0) ? ".".PadRight(places + 1, '0') : "");
				}
				return ToFixed(value.ToDouble(), places);
			}
		}

		private static class PowersOf10
		{
			private const long IndexOf0 = 323L;

			private static double[] Powers { get; }

			static PowersOf10()
			{
				Powers = new double[632];
				int num = 0;
				for (int i = 0; i < Powers.Length; i++)
				{
					Powers[num++] = double.Parse("1e" + ((long)i - 323L), CultureInfo.InvariantCulture);
				}
			}

			public static double Lookup(long power)
			{
				return Powers[323 + power];
			}
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct PrivateConstructorArg
		{
		}

		public const double Tolerance = 1E-18;

		private const int MaxSignificantDigits = 17;

		private const long ExpLimit = long.MaxValue;

		private const long DoubleExpMax = 308L;

		private const long DoubleExpMin = -324L;

		private double mantissa;

		private long exponent;

		public static BigDouble Zero = FromMantissaExponentNoNormalize(0.0, 0L);

		public static BigDouble One = FromMantissaExponentNoNormalize(1.0, 0L);

		public static BigDouble NaN = FromMantissaExponentNoNormalize(double.NaN, long.MinValue);

		public static BigDouble PositiveInfinity = FromMantissaExponentNoNormalize(double.PositiveInfinity, 0L);

		public static BigDouble NegativeInfinity = FromMantissaExponentNoNormalize(double.NegativeInfinity, 0L);

		public double Mantissa => mantissa;

		public long Exponent => exponent;

		private BigDouble(double mantissa, long exponent, PrivateConstructorArg _)
		{
			this.mantissa = mantissa;
			this.exponent = exponent;
		}

		public BigDouble(double mantissa, long exponent)
		{
			this = Normalize(mantissa, exponent);
		}

		public BigDouble(BigDouble other)
		{
			mantissa = other.mantissa;
			exponent = other.exponent;
		}

		public BigDouble(double value)
		{
			if (double.IsNaN(value))
			{
				this = NaN;
			}
			else if (double.IsPositiveInfinity(value))
			{
				this = PositiveInfinity;
			}
			else if (double.IsNegativeInfinity(value))
			{
				this = NegativeInfinity;
			}
			else if (IsZero(value))
			{
				this = Zero;
			}
			else
			{
				this = Normalize(value, 0L);
			}
		}

		public static BigDouble Normalize(double mantissa, long exponent)
		{
			if ((mantissa >= 1.0 && mantissa < 10.0) || !IsFinite(mantissa))
			{
				return FromMantissaExponentNoNormalize(mantissa, exponent);
			}
			if (IsZero(mantissa))
			{
				return Zero;
			}
			long num = (long)Math.Floor(Math.Log10(Math.Abs(mantissa)));
			mantissa = ((num != -324) ? (mantissa / PowersOf10.Lookup(num)) : (mantissa * 10.0 / 1E-323));
			return FromMantissaExponentNoNormalize(mantissa, exponent + num);
		}

		public static BigDouble FromMantissaExponentNoNormalize(double mantissa, long exponent)
		{
			return new BigDouble(mantissa, exponent, default(PrivateConstructorArg));
		}

		public static bool IsNaN(BigDouble value)
		{
			return double.IsNaN(value.Mantissa);
		}

		public static bool IsPositiveInfinity(BigDouble value)
		{
			return double.IsPositiveInfinity(value.Mantissa);
		}

		public static bool IsNegativeInfinity(BigDouble value)
		{
			return double.IsNegativeInfinity(value.Mantissa);
		}

		public static bool IsInfinity(BigDouble value)
		{
			return double.IsInfinity(value.Mantissa);
		}

		public static BigDouble Parse(string value)
		{
			if (value.IndexOf('e') != -1)
			{
				string[] array = value.Split('e');
				double num = double.Parse(array[0], CultureInfo.InvariantCulture);
				long num2 = long.Parse(array[1], CultureInfo.InvariantCulture);
				return Normalize(num, num2);
			}
			if (value == "NaN")
			{
				return NaN;
			}
			BigDouble bigDouble = new BigDouble(double.Parse(value, CultureInfo.InvariantCulture));
			if (IsNaN(bigDouble))
			{
				throw new Exception("Invalid argument: " + value);
			}
			return bigDouble;
		}

		public double ToDouble()
		{
			if (IsNaN(this))
			{
				return double.NaN;
			}
			if (Exponent > 308)
			{
				return (Mantissa > 0.0) ? double.PositiveInfinity : double.NegativeInfinity;
			}
			if (Exponent < -324)
			{
				return 0.0;
			}
			if (Exponent == -324)
			{
				return (Mantissa > 0.0) ? double.Epsilon : (-5E-324);
			}
			double num = Mantissa * PowersOf10.Lookup(Exponent);
			if (!IsFinite(num) || Exponent < 0)
			{
				return num;
			}
			double num2 = Math.Round(num);
			if (Math.Abs(num2 - num) < 1E-10)
			{
				return num2;
			}
			return num;
		}

		public override string ToString()
		{
			return BigNumber.FormatBigDouble(this, null, null);
		}

		public string ToString(string format)
		{
			return BigNumber.FormatBigDouble(this, format, null);
		}

		public string ToString(string format, IFormatProvider formatProvider)
		{
			return BigNumber.FormatBigDouble(this, format, formatProvider);
		}

		public static BigDouble Abs(BigDouble value)
		{
			return FromMantissaExponentNoNormalize(Math.Abs(value.Mantissa), value.Exponent);
		}

		public static BigDouble Negate(BigDouble value)
		{
			return FromMantissaExponentNoNormalize(0.0 - value.Mantissa, value.Exponent);
		}

		public static int Sign(BigDouble value)
		{
			return Math.Sign(value.Mantissa);
		}

		public static BigDouble Round(BigDouble value)
		{
			if (IsNaN(value))
			{
				return value;
			}
			if (value.Exponent < -1)
			{
				return Zero;
			}
			if (value.Exponent < 17)
			{
				return new BigDouble(Math.Round(value.ToDouble()));
			}
			return value;
		}

		public static BigDouble Round(BigDouble value, MidpointRounding mode)
		{
			if (IsNaN(value))
			{
				return value;
			}
			if (value.Exponent < -1)
			{
				return Zero;
			}
			if (value.Exponent < 17)
			{
				return new BigDouble(Math.Round(value.ToDouble(), mode));
			}
			return value;
		}

		public static BigDouble Floor(BigDouble value)
		{
			if (IsNaN(value))
			{
				return value;
			}
			if (value.Exponent < -1)
			{
				return (Math.Sign(value.Mantissa) >= 0) ? Zero : (-One);
			}
			if (value.Exponent < 17)
			{
				return new BigDouble(Math.Floor(value.ToDouble()));
			}
			return value;
		}

		public static BigDouble Ceiling(BigDouble value)
		{
			if (IsNaN(value))
			{
				return value;
			}
			if (value.Exponent < -1)
			{
				return (Math.Sign(value.Mantissa) > 0) ? One : Zero;
			}
			if (value.Exponent < 17)
			{
				return new BigDouble(Math.Ceiling(value.ToDouble()));
			}
			return value;
		}

		public static BigDouble Truncate(BigDouble value)
		{
			if (IsNaN(value))
			{
				return value;
			}
			if (value.Exponent < 0)
			{
				return Zero;
			}
			if (value.Exponent < 17)
			{
				return new BigDouble(Math.Truncate(value.ToDouble()));
			}
			return value;
		}

		public static BigDouble Add(BigDouble left, BigDouble right)
		{
			if (IsZero(left.Mantissa))
			{
				return right;
			}
			if (IsZero(right.Mantissa))
			{
				return left;
			}
			if (IsNaN(left) || IsNaN(right) || IsInfinity(left) || IsInfinity(right))
			{
				return left.Mantissa + right.Mantissa;
			}
			BigDouble result;
			BigDouble bigDouble;
			if (left.Exponent >= right.Exponent)
			{
				result = left;
				bigDouble = right;
			}
			else
			{
				result = right;
				bigDouble = left;
			}
			if (result.Exponent - bigDouble.Exponent > 17)
			{
				return result;
			}
			return Normalize(Math.Round(100000000000000.0 * result.Mantissa + 100000000000000.0 * bigDouble.Mantissa * PowersOf10.Lookup(bigDouble.Exponent - result.Exponent)), result.Exponent - 14);
		}

		public static BigDouble Subtract(BigDouble left, BigDouble right)
		{
			return left + -right;
		}

		public static BigDouble Multiply(BigDouble left, BigDouble right)
		{
			return Normalize(left.Mantissa * right.Mantissa, left.Exponent + right.Exponent);
		}

		public static BigDouble Divide(BigDouble left, BigDouble right)
		{
			return left * Reciprocate(right);
		}

		public static BigDouble Reciprocate(BigDouble value)
		{
			return Normalize(1.0 / value.Mantissa, -value.Exponent);
		}

		public static implicit operator BigDouble(double value)
		{
			return new BigDouble(value);
		}

		public static implicit operator BigDouble(int value)
		{
			return new BigDouble(value);
		}

		public static implicit operator BigDouble(long value)
		{
			return new BigDouble(value);
		}

		public static implicit operator BigDouble(float value)
		{
			return new BigDouble(value);
		}

		public static BigDouble operator -(BigDouble value)
		{
			return Negate(value);
		}

		public static BigDouble operator +(BigDouble left, BigDouble right)
		{
			return Add(left, right);
		}

		public static BigDouble operator -(BigDouble left, BigDouble right)
		{
			return Subtract(left, right);
		}

		public static BigDouble operator *(BigDouble left, BigDouble right)
		{
			return Multiply(left, right);
		}

		public static BigDouble operator /(BigDouble left, BigDouble right)
		{
			return Divide(left, right);
		}

		public static BigDouble operator ++(BigDouble value)
		{
			return value.Add(1);
		}

		public static BigDouble operator --(BigDouble value)
		{
			return value.Subtract(1);
		}

		public int CompareTo(object other)
		{
			if (other == null)
			{
				return 1;
			}
			if (other is BigDouble)
			{
				return CompareTo((BigDouble)other);
			}
			throw new ArgumentException("The parameter must be a BigDouble.");
		}

		public int CompareTo(BigDouble other)
		{
			if (IsZero(Mantissa) || IsZero(other.Mantissa) || IsNaN(this) || IsNaN(other) || IsInfinity(this) || IsInfinity(other))
			{
				return Mantissa.CompareTo(other.Mantissa);
			}
			if (Mantissa > 0.0 && other.Mantissa < 0.0)
			{
				return 1;
			}
			if (Mantissa < 0.0 && other.Mantissa > 0.0)
			{
				return -1;
			}
			int num = Exponent.CompareTo(other.Exponent);
			return (num == 0) ? Mantissa.CompareTo(other.Mantissa) : ((Mantissa > 0.0) ? num : (-num));
		}

		public override bool Equals(object other)
		{
			return other is BigDouble && Equals((BigDouble)other);
		}

		public override int GetHashCode()
		{
			return (Mantissa.GetHashCode() * 397) ^ Exponent.GetHashCode();
		}

		public bool Equals(BigDouble other)
		{
			return !IsNaN(this) && !IsNaN(other) && (AreSameInfinity(this, other) || (Exponent == other.Exponent && AreEqual(Mantissa, other.Mantissa)));
		}

		public bool Equals(BigDouble other, double tolerance)
		{
			return !IsNaN(this) && !IsNaN(other) && (AreSameInfinity(this, other) || Abs(this - other) <= Max(Abs(this), Abs(other)) * tolerance);
		}

		private static bool AreSameInfinity(BigDouble first, BigDouble second)
		{
			return (IsPositiveInfinity(first) && IsPositiveInfinity(second)) || (IsNegativeInfinity(first) && IsNegativeInfinity(second));
		}

		public static bool operator ==(BigDouble left, BigDouble right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(BigDouble left, BigDouble right)
		{
			return !(left == right);
		}

		public static bool operator <(BigDouble a, BigDouble b)
		{
			if (IsNaN(a) || IsNaN(b))
			{
				return false;
			}
			if (IsZero(a.Mantissa))
			{
				return b.Mantissa > 0.0;
			}
			if (IsZero(b.Mantissa))
			{
				return a.Mantissa < 0.0;
			}
			if (a.Exponent == b.Exponent)
			{
				return a.Mantissa < b.Mantissa;
			}
			if (a.Mantissa > 0.0)
			{
				return b.Mantissa > 0.0 && a.Exponent < b.Exponent;
			}
			return b.Mantissa > 0.0 || a.Exponent > b.Exponent;
		}

		public static bool operator <=(BigDouble a, BigDouble b)
		{
			if (IsNaN(a) || IsNaN(b))
			{
				return false;
			}
			return !(a > b);
		}

		public static bool operator >(BigDouble a, BigDouble b)
		{
			if (IsNaN(a) || IsNaN(b))
			{
				return false;
			}
			if (IsZero(a.Mantissa))
			{
				return b.Mantissa < 0.0;
			}
			if (IsZero(b.Mantissa))
			{
				return a.Mantissa > 0.0;
			}
			if (a.Exponent == b.Exponent)
			{
				return a.Mantissa > b.Mantissa;
			}
			if (a.Mantissa > 0.0)
			{
				return b.Mantissa < 0.0 || a.Exponent > b.Exponent;
			}
			return b.Mantissa < 0.0 && a.Exponent < b.Exponent;
		}

		public static bool operator >=(BigDouble a, BigDouble b)
		{
			if (IsNaN(a) || IsNaN(b))
			{
				return false;
			}
			return !(a < b);
		}

		public static BigDouble Max(BigDouble left, BigDouble right)
		{
			if (IsNaN(left) || IsNaN(right))
			{
				return NaN;
			}
			return (left > right) ? left : right;
		}

		public static BigDouble Min(BigDouble left, BigDouble right)
		{
			if (IsNaN(left) || IsNaN(right))
			{
				return NaN;
			}
			return (left > right) ? right : left;
		}

		public static double AbsLog10(BigDouble value)
		{
			return (double)value.Exponent + Math.Log10(Math.Abs(value.Mantissa));
		}

		public static double Log10(BigDouble value)
		{
			return (double)value.Exponent + Math.Log10(value.Mantissa);
		}

		public static double Log(BigDouble value, BigDouble @base)
		{
			return Log(value, @base.ToDouble());
		}

		public static double Log(BigDouble value, double @base)
		{
			if (IsZero(@base))
			{
				return double.NaN;
			}
			return 2.302585092994046 / Math.Log(@base) * Log10(value);
		}

		public static double Log2(BigDouble value)
		{
			return 3.321928094887362 * Log10(value);
		}

		public static double Ln(BigDouble value)
		{
			return 2.302585092994046 * Log10(value);
		}

		public static BigDouble Pow10(double power)
		{
			return IsInteger(power) ? Pow10((long)power) : Normalize(Math.Pow(10.0, power % 1.0), (long)Math.Truncate(power));
		}

		public static BigDouble Pow10(long power)
		{
			return FromMantissaExponentNoNormalize(1.0, power);
		}

		public static BigDouble Pow(BigDouble value, BigDouble power)
		{
			return Pow(value, power.ToDouble());
		}

		public static BigDouble Pow(BigDouble value, long power)
		{
			if (Is10(value))
			{
				return Pow10(power);
			}
			double d = Math.Pow(value.Mantissa, power);
			if (double.IsInfinity(d))
			{
				return Pow(Pow(value, 2L), (double)power / 2.0);
			}
			return Normalize(d, value.Exponent * power);
		}

		public static BigDouble Pow(BigDouble value, double power)
		{
			bool flag = IsInteger(power);
			if (value < 0 && !flag)
			{
				return NaN;
			}
			return (Is10(value) && flag) ? Pow10(power) : PowInternal(value, power);
		}

		private static bool Is10(BigDouble value)
		{
			return value.Exponent == 1 && value.Mantissa - 1.0 < double.Epsilon;
		}

		private static BigDouble PowInternal(BigDouble value, double other)
		{
			double num = (double)value.Exponent * other;
			double value2;
			if (IsInteger(num) && IsFinite(num) && Math.Abs(num) < 9.223372036854776E+18)
			{
				value2 = Math.Pow(value.Mantissa, other);
				if (IsFinite(value2))
				{
					return Normalize(value2, (long)num);
				}
			}
			double num2 = Math.Truncate(num);
			double num3 = num - num2;
			value2 = Math.Pow(10.0, other * Math.Log10(value.Mantissa) + num3);
			if (IsFinite(value2))
			{
				return Normalize(value2, (long)num2);
			}
			BigDouble bigDouble = Pow10(other * AbsLog10(value));
			if (Sign(value) == -1 && AreEqual(other % 2.0, 1.0))
			{
				return -bigDouble;
			}
			return bigDouble;
		}

		public static BigDouble Factorial(BigDouble value)
		{
			double num = value.ToDouble() + 1.0;
			return Pow(num / Math.E * Math.Sqrt(num * Math.Sinh(1.0 / num) + 1.0 / (810.0 * Math.Pow(num, 6.0))), num) * Math.Sqrt(Math.PI * 2.0 / num);
		}

		public static BigDouble Exp(BigDouble value)
		{
			return Pow(Math.E, value);
		}

		public static BigDouble Sqrt(BigDouble value)
		{
			if (value.Mantissa < 0.0)
			{
				return new BigDouble(double.NaN);
			}
			if (value.Exponent % 2 != 0)
			{
				return Normalize(Math.Sqrt(value.Mantissa) * 3.16227766016838, (long)Math.Floor((double)value.Exponent / 2.0));
			}
			return Normalize(Math.Sqrt(value.Mantissa), (long)Math.Floor((double)value.Exponent / 2.0));
		}

		public static BigDouble Cbrt(BigDouble value)
		{
			int num = 1;
			double num2 = value.Mantissa;
			if (num2 < 0.0)
			{
				num = -1;
				num2 = 0.0 - num2;
			}
			double num3 = (double)num * Math.Pow(num2, 1.0 / 3.0);
			long num4 = value.Exponent % 3;
			if (num4 == 1 || num4 == -1)
			{
				return Normalize(num3 * 2.154434690031884, (long)Math.Floor((double)value.Exponent / 3.0));
			}
			if (num4 != 0)
			{
				return Normalize(num3 * 4.641588833612779, (long)Math.Floor((double)value.Exponent / 3.0));
			}
			return Normalize(num3, (long)Math.Floor((double)value.Exponent / 3.0));
		}

		public static BigDouble Sinh(BigDouble value)
		{
			return (Exp(value) - Exp(-value)) / 2;
		}

		public static BigDouble Cosh(BigDouble value)
		{
			return (Exp(value) + Exp(-value)) / 2;
		}

		public static BigDouble Tanh(BigDouble value)
		{
			return Sinh(value) / Cosh(value);
		}

		public static double Asinh(BigDouble value)
		{
			return Ln(value + Sqrt(Pow(value, 2L) + 1));
		}

		public static double Acosh(BigDouble value)
		{
			return Ln(value + Sqrt(Pow(value, 2L) - 1));
		}

		public static double Atanh(BigDouble value)
		{
			if (Abs(value) >= 1)
			{
				return double.NaN;
			}
			return Ln((value + 1) / (One - value)) / 2.0;
		}

		private static bool IsZero(double value)
		{
			return Math.Abs(value) < double.Epsilon;
		}

		private static bool AreEqual(double first, double second)
		{
			return Math.Abs(first - second) < 1E-18;
		}

		private static bool IsInteger(double value)
		{
			return IsZero(Math.Abs(value % 1.0));
		}

		private static bool IsFinite(double value)
		{
			return !double.IsNaN(value) && !double.IsInfinity(value);
		}
	}
	public static class BigMath
	{
		private static readonly Random Random = new Random();

		public static BigDouble RandomBigDouble(double absMaxExponent)
		{
			if (Random.NextDouble() * 20.0 < 1.0)
			{
				return BigDouble.Normalize(0.0, 0L);
			}
			double num = Random.NextDouble() * 10.0;
			if (Random.NextDouble() * 10.0 < 1.0)
			{
				num = Math.Round(num);
			}
			num *= (double)Math.Sign(Random.NextDouble() * 2.0 - 1.0);
			long exponent = (long)(Math.Floor(Random.NextDouble() * absMaxExponent * 2.0) - absMaxExponent);
			return BigDouble.Normalize(num, exponent);
		}

		public static BigDouble AffordGeometricSeries(BigDouble resourcesAvailable, BigDouble priceStart, BigDouble priceRatio, BigDouble currentOwned)
		{
			BigDouble bigDouble = priceStart * BigDouble.Pow(priceRatio, currentOwned);
			return BigDouble.Floor(BigDouble.Log10(resourcesAvailable / bigDouble * (priceRatio - 1) + 1) / BigDouble.Log10(priceRatio));
		}

		public static BigDouble SumGeometricSeries(BigDouble numItems, BigDouble priceStart, BigDouble priceRatio, BigDouble currentOwned)
		{
			BigDouble bigDouble = priceStart * BigDouble.Pow(priceRatio, currentOwned);
			return bigDouble * (1 - BigDouble.Pow(priceRatio, numItems)) / (1 - priceRatio);
		}

		public static BigDouble AffordArithmeticSeries(BigDouble resourcesAvailable, BigDouble priceStart, BigDouble priceAdd, BigDouble currentOwned)
		{
			BigDouble bigDouble = priceStart + currentOwned * priceAdd;
			BigDouble bigDouble2 = bigDouble - priceAdd / 2;
			BigDouble bigDouble3 = BigDouble.Pow(bigDouble2, 2L);
			return BigDouble.Floor((BigDouble.Sqrt(bigDouble3 + priceAdd * resourcesAvailable * 2) - bigDouble2) / priceAdd);
		}

		public static BigDouble SumArithmeticSeries(BigDouble numItems, BigDouble priceStart, BigDouble priceAdd, BigDouble currentOwned)
		{
			BigDouble bigDouble = priceStart + currentOwned * priceAdd;
			return numItems / 2 * (2 * bigDouble + (numItems - 1) * priceAdd);
		}

		public static BigDouble EfficiencyOfPurchase(BigDouble cost, BigDouble currentRpS, BigDouble deltaRpS)
		{
			return cost / currentRpS + cost / deltaRpS;
		}
	}
	public static class BigDoubleExtensions
	{
		public static BigDouble Abs(this BigDouble value)
		{
			return BigDouble.Abs(value);
		}

		public static BigDouble Negate(this BigDouble value)
		{
			return BigDouble.Negate(value);
		}

		public static int Sign(this BigDouble value)
		{
			return BigDouble.Sign(value);
		}

		public static BigDouble Round(this BigDouble value)
		{
			return BigDouble.Round(value);
		}

		public static BigDouble Floor(this BigDouble value)
		{
			return BigDouble.Floor(value);
		}

		public static BigDouble Ceiling(this BigDouble value)
		{
			return BigDouble.Ceiling(value);
		}

		public static BigDouble Truncate(this BigDouble value)
		{
			return BigDouble.Truncate(value);
		}

		public static BigDouble Add(this BigDouble value, BigDouble other)
		{
			return BigDouble.Add(value, other);
		}

		public static BigDouble Subtract(this BigDouble value, BigDouble other)
		{
			return BigDouble.Subtract(value, other);
		}

		public static BigDouble Multiply(this BigDouble value, BigDouble other)
		{
			return BigDouble.Multiply(value, other);
		}

		public static BigDouble Divide(this BigDouble value, BigDouble other)
		{
			return BigDouble.Divide(value, other);
		}

		public static BigDouble Reciprocate(this BigDouble value)
		{
			return BigDouble.Reciprocate(value);
		}

		public static BigDouble Max(this BigDouble value, BigDouble other)
		{
			return BigDouble.Max(value, other);
		}

		public static BigDouble Min(this BigDouble value, BigDouble other)
		{
			return BigDouble.Min(value, other);
		}

		public static double AbsLog10(this BigDouble value)
		{
			return BigDouble.AbsLog10(value);
		}

		public static double Log10(this BigDouble value)
		{
			return BigDouble.Log10(value);
		}

		public static double Log(BigDouble value, BigDouble @base)
		{
			return BigDouble.Log(value, @base);
		}

		public static double Log(this BigDouble value, double @base)
		{
			return BigDouble.Log(value, @base);
		}

		public static double Log2(this BigDouble value)
		{
			return BigDouble.Log2(value);
		}

		public static double Ln(this BigDouble value)
		{
			return BigDouble.Ln(value);
		}

		public static BigDouble Exp(this BigDouble value)
		{
			return BigDouble.Exp(value);
		}

		public static BigDouble Sinh(this BigDouble value)
		{
			return BigDouble.Sinh(value);
		}

		public static BigDouble Cosh(this BigDouble value)
		{
			return BigDouble.Cosh(value);
		}

		public static BigDouble Tanh(this BigDouble value)
		{
			return BigDouble.Tanh(value);
		}

		public static double Asinh(this BigDouble value)
		{
			return BigDouble.Asinh(value);
		}

		public static double Acosh(this BigDouble value)
		{
			return BigDouble.Acosh(value);
		}

		public static double Atanh(this BigDouble value)
		{
			return BigDouble.Atanh(value);
		}

		public static BigDouble Pow(this BigDouble value, BigDouble power)
		{
			return BigDouble.Pow(value, power);
		}

		public static BigDouble Pow(this BigDouble value, long power)
		{
			return BigDouble.Pow(value, power);
		}

		public static BigDouble Pow(this BigDouble value, double power)
		{
			return BigDouble.Pow(value, power);
		}

		public static BigDouble Factorial(this BigDouble value)
		{
			return BigDouble.Factorial(value);
		}

		public static BigDouble Sqrt(this BigDouble value)
		{
			return BigDouble.Sqrt(value);
		}

		public static BigDouble Cbrt(this BigDouble value)
		{
			return BigDouble.Cbrt(value);
		}

		public static BigDouble Sqr(this BigDouble value)
		{
			return BigDouble.Pow(value, 2L);
		}
	}
}
namespace UnfairFlipsAPMod
{
	public static class ArchipelagoConstants
	{
		public const float MaxHeadsChance = 0.95f;

		public const float MinFlipTime = 0.2f;

		public const float MaxFlipTime = 5f;

		public const float MaxComboMultiplier = 3.5f;

		public const float MinComboMultiplier = 1.2f;

		public const float MaxAutoFlipAddition = 5f;

		public const float MinAutoFlipAddition = 0.5f;

		public const int ShopLayers = 2;

		public static int[] CoinValues = new int[5] { 1, 5, 10, 25, 100 };
	}
	public class ArchipelagoHandler : MonoBehaviour
	{
		private string seed;

		private readonly ConcurrentQueue<long> locationsToCheck = new ConcurrentQueue<long>();

		private string lastDeath;

		private DateTime lastDeathLinkTime = DateTime.Now;

		private readonly Random random = new Random();

		private string energyLinkKey;

		private readonly string[] deathMessages = new string[3] { "had a skill issue (died)", "RNGesus has smitten you on this day (died)", "You probably shouldn't go to the lottery... (died)" };

		private const float ConnectTimeoutSeconds = 15f;

		private ArchipelagoSession Session { get; set; }

		private string Server { get; set; }

		private int Port { get; set; }

		private string Slot { get; set; }

		private string Password { get; set; }

		public bool IsConnected
		{
			get
			{
				ArchipelagoSession session = Session;
				return session != null && session.Socket.Connected;
			}
		}

		public bool IsConnecting { get; private set; }

		private MessageManager MessageManager => Object.FindObjectOfType<MessageManager>();

		public event Action OnConnected;

		public event Action<string> OnConnectionFailed;

		public event Action OnDisconnected;

		private static string GetColorHex(PaletteColor? color)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected I4, but got Unknown
			if (1 == 0)
			{
			}
			string result = color switch
			{
				(PaletteColor)2L => "#EE0000", 
				(PaletteColor)3L => "#00FF7F", 
				(PaletteColor)7L => "#FAFAD2", 
				(PaletteColor)4L => "#6495ED", 
				(PaletteColor)6L => "#EE00EE", 
				(PaletteColor)5L => "#00EEEE", 
				(PaletteColor)1L => "#000000", 
				(PaletteColor)0L => "#FFFFFF", 
				(PaletteColor)8L => "#6D8BE8", 
				(PaletteColor)9L => "#FA8072", 
				(PaletteColor)10L => "#AF99EF", 
				_ => "#FFFFFF", 
			};
			if (1 == 0)
			{
			}
			return result;
		}

		public void CreateSession(string server, int port, string slot, string password)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			Server = server;
			Port = port;
			Slot = slot;
			Password = password;
			Session = ArchipelagoSessionFactory.CreateSession(Server, Port);
			Session.MessageLog.OnMessageReceived += new MessageReceivedHandler(OnMessageReceived);
			Session.Socket.ErrorReceived += new ErrorReceivedHandler(OnError);
			Session.Socket.SocketClosed += new SocketClosedHandler(OnSocketClosed);
			Session.Socket.PacketReceived += new PacketReceivedHandler(PacketReceived);
			Session.Items.ItemReceived += new ItemReceivedHandler(ItemReceived);
		}

		private void OnDestroy()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			Session.MessageLog.OnMessageReceived -= new MessageReceivedHandler(OnMessageReceived);
			Session.Socket.ErrorReceived -= new ErrorReceivedHandler(OnError);
			Session.Socket.SocketClosed -= new SocketClosedHandler(OnSocketClosed);
			Session.Socket.PacketReceived -= new PacketReceivedHandler(PacketReceived);
			Session.Items.ItemReceived -= new ItemReceivedHandler(ItemReceived);
		}

		public void Connect()
		{
			if (IsConnecting)
			{
				Log.Warning("Connect requested while already connecting; ignoring.");
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(ConnectRoutine());
			}
		}

		private IEnumerator ConnectRoutine()
		{
			IsConnecting = true;
			try
			{
				Log.Message($"Logging in to {Server}:{Port} as {Slot}...");
				Task<RoomInfoPacket> connectTask = Session.ConnectAsync();
				foreach (object item in WaitForTask(connectTask))
				{
					yield return item;
				}
				if (!connectTask.IsCompleted)
				{
					Fail($"Connection to {Server}:{Port} timed out after {15f:0}s. " + "Check the hostname/port and that the server is online.");
					yield break;
				}
				if (connectTask.IsFaulted)
				{
					Fail($"Could not reach {Server}:{Port}: {Describe(connectTask.Exception)}");
					yield break;
				}
				ArchipelagoHandler archipelagoHandler = this;
				RoomInfoPacket result = connectTask.Result;
				archipelagoHandler.seed = ((result != null) ? result.SeedName : null);
				Task<LoginResult> loginTask = Session.LoginAsync("Unfair Flips", Slot, (ItemsHandlingFlags)7, new Version(0, 6, 7), Array.Empty<string>(), (string)null, Password, true);
				foreach (object item2 in WaitForTask(loginTask))
				{
					yield return item2;
				}
				if (!loginTask.IsCompleted)
				{
					Fail($"Login to {Server}:{Port} as {Slot} timed out after {15f:0}s.");
					yield break;
				}
				if (loginTask.IsFaulted)
				{
					Fail("Login failed: " + Describe(loginTask.Exception));
					yield break;
				}
				LoginResult result2 = loginTask.Result;
				if (result2.Successful)
				{
					Log.Message($"Success! Connected to {Server}:{Port}");
					LoginSuccessful successResult = (LoginSuccessful)result2;
					UnfairFlipsAPMod.SlotData = new SlotData(successResult.SlotData);
					if (seed != null)
					{
						UnfairFlipsAPMod.SaveDataHandler.GetSaveGame(seed, Slot);
					}
					Object.FindObjectOfType<PanelManager>().SetPanelArrangement(2);
					UnfairFlipsAPMod.GameHandler.InitOnConnect();
					((MonoBehaviour)this).StartCoroutine(RunCheckQueue());
					this.OnConnected?.Invoke();
				}
				else
				{
					LoginFailure failure = (LoginFailure)result2;
					string errorMessage = Enumerable.Aggregate(seed: Enumerable.Aggregate(seed: $"Failed to connect to {Server}:{Port} as {Slot}:", source: failure.Errors, func: (string current, string error) => current + "\n    " + error), source: failure.ErrorCodes, func: (string current, ConnectionRefusedError error) => current + $"\n    {error}");
					Fail(errorMessage);
				}
			}
			finally
			{
				IsConnecting = false;
			}
		}

		private static IEnumerable<object> WaitForTask(Task task)
		{
			float elapsed = 0f;
			while (!task.IsCompleted && elapsed < 15f)
			{
				elapsed += Time.deltaTime;
				yield return null;
			}
		}

		private void Fail(string message)
		{
			Log.Error(message);
			this.OnConnectionFailed?.Invoke(message);
		}

		private static string Describe(Exception ex)
		{
			if (ex is AggregateException ex2)
			{
				ex = ex2.Flatten().InnerExceptions.FirstOrDefault() ?? ex2;
			}
			return ex?.Message ?? "unknown error";
		}

		public void Disconnect()
		{
			if (Session != null)
			{
				((MonoBehaviour)this).StopAllCoroutines();
				Session.Socket.DisconnectAsync();
				Session = null;
				Log.Message("Disconnected from Archipelago");
			}
		}

		private void OnError(Exception ex, string message)
		{
			Log.Error("Socket error: " + message + " - " + ex.Message);
		}

		private void OnSocketClosed(string reason)
		{
			((MonoBehaviour)this).StopAllCoroutines();
			Log.Warning("Socket closed: " + reason);
			this.OnDisconnected?.Invoke();
		}

		private void ItemReceived(ReceivedItemsHelper helper)
		{
			try
			{
				int valueOrDefault = (UnfairFlipsAPMod.SaveDataHandler?.SaveData?.ItemIndex).GetValueOrDefault();
				while (helper.Any())
				{
					ItemInfo item = helper.DequeueItem();
					int num = helper.Index - 1;
					if (num >= valueOrDefault)
					{
						UnfairFlipsAPMod.ItemHandler.HandleItem(num, item);
					}
				}
			}
			catch (Exception arg)
			{
				Log.Error($"ItemReceived Error: {arg}");
				throw;
			}
		}

		public void Release()
		{
			Session.SetGoalAchieved();
			Session.SetClientState((ArchipelagoClientState)30);
		}

		public void CheckLocations(long[] ids)
		{
			ids.ToList().ForEach(delegate(long id)
			{
				locationsToCheck.Enqueue(id);
			});
		}

		public void CheckLocation(long id)
		{
			if (!IsLocationChecked(id))
			{
				locationsToCheck.Enqueue(id);
			}
		}

		private IEnumerator RunCheckQueue()
		{
			while (true)
			{
				if (locationsToCheck.TryDequeue(out var locationId))
				{
					Session.Locations.CompleteLocationChecks(new long[1] { locationId });
					Log.Message($"Sent location check: {locationId}");
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
		}

		public bool IsLocationChecked(long id)
		{
			return Session.Locations.AllLocationsChecked.Contains(id);
		}

		public int CountLocationsCheckedInRange(long start, long end)
		{
			return Session.Locations.AllLocationsChecked.Count((long loc) => loc >= start && loc < end);
		}

		public void UpdateTags(List<string> tags)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			ConnectUpdatePacket val = new ConnectUpdatePacket
			{
				Tags = tags.ToArray(),
				ItemsHandling = (ItemsHandlingFlags)7
			};
			Session.Socket.SendPacket((ArchipelagoPacketBase)(object)val);
		}

		private void OnMessageReceived(LogMessage message)
		{
			if (((object)message).GetType().Name.Contains("Hint"))
			{
				try
				{
					PropertyInfo property = ((object)message).GetType().GetProperty("FindingPlayer");
					PropertyInfo property2 = ((object)message).GetType().GetProperty("Item");
					if (property != null && property2 != null)
					{
						object value = property.GetValue(message);
						object value2 = property2.GetValue(message);
						if (value != null && value2 != null)
						{
							PropertyInfo property3 = value.GetType().GetProperty("Slot");
							PropertyInfo property4 = value2.GetType().GetProperty("Location");
							if (property3 != null && property4 != null)
							{
								int num = Convert.ToInt32(property3.GetValue(value));
								long num2 = Convert.ToInt64(property4.GetValue(value2));
								if (num == Session.ConnectionInfo.Slot && num2 >= 512)
								{
									return;
								}
							}
						}
					}
				}
				catch (Exception)
				{
				}
			}
			if (message.Parts.Any((MessagePart x) => (int)x.Type == 1) && UnfairFlipsAPMod.FilterLog != null && UnfairFlipsAPMod.FilterLog.Value && !message.Parts.Any((MessagePart x) => x.Text.Contains(Session.Players.GetPlayerName(Session.ConnectionInfo.Slot))))
			{
				return;
			}
			string message2;
			if (message.Parts.Length == 1)
			{
				message2 = message.Parts[0].Text;
			}
			else
			{
				StringBuilder stringBuilder = new StringBuilder();
				MessagePart[] parts = message.Parts;
				foreach (MessagePart val in parts)
				{
					string colorHex = GetColorHex(val.PaletteColor);
					stringBuilder.Append("<color=" + colorHex + ">" + val.Text + "</color>");
				}
				message2 = stringBuilder.ToString();
			}
			AddMessageToGameLog(message2);
		}

		public void AddMessageToGameLog(string message)
		{
			((MonoBehaviour)this).StartCoroutine(AddMessageToGameLogRoutine(message));
		}

		private IEnumerator AddMessageToGameLogRoutine(string message)
		{
			yield return null;
			MessageManager messageManager = MessageManager;
			if (messageManager != null)
			{
				messageManager.ShowMessage(message);
			}
		}

		private void PacketReceived(ArchipelagoPacketBase packet)
		{
			BouncePacket val = (BouncePacket)(object)((packet is BouncePacket) ? packet : null);
			if (val != null)
			{
				BouncePacketReceived(val);
			}
		}

		public void SendDeath()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			BouncePacket val = new BouncePacket();
			DateTime now = DateTime.Now;
			if (now - lastDeathLinkTime < TimeSpan.FromSeconds(2.0))
			{
				return;
			}
			val.Tags = new List<string>(1) { "DeathLink" };
			val.Data = new Dictionary<string, JToken>
			{
				{
					"time",
					JToken.op_Implicit(UnixTimeConverter.ToUnixTimeStamp(now))
				},
				{
					"source",
					JToken.op_Implicit(Slot)
				},
				{
					"cause",
					JToken.op_Implicit(Slot + " " + deathMessages[random.Next(deathMessages.Length)])
				}
			};
			if (val.Data.TryGetValue("source", out var value))
			{
				string text = ((object)value)?.ToString() ?? "Unknown";
				if (val.Data.TryGetValue("cause", out var value2))
				{
					string text2 = ((object)value2)?.ToString() ?? "Unknown";
					if (val.Data.TryGetValue("time", out var value3))
					{
						string text3 = ((object)value3)?.ToString() ?? "Unknown";
					}
				}
			}
			lastDeathLinkTime = now;
			Session.Socket.SendPacket((ArchipelagoPacketBase)(object)val);
		}

		private void BouncePacketReceived(BouncePacket packet)
		{
			if (UnfairFlipsAPMod.SlotData.DeathLink)
			{
				ProcessBouncePacket(packet, "DeathLink", ref lastDeath, delegate(string source, Dictionary<string, JToken> data)
				{
					JToken value;
					string cause = (data.TryGetValue("cause", out value) ? ((object)value).ToString() : (source + " has died."));
					HandleDeathLink(source, cause);
				});
			}
		}

		private static void ProcessBouncePacket(BouncePacket packet, string tag, ref string lastTime, Action<string, Dictionary<string, JToken>> handler)
		{
			if (!packet.Tags.Contains(tag) || !packet.Data.TryGetValue("time", out var value) || lastTime == ((object)value).ToString())
			{
				return;
			}
			lastTime = ((object)value).ToString();
			if (packet.Data.TryGetValue("source", out var value2))
			{
				string arg = ((object)value2)?.ToString() ?? "Unknown";
				if (packet.Data.TryGetValue("cause", out var value3))
				{
					string text = ((object)value3)?.ToString() ?? "Unknown";
				}
				handler(arg, packet.Data);
			}
		}

		private void HandleDeathLink(string source, string cause)
		{
			if (UnfairFlipsAPMod.SlotData.DeathLink)
			{
				AddMessageToGameLog(cause);
				if (!(source == Slot))
				{
					UnfairFlipsAPMod.GameHandler.Kill();
				}
			}
		}

		public ScoutedItemInfo TryScoutLocation(long locationId, bool createHint = false)
		{
			return Session.Locations.ScoutLocationsAsync(createHint, new long[1] { locationId })?.Result?.Values.First();
		}

		public string GetPlayerName(int player)
		{
			return Session.Players.GetPlayerAlias(player) ?? $"Player {player}";
		}

		public string GetLocationName(long locationId)
		{
			return Session.Locations.GetLocationNameFromId(locationId, (string)null) ?? $"Location {locationId}";
		}

		public void DisplayItemCounts()
		{
			if (Session == null || !IsConnected)
			{
				AddMessageToGameLog("Not connected to Archipelago.");
				return;
			}
			ReadOnlyCollection<ItemInfo> allItemsReceived = Session.Items.AllItemsReceived;
			if (allItemsReceived.Count == 0)
			{
				AddMessageToGameLog("No items received yet.");
				return;
			}
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			foreach (ItemInfo item in allItemsReceived)
			{
				string itemName = item.ItemName;
				bool flag;
				switch (itemName)
				{
				case "$":
				case "$$":
				case "$$$":
					flag = true;
					break;
				default:
					flag = false;
					break;
				}
				if (!flag)
				{
					if (dictionary.ContainsKey(itemName))
					{
						dictionary[itemName]++;
					}
					else
					{
						dictionary[itemName] = 1;
					}
				}
			}
			AddMessageToGameLog("<color=#00FF7F>Upgrades Received:</color>");
			foreach (KeyValuePair<string, int> item2 in dictionary.OrderByDescending((KeyValuePair<string, int> x) => x.Value))
			{
				AddMessageToGameLog($"{item2.Key}: {item2.Value}");
			}
		}

		public void DisplayAutoFlipMsg()
		{
			AddMessageToGameLog($"<color=#FAFAD2>Autoflip Time Is {UnfairFlipsAPMod.SaveDataHandler.SaveData.AutoFlipAddition:F} Seconds.</color>");
		}

		public void DisplayResyncMsg()
		{
			AddMessageToGameLog("<color=#00FF7F>Resyncing items from Archipelago.</color>");
		}
	}
	public class AutoFlipIconHandler
	{
		private static Sprite _autoFlipOnSprite;

		private static Sprite _autoFlipOffSprite;

		private static GameObject _autoFlipButtonObject;

		public static bool IsAutoFlipEnabled;

		public static bool IsVisible
		{
			get
			{
				return (Object)(object)_autoFlipButtonObject != (Object)null && _autoFlipButtonObject.activeSelf;
			}
			set
			{
				if ((Object)(object)_autoFlipButtonObject != (Object)null && _autoFlipButtonObject.activeSelf != value)
				{
					_autoFlipButtonObject.SetActive(value);
				}
			}
		}

		public static void CreateButton()
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			GameObject gameObject = ((Component)Object.FindObjectOfType<AudioButton>()).gameObject;
			Transform parent = gameObject.transform.parent;
			_autoFlipButtonObject = Object.Instantiate<GameObject>(gameObject, parent);
			((Object)_autoFlipButtonObject).name = "AutoFlipButton";
			Object.Destroy((Object)(object)_autoFlipButtonObject.GetComponent<AudioButton>());
			Image image = _autoFlipButtonObject.GetComponent<Image>();
			string path = Path.Combine(UnfairFlipsAPMod.PluginDir, "AutoFlipIcon.png");
			byte[] array = File.ReadAllBytes(path);
			Texture2D val = new Texture2D(2, 2, (TextureFormat)5, false);
			ImageConversion.LoadImage(val, array);
			((Texture)val).filterMode = (FilterMode)0;
			_autoFlipOnSprite = Sprite.Create(val, new Rect(0f, 0f, 33f, 34f), new Vector2(0.5f, 0.5f), 100f);
			_autoFlipOffSprite = Sprite.Create(val, new Rect(34f, 0f, 34f, 34f), new Vector2(0.5f, 0.5f), 100f);
			image.sprite = _autoFlipOffSprite;
			image.preserveAspect = true;
			IsAutoFlipEnabled = false;
			_autoFlipButtonObject.transform.localPosition = new Vector3(250f, 400f, 0f);
			Button component = _autoFlipButtonObject.GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener((UnityAction)delegate
			{
				IsAutoFlipEnabled = !IsAutoFlipEnabled;
				if (IsAutoFlipEnabled)
				{
					GameHandler.QueueNextAutoFlip();
					UnfairFlipsAPMod.ArchipelagoHandler.DisplayAutoFlipMsg();
				}
				image.sprite = (IsAutoFlipEnabled ? _autoFlipOnSprite : _autoFlipOffSprite);
			});
			IsVisible = UnfairFlipsAPMod.SaveDataHandler?.SaveData?.HasAutoFlip == true;
		}
	}
	public class ConnectionUI : MonoBehaviour
	{
		private bool showUI = true;

		private string hostname = "localhost";

		private string slotName = "Player1";

		private string port = "38281";

		private string password = "";

		private string statusMessage = "";

		private Rect windowRect = new Rect((float)(Screen.width / 2 - 300), (float)(Screen.height / 2 - 250), 800f, 700f);

		private ArchipelagoHandler apHandler;

		public void Initialize(ArchipelagoHandler handler)
		{
			apHandler = handler;
			apHandler.OnConnected += delegate
			{
				statusMessage = "Connected successfully!";
			};
			apHandler.OnConnectionFailed += delegate(string error)
			{
				statusMessage = "Failed: " + error;
			};
			apHandler.OnDisconnected += delegate
			{
				statusMessage = "Disconnected";
			};
			apHandler.OnConnected += delegate
			{
				FileWriter fileWriter = Object.FindObjectOfType<FileWriter>();
				if (!((Object)(object)fileWriter == (Object)null))
				{
					int.TryParse(port, out var result);
					fileWriter.WriteLastConnection(hostname, result, slotName, password);
				}
			};
			(string, string, string, string) tuple = FileWriter.ReadLastConnection();
			if (!string.IsNullOrEmpty(tuple.Item1))
			{
				(hostname, _, _, _) = tuple;
			}
			if (!string.IsNullOrEmpty(tuple.Item2))
			{
				port = tuple.Item2;
			}
			if (!string.IsNullOrEmpty(tuple.Item3))
			{
				slotName = tuple.Item3;
			}
			if (!string.IsNullOrEmpty(tuple.Item4))
			{
				password = tuple.Item4;
			}
		}

		public void ToggleUI()
		{
			showUI = !showUI;
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)282))
			{
				ToggleUI();
			}
		}

		private void OnGUI()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			if (showUI)
			{
				GUI.skin.label.fontSize = 24;
				GUI.skin.button.fontSize = 24;
				GUI.skin.textField.fontSize = 24;
				windowRect = GUI.Window(0, windowRect, new WindowFunction(DrawWindow), "Archipelago Connection");
			}
		}

		private void DrawWindow(int windowID)
		{
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Press F1 to toggle this menu", Array.Empty<GUILayoutOption>());
			GUILayout.Space(15f);
			GUILayout.Label("Hostname:", Array.Empty<GUILayoutOption>());
			hostname = GUILayout.TextField(hostname, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(10f);
			GUILayout.Label("Port:", Array.Empty<GUILayoutOption>());
			port = GUILayout.TextField(port, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(10f);
			GUILayout.Label("Slot Name:", Array.Empty<GUILayoutOption>());
			slotName = GUILayout.TextField(slotName, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(10f);
			GUILayout.Label("Password (optional):", Array.Empty<GUILayoutOption>());
			password = GUILayout.PasswordField(password, '*', (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
			GUILayout.Space(15f);
			if ((Object)(object)apHandler != (Object)null && apHandler.IsConnected)
			{
				if (GUILayout.Button("Disconnect", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) }))
				{
					apHandler.Disconnect();
				}
			}
			else if ((Object)(object)apHandler != (Object)null && apHandler.IsConnecting)
			{
				GUI.enabled = false;
				GUILayout.Button("Connecting...", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) });
				GUI.enabled = true;
			}
			else if (GUILayout.Button("Connect", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(40f) }))
			{
				int result;
				if (string.IsNullOrEmpty(hostname))
				{
					statusMessage = "Please enter a hostname!";
				}
				else if (string.IsNullOrEmpty(slotName))
				{
					statusMessage = "Please enter a slot name!";
				}
				else if (int.TryParse(port, out result))
				{
					statusMessage = "Connecting...";
					apHandler.CreateSession(hostname, result, slotName, password);
					apHandler.Connect();
				}
				else
				{
					statusMessage = "Invalid port number!";
				}
			}
			GUILayout.Space(15f);
			if (!string.IsNullOrEmpty(statusMessage))
			{
				GUILayout.Label("Status: " + statusMessage, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndVertical();
			GUI.DragWindow();
		}
	}
	public class CounterPatches : MonoBehaviour
	{
		[HarmonyPatch(typeof(HeadsChanceCounter))]
		public class HeadsChanceCounter_Patch
		{
			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			public static bool Update_Prefix(HeadsChanceCounter __instance)
			{
				//IL_0088: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				if (UnfairFlipsAPMod.SaveDataHandler?.SaveData != null)
				{
					int num = 1 + UnfairFlipsAPMod.SaveDataHandler.SaveData.Fairness * 2;
					__instance.text.text = "HEADS CHANCE: " + (int)((double)UnfairFlipsAPMod.SaveDataHandler.SaveData.HeadsChance * 100.0) + "%";
					((TMP_Text)fairnessAmtText).rectTransform.anchorMin = new Vector2(0f, ((TMP_Text)fairnessAmtText).rectTransform.anchorMin.y);
					((TMP_Text)fairnessAmtText).rectTransform.anchorMax = new Vector2(1f, ((TMP_Text)fairnessAmtText).rectTransform.anchorMax.y);
					((TMP_Text)fairnessAmtText).fontSizeMax = 48f;
					((TMP_Text)fairnessAmtText).text = $"Max Heads In A Row: {num:D0}";
					if (Mathf.Approximately((float)num, UnfairFlipsAPMod.SaveDataHandler.SaveData.HeadsChance))
					{
						((Graphic)fairnessAmtText).color = new Color(0.56f, 0.93f, 0.56f);
					}
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(MoneyCounter))]
		public class MoneyCounter_Patch
		{
			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			public static bool Update_Prefix(MoneyCounter __instance)
			{
				if (UnfairFlipsAPMod.SaveDataHandler?.SaveData != null)
				{
					__instance.text.text = Mathy.CentsToDollarString(UnfairFlipsAPMod.SaveDataHandler.SaveData.PlayerMoney);
				}
				return false;
			}
		}

		private GameObject fairnessAmtObject;

		private static TextMeshProUGUI fairnessAmtText;

		public void Start()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			HeadsChanceCounter val = Object.FindObjectOfType<HeadsChanceCounter>();
			TMP_Text component = ((Component)val).GetComponent<TMP_Text>();
			Transform parent = ((Component)val).transform.parent;
			int height = Screen.height;
			int num = 1080;
			fairnessAmtObject = new GameObject("FairnessAmt");
			fairnessAmtObject.transform.SetParent(((Component)parent).transform, false);
			fairnessAmtObject.transform.position = ((Component)val).gameObject.transform.position;
			fairnessAmtObject.transform.localPosition = ((Component)val).gameObject.transform.localPosition;
			fairnessAmtText = fairnessAmtObject.AddComponent<TextMeshProUGUI>();
			((TMP_Text)fairnessAmtText).font = component.font;
			((TMP_Text)fairnessAmtText).fontSize = component.fontSize;
			((TMP_Text)fairnessAmtText).alignment = (TextAlignmentOptions)514;
			((TMP_Text)fairnessAmtText).enableAutoSizing = true;
			((TMP_Text)fairnessAmtText).overflowMode = (TextOverflowModes)0;
			((TMP_Text)fairnessAmtText).richText = true;
			((Graphic)fairnessAmtText).color = Color.white;
			fairnessAmtObject.transform.Translate(0f, -50f * (float)height / (float)num, 0f);
		}
	}
	public class FileWriter : MonoBehaviour
	{
		private const string LastConnectionFileName = "last_connection.txt";

		public void WriteLastConnection(string host, int port, string slotName, string password)
		{
			try
			{
				string path = Application.persistentDataPath + "/last_connection.txt";
				List<string> contents = new List<string>
				{
					host ?? "",
					port.ToString(),
					slotName ?? "",
					password ?? ""
				};
				File.WriteAllLines(path, contents);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to write last connection info: " + ex.Message));
			}
		}

		public static (string host, string port, string slotName, string password) ReadLastConnection()
		{
			try
			{
				string path = Application.persistentDataPath + "/last_connection.txt";
				if (!File.Exists(path))
				{
					return (host: null, port: null, slotName: null, password: null);
				}
				string[] array = File.ReadAllLines(path);
				string item = ((array.Length != 0) ? array[0] : null);
				string item2 = ((array.Length > 1) ? array[1] : null);
				string item3 = ((array.Length > 2) ? array[2] : null);
				string item4 = ((array.Length > 3) ? array[3] : null);
				return (host: item, port: item2, slotName: item3, password: item4);
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("Failed to read last connection info: " + ex.Message));
				return (host: null, port: null, slotName: null, password: null);
			}
		}
	}
	public class GameHandler : MonoBehaviour
	{
		[HarmonyPatch(typeof(FlipResultMessage))]
		private class FlipResultMessage_Patch
		{
			[HarmonyPatch("ShowResult")]
			[HarmonyPrefix]
			public static bool ShowResult(FlipResultMessage __instance, bool heads, long money, int comboNum)
			{
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Expected O, but got Unknown
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Expected O, but got Unknown
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_0134: Unknown result type (might be due to invalid IL or missing references)
				TweenExtension.CancelTweens(((Component)__instance).gameObject, false);
				__instance.text.text = ((!heads) ? "TAILS" : string.Format("HEADS {0}X\n{1}", comboNum, (_flipMoneyResult > 0L) ? Mathy.CentsToDollarString(_flipMoneyResult) : ""));
				_flipMoneyResult = 0;
				((Graphic)__instance.text).color = Color.white;
				AnchoredPositionYTween val = new AnchoredPositionYTween();
				((Tween<RectTransform, float>)(object)val).from = Nullable<float>.op_Implicit(__instance.baseYPos);
				((Tween<RectTransform, float>)(object)val).to = Nullable<float>.op_Implicit(__instance.baseYPos + 150f);
				((Tween)val).duration = 1f;
				((Tween)val).easeType = (EaseType)41;
				TweenExtension.AddTween<RectTransform, float>(((Component)__instance).gameObject, (Tween<RectTransform, float>)(object)val);
				ColorTween val2 = new ColorTween();
				((Tween<Transform, Color>)(object)val2).from = Nullable<Color>.op_Implicit(Color.white);
				((Tween<Transform, Color>)(object)val2).to = Nullable<Color>.op_Implicit(new Color(1f, 1f, 1f, 0f));
				((Tween)val2).duration = 1f;
				((Tween)val2).easeType = (EaseType)0;
				((Tween<Transform, Color>)(object)val2).onUpdate = delegate(TweenInstance<Transform, Color> _, Color value)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					((Graphic)__instance.text).color = value;
				};
				TweenExtension.AddTween<Transform, Color>(((Component)__instance).gameObject, (Tween<Transform, Color>)(object)val2);
				return false;
			}
		}

		[HarmonyPatch(typeof(CoinFlip))]
		private class CoinFlip_Patch
		{
			private static SaveDataHandler SaveManager => UnfairFlipsAPMod.SaveDataHandler;

			private static SlotData SlotData => UnfairFlipsAPMod.SlotData;

			[HarmonyPatch("Start")]
			[HarmonyPostfix]
			private static void Start_Postfix()
			{
				Log.Debug("CoinFlip started, flushing item queue...");
				UnfairFlipsAPMod.ItemHandler?.FlushQueue();
			}

			[HarmonyPatch("DoFlip")]
			[HarmonyPrefix]
			private static bool DoFlip_Prefix(CoinFlip __instance)
			{
				if (_queuedAutoFlip != null)
				{
					((MonoBehaviour)__instance).StopCoroutine(_queuedAutoFlip);
					_queuedAutoFlip = null;
				}
				if (__instance.isFlipping)
				{
					return false;
				}
				((MonoBehaviour)__instance).StartCoroutine(Flip(__instance));
				return false;
			}

			private static void InitFlip(CoinFlip coinFlip)
			{
				coinFlip.flippedThisSession = true;
				coinFlip.numFlips++;
				coinFlip.img.sprite = coinFlip.coinColors[coinFlip.currentCoin].coinSmirk;
				coinFlip.isFlipping = true;
				coinFlip.currentFlipDuration = 0f;
				coinFlip.currentFlipAnimateDuration = coinFlip.flipAnimateDuration;
				coinFlip.audioSource.volume = 1f;
			}

			private static IEnumerator Flip(CoinFlip coinFlip)
			{
				InitFlip(coinFlip);
				int index = 0;
				while (index < coinFlip.tutorialMessages.Length)
				{
					if (coinFlip.tutorialMessages[index].flipnum == coinFlip.numFlips)
					{
						coinFlip.messageManager.ShowMessage("<color=#bbffbb>" + coinFlip.tutorialMessages[index].message + "</color>");
					}
					int num = index + 1;
					index = num;
				}
				float flipTime = SaveManager.SaveData.FlipTime;
				if (SaveManager.SaveData.QueuedSlowTraps > 0)
				{
					SaveManager.SaveData.QueuedSlowTraps--;
					flipTime = 10f;
				}
				AnchoredPositionTween anchoredPositionTween1 = new AnchoredPositionTween();
				((Tween<RectTransform, Vector2>)(object)anchoredPositionTween1).from = Nullable<Vector2>.op_Implicit(((Component)coinFlip).GetComponent<RectTransform>().anchoredPosition);
				((Tween<RectTransform, Vector2>)(object)anchoredPositionTween1).to = Nullable<Vector2>.op_Implicit(coinFlip.flipTarget);
				((Tween)anchoredPositionTween1).duration = flipTime / 2f;
				((Tween)anchoredPositionTween1).delay = 0f;
				((Tween)anchoredPositionTween1).easeType = (EaseType)21;
				TweenExtension.AddTween<RectTransform, Vector2>(((Component)coinFlip).gameObject, (Tween<RectTransform, Vector2>)(object)anchoredPositionTween1);
				AnchoredPositionTween anchoredPositionTween2 = new AnchoredPositionTween();
				((Tween<RectTransform, Vector2>)(object)anchoredPositionTween2).from = Nullable<Vector2>.op_Implicit(coinFlip.flipTarget);
				((Tween<RectTransform, Vector2>)(object)anchoredPositionTween2).to = Nullable<Vector2>.op_Implicit(coinFlip.flipBasePosition);
				((Tween)anchoredPositionTween2).duration = flipTime / 2f;
				((Tween)anchoredPositionTween2).delay = flipTime / 2f;
				((Tween)anchoredPositionTween2).easeType = (EaseType)30;
				TweenExtension.AddTween<RectTransform, Vector2>(((Component)coinFlip).gameObject, (Tween<RectTransform, Vector2>)(object)anchoredPositionTween2);
				float flipTurnMultiplier = Random.Range(3, 6);
				int maxHeadsAllowed = 1 + SaveManager.SaveData.Fairness * 2;
				bool canBeHeads = coinFlip.headsComboNum + 1 <= maxHeadsAllowed && SaveManager.SaveData.QueuedTailsTraps == 0;
				if (SaveManager.SaveData.QueuedTailsTraps > 0)
				{
					SaveManager.SaveData.QueuedTailsTraps--;
				}
				bool heads = canBeHeads && (double)Random.Range(0f, 1f) < (double)SaveManager.SaveData.HeadsChance;
				if (heads != coinFlip.prevWasHeads)
				{
					flipTurnMultiplier += 0.5f;
				}
				bool comboFailed = false;
				coinFlip.audioSource.clip = ((coinFlip.headsComboNum != SlotData.RequiredHeads - 1) ? coinFlip.flipSounds[Random.Range(0, coinFlip.flipSounds.Length)] : coinFlip.finalFlipSound);
				coinFlip.audioSource.Play();
				if (heads)
				{
					coinFlip.headsComboNum++;
				}
				else
				{
					if (coinFlip.headsComboNum > 2)
					{
						comboFailed = true;
					}
					if (coinFlip.headsComboNum >= SlotData.DeathLinkMinStreak && SlotData.DeathLink && (double)Random.Range(0f, 1f) < (double)SlotData.DeathLinkChance / 100.0)
					{
						UnfairFlipsAPMod.ArchipelagoHandler.SendDeath();
					}
					coinFlip.headsComboNum = 0;
				}
				if (heads && coinFlip.headsComboNum == SlotData.RequiredHeads)
				{
					coinFlip.panelManager.SetPanelArrangement(4);
					((Behaviour)coinFlip.flipButton).enabled = false;
					UnfairFlipsAPMod.ArchipelagoHandler.Release();
					TweenExtension.CancelTweens(((Component)coinFlip).gameObject, false);
					AnchoredPositionTween anchoredPositionTween3 = new AnchoredPositionTween();
					((Tween<RectTransform, Vector2>)(object)anchoredPositionTween3).from = Nullable<Vector2>.op_Implicit(coinFlip.flipBasePosition);
					((Tween<RectTransform, Vector2>)(object)anchoredPositionTween3).to = Nullable<Vector2>.op_Implicit(coinFlip.flipTarget);
					((Tween)anchoredPositionTween3).duration = 3f;
					((Tween)anchoredPositionTween3).delay = 0f;
					((Tween)anchoredPositionTween3).easeType = (EaseType)21;
					AnchoredPositionTween anchoredPositionTween4 = new AnchoredPositionTween();
					((Tween<RectTransform, Vector2>)(object)anchoredPositionTween4).from = Nullable<Vector2>.op_Implicit(coinFlip.flipTarget);
					((Tween<RectTransform, Vector2>)(object)anchoredPositionTween4).to = Nullable<Vector2>.op_Implicit(coinFlip.flipBasePosition);
					((Tween)anchoredPositionTween4).duration = 3f;
					((Tween)anchoredPositionTween4).delay = 3f;
					((Tween)anchoredPositionTween4).easeType = (EaseType)30;
					TweenExtension.AddTween<RectTransform, Vector2>(((Component)coinFlip).gameObject, (Tween<RectTransform, Vector2>)(object)anchoredPositionTween3);
					TweenExtension.AddTween<RectTransform, Vector2>(((Component)coinFlip).gameObject, (Tween<RectTransform, Vector2>)(object)anchoredPositionTween4);
					int coinSprite = 0;
					int numFancyFlips = 1;
					while ((double)coinFlip.currentFlipDuration < 6.0)
					{
						coinFlip.img.sprite = coinFlip.coinColors[coinFlip.currentCoin].coinSlowFlip[coinSprite];
						int num = coinSprite + 1;
						coinSprite = num;
						if (coinSprite >= coinFlip.coinColors[coinFlip.currentCoin].coinSlowFlip.Length)
						{
							if (numFancyFlips < 3)
							{
								coinSprite = 0;
								num = numFancyFlips + 1;
								numFancyFlips = num;
							}
							else
							{
								coinSprite = coinFlip.coinColors[coinFlip.currentCoin].coinSlowFlip.Length - 1;
							}
						}
						float seconds = 6f / (float)(3 * coinFlip.coinColors[coinFlip.currentCoin].coinSlowFlip.Length);
						coinFlip.currentFlipDuration += seconds;
						yield return (object)new WaitForSeconds(seconds);
					}
					coinFlip.audioSource.clip = coinFlip.headsSounds[0];
					coinFlip.audioSource.Play();
					_flipMoneyResult = 0;
					Object.FindObjectOfType<FlipResultMessage>().ShowResult(true, 0L, SlotData.RequiredHeads);
					yield return (object)new WaitForSeconds(1f);
					RocketSpawner[] objectsOfType = Object.FindObjectsOfType<RocketSpawner>();
					objectsOfType[0].SpawnRockets(0f);
					objectsOfType[1].SpawnRockets(1f);
					yield return (object)new WaitForSeconds(4f);
					LocalScaleTween localScaleTween = new LocalScaleTween();
					((Tween<Transform, Vector3>)(object)localScaleTween).from = Nullable<Vector3>.op_Implicit(Vector3.zero);
					((Tween<Transform, Vector3>)(object)localScaleTween).to = Nullable<Vector3>.op_Implicit(Vector3.one);
					((Tween)localScaleTween).duration = 5f;
					((Tween)localScaleTween).easeType = (EaseType)0;
					TweenExtension.AddTween<Transform, Vector3>(coinFlip.gooJobSticker, (Tween<Transform, Vector3>)(object)localScaleTween);
					coinFlip.gooJobSticker.SetActive(true);
					yield return (object)new WaitForSeconds(8f);
					coinFlip.gar.LookAtPlayer();
					coinFlip.UnlockCheevo("ENDING_10FLIP");
					yield return (object)new WaitForSeconds(3f);
					coinFlip.panelManager.SetPanelArrangement(5);
					yield break;
				}
				while ((double)coinFlip.currentFlipDuration < (double)flipTime)
				{
					coinFlip.currentFlipDuration += Time.deltaTime;
					coinFlip.currentFlipAnimateDuration += Time.deltaTime * 360f / flipTime * flipTurnMultiplier;
					((Component)coinFlip).transform.eulerAngles = new Vector3(0f, 0f, coinFlip.currentFlipAnimateDuration);
					yield return null;
				}
				((Component)coinFlip).transform.eulerAngles = new Vector3(0f, 0f, 0f);
				BigDouble money = SaveManager.SaveData.CoinValue * new BigDouble(BigDouble.Ceiling(BigDouble.Pow(SaveManager.SaveData.ComboMult, coinFlip.headsComboNum - 1)));
				if (SaveManager.SaveData.QueuedPennyTraps > 0)
				{
					SaveManager.SaveData.QueuedPennyTraps--;
					money = 1 * new BigDouble(BigDouble.Ceiling(BigDouble.Pow(SaveManager.SaveData.ComboMult, coinFlip.headsComboNum - 1)));
				}
				if (SaveManager.SaveData.QueuedTaxTraps > 0)
				{
					SaveManager.SaveData.QueuedTaxTraps--;
					money *= (BigDouble)(-1);
				}
				if (heads)
				{
					string message = "HEADS";
					int index2 = 1;
					while (index2 < coinFlip.headsComboNum)
					{
						message += "!";
						int num = index2 + 1;
						index2 = num;
					}
					UnfairFlipsAPMod.ArchipelagoHandler.CheckLocation(256 + coinFlip.headsComboNum);
					coinFlip.messageManager.ShowMessage(message);
					coinFlip.img.sprite = coinFlip.coinColors[coinFlip.currentCoin].coinHappy;
					SaveManager.SaveData.PlayerMoney += money;
					coinFlip.UnlockCheevo(coinFlip.headsComboNum + "FLIP");
					GameObject gameObject = Object.Instantiate<GameObject>(coinFlip.prf_sfx);
					int soundIndex = Mathf.Clamp(coinFlip.headsComboNum - 1, 0, coinFlip.headsSounds.Length - 1);
					gameObject.GetComponent<AudioSource>().clip = coinFlip.headsSounds[soundIndex];
					gameObject.GetComponent<AudioSource>().Play();
					Object.Destroy((Object)(object)gameObject, 3f);
				}
				else
				{
					string str = "<color=#FFFFFF77>TAILS";
					if (comboFailed)
					{
						str += "...";
					}
					string message2 = str + "</color>";
					coinFlip.messageManager.ShowMessage(message2);
					coinFlip.img.sprite = coinFlip.coinColors[coinFlip.currentCoin].coinSad;
					coinFlip.audioSource.clip = coinFlip.landingSounds[Random.Range(0, coinFlip.landingSounds.Length)];
					coinFlip.audioSource.volume = 0.5f;
					coinFlip.audioSource.Play();
				}
				_flipMoneyResult = money;
				Object.FindObjectOfType<FlipResultMessage>().ShowResult(heads, 0L, coinFlip.headsComboNum);
				if (coinFlip.numFlips > 2 && coinFlip.panelManager.GetCurrentArrangement() < 1)
				{
					coinFlip.panelManager.SetPanelArrangement(1);
				}
				if ((coinFlip.numFlips >= 8 || (coinFlip.bigMoment && comboFailed)) && (coinFlip.panelManager.GetCurrentArrangement() < 2 || (coinFlip.bigMoment && comboFailed)))
				{
					coinFlip.panelManager.SetPanelArrangement(2);
					if (coinFlip.bigMoment && comboFailed)
					{
						coinFlip.timeSinceMoved = 0f;
					}
					coinFlip.bigMoment = false;
				}
				if (coinFlip.headsComboNum == SlotData.RequiredHeads - 1)
				{
					coinFlip.bigMoment = true;
					coinFlip.panelManager.SetPanelArrangement(3);
					coinFlip.timeSinceMoved = 0f;
				}
				coinFlip.prevWasHeads = heads;
				coinFlip.isFlipping = false;
				SaveManager.SaveGame();
				QueueNextAutoFlip();
			}
		}

		private static Coroutine _queuedAutoFlip;

		private static CoinFlip _coinFlip;

		private List<TutorialMessage> tutorialMessages = new List<TutorialMessage>();

		private static BigDouble _flipMoneyResult;

		private static SlotData SlotData => UnfairFlipsAPMod.SlotData;

		public void InitOnConnect()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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_004b: 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_005e: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//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_0136: 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)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			UpdateCoinValue();
			AutoFlipIconHandler.CreateButton();
			ReceivedItemsButtonHandler.CreateButton();
			_coinFlip = Object.FindObjectOfType<CoinFlip>();
			_coinFlip.tutorialMessages = (TutorialMessage[])(object)new TutorialMessage[31]
			{
				CreateTutorialMessage("Welcome to Unfair Flips Archipelago!", 2),
				CreateTutorialMessage("GAME MADE BY HEATHER FLOWERS", 3),
				CreateTutorialMessage("ART BY GWYNDOLYN MARCHANT", 4),
				CreateTutorialMessage("AND A SPECIAL SFX BY SURASSHU", 5),
				CreateTutorialMessage("Archipelago by xMcacutt and Jeffdev", 6),
				CreateTutorialMessage("with help from itepastra (Noa)", 8),
				CreateTutorialMessage("and DashieSwag92", 9),
				CreateTutorialMessage("Testing & Support - Sterlia, EthicalLogic, Peppidesu, Mac", 10),
				CreateTutorialMessage("May the odds... idk do whatever they feel like", 11),
				CreateTutorialMessage($"Your goal is to get {SlotData.RequiredHeads} heads in a row!", 20),
				CreateTutorialMessage("Curious about the Archipelago items?", 30),
				CreateTutorialMessage("Heads+ increases the chance of getting heads", 31),
				CreateTutorialMessage("Progressive Fairness increases the max heads in a row you can get", 32),
				CreateTutorialMessage("Flip+ decreases the flip time", 33),
				CreateTutorialMessage("Combo+ increases the combo multiplier", 34),
				CreateTutorialMessage("Coin+ increases the coin type progressively", 35),
				CreateTutorialMessage("$/$$/$$$ give money, more money, and even more money respectively", 36),
				CreateTutorialMessage("Tails Trap makes your next coinflip tails", 37),
				CreateTutorialMessage("Penny Trap makes your next coinflip worth a penny", 38),
				CreateTutorialMessage("Tax Trap makes you pay some money after your next coinflip", 39),
				CreateTutorialMessage("Slow Trap makes the next coinflip take 10 seconds", 40),
				CreateTutorialMessage("That's all you need to know! Good luck!", 41),
				CreateTutorialMessage("67 coin flips. I don't wanna hear it.", 67),
				CreateTutorialMessage("69 coin flips. Nice.", 69),
				CreateTutorialMessage("WOW you did a hundred flips. That's almost a hundred and one. Goo:) Job", 100),
				CreateTutorialMessage("WOW you did a hundred and one flips. That's almost a hundred and two. Goo:) Job!", 101),
				CreateTutorialMessage("Okay I'll stop now...", 102),
				CreateTutorialMessage("You are statistically likely to finish this game.", 300),
				CreateTutorialMessage("Eight Eight Eight Eight Eight Eight Eight Eight", 888),
				CreateTutorialMessage("You realise your friends want to finish this generation right?", 1000),
				CreateTutorialMessage("Honestly, if you're seeing this, you might be too unlucky for this game. Hope things go better next time!.", 10000)
			};
			if (UnfairFlipsAPMod.SlotData.AutoFlipEnabled)
			{
				tutorialMessages.Add(CreateTutorialMessage("AutoFlip+ makes the autoflip button work faster!", 35));
			}
			QueueNextAutoFlip();
		}

		private TutorialMessage CreateTutorialMessage(string message, int flipNum)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			return new TutorialMessage
			{
				flipnum = flipNum,
				message = message
			};
		}

		public void UpdateCoinValue()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			int coinValue = 1;
			Color white = Color.white;
			Vector3 localScale = Vector3.one;
			int coinType = 0;
			int coinUpgradeLevel = UnfairFlipsAPMod.SaveDataHandler.SaveData.CoinUpgradeLevel;
			int num = coinUpgradeLevel;
			if (num < 4)
			{
				switch (num)
				{
				case 1:
					coinValue = 5;
					((Color)(ref white))..ctor(0.9f, 0.9f, 0.9f, 1f);
					coinType = 1;
					break;
				case 2:
					coinValue = 10;
					((Color)(ref white))..ctor(1f, 1f, 1f, 1f);
					localScale = Vector3.one * 0.7f;
					coinType = 1;
					break;
				case 3:
					coinValue = 25;
					localScale = Vector3.one * 1.2f;
					coinType = 1;
					break;
				}
			}
			else
			{
				coinValue = 100;
				localScale = Vector3.one * 1.2f;
				coinType = 2;
			}
			UnfairFlipsAPMod.SaveDataHandler.SaveData.CoinValue = coinValue;
			((Graphic)((Component)Object.FindObjectOfType<CoinFlip>()).GetComponent<Image>()).color = white;
			((Component)Object.FindObjectOfType<CoinFlip>()).transform.localScale = localScale;
			Object.FindObjectOfType<CoinFlip>().SetCoinType(coinType);
		}

		public static void QueueNextAutoFlip()
		{
			if (UnfairFlipsAPMod.SaveDataHandler.SaveData.HasAutoFlip && AutoFlipIconHandler.IsAutoFlipEnabled)
			{
				_queuedAutoFlip = ((MonoBehaviour)_coinFlip).StartCoroutine(AutoFlipDelayCoroutine(_coinFlip));
			}
		}

		private static IEnumerator AutoFlipDelayCoroutine(CoinFlip coinFlip)
		{
			float delay = UnfairFlipsAPMod.SaveDataHandler.SaveData.AutoFlipAddition;
			if (delay > 0f)
			{
				yield return (object)new WaitForSeconds(delay);
			}
			if (!coinFlip.isFlipping && UnfairFlipsAPMod.SaveDataHandler.SaveData.HasAutoFlip && AutoFlipIconHandler.IsAutoFlipEnabled)
			{
				coinFlip.DoFlip();
			}
		}

		public void Kill()
		{
			CoinFlip val = Object.FindObjectOfType<CoinFlip>();
			if ((Object)(object)val != (Object)null)
			{
				val.headsComboNum = 0;
			}
		}
	}
	public enum UFItem
	{
		ProgressiveFairness = 1,
		HeadsUp = 2,
		FlipUp = 3,
		ComboUp = 4,
		CoinUp = 5,
		AutoFlipUp = 6,
		TailsTrap = 16,
		PennyTrap = 17,
		TaxTrap = 18,
		SlowTrap = 19,
		Money = 32,
		MoreMoney = 33,
		BigMoney = 34
	}
	public class ItemHandler : MonoBehaviour
	{
		private Queue<(int, ItemInfo)> cachedItems = new Queue<(int, ItemInfo)>();

		private bool IsGameReady()
		{
			if (UnfairFlipsAPMod.SaveDataHandler?.SaveData == null)
			{
				Log.Debug("SaveData not ready");
				return false;
			}
			if (UnfairFlipsAPMod.SlotData == null)
			{
				Log.Debug("SlotData not ready");
				return false;
			}
			CoinFlip val = Object.FindObjectOfType<CoinFlip>();
			if ((Object)(object)val == (Object)null)
			{
				Log.Debug("CoinFlip not found in scene");
				return false;
			}
			return true;
		}

		public void HandleItem(int index, ItemInfo item, bool save = true)
		{
			try
			{
				if (!IsGameReady())
				{
					Log.Debug($"Game not ready, caching item: {item.ItemName} (index {index})");
					cachedItems.Enqueue((index, item));
					return;
				}
				if (index < UnfairFlipsAPMod.SaveDataHandler.SaveData.ItemIndex)
				{
					Log.Debug($"Item {index} already processed (current: {UnfairFlipsAPMod.SaveDataHandler.SaveData.ItemIndex}), skipping");
					return;
				}
				if (cachedItems.Count > 0)
				{
					Log.Message($"Processing {cachedItems.Count} cached items...");
					FlushQueue();
				}
				ProcessItem(index, item, save);
			}
			catch (Exception arg)
			{
				Log.Error($"HandleItem Error: {arg}");
			}
		}

		public void FlushQueue()
		{
			if (!IsGameReady())
			{
				Log.Warning("Attempted to flush queue but game is not ready");
				return;
			}
			int num = 0;
			while (cachedItems.Count > 0)
			{
				var (index, item) = cachedItems.Dequeue();
				ProcessItem(index, item, save: false);
				num++;
			}
			if (num > 0)
			{
				Log.Message($"Flushed {num} cached items");
				UnfairFlipsAPMod.SaveDataHandler.SaveGame();
			}
		}

		private void ProcessItem(int index, ItemInfo item, bool save = true)
		{
			CustomSaveData saveData = UnfairFlipsAPMod.SaveDataHandler.SaveData;
			SlotData slotData = UnfairFlipsAPMod.SlotData;
			if (index < saveData.ItemIndex)
			{
				Log.Debug($"Item {index} already processed (current: {saveData.ItemIndex})");
				return;
			}
			saveData.ItemIndex++;
			switch ((UFItem)item.ItemId)
			{
			case UFItem.ProgressiveFairness:
				saveData.Fairness++;
				Log.Debug($"Received Fairness upgrade! Level: {saveData.Fairness}");
				break;
			case UFItem.HeadsUp:
			{
				saveData.HeadsUpCount++;
				float num2 = (float)slotData.StartingHeadsChance / 100f;
				float num3 = 0.95f - num2;
				float num4 = ((slotData.HeadsUpgradeCount > 0) ? (num3 / (float)slotData.HeadsUpgradeCount) : 0f);
				saveData.HeadsChance = Math.Min(0.95f, num2 + (float)saveData.HeadsUpCount * num4);
				Log.Debug($"Received Heads Up! Chance: {saveData.HeadsChance:P1} (Total: {saveData.HeadsUpCount})");
				break;
			}
			case UFItem.FlipUp:
			{
				saveData.FlipUpCount++;
				float num5 = 4.8f;
				float num6 = ((slotData.FlipTimeUpgradeCount > 0) ? (num5 / (float)slotData.FlipTimeUpgradeCount) : 0f);
				saveData.FlipTime = Math.Max(0.2f, 5f - (float)saveData.FlipUpCount * num6);
				Log.Debug($"Received Flip Up! Time: {saveData.FlipTime:F2}s (Total: {saveData.FlipUpCount})");
				break;
			}
			case UFItem.ComboUp:
			{
				saveData.ComboUpCount++;
				float num9 = 2.3f;
				float num10 = ((slotData.ComboUpgradeCount > 0) ? (num9 / (float)slotData.ComboUpgradeCount) : 0f);
				saveData.ComboMult = Math.Min(3.5f, 1.2f + (float)saveData.ComboUpCount * num10);
				Log.Debug($"Received Combo Up! Multiplier: {saveData.ComboMult:F2}x (Total: {saveData.ComboUpCount})");
				break;
			}
			case UFItem.CoinUp:
				saveData.CoinUpgradeLevel++;
				UnfairFlipsAPMod.GameHandler?.UpdateCoinValue();
				Log.Debug($"Received Coin Up! Level: {saveData.CoinUpgradeLevel}");
				break;
			case UFItem.AutoFlipUp:
			{
				if (!saveData.HasAutoFlip)
				{
					UnfairFlipsAPMod.ArchipelagoHandler.AddMessageToGameLog("The new button in the top right turns on autoflip... In case you're feeling too lazy to press a button.");
				}
				saveData.HasAutoFlip = true;
				AutoFlipIconHandler.IsVisible = true;
				saveData.AutoFlipUpCount++;
				float num7 = 4.5f;
				float num8 = ((slotData.AutoFlipUpgradeCount > 0) ? (num7 / (float)slotData.AutoFlipUpgradeCount) : 0f);
				saveData.AutoFlipAddition = Math.Max(0.5f, 5f - (float)saveData.AutoFlipUpCount * num8);
				Log.Debug($"Received Auto Flip Up! Addition: {saveData.AutoFlipAddition:F2} (Total: {saveData.AutoFlipUpCount})");
				break;
			}
			case UFItem.TailsTrap:
				saveData.QueuedTailsTraps++;
				Log.Debug($"Received Tails Trap! Queued: {saveData.QueuedTailsTraps}");
				break;
			case UFItem.PennyTrap:
				saveData.QueuedPennyTraps++;
				Log.Debug($"Received Penny Trap! Queued: {saveData.QueuedPennyTraps}");
				break;
			case UFItem.TaxTrap:
				saveData.QueuedTaxTraps++;
				Log.Debug($"Received Tax Trap! Queued: {saveData.QueuedTaxTraps}");
				break;
			case UFItem.SlowTrap:
				saveData.QueuedSlowTraps++;
				Log.Debug($"Received Slow Trap! Queued: {saveData.QueuedSlowTraps}");
				break;
			case UFItem.Money:
			{
				float comboMult = UnfairFlipsAPMod.SaveDataHandler.SaveData.ComboMult;
				int coinValue = UnfairFlipsAPMod.SaveDataHandler.SaveData.CoinValue;
				int fairness = UnfairFlipsAPMod.SaveDataHandler.SaveData.Fairness;
				int num = 1 + fairness * 2;
				num -= 5;
				if (num <= 0)
				{
					num = 1;
				}
				BigDouble bigDouble = coinValue * new BigDouble(BigDouble.Ceiling(BigDouble.Pow(comboMult, num)));
				if (bigDouble == 0)
				{
					bigDouble = 1;
				}
				saveData.PlayerMoney += bigDouble;
				Log.Warning("Received " + Mathy.CentsToDollarString(bigDouble) + "!");
				break;
			}
			case UFItem.MoreMoney:
			{
				float comboMult = UnfairFlipsAPMod.SaveDataHandler.SaveData.ComboMult;
				int coinValue = UnfairFlipsAPMod.SaveDataHandler.SaveData.CoinValue;
				int fairness = UnfairFlipsAPMod.SaveDataHandler.SaveData.Fairness;
				int num = 1 + fairness * 2;
				num -= 3;
				if (num <= 0)
				{
					num = 1;
				}
				BigDouble bigDouble = coinValue * new BigDouble(Math.Ceiling(Math.Pow(comboMult, num)));
				if (bigDouble == 0)
				{
					bigDouble = 1;
				}
				saveData.PlayerMoney += bigDouble;
				Log.Debug("Received " + Mathy.CentsToDollarString(bigDouble) + "!");
				break;
			}
			case UFItem.BigMoney:
			{
				float comboMult = UnfairFlipsAPMod.SaveDataHandler.SaveData.ComboMult;
				int coinValue = UnfairFlipsAPMod.SaveDataHandler.SaveData.CoinValue;
				int fairness = UnfairFlipsAPMod.SaveDataHandler.SaveData.Fairness;
				int num = 1 + fairness * 2;
				num--;
				if (num <= 0)
				{
					num = 1;
				}
				BigDouble bigDouble = coinValue * new BigDouble(Math.Ceiling(Math.Pow(comboMult, num)));
				if (bigDouble == 0)
				{
					bigDouble = 1;
				}
				saveData.PlayerMoney += bigDouble;
				Log.Debug("Received " + Mathy.CentsToDollarString(bigDouble) + "!");
				break;
			}
			default:
				Log.Warning($"Unknown item: {item.ItemId} ({item.ItemName})");
				break;
			}
			if (save)
			{
				UnfairFlipsAPMod.SaveDataHandler.SaveGame();
			}
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)286))
			{
				Log.Message("F5 pressed - resyncing items...");
				UnfairFlipsAPMod.ItemHandler.FlushQueue();
				UnfairFlipsAPMod.ArchipelagoHandler.DisplayResyncMsg();
			}
		}
	}
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			_logSource.LogInfo(data);
		}

		internal static void Message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
	public class LoginHandler : MonoBehaviour
	{
		[HarmonyPatch(typeof(PanelManager))]
		private class PanelManager_Patch
		{
			[HarmonyPatch("Start")]
			[HarmonyPostfix]
			private static void Start_Postfix(PanelManager __instance)
			{
				((Component)((Transform)__instance.coinPanel).Find("FlipButton")).gameObject.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(LogoFade))]
		private class LogoFade_Patch
		{
			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			public static bool Update_Prefix(LogoFade __instance)
			{
				//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_0040: 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_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				if (!UnfairFlipsAPMod.ArchipelagoHandler.IsConnected)
				{
					return false;
				}
				((Graphic)__instance.img).color = Mathy.Decay(((Graphic)__instance.img).color, new Color(((Graphic)__instance.img).color.r, ((Graphic)__instance.img).color.g, ((Graphic)__instance.img).color.b, 0f), 8f, Time.deltaTime);
				if (((Graphic)__instance.img).color.a >= 0.05f)
				{
					return false;
				}
				Object.Destroy((Object)(object)((Component)__instance).gameObject, 0.2f);
				return false;
			}
		}

		private bool isMenuCreated;

		private GameObject menuObject;

		private ConnectionUI connectionUI;

		public void CreateUI(ArchipelagoHandler archipelagoHandler)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!isMenuCreated)
			{
				Log.Message("Creating Archipelago UI...");
				menuObject = new GameObject("ArchipelagoUI");
				Object.DontDestroyOnLoad((Object)(object)menuObject);
				connectionUI = menuObject.AddComponent<ConnectionUI>();
				connectionUI.Initialize(archipelagoHandler);
				archipelagoHandler.OnConnected += delegate
				{
					SetCoinEnabled(enabled: true);
				};
				archipelagoHandler.OnDisconnected += delegate
				{
					SetCoinEnabled(enabled: false);
				};
				isMenuCreated = true;
			}
		}

		public void ToggleUI()
		{
			if (isMenuCreated && !((Object)(object)connectionUI == (Object)null))
			{
				connectionUI.ToggleUI();
			}
		}

		public void DestroyMenu()
		{
			SetCoinEnabled(enabled: false);
			if ((Object)(object)menuObject != (Object)null)
			{
				Object.Destroy((Object)(object)menuObject);
			}
		}

		public void SetCoinEnabled(bool enabled)
		{
			GameObject val = GameObject.Find("Canvas/RATIO CANVAS/Coin Panel/FlipButton");
			if ((Object)(object)val != (Object)null)
			{
				val.SetActive(enabled);
			}
		}
	}
	public class ReceivedItemsButtonHandler
	{
		private static Sprite _buttonSprite;

		public static void CreateButton()
		{
			//IL_0112: 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_0131: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)Object.FindObjectOfType<AudioButton>()).gameObject;
			CoinFlip flip = Object.FindObjectOfType<CoinFlip>();
			Transform parent = gameObject.transform.parent;
			GameObject val = Object.Instantiate<GameObject>(gameObject, parent);
			((Object)val).name = "ReceivedItemsButton";
			Object.Destroy((Object)(object)val.GetComponent<AudioButton>());
			Image component = val.GetComponent<Image>();
			string path = Path.Combine(UnfairFlipsAPMod.PluginDir, "ArchipelagoLogo.png");
			if (File.Exists(path))
			{
				byte[] array = File.ReadAllBytes(path);
				Texture2D val2 = new Texture2D(2, 2, (TextureFormat)5, false);
				ImageConversion.LoadImage(val2, array);
				((Texture)val2).filterMode = (FilterMode)0;
				_buttonSprite = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f), 100f);
				component.sprite = _buttonSprite;
				((Graphic)component).color = Color.white;
				component.preserveAspect = true;
			}
			val.transform.localPosition = new Vector3(250f, 330f, 0f);
			Button component2 = val.GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				UnfairFlipsAPMod.ArchipelagoHandler.DisplayItemCounts();
				if ((Object)(object)flip != (Object)null)
				{
					UnfairFlipsAPMod.ArchipelagoHandler.AddMessageToGameLog($"<color=#00FF7F>TOTAL FLIPS: {flip.numFlips}</color>");
				}
			});
		}
	}
	public class CustomSaveData
	{
		public int ItemIndex;

		public int Fairness;

		public float HeadsChance;

		public float FlipTime;

		public float AutoFlipAddition;

		public float ComboMult;

		public int CoinValue;

		public int CoinUpgradeLevel;

		public int HeadsStreak;

		public int FlipCount;

		public bool HasAutoFlip;

		public int HeadsUpCount;

		public int FlipUpCount;

		public int ComboUpCount;

		public int AutoFlipUpCount;

		[SerializeField]
		private string playerMoney = "0";

		public int QueuedTailsTraps;

		public int QueuedPennyTraps;

		public int QueuedTaxTraps;

		public int QueuedSlowTraps;

		public List<long> HintedLocationIds = new List<long>();

		public BigDouble PlayerMoney
		{
			get
			{
				return BigDouble.Parse(playerMoney);
			}
			set
			{
				playerMoney = value.ToString();
			}
		}
	}
	public class SaveDataHandler
	{
		[HarmonyPatch(typeof(QuitButton))]
		public class QuitButton_Patch
		{
			[HarmonyPatch("Click")]
			[HarmonyPrefix]
			public static bool Click_Prefix(QuitButton __instance)
			{
				if ((Object)(object)Object.FindObjectOfType<PanelManager>() != (Object)null && Object.FindObjectOfType<PanelManager>().GetCurrentArrangement() == 0)
				{
					Object.FindObjectOfType<PanelManager>().SetPanelArrangement(1);
				}
				if (!__instance.quitPrimed)
				{
					Object.FindObjectOfType<MessageManager>().ShowMessage("<color=#ffbbbb>CLICK AGAIN TO QUIT GAME. PROGRESS IS SAVED AUTOMATICALLY</color>");
					__instance.quitPrimed = true;
					UnfairFlipsAPMod.SaveDataHandler.SaveGame();
				}
				else
				{
					UnfairFlipsAPMod.SaveDataHandler.SaveGame();
					Application.Quit();
				}
				return false;
			}

			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			public static bool Update_Prefix(QuitButton __instance)
			{
				return false;
			}
		}

		private string folderName;

		private string fileName;

		public CustomSaveData SaveData;

		public ShopButton[] ShopButtons;

		public void GetSaveGame(string seed, string slot)
		{
			if (SaveData == null)
			{
				UnfairFlipsAPMod.ArchipelagoHandler.OnDisconnected += delegate
				{
					SaveGame();
					SaveData = null;
				};
				folderName = "./ArchipelagoSaves";
				fileName = folderName + "/" + slot + seed + ".coin";
				if (File.Exists(fileName))
				{
					LoadGame();
				}
				else
				{
					CreateNewGame();
				}
				UnfairFlipsAPMod.ItemHandler.FlushQueue();
			}
		}

		private void LoadGame()
		{
			Log.Debug("Loading game...");
			try
			{
				using FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
				using StreamReader streamReader = new StreamReader(stream);
				string text = streamReader.ReadToEnd();
				SaveData = JsonUtility.FromJson<CustomSaveData>(text);
				if (SaveData.HasAutoFlip)
				{
					AutoFlipIconHandler.IsVisible = true;
				}
			}
			catch (Exception ex)
			{
				Log.Debug("Save file is corrupted or locked: " + ex.Message + ". Starting new game...");
				CreateNewGame();
				return;
			}
			CoinFlip val = Object.FindObjectOfType<CoinFlip>();
			val.SetHeadsStreak(SaveData.HeadsStreak);
			val.SetNumFlips(SaveData.FlipCount);
			Log.Debug("Game loaded!");
		}

		private void CreateNewGame()
		{
			Log.Debug("Creating new game...");
			SaveData = new CustomSaveData();
			SaveData.Fairness = 0;
			SaveData.HeadsUpCount = 0;
			SaveData.FlipUpCount = 0;
			SaveData.ComboUpCount = 0;
			SaveData.AutoFlipUpCount = 0;
			SaveData.HeadsChance = (float)UnfairFlipsAPMod.SlotData.StartingHeadsChance / 100f;
			SaveData.FlipTime = 5f;
			SaveData.ComboMult = 1.2f;
			SaveData.CoinValue = 1;
			SaveData.CoinUpgradeLevel = 0;
			SaveData.AutoFlipAddition = 5f;
			SaveData.ItemIndex = 0;
			SaveData.PlayerMoney = 0;
			SaveGame();
		}

		public void ResetGame()
		{
			SceneManager.LoadScene("Game");
		}

		public void SaveGame()
		{
			Log.Debug("Starting save...");
			CoinFlip val = Object.FindObjectOfType<CoinFlip>();
			SaveData.HeadsStreak = val.GetHeadsStreak();
			SaveData.FlipCount = val.GetNumFlips();
			FinishSavingGame();
		}

		private void FinishSavingGame()
		{
			Log.Debug("Saving game...");
			Directory.CreateDirectory(folderName);
			Log.Debug("Creating save file...");
			using StreamWriter streamWriter = File.CreateText(fileName);
			streamWriter.Write(JsonUtility.ToJson((object)SaveData));
			streamWriter.Close();
		}
	}
	public class ShopButtonHoverHandler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
	{
		public string tooltipText;

		public void OnPointerEnter(PointerEventData eventData)
		{
			if (!string.IsNullOrEmpty(tooltipText))
			{
				TooltipHandler.Instance.Show(tooltipText, ((Component)this).GetComponent<RectTransform>());
			}
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			TooltipHandler.Instance.Hide();
		}

		private void OnDisable()
		{
			if ((Object)(object)TooltipHandler.Instance != (Object)null)
			{
				TooltipHandler.Instance.Hide();
			}
		}
	}
	public class ShopHandler
	{
		[HarmonyPatch(typeof(ShopButton))]
		public class ShopButton_Patch
		{
			public static Dictionary<ShopButton, BigDouble> Costs = new Dictionary<ShopButton, BigDouble>();

			private static Dictionary<UpgradeType, string> PurchaseNames = new Dictionary<UpgradeType, string>
			{
				{
					(UpgradeType)0,
					"Heads Chance Purchase"
				},
				{
					(UpgradeType)3,
					"Coin Value Purchase"
				},
				{
					(UpgradeType)2,
					"Combo Mult Purchase"
				},
				{
					(UpgradeType)1,
					"Flip Time Purchase"
				}
			};

			private static List<int> _valueUpgradeGates = null;

			[HarmonyPatch("Start")]
			[HarmonyPostfix]
			public static void Start_Postfix(ShopButton __instance)
			{
				((Component)__instance).gameObject.AddComponent<ShopButtonHoverHandler>();
			}

			private static List<int> InitializeValueUpgradeGates(int gateCount)
			{
				List<int> list = new List<int>();
				for (int i = 0; i < 4; i++)
				{
					list.Add(Mathf.RoundToInt((float)((i + 1) * (gateCount - 1)) / 4f));
				}
				return list;
			}

			public static BigDouble GetCost(int gateIndex)
			{
				int num = (int)Math.Ceiling((double)(UnfairFlipsAPMod.SlotData.RequiredHeads + 1) / 2.0);
				if (_valueUpgradeGates == null)
				{
					_valueUpgradeGates = InitializeValueUpgradeGates(num);
				}
				float num2 = 1.2f + 2.3f / (float)num * (float)gateIndex;
				float num3 = (float)UnfairFlipsAPMod.SlotData.StartingHeadsChance / 100f + (0.95f - (float)UnfairFlipsAPMod.SlotData.StartingHeadsChance / 100f) / (float)num * (float)gateIndex;
				int num4 = _valueUpgradeGates.Count((int x) => x <= gateIndex);
				int num5 = ArchipelagoConstants.CoinValues[num4];
				int num6 = 1 + gateIndex * 2;
				int num7 = UnfairFlipsAPMod.SlotData.FlipDifficulty * num5;
				BigDouble bigDouble = 0;
				for (int num8 = 0; num8 < num6; num8++)
				{
					bigDouble += BigDouble.Pow(num2, num8) * BigDouble.Pow(num3, num8 + 1);
				}
				bigDouble *= (BigDouble)num7;
				BigDouble bigDouble2 = bigDouble;
				float num9 = Random.Range(0.8f, 0.95f);
				return BigDouble.Ceiling(bigDouble2 * num9);
			}

			[HarmonyPatch("Update")]
			[HarmonyPrefix]
			public static bool Update_Prefix(ShopButton __instance)
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				if (!UnfairFlipsAPMod.ArchipelagoHandler.IsConnected || UnfairFlipsAPMod.SlotData == null)
				{
					return false;
				}
				int num = (int)Math.Ceiling(((float)UnfairFlipsAPMod.SlotData.RequiredHeads + 1f) / 2f);
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < 2; j++)
					{
						int num2 = i * 2 + j;
						long num3 = 512 + num2 * 4 + __instance.upgradeType;
						if (UnfairFlipsAPMod.ArchipelagoHandler.IsLocationChecked(num3))
						{
							continue;
						}
						ShopButtonHoverHandler component = ((Component)__instance).GetComponent<ShopButtonHoverHandler>();
						if (!scoutedLocations.ContainsKey(num3))
						{
							bool flag = !UnfairFlipsAPMod.SaveDataHandler.SaveData.HintedLocationIds.Contains(num3);
							ScoutedItemInfo val = UnfairFlipsAPMod.ArchipelagoHandler.TryScoutLocation(num3);
							if (((Enum)((ItemInfo)val).Flags).HasFlag((Enum)(object)(ItemFlags)1))
							{
								UnfairFlipsAPMod.ArchipelagoHandler.TryScoutLocation(num3, createHint: true);
							}
							scoutedLocations[num3] = val;
							if (flag)
							{
								UnfairFlipsAPMod.SaveDataHandler.SaveData.HintedLocationIds.Add(num3);
								UnfairFlipsAPMod.SaveDataHandler.SaveGame();
							}
							if (Costs.ContainsKey(__instance))
							{
								Costs[__instance] = GetCost(i);
							}
							else
							{
								Costs.TryAdd(__instance, GetCost(i));
							}
							string text = ((ItemInfo)val).ItemDisplayName;
							int length = text.Length;
							if (length > 23)
							{
								text = text.Substring(0, 23) + "...";
							}
							__instance.text.text = text + "\n" + Mathy.CentsToDollarString(Costs[__instance]);
						}
						if ((Object)(object)component != (Object)null && scoutedLocations.TryGetValue(num3, out var value))
						{
							ArchipelagoHandler archipelagoHandler = UnfairFlipsAPMod.ArchipelagoHandler;
							string itemDisplayName = ((ItemInfo)value).ItemDisplayName;
							string playerName = archipelagoHandler.GetPlayerName(PlayerInfo.op_Implicit(value.Player));
							string itemGame = ((ItemInfo)value).ItemGame;
							(string name, string color) rarityInfo = GetRarityInfo(((ItemInfo)value).Flags);
							string item = rarityInfo.name;
							string item2 = rarityInfo.color;
							component.tooltipText = $"{PurchaseNames[__instance.upgradeType]} {num2 + 1}\nItem: {itemDisplayName}\nfor {playerName} in {itemGame}\nTier: <color={item2}>{item}</color>";
						}
						__instance.text.overflowMode = (TextOverflowModes)3;
						((Selectable)__instance.button).interactable = UnfairFlipsAPMod.SaveDataHandler.SaveData.PlayerMoney >= Costs[__instance];
						currentLocationForButton[__instance] = num3;
						return false;
					}
				}
				currentLocationForButton.Remove(__instance);
				((Component)__instance).gameObject.SetActive(false);
				return false;
			}

			private static (string name, string color) GetRarityInfo(ItemFlags flags)
			{
				//IL_0001: 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_004f: Unknown result type (might be due to invalid IL or missing references)
				if (((Enum)flags).HasFlag((Enum)(object)(ItemFlags)1))
				{
					return (name: "Progression", color: "#AF99EF");
				}
				if (((Enum)flags).HasFlag((Enum)(object)(ItemFlags)4))
				{
					return (name: "Trap", color: "#EE0000");
				}
				if (((Enum)flags).HasFlag((Enum)(object)(ItemFlags)2))
				{
					return (name: "Useful", color: "#6495ED");
				}
				return (name: "Filler", color: "#FFFFFF");
			}

			[HarmonyPatch("Buy")]
			[HarmonyPrefix]
			public static bool Buy_Prefix(ShopButton __instance)
			{
				if (!currentLocationForButton.TryGetValue(__instance, out var value))
				{
					return false;
				}
				UnfairFlipsAPMod.SaveDataHandler.SaveData.PlayerMoney -= Costs[__instance];
				UnfairFlipsAPMod.ArchipelagoHandler.CheckLocation(value);
				return false;
			}

			[HarmonyPatch("SetShopLevel")]
			[HarmonyPrefix]
			public static bool SetShopLevel_Prefix(int level)
			{
				return false;
			}

			[HarmonyPatch("IncreaseHeadsChance")]
			[HarmonyPrefix]
			public static bool IncreaseHeadsChance(float amount)
			{
				return false;
			}

			[HarmonyPatch("DecreaseFlipTime")]
			[HarmonyPrefix]
			public static bool DecreaseFlipTime(float amount)
			{
				return false;
			}

			[HarmonyPatch("IncreaseFlipMultiplier")]
			[HarmonyPrefix]
			public static bool IncreaseFlipMultiplier(float amount)
			{
				return false;
			}

			[HarmonyPatch("IncreaseFlipBaseWorth")]
			[HarmonyPrefix]
			public static bool IncreaseFlipBaseWorth()
			{
				return false;
			}
		}

		private static readonly Dictionary<long, ScoutedItemInfo> scoutedLocations = new Dictionary<long, ScoutedItemInfo>();

		private static readonly Dictionary<ShopButton, long> currentLocationForButton = new Dictionary<ShopButton, long>();
	}
	public class SlotData
	{
		public readonly int RequiredHeads;

		public readonly int StartingHeadsChance;

		public readonly bool DeathLink;

		public readonly int DeathLinkChance;

		public readonly int DeathLinkMinStreak;

		public readonly int HeadsUpgradeCount;

		public readonly int FlipTimeUpgradeCount;

		public readonly int ComboUpgradeCount;

		public readonly int AutoFlipUpgradeCount;

		public readonly int FlipDifficulty;

		public readonly bool AutoFlipEnabled;

		public SlotData(Dictionary<string, object> slotDict)
		{
			if (slotDict.TryGetValue("RequiredHeads", out var value))
			{
				RequiredHeads = (int)(long)value;
			}
			if (slotDict.TryGetValue("StartingHeadsChance", out var value2))
			{
				StartingHeadsChance = (int)(long)value2;
			}
			if (slotDict.TryGetValue("DeathLink", out var value3))
			{
				DeathLink = (int)(long)value3 == 1;
			}
			if (slotDict.TryGetValue("DeathLinkChance", out var value4))
			{
				DeathLinkChance = (int)(long)value4;
			}
			if (slotDict.TryGetValue("DeathLinkMinStreak", out var value5))
			{
				DeathLinkMinStreak = (int)(long)value5;
			}
			if (slotDict.TryGetValue("HeadsUpgradeCount", out var value6))
			{
				HeadsUpgradeCount = (int)(long)value6;
			}
			if (slotDict.TryGetValue("FlipSpeedUpgradeCount", out var value7))
			{
				FlipTimeUpgradeCount = (int)(long)value7;
			}
			if (slotDict.TryGetValue("ComboUpgradeCount", out var value8))
			{
				ComboUpgradeCount = (int)(long)value8;
			}
			if (slotDict.TryGetValue("AutoFlipUpgradeCount", out var value9))
			{
				AutoFlipUpgradeCount = (int)(long)value9;
			}
			if (slotDict.TryGetValue("FlipDifficulty", out var value10))
			{
				FlipDifficulty = (int)(long)value10;
			}
			if (slotDict.TryGetValue("AutoFlipEnabled", out var value11))
			{
				AutoFlipEnabled = (int)(long)value11 == 1;
			}
			if (DeathLink)
			{
				UnfairFlipsAPMod.ArchipelagoHandler.UpdateTags(new List<string>(1) { "DeathLink" });
			}
			UnfairFlipsAPMod.ItemHandler.FlushQueue();
		}
	}
	[Serializable]
	public class SlotDataException : ApplicationException
	{
		public SlotDataException()
		{
		}

		public SlotDataException(string message)
			: base(message)
		{
		}

		public SlotDataException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public class TooltipHandler : MonoBehaviour
	{
		private static TooltipHandler _instance;

		private GameObject tooltipObject;

		private TextMeshProUGUI tooltipText;

		private RectTransform tooltipRect;

		private Image background;

		private Canvas canvas;

		private RectTransform currentTarget;

		public static TooltipHandler Instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if ((Object)(object)_instance == (Object)null)
				{
					GameObject val = new GameObject("TooltipHandler");
					_instance = val.AddComponent<TooltipHandler>();
					Object.DontDestroyOnLoad((Object)(object)val);
				}
				return _instance;
			}
		}

		private void Awake()
		{
			if ((Object)(object)_instance != (Object)null && (Object)(object)_instance != (Object)(object)this)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
				return;
			}
			_instance = this;
			CreateTooltip();
		}

		private void CreateTooltip()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_008a: 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_00a0: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			canvas = Object.FindObjectOfType<Canvas>();
			if ((Object)(object)canvas == (Object)null)
			{
				return;
			}
			tooltipObject = new GameObject("ShopTooltip");
			tooltipObject.transform.SetParent(((Component)canvas).transform, false);
			tooltipRect = tooltipObject.AddComponent<RectTransform>();
			background = tooltipObject.AddComponent<Image>();
			((Graphic)background).color = new Color(0f, 0f, 0f, 0.8f);
			GameObject val = new GameObject("Text");
			val.transform.SetParent(tooltipObject.transform, false);
			tooltipText = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)tooltipText).fontSize = 24f;
			((TMP_Text)tooltipText).alignment = (TextAlignmentOptions)514;
			((Graphic)tooltipText).color = Color.white;
			MessageManager val2 = Object.FindObjectOfType<MessageManager>();
			if ((Object)(object)val2 != (Object)null && (Object)(object)val2.prf_message != (Object)null)
			{
				TMP_Text component = ((Component)val2.prf_message).GetComponent<TMP_Text>();
				if ((Object)(object)component != (Object)null)
				{
					((TMP_Text)tooltipText).font = component.font;
				}
			}
			RectTransform component2 = val.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.sizeDelta = new Vector2(-15f, -15f);
			tooltipObject.SetActive(false);
		}

		public void Show(string text, RectTransform target = null)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)tooltipObject == (Object)null)
			{
				CreateTooltip();
			}
			if (!((Object)(object)tooltipObject == (Object)null))
			{
				currentTarget = target;
				((TMP_Text)tooltipText).text = text;
				tooltipObject.SetActive(true);
				tooltipObject.transform.SetAsLastSibling();
				Vector2 preferredValues = ((TMP_Text)tooltipText).GetPreferredValues(text);
				tooltipRect.sizeDelta = new Vector2(preferredValues.x + 30f, preferredValues.y + 30f);
				UpdatePosition();
			}
		}

		public void Hide()
		{
			currentTarget = null;
			if ((Object)(object)tooltipObject != (Object)null)
			{
				tooltipObject.SetActive(false);
			}
		}

		private void Update()
		{
			if ((Object)(object)tooltipObject != (Object)null && tooltipObject.activeSelf)
			{
				UpdatePosition();
			}
		}

		private void UpdatePosition()
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_0084: 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_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)currentTarget != (Object)null)
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				currentTarget.GetWorldCorners(array);
				float num = (array[0].x + array[3].x) / 2f;
				float y = array[0].y;
				((Transform)tooltipRect).position = new Vector3(num, y - 5f, 0f);
				tooltipRect.pivot = new Vector2(0.5f, 1f);
				return;
			}
			Vector2 val = Vector2.op_Implicit(Input.mousePosition);
			((Transform)tooltipRect).position = Vector2.op_Implicit(val + new Vector2(20f, 20f));
			Vector2 pivot = default(Vector2);
			((Vector2)(ref pivot))..ctor(0f, 0f);
			if (val.x + tooltipRect.sizeDelta.x > (float)Screen.width)
			{
				pivot.x = 1f;
			}
			if (val.y + tooltipRect.sizeDelta.y > (float)Screen.height)
			{
				pivot.y = 1f;
			}
			tooltipRect.pivot = pivot;
		}
	}
	[BepInPlugin("UnfairFlipsAPMod", "Unfair Flips Archipelago Mod", "1.4.6")]
	public class UnfairFlipsAPMod : BaseUnityPlugin
	{
		private const string PluginGuid = "UnfairFlipsAPMod";

		private const string PluginName = "Unfair Flips Archipelago Mod";

		private const string PluginVersion = "1.4.6";

		public static string PluginDir;

		private readonly Harmony harmony = new Harmony("UnfairFlipsAPMod");

		public static ConfigEntry<bool>? FilterLog;

		public static ConfigEntry<float>? MessageInTime;

		public static ConfigEntry<float>? MessageHoldTime;

		public static ConfigEntry<float>? MessageOutTime;

		public static SlotData SlotData;

		public static ArchipelagoHandler ArchipelagoHandler { get; private set; }

		private static LoginHandler LoginHandler { get; set; }

		public static GameHandler GameHandler { get; private set; }

		public static ItemHandler ItemHandler { get; private set; }

		public static SaveDataHandler SaveDataHandler { get; private set; }

		public void Awake()
		{
			PluginDir = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			Application.runInBackground = true;
			harmony.PatchAll();
			Log.Init(((BaseUnityPlugin)this).Logger);
			MetaManager val = Object.FindObjectOfType<MetaManager>();
			Object.Destroy((Object)(object)val);
			((Component)this).gameObject.AddComponent<FileWriter>();
			ArchipelagoHandler = ((Component)this).gameObject.AddComponent<ArchipelagoHandler>();
			LoginHandler = ((Component)this).gameObject.AddComponent<LoginHandler>();
			LoginHandler.CreateUI(ArchipelagoHandler);
			GameHandler = ((Component)this).gameObject.AddComponent<GameHandler>();
			ItemHandler = ((Component)this).gameObject.AddComponent<ItemHandler>();
			SaveDataHandler = new SaveDataHandler();
			((Component)this).gameObject.AddComponent<CounterPatches>();
			ArchipelagoHandler.OnConnected += delegate
			{
				Log.Message("Connected to Archipelago - loading items");
				LoginHandler.ToggleUI();
			};
			ArchipelagoHandler.OnDisconnected += delegate
			{
				Log.Message("Disconnected from Archipelago");
				LoginHandler.ToggleUI();
			};
			FilterLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Logging", "FilterLog", false, "Filter the archipelago log to only show messages relevant to you.");
		}

		public void OnDestroy()
		{
			ArchipelagoHandler?.Disconnect();
			LoginHandler?.DestroyMenu();
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}