using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
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 BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.binbin.ChaoticCorruptions")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.9.0.0")]
[assembly: AssemblyInformationalVersion("0.9.0+694458a779b15b2a7f06aeaa55c621b4f7dd17e0")]
[assembly: AssemblyProduct("ChaoticCorruptions")]
[assembly: AssemblyTitle("com.binbin.ChaoticCorruptions")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ChaoticCorruptions
{
public class ChaoticCorruptionsFunctions
{
public static bool CanCraftRarity(CardCraftManager __instance, CardData cardData)
{
//IL_0026: 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_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Invalid comparison between Unknown and I4
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Invalid comparison between Unknown and I4
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Invalid comparison between Unknown and I4
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Invalid comparison between Unknown and I4
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Invalid comparison between Unknown and I4
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Invalid comparison between Unknown and I4
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Invalid comparison between Unknown and I4
//IL_0140: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Invalid comparison between Unknown and I4
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Invalid comparison between Unknown and I4
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Invalid comparison between Unknown and I4
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Invalid comparison between Unknown and I4
//IL_011a: Unknown result type (might be due to invalid IL or missing references)
//IL_0120: Invalid comparison between Unknown and I4
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Invalid comparison between Unknown and I4
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Invalid comparison between Unknown and I4
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Invalid comparison between Unknown and I4
CardData val = cardData;
val = Functions.GetCardDataFromCardData(val, "");
Traverse obj = Traverse.Create((object)__instance).Field("maxCraftRarity");
CardRarity val2 = (CardRarity)((obj == null) ? 3 : ((int)obj.GetValue<CardRarity>()));
if (Object.op_Implicit((Object)(object)MapManager.Instance) && GameManager.Instance.IsObeliskChallenge())
{
return (int)val2 == 4 || ((int)val2 == 3 && (int)val.CardRarity != 4) || ((int)val2 == 2 && (int)val.CardRarity != 4 && (int)val.CardRarity != 3) || ((int)val2 == 1 && (int)val.CardRarity != 4 && (int)val.CardRarity != 3 && (int)val.CardRarity != 2) || ((int)val2 == 0 && (int)val.CardRarity == 0);
}
if (AtOManager.Instance.Sandbox_allRarities)
{
return true;
}
if ((int)val.CardRarity == 4)
{
return false;
}
if (AtOManager.Instance.GetTownTier() == 0)
{
if (((int)val.CardRarity == 2 && (!PlayerManager.Instance.PlayerHaveSupply("townUpgrade_1_4") || AtOManager.Instance.GetNgPlus(false) >= 8)) || (int)val.CardRarity == 3 || (int)val.CardRarity == 4)
{
return false;
}
}
else if (AtOManager.Instance.GetTownTier() == 1 && (int)val.CardRarity == 3 && (!PlayerManager.Instance.PlayerHaveSupply("townUpgrade_1_6") || AtOManager.Instance.GetNgPlus(false) >= 8))
{
return false;
}
return true;
}
public static CardData GetRandomCardWeighted(Hero hero, bool craftableOnly = true)
{
//IL_005c: 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_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: 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_00cc: Invalid comparison between Unknown and I4
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: Invalid comparison between Unknown and I4
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Invalid comparison between Unknown and I4
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d1: Invalid comparison between Unknown and I4
//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
//IL_01f8: Invalid comparison between Unknown and I4
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_021e: Invalid comparison between Unknown and I4
//IL_0257: Unknown result type (might be due to invalid IL or missing references)
//IL_025d: Invalid comparison between Unknown and I4
//IL_0241: Unknown result type (might be due to invalid IL or missing references)
//IL_0247: Invalid comparison between Unknown and I4
AtOManager instance = AtOManager.Instance;
int num = ((instance != null) ? instance.GetNgPlus(false) : 0);
int num2 = ((!craftableOnly) ? 30 : ((num < 5) ? 10 : 37));
int num3 = ((!craftableOnly) ? 35 : ((num < 5) ? 65 : 60));
int num4 = ((!craftableOnly) ? 20 : ((num < 5) ? 20 : 3));
int num5 = ((!craftableOnly) ? 10 : ((num < 5) ? 5 : 0));
CardClass result = (CardClass)11;
Enum.TryParse<CardClass>(Enum.GetName(typeof(HeroClass), ((Character)hero).HeroData.HeroClass), out result);
CardClass result2 = (CardClass)11;
Enum.TryParse<CardClass>(Enum.GetName(typeof(HeroClass), ((Character)hero).HeroData.HeroSubClass.HeroClassSecondary), out result2);
List<string> list = Globals.Instance.CardListNotUpgradedByClass[result];
List<string> list2 = (((int)result2 == 11) ? new List<string>() : Globals.Instance.CardListNotUpgradedByClass[result2]);
int num6 = Random.Range(0, 2);
int num7 = Random.Range(0, 100);
CardData cardData = Globals.Instance.GetCardData((num6 < 1 || (int)result2 == 11) ? list[Random.Range(0, list.Count)] : list2[Random.Range(0, list2.Count)], false);
Plugin.LogDebug("Randomizing card: " + cardData.Id);
bool flag = true;
while (flag)
{
flag = false;
bool flag2 = false;
while (!flag2)
{
flag = false;
cardData = Globals.Instance.GetCardData((num6 < 1 || (int)result2 == 11) ? list[Random.Range(0, list.Count)] : list2[Random.Range(0, list2.Count)], false);
if (flag)
{
continue;
}
if (num7 < num2)
{
if ((int)cardData.CardRarity == 0)
{
flag2 = true;
}
}
else if (num7 < num2 + num3)
{
if ((int)cardData.CardRarity == 1)
{
flag2 = true;
}
}
else if (num7 < num2 + num3 + num4)
{
if ((int)cardData.CardRarity == 2)
{
flag2 = true;
}
}
else if (num7 < num2 + num3 + num4 + num5)
{
if ((int)cardData.CardRarity == 3)
{
flag2 = true;
}
}
else if ((int)cardData.CardRarity == 4)
{
flag2 = true;
}
}
}
return cardData;
}
internal static void InitNewCard(CardData newCard, ref Dictionary<CardType, List<string>> ____CardItemByType, ref Dictionary<CardType, List<string>> ____CardListByType, ref Dictionary<CardClass, List<string>> ____CardListByClass, ref List<string> ____CardListNotUpgraded, ref Dictionary<CardClass, List<string>> ____CardListNotUpgradedByClass, ref Dictionary<string, List<string>> ____CardListByClassType, ref Dictionary<string, int> ____CardEnergyCost)
{
//IL_003e: 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_005b: Invalid comparison between Unknown and I4
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Invalid comparison between Unknown and I4
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
newCard.InitClone(newCard.Id);
____CardEnergyCost.Add(newCard.Id, newCard.EnergyCost);
Globals.Instance.IncludeInSearch(newCard.CardName, newCard.Id, true);
____CardListByClass[newCard.CardClass].Add(newCard.Id);
if ((int)newCard.CardUpgraded == 0)
{
____CardListNotUpgradedByClass[newCard.CardClass].Add(newCard.Id);
____CardListNotUpgraded.Add(newCard.Id);
if ((int)newCard.CardClass == 8)
{
if (!____CardItemByType.ContainsKey(newCard.CardType))
{
____CardItemByType.Add(newCard.CardType, new List<string>());
}
____CardItemByType[newCard.CardType].Add(newCard.Id);
}
}
List<CardType> cardTypes = newCard.GetCardTypes();
for (int i = 0; i < cardTypes.Count; i++)
{
if (!____CardListByType.ContainsKey(cardTypes[i]))
{
____CardListByType.Add(cardTypes[i], new List<string>());
}
____CardListByType[cardTypes[i]].Add(newCard.Id);
string key = Enum.GetName(typeof(CardClass), newCard.CardClass) + "_" + Enum.GetName(typeof(CardType), cardTypes[i]);
if (!____CardListByClassType.ContainsKey(key))
{
____CardListByClassType[key] = new List<string>();
}
____CardListByClassType[key].Add(newCard.Id);
Globals.Instance.IncludeInSearch(Texts.Instance.GetText(Enum.GetName(typeof(CardType), cardTypes[i]), ""), newCard.Id, true);
}
newCard.InitClone2();
newCard.SetDescriptionNew(true, (Character)null, true);
}
public static CardData AddNewCard(string id, string baseId, ref Dictionary<string, CardData> ____CardsSource, ref Dictionary<string, CardData> ____Cards)
{
if (____CardsSource.TryGetValue(baseId, out var value))
{
Plugin.LogInfo("Adding new card: " + id + " from " + baseId);
CardData val = Object.Instantiate<CardData>(value);
val.Id = id;
val.InternalId = id;
if ((Object)(object)val.Item != (Object)null)
{
val.Item = Object.Instantiate<ItemData>(val.Item);
val.Item.Id = id;
}
if ((Object)(object)val.ItemEnchantment != (Object)null)
{
val.ItemEnchantment = Object.Instantiate<ItemData>(val.ItemEnchantment);
val.ItemEnchantment.Id = id;
}
____CardsSource.Add(val.Id.ToLower(), val);
____Cards.Add(val.Id.ToLower(), val);
return val;
}
return null;
}
}
[HarmonyPatch]
public class ChaoticCorruptionsPatches
{
public static bool devMode = Plugin.DevMode.Value;
public static int i = 0;
[HarmonyPostfix]
[HarmonyPatch(typeof(Functions), "GetCardByRarity")]
public static void GetCardByRarityPostfix(ref string __result, CardData _cardData)
{
Plugin.LogDebug("GetCardByRarityPostfix");
if (Plugin.GuaranteeCorruptCards.Value || devMode || Random.Range(0, 100) <= Plugin.IncreaseCardCorruptionOdds.Value)
{
object obj;
if (_cardData == null)
{
obj = null;
}
else
{
CardData upgradesToRare = _cardData.UpgradesToRare;
obj = ((upgradesToRare != null) ? upgradesToRare.Id : null);
}
if (obj == null)
{
obj = __result;
}
__result = (string)obj;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Loot), "GetLootItems")]
public static void GetLootItemsPostfix(ref List<string> __result, string _itemListId, string _idAux = "")
{
Plugin.LogDebug("GetLootItemsPostfix");
if (!Plugin.GuaranteeCorruptItems.Value && Plugin.IncreaseItemCorruptionOdds.Value <= 0 && !devMode)
{
return;
}
for (int i = 0; i < __result.Count; i++)
{
CardData cardData = Globals.Instance.GetCardData(__result[i], true);
if (!((Object)(object)cardData == (Object)null) && (Plugin.GuaranteeCorruptItems.Value || (Plugin.IncreaseItemCorruptionOdds.Value > 0 && Random.Range(0, 100) <= Plugin.IncreaseItemCorruptionOdds.Value) || devMode))
{
List<string> obj = __result;
int index = i;
object obj2;
if (cardData == null)
{
obj2 = null;
}
else
{
CardData upgradesToRare = cardData.UpgradesToRare;
obj2 = ((upgradesToRare != null) ? upgradesToRare.Id : null);
}
if (obj2 == null)
{
obj2 = __result[i];
}
obj[index] = (string)obj2;
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Hero), "SetInitialItems")]
public static void SetInitialItemsPrefix(ref Hero __instance, ref CardData _cardData, ref int _rankLevel)
{
Plugin.LogDebug("SetInitialItemsPrefix " + _cardData.Id);
if (!(_cardData.Id == "harley") && (Plugin.CorruptStartingItems.Value || devMode))
{
CardData obj = _cardData;
_cardData = ((obj != null) ? obj.UpgradesToRare : null) ?? _cardData;
_rankLevel = 0;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Hero), "SetInitialCards")]
public static void SetInitialCardsPostfix(ref Hero __instance, HeroData heroData)
{
Plugin.LogDebug("SetInitialCardsPostfix");
List<string> cards = ((Character)__instance).Cards;
if (Plugin.CompletelyRandomizeStartingDecks.Value || devMode)
{
Plugin.LogDebug("SetInitialCardsPostfix - randomizing " + ((Character)__instance).SourceName);
for (int i = 0; i < cards.Count; i++)
{
string text = cards[i];
Plugin.LogDebug(text);
if (!Globals.Instance.GetCardData(text, true).Starter && !((Object)(object)Globals.Instance.GetCardData(text, true) == (Object)null))
{
Plugin.LogDebug("past check");
string id = ChaoticCorruptionsFunctions.GetRandomCardWeighted(__instance, craftableOnly: false).Id;
Plugin.LogDebug("newCard " + id);
cards[i] = id;
}
}
((Character)__instance).Cards = cards;
}
else if (Plugin.RandomizeStartingDecks.Value || devMode)
{
for (int j = 0; j < cards.Count; j++)
{
string text2 = cards[j];
if (!Globals.Instance.GetCardData(text2, true).Starter && !((Object)(object)Globals.Instance.GetCardData(text2, true) == (Object)null))
{
cards[j] = ChaoticCorruptionsFunctions.GetRandomCardWeighted(__instance).Id;
}
}
((Character)__instance).Cards = cards;
}
if (Plugin.CorruptStartingDecks.Value || devMode)
{
Plugin.LogDebug("SetInitialCardsPostfix - corrupting " + ((Character)__instance).SourceName);
for (int k = 0; k < cards.Count; k++)
{
string text3 = cards[k];
int index = k;
Globals instance = Globals.Instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
CardData cardData = instance.GetCardData(text3, true);
if (cardData == null)
{
obj = null;
}
else
{
CardData upgradesToRare = cardData.UpgradesToRare;
obj = ((upgradesToRare != null) ? upgradesToRare.Id : null);
}
}
if (obj == null)
{
obj = cards[k];
}
cards[index] = (string)obj;
}
((Character)__instance).Cards = cards;
}
if (!Plugin.ChaoticStartingDeck.Value && !devMode)
{
return;
}
Plugin.LogDebug("SetInitialCardsPostfix - Pandoras Box");
for (int l = 0; l < cards.Count; l++)
{
string text4 = cards[l];
Plugin.LogDebug(text4);
if (!Globals.Instance.GetCardData(text4, true).Starter && !((Object)(object)Globals.Instance.GetCardData(text4, true) == (Object)null))
{
Plugin.LogDebug("past check");
string text5 = (Plugin.CorruptStartingDecks.Value ? "chaoticchaosrare" : "chaoticchaos");
Plugin.LogDebug("newCard " + text5);
cards[l] = text5;
}
}
((Character)__instance).Cards = cards;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Hero), "SetInitialCardsSingularity")]
public static void SetSingularityInitialCardsPostfix(ref Hero __instance, HeroData heroData)
{
Plugin.LogDebug("SetInitialCardsSingularity");
Random.InitState(Functions.GetDeterministicHashCode(AtOManager.Instance.GetGameId() + ((Character)__instance).SourceName + "com.binbin.ChaoticCorruptions"));
List<string> cards = ((Character)__instance).Cards;
if (Plugin.CompletelyRandomizeStartingDecks.Value || devMode)
{
Plugin.LogDebug("SetInitialCardsPostfix - randomizing " + ((Character)__instance).SourceName);
for (int i = 0; i < cards.Count; i++)
{
string text = cards[i];
Plugin.LogDebug(text);
if (!Globals.Instance.GetCardData(text, true).Starter && !((Object)(object)Globals.Instance.GetCardData(text, true) == (Object)null))
{
Plugin.LogDebug("past check");
string id = ChaoticCorruptionsFunctions.GetRandomCardWeighted(__instance, craftableOnly: false).Id;
Plugin.LogDebug("newCard " + id);
cards[i] = id;
}
}
((Character)__instance).Cards = cards;
}
else if (Plugin.RandomizeStartingDecks.Value || devMode)
{
for (int j = 0; j < cards.Count; j++)
{
string text2 = cards[j];
cards[j] = ChaoticCorruptionsFunctions.GetRandomCardWeighted(__instance).Id;
}
((Character)__instance).Cards = cards;
}
if (!Plugin.CorruptStartingDecks.Value && !devMode)
{
return;
}
Plugin.LogDebug("SetInitialCardsPostfix - corrupting " + ((Character)__instance).SourceName);
for (int k = 0; k < cards.Count; k++)
{
string text3 = cards[k];
int index = k;
Globals instance = Globals.Instance;
object obj;
if (instance == null)
{
obj = null;
}
else
{
CardData cardData = instance.GetCardData(text3, true);
if (cardData == null)
{
obj = null;
}
else
{
CardData upgradesToRare = cardData.UpgradesToRare;
obj = ((upgradesToRare != null) ? upgradesToRare.Id : null);
}
}
if (obj == null)
{
obj = cards[k];
}
cards[index] = (string)obj;
}
((Character)__instance).Cards = cards;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(CardCraftManager), "CanCraftThisCard")]
public static void CanCraftThisCardPostfix(ref CardCraftManager __instance, ref bool __result, CardData cData)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Invalid comparison between Unknown and I4
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Invalid comparison between Unknown and I4
if ((Plugin.CraftableCorruptions.Value || devMode) && (int)cData.CardUpgraded == 3 && ChaoticCorruptionsFunctions.CanCraftRarity(__instance, cData))
{
__result = true;
}
else if (Plugin.OnlyCraftCorrupts.Value || devMode)
{
if ((int)cData.CardUpgraded == 3 && ChaoticCorruptionsFunctions.CanCraftRarity(__instance, cData))
{
__result = true;
}
else
{
__result = false;
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(CardCraftManager), "ShowCardCraft")]
public static void ShowCardCraftPostfix(CardCraftManager __instance, BotonAdvancedCraft ___buttonAdvancedCraft)
{
Plugin.LogDebug("ShowCardCraftPostfix");
if ((Plugin.OnlyCraftCorrupts.Value || devMode) && __instance.craftType == 2)
{
Plugin.LogDebug("ShowCardCraftPostfix - setting Active");
__instance.AdvancedCraft(true);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Globals), "GetCraftCost")]
public static void GetCraftCostPostfix(ref int __result, string cardId, float discountCraft = 0f, float discountUpgrade = 0f, int zoneTier = 0)
{
//IL_0054: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Invalid comparison between Unknown and I4
Plugin.LogDebug("GetCraftCostPostfix - " + cardId);
if ((Plugin.CraftableCorruptionsCost.Value > 0 && Plugin.CraftableCorruptions.Value) || devMode)
{
CardData cardData = Globals.Instance.GetCardData(cardId, true);
if (!((Object)(object)cardData == (Object)null) && (int)cardData.CardUpgraded == 3)
{
int value = Plugin.CraftableCorruptionsCost.Value;
value -= Functions.FuncRoundToInt((float)value * discountUpgrade);
value += Functions.FuncRoundToInt((float)((double)value * (double)AtOManager.Instance.Sandbox_cardCraftPrice * 0.009999999776482582));
__result += value;
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SteamManager), "SetObeliskScore")]
public static bool SetObeliskScorePrefix(ref SteamManager __instance, int score, bool singleplayer = true)
{
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SteamManager), "SetScore")]
public static bool SetScorePrefix(ref SteamManager __instance, int score, bool singleplayer = true)
{
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SteamManager), "SetSingularityScore")]
public static bool SetSingularityScorePrefix(ref SteamManager __instance, int score, bool singleplayer = true)
{
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SteamManager), "SetObeliskScoreLeaderboard")]
public static bool SetObeliskScoreLeaderboardPrefix(ref SteamManager __instance, int score, bool singleplayer = true)
{
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SteamManager), "SetScoreLeaderboard")]
public static bool SetScoreLeaderboardPrefix(ref SteamManager __instance, int score, bool singleplayer = true)
{
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(SteamManager), "SetSingularityScoreLeaderboard")]
public static bool SetSingularityScoreLeaderboardPrefix(ref SteamManager __instance, int score, bool singleplayer = true)
{
return false;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Globals), "CreateGameContent")]
public static void CreateGameContent(ref Globals __instance, ref Dictionary<string, CardData> ____CardsSource, ref Dictionary<string, CardData> ____Cards, ref Dictionary<CardType, List<string>> ____CardItemByType, ref Dictionary<CardType, List<string>> ____CardListByType, ref Dictionary<CardClass, List<string>> ____CardListByClass, ref List<string> ____CardListNotUpgraded, ref Dictionary<CardClass, List<string>> ____CardListNotUpgradedByClass, ref Dictionary<string, List<string>> ____CardListByClassType, ref Dictionary<string, int> ____CardEnergyCost)
{
string text = "chaos";
string baseId = "lasthope";
CardData val = ChaoticCorruptionsFunctions.AddNewCard("chaotic" + text, baseId, ref ____CardsSource, ref ____Cards);
val.UpgradedFrom = "";
val.CardClass = (CardClass)9;
val.EnergyCost = 0;
val.CardType = (CardType)16;
val.AddCard = 1;
val.AddCardChoose = 6;
val.AddCardVanish = false;
val.AddCardReducedCost = 0;
val.AddCardPlace = (CardPlace)5;
val.CardName = "Chaos";
val.CardUpgraded = (CardUpgraded)3;
val.CardRarity = (CardRarity)3;
val.Playable = true;
string text2 = "chaosrare";
CardData val2 = ChaoticCorruptionsFunctions.AddNewCard("chaotic" + text2, baseId, ref ____CardsSource, ref ____Cards);
val2.UpgradedFrom = "";
val2.CardClass = (CardClass)9;
val2.EnergyCost = 0;
val2.CardType = (CardType)16;
val2.AddCard = 1;
val2.RelatedCard = "";
val2.AddCardChoose = 10;
val2.CardName = "CHAOS!";
val2.AddCardVanish = false;
val2.AddCardPlace = (CardPlace)5;
val2.CardUpgraded = (CardUpgraded)3;
val2.CardRarity = (CardRarity)4;
val2.AddCardReducedCost = 0;
val2.Playable = true;
ChaoticCorruptionsFunctions.InitNewCard(val, ref ____CardItemByType, ref ____CardListByType, ref ____CardListByClass, ref ____CardListNotUpgraded, ref ____CardListNotUpgradedByClass, ref ____CardListByClassType, ref ____CardEnergyCost);
ChaoticCorruptionsFunctions.InitNewCard(val2, ref ____CardItemByType, ref ____CardListByType, ref ____CardListByClass, ref ____CardListNotUpgraded, ref ____CardListNotUpgradedByClass, ref ____CardListByClassType, ref ____CardEnergyCost);
}
}
public class CustomFunctions
{
public enum AppliesTo
{
None,
Global,
Monsters,
Heroes,
ThisHero
}
public enum CharacterHas
{
Perk,
Item,
Trait
}
public enum IsAuraOrCurse
{
Aura,
Curse,
Both
}
public static string perkBase = "<RenameThisForPerks>";
public static void TraitHeal(ref Character _character, Character _target, int healAmount, string traitName)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Expected O, but got Unknown
int num = healAmount;
if (_target.GetHpLeftForMax() < healAmount)
{
num = _target.GetHpLeftForMax();
}
if (num > 0)
{
_target.ModifyHp(num, true, true);
CastResolutionForCombatText val = new CastResolutionForCombatText();
val.heal = num;
if (_target.HeroItem != null)
{
((CharacterItem)_target.HeroItem).ScrollCombatTextDamageNew(val);
EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)_target.HeroItem).CharImageT, false, 0f);
}
else
{
((CharacterItem)_target.NPCItem).ScrollCombatTextDamageNew(val);
EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)_target.NPCItem).CharImageT, false, 0f);
}
_target.SetEvent((EventActivation)15, (Character)null, 0, "");
_character.SetEvent((EventActivation)14, _target, 0, "");
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
}
}
public static void TraitHealHero(ref Character _character, ref Hero _target, int healAmount, string traitName)
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
if (_target == null || !((Character)_target).IsHero || !((Character)_target).Alive)
{
return;
}
int num = healAmount;
if (((Character)_target).GetHpLeftForMax() < healAmount)
{
num = ((Character)_target).GetHpLeftForMax();
}
if (num > 0)
{
((Character)_target).ModifyHp(num, true, true);
CastResolutionForCombatText val = new CastResolutionForCombatText();
val.heal = num;
if (((Character)_target).HeroItem != null)
{
((CharacterItem)((Character)_target).HeroItem).ScrollCombatTextDamageNew(val);
EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)((Character)_target).HeroItem).CharImageT, false, 0f);
}
else
{
((CharacterItem)((Character)_target).NPCItem).ScrollCombatTextDamageNew(val);
EffectsManager.Instance.PlayEffectAC("healimpactsmall", true, ((CharacterItem)((Character)_target).NPCItem).CharImageT, false, 0f);
}
((Character)_target).SetEvent((EventActivation)15, (Character)null, 0, "");
_character.SetEvent((EventActivation)14, (Character)(object)_target, 0, "");
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
}
}
public static void WhenYouGainXGainY(string ACGained, string targetAC, string ACtoApply, int nGained, int nToApply, float multiplier, ref Character _character, string traitName)
{
if ((!((Object)(object)MatchManager.Instance == (Object)null) || ACGained != null || IsLivingHero(_character)) && !(targetAC == ACtoApply) && ACGained == targetAC)
{
int num = Mathf.RoundToInt((float)(nGained + nToApply) * multiplier);
_character.SetAuraTrait(_character, ACtoApply, num);
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
}
}
public static void WhenYouPlayXGainY(CardType desiredCardType, string desiredAuraCurse, int n_charges, CardData castedCard, ref Character _character, string traitName)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)MatchManager.Instance != (Object)null && (Object)(object)castedCard != (Object)null && (Object)(object)_character.HeroData != (Object)null && castedCard.GetCardTypes().Contains(desiredCardType))
{
_character.SetAuraTrait(_character, desiredAuraCurse, n_charges);
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
}
}
public static void ReduceCostByStacks(CardType cardType, string auraCurseName, int nCharges, ref Character _character, ref List<string> heroHand, ref List<CardData> cardDataList, string traitName, bool applyToAllCards)
{
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)_character.HeroData != (Object)null))
{
return;
}
int num = Mathf.FloorToInt((float)(_character.EffectCharges(auraCurseName) / nCharges));
if (num <= 0)
{
return;
}
for (int i = 0; i < heroHand.Count; i++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
if (cardData.GetCardFinalCost() > 0 && (cardData.GetCardTypes().Contains(cardType) || applyToAllCards))
{
cardDataList.Add(cardData);
}
}
for (int j = 0; j < cardDataList.Count; j++)
{
CardData obj = cardDataList[j];
obj.EnergyReductionTemporal += num;
MatchManager.Instance.UpdateHandCards();
CardItem cardFromTableByIndex = MatchManager.Instance.GetCardFromTableByIndex(cardDataList[j].InternalId);
cardFromTableByIndex.PlayDissolveParticle();
cardFromTableByIndex.ShowEnergyModification(-num);
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
MatchManager.Instance.CreateLogCardModification(cardDataList[j].InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
}
}
public static void ReduceCardTypeCostUntilDiscarded(CardType cardType, int amountToReduce, ref Character _character, ref List<string> heroHand, ref List<CardData> cardDataList, string traitName)
{
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
if (_character.HeroData == null)
{
return;
}
if (amountToReduce <= 0)
{
return;
}
for (int i = 0; i < heroHand.Count; i++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
if (cardData != null && cardData.GetCardFinalCost() > 0 && cardData.HasCardType(cardType))
{
cardDataList.Add(cardData);
}
}
for (int j = 0; j < cardDataList.Count; j++)
{
CardData val = cardDataList[j];
if (val != null)
{
val.EnergyReductionTemporal += amountToReduce;
MatchManager.Instance.UpdateHandCards();
CardItem cardFromTableByIndex = MatchManager.Instance.GetCardFromTableByIndex(val.InternalId);
cardFromTableByIndex.PlayDissolveParticle();
cardFromTableByIndex.ShowEnergyModification(-amountToReduce);
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
MatchManager.Instance.CreateLogCardModification(val.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
}
}
}
public static void AddImmunityToHero(string immunity, ref Hero _character)
{
if (_character != null && !((Character)_character).AuracurseImmune.Contains(immunity))
{
((Character)_character).AuracurseImmune.Add(immunity);
}
}
public static void IncreaseChargesByStacks(string auraCurseToModify, float stacks_per_bonus, string auraCurseDependent, ref Character _character)
{
int auraCharges = _character.GetAuraCharges(auraCurseDependent);
int num = Mathf.FloorToInt((float)auraCharges / stacks_per_bonus);
_character.ModifyAuraCurseQuantity(auraCurseToModify, num);
}
public static AuraCurseData GetAuraCurseData(string auraCurse)
{
return Globals.Instance.GetAuraCurseData(auraCurse);
}
public static string TextChargesLeft(int currentCharges, int chargesTotal)
{
int num = currentCharges;
int num2 = chargesTotal;
return "<br><color=#FFF>" + num + "/" + num2 + "</color>";
}
public static void Duality(ref Character _character, ref CardData _castedCard, CardClass class1, CardClass class2, string _trait)
{
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: 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_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_0109: 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_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
if (MatchManager.Instance == null || _castedCard == null)
{
return;
}
TraitData traitData = Globals.Instance.GetTraitData(_trait);
if (MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(_trait) && MatchManager.Instance.activatedTraits[_trait] > traitData.TimesPerTurn - 1)
{
return;
}
for (int i = 0; i < 2; i++)
{
CardClass val;
CardClass val2;
if (i == 0)
{
val = class1;
val2 = class2;
}
else
{
val = class2;
val2 = class1;
}
if (_castedCard.CardClass != val)
{
continue;
}
if (MatchManager.Instance.CountHeroHand(-1) == 0 || _character.HeroData == null)
{
break;
}
List<CardData> list = new List<CardData>();
List<string> heroHand = MatchManager.Instance.GetHeroHand(_character.HeroIndex);
int num = 0;
for (int j = 0; j < heroHand.Count; j++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[j], true);
if (cardData != null && cardData.CardClass == val2 && _character.GetCardFinalCost(cardData) > num)
{
num = _character.GetCardFinalCost(cardData);
}
}
if (num <= 0)
{
break;
}
for (int k = 0; k < heroHand.Count; k++)
{
CardData cardData2 = MatchManager.Instance.GetCardData(heroHand[k], true);
if (cardData2 != null && cardData2.CardClass == val2 && _character.GetCardFinalCost(cardData2) >= num)
{
list.Add(cardData2);
}
}
if (list.Count <= 0)
{
break;
}
CardData val3 = ((list.Count != 1) ? list[MatchManager.Instance.GetRandomIntRange(0, list.Count, "trait", "")] : list[0]);
if (val3 != null)
{
if (!MatchManager.Instance.activatedTraits.ContainsKey(_trait))
{
MatchManager.Instance.activatedTraits.Add(_trait, 1);
}
else
{
Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
int value = activatedTraits[_trait] + 1;
activatedTraits[_trait] = value;
}
MatchManager.Instance.SetTraitInfoText();
int num2 = 1;
val3.EnergyReductionTemporal += num2;
MatchManager.Instance.GetCardFromTableByIndex(val3.InternalId).ShowEnergyModification(-num2);
MatchManager.Instance.UpdateHandCards();
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitData.TraitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[_trait], traitData.TimesPerTurn), (CombatScrollEffectType)7);
MatchManager.Instance.CreateLogCardModification(val3.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
}
break;
}
}
public static void PermanentyReduceXWhenYouPlayY(ref Character _character, ref CardData _castedCard, CardType reduceThis, CardType whenYouPlayThis, int amountToReduce, string _trait)
{
//IL_0077: 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_00ca: Invalid comparison between Unknown and I4
//IL_0143: Unknown result type (might be due to invalid IL or missing references)
if (MatchManager.Instance == null || _castedCard == null)
{
return;
}
TraitData traitData = Globals.Instance.GetTraitData(_trait);
if ((MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(_trait) && MatchManager.Instance.activatedTraits[_trait] > traitData.TimesPerTurn - 1) || !_castedCard.GetCardTypes().Contains(whenYouPlayThis) || MatchManager.Instance.CountHeroHand(-1) == 0 || _character.HeroData == null)
{
return;
}
List<CardData> list = new List<CardData>();
List<string> heroHand = MatchManager.Instance.GetHeroHand(_character.HeroIndex);
if ((int)reduceThis == 0)
{
for (int i = 0; i < heroHand.Count; i++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
if (cardData != null)
{
list.Add(cardData);
}
}
}
else
{
for (int j = 0; j < heroHand.Count; j++)
{
CardData cardData2 = MatchManager.Instance.GetCardData(heroHand[j], true);
if (cardData2 != null && cardData2.GetCardTypes().Contains(reduceThis))
{
list.Add(cardData2);
}
}
}
if (!MatchManager.Instance.activatedTraits.ContainsKey(_trait))
{
MatchManager.Instance.activatedTraits.Add(_trait, 1);
}
else
{
Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
int value = activatedTraits[_trait] + 1;
activatedTraits[_trait] = value;
}
CardData val = list[MatchManager.Instance.GetRandomIntRange(0, list.Count, "trait", "")];
val.EnergyReductionPermanent += amountToReduce;
MatchManager.Instance.GetCardFromTableByIndex(val.InternalId).ShowEnergyModification(-amountToReduce);
MatchManager.Instance.UpdateHandCards();
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + _trait, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[_trait], traitData.TimesPerTurn), (CombatScrollEffectType)7);
MatchManager.Instance.CreateLogCardModification(val.InternalId, MatchManager.Instance.GetHero(_character.HeroIndex));
}
public static int CountAllStacks(string auraCurse, Hero[] teamHero = null, NPC[] teamNpc = null, bool includeHeroes = true, bool includeNpcs = true)
{
if ((Object)(object)MatchManager.Instance == (Object)null)
{
return 0;
}
if (teamHero == null)
{
teamHero = MatchManager.Instance.GetTeamHero();
}
if (teamNpc == null)
{
teamNpc = MatchManager.Instance.GetTeamNPC();
}
int num = 0;
if (includeHeroes)
{
for (int i = 0; i < teamHero.Length; i++)
{
if (IsLivingHero((Character)(object)teamHero[i]))
{
num += ((Character)teamHero[i]).GetAuraCharges(auraCurse);
}
}
}
if (includeNpcs)
{
for (int j = 0; j < teamNpc.Length; j++)
{
if (IsLivingNPC((Character)(object)teamNpc[j]))
{
num += ((Character)teamNpc[j]).GetAuraCharges(auraCurse);
}
}
}
return num;
}
public static void DealIndirectDamageToAllMonsters(DamageType damageType, int amount)
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
Plugin.Log.LogDebug((object)(Plugin.debugBase + "Dealing Indirect Damage"));
if ((Object)(object)MatchManager.Instance == (Object)null)
{
return;
}
NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
foreach (NPC val in teamNPC)
{
if (IsLivingNPC((Character)(object)val))
{
((Character)val).IndirectDamage(damageType, amount, (AudioClip)null, "", "", "");
}
}
}
public static List<int> GetValidCharacters(Character[] characters)
{
List<int> list = new List<int>();
for (int i = 0; i < characters.Length; i++)
{
Character val = characters[i];
if (val.Alive && val != null)
{
list.Add(i);
}
}
return list;
}
public static Character GetFrontCharacter(Character[] characters)
{
List<int> validCharacters = GetValidCharacters(characters);
int num = validCharacters.First();
return characters[num];
}
public static Character GetBackCharacter(Character[] characters)
{
List<int> validCharacters = GetValidCharacters(characters);
int num = validCharacters.Last();
return characters[num];
}
public static Character GetRandomCharacter(Character[] array)
{
if (array == null)
{
Plugin.Log.LogDebug((object)(Plugin.debugBase + "Null Array"));
}
List<Character> list = new List<Character>();
for (int i = 0; i < array.Length; i++)
{
if (array[i] == null)
{
Plugin.Log.LogDebug((object)(Plugin.debugBase + "Null index"));
continue;
}
Character val = array[i];
if (val.Alive && val != null)
{
list.Add(val);
}
}
if (list.Count == 0)
{
return null;
}
int randomIntRange = MatchManager.Instance.GetRandomIntRange(0, list.Count, "default", "");
if (randomIntRange < list.Count)
{
return list[randomIntRange];
}
if (list[randomIntRange] == null)
{
return null;
}
return list[0];
}
public static bool IsLivingHero(Character _character)
{
return _character != null && _character.Alive && _character.IsHero;
}
public static bool IsLivingNPC(Character _character)
{
return _character != null && _character.Alive && !_character.IsHero;
}
public static bool CharacterHasPerkForSet(string perkName, bool flag, AtOManager __instance, Character _characterTarget)
{
return flag && _characterTarget != null && __instance.CharacterHavePerk(_characterTarget.SubclassName, perkBase + perkName);
}
public static bool CharacterHasPerkForConsume(string perkName, bool flag, AtOManager __instance, Character _characterCaster)
{
return flag && _characterCaster != null && __instance.CharacterHavePerk(_characterCaster.SubclassName, perkBase + perkName);
}
public static bool TeamHasPerk(string perkName)
{
if ((Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
return AtOManager.Instance.TeamHavePerk(perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
}
public static bool IfCharacterHas(Character characterOfInterest, CharacterHas characterHas, string id, AppliesTo appliesTo = AppliesTo.Global, string _type = "", string onlyThisType = "")
{
if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
if (_type != "" && onlyThisType != _type)
{
return false;
}
bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global || (appliesTo == AppliesTo.ThisHero && characterOfInterest.IsHero);
bool flag2 = false;
if (appliesTo == AppliesTo.ThisHero)
{
switch (characterHas)
{
case CharacterHas.Item:
flag2 = AtOManager.Instance.CharacterHaveItem(characterOfInterest.SubclassName, perkBase + id) || AtOManager.Instance.CharacterHaveItem(characterOfInterest.SubclassName, id);
break;
case CharacterHas.Perk:
flag2 = AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, perkBase + id) || AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, id);
break;
case CharacterHas.Trait:
flag2 = AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, perkBase + id) || AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, id);
break;
}
}
else
{
switch (characterHas)
{
case CharacterHas.Item:
flag2 = AtOManager.Instance.TeamHaveItem(perkBase + id, -1, false) || AtOManager.Instance.TeamHaveItem(id, -1, false);
break;
case CharacterHas.Perk:
flag2 = AtOManager.Instance.TeamHavePerk(perkBase + id) || AtOManager.Instance.TeamHavePerk(id);
break;
case CharacterHas.Trait:
flag2 = AtOManager.Instance.TeamHaveTrait(perkBase + id) || AtOManager.Instance.TeamHaveTrait(id);
break;
}
}
return flag2 && flag;
}
public static bool TeamHasPerkGACM(Character characterOfInterest, string perkName, AppliesTo appliesTo = AppliesTo.Global, string _type = "", string onlyThisType = "")
{
if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
if (_type != "" && onlyThisType != _type)
{
return false;
}
bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global;
bool flag2 = AtOManager.Instance.TeamHavePerk(perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
return flag2 && flag;
}
public static bool CharacterHasPerkGACM(Character characterOfInterest, string perkName, AppliesTo appliesTo = AppliesTo.Global)
{
if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global;
bool flag2 = AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, perkBase + perkName) || AtOManager.Instance.CharacterHavePerk(characterOfInterest.SubclassName, perkName);
return flag2 && flag;
}
public static bool TeamHasTraitGACM(Character characterOfInterest, string perkName, AppliesTo appliesTo = AppliesTo.Global, string _type = "", string onlyThisType = "")
{
if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
if (_type != "" && onlyThisType != _type)
{
return false;
}
bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global;
bool flag2 = AtOManager.Instance.TeamHaveTrait(perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
return flag2 && flag;
}
public static bool CharacterHasTraitGACM(Character characterOfInterest, string perkName, AppliesTo appliesTo = AppliesTo.Global, string _type = "", string onlyThisType = "")
{
if (appliesTo == AppliesTo.None || characterOfInterest == null || (Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
if (_type != "" && onlyThisType != _type)
{
return false;
}
bool flag = (characterOfInterest.IsHero && appliesTo == AppliesTo.Heroes) || (!characterOfInterest.IsHero && appliesTo == AppliesTo.Monsters) || appliesTo == AppliesTo.Global;
bool flag2 = AtOManager.Instance.CharacterHaveTrait(characterOfInterest.SubclassName, perkBase + perkName) || AtOManager.Instance.TeamHavePerk(perkName);
return flag2 && flag;
}
public static bool TeamHasPerkForSet(string perkName, bool flag, AtOManager __instance, Character _characterTarget)
{
return _characterTarget != null && __instance.TeamHavePerk(perkBase + perkName) && flag;
}
public static bool TeamHasPerkForConsume(string perkName, bool flag, AtOManager __instance, Character _characterCaster)
{
if ((Object)(object)__instance == (Object)null)
{
return false;
}
return _characterCaster != null && (__instance.TeamHavePerk(perkBase + perkName) || __instance.TeamHavePerk(perkName)) && flag;
}
public static bool CharacterObjectHavePerk(Character _character, string _perkID)
{
if (_character == null || (Object)(object)AtOManager.Instance == (Object)null)
{
return false;
}
return AtOManager.Instance.CharacterHavePerk(_character.SubclassName, perkBase + _perkID) || AtOManager.Instance.CharacterHavePerk(_character.SubclassName, _perkID);
}
public static void PlayCardForFree(string cardToCast)
{
if (cardToCast != null && !((Object)(object)Globals.Instance == (Object)null))
{
CardData cardData = Globals.Instance.GetCardData(cardToCast, true);
if ((Object)(object)cardData == (Object)null)
{
Plugin.LogDebug("Invalid CardName");
}
else
{
((MonoBehaviour)MatchManager.Instance).StartCoroutine(MatchManager.Instance.CastCard((CardItem)null, true, cardData, 0, -1, true));
}
}
}
public static void PlaySoundEffect(Character _character, string ACeffect)
{
if ((Object)(object)_character.HeroItem != (Object)null)
{
EffectsManager.Instance.PlayEffectAC(ACeffect, true, ((CharacterItem)_character.HeroItem).CharImageT, false, 0f);
}
}
public static void DisplayRemainingChargesForTrait(ref Character _character, TraitData traitData)
{
if ((Object)(object)_character.HeroItem != (Object)null)
{
((CharacterItem)_character.HeroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitData.TraitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[traitData.TraitName], traitData.TimesPerTurn), (CombatScrollEffectType)7);
}
}
public static void DisplayTraitScroll(ref Character _character, TraitData traitData)
{
HeroItem heroItem = _character.HeroItem;
if (heroItem != null)
{
((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitData.TraitName, ""), (CombatScrollEffectType)7);
}
}
public static void DisplayTraitScroll(ref Character _character, string traitName)
{
HeroItem heroItem = _character.HeroItem;
if (heroItem != null)
{
((CharacterItem)heroItem).ScrollCombatText(Texts.Instance.GetText("traits_" + traitName, ""), (CombatScrollEffectType)7);
}
}
public static void IncrementTraitActivations(TraitData traitData)
{
string id = traitData.Id;
if (!MatchManager.Instance.activatedTraits.ContainsKey(id))
{
MatchManager.Instance.activatedTraits.Add(id, 1);
}
else
{
MatchManager.Instance.activatedTraits[id]++;
}
MatchManager.Instance.SetTraitInfoText();
}
public static void IncrementTraitActivations(string traitId)
{
TraitData traitData = Globals.Instance.GetTraitData(traitId);
IncrementTraitActivations(traitData);
}
public static bool CanIncrementTraitActivations(TraitData traitData, int bonusActivations = 0)
{
Plugin.LogDebug("canIncrementTraitActivations");
if ((Object)(object)traitData == (Object)null)
{
return false;
}
string id = traitData.Id;
if ((Object)(object)MatchManager.Instance == (Object)null)
{
return false;
}
if (MatchManager.Instance.activatedTraits == null)
{
return false;
}
if (MatchManager.Instance.activatedTraits.ContainsKey(id) && MatchManager.Instance.activatedTraits[id] > traitData.TimesPerTurn - 1 + bonusActivations)
{
return false;
}
if (!MatchManager.Instance.activatedTraits.ContainsKey(id))
{
MatchManager.Instance.activatedTraits.Add(id, 0);
}
return true;
}
public static bool CanIncrementTraitActivations(string traitId, int bonusActivations = 0)
{
TraitData traitData = Globals.Instance.GetTraitData(traitId);
return CanIncrementTraitActivations(traitData, bonusActivations);
}
public static void ModifyAllAurasOrCursesByPercent(int percentToModify, IsAuraOrCurse isAuraOrCurse, Character _characterTarget, Character _characterCaster)
{
if (percentToModify == 0 || _characterTarget == null || !_characterTarget.Alive)
{
return;
}
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
if ((isAuraOrCurse == IsAuraOrCurse.Aura || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify > 0)
{
num = percentToModify;
}
if ((isAuraOrCurse == IsAuraOrCurse.Aura || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify < 0)
{
num2 = Math.Abs(percentToModify);
}
if ((isAuraOrCurse == IsAuraOrCurse.Curse || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify > 0)
{
num3 = percentToModify;
}
if ((isAuraOrCurse == IsAuraOrCurse.Curse || isAuraOrCurse == IsAuraOrCurse.Both) && percentToModify < 0)
{
num4 = Math.Abs(percentToModify);
}
if (_characterTarget == null || !_characterTarget.Alive)
{
return;
}
for (int i = 0; i < 4; i++)
{
if ((i == 0 && num <= 0) || (i == 1 && num3 <= 0) || (i == 2 && num2 <= 0) || (i == 3 && num4 <= 0))
{
continue;
}
List<string> list = new List<string>();
List<int> list2 = new List<int>();
for (int j = 0; j < _characterTarget.AuraList.Count; j++)
{
if (_characterTarget.AuraList[j] != null && (Object)(object)_characterTarget.AuraList[j].ACData != (Object)null && _characterTarget.AuraList[j].GetCharges() > 0 && !(_characterTarget.AuraList[j].ACData.Id == "furnace"))
{
bool flag = false;
if ((i == 0 || i == 2) && _characterTarget.AuraList[j].ACData.IsAura)
{
flag = true;
}
else if ((i == 1 || i == 3) && !_characterTarget.AuraList[j].ACData.IsAura)
{
flag = true;
}
if (flag)
{
list.Add(_characterTarget.AuraList[j].ACData.Id);
list2.Add(_characterTarget.AuraList[j].GetCharges());
}
}
}
if (list.Count <= 0)
{
continue;
}
for (int k = 0; k < list.Count; k++)
{
int num5 = i switch
{
0 => Functions.FuncRoundToInt((float)((double)list2[k] * (double)num / 100.0)),
1 => Functions.FuncRoundToInt((float)((double)list2[k] * (double)num3 / 100.0)),
2 => list2[k] - Functions.FuncRoundToInt((float)((double)list2[k] * (double)num2 / 100.0)),
_ => list2[k] - Functions.FuncRoundToInt((float)((double)list2[k] * (double)num4 / 100.0)),
};
switch (i)
{
case 0:
case 1:
{
AuraCurseData val = AtOManager.Instance.GlobalAuraCurseModificationByTraitsAndItems("set", list[k], _characterCaster, _characterTarget);
if ((Object)(object)val != (Object)null)
{
int maxCharges = val.GetMaxCharges();
if (maxCharges > -1 && list2[k] + num5 > maxCharges)
{
num5 = maxCharges - list2[k];
}
_characterTarget.SetAura(_characterCaster, val, num5, false, (CardClass)11, false, false);
}
break;
}
case 2:
case 3:
if (num5 <= 0)
{
num5 = 1;
}
_characterTarget.ModifyAuraCurseCharges(list[k], num5);
_characterTarget.UpdateAuraCurseFunctions((AuraCurseData)null, 0, -1);
break;
}
}
}
}
public static void ApplyAuraCurseToAll(string acToApply, int nToApply, AppliesTo appliesTo, Character sourceCharacter = null, bool useCharacterMods = false, bool isPreventable = true)
{
Plugin.LogInfo("ApplyAuraCurseToAll");
if ((Object)(object)MatchManager.Instance == (Object)null)
{
Plugin.LogError("No MatchManager");
return;
}
if (sourceCharacter == null && useCharacterMods)
{
Plugin.LogError("No Source Character");
return;
}
AuraCurseData auraCurseData = GetAuraCurseData(acToApply);
if ((Object)(object)auraCurseData == (Object)null)
{
Plugin.LogError("Improper AuraCurse");
return;
}
Hero[] teamHero = MatchManager.Instance.GetTeamHero();
NPC[] teamNPC = MatchManager.Instance.GetTeamNPC();
switch (appliesTo)
{
case AppliesTo.Heroes:
{
Hero[] array2 = teamHero;
foreach (Hero val2 in array2)
{
if (IsLivingHero((Character)(object)val2))
{
((Character)val2).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
}
}
break;
}
case AppliesTo.Global:
{
Hero[] array3 = teamHero;
foreach (Hero val3 in array3)
{
if (IsLivingHero((Character)(object)val3))
{
((Character)val3).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
}
}
NPC[] array4 = teamNPC;
foreach (NPC val4 in array4)
{
if (IsLivingNPC((Character)(object)val4))
{
((Character)val4).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
}
}
break;
}
case AppliesTo.Monsters:
{
NPC[] array = teamNPC;
foreach (NPC val in array)
{
if (IsLivingNPC((Character)(object)val))
{
((Character)val).SetAura(sourceCharacter, auraCurseData, nToApply, false, (CardClass)11, useCharacterMods, isPreventable);
}
}
break;
}
}
}
public static string CollectionToString(Collection<object> values)
{
return string.Join(",", values);
}
public static string CollectionToString(Dictionary<string, int> dictionary)
{
return "{" + string.Join(",", dictionary.Select((KeyValuePair<string, int> kv) => kv.Key + "=" + kv.Value).ToArray()) + "}";
}
public static void DrawCards(int numToDraw)
{
MatchManager.Instance.NewCard(numToDraw, (CardFrom)0, "");
}
public static void GainEnergy(Character _character, int energyToGain, TraitData traitData = null)
{
if (!IsLivingHero(_character))
{
Plugin.LogDebug("GainEnergy - Invalid Character");
return;
}
Plugin.LogDebug("GainEnergy - Modifying Energy");
_character.ModifyEnergy(energyToGain, true);
if (_character.HeroItem != null)
{
Plugin.LogDebug("GainEnergy - Setting Effect AC");
EffectsManager.Instance.PlayEffectAC("energy", true, ((CharacterItem)_character.HeroItem).CharImageT, false, 0f);
if (!((Object)(object)traitData == (Object)null))
{
}
}
}
public static void StealAuraCurses(ref Character characterStealing, ref Character characterToStealFrom, int nToSteal, IsAuraOrCurse isAuraOrCurse = IsAuraOrCurse.Aura)
{
if (isAuraOrCurse == IsAuraOrCurse.Both)
{
Plugin.LogDebug("Must Specify Aura or Curse to Steal");
return;
}
if (characterStealing == null || characterToStealFrom == null || !characterStealing.Alive || !characterToStealFrom.Alive)
{
Plugin.LogDebug("Character to Steal from or Character Stealing is not a valid living character");
return;
}
List<string> list = new List<string>();
List<int> list2 = new List<int>();
int num = 0;
if (characterToStealFrom != null)
{
for (int i = 0; i < characterToStealFrom.AuraList.Count; i++)
{
if (num >= nToSteal)
{
break;
}
bool flag = characterToStealFrom.AuraList[i] != null && (Object)(object)characterToStealFrom.AuraList[i].ACData != (Object)null;
bool flag2 = ((isAuraOrCurse == IsAuraOrCurse.Aura) ? characterToStealFrom.AuraList[i].ACData.IsAura : (!characterToStealFrom.AuraList[i].ACData.IsAura));
bool flag3 = characterToStealFrom.AuraList[i].ACData.Removable && characterToStealFrom.AuraList[i].GetCharges() > 0;
if (flag && flag2 && flag3)
{
list.Add(characterToStealFrom.AuraList[i].ACData.Id);
list2.Add(characterToStealFrom.AuraList[i].GetCharges());
num++;
}
}
}
if (num <= 0)
{
return;
}
characterToStealFrom.HealCursesName(list, "");
for (int j = 0; j < list.Count; j++)
{
if (characterStealing != null && characterStealing.Alive)
{
characterStealing.SetAura(characterToStealFrom, Globals.Instance.GetAuraCurseData(list[j]), list2[j], false, (CardClass)11, true, true);
}
}
}
public static List<string> GetDeck(Character character)
{
return character.Cards;
}
public static List<CardData> GetDeckCardData(Character character)
{
List<CardData> list = new List<CardData>();
foreach (string card in character.Cards)
{
list.Add(Globals.Instance.GetCardData(card, true));
}
return list;
}
public static int CountAllACOnCharacter(Character character, IsAuraOrCurse isAuraOrCurse)
{
int num = 0;
foreach (Aura aura in character.AuraList)
{
bool flag = true;
switch (isAuraOrCurse)
{
case IsAuraOrCurse.Aura:
flag = aura.ACData.IsAura;
break;
case IsAuraOrCurse.Curse:
flag = !aura.ACData.IsAura;
break;
case IsAuraOrCurse.Both:
flag = true;
break;
}
if (flag)
{
num += aura.AuraCharges;
}
}
return num;
}
public static void ReduceCardCost(ref CardData cardData, Character currentCharacter = null, int amountToReduce = 1, bool isPermanent = false)
{
if ((Object)(object)MatchManager.Instance == (Object)null || (Object)(object)cardData == (Object)null)
{
Plugin.LogError("Null MatchManager/card");
return;
}
Plugin.LogDebug("Reducing card Cost");
if (currentCharacter == null)
{
currentCharacter = (Character)(object)MatchManager.Instance.GetHeroHeroActive();
}
if (currentCharacter == null)
{
Plugin.LogError("Null Current Character");
return;
}
if (isPermanent)
{
Plugin.LogDebug("Reducing card Cost - permanent");
CardData obj = cardData;
obj.EnergyReductionPermanent += amountToReduce;
}
else
{
Plugin.LogDebug("Reducing card Cost - temporary");
CardData obj2 = cardData;
obj2.EnergyReductionTemporal += amountToReduce;
}
Plugin.LogDebug("Reducing card Cost - updates");
MatchManager.Instance.GetCardFromTableByIndex(cardData.InternalId).ShowEnergyModification(-amountToReduce);
MatchManager.Instance.UpdateHandCards();
MatchManager.Instance.CreateLogCardModification(cardData.InternalId, MatchManager.Instance.GetHero(currentCharacter.HeroIndex));
Plugin.LogDebug("Reducing card Cost - END");
}
public static CardData GetRandomHighestCostCard(CardType cardType, List<string> heroHand = null)
{
//IL_006b: 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)
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)MatchManager.Instance == (Object)null)
{
Plugin.LogError("Null MatchManager");
return null;
}
if (heroHand == null)
{
heroHand = MatchManager.Instance.GetHeroHand(MatchManager.Instance.GetHeroActive());
}
int num = 0;
List<CardData> list = new List<CardData>();
for (int i = 0; i < heroHand.Count; i++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
if (cardData != null && (cardData.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData.GetCardFinalCost() > num)
{
num = cardData.GetCardFinalCost();
}
}
if (num <= 0)
{
return null;
}
for (int j = 0; j < heroHand.Count; j++)
{
CardData cardData2 = MatchManager.Instance.GetCardData(heroHand[j], true);
if (cardData2 != null && (cardData2.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData2.GetCardFinalCost() >= num)
{
list.Add(cardData2);
}
}
if (list.Count <= 0)
{
return null;
}
return (list.Count != 1) ? list[MatchManager.Instance.GetRandomIntRange(0, list.Count, "default", "")] : list[0];
}
public static List<CardData> GetCardsFromHand(CardType cardType = 0, int equalOrAboveCertainCost = 0, int lessThanOrEqualToThisCost = 100)
{
//IL_0057: 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)
Character heroHeroActive = (Character)(object)MatchManager.Instance.GetHeroHeroActive();
List<string> heroHand = MatchManager.Instance.GetHeroHand(heroHeroActive.HeroIndex);
List<CardData> list = new List<CardData>();
for (int i = 0; i < heroHand.Count; i++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
if ((Object)(object)cardData != (Object)null && cardData.GetCardFinalCost() > 0 && (cardData.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData.GetCardFinalCost() >= equalOrAboveCertainCost && cardData.GetCardFinalCost() <= lessThanOrEqualToThisCost)
{
list.Add(cardData);
}
}
return list;
}
public static List<CardData> GetCardsFromHand(List<string> heroHand, CardType cardType = 0, int equalOrAboveCertainCost = 0, int lessThanOrEqualToThisCost = 100)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
List<CardData> list = new List<CardData>();
for (int i = 0; i < heroHand.Count; i++)
{
CardData cardData = MatchManager.Instance.GetCardData(heroHand[i], true);
if ((Object)(object)cardData != (Object)null && cardData.GetCardFinalCost() > 0 && (cardData.GetCardTypes().Contains(cardType) || (int)cardType == 0) && cardData.GetCardFinalCost() >= equalOrAboveCertainCost && cardData.GetCardFinalCost() <= lessThanOrEqualToThisCost)
{
list.Add(cardData);
}
}
return list;
}
public static CardData GetRightmostCard(List<string> heroHand)
{
return MatchManager.Instance.GetCardData(heroHand.Last(), true);
}
}
[BepInPlugin("com.binbin.ChaoticCorruptions", "ChaoticCorruptions", "0.9.0")]
[BepInProcess("AcrossTheObelisk.exe")]
public class Plugin : BaseUnityPlugin
{
internal int ModDate = int.Parse(DateTime.Today.ToString("yyyyMMdd"));
private readonly Harmony harmony = new Harmony("com.binbin.ChaoticCorruptions");
internal static ManualLogSource Log;
public static string debugBase = "com.binbin.ChaoticCorruptions ";
public static ConfigEntry<bool> EnableMod { get; set; }
public static ConfigEntry<bool> EnableDebugging { get; set; }
public static ConfigEntry<int> IncreaseCardCorruptionOdds { get; set; }
public static ConfigEntry<int> IncreaseItemCorruptionOdds { get; set; }
public static ConfigEntry<bool> GuaranteeCorruptCards { get; set; }
public static ConfigEntry<bool> GuaranteeCorruptItems { get; set; }
public static ConfigEntry<bool> CorruptStartingDecks { get; set; }
public static ConfigEntry<bool> CorruptStartingItems { get; set; }
public static ConfigEntry<bool> RandomizeStartingDecks { get; set; }
public static ConfigEntry<bool> CompletelyRandomizeStartingDecks { get; set; }
public static ConfigEntry<bool> ChaoticStartingDeck { get; set; }
public static ConfigEntry<bool> CraftableCorruptions { get; set; }
public static ConfigEntry<int> CraftableCorruptionsCost { get; set; }
public static ConfigEntry<bool> PurchaseableCorruptPets { get; set; }
public static ConfigEntry<int> PurchaseableCorruptPetsMultiplier { get; set; }
public static ConfigEntry<bool> OnlyCraftCorrupts { get; set; }
public static ConfigEntry<bool> DevMode { get; set; }
private void Awake()
{
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_0047: Expected O, but got Unknown
//IL_005d: 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_0078: Expected O, but got Unknown
//IL_0078: Expected O, but got Unknown
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_009f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Expected O, but got Unknown
//IL_00a9: Expected O, but got Unknown
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
//IL_00da: Expected O, but got Unknown
//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
//IL_010b: Expected O, but got Unknown
//IL_010b: Expected O, but got Unknown
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0132: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Expected O, but got Unknown
//IL_013c: Expected O, but got Unknown
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Expected O, but got Unknown
//IL_016d: Expected O, but got Unknown
//IL_0183: Unknown result type (might be due to invalid IL or missing references)
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Expected O, but got Unknown
//IL_019e: Expected O, but got Unknown
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Expected O, but got Unknown
//IL_01cf: Expected O, but got Unknown
//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0200: Expected O, but got Unknown
//IL_0200: Expected O, but got Unknown
//IL_0216: Unknown result type (might be due to invalid IL or missing references)
//IL_0227: Unknown result type (might be due to invalid IL or missing references)
//IL_0231: Expected O, but got Unknown
//IL_0231: Expected O, but got Unknown
//IL_0247: Unknown result type (might be due to invalid IL or missing references)
//IL_0258: Unknown result type (might be due to invalid IL or missing references)
//IL_0262: Expected O, but got Unknown
//IL_0262: Expected O, but got Unknown
//IL_0278: Unknown result type (might be due to invalid IL or missing references)
//IL_028d: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Expected O, but got Unknown
//IL_0297: Expected O, but got Unknown
//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
//IL_02be: Unknown result type (might be due to invalid IL or missing references)
//IL_02c8: Expected O, but got Unknown
//IL_02c8: Expected O, but got Unknown
//IL_02de: Unknown result type (might be due to invalid IL or missing references)
//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
//IL_02f9: Expected O, but got Unknown
//IL_02f9: Expected O, but got Unknown
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"com.binbin.ChaoticCorruptions 0.9.0 has loaded!");
EnableMod = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "EnableMod"), true, new ConfigDescription("Enables the mod. If false, the mod will not work then next time you load the game.", (AcceptableValueBase)null, Array.Empty<object>()));
EnableDebugging = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "EnableDebugging"), false, new ConfigDescription("Enables the debugging", (AcceptableValueBase)null, Array.Empty<object>()));
IncreaseCardCorruptionOdds = ((BaseUnityPlugin)this).Config.Bind<int>(new ConfigDefinition("ChaoticCorruptions", "IncreaseCardCorruptionOdds"), 0, new ConfigDescription("Adds a second roll to corrupt cards. 100 will make it guaranteed", (AcceptableValueBase)null, Array.Empty<object>()));
IncreaseItemCorruptionOdds = ((BaseUnityPlugin)this).Config.Bind<int>(new ConfigDefinition("ChaoticCorruptions", "IncreaseItemCorruptionOdds"), 0, new ConfigDescription("Adds a second roll to corrupt items. 100 will make it guaranteed", (AcceptableValueBase)null, Array.Empty<object>()));
GuaranteeCorruptCards = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "GuaranteeCorruptCards"), false, new ConfigDescription("Guarantees all card rewards are corrupted.", (AcceptableValueBase)null, Array.Empty<object>()));
GuaranteeCorruptItems = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "GuaranteeCorruptItems"), false, new ConfigDescription("Guarantees all item rewardss are corrupted.", (AcceptableValueBase)null, Array.Empty<object>()));
CorruptStartingDecks = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "CorruptStartingDecks"), false, new ConfigDescription("Forces all starting cards to be corrupted.", (AcceptableValueBase)null, Array.Empty<object>()));
CorruptStartingItems = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "CorruptStartingItems"), false, new ConfigDescription("Forces all starting items to be corrupted.", (AcceptableValueBase)null, Array.Empty<object>()));
RandomizeStartingDecks = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "RandomizeStartingDecks"), true, new ConfigDescription("Randomizes starting decks from all craftable cards. If CorruptStartingDecks is active, they are all corrupted", (AcceptableValueBase)null, Array.Empty<object>()));
CompletelyRandomizeStartingDecks = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "CompletelyRandomizeStartingDecks"), true, new ConfigDescription("Randomizes starting decks from all available cards for each hero's class. If CorruptStartingDecks is active, they are all corrupted", (AcceptableValueBase)null, Array.Empty<object>()));
ChaoticStartingDeck = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "PandorasBox"), false, new ConfigDescription("If true, replaces your starting deck with Chaos (discovers a card). If CorruptStartingDecks is active, replaces your deck with CHAOS (discovers a corrupted card). Overrides all other starting deck options.", (AcceptableValueBase)null, Array.Empty<object>()));
CraftableCorruptions = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "CraftableCorruptions"), true, new ConfigDescription("Makes corrupted cards craftable", (AcceptableValueBase)null, Array.Empty<object>()));
CraftableCorruptionsCost = ((BaseUnityPlugin)this).Config.Bind<int>(new ConfigDefinition("ChaoticCorruptions", "CraftableCorruptionsCost"), 800, new ConfigDescription("The cost added to the regular crafting cost that will be added to the card to craft the corrupted version.", (AcceptableValueBase)null, Array.Empty<object>()));
OnlyCraftCorrupts = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "OnlyCraftCorrupts"), false, new ConfigDescription("Makes it so that the only cards you can craft are corrupted cards", (AcceptableValueBase)null, Array.Empty<object>()));
DevMode = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("ChaoticCorruptions", "DevMode"), false, new ConfigDescription("Enables all of the things for testing.", (AcceptableValueBase)null, Array.Empty<object>()));
if (EnableMod.Value)
{
harmony.PatchAll();
}
}
internal static void LogDebug(string msg)
{
if (EnableDebugging.Value)
{
Log.LogDebug((object)(debugBase + msg));
}
}
internal static void LogInfo(string msg)
{
Log.LogInfo((object)(debugBase + msg));
}
internal static void LogError(string msg)
{
Log.LogError((object)(debugBase + msg));
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "com.binbin.ChaoticCorruptions";
public const string PLUGIN_NAME = "ChaoticCorruptions";
public const string PLUGIN_VERSION = "0.9.0";
}
}
