377 lines
15 KiB
C#
377 lines
15 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using Invector.vCharacterController.AI.FSMBehaviour; // For vFSMBehaviourController
|
|
using Beyond; // For GameStateManager and Player (ensure Player.cs is in this namespace or adjust)
|
|
using System; // For Action
|
|
|
|
public class AutoTargetting : MonoBehaviour
|
|
{
|
|
[Header("Targeting Parameters")]
|
|
[Tooltip("Maximum distance AutoTargetting will consider an enemy for selection.")]
|
|
public float maxTargetingDistance = 20f;
|
|
[Tooltip("How often (in seconds) to re-evaluate for a new target during combat.")]
|
|
public float targetingInterval = 0.25f;
|
|
[Tooltip("Maximum angle (in degrees from player's forward) within which an enemy can be auto-targeted.")]
|
|
public float targetingAngleThreshold = 90f;
|
|
|
|
[Header("Rotation Parameters")]
|
|
[Tooltip("Speed at which the player rotates towards the current target when rotation is explicitly called.")]
|
|
public float playerRotationSpeed = 10f;
|
|
|
|
[Header("Visuals")]
|
|
[Tooltip("Name of the material color property to animate for Fresnel effect.")]
|
|
public string materialHighlightPropertyName = "_FresnelColor";
|
|
[Tooltip("HDR Color to use for Fresnel highlight when a target is selected (fade-in target).")]
|
|
[ColorUsage(true, true)]
|
|
public Color highlightColor = Color.white;
|
|
[Tooltip("HDR Color to use for Fresnel when a target is deselected (fade-out target).")]
|
|
[ColorUsage(true, true)]
|
|
public Color deselectHighlightColor = Color.black;
|
|
[Tooltip("Duration of the fade in/out animation for the highlight.")]
|
|
public float highlightFadeDuration = 0.3f;
|
|
[Tooltip("If true, will try to find a SkinnedMeshRenderer first, then MeshRenderer. If false, affects all renderers.")]
|
|
public bool preferSkinnedMeshRenderer = true;
|
|
|
|
public vFSMBehaviourController CurrentTarget { get; private set; }
|
|
public event Action<vFSMBehaviourController> OnTargetSelected;
|
|
public event Action<vFSMBehaviourController> OnTargetDeselected;
|
|
|
|
private GameStateManager _gameStateManager;
|
|
private Coroutine _targetingLoopCoroutine;
|
|
private Dictionary<Material, Color> _originalMaterialColors = new Dictionary<Material, Color>();
|
|
private Dictionary<Material, Coroutine> _materialToFadeCoroutineMap = new Dictionary<Material, Coroutine>();
|
|
private Transform _playerTransform;
|
|
|
|
void Start()
|
|
{
|
|
if (Player.Instance == null) // Player.Instance should be set by its own Awake
|
|
{
|
|
Debug.LogError("AutoTargetting: Player.Instance is not available at Start! Ensure Player script with static Instance exists and runs before AutoTargetting.");
|
|
enabled = false;
|
|
return;
|
|
}
|
|
_playerTransform = Player.Instance.transform;
|
|
|
|
_gameStateManager = GameStateManager.Instance;
|
|
if (_gameStateManager != null)
|
|
{
|
|
_gameStateManager.m_OnStateChanged.AddListener(HandleGameStateChanged);
|
|
HandleGameStateChanged(_gameStateManager.CurrentState); // Initialize based on current state
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("AutoTargetting: GameStateManager.Instance not found! Disabling script.");
|
|
enabled = false;
|
|
}
|
|
}
|
|
|
|
void OnDestroy()
|
|
{
|
|
if (_gameStateManager != null)
|
|
{
|
|
_gameStateManager.m_OnStateChanged.RemoveListener(HandleGameStateChanged);
|
|
}
|
|
StopAndClearAllFadeCoroutines();
|
|
if (_targetingLoopCoroutine != null)
|
|
{
|
|
StopCoroutine(_targetingLoopCoroutine);
|
|
_targetingLoopCoroutine = null;
|
|
}
|
|
}
|
|
|
|
private void StopAndClearAllFadeCoroutines()
|
|
{
|
|
foreach (var pair in _materialToFadeCoroutineMap)
|
|
{
|
|
if (pair.Value != null) StopCoroutine(pair.Value);
|
|
}
|
|
_materialToFadeCoroutineMap.Clear();
|
|
}
|
|
|
|
private void HandleGameStateChanged(GameStateManager.State newState)
|
|
{
|
|
if (newState == GameStateManager.State.COMBAT)
|
|
{
|
|
if (_targetingLoopCoroutine == null)
|
|
{
|
|
_targetingLoopCoroutine = StartCoroutine(TargetingLoop());
|
|
}
|
|
}
|
|
else // State is NORMAL or other non-combat
|
|
{
|
|
if (_targetingLoopCoroutine != null)
|
|
{
|
|
StopCoroutine(_targetingLoopCoroutine);
|
|
_targetingLoopCoroutine = null;
|
|
}
|
|
if (CurrentTarget != null) // If there was a target, deselect it
|
|
{
|
|
vFSMBehaviourController oldTarget = CurrentTarget;
|
|
SetNewTarget(null); // This will handle fade out and event
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator TargetingLoop()
|
|
{
|
|
while (true)
|
|
{
|
|
if (_playerTransform == null && Player.Instance != null) // Defensive: re-cache if player was respawned or similar
|
|
{
|
|
_playerTransform = Player.Instance.transform;
|
|
}
|
|
|
|
if (_playerTransform != null) // Only proceed if we have a valid player transform
|
|
{
|
|
UpdateTarget();
|
|
}
|
|
yield return new WaitForSeconds(targetingInterval);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if the given AI target is within the specified angle from the source transform's forward direction.
|
|
/// </summary>
|
|
public bool IsTargetInAngle(Transform sourceTransform, vFSMBehaviourController targetAI, float angleThreshold)
|
|
{
|
|
if (targetAI == null || sourceTransform == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Vector3 directionToTarget = (targetAI.transform.position - sourceTransform.position);
|
|
directionToTarget.y = 0; // Consider only horizontal angle
|
|
|
|
// If target is effectively at the same horizontal position, consider it in angle.
|
|
if (directionToTarget.sqrMagnitude < 0.0001f) return true;
|
|
|
|
directionToTarget.Normalize();
|
|
float angle = Vector3.Angle(sourceTransform.forward, directionToTarget);
|
|
return angle <= angleThreshold;
|
|
}
|
|
|
|
private void UpdateTarget()
|
|
{
|
|
if (_playerTransform == null || _gameStateManager == null) return;
|
|
|
|
vFSMBehaviourController bestCandidate = null;
|
|
float minDistanceSqr = maxTargetingDistance * maxTargetingDistance;
|
|
|
|
HashSet<vFSMBehaviourController> combatControllers = _gameStateManager.GetActiveCombatcontrollers();
|
|
|
|
if (combatControllers == null || combatControllers.Count == 0)
|
|
{
|
|
if (CurrentTarget != null) SetNewTarget(null); // No enemies, clear current
|
|
return;
|
|
}
|
|
|
|
foreach (var controller in combatControllers)
|
|
{
|
|
if (controller == null || !controller.gameObject.activeInHierarchy || controller.aiController.currentHealth <= 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Check 1: Is target within selection angle?
|
|
if (!IsTargetInAngle(_playerTransform, controller, targetingAngleThreshold))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Check 2: Is target within selection distance?
|
|
float distSqr = (controller.transform.position - _playerTransform.position).sqrMagnitude;
|
|
if (distSqr <= minDistanceSqr) // distSqr must also be <= maxTargetingDistance^2 due to minDistanceSqr initialization
|
|
{
|
|
// If multiple targets are at similar very close distances, this might pick the "last one" processed.
|
|
// For more refined "closest", ensure this is strictly '<' for new candidates,
|
|
// or add a secondary sort criterion if multiple are at exact same minDistanceSqr.
|
|
// Current logic is fine for most cases.
|
|
minDistanceSqr = distSqr;
|
|
bestCandidate = controller;
|
|
}
|
|
}
|
|
|
|
if (CurrentTarget != bestCandidate)
|
|
{
|
|
SetNewTarget(bestCandidate);
|
|
}
|
|
else if (CurrentTarget != null && !IsTargetValid(CurrentTarget)) // Current target became invalid (e.g. died, moved out of range/angle)
|
|
{
|
|
SetNewTarget(null);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if a given target is still valid according to AutoTargetting's rules.
|
|
/// </summary>
|
|
private bool IsTargetValid(vFSMBehaviourController target)
|
|
{
|
|
if (target == null || !target.gameObject.activeInHierarchy || target.aiController.currentHealth <= 0)
|
|
return false;
|
|
|
|
if (_playerTransform == null) return false; // Should not happen if script is active
|
|
|
|
// Check 1: Angle (using AutoTargetting's own targetingAngleThreshold)
|
|
if (!IsTargetInAngle(_playerTransform, target, targetingAngleThreshold))
|
|
return false;
|
|
|
|
// Check 2: Distance (using AutoTargetting's own maxTargetingDistance)
|
|
float distSqr = (target.transform.position - _playerTransform.position).sqrMagnitude;
|
|
return distSqr <= maxTargetingDistance * maxTargetingDistance;
|
|
}
|
|
|
|
private void SetNewTarget(vFSMBehaviourController newTarget)
|
|
{
|
|
if (CurrentTarget == newTarget) return;
|
|
|
|
// Deselect previous target
|
|
if (CurrentTarget != null)
|
|
{
|
|
ApplyHighlight(CurrentTarget, false); // Fade out
|
|
OnTargetDeselected?.Invoke(CurrentTarget);
|
|
}
|
|
|
|
CurrentTarget = newTarget;
|
|
|
|
// Select new target
|
|
if (CurrentTarget != null)
|
|
{
|
|
ApplyHighlight(CurrentTarget, true); // Fade in
|
|
OnTargetSelected?.Invoke(CurrentTarget);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Smoothly rotates the player character towards the CurrentTarget on the horizontal plane.
|
|
/// </summary>
|
|
public void ExecuteRotationTowardsCurrentTarget(float deltaTime)
|
|
{
|
|
if (CurrentTarget == null || _playerTransform == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Vector3 directionToTarget = CurrentTarget.transform.position - _playerTransform.position;
|
|
directionToTarget.y = 0f;
|
|
|
|
if (directionToTarget.sqrMagnitude < 0.0001f) return; // Already at target or too close to get a direction
|
|
|
|
directionToTarget.Normalize();
|
|
Quaternion targetRotation = Quaternion.LookRotation(directionToTarget);
|
|
_playerTransform.rotation = Quaternion.Lerp(_playerTransform.rotation, targetRotation, deltaTime * playerRotationSpeed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the health of the CurrentTarget.
|
|
/// </summary>
|
|
/// <returns>The health of the CurrentTarget, or -1f if no target or target has no health component.</returns>
|
|
public float GetCurrentTargetHealth()
|
|
{
|
|
if (CurrentTarget != null && CurrentTarget.aiController != null)
|
|
{
|
|
return CurrentTarget.aiController.currentHealth;
|
|
}
|
|
return -1f;
|
|
}
|
|
|
|
public void ClearTarget(bool findNewOneImmediately)
|
|
{
|
|
SetNewTarget(null);
|
|
if (findNewOneImmediately && _gameStateManager != null && _gameStateManager.CurrentState == GameStateManager.State.COMBAT)
|
|
{
|
|
UpdateTarget(); // Attempt to find a new one if in combat
|
|
}
|
|
}
|
|
|
|
private Renderer[] GetTargetRenderers(vFSMBehaviourController targetController)
|
|
{
|
|
if (targetController == null) return new Renderer[0];
|
|
|
|
if (preferSkinnedMeshRenderer)
|
|
{
|
|
SkinnedMeshRenderer smr = targetController.GetComponentInChildren<SkinnedMeshRenderer>();
|
|
if (smr != null) return new Renderer[] { smr };
|
|
|
|
MeshRenderer mr = targetController.GetComponentInChildren<MeshRenderer>();
|
|
if (mr != null) return new Renderer[] { mr };
|
|
}
|
|
|
|
return targetController.GetComponentsInChildren<Renderer>(true); // Include inactive renderers if any
|
|
}
|
|
|
|
private void ApplyHighlight(vFSMBehaviourController targetController, bool fadeIn)
|
|
{
|
|
if (targetController == null || string.IsNullOrEmpty(materialHighlightPropertyName)) return;
|
|
|
|
Renderer[] renderers = GetTargetRenderers(targetController);
|
|
|
|
foreach (Renderer rend in renderers)
|
|
{
|
|
if (rend == null) continue;
|
|
|
|
// Use rend.materials to get instances for modification
|
|
foreach (Material mat in rend.materials)
|
|
{
|
|
if (mat == null || !mat.HasProperty(materialHighlightPropertyName)) continue;
|
|
|
|
// Stop any existing fade coroutine for this specific material
|
|
if (_materialToFadeCoroutineMap.TryGetValue(mat, out Coroutine existingCoroutine) && existingCoroutine != null)
|
|
{
|
|
StopCoroutine(existingCoroutine);
|
|
}
|
|
|
|
Color currentColor = mat.GetColor(materialHighlightPropertyName);
|
|
Color targetColor = fadeIn ? highlightColor : deselectHighlightColor;
|
|
|
|
// Smartly store original color only if not already a highlight/deselect color.
|
|
if (fadeIn)
|
|
{
|
|
if (!_originalMaterialColors.ContainsKey(mat) ||
|
|
(_originalMaterialColors[mat] != currentColor && currentColor != deselectHighlightColor && currentColor != highlightColor) )
|
|
{
|
|
_originalMaterialColors[mat] = currentColor;
|
|
}
|
|
}
|
|
// When fading out, if an original was stored, we could potentially use it instead of always deselectHighlightColor.
|
|
// However, for a consistent "off" state, deselectHighlightColor (e.g., black) is usually desired.
|
|
// If fading out and original exists and isn't black:
|
|
// else if (_originalMaterialColors.TryGetValue(mat, out Color original) && original != deselectHighlightColor)
|
|
// {
|
|
// targetColor = original; // Fade back to true original
|
|
// }
|
|
|
|
|
|
Coroutine newFadeCoroutine = StartCoroutine(FadeMaterialPropertyCoroutine(mat, currentColor, targetColor, highlightFadeDuration));
|
|
_materialToFadeCoroutineMap[mat] = newFadeCoroutine;
|
|
}
|
|
}
|
|
}
|
|
|
|
private IEnumerator FadeMaterialPropertyCoroutine(Material material, Color fromValue, Color toValue, float duration)
|
|
{
|
|
float timer = 0f;
|
|
// yield return null; // Not strictly necessary here as StopCoroutine handles overlaps.
|
|
|
|
while (timer < duration)
|
|
{
|
|
if (material == null) yield break; // Material might have been destroyed
|
|
|
|
timer += Time.deltaTime;
|
|
float progress = Mathf.Clamp01(timer / duration);
|
|
material.SetColor(materialHighlightPropertyName, Color.Lerp(fromValue, toValue, progress));
|
|
yield return null;
|
|
}
|
|
|
|
if (material != null) // Final set
|
|
{
|
|
material.SetColor(materialHighlightPropertyName, toValue);
|
|
}
|
|
|
|
// Optional: Remove from map if coroutine completed naturally and is still the one in the map.
|
|
// if (_materialToFadeCoroutineMap.TryGetValue(material, out Coroutine currentMappedCoroutine) && currentMappedCoroutine == /*this specific instance, tricky to get*/)
|
|
// {
|
|
// _materialToFadeCoroutineMap.Remove(material);
|
|
// }
|
|
}
|
|
} |