using System;
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 System.Text;
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.definiteseeds")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+9f94eec87355cb15fa15feb344e6aaf3db55e091")]
[assembly: AssemblyProduct("SeedSearcher")]
[assembly: AssemblyTitle("com.binbin.definiteseeds")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.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 SeedSearcher
{
public static 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 debugBase = "<RenameThis>";
public static string perkBase = "<RenameThisForPerks>";
public static string SerializeDictionary(Dictionary<string, List<string>> dict)
{
if (dict == null)
{
throw new ArgumentNullException("dict");
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append('{');
List<string> list = dict.Keys.OrderBy((string k) => k).ToList();
for (int i = 0; i < list.Count; i++)
{
string text = list[i];
List<string> list2 = dict[text];
stringBuilder.Append("\"" + text + "\":[");
for (int j = 0; j < list2.Count; j++)
{
stringBuilder.Append("\"" + list2[j] + "\"");
if (j < list2.Count - 1)
{
stringBuilder.Append(',');
}
}
stringBuilder.Append(']');
if (i < list.Count - 1)
{
stringBuilder.Append(',');
}
}
stringBuilder.Append('}');
return stringBuilder.ToString();
}
public static void PLog(string s)
{
Plugin.Log.LogDebug((object)(debugBase + s));
}
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, string traitName)
{
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 traitName)
{
//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(traitName);
if ((MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(traitName) && MatchManager.Instance.activatedTraits[traitName] > 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(traitName))
{
MatchManager.Instance.activatedTraits.Add(traitName, 1);
}
else
{
Dictionary<string, int> activatedTraits = MatchManager.Instance.activatedTraits;
int value = activatedTraits[traitName] + 1;
activatedTraits[traitName] = 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_" + traitName, "") + TextChargesLeft(MatchManager.Instance.activatedTraits[traitName], 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)(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)(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)(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)
{
PLog("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 IncrementTraitActivations(TraitData traitData)
{
string id = traitData.Id;
if (CanIncrementTraitActivations(traitData))
{
if (!MatchManager.Instance.activatedTraits.ContainsKey(id))
{
MatchManager.Instance.activatedTraits.Add(id, 1);
}
else
{
MatchManager.Instance.activatedTraits[id]++;
}
MatchManager.Instance.SetTraitInfoText();
}
}
public static bool CanIncrementTraitActivations(TraitData traitData)
{
string id = traitData.Id;
if (!((Object)(object)MatchManager.Instance != (Object)null))
{
return false;
}
if (MatchManager.Instance.activatedTraits != null && MatchManager.Instance.activatedTraits.ContainsKey(id) && MatchManager.Instance.activatedTraits[id] > traitData.TimesPerTurn - 1)
{
return false;
}
return true;
}
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;
}
}
}
}
}
[BepInPlugin("com.binbin.definiteseeds", "SeedSearcher", "1.0.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.definiteseeds");
internal static ManualLogSource Log;
public static string debugBase = "com.binbin.definiteseeds ";
public static ConfigEntry<bool> RunSeedSearcher { 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
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"com.binbin.definiteseeds 1.0.0 has loaded!");
RunSeedSearcher = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("RunSeedSearcher", "RunSeedSearcher"), true, new ConfigDescription("If false, disables the mod. Restart the game upon changing this setting.", (AcceptableValueBase)null, Array.Empty<object>()));
LogDebug($"Pre-Log Items {RunSeedSearcher.Value}");
if (RunSeedSearcher.Value)
{
harmony.PatchAll();
}
LogDebug($"Post-Log Items {RunSeedSearcher.Value}");
}
internal static void LogDebug(string msg)
{
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));
}
}
[HarmonyPatch]
public class SeedSearcher
{
[HarmonyPrefix]
[HarmonyPatch(typeof(AtOManager), "BeginAdventure")]
public static void BeginAdventurePrefix(ref AtOManager __instance, out string __state)
{
Plugin.LogInfo("BeginAdventurePrefix - Start");
__state = __instance.GetGameId();
Plugin.LogInfo("BeginAdventurePrefix - GameID - " + __state);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(AtOManager), "BeginAdventure")]
public static void BeginAdventurePostfix(ref AtOManager __instance, string __state)
{
Plugin.LogInfo("BeginAdventurePostfix - Start");
__instance.SetGameId(__state);
Plugin.LogInfo("BeginAdventurePostfix - GameID - " + __instance.GetGameId());
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Globals), "CreateGameContent")]
public static void CreateGameContentPostfix(ref Globals __instance)
{
Plugin.LogInfo("CreateGameContentPostfix - Start");
Plugin.LogInfo("CreateGameContentPostfix - END ");
}
public static void LogAllItems()
{
Plugin.LogInfo("LogAllItems - Start");
LogCaravanItems();
}
internal static void LogPetItems()
{
Dictionary<string, string> lootNodeMap = new Dictionary<string, string>
{
{ "Jelly", "aquar_41" },
{ "betty", "sen_39" },
{ "blobbleed", "sen_29" },
{ "blobcold", "sewers_13" },
{ "blobdire", "velka_37" },
{ "blobholy", "pyr_12" },
{ "bloblightning", "sahti_30" },
{ "blobmetal", "velka_38" },
{ "blobmind", "dread_7" },
{ "blobpoison", "aquar_44" },
{ "blobselem", "voidlow_28" },
{ "blobshadow", "ulmin_59" },
{ "blobsmyst", "voidlow_28" },
{ "blobsphys", "voidlow_28" },
{ "blobwater", "aquar_45" },
{ "cuby", "pyr_9" },
{ "cubyd", "pyr_9" },
{ "daley", "faen_7" },
{ "fenny", "ulmin_6" },
{ "fishlava", "forge_8" },
{ "inky", "aquar_41" },
{ "liante", "lair_5" },
{ "matey", "sahti_20" },
{ "mimy", "dread_10" },
{ "oculy", "aquar_41" },
{ "sharpy", "aquar_18" },
{ "slimy", "lair_7" },
{ "stormy", "aquar_24" },
{ "wolfy", "sen_46" }
};
int nSeeds = 300;
HandleDropItems(lootNodeMap, nSeeds);
}
internal static void LogBossDropItems()
{
Dictionary<string, string> lootNodeMap = new Dictionary<string, string>
{
{ "Basthet", "pyr_7" },
{ "Dryad_a", "sen_31" },
{ "Dryad_b", "sen_32" },
{ "Faeborg", "faen_38" },
{ "Hydra", "aquar_35" },
{ "Ignidoh", "velka_32" },
{ "Mansionright", "faen_35" },
{ "Mortis", "ulmin_56" },
{ "Tulah", "lair_8" },
{ "Ylmer", "sen_33" },
{ "belphyor", "secta_5" },
{ "belphyorquest", "velka_8" },
{ "burninghand", "velka_25" },
{ "dreadhalfman", "dread_11" },
{ "elvenarmory", "faen_29" },
{ "elvenarmoryplus", "faen_29" },
{ "goblintown", "velka_6" },
{ "harpychest", "velka_27" },
{ "harpyfight", "velka_27" },
{ "khazakdhum", "velka_29" },
{ "kingrat", "sewers_8" },
{ "minotaurcave", "velka_9" },
{ "sahtikraken", "sahti_65" },
{ "sahtikrakenmjolmir", "sahti_65" },
{ "sahtirustkingtreasure", "sahti_62" },
{ "spiderqueen", "sen_1" },
{ "tyrant", "faen_25" },
{ "tyrantbeavers", "faen_25" },
{ "tyrantchampy", "faen_25" },
{ "tyrantchompy", "faen_25" },
{ "tyrantchumpy", "faen_25" },
{ "upripreboss", "uprising_13" },
{ "yogger", "sen_27" }
};
int nSeeds = 300;
HandleDropItems(lootNodeMap, nSeeds);
}
internal static void LogGuaranteedDropItems()
{
Dictionary<string, string> lootNodeMap = new Dictionary<string, string>
{
{ "FrozenSewersElves", "sewers_11" },
{ "FrozenSewersMix", "sewers_11" },
{ "FrozenSewersRatmen", "sewers_11" },
{ "Jewelerrings", "sen_35" },
{ "Mansionleft", "faen_35" },
{ "Mansionleftplus", "faen_35" },
{ "Sailor", "faen_4" },
{ "Stolenitems", "faen_10" },
{ "apprentince", "sen_24" },
{ "balanceblack", "ulmin_52" },
{ "balanceboth", "ulmin_52" },
{ "balancewhite", "ulmin_52" },
{ "battlefield", "aquar_6" },
{ "bridge", "sen_17" },
{ "chappel", "sen_21" },
{ "crane", "velka_21" },
{ "crocoloot", "aquar_7" },
{ "crocosmugglers", "aquar_48" },
{ "desertreliquary", "ulmin_58" },
{ "dreadcosme", "dread_2" },
{ "dreadcuthbert", "dread_2" },
{ "dreadfrancis", "dread_2" },
{ "dreadhoratio", "dread_2" },
{ "dreadjack", "dread_2" },
{ "dreadmimic", "dread_10" },
{ "dreadrhodogor", "dread_2" },
{ "eeriechest_a", "sen_6" },
{ "eeriechest_b", "sen_6" },
{ "lavacascade", "velka_22" },
{ "lootedarmory", "pyr_10" },
{ "lootsepulchralrare", "voidlow_18" },
{ "obsidianall", "forge_3" },
{ "obsidiananvil", "forge_3" },
{ "obsidianboots", "forge_3" },
{ "obsidianrings", "forge_3" },
{ "obsidianrods", "forge_3" },
{ "rift", "velka_40" },
{ "riftsen", "sen_48" },
{ "sahtibernardstash", "sahti_52" },
{ "sahtidomedesert", "sahti_49" },
{ "sahtidomeice", "sahti_49" },
{ "sahtidomemain", "sahti_49" },
{ "sahtidomemountain", "sahti_49" },
{ "sahtidomeswamp", "sahti_49" },
{ "sahtipiratearsenal", "sahti_25" },
{ "sahtipiratewarehouse", "sahti_25" },
{ "sahtiplaguecot", "sahti_11" },
{ "sahtisurgeonarsenal", "sahti_13" },
{ "sahtisurgeonstash", "sahti_13" },
{ "sahtitreasurechamber", "sahti_25" },
{ "sahtivalkyriestash", "sahti_19" },
{ "thorimsrod", "forge_8" },
{ "treasureaquarfall", "aquar_28" },
{ "uprienergy", "uprising_5" },
{ "uprimagma", "uprising_4" },
{ "voidcraftemerald", "voidlow_14" },
{ "voidcraftgolden", "voidlow_14" },
{ "voidcraftobsidian", "voidlow_14" },
{ "voidcraftpearl", "voidlow_14" },
{ "voidcraftring", "voidlow_14" },
{ "voidcraftruby", "voidlow_14" },
{ "voidcraftsapphire", "voidlow_14" },
{ "voidcrafttopaz", "voidlow_14" },
{ "voidtreasurejade", "voidlow_16" },
{ "watermill", "sen_15" }
};
int nSeeds = 300;
HandleDropItems(lootNodeMap, nSeeds);
}
internal static void LogShopItems()
{
Dictionary<string, string> lootNodeMap = new Dictionary<string, string>
{
{ "aquarvendor", "aquar_26" },
{ "elvenemporium", "faen_23" },
{ "felineshop", "ulmin_29" },
{ "firebazaar", "velka_20" }
};
int nSeeds = 300;
HandleDropItems(lootNodeMap, nSeeds);
}
internal static void HandleDropItems(Dictionary<string, string> lootNodeMap, int nSeeds = 300)
{
Dictionary<string, List<string>> itemDict = new Dictionary<string, List<string>>();
foreach (string key in lootNodeMap.Keys)
{
LootData lootData = Globals.Instance.GetLootData(key);
List<string> list = new List<string>();
LootItem[] lootItemTable = lootData.LootItemTable;
foreach (LootItem val in lootItemTable)
{
if (!((Object)(object)val.LootCard == (Object)null) && val.LootCard.CardName != "")
{
list.Add(val.LootCard.Id);
}
}
Plugin.LogDebug("Shop - " + key + " Valid Items - " + string.Join(", ", list));
for (int j = 0; j < nSeeds; j++)
{
string seed = Functions.RandomStringSafe(7f, 0f).ToUpper();
string node = lootNodeMap[key];
List<string> itemsFromSeed = GetItemsFromSeed(seed, key, node, 0, _obeliskChallenge: false, 8, 8);
UpdateItemDictForShops(ref itemDict, itemsFromSeed, list, seed, key);
}
}
Plugin.LogDebug("Shop Items - " + CustomFunctions.SerializeDictionary(itemDict));
}
internal static void LogCaravanItems()
{
Dictionary<string, List<string>> itemDict = new Dictionary<string, List<string>>();
int num = 1000;
for (int i = 0; i < num; i++)
{
string seed = Functions.RandomStringSafe(7f, 0f).ToUpper();
string shop = "caravanshop";
string node = "sen_44";
List<string> itemsFromSeed = GetItemsFromSeed(seed, shop, node, 0, _obeliskChallenge: false, 1);
UpdateItemDict(ref itemDict, itemsFromSeed, seed);
}
Plugin.LogDebug("Dictionary - " + CustomFunctions.SerializeDictionary(itemDict));
}
internal static void UpdateItemDictForShops(ref Dictionary<string, List<string>> itemDict, List<string> itemList, List<string> validItems, string seed, string shopName, int count = 5)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Invalid comparison between Unknown and I4
foreach (string item in itemList)
{
if (!validItems.Contains(item))
{
continue;
}
CardData cardData = Globals.Instance.GetCardData(item, false);
if (!((Object)(object)cardData == (Object)null) && (int)cardData.CardUpgraded == 3)
{
string key = shopName + " - " + cardData.CardName;
if (!itemDict.ContainsKey(key))
{
itemDict.Add(key, new List<string>());
}
if (itemDict[key].Count() < count)
{
itemDict[key].Add(seed);
}
}
}
}
internal static void UpdateItemDict(ref Dictionary<string, List<string>> itemDict, List<string> itemList, string seed, int count = 5)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Invalid comparison between Unknown and I4
foreach (string item in itemList)
{
CardData cardData = Globals.Instance.GetCardData(item, false);
string key = (((int)cardData.CardUpgraded == 3) ? (cardData.CardName + " (Corrupted)") : cardData.CardName);
if (!itemDict.ContainsKey(key))
{
itemDict.Add(key, new List<string>());
}
if (itemDict[key].Count() < count)
{
itemDict[key].Add(seed);
}
}
}
internal static List<string> GetItemsFromSeed(string _seed = "", string _shop = "caravanshop", string _node = "", int _townReroll = 0, bool _obeliskChallenge = false, int _madness = 0, int _corruptorCount = 0, bool _poverty = false)
{
//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
//IL_03bb: Invalid comparison between Unknown and I4
//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0201: Invalid comparison between Unknown and I4
//IL_0672: Unknown result type (might be due to invalid IL or missing references)
//IL_0678: Invalid comparison between Unknown and I4
//IL_067c: Unknown result type (might be due to invalid IL or missing references)
//IL_0682: Invalid comparison between Unknown and I4
//IL_069c: Unknown result type (might be due to invalid IL or missing references)
//IL_06a2: Invalid comparison between Unknown and I4
//IL_0255: Unknown result type (might be due to invalid IL or missing references)
//IL_0428: Unknown result type (might be due to invalid IL or missing references)
//IL_042e: Invalid comparison between Unknown and I4
//IL_025e: Unknown result type (might be due to invalid IL or missing references)
//IL_0265: Unknown result type (might be due to invalid IL or missing references)
//IL_045c: Unknown result type (might be due to invalid IL or missing references)
//IL_0462: Invalid comparison between Unknown and I4
//IL_06bc: Unknown result type (might be due to invalid IL or missing references)
//IL_06c2: Invalid comparison between Unknown and I4
//IL_0498: Unknown result type (might be due to invalid IL or missing references)
//IL_049e: Invalid comparison between Unknown and I4
//IL_027c: Unknown result type (might be due to invalid IL or missing references)
//IL_0283: Unknown result type (might be due to invalid IL or missing references)
//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
//IL_04f5: Invalid comparison between Unknown and I4
//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
//IL_04df: Invalid comparison between Unknown and I4
//IL_028c: Unknown result type (might be due to invalid IL or missing references)
//IL_0293: Unknown result type (might be due to invalid IL or missing references)
//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
string text = "";
string text2 = _node;
if (_shop == "caravanshop" && text2 == "")
{
text2 = "sen_44";
}
if (_townReroll > 0)
{
}
LootData lootData = Globals.Instance.GetLootData(_shop);
if ((Object)(object)lootData == (Object)null)
{
Plugin.LogError("Unable to get shop items for " + _shop + " (shop does not exist!)");
return null;
}
List<string> list = new List<string>();
List<string> list2 = new List<string>();
for (int i = 0; i < Globals.Instance.CardListByClass[(CardClass)8].Count; i++)
{
list2.Add(Globals.Instance.CardListByClass[(CardClass)8][i]);
}
int deterministicHashCode = Functions.GetDeterministicHashCode(text2 + _seed + text);
Random.InitState(deterministicHashCode);
IListExtensions.Shuffle<string>((IList<string>)list2, deterministicHashCode);
int num = 0;
int num2 = ((!_obeliskChallenge) ? lootData.NumItems : lootData.LootItemTable.Length);
for (int j = 0; j < num2; j++)
{
if (list.Count >= lootData.NumItems)
{
break;
}
if (j >= lootData.LootItemTable.Length)
{
continue;
}
LootItem val = lootData.LootItemTable[j];
if (!((double)Random.Range(0, 100) < (double)val.LootPercent))
{
continue;
}
if ((Object)(object)val.LootCard != (Object)null)
{
list.Add(val.LootCard.Id);
continue;
}
bool flag = false;
int num3 = 0;
CardData val2 = null;
while (!flag && num3 < 10000)
{
if (num >= list2.Count)
{
num = 0;
}
string text3 = list2[num];
if (!list.Contains(text3))
{
val2 = Globals.Instance.GetCardData(text3, false);
if ((Object)(object)val2.Item != (Object)null && !val2.Item.DropOnly)
{
if ((int)val2.CardUpgraded == 3)
{
flag = false;
}
else if (val2.Item.PercentRetentionEndGame > 0 && (_madness > 2 || _obeliskChallenge))
{
flag = false;
}
else if (val2.Item.PercentDiscountShop > 0 && _poverty)
{
flag = false;
}
else if ((int)val.LootType == 0 && val2.CardRarity == val.LootRarity)
{
flag = true;
}
else if (val2.CardType == val.LootType && val2.CardRarity == val.LootRarity)
{
flag = true;
}
}
}
num++;
num3++;
}
if (flag && (Object)(object)val2 != (Object)null)
{
list.Add(val2.Id);
}
}
for (int k = list.Count; k < lootData.NumItems; k++)
{
bool flag2 = false;
int num4 = 0;
CardData val3 = null;
int num5 = Random.Range(0, 100);
while (!flag2 && num4 < 10000)
{
if (num >= list2.Count)
{
num = 0;
}
string text4 = list2[num];
if (!list.Contains(text4))
{
val3 = Globals.Instance.GetCardData(text4, false);
if ((Object)(object)val3.Item != (Object)null && !val3.Item.DropOnly)
{
if ((int)val3.CardUpgraded == 3)
{
flag2 = false;
}
else if (val3.Item.PercentRetentionEndGame > 0 && (_madness > 2 || _obeliskChallenge))
{
flag2 = false;
}
else if (val3.Item.PercentDiscountShop > 0 && _poverty)
{
flag2 = false;
}
else if ((double)num5 < (double)lootData.DefaultPercentMythic)
{
if ((int)val3.CardRarity == 4)
{
flag2 = true;
}
}
else if ((double)num5 < (double)lootData.DefaultPercentEpic + (double)lootData.DefaultPercentMythic)
{
if ((int)val3.CardRarity == 3)
{
flag2 = true;
}
}
else if ((double)num5 < (double)lootData.DefaultPercentRare + (double)lootData.DefaultPercentEpic + (double)lootData.DefaultPercentMythic)
{
if ((int)val3.CardRarity == 2)
{
flag2 = true;
}
}
else if ((double)num5 < (double)lootData.DefaultPercentUncommon + (double)lootData.DefaultPercentRare + (double)lootData.DefaultPercentEpic + (double)lootData.DefaultPercentMythic)
{
if ((int)val3.CardRarity == 1)
{
flag2 = true;
}
}
else if ((int)val3.CardRarity == 0)
{
flag2 = true;
}
}
}
num++;
num4++;
if (!flag2 && num4 % 100 == 0)
{
num5 += 10;
}
}
if (flag2 && (Object)(object)val3 != (Object)null)
{
list.Add(val3.Id);
continue;
}
break;
}
IListExtensions.Shuffle<string>((IList<string>)list, deterministicHashCode);
if (!_shop.Contains("towntier") && ((!_obeliskChallenge && _madness > 0) || _obeliskChallenge))
{
int num6 = 0;
if (_shop.Contains("exoticshop"))
{
num6 += 8;
}
else if (_shop.Contains("rareshop"))
{
num6 += 4;
}
if (_obeliskChallenge)
{
if (_madness > 8)
{
num6 += 4;
}
else if (_madness > 4)
{
num6 += 2;
}
}
else
{
num6 += Functions.FuncRoundToInt(0.2f * (float)(_madness + _corruptorCount));
}
for (int l = 0; l < list.Count; l++)
{
int num7 = Random.Range(0, 100);
CardData cardData = Globals.Instance.GetCardData(list[l], false);
if (!((Object)(object)cardData == (Object)null))
{
bool flag3 = false;
if (((int)cardData.CardRarity == 4 || (int)cardData.CardRarity == 3) && num7 < 3 + num6)
{
flag3 = true;
}
else if ((int)cardData.CardRarity == 2 && num7 < 5 + num6)
{
flag3 = true;
}
else if ((int)cardData.CardRarity == 1 && num7 < 7 + num6)
{
flag3 = true;
}
else if ((int)cardData.CardRarity == 0 && num7 < 9 + num6)
{
flag3 = true;
}
if (flag3 && (Object)(object)cardData.UpgradesToRare != (Object)null)
{
list[l] = cardData.UpgradesToRare.Id;
}
}
}
}
return list;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "com.binbin.definiteseeds";
public const string PLUGIN_NAME = "SeedSearcher";
public const string PLUGIN_VERSION = "1.0.0";
}
}
