using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using AALUND13Cards.Armors.Armors;
using AALUND13Cards.Armors.Armors.Processors;
using AALUND13Cards.Armors.Cards;
using AALUND13Cards.Armors.Utils;
using AALUND13Cards.Core;
using AALUND13Cards.Core.Cards;
using AALUND13Cards.Core.Cards.Conditions;
using AALUND13Cards.Core.Extensions;
using AALUND13Cards.Core.Utils;
using BepInEx;
using HarmonyLib;
using JARL.Armor;
using JARL.Armor.Bases;
using JARL.Armor.Builtin;
using JARL.Armor.Processors;
using JARL.Armor.Utlis;
using JARL.Extensions;
using Microsoft.CodeAnalysis;
using TabInfo.Utils;
using UnboundLib;
using UnityEngine;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[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 AALUND13Cards.Armors
{
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("AALUND13.Cards.Armors", "AALUND13 Armors Cards", "1.0.0")]
[BepInProcess("Rounds.exe")]
internal class AAC_Armors : BaseUnityPlugin
{
internal const string ModId = "AALUND13.Cards.Armors";
internal const string ModName = "AALUND13 Armors Cards";
internal const string Version = "1.0.0";
private static AssetBundle assets;
private void Awake()
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
assets = AssetsUtils.LoadAssetBundle("aac_armors_assets", typeof(AAC_Armors).Assembly);
if ((Object)(object)assets != (Object)null)
{
new Harmony("AALUND13.Cards.Armors").PatchAll();
}
}
private void Start()
{
if ((Object)(object)assets == (Object)null)
{
Unbound.BuildModal("AALUND13 Cards Error", "The mod \"AALUND13 Armors Cards\" assets failled to load, All the cards will be disable in this mod");
throw new NullReferenceException("Failled to load \"AALUND13 Armors Cards\" assets");
}
ArmorTypeGetterUtils.RegiterArmorType<TitaniumArmor>("Titanium");
ArmorTypeGetterUtils.RegiterArmorType<BattleforgedArmor>("Battleforged");
ArmorFramework.RegisterArmorProcessor<DamageAgainstArmorPercentageProcessor>();
ArmorFramework.RegisterArmorProcessor<ArmorDamageReductionProcessor>();
CardResgester cardResgester = assets.LoadAsset<GameObject>("ArmorsModCards").GetComponent<CardResgester>();
cardResgester.RegisterCards();
AACMenu.OnMenuRegister = (Action)Delegate.Combine(AACMenu.OnMenuRegister, (Action)delegate
{
AACMenu.CreateModuleMenuWithReadmeGenerator("AALUND13 Armors Cards", "1.0.0", cardResgester);
});
if (AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "com.willuwontu.rounds.tabinfo"))
{
TabinfoInterface.Setup();
}
}
}
internal class TabinfoInterface
{
public static void Setup()
{
StatCategory orCreateCategory = TabinfoInterface.GetOrCreateCategory("AA Stats", 6);
TabInfoManager.RegisterStat(orCreateCategory, "Damage Against Armor Percentage", (Func<Player, bool>)((Player p) => GetArmorStatsFromPlayer(p).DamageAgainstArmorPercentage != 1f), (Func<Player, string>)((Player p) => $"{GetArmorStatsFromPlayer(p).DamageAgainstArmorPercentage * 100f:0}%"));
TabInfoManager.RegisterStat(orCreateCategory, "Armor Damage Reduction", (Func<Player, bool>)((Player p) => GetArmorStatsFromPlayer(p).ArmorDamageReduction != 0f), (Func<Player, string>)((Player p) => $"{GetArmorStatsFromPlayer(p).ArmorDamageReduction * 100f:0}%"));
}
private static ArmorStats GetArmorStatsFromPlayer(Player player)
{
return CharacterDataExtensions.GetCustomStatsRegistry(player.data).GetOrCreate<ArmorStats>();
}
}
}
namespace AALUND13Cards.Armors.Utils
{
public class ArmorTypeGetterUtils
{
private static Dictionary<string, Type> registerArmorType = new Dictionary<string, Type>();
public static ReadOnlyDictionary<string, Type> RegisterArmorType => new ReadOnlyDictionary<string, Type>(RegisterArmorType);
public static void RegiterArmorType<T>(string armorId) where T : ArmorBase, new()
{
if (registerArmorType.ContainsKey(armorId))
{
throw new ArgumentException("Armor with the type '" + armorId + "' already register");
}
ArmorFramework.RegisterArmorType<T>();
registerArmorType.Add(armorId, typeof(T));
}
public static Type GetArmorType(string armorId)
{
return registerArmorType[armorId];
}
}
}
namespace AALUND13Cards.Armors.CardsEffects
{
public class RestorationMono : MonoBehaviour
{
public float MnRegenCooldown;
private bool isActive;
private float regenAmount;
private CharacterData data;
private ArmorHandler armorHandler;
private void Start()
{
data = ((Component)this).GetComponentInParent<CharacterData>();
armorHandler = ((Component)this).GetComponentInParent<ArmorHandler>();
}
private void Update()
{
if (!isActive && data.health >= data.maxHealth)
{
regenAmount = data.healthHandler.regeneration;
AddRegenerationAmountToAllArmors(regenAmount);
isActive = true;
}
else if (isActive && data.health >= data.maxHealth && regenAmount != data.healthHandler.regeneration)
{
AddRegenerationAmountToAllArmors(0f - regenAmount);
regenAmount = data.healthHandler.regeneration;
AddRegenerationAmountToAllArmors(regenAmount);
}
else if (isActive && data.health < data.maxHealth)
{
AddRegenerationAmountToAllArmors(0f - regenAmount);
isActive = false;
}
}
private void AddRegenerationAmountToAllArmors(float regenerationAmount)
{
foreach (ArmorBase activeArmor in armorHandler.ActiveArmors)
{
if (!activeArmor.HasArmorTag("NoRestorationRegen"))
{
if (activeArmor.ArmorRegenCooldownSeconds < MnRegenCooldown)
{
activeArmor.ArmorRegenCooldownSeconds = MnRegenCooldown;
}
activeArmor.ArmorRegenerationRate += regenerationAmount;
}
}
}
}
}
namespace AALUND13Cards.Armors.MonoBehaviours.CardsEffects
{
public class HealthToArmorConversion : MonoBehaviour
{
public float HealthToArmorConversions = 0.5f;
private Dictionary<ArmorBase, float> armorAdded = new Dictionary<ArmorBase, float>();
private CharacterData characterData;
private ArmorHandler armorHandler;
private float oldHealth;
private int oldArmorCount;
private void Start()
{
characterData = ((Component)this).GetComponentInParent<CharacterData>();
armorHandler = ((Component)this).GetComponentInParent<ArmorHandler>();
CharacterData obj = characterData;
obj.maxHealth *= HealthToArmorConversions;
CharacterData obj2 = characterData;
obj2.health *= HealthToArmorConversions;
oldHealth = characterData.maxHealth;
oldArmorCount = Mathf.Max(armorHandler.ActiveArmors.Count, 1);
UpdateArmorStats();
}
private void Update()
{
if (characterData.maxHealth != oldHealth || armorHandler.ActiveArmors.Count != oldArmorCount)
{
oldHealth = characterData.maxHealth;
oldArmorCount = Mathf.Max(armorHandler.ActiveArmors.Count, 1);
UpdateArmorStats();
}
}
private void OnDestroy()
{
foreach (KeyValuePair<ArmorBase, float> item in armorAdded)
{
ArmorBase key = item.Key;
key.MaxArmorValue -= item.Value;
ArmorBase key2 = item.Key;
key2.CurrentArmorValue -= item.Value;
}
}
private void UpdateArmorStats()
{
Dictionary<ArmorBase, float> dictionary = new Dictionary<ArmorBase, float>(armorAdded);
foreach (KeyValuePair<ArmorBase, float> item in armorAdded)
{
ArmorBase key = item.Key;
key.MaxArmorValue -= item.Value;
}
armorAdded.Clear();
if (armorHandler.ActiveArmors.Count == 0)
{
float num = characterData.maxHealth * HealthToArmorConversions * 2f;
ArmorBase armorByType = armorHandler.GetArmorByType<DefaultArmor>();
float num2 = num;
if (dictionary.ContainsKey(armorByType))
{
num2 = num - dictionary[armorByType];
}
armorByType.MaxArmorValue += num;
armorByType.CurrentArmorValue += num2;
armorAdded[armorByType] = num;
}
else
{
float num3 = characterData.maxHealth * HealthToArmorConversions * 2f / (float)armorHandler.ActiveArmors.Count;
foreach (ArmorBase activeArmor in armorHandler.ActiveArmors)
{
float num4 = num3;
if (dictionary.ContainsKey(activeArmor))
{
num4 = num3 - dictionary[activeArmor];
}
activeArmor.MaxArmorValue += num3;
activeArmor.CurrentArmorValue += num4;
armorAdded[activeArmor] = num3;
}
}
LoggerUtils.LogInfo($"Added armors to player with a id of {characterData.player.playerID}", false);
}
}
}
namespace AALUND13Cards.Armors.Cards
{
public class ArmorStats : ICustomStats
{
public float DamageAgainstArmorPercentage = 1f;
public float ArmorDamageReduction;
public void ResetStats()
{
DamageAgainstArmorPercentage = 1f;
ArmorDamageReduction = 0f;
}
}
}
namespace AALUND13Cards.Armors.Cards.StatModifers
{
public class ArmorStatModifers : CustomStatModifers
{
[Header("Armors Stats")]
public float ArmorDamageReduction;
[Space(10f)]
public string ArmorTypeId = "";
public float ArmorHealth;
public float ArmorHealthMultiplier = 1f;
public float ArmorRegenRate;
public float ArmorRegenCooldown;
public bool RemoveArmorPirceTag;
[Space(10f)]
public bool OverrideArmorDamagePatchType;
public bool PatchDoDamage;
public bool PatchTakeDamage;
public bool PatchTakeDamageOverTime;
[Space(10f)]
public ArmorReactivateType ArmorReactivateType;
public float ArmorReactivateValue;
[Header("Armor Pierce Stats")]
public float ArmorPiercePercent;
public float DamageAgainstArmorPercentage = 1f;
public override void Apply(Player player)
{
//IL_0118: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_0179: Unknown result type (might be due to invalid IL or missing references)
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_018f: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
ArmorStats orCreate = CharacterDataExtensions.GetCustomStatsRegistry(player.data).GetOrCreate<ArmorStats>();
JARLCharacterDataAdditionalData additionalData = CharacterDataExtensions.GetAdditionalData(player.data);
orCreate.ArmorDamageReduction = Mathf.Min(orCreate.ArmorDamageReduction + ArmorDamageReduction, 0.8f);
if (!Utility.IsNullOrWhiteSpace(ArmorTypeId))
{
ArmorBase val = ArmorFramework.ArmorHandlers[player].Armors.First((ArmorBase x) => ((object)x).GetType() == ArmorTypeGetterUtils.GetArmorType(ArmorTypeId));
if (val != null)
{
val.MaxArmorValue += ArmorHealth;
if (AAC_Core.Plugins.Exists((BaseUnityPlugin plugin) => plugin.Info.Metadata.GUID == "Systems.R00t.AdditiveStats"))
{
val.MaxArmorValue += 100f * (ArmorHealthMultiplier - 1f);
}
else
{
val.MaxArmorValue *= ArmorHealthMultiplier;
}
val.ArmorRegenerationRate += ArmorRegenRate;
val.ArmorRegenCooldownSeconds += ArmorRegenCooldown;
if (ArmorReactivateValue > 0f)
{
val.reactivateArmorType = ArmorReactivateType;
val.reactivateArmorValue = ArmorReactivateValue;
}
if (RemoveArmorPirceTag && val.HasArmorTag("CanArmorPierce"))
{
val.ArmorTags.Remove("CanArmorPierce");
}
if (OverrideArmorDamagePatchType)
{
val.ArmorDamagePatch = (ArmorDamagePatchType)0;
if (PatchDoDamage)
{
val.ArmorDamagePatch = (ArmorDamagePatchType)(val.ArmorDamagePatch | 1);
}
if (PatchTakeDamage)
{
val.ArmorDamagePatch = (ArmorDamagePatchType)(val.ArmorDamagePatch | 2);
}
if (PatchTakeDamageOverTime)
{
val.ArmorDamagePatch = (ArmorDamagePatchType)(val.ArmorDamagePatch | 4);
}
}
}
}
additionalData.ArmorPiercePercent = Mathf.Clamp(additionalData.ArmorPiercePercent + ArmorPiercePercent, 0f, 1f);
orCreate.DamageAgainstArmorPercentage += DamageAgainstArmorPercentage - 1f;
}
}
}
namespace AALUND13Cards.Armors.Cards.Conditions
{
public class PlayerHaveArmorCondition : CardCondition
{
public List<string> BlacklistedArmorTag = new List<string>();
public override bool IsPlayerAllowedCard(Player player)
{
return ArmorFramework.ArmorHandlers[player].ActiveArmors.Any((ArmorBase armor) => !BlacklistedArmorTag.Any((string tag) => armor.ArmorTags.Contains(tag)));
}
}
}
namespace AALUND13Cards.Armors.Armors
{
public class BattleforgedArmor : ArmorBase
{
public override BarColor GetBarColor()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
return new BarColor(Color.yellow * 0.6f, Color.yellow * 0.45f);
}
public override DamageArmorInfo OnDamage(float damage, Player DamagingPlayer, ArmorDamagePatchType? armorDamagePatchType)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
DamageArmorInfo val = ArmorUtils.ApplyDamage(base.CurrentArmorValue, damage);
float num = base.CurrentArmorValue - val.Armor;
base.MaxArmorValue += num * 0.1f;
return val;
}
public BattleforgedArmor()
{
base.ArmorTags.Add("CanArmorPierce");
base.ArmorRegenCooldownSeconds = 5f;
}
}
public class TitaniumArmor : ArmorBase
{
public int SegmentsCount = 4;
public float RegenThresholdPercent = 1.5f;
private float segmentThresholdHealth;
private Image segmentThresholdBar;
public TitaniumArmor()
{
base.ArmorTags.Add("CanArmorPierce");
base.ArmorRegenCooldownSeconds = 5f;
}
public override BarColor GetBarColor()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
return new BarColor(Color.magenta * 0.6f, Color.magenta * 0.45f);
}
public override void OnUpdate()
{
TryCreateArmorMinBar();
float num = base.MaxArmorValue / (float)SegmentsCount;
while (base.CurrentArmorValue >= segmentThresholdHealth + num * RegenThresholdPercent)
{
segmentThresholdHealth += num;
}
if ((Object)(object)segmentThresholdBar != (Object)null)
{
segmentThresholdBar.fillAmount = segmentThresholdHealth / base.MaxArmorValue;
}
}
public override void OnRespawn()
{
segmentThresholdHealth = base.MaxArmorValue - base.MaxArmorValue / (float)SegmentsCount;
}
public override DamageArmorInfo OnDamage(float damage, Player DamagingPlayer, ArmorDamagePatchType? armorDamagePatchType)
{
//IL_0004: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
DamageArmorInfo val = ((ArmorBase)this).OnDamage(damage, DamagingPlayer, armorDamagePatchType);
if (Mathf.Max(val.Armor, segmentThresholdHealth) <= segmentThresholdHealth + 0.1f && segmentThresholdHealth > 0f)
{
((DamageArmorInfo)(ref val))..ctor(0f, segmentThresholdHealth);
segmentThresholdHealth = Mathf.Max(segmentThresholdHealth - base.MaxArmorValue / (float)SegmentsCount, 0f);
}
return val;
}
private void TryCreateArmorMinBar()
{
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)segmentThresholdBar != (Object)null)
{
return;
}
Dictionary<ArmorBase, GameObject> dictionary = (Dictionary<ArmorBase, GameObject>)ExtensionMethods.GetFieldValue((object)((ArmorBase)this).ArmorHandler, "armorHealthBars");
if (dictionary == null || !dictionary.ContainsKey((ArmorBase)(object)this))
{
return;
}
GameObject gameObject = ((Component)dictionary[(ArmorBase)(object)this].transform.Find("Healthbar(Clone)/Canvas/Image")).gameObject;
if ((Object)(object)gameObject.transform.Find("MinArmorBar") == (Object)null)
{
gameObject.AddComponent<Mask>();
GameObject obj = Object.Instantiate<GameObject>(((Component)gameObject.transform.Find("Health")).gameObject, gameObject.transform);
((Object)obj).name = "MinArmorBar";
obj.transform.SetAsLastSibling();
Image component = obj.GetComponent<Image>();
((Graphic)component).color = new Color(0.45f, 0f, 0.45f, 1f);
component.fillAmount = segmentThresholdHealth / base.MaxArmorValue;
segmentThresholdBar = component;
GameObject gameObject2 = ((Component)gameObject.transform.Find("Grid")).gameObject;
gameObject2.transform.SetAsLastSibling();
((HorizontalOrVerticalLayoutGroup)gameObject2.GetComponent<HorizontalLayoutGroup>()).spacing = -10f;
GameObject[] array = (GameObject[])(object)new GameObject[gameObject2.transform.childCount];
for (int i = 0; i < gameObject2.transform.childCount; i++)
{
array[i] = ((Component)gameObject2.transform.GetChild(i)).gameObject;
}
int num = 8 - SegmentsCount;
for (int j = 0; j < num; j++)
{
array[j].SetActive(false);
}
gameObject2.SetActive(true);
}
else
{
segmentThresholdBar = ((Component)gameObject.transform.Find("MinArmorBar")).GetComponent<Image>();
segmentThresholdBar.fillAmount = segmentThresholdHealth / base.MaxArmorValue;
}
}
}
}
namespace AALUND13Cards.Armors.Armors.Processors
{
public class ArmorDamageReductionProcessor : ArmorProcessor
{
public override float BeforeArmorProcess(float remaindingDamage, float originalDamage)
{
if (!((ArmorProcessor)this).Armor.HasArmorTag("NoDamageReduction"))
{
if (CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).HurtPlayer.data).GetOrCreate<ArmorStats>().ArmorDamageReduction == 0f)
{
return remaindingDamage;
}
return remaindingDamage * (1f - CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).HurtPlayer.data).GetOrCreate<ArmorStats>().ArmorDamageReduction);
}
return remaindingDamage;
}
}
internal class DamageAgainstArmorPercentageProcessor : ArmorProcessor
{
public override float AfterArmorProcess(float remaindingDamage, float originalDamage, float takenArmorDamage)
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
if (((ArmorProcessor)this).Armor.HasArmorTag("CanArmorPierce"))
{
if ((Object)(object)((ArmorProcessor)this).DamagingPlayer == (Object)null || CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).DamagingPlayer.data).GetOrCreate<ArmorStats>().DamageAgainstArmorPercentage == 1f || takenArmorDamage <= 0f)
{
return remaindingDamage;
}
DamageArmorInfo val = ((ArmorProcessor)this).Armor.OnDamage(takenArmorDamage * (CharacterDataExtensions.GetCustomStatsRegistry(((ArmorProcessor)this).DamagingPlayer.data).GetOrCreate<ArmorStats>().DamageAgainstArmorPercentage - 1f), ((ArmorProcessor)this).DamagingPlayer, (ArmorDamagePatchType?)((ArmorProcessor)this).ArmorDamagePatchType);
((ArmorProcessor)this).Armor.CurrentArmorValue = val.Armor;
}
return remaindingDamage;
}
}
}
