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 System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Obeliskial_Essentials;
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.UnofficialBalancePatch")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.5.8.0")]
[assembly: AssemblyInformationalVersion("1.5.8+ed9f8cf1e172eed42878881bde32a5eb3df701c0")]
[assembly: AssemblyProduct("UnofficialBalancePatch")]
[assembly: AssemblyTitle("com.binbin.UnofficialBalancePatch")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.8.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 UnofficialBalancePatch
{
public class BalanceFunctions
{
public static string NumFormatItem(int num, bool plus = false, bool percent = false)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(" <nobr>");
if (num > 0)
{
stringBuilder.Append("<color=#263ABC><size=+.1>");
if (plus)
{
stringBuilder.Append("+");
}
}
else
{
stringBuilder.Append("<color=#720070><size=+.1>");
if (plus)
{
stringBuilder.Append("-");
}
}
stringBuilder.Append(Mathf.Abs(num));
if (percent)
{
stringBuilder.Append("%");
}
stringBuilder.Append("</color></size></nobr>");
return stringBuilder.ToString();
}
public static void BinbinNormalizeDescription(ref CardData __instance, StringBuilder stringBuilder)
{
stringBuilder.Replace("<c>", "<color=#5E3016>");
stringBuilder.Replace("</c>", "</color>");
stringBuilder.Replace("<nb>", "<nobr>");
stringBuilder.Replace("</nb>", "</nobr>");
stringBuilder.Replace("<br1>", "<br><line-height=15%><br></line-height>");
stringBuilder.Replace("<br2>", "<br><line-height=30%><br></line-height>");
stringBuilder.Replace("<br3>", "<br><line-height=50%><br></line-height>");
string input = stringBuilder.ToString();
input = Regex.Replace(input, "[,][ ]*(<(.*?)>)*(.)", (Match m) => m.ToString().ToLower());
input = Regex.Replace(input, "<br>\\w", (Match m) => m.ToString().ToUpper());
Globals.Instance.CardsDescriptionNormalized[__instance.Id] = stringBuilder.ToString();
__instance.DescriptionNormalized = input;
Traverse.Create((object)__instance).Field("descriptionNormalized").SetValue((object)input);
}
public static void HandleDamagePercentDescription(ref StringBuilder stringBuilder, ItemData itemData, DamageType damageType, float percentIncrease)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Invalid comparison between Unknown and I4
if (itemData.Id == "battleaxerare")
{
Plugin.LogDebug(" battleaxerare");
}
if ((int)damageType != 0 && (int)damageType != 10 && percentIncrease != 0f)
{
string text = ((object)(DamageType)(ref damageType)).ToString().ToLower();
int num = Functions.FuncRoundToInt(itemData.DamagePercentBonusValue);
Plugin.LogDebug("damage type - " + text);
string text2 = "item" + text + "Damages";
Plugin.LogDebug("medsText - " + Essentials.medsTexts[text2]);
Plugin.LogDebug("GetText - " + Texts.Instance.GetText(text2, ""));
string value = string.Format(Essentials.medsTexts[text2], NumFormatItem(num, plus: true, percent: true)) + "\n";
stringBuilder.Insert(0, value);
}
}
public static void HandleAllDamagePercentDescriptions(ref CardData __instance)
{
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Invalid comparison between Unknown and I4
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
StringBuilder stringBuilder = new StringBuilder();
if ((Object)(object)__instance.Item == (Object)null)
{
return;
}
ItemData item = __instance.Item;
if ((int)item.DamagePercentBonus != 0 || (int)item.DamagePercentBonus2 != 0 || (int)item.DamagePercentBonus3 != 0)
{
if (__instance.Id == "burningorbrare" || __instance.Id == "frozenorbrare")
{
Plugin.LogDebug("Setting Description for " + __instance.Id);
}
stringBuilder.Append(Globals.Instance.CardsDescriptionNormalized[__instance.Id]);
HandleDamagePercentDescription(ref stringBuilder, item, __instance.Item.DamagePercentBonus, __instance.Item.DamagePercentBonusValue);
HandleDamagePercentDescription(ref stringBuilder, item, __instance.Item.DamagePercentBonus2, __instance.Item.DamagePercentBonusValue2);
HandleDamagePercentDescription(ref stringBuilder, item, __instance.Item.DamagePercentBonus3, __instance.Item.DamagePercentBonusValue3);
BinbinNormalizeDescription(ref __instance, stringBuilder);
}
}
public static void UpdateMaxMadnessChargesByItem(ref AuraCurseData __result, Character characterOfInterest, string itemID)
{
Plugin.LogDebug("UpdateChargesByItem: " + itemID);
if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, itemID + "rare", CustomFunctions.AppliesTo.Heroes))
{
ItemData itemData = Globals.Instance.GetItemData(itemID + "rare");
if (!((Object)(object)itemData == (Object)null))
{
if (__result.MaxCharges != -1)
{
AuraCurseData obj = __result;
obj.MaxCharges += itemData.AuracurseCustomModValue1;
}
if (__result.MaxMadnessCharges != -1)
{
AuraCurseData obj2 = __result;
obj2.MaxMadnessCharges += itemData.AuracurseCustomModValue1;
}
}
}
else
{
if (!CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, itemID, CustomFunctions.AppliesTo.Heroes))
{
return;
}
ItemData itemData2 = Globals.Instance.GetItemData(itemID);
if (!((Object)(object)itemData2 == (Object)null))
{
if (__result.MaxCharges != -1)
{
AuraCurseData obj3 = __result;
obj3.MaxCharges += itemData2.AuracurseCustomModValue1;
}
if (__result.MaxMadnessCharges != -1)
{
AuraCurseData obj4 = __result;
obj4.MaxMadnessCharges += itemData2.AuracurseCustomModValue1;
}
}
}
}
public static string SpriteText(string sprite)
{
StringBuilder stringBuilder = new StringBuilder();
string text = sprite.ToLower().Replace(" ", "");
switch (text)
{
case "block":
case "card":
stringBuilder.Append("<space=.2>");
break;
case "piercing":
stringBuilder.Append("<space=.4>");
break;
case "bleed":
stringBuilder.Append("<space=.1>");
break;
case "bless":
stringBuilder.Append("<space=.1>");
break;
default:
stringBuilder.Append("<space=.3>");
break;
}
stringBuilder.Append(" <space=-.2>");
stringBuilder.Append("<size=+.1><sprite name=");
stringBuilder.Append(text);
stringBuilder.Append("></size>");
switch (text)
{
case "bleed":
stringBuilder.Append("<space=-.4>");
break;
case "card":
stringBuilder.Append("<space=-.2>");
break;
case "powerful":
case "fury":
stringBuilder.Append("<space=-.1>");
break;
default:
stringBuilder.Append("<space=-.2>");
break;
case "reinforce":
case "fire":
break;
}
return stringBuilder.ToString();
}
public static string ColorTextArray(string type, params string[] text)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("<nobr>");
if (type == null || type.Length != 0)
{
switch (type)
{
case "damage":
stringBuilder.Append("<color=#B00A00>");
break;
case "heal":
stringBuilder.Append("<color=#1E650F>");
break;
case "aura":
stringBuilder.Append("<color=#263ABC>");
break;
case "curse":
stringBuilder.Append("<color=#720070>");
break;
case "system":
stringBuilder.Append("<color=#5E3016>");
break;
default:
stringBuilder.Append("<color=#5E3016");
stringBuilder.Append(">");
break;
}
}
int num = 0;
foreach (string value in text)
{
if (num > 0)
{
stringBuilder.Append(" ");
}
stringBuilder.Append(value);
num++;
}
if (type != "")
{
stringBuilder.Append("</color>");
}
stringBuilder.Append("</nobr> ");
return stringBuilder.ToString();
}
public static void AppendDescriptionsToCards(CardData __instance, ref StringBuilder stringBuilder1)
{
if (BalancePatches.cardsToAppendDescription.Contains(__instance.Id))
{
Plugin.LogDebug("Creating description for " + __instance.Id);
Plugin.LogDebug($"Current description {__instance.Id}: {stringBuilder1}");
string text = Plugin.itemStem + __instance.Id;
stringBuilder1.Append(Functions.FormatStringCard(Texts.Instance.GetText(text, "")));
}
}
}
[HarmonyPatch]
public class BalancePatches
{
public static List<string> cardsWithCustomDescriptions = new List<string>(14)
{
"surprisebox", "surpriseboxrare", "surprisegiftbox", "surprisegiftboxrare", "bbbtreefellingaxe", "bbbtreefellingaxerare", "bbbcloakofthorns", "bbbcloakofthornsrare", "bbbportablewallofflames", "bbbportablewallofflamesrare",
"bbbslimepoison", "bbbslimepoisonrare", "bbbscrollofpetimmortality", "bbbscrollofpetimmortalityrare"
};
public static List<string> cardsToAppendDescription = new List<string>(2) { "bbbrustedshield", "bbbrustedshieldrare" };
[HarmonyPrefix]
[HarmonyPatch(typeof(Item), "surprisebox")]
public static bool surpriseboxPrefix(Item __instance, Character theCharacter, bool isRare, string itemName)
{
Plugin.LogInfo("executing supriseboxPrefix");
if (!((Object)(object)MatchManager.Instance != (Object)null))
{
return false;
}
int randomIntRange = MatchManager.Instance.GetRandomIntRange(0, 9, "item", "");
int num = 4;
string text;
switch (randomIntRange)
{
case 0:
num = (isRare ? 6 : 3);
text = "fast";
break;
case 1:
num = (isRare ? 10 : 5);
text = "powerful";
break;
case 2:
num = (isRare ? 8 : 4);
text = "bless";
break;
case 3:
num = (isRare ? 8 : 4);
text = "sharp";
break;
case 4:
num = (isRare ? 6 : 3);
text = "fortify";
break;
case 5:
num = (isRare ? 4 : 2);
text = "evasion";
break;
case 6:
num = (isRare ? 10 : 5);
text = "regeneration";
break;
case 7:
num = (isRare ? 4 : 2);
text = "mitigate";
break;
default:
num = (isRare ? 8 : 4);
text = "vitality";
break;
}
theCharacter.SetAuraTrait(theCharacter, text, num);
((CharacterItem)theCharacter.HeroItem).ScrollCombatText(itemName, (CombatScrollEffectType)11);
return false;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Item), "surprisegiftbox")]
public static bool surprisegiftboxPrefix(Item __instance, Character theCharacter, bool isRare, string itemName)
{
Plugin.LogInfo("executing surprisegiftbox prefix");
if (!((Object)(object)MatchManager.Instance != (Object)null))
{
return false;
}
int randomIntRange = MatchManager.Instance.GetRandomIntRange(0, 9, "item", "");
int num = 4;
string text;
switch (randomIntRange)
{
case 0:
num = (isRare ? 6 : 3);
text = "fast";
break;
case 1:
num = (isRare ? 10 : 5);
text = "powerful";
break;
case 2:
num = (isRare ? 8 : 4);
text = "bless";
break;
case 3:
num = (isRare ? 8 : 4);
text = "sharp";
break;
case 4:
num = (isRare ? 6 : 3);
text = "fortify";
break;
case 5:
num = (isRare ? 4 : 2);
text = "evasion";
break;
case 6:
num = (isRare ? 10 : 5);
text = "regeneration";
break;
case 7:
num = (isRare ? 4 : 2);
text = "mitigate";
break;
default:
num = (isRare ? 8 : 4);
text = "vitality";
break;
}
Hero[] teamHero = MatchManager.Instance.GetTeamHero();
for (int i = 0; i < teamHero.Length; i++)
{
if (teamHero[i] != null && (Object)(object)((Character)teamHero[i]).HeroData != (Object)null && ((Character)teamHero[i]).Alive)
{
((Character)teamHero[i]).SetAuraTrait(theCharacter, text, num);
}
}
((CharacterItem)theCharacter.HeroItem).ScrollCombatText(itemName, (CombatScrollEffectType)11);
return false;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(CardData), "SetDescriptionNew")]
public static void SetDescriptionNewPostfix(ref CardData __instance, bool forceDescription = false, Character character = null, bool includeInSearch = true)
{
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Invalid comparison between Unknown and I4
//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Invalid comparison between Unknown and I4
//IL_0291: Unknown result type (might be due to invalid IL or missing references)
//IL_0297: Invalid comparison between Unknown and I4
//IL_040d: Unknown result type (might be due to invalid IL or missing references)
//IL_0412: Unknown result type (might be due to invalid IL or missing references)
//IL_0463: Unknown result type (might be due to invalid IL or missing references)
//IL_0468: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)__instance == (Object)null)
{
Plugin.LogDebug("Null Card");
return;
}
StringBuilder stringBuilder = new StringBuilder();
if (cardsWithCustomDescriptions.Contains(__instance.Id))
{
Plugin.LogDebug("Creating description for " + __instance.Id);
Plugin.LogDebug($"Current description {__instance.Id}: {stringBuilder}");
string text = Plugin.itemStem + __instance.Id;
stringBuilder.Append(Functions.FormatStringCard(Texts.Instance.GetText(text, "")));
BalanceFunctions.BinbinNormalizeDescription(ref __instance, stringBuilder);
return;
}
BalanceFunctions.HandleAllDamagePercentDescriptions(ref __instance);
if (!Globals.Instance.CardsDescriptionNormalized.ContainsKey(__instance.Id))
{
Plugin.LogError("missing card Id " + __instance.Id);
return;
}
string value = Globals.Instance.CardsDescriptionNormalized[__instance.Id];
stringBuilder.Append(value);
if ((Object)(object)__instance.Item != (Object)null && (int)__instance.Item.Activation == 22 && __instance.Item.ExactRound >= 2)
{
Plugin.LogDebug("Attempting to alter description for " + __instance.Id);
Plugin.LogDebug($"Current description {__instance.Id}: {stringBuilder}");
stringBuilder.Replace("Every turn", $"On turn {__instance.Item.ExactRound}");
}
if ((Object)(object)__instance.Item != (Object)null && (int)__instance.Item.Activation == 2 && __instance.Item.ExactRound >= 2)
{
Plugin.LogDebug("Attempting to alter description for " + __instance.Id);
stringBuilder.Replace("Every round", $"On round {__instance.Item.ExactRound}");
}
if (__instance.HealSides != 0)
{
Plugin.LogDebug($"Current description for {__instance.Id}: {stringBuilder}");
string text2 = BalanceFunctions.SpriteText("heal");
string text3 = BalanceFunctions.ColorTextArray("heal", BalanceFunctions.NumFormatItem(__instance.HealSides));
stringBuilder.Append("Heal sides " + text3 + " " + text2);
}
if (__instance.EnergyRecharge != 0 && (int)__instance.TargetSide == 0)
{
Plugin.LogDebug($"Current description for {__instance.Id}: {stringBuilder}");
string text4 = BalanceFunctions.SpriteText("energy");
stringBuilder.Replace("Grant", "Gain");
}
if ((Object)(object)__instance.Item != (Object)null && __instance.Item.CardNum > 1 && __instance.Item.CardToGainList.Count < 1)
{
Plugin.LogDebug($"Current description for {__instance.Id}: {stringBuilder}");
stringBuilder.Replace("cast card", $"Cast card {__instance.Item.CardNum}");
}
if (((Object)(object)__instance.SpecialAuraCurseName1 != (Object)null && __instance.SpecialAuraCurseName1.Id == "stealthbonus") || ((Object)(object)__instance.SpecialAuraCurseNameGlobal != (Object)null && __instance.SpecialAuraCurseNameGlobal.Id == "stealthbonus"))
{
Plugin.LogDebug($"Current description for {__instance.Id}: {stringBuilder}");
stringBuilder.Replace("<sprite name=>", "<sprite name=stealth>");
}
if (__instance.DamageSides > 0 && __instance.DamageSpecialValueGlobal)
{
Plugin.LogDebug($"Current description for {__instance.Id}: {stringBuilder}");
DamageType damageType = __instance.DamageType;
string oldValue = "Target sides <nobr><color=#B00A00><size=+.1>1</size>";
string newValue = "Target sides <nobr><color=#B00A00><size=+.1>X</size>";
stringBuilder.Replace(oldValue, newValue);
}
if (__instance.DamageSides2 > 0 && __instance.Damage2SpecialValueGlobal)
{
Plugin.LogDebug($"Current description for {__instance.Id}: {stringBuilder}");
DamageType damageType2 = __instance.DamageType2;
string oldValue2 = "Target sides <nobr><color=#B00A00><size=+.1>1</size>";
string newValue2 = "Target sides <nobr><color=#B00A00><size=+.1>X</size>";
stringBuilder.Replace(oldValue2, newValue2);
}
BalanceFunctions.AppendDescriptionsToCards(__instance, ref stringBuilder);
BalanceFunctions.BinbinNormalizeDescription(ref __instance, stringBuilder);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(AtOManager), "GlobalAuraCurseModificationByTraitsAndItems")]
public static void GlobalAuraCurseModificationByTraitsAndItemsPostfixGeneral(ref AtOManager __instance, ref AuraCurseData __result, string _type, string _acId, Character _characterCaster, Character _characterTarget)
{
Character characterOfInterest = ((_type == "set") ? _characterTarget : _characterCaster);
Plugin.LogDebug("GACM for Balance Patch");
switch (_acId)
{
case "bleed":
{
string itemID = "bloodstone";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "yoggercleaver";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, "bbbtreefellingaxe", CustomFunctions.AppliesTo.Monsters) || CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, "bbbtreefellingaxerare", CustomFunctions.AppliesTo.Monsters))
{
__result.Preventable = false;
}
break;
}
case "bless":
{
string itemID = "topazring";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "block":
{
string itemID = "crusaderhelmet";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "burn":
{
string itemID = "solring";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "ringoffire";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "chill":
{
string itemID = "lunaring";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "neverfrost";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "crack":
{
string itemID = "bronzegear";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "ironkanabo";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "poison":
{
string itemID = "thepolluter";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "venomamulet";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, "bbbslimepoison", CustomFunctions.AppliesTo.Monsters) || CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, "bbbslimepoisonrare", CustomFunctions.AppliesTo.Monsters))
{
__result.Preventable = false;
}
break;
}
case "sight":
{
string itemID = "eeriering";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "thorns":
{
string itemID = "corruptedplateb";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "shieldofthorns";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "thornyring";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "yggdrasilroot";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "bbbthehedgehog";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "bbbphalanx";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
itemID = "heartofthorns";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
if (CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, "bbbportablewallofflames", CustomFunctions.AppliesTo.ThisHero) || CustomFunctions.IfCharacterHas(characterOfInterest, CustomFunctions.CharacterHas.Item, "bbbportablewallofflamesrare", CustomFunctions.AppliesTo.ThisHero))
{
__result.DamageReflectedType = (DamageType)4;
}
break;
}
case "vitality":
{
string itemID = "heartamulet";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
case "wet":
{
string itemID = "bucket";
BalanceFunctions.UpdateMaxMadnessChargesByItem(ref __result, characterOfInterest, itemID);
break;
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Character), "IndirectDamage")]
public static void IndirectDamagePostfix(ref Character __instance, DamageType damageType, ref int damage, AudioClip sound = null, string effect = "", string sourceCharacterName = "", string sourceCharacterId = "")
{
CustomFunctions.PLog("IndirectDamagePostfix");
if (!((Object)(object)MatchManager.Instance == (Object)null))
{
Character characterById = MatchManager.Instance.GetCharacterById(sourceCharacterId);
if (AtOManager.Instance.TeamHaveItem("bbbcloakofthornsrare", -1, false) && CustomFunctions.IsLivingHero(characterById) && characterById.HasEffect("mitigate") && effect == "thorns")
{
int auraCharges = characterById.GetAuraCharges("mitigate");
float num = 1f + 0.25f * (float)auraCharges;
damage *= Mathf.RoundToInt((float)damage * num);
}
else if (AtOManager.Instance.TeamHaveItem("bbbcloakofthorns", -1, false) && CustomFunctions.IsLivingHero(characterById) && characterById.HasEffect("mitigate") && effect == "thorns")
{
int auraCharges2 = characterById.GetAuraCharges("mitigate");
float num2 = 1f + 0.15f * (float)auraCharges2;
damage *= Mathf.RoundToInt((float)damage * num2);
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(MatchManager), "DestroyedItemInThisTurn")]
public static bool DestroyedItemInThisTurnPrefix(MatchManager __instance, int _charIndex, string _cardId)
{
Plugin.LogDebug("DestroyedItemInThisTurnPrefix");
Hero hero = MatchManager.Instance.GetHero(_charIndex);
if (hero == null)
{
return true;
}
if (((Character)hero).HaveItem("bbbscrollofpetimmortality", -1, false))
{
Plugin.LogDebug("Protecting Pet!");
return false;
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(MatchManager), "CreatePet")]
public static bool CreatePet(MatchManager __instance, CardData cardPet, GameObject charGO, Hero _hero, NPC _npc, bool _fromEnchant = false, int _enchantIndex = -1)
{
Plugin.LogDebug("CreatePet");
if ((Object)(object)cardPet == (Object)null)
{
return true;
}
if (cardPet.Id == "tombstone" && ((Character)_hero).HaveItem("bbbscrollofpetimmortality", -1, false))
{
Plugin.LogDebug("Protecting Pet!");
return false;
}
return true;
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Item), "DoItem")]
public static void DoItemPrefix(EventActivation _theEvent, CardData _cardData, string _item, Character _character, Character _target, int _auxInt, string _auxString, int order, CardData castedCard, ref bool onlyCheckItemActivation)
{
Plugin.LogDebug("DoItemPrefix");
if (!((Object)(object)MatchManager.Instance == (Object)null))
{
List<string> list = new List<string>(4) { "surprisebox", "surpriseboxrare", "surprisegiftbox", "surprisegiftboxrare" };
if (list.Contains(_item))
{
Plugin.LogDebug("DoItemPrefix - found surpriseboxes");
}
if (MatchManager.Instance.GetCurrentRound() != 3 && list.Contains(_item))
{
Plugin.LogDebug("DoItemPrefix - disabling surpriseboxes");
onlyCheckItemActivation = true;
}
else
{
onlyCheckItemActivation = false;
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Item), "DoItemData")]
public static void DoItemDataPrefix(ref Item __instance, Character target, string itemName, int auxInt, CardData cardItem, ref string itemType, ItemData itemData, Character character, int order, string castedCardId = "", EventActivation theEvent = 0)
{
Plugin.LogDebug("DoItemDataPrefix");
if ((Object)(object)itemData != (Object)null && (itemData.Id == "bbbfirestarter" || itemData.Id == "bbbfirestarterrare"))
{
Plugin.LogDebug("Changing Firestarter");
itemData.CardToGainType = (CardType)5;
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(MatchManager), "CastCardAction")]
public static void CastCardActionPostfix(MatchManager __instance, CardData _cardActive, Transform targetTransformCast, CardItem theCardItem, string _uniqueCastId, bool _automatic = false, CardData _card = null, int _cardIterationTotal = 1)
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Invalid comparison between Unknown and I4
Plugin.LogDebug("CastCardActionPostfix");
if ((Object)(object)_cardActive != (Object)null)
{
Plugin.LogDebug("Casted Card - " + _cardActive.Id);
Hero heroHeroActive = __instance.GetHeroHeroActive();
if ((Object)(object)_cardActive != (Object)null && _cardActive.EnergyRecharge > 0 && CustomFunctions.IsLivingHero((Character)(object)heroHeroActive) && (int)_cardActive.TargetSide == 0)
{
Plugin.LogDebug($"Energy Recharge - giving energy - {_cardActive.EnergyRecharge}");
int num = ((_cardActive.EffectRepeat != 0) ? (_cardActive.EnergyRecharge * _cardActive.EffectRepeat) : _cardActive.EnergyRecharge);
((Character)heroHeroActive).ModifyEnergy(num, true);
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(Character), "DamageReflected")]
public static void DamageReflectedPostfix(ref Character __instance, Hero theCasterHero, NPC theCasterNPC)
{
if (!CustomFunctions.IsLivingHero(__instance) && theCasterHero != null)
{
Plugin.LogDebug("DamageReflectedPostfix");
AuraCurseData auraCurseData = CustomFunctions.GetAuraCurseData("thorns");
if ((Object)(object)auraCurseData == (Object)null || auraCurseData.DamageReflectedPerStack <= 0 || theCasterNPC == null)
{
Plugin.LogDebug("DamageReflectedPostfix - Null thorns data");
}
else if (CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Item, "bbbrustedshieldrare", CustomFunctions.AppliesTo.ThisHero))
{
Plugin.LogDebug("DamageReflectedPostfix - Applying bbbrustedshieldrare Poison");
((Character)theCasterNPC).SetAura(__instance, CustomFunctions.GetAuraCurseData("poison"), Functions.FuncRoundToInt((float)__instance.GetAuraCharges("thorns") * 0.75f), false, (CardClass)11, true, true);
}
else if (CustomFunctions.IfCharacterHas(__instance, CustomFunctions.CharacterHas.Item, "bbbrustedshield", CustomFunctions.AppliesTo.ThisHero) && __instance.HasEffect("rust"))
{
Plugin.LogDebug("DamageReflectedPostfix - Applying bbbrustedshield Poison");
((Character)theCasterNPC).SetAura(__instance, CustomFunctions.GetAuraCurseData("poison"), Functions.FuncRoundToInt((float)__instance.GetAuraCharges("thorns") * 0.5f), false, (CardClass)11, true, true);
}
}
}
[HarmonyPrefix]
[HarmonyPatch(typeof(Functions), "GetRandomCardIdByTypeAndRandomRarity")]
public static bool GetRandomCardIdByTypeAndRandomRarityPrefix(ref string __result, CardType _cardType)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
Plugin.LogDebug("GetRandomCardIdByTypeAndRandomRarityPrefix");
CardData cardData = Globals.Instance.GetCardData(Globals.Instance.CardListByType[_cardType][MatchManager.Instance.GetRandomIntRange(0, Globals.Instance.CardListByType[_cardType].Count, "default", "")], false);
__result = Functions.GetCardByRarity(MatchManager.Instance.GetRandomIntRange(0, 100, "default", ""), cardData, false);
return false;
}
}
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 PLog(string s)
{
Plugin.Log.LogDebug((object)(Plugin.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)(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)
{
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.UnofficialBalancePatch", "UnofficialBalancePatch", "1.5.8")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInProcess("AcrossTheObelisk.exe")]
public class Plugin : BaseUnityPlugin
{
internal const int ModDate = 20241206;
private readonly Harmony harmony = new Harmony("com.binbin.UnofficialBalancePatch");
internal static ManualLogSource Log;
public static string itemStem = "binbin_balances_";
public static string debugBase = "Custom Descriptions - ";
private void Awake()
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
Log = ((BaseUnityPlugin)this).Logger;
Log.LogInfo((object)"com.binbin.UnofficialBalancePatch 1.5.8 has loaded!");
Essentials.RegisterMod("UnofficialBalancePatch", "binbin", "Unofficial Balance Patch", "1.5.8", 20241206, "https://github.com/binbinmods/Unofficial-AtO-Balance-Patch", (string[])null, "", 100, (string[])null, "", true);
Array values = Enum.GetValues(typeof(DamageType));
foreach (DamageType item in values)
{
DamageType val = item;
string text = ((object)(DamageType)(ref val)).ToString().ToLower();
Essentials.medsTexts["item" + text + "Damages"] = "<space=.3><size=+.1><sprite name=" + text + "></size> damage {0}";
LogDebug("Setting medsText for itemDamageType: " + text);
}
Essentials.medsTexts[itemStem + "surprisebox"] = "At the start of the third round, gain a significant random buff.";
Essentials.medsTexts[itemStem + "surpriseboxrare"] = "At the start of the third round, gain a more significant random buff.";
Essentials.medsTexts[itemStem + "surprisegiftbox"] = "At the start of the third round, all heroes gain a significant random buff.";
Essentials.medsTexts[itemStem + "surprisegiftboxrare"] = "At the start of the third round, all heroes gain a more significant random buff.";
Essentials.medsTexts[itemStem + "bbbportablewallofflames"] = "<size=+.1><sprite name=thorns></size> charges +1 \n Thorns on this character deal <space=.3><size=+.1><sprite name=fire></size> damage.";
Essentials.medsTexts[itemStem + "bbbportablewallofflamesrare"] = "<size=+.1><sprite name=thorns></size> charges +2 \n Thorns on this character deal <space=.3><size=+.1><sprite name=fire></size> damage.";
Essentials.medsTexts[itemStem + "bbbtreefellingaxe"] = "All damage +1 \n <size=+.1><sprite name=bleed></size> charges +1 \n Bleed on enemies cannot be prevented by Buffer or Immunities.";
Essentials.medsTexts[itemStem + "bbbtreefellingaxerare"] = "All damage +2 \n <size=+.1><sprite name=bleed></size> charges +2 \n Bleed on enemies cannot be prevented by Buffer or Immunities.";
Essentials.medsTexts[itemStem + "bbbslimepoison"] = "All damage +1 \n <size=+.1><sprite name=poison></size> charges +1 \n Poison on enemies cannot be prevented by Buffer or Immunities.";
Essentials.medsTexts[itemStem + "bbbslimepoisonrare"] = "All damage +2 \n <size=+.1><sprite name=poison></size> charges +2 \n Poison on enemies cannot be prevented by Buffer or Immunities.";
Essentials.medsTexts[itemStem + "bbbcloakofthorns"] = "All resistances +5% \n <size=+.1><sprite name=mitigate></size> on heroes increases Thorns damage by 15% per charge.";
Essentials.medsTexts[itemStem + "bbbcloakofthornsrare"] = "All resistances +5% \n <size=+.1><sprite name=mitigate></size> on heroes increases Thorns damage by 25% per charge.";
Essentials.medsTexts[itemStem + "bbbscrollofpetimmortality"] = "Your pet is Immortal!";
Essentials.medsTexts[itemStem + "bbbscrollofpetimmortalityrare"] = "Your pet is Immortal!!";
Essentials.medsTexts[itemStem + "bbbrustedshield"] = "If this hero has " + BalanceFunctions.SpriteText("rust") + ", " + BalanceFunctions.SpriteText("thorns") + " applies 50% of its charges as " + BalanceFunctions.SpriteText("poison") + " in addition to its normal effects.";
Essentials.medsTexts[itemStem + "bbbrustedshieldrare"] = BalanceFunctions.SpriteText("thorns") + " applies 75% of its charges as " + BalanceFunctions.SpriteText("poison") + " in addition to its normal effects.";
harmony.PatchAll();
}
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));
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "com.binbin.UnofficialBalancePatch";
public const string PLUGIN_NAME = "UnofficialBalancePatch";
public const string PLUGIN_VERSION = "1.5.8";
}
}
