*renameHEADmaster

1 files changed, 375 insertions, 0 deletions

diff --git a/Thronefall_v1.0/Decompile/Hp.cs b/Thronefall_v1.0/Decompile/Hp.cs
new file mode 100644
index 0000000..d28b16f
--- /dev/null
+++ b/Thronefall_v1.0/Decompile/Hp.cs
@@ -0,0 +1,375 @@
+using System.Collections.Generic;
+using Pathfinding;
+using Pathfinding.RVO;
+using UnityEngine;
+using UnityEngine.Events;
+
+[RequireComponent(typeof(TaggedObject))]
+public class Hp : MonoBehaviour
+{
+	public float maxHp;
+
+	public bool getsKnockedOutInsteadOfDying;
+
+	private float hp;
+
+	private TaggedObject taggedObject;
+
+	[Tooltip("The hight where enemies aim at and where hit indicators are spawned")]
+	public float hitFeedbackHeight;
+
+	[Tooltip("This child object is enabled when this unit is alive.")]
+	public GameObject aliveVisuals;
+
+	[Tooltip("This child object is enabled when this unit is knocked out.")]
+	public GameObject knockedOutVisuals;
+
+	public GameObject fxToSpawnOnDeath;
+
+	public Vector3 deathFxSpawnOffset;
+
+	public Transform deathFxSpawnWithPosAndRotOf;
+
+	[HideInInspector]
+	public UnityEvent OnHpChange = new UnityEvent();
+
+	[HideInInspector]
+	public UnityEvent OnRevive = new UnityEvent();
+
+	[HideInInspector]
+	public UnityEvent OnHeal = new UnityEvent();
+
+	[HideInInspector]
+	public UnityEvent<bool> OnReceiveDamage = new UnityEvent<bool>();
+
+	[HideInInspector]
+	public UnityEvent OnKillOrKnockout = new UnityEvent();
+
+	private AutoAttack[] autoAttacks;
+
+	private ManualAttack[] manualAttacks;
+
+	private PathfindMovement pathfindMovement;
+
+	private RVOController rvoController;
+
+	private PlayerMovement playerMovement;
+
+	private NavmeshCut[] navmeshCut;
+
+	private PlayerInteraction playerInteraction;
+
+	public GameObject coin;
+
+	public float coinSpawnOffset;
+
+	public int coinCount;
+
+	[SerializeField]
+	private Weapon spwanAttackOnDeath;
+
+	private float damageMultiplyer = 1f;
+
+	private float healingMultiplyer = 1f;
+
+	public bool invulnerable;
+
+	public float HpValue => hp;
+
+	public float HpPercentage => hp / maxHp;
+
+	public bool KnockedOut => hp <= 0f;
+
+	public TaggedObject TaggedObj => taggedObject;
+
+	public PathfindMovement PathfindMovement => pathfindMovement;
+
+	public Weapon SpwanAttackOnDeath
+	{
+		get
+		{
+			return spwanAttackOnDeath;
+		}
+		set
+		{
+			spwanAttackOnDeath = value;
+		}
+	}
+
+	public float DamageMultiplyer
+	{
+		get
+		{
+			return damageMultiplyer;
+		}
+		set
+		{
+			damageMultiplyer = value;
+		}
+	}
+
+	public void ScaleHp(float _multiply)
+	{
+		hp *= _multiply;
+		maxHp *= _multiply;
+	}
+
+	private void Start()
+	{
+		playerInteraction = GetComponent<PlayerInteraction>();
+		taggedObject = GetComponent<TaggedObject>();
+		autoAttacks = GetComponents<AutoAttack>();
+		manualAttacks = GetComponents<ManualAttack>();
+		pathfindMovement = GetComponent<PathfindMovement>();
+		rvoController = GetComponent<RVOController>();
+		playerMovement = GetComponent<PlayerMovement>();
+		navmeshCut = GetComponentsInChildren<NavmeshCut>();
+		taggedObject.AddTag(TagManager.ETag.AUTO_Alive);
+		Revive(callReviveEvent: false);
+		ActivateAndDeactivateChildrenAndCompements(_alive: true);
+		if (PerkManager.instance.HealingSpiritsActive && (bool)taggedObject && taggedObject.Tags.Contains(TagManager.ETag.PlayerOwned))
+		{
+			healingMultiplyer *= PerkManager.instance.healingSpirits_healMulti;
+		}
+	}
+
+	private void ActivateAndDeactivateChildrenAndCompements(bool _alive)
+	{
+		if ((bool)aliveVisuals)
+		{
+			aliveVisuals.SetActive(_alive);
+		}
+		if ((bool)knockedOutVisuals)
+		{
+			knockedOutVisuals.SetActive(!_alive);
+		}
+		if (autoAttacks.Length != 0)
+		{
+			AutoAttack[] array = autoAttacks;
+			for (int i = 0; i < array.Length; i++)
+			{
+				array[i].enabled = _alive;
+			}
+		}
+		if (manualAttacks.Length != 0)
+		{
+			ManualAttack[] array2 = manualAttacks;
+			for (int i = 0; i < array2.Length; i++)
+			{
+				array2[i].enabled = _alive;
+			}
+		}
+		if ((bool)pathfindMovement)
+		{
+			pathfindMovement.enabled = _alive;
+			if (!_alive)
+			{
+				pathfindMovement.ClearCurrentPath();
+			}
+		}
+		if ((bool)rvoController)
+		{
+			rvoController.enabled = _alive;
+		}
+		if ((bool)playerMovement)
+		{
+			playerMovement.enabled = _alive;
+		}
+		NavmeshCut[] array3 = navmeshCut;
+		for (int i = 0; i < array3.Length; i++)
+		{
+			array3[i].enabled = _alive;
+		}
+		if ((bool)playerInteraction)
+		{
+			playerInteraction.enabled = _alive;
+		}
+	}
+
+	public void Revive(bool callReviveEvent = true, float healthPercentage = 1f)
+	{
+		if (hp <= 0f)
+		{
+			if (callReviveEvent)
+			{
+				OnRevive.Invoke();
+			}
+			taggedObject.RemoveTag(TagManager.ETag.AUTO_KnockedOutAndHealOnDawn);
+			taggedObject.AddTag(TagManager.ETag.AUTO_Alive);
+			ActivateAndDeactivateChildrenAndCompements(_alive: true);
+			hp = 0f;
+		}
+		else if (hp < maxHp)
+		{
+			OnHeal.Invoke();
+		}
+		hp += maxHp * healthPercentage;
+		if (hp > maxHp)
+		{
+			hp = maxHp;
+		}
+		OnHpChange.Invoke();
+	}
+
+	public bool TakeDamage(float _amount, TaggedObject _damageComingFrom = null, bool causedByPlayer = false, bool invokeFeedbackEvents = true)
+	{
+		if (hp <= 0f)
+		{
+			return false;
+		}
+		if (invulnerable)
+		{
+			return false;
+		}
+		if (_amount <= 0f)
+		{
+			Heal(0f - _amount);
+			return false;
+		}
+		if ((bool)pathfindMovement)
+		{
+			pathfindMovement.GetAgroFromObject(_damageComingFrom);
+		}
+		hp -= _amount;
+		OnHpChange.Invoke();
+		if (invokeFeedbackEvents)
+		{
+			OnReceiveDamage.Invoke(causedByPlayer);
+		}
+		if (hp <= 0f)
+		{
+			OnKillOrKnockout.Invoke();
+			if ((bool)fxToSpawnOnDeath)
+			{
+				if ((bool)deathFxSpawnWithPosAndRotOf)
+				{
+					Object.Instantiate(fxToSpawnOnDeath, deathFxSpawnWithPosAndRotOf.position + deathFxSpawnOffset, deathFxSpawnWithPosAndRotOf.rotation, null);
+				}
+				else
+				{
+					Object.Instantiate(fxToSpawnOnDeath, base.transform.position + deathFxSpawnOffset, fxToSpawnOnDeath.transform.rotation, null);
+				}
+			}
+			if (getsKnockedOutInsteadOfDying)
+			{
+				taggedObject.RemoveTag(TagManager.ETag.AUTO_Alive);
+				taggedObject.AddTag(TagManager.ETag.AUTO_KnockedOutAndHealOnDawn);
+				ActivateAndDeactivateChildrenAndCompements(_alive: false);
+			}
+			else
+			{
+				Object.Destroy(base.gameObject);
+				if ((bool)coin)
+				{
+					for (int i = 0; i < coinCount; i++)
+					{
+						if (i > 1)
+						{
+							Object.Instantiate(coin, base.transform.position + Vector3.up * coinSpawnOffset + Quaternion.Euler(0f, 45f * (float)i, 0f) * Vector3.forward * 2f, Quaternion.identity);
+						}
+						else
+						{
+							Object.Instantiate(coin, base.transform.position + Vector3.up * coinSpawnOffset, Quaternion.identity);
+						}
+					}
+				}
+			}
+			if ((bool)spwanAttackOnDeath)
+			{
+				spwanAttackOnDeath.Attack(base.transform.position, null, Vector3.zero, taggedObject, damageMultiplyer);
+			}
+			return true;
+		}
+		return false;
+	}
+
+	public void Heal(float _amount)
+	{
+		if (!(hp <= 0f) && !(_amount <= 0f))
+		{
+			hp += _amount * healingMultiplyer;
+			if (hp > maxHp)
+			{
+				hp = maxHp;
+			}
+			OnHpChange.Invoke();
+		}
+	}
+
+	public static void ReviveAllUnitsWithTag(List<TagManager.ETag> _mustHaveTags, List<TagManager.ETag> _mayNotHaveTags, float _healthPercentage = 1f)
+	{
+		List<TaggedObject> list = new List<TaggedObject>();
+		TagManager.instance.FindAllTaggedObjectsWithTags(list, _mustHaveTags, _mayNotHaveTags);
+		for (int i = 0; i < list.Count; i++)
+		{
+			list[i].Hp.Revive(callReviveEvent: true, _healthPercentage);
+		}
+	}
+
+	public static void MarkDestroyedBuildingsAsDontRevive(List<TagManager.ETag> _mustHaveTags, List<TagManager.ETag> _mayNotHaveTags, float _healthPercentage = 1f)
+	{
+		List<TaggedObject> list = new List<TaggedObject>();
+		TagManager.instance.FindAllTaggedObjectsWithTags(list, _mustHaveTags, _mayNotHaveTags);
+		for (int i = 0; i < list.Count; i++)
+		{
+			if (list[i].Tags.Contains(TagManager.ETag.AUTO_KnockedOutAndHealOnDawn))
+			{
+				list[i].GetComponentInParent<BuildSlot>().Interactor.OnKnockOut();
+				if (!list[i].Tags.Contains(TagManager.ETag.AUTO_NoReviveNextMorning))
+				{
+					list[i].Tags.Add(TagManager.ETag.AUTO_NoReviveNextMorning);
+				}
+				else
+				{
+					list[i].Tags.Remove(TagManager.ETag.AUTO_NoReviveNextMorning);
+				}
+			}
+		}
+	}
+
+	public static void KillAllUnitsWithTag(List<TagManager.ETag> _mustHaveTags, List<TagManager.ETag> _mayNotHaveTags)
+	{
+		List<TaggedObject> list = new List<TaggedObject>();
+		TagManager.instance.FindAllTaggedObjectsWithTags(list, _mustHaveTags, _mayNotHaveTags);
+		for (int i = 0; i < list.Count; i++)
+		{
+			list[i].Hp.TakeDamage(float.MaxValue);
+		}
+	}
+
+	public static void ReviveAllKnockedOutPlayerUnitsAndBuildings()
+	{
+		if (!PerkManager.instance.DestructionGodActive)
+		{
+			List<TagManager.ETag> list = new List<TagManager.ETag>();
+			List<TagManager.ETag> list2 = new List<TagManager.ETag>();
+			list.Add(TagManager.ETag.PlayerOwned);
+			list2.Add(TagManager.ETag.AUTO_NoReviveNextMorning);
+			ReviveAllUnitsWithTag(list, list2);
+			return;
+		}
+		List<TagManager.ETag> list3 = new List<TagManager.ETag>();
+		List<TagManager.ETag> mayNotHaveTags = new List<TagManager.ETag>();
+		list3.Add(TagManager.ETag.PlayerOwned);
+		list3.Add(TagManager.ETag.Building);
+		MarkDestroyedBuildingsAsDontRevive(list3, mayNotHaveTags);
+		List<TagManager.ETag> list4 = new List<TagManager.ETag>();
+		mayNotHaveTags = new List<TagManager.ETag>();
+		list4.Add(TagManager.ETag.PlayerOwned);
+		mayNotHaveTags.Add(TagManager.ETag.Building);
+		mayNotHaveTags.Add(TagManager.ETag.AUTO_NoReviveNextMorning);
+		ReviveAllUnitsWithTag(list4, mayNotHaveTags);
+		mayNotHaveTags.Clear();
+		mayNotHaveTags.Add(TagManager.ETag.AUTO_NoReviveNextMorning);
+		list4.Add(TagManager.ETag.Building);
+		ReviveAllUnitsWithTag(list4, mayNotHaveTags, 0.33f);
+	}
+
+	public static void KillAllEnemyUnits()
+	{
+		List<TagManager.ETag> list = new List<TagManager.ETag>();
+		List<TagManager.ETag> mayNotHaveTags = new List<TagManager.ETag>();
+		list.Add(TagManager.ETag.EnemyOwned);
+		KillAllUnitsWithTag(list, mayNotHaveTags);
+	}
+}