Decompiled source of Genie v1.1.4

Get the Thunderstore App

Easily install and manage your mods with the Thunderstore App!
Decompiled source of Genie v1.1.4

Genie.dll

Decompiled 2 months ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using CardChoiceSpawnUniqueCardPatch.CustomCategories;
using DrawNCards;
using HarmonyLib;
using ItemShops;
using ItemShops.Extensions;
using ItemShops.Utils;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using ModdingUtils.Utils;
using Nullmanager;
using Photon.Pun;
using RarityLib.Utils;
using RootCore;
using TMPro;
using UnboundLib;
using UnboundLib.GameModes;
using UnboundLib.Networking;
using UnboundLib.Utils;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.UI.ProceduralImage;
using WillsWackyManagers.Utils;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: SecurityPermission(8, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.4.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Genie
{
	public class Curseed : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Curse>d__3 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Curseed <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Curse>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				Curseed curseed = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				CurseManager.instance.CursePlayer(curseed.player, (Func<CardInfo, Player, bool>)((CardInfo c, Player p) => !Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)c.categories, CustomCardCategories.instance.CardCategory("KindCurse"))));
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		private Player player;

		private void Awake()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)Curse);
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)Curse);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator Curse(IGameModeHandler _)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Curse>d__3(0)
			{
				<>4__this = this
			};
		}
	}
	public class Efreet : OnAddEffect
	{
		public override void OnAdd(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			GenieCard.CursePlayer(player);
		}
	}
	public class EndlessAdd : OnAddEffect
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0 : Object
		{
			public Player player;

			public CardInfo card;

			internal bool <LockCard>b__0()
			{
				if ((Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards) != (Object)(object)card)
				{
					return (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards) != (Object)(object)CardList.GetCardInfo("Genie_Endless");
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <LockCard>d__1 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			private <>c__DisplayClass1_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LockCard>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass1_0();
					<>8__1.player = player;
					<>8__1.card = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards) != (Object)(object)<>8__1.card && (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards) != (Object)(object)CardList.GetCardInfo("Genie_Endless")));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					CharacterStatModifiersExtension.GetRootData(<>8__1.player).perpetualCard = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards).sourceCard = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					return false;
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		public override void OnAdd(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			((MonoBehaviour)Core.instance).StartCoroutine(LockCard(player));
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		public static IEnumerator LockCard(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <LockCard>d__1(0)
			{
				player = player
			};
		}
	}
	public class EternityAdd : OnAddEffect
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0 : Object
		{
			public Player player;

			public CardInfo card;

			internal bool <LockCard>b__0()
			{
				if ((Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards) != (Object)(object)card)
				{
					return (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards) != (Object)(object)CardList.GetCardInfo("Genie_Eternity");
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <LockCard>d__1 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			private <>c__DisplayClass1_0 <>8__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LockCard>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass1_0();
					<>8__1.player = player;
					<>8__1.card = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards) != (Object)(object)<>8__1.card && (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards) != (Object)(object)CardList.GetCardInfo("Genie_Eternity")));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					CharacterStatModifiersExtension.GetRootData(<>8__1.player).lockedCard = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards).sourceCard = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					return false;
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		public override void OnAdd(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			((MonoBehaviour)Core.instance).StartCoroutine(LockCard(player));
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		public static IEnumerator LockCard(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <LockCard>d__1(0)
			{
				player = player
			};
		}
	}
	public class GenieCard : Object
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass10_0 : Object
		{
			public bool done;

			internal void <WaitTillShopDone>b__0(Player p)
			{
				if (PlayerExtension.GetAdditionalData(p).bankAccount.HasFunds(wishes))
				{
					Genie_Shop.Show(p);
					done = false;
				}
			}

			internal void <WaitTillShopDone>b__1(Player p)
			{
				if (ShopManager.instance.PlayerIsInShop(p))
				{
					done = false;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass7_0 : Object
		{
			public Player player;

			public List<CardInfo> newCards;

			internal void <GenieRerollAction>b__1()
			{
				Cards.instance.AddCardsToPlayer(player, newCards.ToArray(), true, (string[])null, (float[])null, (float[])null, true);
			}
		}

		[CompilerGenerated]
		private sealed class <RestCardLock>d__11 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RestCardLock>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				CursedPlayers.Clear();
				Player[] array = PlayerManager.instance.players.ToArray();
				foreach (Player val in array)
				{
					CharacterStatModifiersExtension.GetRootData(val).lockedCard = null;
					CursedPlayers[val.playerID] = 0;
				}
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <SetUpShop>d__9 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <SetUpShop>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0032: 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)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				List<Card> obj = Enumerable.ToList<Card>((IEnumerable<Card>)(object)CardManager.cards.Values);
				List<CardItem> val = new List<CardItem>();
				Core.Debug((object)"Setting up shop");
				Enumerator<Card> enumerator = obj.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						Card current = enumerator.Current;
						Core.Debug((object)current?.cardInfo.cardName);
						if (current != null && (Object)(object)current.cardInfo != (Object)(object)CardList.GetCardInfo("Genie") && (Object)(object)current.cardInfo != (Object)(object)CardList.GetCardInfo("Efreet") && (Object)(object)current.cardInfo != (Object)(object)CardList.GetCardInfo("Cake_Divine") && CardManager.IsCardActive(current.cardInfo) && !current.cardInfo.cardName.ToLower().Contains("half ass copy cat") && !current.cardInfo.cardName.ToLower().Contains("wheel of fortune") && !current.cardInfo.cardName.ToLower().Contains("zero point"))
						{
							CardInfo cardInfo = current.cardInfo;
							RootCardInfo val2 = (RootCardInfo)(object)((cardInfo is RootCardInfo) ? cardInfo : null);
							if (val2 == null || !val2.Restricted || !val2.Key.StartsWith("Cake_") || CardManager.IsCardActive((CardInfo)(object)CardList.GetCardInfo("Cake_Toggle")))
							{
								val.Add(new CardItem(current));
								Core.Debug((object)"Added To Shop");
							}
						}
					}
				}
				finally
				{
					((IDisposable)enumerator).Dispose();
				}
				Shop genie_Shop = Genie_Shop;
				string[] array = Enumerable.ToArray<string>(Enumerable.Select<CardItem, string>((IEnumerable<CardItem>)(object)val, (Func<CardItem, string>)((CardItem c) => String.Concat(c.Card.cardInfo.cardName, ((Object)c.Card.cardInfo).name))));
				Purchasable[] array2 = (Purchasable[])(object)val.ToArray();
				genie_Shop.AddItems(array, array2);
				Core.Debug((object)"Finnished setting up shop");
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <WaitTillShopDone>d__10 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass10_0 <>8__1;

			private GameObject <gameObject>5__2;

			private GameObject <timer>5__3;

			private float <time>5__4;

			private int <i>5__5;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <WaitTillShopDone>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<gameObject>5__2 = null;
				<timer>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: 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_0123: Expected O, but got Unknown
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0230: Unknown result type (might be due to invalid IL or missing references)
				//IL_023a: Expected O, but got Unknown
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Expected O, but got Unknown
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass10_0();
					<>8__1.done = true;
					<gameObject>5__2 = null;
					<timer>5__3 = null;
					<time>5__4 = 120f;
					PlayerManager.instance.players.ForEach((Action<Player>)delegate(Player p)
					{
						if (PlayerExtension.GetAdditionalData(p).bankAccount.HasFunds(wishes))
						{
							Genie_Shop.Show(p);
							<>8__1.done = false;
						}
					});
					if (<>8__1.done)
					{
						break;
					}
					<gameObject>5__2 = new GameObject();
					<gameObject>5__2.AddComponent<Canvas>().sortingLayerName = "MostFront";
					((TMP_Text)<gameObject>5__2.AddComponent<TextMeshProUGUI>()).text = "Waiting For Players In Wish Menu";
					Color magenta = Color.magenta;
					magenta.a = 0.85f;
					((Graphic)<gameObject>5__2.GetComponent<TextMeshProUGUI>()).color = magenta;
					<gameObject>5__2.transform.localScale = new Vector3(0.2f, 0.2f);
					<gameObject>5__2.transform.localPosition = new Vector3(0f, 5f);
					<timer>5__3 = new GameObject();
					<timer>5__3.AddComponent<Canvas>().sortingLayerName = "MostFront";
					<timer>5__3.transform.localScale = new Vector3(0.2f, 0.2f);
					<timer>5__3.transform.localPosition = new Vector3(0f, 16f);
					((Graphic)<timer>5__3.AddComponent<TextMeshProUGUI>()).color = magenta;
					<i>5__5 = 0;
					goto IL_01f1;
				}
				case 1:
					<>1__state = -1;
					<time>5__4 -= 1f;
					num = <i>5__5++;
					goto IL_01f1;
				case 2:
					{
						<>1__state = -1;
						<time>5__4 -= 0.2f;
						PlayerManager.instance.players.ForEach((Action<Player>)delegate(Player p)
						{
							if (ShopManager.instance.PlayerIsInShop(p))
							{
								<>8__1.done = false;
							}
						});
						if (<time>5__4 <= 0f)
						{
							ShopManager.instance.HideAllShops();
							<>8__1.done = true;
						}
						break;
					}
					IL_01f1:
					if (<i>5__5 < 5)
					{
						TextMeshProUGUI component = <timer>5__3.GetComponent<TextMeshProUGUI>();
						num = (int)<time>5__4;
						((TMP_Text)component).text = ((Int32)(ref num)).ToString();
						<>2__current = (object)new WaitForSecondsRealtime(1f);
						<>1__state = 1;
						return true;
					}
					break;
				}
				if (!<>8__1.done)
				{
					TextMeshProUGUI component2 = <timer>5__3.GetComponent<TextMeshProUGUI>();
					num = (int)<time>5__4;
					((TMP_Text)component2).text = ((Int32)(ref num)).ToString();
					<>8__1.done = true;
					<>2__current = (object)new WaitForSecondsRealtime(0.2f);
					<>1__state = 2;
					return true;
				}
				Object.Destroy((Object)(object)<gameObject>5__2);
				Object.Destroy((Object)(object)<timer>5__3);
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Wish>d__8 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Wish>d__8(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				wishes = new Dictionary<string, int>();
				wishes.Add("Wish", 1);
				if ((Object)(object)Genie_Shop != (Object)null)
				{
					ShopManager.instance.RemoveShop(Genie_Shop);
				}
				Genie_Shop = ShopManager.instance.CreateShop(ShopID);
				Genie_Shop.UpdateMoneyColumnName("Wishes");
				Genie_Shop.UpdateTitle("Be Carful What You Wish For");
				((MonoBehaviour)Core.instance).StartCoroutine(SetUpShop());
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		public static Shop Genie_Shop;

		public static string ShopID = "Root_Genie_Shop";

		public static Dictionary<string, int> wishes = new Dictionary<string, int>();

		internal static Dictionary<int, int> CursedPlayers = new Dictionary<int, int>();

		internal static int IsCursed(Player player)
		{
			if (!CursedPlayers.ContainsKey(player.playerID))
			{
				CursedPlayers[player.playerID] = 0;
			}
			return CursedPlayers[player.playerID];
		}

		internal static void CursePlayer(Player player)
		{
			if (!CursedPlayers.ContainsKey(player.playerID))
			{
				CursedPlayers[player.playerID] = 0;
			}
			Dictionary<int, int> cursedPlayers = CursedPlayers;
			int playerID = player.playerID;
			int num = cursedPlayers[playerID];
			cursedPlayers[playerID] = num + 1;
		}

		internal static bool CanEternity(CardInfo card)
		{
			if (card.cardName == "Shuffle")
			{
				return false;
			}
			if (!Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)card.categories, CustomCardCategories.instance.CardCategory("CardManipulation")))
			{
				return !Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)card.categories, CustomCardCategories.instance.CardCategory("cantEternity"));
			}
			return false;
		}

		internal static void GenieRerollAction(Player player, CardInfo[] originalCards)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			<>c__DisplayClass7_0 CS$<>8__locals0 = new <>c__DisplayClass7_0();
			CS$<>8__locals0.player = player;
			List<CardInfo> val = Enumerable.ToList<CardInfo>(Enumerable.Where<CardInfo>((IEnumerable<CardInfo>)(object)originalCards, (Func<CardInfo, bool>)((CardInfo c) => Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)c.categories, CustomCardCategories.instance.CardCategory("GenieOutcome")))));
			if (val.Count != 0)
			{
				CS$<>8__locals0.newCards = new List<CardInfo>();
				List<CardInfo> val2 = Enumerable.ToList<CardInfo>((IEnumerable<CardInfo>)(object)CS$<>8__locals0.player.data.currentCards);
				while (val2.Count < val.Count)
				{
					val.RemoveAt(Random.Range(0, val.Count));
				}
				for (int i = 0; i < val.Count; i++)
				{
					CS$<>8__locals0.newCards.Add(val[i]);
					CS$<>8__locals0.newCards.Add(val2[i]);
				}
				val2.RemoveRange(0, val.Count);
				CS$<>8__locals0.newCards.AddRange((IEnumerable<CardInfo>)(object)val2);
				Cards.instance.RemoveAllCardsFromPlayer(CS$<>8__locals0.player, true);
				ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Core.instance, 2, (Action)delegate
				{
					Cards.instance.AddCardsToPlayer(CS$<>8__locals0.player, CS$<>8__locals0.newCards.ToArray(), true, (string[])null, (float[])null, (float[])null, true);
				});
			}
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		internal static IEnumerator Wish()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Wish>d__8(0);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		internal static IEnumerator SetUpShop()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <SetUpShop>d__9(0);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		internal static IEnumerator WaitTillShopDone()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <WaitTillShopDone>d__10(0);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		internal static IEnumerator RestCardLock()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <RestCardLock>d__11(0);
		}
	}
	internal class CardItem : Purchasable
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass12_0 : Object
		{
			public Player player;

			public bool can_eternity;

			public CardItem <>4__this;

			public CardInfo card;

			public float range;

			internal bool <GetValidOutcomes>b__0(RootCardInfo c)
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				if (Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)((CardInfo)c).categories, CustomCardCategories.instance.CardCategory("GenieOutcome")) && (((CardInfo)c).allowMultiple || !UtilityExtenions.HasCard(player, (CardInfo)(object)c)) && (c.Key != "Genie_Debt" || GameModeManager.CurrentHandler.GetTeamScore(player.teamID).rounds > 0))
				{
					if (!can_eternity)
					{
						return c.Key != "Genie_Eternity";
					}
					return true;
				}
				return false;
			}

			internal bool <GetValidOutcomes>b__1(RootCardInfo c)
			{
				//IL_0007: 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_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				if (<>4__this.GetDistance(((CardInfo)c).rarity, card.rarity) < range)
				{
					if (range != 6f || !UtilityExtenions.IsAllowedCard(player, card))
					{
						return RarityUtils.GetRarityData(((CardInfo)c).rarity).relativeRarity <= RarityUtils.GetRarityData(card.rarity).relativeRarity * Mathf.Max(1f, 8f / range);
					}
					return true;
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_0 : Object
		{
			public float target;

			public Player player;

			public CardInfo card;

			public Action<Player> <>9__4;

			internal float <DoGenieWish>b__0(float f)
			{
				return Mathf.Abs(f - target);
			}

			internal void <DoGenieWish>b__4(Player p)
			{
				if (p.playerID != player.playerID)
				{
					Cards.instance.AddCardToPlayer(p, card, false, "", 2f, 2f, true);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass13_1 : Object
		{
			public RootCardInfo oCard;

			public <>c__DisplayClass13_0 CS$<>8__locals1;

			internal void <DoGenieWish>b__2()
			{
				Cards.instance.AddCardToPlayer(CS$<>8__locals1.player, (CardInfo)(object)oCard, false, "", 2f, 2f, true);
				Cards.instance.AddCardToPlayer(CS$<>8__locals1.player, CS$<>8__locals1.card, false, "", 2f, 2f, true);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass16_0 : Object
		{
			public GameObject cardObj;

			internal void <GetCardVisuals>b__0()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: 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)
				CardRarityColor[] componentsInChildren = cardObj.GetComponentsInChildren<CardRarityColor>();
				foreach (CardRarityColor val in componentsInChildren)
				{
					try
					{
						val.Toggle(true);
					}
					catch (Object)
					{
					}
				}
				TextMeshProUGUI component = FindObjectInChildren(cardObj, "Text_Name").GetComponent<TextMeshProUGUI>();
				if (((Graphic)component).color.r < 0.18f && ((Graphic)component).color.g < 0.18f && ((Graphic)component).color.b < 0.18f)
				{
					((Graphic)component).color = Color32.op_Implicit(new Color32((byte)200, (byte)200, (byte)200, (byte)255));
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass17_0 : Object
		{
			public string gameObjectName;

			internal bool <FindObjectInChildren>b__0(Transform item)
			{
				return ((Object)item).name == gameObjectName;
			}
		}

		[CompilerGenerated]
		private sealed class <ShowCard>d__15 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public CardInfo card;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ShowCard>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = CardBarUtils.instance.ShowImmediate(player, card, new Nullable<float>(2f));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		internal Card Card;

		private Dictionary<string, int> cost = new Dictionary<string, int>();

		public override string Name => Card.cardInfo.cardName;

		public override Dictionary<string, int> Cost => cost;

		public override Tag[] Tags => (Tag[])(object)new Tag[2]
		{
			new Tag(((Object)(Rarity)(ref Card.cardInfo.rarity)).ToString()),
			new Tag(Card.category)
		};

		public CardItem(Card card)
		{
			Card = card;
			cost.Add("Wish", 1);
		}

		public override bool CanPurchase(Player player)
		{
			return true;
		}

		public override GameObject CreateItem(GameObject parent)
		{
			//IL_00e1: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			GameObject val2 = null;
			try
			{
				val = Object.Instantiate<GameObject>(ItemShops.instance.assets.LoadAsset<GameObject>("Card Container"));
			}
			catch (Exception)
			{
				Debug.Log((object)"Issue with creating the card container");
			}
			try
			{
				val2 = ((Component)val.transform.Find("Card Holder")).gameObject;
			}
			catch (Exception)
			{
				Debug.Log((object)"Issue with getting the Card Holder");
				val2 = ((Component)val.transform.GetChild(0)).gameObject;
			}
			val2.transform.localPosition = new Vector3(0f, -100f, 0f);
			val2.transform.localScale = new Vector3(0.125f, 0.125f, 1f);
			val2.transform.Rotate(0f, 180f, 0f);
			try
			{
				GetCardVisuals(Card.cardInfo, val2);
			}
			catch (Exception val5)
			{
				Debug.Log((object)"Issue with getting card visuals");
				Debug.LogError((object)val5);
			}
			val.transform.SetParent(parent.transform);
			return val;
		}

		private float GetDistance(Rarity r1, Rarity r2)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			float relativeRarity = RarityUtils.GetRarityData(r2).relativeRarity;
			float relativeRarity2 = RarityUtils.GetRarityData(r1).relativeRarity;
			relativeRarity2 = ((!(relativeRarity2 > relativeRarity)) ? (relativeRarity / relativeRarity2) : (relativeRarity2 / relativeRarity));
			Core.Debug((object)String.Format("Distence => {0},{1} : {2}", (object)r1, (object)r2, (object)relativeRarity2));
			return relativeRarity2 - 1f;
		}

		private List<RootCardInfo> GetValidOutcomes(Player player, CardInfo card)
		{
			<>c__DisplayClass12_0 CS$<>8__locals0 = new <>c__DisplayClass12_0();
			CS$<>8__locals0.player = player;
			CS$<>8__locals0.<>4__this = this;
			CS$<>8__locals0.card = card;
			CS$<>8__locals0.can_eternity = GenieCard.CanEternity(CS$<>8__locals0.card);
			List<RootCardInfo> cardsWithCondition = CardList.GetCardsWithCondition((Func<RootCardInfo, bool>)((RootCardInfo c) => Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)((CardInfo)c).categories, CustomCardCategories.instance.CardCategory("GenieOutcome")) && (((CardInfo)c).allowMultiple || !UtilityExtenions.HasCard(CS$<>8__locals0.player, (CardInfo)(object)c)) && (c.Key != "Genie_Debt" || GameModeManager.CurrentHandler.GetTeamScore(CS$<>8__locals0.player.teamID).rounds > 0) && (CS$<>8__locals0.can_eternity || c.Key != "Genie_Eternity")));
			CS$<>8__locals0.range = 6 + 2 * GenieCard.IsCursed(CS$<>8__locals0.player);
			return Enumerable.ToList<RootCardInfo>(Enumerable.Where<RootCardInfo>((IEnumerable<RootCardInfo>)(object)cardsWithCondition, (Func<RootCardInfo, bool>)((RootCardInfo c) => CS$<>8__locals0.<>4__this.GetDistance(((CardInfo)c).rarity, CS$<>8__locals0.card.rarity) < CS$<>8__locals0.range && ((CS$<>8__locals0.range == 6f && UtilityExtenions.IsAllowedCard(CS$<>8__locals0.player, CS$<>8__locals0.card)) || RarityUtils.GetRarityData(((CardInfo)c).rarity).relativeRarity <= RarityUtils.GetRarityData(CS$<>8__locals0.card.rarity).relativeRarity * Mathf.Max(1f, 8f / CS$<>8__locals0.range)))));
		}

		private void DoGenieWish(Player player, CardInfo card)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Expected O, but got Unknown
			<>c__DisplayClass13_0 CS$<>8__locals0 = new <>c__DisplayClass13_0();
			CS$<>8__locals0.player = player;
			CS$<>8__locals0.card = card;
			Random val = new Random();
			List<RootCardInfo> validOutcomes = GetValidOutcomes(CS$<>8__locals0.player, CS$<>8__locals0.card);
			if (val.Next(100) >= 98 || validOutcomes.Count == 0 || CS$<>8__locals0.card.rarity == RootCardInfo.GetRarity((CardRarity)10))
			{
				Cards.instance.AddCardToPlayer(CS$<>8__locals0.player, (CardInfo)(object)CardList.GetCardInfo("Empty_Lamp"), false, "", 2f, 2f, true);
				return;
			}
			Core.Debug((object)validOutcomes.Count);
			List<float> val2 = new List<float>();
			_ = RarityUtils.GetRarityData(CS$<>8__locals0.card.rarity).relativeRarity;
			for (int i = 0; i < validOutcomes.Count; i++)
			{
				val2.Add(GetDistance(((CardInfo)validOutcomes[i]).rarity, CS$<>8__locals0.card.rarity));
			}
			float num = Enumerable.Max((IEnumerable<float>)(object)val2);
			CS$<>8__locals0.target = Mathf.Lerp(0f, num, 3f / (float)GenieCard.IsCursed(CS$<>8__locals0.player));
			val2 = Enumerable.ToList<float>(Enumerable.Select<float, float>((IEnumerable<float>)(object)val2, (Func<float, float>)((float f) => Mathf.Abs(f - CS$<>8__locals0.target))));
			float num2 = Enumerable.Sum((IEnumerable<float>)(object)val2);
			float num3 = Random.Range(0f, num2);
			Core.Debug((object)String.Format("Rolled:{0} out of {1}", (object)num3, (object)num2));
			for (int j = 0; j < validOutcomes.Count; j++)
			{
				num3 -= val2[j];
				Core.Debug((object)val2[j]);
				if (!(num3 <= 0f))
				{
					continue;
				}
				<>c__DisplayClass13_1 CS$<>8__locals1 = new <>c__DisplayClass13_1();
				CS$<>8__locals1.CS$<>8__locals1 = CS$<>8__locals0;
				CS$<>8__locals1.oCard = validOutcomes[j];
				Core.Debug((object)CS$<>8__locals1.oCard.Key);
				if (CS$<>8__locals1.oCard.Key == "Genie_Greed" && (Object)(object)CharacterStatModifiersExtension.GetRootData(CS$<>8__locals1.CS$<>8__locals1.player).lockedCard == (Object)null)
				{
					Cards.instance.RemoveCardsFromPlayer(CS$<>8__locals1.CS$<>8__locals1.player, Enumerable.ToArray<CardInfo>(Enumerable.Where<CardInfo>((IEnumerable<CardInfo>)(object)CS$<>8__locals1.CS$<>8__locals1.player.data.currentCards, (Func<CardInfo, bool>)((CardInfo c) => !Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)c.categories, CustomCardCategories.instance.CardCategory("GenieOutcome"))))), (SelectionType)0, true);
					ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)Unbound.Instance, 0.2f, (Action)delegate
					{
						Cards.instance.AddCardToPlayer(CS$<>8__locals1.CS$<>8__locals1.player, (CardInfo)(object)CS$<>8__locals1.oCard, false, "", 2f, 2f, true);
						Cards.instance.AddCardToPlayer(CS$<>8__locals1.CS$<>8__locals1.player, CS$<>8__locals1.CS$<>8__locals1.card, false, "", 2f, 2f, true);
					});
					return;
				}
				Cards.instance.AddCardToPlayer(CS$<>8__locals1.CS$<>8__locals1.player, (CardInfo)(object)CS$<>8__locals1.oCard, false, "", 2f, 2f, true);
				if (CS$<>8__locals1.oCard.Key == "Genie_Smiles")
				{
					Cards.instance.AddCardToPlayer(CS$<>8__locals1.CS$<>8__locals1.player, CS$<>8__locals1.CS$<>8__locals1.card, false, "", 2f, 2f, true);
				}
				if (CS$<>8__locals1.oCard.Key == "Genie_Gift")
				{
					Cards.instance.AddCardToPlayer(CS$<>8__locals1.CS$<>8__locals1.player, Cards.instance.GetRandomCardWithCondition(CS$<>8__locals1.CS$<>8__locals1.player, CS$<>8__locals1.CS$<>8__locals1.player.data.weaponHandler.gun, ((Component)CS$<>8__locals1.CS$<>8__locals1.player.data.weaponHandler.gun).GetComponentInChildren<GunAmmo>(), CS$<>8__locals1.CS$<>8__locals1.player.data, CS$<>8__locals1.CS$<>8__locals1.player.data.healthHandler, ((Component)CS$<>8__locals1.CS$<>8__locals1.player).GetComponent<Gravity>(), CS$<>8__locals1.CS$<>8__locals1.player.data.block, CS$<>8__locals1.CS$<>8__locals1.player.data.stats, (Func<CardInfo, Player, Gun, GunAmmo, CharacterData, HealthHandler, Gravity, Block, CharacterStatModifiers, bool>)((CardInfo cardInfo, Player _0, Gun _1, GunAmmo _2, CharacterData _3, HealthHandler _4, Gravity _5, Block _6, CharacterStatModifiers _7) => (int)cardInfo.rarity == 0), 0), false, "", 2f, 2f, true);
				}
				if (CS$<>8__locals1.oCard.Key == "Genie_Shared")
				{
					PlayerManager.instance.players.ForEach((Action<Player>)delegate(Player p)
					{
						if (p.playerID != CS$<>8__locals1.CS$<>8__locals1.player.playerID)
						{
							Cards.instance.AddCardToPlayer(p, CS$<>8__locals1.CS$<>8__locals1.card, false, "", 2f, 2f, true);
						}
					});
				}
				if (CS$<>8__locals1.oCard.Key == "Genie_Defective")
				{
					Cards.instance.AddCardToPlayer(CS$<>8__locals1.CS$<>8__locals1.player, (CardInfo)(object)NullManager.instance.GetNullCardInfo(((Object)CS$<>8__locals1.CS$<>8__locals1.card).name, CS$<>8__locals1.CS$<>8__locals1.player), false, "", 2f, 2f, true);
					return;
				}
				if (!(CS$<>8__locals1.oCard.Key == "Genie_Delayed"))
				{
					break;
				}
				CharacterStatModifiersExtension.GetRootData(CS$<>8__locals1.CS$<>8__locals1.player).DelayedCard = CS$<>8__locals1.CS$<>8__locals1.card;
				return;
			}
			Cards.instance.AddCardToPlayer(CS$<>8__locals0.player, CS$<>8__locals0.card, false, "", 2f, 2f, true);
		}

		public override void OnPurchase(Player player, Purchasable item)
		{
			CardInfo cardInfo = ((CardItem)(object)item).Card.cardInfo;
			DoGenieWish(player, cardInfo);
			((MonoBehaviour)Core.instance).StartCoroutine(ShowCard(player, cardInfo));
			if (player.data.view.IsMine)
			{
				GenieCard.Genie_Shop.Hide();
			}
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		public static IEnumerator ShowCard(Player player, CardInfo card)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <ShowCard>d__15(0)
			{
				player = player,
				card = card
			};
		}

		private GameObject GetCardVisuals(CardInfo card, GameObject parent)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			<>c__DisplayClass16_0 CS$<>8__locals0 = new <>c__DisplayClass16_0();
			CS$<>8__locals0.cardObj = Object.Instantiate<GameObject>(((Component)card).gameObject, parent.gameObject.transform);
			CS$<>8__locals0.cardObj.SetActive(true);
			CS$<>8__locals0.cardObj.GetComponentInChildren<CardVisuals>().firstValueToSet = true;
			RectTransform orAddComponent = ExtensionMethods.GetOrAddComponent<RectTransform>(CS$<>8__locals0.cardObj, false);
			((Transform)orAddComponent).localScale = 100f * Vector3.one;
			orAddComponent.anchorMin = Vector2.zero;
			orAddComponent.anchorMax = Vector2.one;
			orAddComponent.offsetMin = Vector2.zero;
			orAddComponent.offsetMax = Vector2.zero;
			orAddComponent.pivot = new Vector2(0.5f, 0.5f);
			GameObject val = FindObjectInChildren(CS$<>8__locals0.cardObj, "Back");
			try
			{
				Object.Destroy((Object)(object)val);
			}
			catch (Object)
			{
			}
			GameObject obj = FindObjectInChildren(CS$<>8__locals0.cardObj, "BlockFront");
			if (obj != null)
			{
				obj.SetActive(false);
			}
			CanvasGroup[] componentsInChildren = CS$<>8__locals0.cardObj.GetComponentsInChildren<CanvasGroup>();
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].alpha = 1f;
			}
			ExtensionMethods.ExecuteAfterSeconds((MonoBehaviour)(object)ItemShops.instance, 0.2f, (Action)delegate
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: 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)
				CardRarityColor[] componentsInChildren2 = CS$<>8__locals0.cardObj.GetComponentsInChildren<CardRarityColor>();
				foreach (CardRarityColor val3 in componentsInChildren2)
				{
					try
					{
						val3.Toggle(true);
					}
					catch (Object)
					{
					}
				}
				TextMeshProUGUI component = FindObjectInChildren(CS$<>8__locals0.cardObj, "Text_Name").GetComponent<TextMeshProUGUI>();
				if (((Graphic)component).color.r < 0.18f && ((Graphic)component).color.g < 0.18f && ((Graphic)component).color.b < 0.18f)
				{
					((Graphic)component).color = Color32.op_Implicit(new Color32((byte)200, (byte)200, (byte)200, (byte)255));
				}
			});
			return CS$<>8__locals0.cardObj;
		}

		private static GameObject FindObjectInChildren(GameObject gameObject, string gameObjectName)
		{
			<>c__DisplayClass17_0 CS$<>8__locals0 = new <>c__DisplayClass17_0();
			CS$<>8__locals0.gameObjectName = gameObjectName;
			return Enumerable.FirstOrDefault<GameObject>(Enumerable.Select<Transform, GameObject>(Enumerable.Where<Transform>((IEnumerable<Transform>)(object)gameObject.GetComponentsInChildren<Transform>(true), (Func<Transform, bool>)((Transform item) => ((Object)item).name == CS$<>8__locals0.gameObjectName)), (Func<Transform, GameObject>)((Transform item) => ((Component)item).gameObject)));
		}
	}
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("Systems.R00t.Genie", "Genie", "1.1.4")]
	[BepInProcess("Rounds.exe")]
	public class Main : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <GameStart>d__5 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GameStart>d__5(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = GenieCard.Wish();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = GenieCard.RestCardLock();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					return false;
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		private const string ModId = "Systems.R00t.Genie";

		private const string ModName = "Genie";

		public const string Version = "1.1.4";

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			new Harmony("Systems.R00t.Genie").PatchAll();
			Core.RegesterCards(AssetUtils.LoadAssetBundleFromResources("genieassets", typeof(Main).Assembly).LoadAsset<GameObject>("Genie").GetComponent<CardList>(), false);
		}

		private void Start()
		{
			GameModeManager.AddHook("PlayerPickStart", (Func<IGameModeHandler, IEnumerator>)([CompilerGenerated] (IGameModeHandler gm) =>
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				((MonoBehaviour)this).StartCoroutine(NoBlock.HideChocieBlock());
				return (IEnumerator)(object)new List<object>().GetEnumerator();
			}));
			GameModeManager.AddHook("PickEnd", (Func<IGameModeHandler, IEnumerator>)((IGameModeHandler gm) => GenieCard.WaitTillShopDone()));
			GameModeManager.AddHook("GameStart", (Func<IGameModeHandler, IEnumerator>)GameStart);
			RerollManager.instance.RegisterRerollAction((Action<Player, CardInfo[]>)GenieCard.GenieRerollAction);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		internal IEnumerator GameStart(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <GameStart>d__5(0);
		}
	}
	public class MortalityTimer : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass16_0 : Object
		{
			public int playerId;

			internal bool <Kill>b__0(Player p)
			{
				return p.playerID == playerId;
			}
		}

		[CompilerGenerated]
		private sealed class <Enable>d__18 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MortalityTimer <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Enable>d__18(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MortalityTimer mortalityTimer = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				mortalityTimer.Enabled = true;
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Pause>d__17 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MortalityTimer <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Pause>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				MortalityTimer mortalityTimer = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				mortalityTimer.Enabled = false;
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Reset>d__19 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MortalityTimer <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Reset>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0095: Expected O, but got Unknown
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				MortalityTimer mortalityTimer = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				try
				{
					mortalityTimer.Enabled = false;
					mortalityTimer.timer = 0f;
					mortalityTimer.counter = 0f;
					((Image)mortalityTimer.outerRing).fillAmount = mortalityTimer.counter;
					((Image)mortalityTimer.fill).fillAmount = mortalityTimer.counter;
					((Component)mortalityTimer.rotator).transform.localEulerAngles = new Vector3(0f, 0f, 0f - Mathf.Lerp(0f, 360f, mortalityTimer.counter));
				}
				catch (Exception val)
				{
					Core.Debug((object)val);
				}
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		private float timer;

		public Player player;

		[Range(0f, 1f)]
		public float counter;

		public float timeToFill = 30f;

		public float timeToEmpty;

		public float duration = 1f;

		public ProceduralImage outerRing;

		public ProceduralImage fill;

		public Transform rotator;

		public Transform still;

		public GameObject Scythe;

		public bool Enabled;

		public void Awake()
		{
			player = ((Component)this).GetComponentInParent<Player>();
		}

		private void Start()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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)
			GameModeManager.AddHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)Pause);
			GameModeManager.AddHook("RoundEnd", (Func<IGameModeHandler, IEnumerator>)Reset);
			GameModeManager.AddHook("PointStart", (Func<IGameModeHandler, IEnumerator>)Enable);
			((Graphic)outerRing).color = Color32.op_Implicit(new Color32((byte)106, (byte)33, (byte)145, (byte)255));
			((Graphic)fill).color = Color32.op_Implicit(new Color32((byte)255, (byte)0, (byte)64, (byte)150));
			counter = 0f;
			((Image)outerRing).fillAmount = counter;
			((Image)fill).fillAmount = counter;
			((Component)rotator).transform.localEulerAngles = new Vector3(0f, 0f, 0f - Mathf.Lerp(0f, 360f, counter));
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("PointEnd", (Func<IGameModeHandler, IEnumerator>)Pause);
			GameModeManager.RemoveHook("RoundEnd", (Func<IGameModeHandler, IEnumerator>)Reset);
			GameModeManager.RemoveHook("PointStart", (Func<IGameModeHandler, IEnumerator>)Enable);
		}

		private void Update()
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (!Enabled || player.data.dead)
			{
				return;
			}
			timer += Time.deltaTime;
			counter = timer / timeToFill;
			((Image)outerRing).fillAmount = counter;
			((Image)fill).fillAmount = counter;
			((Component)rotator).transform.localEulerAngles = new Vector3(0f, 0f, 0f - Mathf.Lerp(0f, 360f, counter));
			if (counter > 1f && !player.data.dead && player.data.view.IsMine)
			{
				NetworkingManager.RPC(typeof(MortalityTimer), "Kill", (object[])(object)new Object[1] { (object)player.playerID });
				if (player.data.stats.remainingRespawns > 0)
				{
					player.data.view.RPC("RPCA_Die_Phoenix", (RpcTarget)0, (object[])(object)new Object[1] { (object)(Vector2.down * 1000f) });
				}
				else
				{
					player.data.view.RPC("RPCA_Die", (RpcTarget)0, (object[])(object)new Object[1] { (object)(Vector2.down * 1000f) });
				}
			}
		}

		[UnboundRPC]
		public static void Kill(int playerId)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0069: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			<>c__DisplayClass16_0 CS$<>8__locals0 = new <>c__DisplayClass16_0();
			CS$<>8__locals0.playerId = playerId;
			MortalityTimer componentInChildren = ((Component)PlayerManager.instance.players.Find((Predicate<Player>)((Player p) => p.playerID == CS$<>8__locals0.playerId))).GetComponentInChildren<MortalityTimer>();
			GameObject obj = Object.Instantiate<GameObject>(componentInChildren.Scythe, ((Component)componentInChildren).transform.position + ((Component)componentInChildren).transform.up * ((Component)componentInChildren).transform.parent.localScale.y / 3f, Quaternion.identity);
			((Behaviour)obj.GetComponent<Animator>()).enabled = true;
			Object.Destroy((Object)(object)obj, 15f);
			componentInChildren.counter = 1.5f;
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator Pause(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Pause>d__17(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator Enable(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Enable>d__18(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator Reset(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Reset>d__19(0)
			{
				<>4__this = this
			};
		}
	}
	public class NoBlock : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <HideChocieBlock>d__2 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HideChocieBlock>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (!CardChoice.instance.IsPicking)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				((Component)((Component)CardChoiceVisuals.instance).transform.Find("Card Choice Face/ArmStuff/ShieldStone")).gameObject.SetActive(!UtilityExtenions.HasCard(PlayerManager.instance.players.Find((Predicate<Player>)((Player player) => CardChoice.instance.pickrID == player.playerID)), "Genie_Exposed"));
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		private void Start()
		{
			((Behaviour)((Component)this).GetComponentInParent<Player>().data.block).enabled = false;
			((Component)this).GetComponentInParent<Player>().data.block.counter = 0.25f;
			((Component)((Component)((Component)this).GetComponentInParent<Player>()).transform.Find("Limbs/ArmStuff/ShieldStone")).gameObject.SetActive(false);
		}

		private void OnDestroy()
		{
			((Behaviour)((Component)this).GetComponentInParent<Player>().data.block).enabled = true;
			((Component)((Component)((Component)this).GetComponentInParent<Player>()).transform.Find("Limbs/ArmStuff/ShieldStone")).gameObject.SetActive(true);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		public static IEnumerator HideChocieBlock()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <HideChocieBlock>d__2(0);
		}
	}
	public class PointReduction : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ReducePoints>d__3 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public IGameModeHandler gameModeHandler;

			public PointReduction <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ReducePoints>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002b: 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_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				PointReduction pointReduction = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				TeamScore teamScore = gameModeHandler.GetTeamScore(pointReduction.player.teamID);
				TeamScore val = default(TeamScore);
				((TeamScore)(ref val))..ctor(teamScore.points - (int)(((Component)pointReduction).GetComponent<AttackLevel>().LevelScale() - 1f), teamScore.rounds);
				gameModeHandler.SetTeamScore(pointReduction.player.teamID, val);
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		private Player player;

		private void Awake()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			GameModeManager.AddHook("RoundStart", (Func<IGameModeHandler, IEnumerator>)ReducePoints);
		}

		private void OnDestroy()
		{
			GameModeManager.RemoveHook("RoundStart", (Func<IGameModeHandler, IEnumerator>)ReducePoints);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		public IEnumerator ReducePoints(IGameModeHandler gameModeHandler)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <ReducePoints>d__3(0)
			{
				<>4__this = this,
				gameModeHandler = gameModeHandler
			};
		}
	}
	public class Predestination : MonoBehaviour
	{
		private Player player;

		private int OldDraws;

		private void Awake()
		{
			player = ((Component)this).GetComponentInParent<Player>();
			OldDraws = DrawNCards.GetPickerDraws(player.playerID);
		}

		private void Update()
		{
			if ((Object)(object)player != (Object)null && DrawNCards.GetPickerDraws(player.playerID) != 1)
			{
				DrawNCards.SetPickerDraws(player.playerID, 1);
			}
		}

		private void OnDestroy()
		{
			DrawNCards.SetPickerDraws(player.playerID, OldDraws);
		}
	}
	internal class RoundDeath : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Die>d__3 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RoundDeath <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Die>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				RoundDeath roundDeath = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				((Component)roundDeath).GetComponentInParent<Player>().data.view.RPC("RPCA_Die", (RpcTarget)0, (object[])(object)new Object[1] { (object)new Vector2(0f, 1f) });
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <Kill>d__2 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RoundDeath <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Kill>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				RoundDeath roundDeath = <>4__this;
				if (num != 0)
				{
					return false;
				}
				<>1__state = -1;
				GameModeManager.AddOnceHook("BattleStart", (Func<IGameModeHandler, IEnumerator>)roundDeath.Die);
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		public void Start()
		{
			GameModeManager.AddHook("RoundStart", (Func<IGameModeHandler, IEnumerator>)Kill);
		}

		public void OnDestroy()
		{
			GameModeManager.RemoveHook("RoundStart", (Func<IGameModeHandler, IEnumerator>)Kill);
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator Kill(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Kill>d__2(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		private IEnumerator Die(IGameModeHandler gm)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <Die>d__3(0)
			{
				<>4__this = this
			};
		}
	}
	public class RoundLoss : MonoBehaviour
	{
		public int cost;

		private void Start()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameModeManager.CurrentHandler.SetTeamScore(((Component)this).GetComponentInParent<Player>().teamID, new TeamScore(0, GameModeManager.CurrentHandler.GetTeamScore(((Component)this).GetComponentInParent<Player>().teamID).rounds - cost));
		}

		private void OnDestroy()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameModeManager.CurrentHandler.SetTeamScore(((Component)this).GetComponentInParent<Player>().teamID, new TeamScore(0, GameModeManager.CurrentHandler.GetTeamScore(((Component)this).GetComponentInParent<Player>().teamID).rounds + cost));
		}
	}
	public class Trade : OnAddEffect
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0 : Object
		{
			public Player player;

			public CardInfo card;

			public IEnumerable<CardInfo> cards;

			internal bool <TradeCard>b__0()
			{
				if ((Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards) != (Object)(object)card)
				{
					return (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards) != (Object)(object)CardList.GetCardInfo("Genie_Traded");
				}
				return false;
			}

			internal bool <TradeCard>b__1(CardInfo c)
			{
				if (c.cardName != "Genie" && c.cardName != Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)player.data.currentCards).cardName)
				{
					return !Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)c.categories, CustomCardCategories.instance.CardCategory("GenieOutcome"));
				}
				return false;
			}

			internal bool <TradeCard>b__2(CardInfo cardi)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return RarityUtils.GetRarityData(cardi.rarity).relativeRarity == Enumerable.Min<CardInfo>(cards, (Func<CardInfo, float>)((CardInfo c) => RarityUtils.GetRarityData(c.rarity).relativeRarity));
			}
		}

		[CompilerGenerated]
		private sealed class <TradeCard>d__1 : Object, IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			private <>c__DisplayClass1_0 <>8__1;

			private int <_>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <TradeCard>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass1_0();
					<>8__1.player = player;
					<>8__1.card = Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards) != (Object)(object)<>8__1.card && (Object)(object)Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards) != (Object)(object)CardList.GetCardInfo("Genie_Traded")));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<_>5__2 = 0;
					break;
				case 2:
					<>1__state = -1;
					<_>5__2++;
					break;
				}
				if (<_>5__2 < 60)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				<>8__1.cards = Enumerable.Where<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards, (Func<CardInfo, bool>)((CardInfo c) => c.cardName != "Genie" && c.cardName != Enumerable.Last<CardInfo>((IEnumerable<CardInfo>)(object)<>8__1.player.data.currentCards).cardName && !Enumerable.Contains<CardCategory>((IEnumerable<CardCategory>)(object)c.categories, CustomCardCategories.instance.CardCategory("GenieOutcome"))));
				CardInfo[] array = Enumerable.ToArray<CardInfo>(Enumerable.Where<CardInfo>(<>8__1.cards, (Func<CardInfo, bool>)((CardInfo cardi) => RarityUtils.GetRarityData(cardi.rarity).relativeRarity == Enumerable.Min<CardInfo>(<>8__1.cards, (Func<CardInfo, float>)((CardInfo c) => RarityUtils.GetRarityData(c.rarity).relativeRarity)))));
				CardInfo val = array[Random.Range(0, Enumerable.Count<CardInfo>((IEnumerable<CardInfo>)(object)array))];
				Cards.instance.RemoveCardFromPlayer(<>8__1.player, val, (SelectionType)0, true);
				return false;
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}
		}

		public override void OnAdd(Player player, Gun gun, GunAmmo gunAmmo, CharacterData data, HealthHandler health, Gravity gravity, Block block, CharacterStatModifiers characterStats)
		{
			((MonoBehaviour)Core.instance).StartCoroutine(TradeCard(player));
		}

		[IteratorStateMachine(/*Could not decode attribute arguments.*/)]
		public static IEnumerator TradeCard(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return (IEnumerator)(object)new <TradeCard>d__1(0)
			{
				player = player
			};
		}
	}
}
namespace Genie.Patches
{
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class BlockNoBlockPatch : MonoBehaviour
	{
		[HarmonyPrefix]
		[HarmonyPatch("RPCA_DoBlock")]
		public static bool norpca(Block __instance)
		{
			return (Object)(object)((Component)__instance).GetComponentInChildren<NoBlock>() == (Object)null;
		}

		[HarmonyPrefix]
		[HarmonyPatch("TryBlock")]
		public static bool notry(Block __instance)
		{
			return (Object)(object)((Component)__instance).GetComponentInChildren<NoBlock>() == (Object)null;
		}

		[HarmonyPrefix]
		[HarmonyPatch("DoBlock")]
		public static bool nodo(Block __instance)
		{
			return (Object)(object)((Component)__instance).GetComponentInChildren<NoBlock>() == (Object)null;
		}

		[HarmonyPostfix]
		[HarmonyPatch("IsBlocking")]
		public static void IsBlocking(Block __instance, ref bool __result)
		{
			__result = __result && (Object)(object)((Component)__instance).GetComponentInChildren<NoBlock>() == (Object)null;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class CardSpawnPatch : Object
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_0 : Object
		{
			public GameObject old;

			internal void <Postfix>b__0()
			{
				PhotonNetwork.Destroy(old);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_1 : Object
		{
			public GameObject old;

			internal void <Postfix>b__1()
			{
				PhotonNetwork.Destroy(old);
			}
		}

		private static void Postfix(List<GameObject> ___spawnedCards, Transform[] ___children, int ___pickrID, ref GameObject __result)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			Player playerWithID = GetPlayerWithID(___pickrID);
			if ((Object)(object)playerWithID != (Object)null && ___spawnedCards.Count == 0 && (Object)(object)CharacterStatModifiersExtension.GetRootData(playerWithID).perpetualCard != (Object)null)
			{
				<>c__DisplayClass0_0 CS$<>8__locals0 = new <>c__DisplayClass0_0();
				CS$<>8__locals0.old = __result;
				ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Core.instance, 3, (Action)delegate
				{
					PhotonNetwork.Destroy(CS$<>8__locals0.old);
				});
				__result = PhotonNetwork.Instantiate(((Object)CharacterStatModifiersExtension.GetRootData(playerWithID).perpetualCard).name, __result.transform.position, __result.transform.rotation, (byte)0, (object[])null);
			}
			if ((Object)(object)playerWithID != (Object)null && ___spawnedCards.Count == ___children.Length - 1 && (Object)(object)CharacterStatModifiersExtension.GetRootData(playerWithID).DelayedCard != (Object)null)
			{
				<>c__DisplayClass0_1 CS$<>8__locals1 = new <>c__DisplayClass0_1();
				CS$<>8__locals1.old = __result;
				ExtensionMethods.ExecuteAfterFrames((MonoBehaviour)(object)Core.instance, 3, (Action)delegate
				{
					PhotonNetwork.Destroy(CS$<>8__locals1.old);
				});
				__result = PhotonNetwork.Instantiate(((Object)CharacterStatModifiersExtension.GetRootData(playerWithID).DelayedCard).name, __result.transform.position, __result.transform.rotation, (byte)0, (object[])null);
				CharacterStatModifiersExtension.GetRootData(playerWithID).DelayedCard = null;
			}
		}

		internal static Player GetPlayerWithID(int playerID)
		{
			for (int i = 0; i < PlayerManager.instance.players.Count; i++)
			{
				if (PlayerManager.instance.players[i].playerID == playerID)
				{
					return PlayerManager.instance.players[i];
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	public class EternityPatch : Object
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_0 : Object
		{
			public ApplyCardStats __instance;

			internal void <PickCardOffline>b__1(Player player)
			{
				Debug.Log((object)CharacterStatModifiersExtension.GetRootData(player).lockedCard);
				if ((Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)null && (Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)(object)((Component)__instance).GetComponent<CardInfo>().sourceCard)
				{
					Cards.instance.AddCardToPlayer(player, CharacterStatModifiersExtension.GetRootData(player).lockedCard, false, "", 0f, 0f, true);
				}
				else
				{
					Cards.instance.AddCardToPlayer(player, ((Component)__instance).GetComponent<CardInfo>().sourceCard, false, "", 0f, 0f, true);
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0 : Object
		{
			public ApplyCardStats __instance;

			internal void <PickCard>b__1(Player player)
			{
				Debug.Log((object)CharacterStatModifiersExtension.GetRootData(player).lockedCard);
				if ((Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)null && (Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)(object)((Component)__instance).GetComponent<CardInfo>().sourceCard)
				{
					Cards.instance.AddCardToPlayer(player, CharacterStatModifiersExtension.GetRootData(player).lockedCard, false, "", 0f, 0f, true);
				}
				else
				{
					Cards.instance.AddCardToPlayer(player, ((Component)__instance).GetComponent<CardInfo>().sourceCard, false, "", 0f, 0f, true);
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static bool PickCardOffline(ApplyCardStats __instance, Player[] players)
		{
			<>c__DisplayClass0_0 CS$<>8__locals0 = new <>c__DisplayClass0_0();
			CS$<>8__locals0.__instance = __instance;
			List<Player> val = Enumerable.ToList<Player>((IEnumerable<Player>)(object)players);
			if (Enumerable.Any<Player>((IEnumerable<Player>)(object)val, (Func<Player, bool>)((Player p) => (Object)(object)CharacterStatModifiersExtension.GetRootData(p).lockedCard != (Object)null)))
			{
				val.ForEach((Action<Player>)delegate(Player player)
				{
					Debug.Log((object)CharacterStatModifiersExtension.GetRootData(player).lockedCard);
					if ((Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)null && (Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)(object)((Component)CS$<>8__locals0.__instance).GetComponent<CardInfo>().sourceCard)
					{
						Cards.instance.AddCardToPlayer(player, CharacterStatModifiersExtension.GetRootData(player).lockedCard, false, "", 0f, 0f, true);
					}
					else
					{
						Cards.instance.AddCardToPlayer(player, ((Component)CS$<>8__locals0.__instance).GetComponent<CardInfo>().sourceCard, false, "", 0f, 0f, true);
					}
				});
				return false;
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static bool PickCard(ApplyCardStats __instance, int[] actorIDs)
		{
			<>c__DisplayClass1_0 CS$<>8__locals0 = new <>c__DisplayClass1_0();
			CS$<>8__locals0.__instance = __instance;
			List<Player> val = Enumerable.ToList<Player>(Enumerable.Select<int, Player>((IEnumerable<int>)(object)actorIDs, (Func<int, Player>)PlayerManager.instance.GetPlayerWithActorID));
			if (Enumerable.Any<Player>((IEnumerable<Player>)(object)val, (Func<Player, bool>)((Player p) => (Object)(object)CharacterStatModifiersExtension.GetRootData(p).lockedCard != (Object)null)))
			{
				val.ForEach((Action<Player>)delegate(Player player)
				{
					Debug.Log((object)CharacterStatModifiersExtension.GetRootData(player).lockedCard);
					if ((Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)null && (Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)(object)((Component)CS$<>8__locals0.__instance).GetComponent<CardInfo>().sourceCard)
					{
						Cards.instance.AddCardToPlayer(player, CharacterStatModifiersExtension.GetRootData(player).lockedCard, false, "", 0f, 0f, true);
					}
					else
					{
						Cards.instance.AddCardToPlayer(player, ((Component)CS$<>8__locals0.__instance).GetComponent<CardInfo>().sourceCard, false, "", 0f, 0f, true);
					}
				});
				return false;
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static void Add(Player player, ref CardInfo card)
		{
			if ((Object)(object)CharacterStatModifiersExtension.GetRootData(player).lockedCard != (Object)null)
			{
				card = CharacterStatModifiersExtension.GetRootData(player).lockedCard;
			}
		}
	}
}
Get the Thunderstore App

Decompiled source of Genie v1.1.4

Genie.dll

About

Developers
