*renameHEADmaster

1 files changed, 166 insertions, 0 deletions

diff --git a/Thronefall_v1.0/Decompile/AimbotProjectile.cs b/Thronefall_v1.0/Decompile/AimbotProjectile.cs
new file mode 100644
index 0000000..546deeb
--- /dev/null
+++ b/Thronefall_v1.0/Decompile/AimbotProjectile.cs
@@ -0,0 +1,166 @@
+using UnityEngine;
+using UnityEngine.Events;
+
+public class AimbotProjectile : MonoBehaviour
+{
+	private Weapon weapon;
+
+	public bool shakeCameraOnDestroy;
+
+	private Transform targetTransform;
+
+	private Hp targetHp;
+
+	private TaggedObject targetTaggedObject;
+
+	private Vector3 rememberTarget;
+
+	private Vector3 myLinearPosition;
+
+	private Vector3 spawnPosition;
+
+	private Vector3 previousPosition;
+
+	private float finalDamageMultiplyer = 1f;
+
+	private float remainingRange;
+
+	private TaggedObject firedBy;
+
+	private bool firedByPlayer;
+
+	private bool targetIsFlying;
+
+	[HideInInspector]
+	public UnityEvent onHit = new UnityEvent();
+
+	public Weapon Weapon
+	{
+		get
+		{
+			return weapon;
+		}
+		set
+		{
+			weapon = value;
+		}
+	}
+
+	public void Fire(Weapon _weapon, Hp _target, float _chaseRange, Vector3 _backupTarget, TaggedObject _firedBy, float _finalDamageMultiplyer = 1f)
+	{
+		firedBy = _firedBy;
+		if ((bool)firedBy)
+		{
+			firedByPlayer = _firedBy.Tags.Contains(TagManager.ETag.Player);
+		}
+		weapon = _weapon;
+		if ((bool)_target)
+		{
+			targetTransform = _target.transform;
+			targetHp = _target;
+			targetTaggedObject = _target.GetComponent<TaggedObject>();
+			if (targetTaggedObject.Tags.Contains(TagManager.ETag.Flying))
+			{
+				targetIsFlying = true;
+			}
+		}
+		else
+		{
+			rememberTarget = _backupTarget;
+		}
+		myLinearPosition = base.transform.position;
+		spawnPosition = base.transform.position;
+		previousPosition = base.transform.position;
+		remainingRange = _chaseRange;
+		finalDamageMultiplyer = _finalDamageMultiplyer;
+		Update();
+	}
+
+	private void Update()
+	{
+		if ((bool)targetTransform)
+		{
+			if (targetTaggedObject.colliderForBigOjectsToMeasureDistance != null)
+			{
+				rememberTarget = targetTaggedObject.colliderForBigOjectsToMeasureDistance.ClosestPoint(spawnPosition);
+			}
+			else
+			{
+				rememberTarget = targetTransform.position + targetHp.hitFeedbackHeight * Vector3.up;
+			}
+		}
+		Vector3 vector = rememberTarget - myLinearPosition;
+		float num = weapon.projectileSpeed * Time.deltaTime;
+		if (num >= vector.magnitude)
+		{
+			Vector3 position = base.transform.position;
+			base.transform.position = rememberTarget;
+			if (targetTaggedObject != null && targetHp != null && targetTransform != null)
+			{
+				weapon.DealDamage(targetHp, finalDamageMultiplyer, firedBy);
+			}
+			else if (weapon.performRaycastWhenHittingEmptyPosition)
+			{
+				float raycastLength = weapon.raycastLength;
+				Vector3 normalized = (base.transform.position - position).normalized;
+				Physics.Raycast(base.transform.position - normalized * raycastLength, normalized, out var hitInfo, raycastLength, weapon.emptyPositionRaycastLayerMask);
+				if ((bool)hitInfo.collider)
+				{
+					Hp componentInParent = hitInfo.collider.GetComponentInParent<Hp>();
+					if ((bool)componentInParent)
+					{
+						weapon.DealDamage(componentInParent, finalDamageMultiplyer, firedBy);
+					}
+				}
+			}
+			if (!targetIsFlying && (bool)weapon.spawnOnGroundWhenTargetingGround)
+			{
+				if (targetTransform != null)
+				{
+					Object.Instantiate(weapon.spawnOnGroundWhenTargetingGround, targetTransform.position, Quaternion.identity);
+				}
+				else
+				{
+					Object.Instantiate(weapon.spawnOnGroundWhenTargetingGround, base.transform.position, Quaternion.identity);
+				}
+			}
+			onHit.Invoke();
+			Object.Destroy(base.gameObject);
+		}
+		else
+		{
+			myLinearPosition += vector.normalized * num;
+		}
+		float magnitude = (rememberTarget - spawnPosition).magnitude;
+		float num4;
+		if (magnitude > 0.001f)
+		{
+			float num2 = (myLinearPosition - spawnPosition).magnitude / magnitude;
+			float num3 = Mathf.Max(0f, (magnitude + weapon.projectileParabulaOffset) * weapon.projectileParabulaFactor);
+			num4 = (0f - Mathf.Pow(2f * num2 - 1f, 2f) + 1f) * num3;
+		}
+		else
+		{
+			num4 = 0f;
+		}
+		base.transform.position = myLinearPosition + Vector3.up * num4;
+		if (weapon.projectileFacingDirection == Weapon.EFacingDirection.FaceVictim && base.transform.position != previousPosition)
+		{
+			base.transform.rotation = Quaternion.LookRotation(base.transform.position - previousPosition, Vector3.up);
+		}
+		previousPosition = base.transform.position;
+		remainingRange -= num;
+		if (remainingRange <= 0f)
+		{
+			targetTransform = null;
+		}
+	}
+
+	private void OnDestroy()
+	{
+		if (shakeCameraOnDestroy && (bool)CameraController.instance)
+		{
+			CameraController.instance.ShakePunch();
+		}
+	}
+}