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;
}
}
}
}