400 lines
9.6 KiB
C#
400 lines
9.6 KiB
C#
using Invector;
|
|
using Invector.vCharacterController;
|
|
using Lean.Pool;
|
|
using UnityEngine;
|
|
using UnityEngine.Events;
|
|
|
|
namespace DemonBoss.Magic
|
|
{
|
|
/// <summary>
|
|
/// Enhanced meteor projectile with fireball-like tracking mechanics
|
|
/// Can either track player or fly to a locked impact point
|
|
/// </summary>
|
|
public class MeteorProjectile : MonoBehaviour
|
|
{
|
|
#region Inspector: Targeting
|
|
|
|
[Header("Targeting")]
|
|
[Tooltip("If true, use 'overrideImpactPoint' instead of tracking player")]
|
|
public bool useOverrideImpactPoint = false;
|
|
|
|
[Tooltip("Externally provided locked impact point")]
|
|
public Vector3 overrideImpactPoint;
|
|
|
|
[Tooltip("Tag to find and track if not using override point")]
|
|
public string targetTag = "Player";
|
|
|
|
[Tooltip("Height offset for targeting (aim at chest/head)")]
|
|
public float targetHeightOffset = 1.0f;
|
|
|
|
[Tooltip("If true, raycast to ground from impact point")]
|
|
public bool snapImpactToGround = true;
|
|
|
|
[Tooltip("Layers considered 'ground'")]
|
|
public LayerMask groundMask = ~0;
|
|
|
|
[ReadOnlyInInspector] public Vector3 currentTargetPoint;
|
|
|
|
#endregion Inspector: Targeting
|
|
|
|
#region Inspector: Flight
|
|
|
|
[Header("Flight")]
|
|
[Tooltip("Movement speed in m/s")]
|
|
public float speed = 25f;
|
|
|
|
[Tooltip("Time to track player before locking to position")]
|
|
public float trackingTime = 1.5f;
|
|
|
|
[Tooltip("Distance threshold to consider arrived")]
|
|
public float arriveEpsilon = 0.5f;
|
|
|
|
[Tooltip("Max lifetime in seconds")]
|
|
public float maxLifetime = 15f;
|
|
|
|
#endregion Inspector: Flight
|
|
|
|
#region Inspector: Collision & Damage
|
|
|
|
[Header("Collision & Damage")]
|
|
[Tooltip("Collision detection radius")]
|
|
public float collisionRadius = 0.8f;
|
|
|
|
[Tooltip("Layers that stop the meteor")]
|
|
public LayerMask stopOnLayers = ~0;
|
|
|
|
[Tooltip("Layers that take damage")]
|
|
public LayerMask damageLayers = ~0;
|
|
|
|
[Tooltip("Explosion damage radius")]
|
|
public float explosionRadius = 4f;
|
|
|
|
[Tooltip("Base damage")]
|
|
public int damage = 35;
|
|
|
|
[Tooltip("Knockback force")]
|
|
public float knockbackForce = 12f;
|
|
|
|
#endregion Inspector: Collision & Damage
|
|
|
|
#region Inspector: Effects
|
|
|
|
[Header("Effects & Events")]
|
|
public GameObject impactVfxPrefab;
|
|
|
|
public UnityEvent onSpawn;
|
|
public UnityEvent onImpact;
|
|
|
|
[Header("Debug")]
|
|
public bool enableDebug = false;
|
|
|
|
#endregion Inspector: Effects
|
|
|
|
#region Runtime
|
|
|
|
private Transform _player;
|
|
private Vector3 _lockedTarget;
|
|
private bool _isLocked = false;
|
|
private bool _hasImpacted = false;
|
|
private float _lifetime = 0f;
|
|
private readonly Collider[] _overlapCache = new Collider[32];
|
|
|
|
#endregion Runtime
|
|
|
|
#region Unity
|
|
|
|
private void OnEnable()
|
|
{
|
|
ResetState();
|
|
InitializeTargeting();
|
|
onSpawn?.Invoke();
|
|
|
|
if (enableDebug) Debug.Log($"[MeteorProjectile] Spawned at {transform.position}");
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (_hasImpacted) return;
|
|
|
|
_lifetime += Time.deltaTime;
|
|
|
|
// Check lifetime limit
|
|
if (_lifetime >= maxLifetime)
|
|
{
|
|
if (enableDebug) Debug.Log("[MeteorProjectile] Lifetime expired");
|
|
DoImpact(transform.position);
|
|
return;
|
|
}
|
|
|
|
// Handle tracking to lock transition
|
|
if (!_isLocked && _lifetime >= trackingTime)
|
|
{
|
|
LockTarget();
|
|
}
|
|
|
|
// Update target position and move
|
|
UpdateTargetPosition();
|
|
MoveTowardsTarget();
|
|
CheckCollisions();
|
|
}
|
|
|
|
#endregion Unity
|
|
|
|
#region Targeting & Movement
|
|
|
|
private void ResetState()
|
|
{
|
|
_hasImpacted = false;
|
|
_isLocked = false;
|
|
_lifetime = 0f;
|
|
_lockedTarget = Vector3.zero;
|
|
}
|
|
|
|
private void InitializeTargeting()
|
|
{
|
|
if (useOverrideImpactPoint)
|
|
{
|
|
_lockedTarget = snapImpactToGround ? SnapToGround(overrideImpactPoint) : overrideImpactPoint;
|
|
_isLocked = true;
|
|
currentTargetPoint = _lockedTarget;
|
|
|
|
if (enableDebug) Debug.Log($"[MeteorProjectile] Using override target: {_lockedTarget}");
|
|
}
|
|
else
|
|
{
|
|
// Find player for tracking
|
|
var playerGO = GameObject.FindGameObjectWithTag(targetTag);
|
|
_player = playerGO ? playerGO.transform : null;
|
|
|
|
if (enableDebug)
|
|
{
|
|
if (_player) Debug.Log($"[MeteorProjectile] Found player: {_player.name}");
|
|
else Debug.LogWarning($"[MeteorProjectile] No player found with tag: {targetTag}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LockTarget()
|
|
{
|
|
if (_isLocked) return;
|
|
|
|
if (_player != null)
|
|
{
|
|
Vector3 targetPos = _player.position + Vector3.up * targetHeightOffset;
|
|
_lockedTarget = snapImpactToGround ? SnapToGround(targetPos) : targetPos;
|
|
}
|
|
else
|
|
{
|
|
// Fallback: lock to current forward direction
|
|
_lockedTarget = transform.position + transform.forward * 50f;
|
|
}
|
|
|
|
_isLocked = true;
|
|
|
|
if (enableDebug) Debug.Log($"[MeteorProjectile] Target locked to: {_lockedTarget}");
|
|
}
|
|
|
|
private void UpdateTargetPosition()
|
|
{
|
|
if (_isLocked)
|
|
{
|
|
currentTargetPoint = _lockedTarget;
|
|
}
|
|
else if (_player != null)
|
|
{
|
|
currentTargetPoint = _player.position + Vector3.up * targetHeightOffset;
|
|
}
|
|
else
|
|
{
|
|
// No player, keep going forward
|
|
currentTargetPoint = transform.position + transform.forward * 100f;
|
|
}
|
|
}
|
|
|
|
private void MoveTowardsTarget()
|
|
{
|
|
Vector3 direction = (currentTargetPoint - transform.position).normalized;
|
|
Vector3 movement = direction * speed * Time.deltaTime;
|
|
|
|
transform.position += movement;
|
|
|
|
// Face movement direction
|
|
if (movement.sqrMagnitude > 0.0001f)
|
|
{
|
|
transform.rotation = Quaternion.LookRotation(movement.normalized);
|
|
}
|
|
|
|
// Check if we've arrived (only when locked)
|
|
if (_isLocked && Vector3.Distance(transform.position, currentTargetPoint) <= arriveEpsilon)
|
|
{
|
|
if (enableDebug) Debug.Log("[MeteorProjectile] Arrived at target");
|
|
DoImpact(transform.position);
|
|
}
|
|
}
|
|
|
|
private void CheckCollisions()
|
|
{
|
|
// Use OverlapSphere for collision detection
|
|
int hitCount = Physics.OverlapSphereNonAlloc(transform.position, collisionRadius, _overlapCache, stopOnLayers, QueryTriggerInteraction.Ignore);
|
|
|
|
if (hitCount > 0)
|
|
{
|
|
if (enableDebug) Debug.Log($"[MeteorProjectile] Collision detected with {_overlapCache[0].name}");
|
|
DoImpact(transform.position);
|
|
}
|
|
}
|
|
|
|
#endregion Targeting & Movement
|
|
|
|
#region Impact & Damage
|
|
|
|
private void DoImpact(Vector3 impactPos)
|
|
{
|
|
if (_hasImpacted) return;
|
|
_hasImpacted = true;
|
|
|
|
if (enableDebug) Debug.Log($"[MeteorProjectile] Impact at {impactPos}");
|
|
|
|
// Spawn VFX
|
|
if (impactVfxPrefab != null)
|
|
{
|
|
var vfx = LeanPool.Spawn(impactVfxPrefab, impactPos, Quaternion.identity);
|
|
// Auto-despawn VFX after 5 seconds
|
|
LeanPool.Despawn(vfx, 5f);
|
|
}
|
|
|
|
onImpact?.Invoke();
|
|
|
|
// Deal area damage
|
|
int damageTargets = Physics.OverlapSphereNonAlloc(impactPos, explosionRadius, _overlapCache, damageLayers, QueryTriggerInteraction.Ignore);
|
|
|
|
for (int i = 0; i < damageTargets; i++)
|
|
{
|
|
var col = _overlapCache[i];
|
|
if (col != null)
|
|
{
|
|
DealDamageToTarget(col, impactPos);
|
|
}
|
|
}
|
|
|
|
// Despawn meteor
|
|
LeanPool.Despawn(gameObject);
|
|
}
|
|
|
|
private void DealDamageToTarget(Collider targetCollider, Vector3 hitPoint)
|
|
{
|
|
Vector3 hitDirection = (targetCollider.bounds.center - hitPoint).normalized;
|
|
if (hitDirection.sqrMagnitude < 0.0001f) hitDirection = Vector3.up;
|
|
|
|
vDamage damageInfo = new vDamage(damage)
|
|
{
|
|
sender = transform,
|
|
hitPosition = hitPoint
|
|
};
|
|
|
|
if (knockbackForce > 0f)
|
|
damageInfo.force = hitDirection * knockbackForce;
|
|
|
|
bool damageDealt = false;
|
|
|
|
// Try vIDamageReceiver first
|
|
var receiver = targetCollider.GetComponent<vIDamageReceiver>() ??
|
|
targetCollider.GetComponentInParent<vIDamageReceiver>();
|
|
if (receiver != null && !damageDealt)
|
|
{
|
|
receiver.TakeDamage(damageInfo);
|
|
damageDealt = true;
|
|
}
|
|
|
|
// Fallback to vHealthController
|
|
if (!damageDealt)
|
|
{
|
|
var hc = targetCollider.GetComponent<vHealthController>() ??
|
|
targetCollider.GetComponentInParent<vHealthController>();
|
|
if (hc != null)
|
|
{
|
|
hc.TakeDamage(damageInfo);
|
|
damageDealt = true;
|
|
}
|
|
}
|
|
|
|
// Fallback to vThirdPersonController
|
|
if (!damageDealt)
|
|
{
|
|
var tpc = targetCollider.GetComponent<vThirdPersonController>() ??
|
|
targetCollider.GetComponentInParent<vThirdPersonController>();
|
|
if (tpc != null)
|
|
{
|
|
// Handle Beyond variant
|
|
if (tpc is Beyond.bThirdPersonController beyond)
|
|
{
|
|
if (!beyond.GodMode && !beyond.isImmortal)
|
|
{
|
|
tpc.TakeDamage(damageInfo);
|
|
damageDealt = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tpc.TakeDamage(damageInfo);
|
|
damageDealt = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Apply physics force
|
|
var rb = targetCollider.attachedRigidbody;
|
|
if (rb != null && knockbackForce > 0f)
|
|
{
|
|
rb.AddForce(hitDirection * knockbackForce, ForceMode.Impulse);
|
|
}
|
|
|
|
if (enableDebug && damageDealt)
|
|
{
|
|
Debug.Log($"[MeteorProjectile] Dealt {damage} damage to {targetCollider.name}");
|
|
}
|
|
}
|
|
|
|
#endregion Impact & Damage
|
|
|
|
#region Helpers
|
|
|
|
private Vector3 SnapToGround(Vector3 point)
|
|
{
|
|
Vector3 rayStart = point + Vector3.up * 10f;
|
|
if (Physics.Raycast(rayStart, Vector3.down, out RaycastHit hit, 50f, groundMask, QueryTriggerInteraction.Ignore))
|
|
{
|
|
return hit.point;
|
|
}
|
|
return point;
|
|
}
|
|
|
|
#endregion Helpers
|
|
|
|
#if UNITY_EDITOR
|
|
|
|
private void OnDrawGizmosSelected()
|
|
{
|
|
// Draw collision sphere
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawWireSphere(transform.position, collisionRadius);
|
|
|
|
// Draw explosion radius
|
|
Gizmos.color = Color.red;
|
|
Gizmos.DrawWireSphere(transform.position, explosionRadius);
|
|
|
|
// Draw target point
|
|
if (currentTargetPoint != Vector3.zero)
|
|
{
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawWireSphere(currentTargetPoint, 0.5f);
|
|
Gizmos.DrawLine(transform.position, currentTargetPoint);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
public sealed class ReadOnlyInInspectorAttribute : PropertyAttribute
|
|
{ }
|
|
} |