296 lines
11 KiB
C#
296 lines
11 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using Sirenix.OdinInspector;
|
|
using Unity.Cinemachine;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
using UnityEngine.UIElements;
|
|
using Vector2 = UnityEngine.Vector2;
|
|
using Vector3 = UnityEngine.Vector3;
|
|
|
|
public class LockOnManager : MonoBehaviour{
|
|
class ReferencedTarget{
|
|
public GameObject gameObject;
|
|
public float targetWeight;
|
|
public float refVelocity;
|
|
public CinemachineTargetGroup.Target cinemachineTarget;
|
|
}
|
|
|
|
private CinemachineTargetGroup.Target playerTarget;
|
|
|
|
// Lock On settings
|
|
[Space(5)] public float lockOnRange = 40f;
|
|
public float lockOnMaxAngle = 70f;
|
|
[Range(0,1)] public float mainTargetWeight = .15f;
|
|
[FormerlySerializedAs("smoothing")] public float smoothTime = 1f;
|
|
|
|
// Lock On Tracking
|
|
[Space(10)]
|
|
public GameObject lockonGameObject; // Needed because nulling the Target below doesn't actually empty it out
|
|
|
|
[ShowInInspector]
|
|
ReferencedTarget mainTarget;
|
|
|
|
[ShowInInspector]
|
|
List<ReferencedTarget> activeTargets = new List<ReferencedTarget>();
|
|
|
|
[ReadOnly] public CinemachineTargetGroup.Target lockonTarget;
|
|
public CinemachineTargetGroup targetGroup;
|
|
|
|
[FormerlySerializedAs("lockOnTargets")] [Space(5)]
|
|
public List<GameObject> acceptedTargets = new List<GameObject>();
|
|
|
|
// UI
|
|
[ShowInInspector] public UIDocument lockOnDocument;
|
|
private Label elementLabelName;
|
|
private VisualElement elementRoot;
|
|
|
|
// Start is called once before the first execution of Update after the MonoBehaviour is created
|
|
void Start(){
|
|
// Save the player target object to track later
|
|
playerTarget = targetGroup.Targets[0];
|
|
|
|
// Quick check for things in lock-on target that aren't lock-onable
|
|
if (lockonGameObject != null && lockonTarget.Object.GetComponent<ILockOnTarget>() == null) {
|
|
Debug.LogError($"Game Object {lockonTarget.Object.name} does not implement the ILockOnTarget interface!");
|
|
}
|
|
|
|
elementRoot = lockOnDocument.rootVisualElement.Query<VisualElement>("LockOnGroup");
|
|
elementLabelName = lockOnDocument.rootVisualElement.Query<Label>("LockOnName").First();
|
|
|
|
// Add all nearby game objects to lock-on eligible list
|
|
GameObject[] allGameObjects = GameObject.FindObjectsByType<GameObject>(0, 0);
|
|
|
|
foreach (GameObject thisObject in allGameObjects) {
|
|
if (Vector3.Distance(transform.position, thisObject.transform.position) < lockOnRange) {
|
|
if (thisObject.GetComponent<ILockOnTarget>() != null) {
|
|
acceptedTargets.Add(thisObject);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Update(){
|
|
if (mainTarget != null && mainTarget.gameObject.GetComponent<ILockOnTarget>() == null) {
|
|
Debug.LogError($"Game Object {lockonTarget.Object.name} does not implement the ILockOnTarget interface!");
|
|
}
|
|
|
|
// Find the current lock-on target and increase it's weight to the .15f max slowly
|
|
// They start at 0 weight when the lock-on adds them to the group
|
|
// if (mainTarget != null) {
|
|
// CinemachineTargetGroup.Target currentTarget = targetGroup.Targets.Find(target => target == lockonTarget);
|
|
// currentTarget.Weight = Mathf.MoveTowards(currentTarget.Weight, .15f, .5f * Time.deltaTime);
|
|
// }
|
|
|
|
for (int i = 0; i < activeTargets.Count; i++) {
|
|
if (activeTargets[i].gameObject == this.gameObject) {
|
|
continue;
|
|
}
|
|
|
|
activeTargets[i].cinemachineTarget.Weight =
|
|
Mathf.SmoothDamp(
|
|
activeTargets[i].cinemachineTarget.Weight,
|
|
activeTargets[i].targetWeight,
|
|
ref activeTargets[i].refVelocity,
|
|
smoothTime * Time.deltaTime);
|
|
|
|
if (activeTargets[i].cinemachineTarget.Weight < 0.0001f) {
|
|
StartCoroutine(RemoveFromTargetAtFrameEnd(activeTargets[i]));
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// If a target is not the current lock on target, lower their targeting weight. When low enough to not cause a sharp jitter, remove them.
|
|
// for (int i = 1; i < targetGroup.Targets.Count; i++) {
|
|
// if (targetGroup.Targets[i] == lockonTarget || targetGroup.Targets[i] == playerTarget || extraTargets.ContainsKey(targetGroup.Targets[i].Object.gameObject)){
|
|
// continue;
|
|
// }
|
|
//
|
|
// if (targetGroup.Targets[i].Weight < 0.001f) {
|
|
// StartCoroutine(RemoveFromTargetAtFrameEnd(targetGroup.Targets[i]));
|
|
// continue;
|
|
// }
|
|
//
|
|
// targetGroup.Targets[i].Weight = Mathf.SmoothDamp(targetGroup.Targets[i].Weight, 0f, 1f * Time.deltaTime);
|
|
// }
|
|
}
|
|
|
|
IEnumerator RemoveFromTargetAtFrameEnd(ReferencedTarget target){
|
|
yield return new WaitForEndOfFrame();
|
|
|
|
// if (target.targetWeight == 0) {
|
|
activeTargets.Remove(target);
|
|
targetGroup.Targets.Remove(target.cinemachineTarget);
|
|
// }
|
|
|
|
// activeTargets.Remove(target);
|
|
// targetGroup.Targets.Remove(target.cinemachineTarget);
|
|
}
|
|
|
|
public void AddNewTarget(GameObject targetObject, float targetWeight, bool isMain = false){
|
|
foreach (ReferencedTarget target in activeTargets) {
|
|
if (target.gameObject == targetObject) {
|
|
target.targetWeight = targetWeight;
|
|
|
|
if (isMain) {
|
|
mainTarget = target;
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
ReferencedTarget newTarget = new ReferencedTarget{
|
|
gameObject = targetObject,
|
|
targetWeight = mainTargetWeight,
|
|
cinemachineTarget = new CinemachineTargetGroup.Target{
|
|
Object = targetObject.transform,
|
|
Radius = 1f,
|
|
Weight = 0f
|
|
}
|
|
};
|
|
|
|
if (isMain) {
|
|
mainTarget = newTarget;
|
|
}
|
|
|
|
activeTargets.Add(newTarget);
|
|
targetGroup.Targets.Add(newTarget.cinemachineTarget);
|
|
}
|
|
|
|
public void QueueTargetRemoval(GameObject targetObject){
|
|
activeTargets.Find(target => target.gameObject == targetObject).targetWeight = 0f;
|
|
|
|
if (mainTarget == activeTargets.Find(target => target.gameObject == targetObject)) {
|
|
mainTarget = null;
|
|
}
|
|
|
|
Debug.Log(activeTargets.Find(target => target.gameObject == targetObject).targetWeight);
|
|
}
|
|
|
|
// public void AddToExtraTargets(GameObject target, float weight){
|
|
// if (extraTargets.ContainsKey(target)) {
|
|
// return;
|
|
// }
|
|
//
|
|
// extraTargets.Add(target, weight);
|
|
//
|
|
// targetGroup.Targets.Add(new CinemachineTargetGroup.Target(){ Object = target.transform, Weight = 0f });
|
|
// }
|
|
//
|
|
// public void RemoveFromExtraTargets(GameObject target){
|
|
// if (extraTargets.ContainsKey(target)) {
|
|
// extraTargets.Remove(target);
|
|
// }
|
|
// }
|
|
|
|
public void ChangeLockOnTarget(){
|
|
Transform cameraTransform = Camera.main.transform;
|
|
|
|
// If there is no target, simply find the closest to the center of the camera
|
|
GameObject closestTarget = null;
|
|
float lowestDistanceToCenter = Mathf.Infinity;
|
|
|
|
foreach (GameObject target in acceptedTargets) {
|
|
// Skip the current target if one exists
|
|
if (lockonGameObject != null && lockonTarget.Object.gameObject == target) {
|
|
continue;
|
|
}
|
|
|
|
// Skip targets currently behind objects.
|
|
Physics.Raycast(cameraTransform.position,
|
|
cameraTransform.position.DirectionTo(target.transform.position), out RaycastHit hit);
|
|
|
|
if (hit.transform != target.transform) {
|
|
continue;
|
|
}
|
|
|
|
// Skip targets outside lock on angle
|
|
float angleFromCameraForward = Vector3.Angle(cameraTransform.forward, cameraTransform.position.DirectionTo(target.transform.position));
|
|
if (angleFromCameraForward > lockOnMaxAngle) {
|
|
continue;
|
|
}
|
|
|
|
// Find how close this target is from the center of the screen
|
|
Vector3 targetScreenPoint = Camera.main.WorldToScreenPoint(target.transform.position);
|
|
float distanceFromScreenCenter = targetScreenPoint.Flatten(null, null, 0f).magnitude - new Vector3(Screen.width, Screen.height, 0f).magnitude / 2f;
|
|
distanceFromScreenCenter = Mathf.Abs(distanceFromScreenCenter);
|
|
|
|
// Debug.Log($"{target.name}: {distanceFromScreenCenter} pixels, {angleFromCameraForward} degrees");
|
|
|
|
// Set the new target to closest to screen
|
|
if (distanceFromScreenCenter < lowestDistanceToCenter) {
|
|
lowestDistanceToCenter = distanceFromScreenCenter;
|
|
closestTarget = target;
|
|
}
|
|
}
|
|
|
|
// Catch exception from nothing being found
|
|
if (!closestTarget) {
|
|
Debug.LogWarning("Lock-on attempted, but no lock on target was found viable.");
|
|
return;
|
|
}
|
|
|
|
// TODO: Recomment below
|
|
|
|
if (mainTarget != null) {
|
|
QueueTargetRemoval(mainTarget.gameObject);
|
|
// mainTarget = null;
|
|
}
|
|
|
|
// Create a new Target for the Target Group
|
|
var newCineTarget = new CinemachineTargetGroup.Target{
|
|
Object = closestTarget.transform,
|
|
Radius = 1f,
|
|
Weight = 0f
|
|
};
|
|
|
|
// Set the new target variables
|
|
lockonTarget = newCineTarget; // Old
|
|
|
|
ReferencedTarget thisTarget = new ReferencedTarget{
|
|
gameObject = closestTarget.gameObject,
|
|
targetWeight = mainTargetWeight,
|
|
cinemachineTarget = newCineTarget
|
|
};
|
|
|
|
AddNewTarget(closestTarget.gameObject, mainTargetWeight, true);
|
|
|
|
lockonGameObject = closestTarget.gameObject; // Old
|
|
// targetGroup.Targets.Add(newCineTarget); // Old
|
|
}
|
|
|
|
public void RemoveLockOnTarget(){
|
|
lockonTarget = null; // Old
|
|
lockonGameObject = null; // Old
|
|
|
|
QueueTargetRemoval(mainTarget.gameObject);
|
|
}
|
|
|
|
void LateUpdate(){
|
|
if (mainTarget != null) {
|
|
// This is just test logic to get an image above a lock on.
|
|
// TODO: Replace with something less silly
|
|
Vector2 screenPos = RuntimePanelUtils.CameraTransformWorldToPanel(
|
|
lockOnDocument.rootVisualElement.panel,
|
|
mainTarget.gameObject.GetComponent<ILockOnTarget>().GetReticlePosition(),
|
|
Camera.main
|
|
);
|
|
|
|
// Set name
|
|
elementLabelName.text = mainTarget.gameObject.name;
|
|
|
|
// Set position (add the width/height of the element)
|
|
elementRoot.style.top = new StyleLength(screenPos.y - 25f); // Was elementRoot.resolvedStyle.height * .7f
|
|
elementRoot.style.left = new StyleLength(screenPos.x - elementRoot.resolvedStyle.width / 2f);
|
|
|
|
// Set enabled
|
|
elementRoot.style.display = new StyleEnum<DisplayStyle>(DisplayStyle.Flex);
|
|
} else {
|
|
elementRoot.style.display = new StyleEnum<DisplayStyle>(DisplayStyle.None);
|
|
}
|
|
}
|
|
}
|