291 lines
12 KiB
C#
291 lines
12 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Numerics;
|
|
using System.Runtime.CompilerServices;
|
|
using Reset;
|
|
using Sirenix.OdinInspector;
|
|
using Unity.Cinemachine;
|
|
using UnityEngine;
|
|
using UnityEngine.InputSystem;
|
|
using UnityEngine.Serialization;
|
|
using UnityEngine.UIElements;
|
|
using Vector2 = UnityEngine.Vector2;
|
|
using Vector3 = UnityEngine.Vector3;
|
|
|
|
public class LockOnManager : MonoBehaviour{
|
|
public class ActiveLockOnTarget{
|
|
public GameObject gameObject;
|
|
public float targetWeight;
|
|
public float refVelocity;
|
|
public CinemachineTargetGroup.Target cinemachineTarget;
|
|
}
|
|
|
|
public static LockOnManager Instance;
|
|
|
|
// 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 ActiveLockOnTarget mainTarget;
|
|
|
|
public List<ActiveLockOnTarget> activeTargets = new List<ActiveLockOnTarget>();
|
|
|
|
[ReadOnly] public CinemachineTargetGroup.Target lockonTarget;
|
|
public CinemachineTargetGroup targetGroup;
|
|
|
|
public List<GameObject> acceptedTargets = new List<GameObject>();
|
|
|
|
// UI
|
|
[ShowInInspector] public UIDocument lockOnDocument;
|
|
private Label elementLabelName;
|
|
private VisualElement elementRoot;
|
|
|
|
private void Awake(){
|
|
// // Register as singleton
|
|
// if (Instance == null) {
|
|
// Instance = this;
|
|
// } else {
|
|
// this.enabled = false;
|
|
// return;
|
|
// }
|
|
|
|
// References from camera
|
|
targetGroup = GameManager.Camera.transform.Find("Target Group").GetComponent<CinemachineTargetGroup>();
|
|
lockOnDocument = GameManager.UI.transform.Find("Lock On").GetComponent<UIDocument>();
|
|
}
|
|
|
|
// Start is called once before the first execution of Update after the MonoBehaviour is created
|
|
void Start(){
|
|
// Quick check for things in lock-on target that aren't lock-onable
|
|
if (mainTarget != null && mainTarget.gameObject.GetComponent<ILockOnTarget>() == null) {
|
|
mainTarget.gameObject.AddComponent<GenericLockOnTarget>();
|
|
Debug.LogWarning($"The object <b>{mainTarget.gameObject.name}</b> has no ILockOnTarget interface. This isn't hyper critical, but adding one as a GenericLockOnTarget anyways.");
|
|
}
|
|
|
|
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) {
|
|
Debug.Log($"{thisObject.name}: {thisObject.GetComponent<ILockOnTarget>() != null}");
|
|
|
|
if (thisObject.GetComponent<ILockOnTarget>() != null) {
|
|
acceptedTargets.Add(thisObject);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void AttachCamera(GameObject target){
|
|
targetGroup = GameManager.Camera.transform.Find("Target Group").GetComponent<CinemachineTargetGroup>();
|
|
Debug.Log($"{GameManager.Camera}");
|
|
|
|
// Set the camera's target as the player
|
|
targetGroup.Targets.Add(new CinemachineTargetGroup.Target{Object = target.transform, Radius = 3.5f, Weight = 1f});
|
|
GameManager.Camera.transform.Find("Cinemachine").GetComponent<CinemachineCamera>().Target.TrackingTarget = target.transform;
|
|
GameManager.Camera.transform.Find("Cinemachine").GetComponent<CustomInputHandler>().PlayerInput =
|
|
GetComponent<PlayerInput>();
|
|
GameManager.Camera.transform.Find("Cinemachine").GetComponent<CustomInputHandler>().AddEvents();
|
|
}
|
|
|
|
void Update(){
|
|
if (mainTarget != null && mainTarget.gameObject.GetComponent<ILockOnTarget>() == null) {
|
|
mainTarget.gameObject.AddComponent<GenericLockOnTarget>();
|
|
Debug.LogWarning($"The object <b>{mainTarget.gameObject.name}</b> has no ILockOnTarget interface. This isn't hyper critical, but adding one as a GenericLockOnTarget anyways.");
|
|
}
|
|
|
|
// Iterate through targets, pushing their Target Group weight towards their goal weight, or removing them if they get too low.
|
|
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]));
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerator RemoveFromTargetAtFrameEnd(ActiveLockOnTarget target){
|
|
yield return new WaitForEndOfFrame();
|
|
|
|
activeTargets.Remove(target);
|
|
targetGroup.Targets.Remove(target.cinemachineTarget);
|
|
}
|
|
|
|
public void AddNewTarget(GameObject targetObject, float targetWeight, bool isMain = false){
|
|
// Check that the target doesn't already exist- if it does, just change it's weight/make it main
|
|
foreach (ActiveLockOnTarget target in activeTargets) {
|
|
if (target.gameObject == targetObject) {
|
|
target.targetWeight = targetWeight;
|
|
|
|
if (isMain) {
|
|
mainTarget = target;
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If it doesn't exist in the list of targets, add it
|
|
ActiveLockOnTarget newTarget = new ActiveLockOnTarget{
|
|
gameObject = targetObject,
|
|
targetWeight = mainTargetWeight,
|
|
cinemachineTarget = new CinemachineTargetGroup.Target{
|
|
Object = targetObject.transform,
|
|
Radius = 1f,
|
|
Weight = 0f
|
|
}
|
|
};
|
|
|
|
//Set as main
|
|
if (isMain) {
|
|
mainTarget = newTarget;
|
|
}
|
|
|
|
// Finalize
|
|
activeTargets.Add(newTarget);
|
|
targetGroup.Targets.Add(newTarget.cinemachineTarget);
|
|
}
|
|
|
|
public void QueueTargetRemoval(GameObject targetObject, bool deleteAfterRemoved = false){
|
|
// Ostensibly removes targest by setting their target weight to 0. Update loop finds targets with no weight and reduces their impact on the camera
|
|
// After it smooths their current weight to 0, it removes them
|
|
activeTargets.Find(target => target.gameObject == targetObject).targetWeight = 0f;
|
|
|
|
if (deleteAfterRemoved) {
|
|
StartCoroutine(DeleteGameObjectPostRemoval(targetObject));
|
|
}
|
|
|
|
// Remove as main target if it is
|
|
if (mainTarget == activeTargets.Find(target => target.gameObject == targetObject)) {
|
|
mainTarget = null;
|
|
}
|
|
}
|
|
|
|
IEnumerator DeleteGameObjectPostRemoval(GameObject targetObject){
|
|
ActiveLockOnTarget thisTarget = activeTargets.Find(target => target.gameObject == targetObject);
|
|
|
|
yield return new WaitForEndOfFrame();
|
|
|
|
while (activeTargets.Contains(thisTarget)) {
|
|
yield return null;
|
|
}
|
|
|
|
Destroy(thisTarget.gameObject);
|
|
}
|
|
|
|
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) {
|
|
// Find out if this target wants to be debugged on it's selection process
|
|
bool debugThisTarget = target.GetComponent<ILockOnTarget>().lockonDebug;
|
|
|
|
// Skip the current target if one exists
|
|
if (mainTarget != null && mainTarget.gameObject == target) {
|
|
if (debugThisTarget){Debug.Log($"Not selected by {name}: I'm already the main target");}
|
|
continue;
|
|
}
|
|
|
|
// Skip targets currently behind objects.
|
|
Physics.Raycast(cameraTransform.position,
|
|
cameraTransform.position.DirectionTo(target.transform.position + target.GetComponent<ILockOnTarget>().lockonRaycastVerticalOffset * Vector3.up), out RaycastHit hit);
|
|
|
|
if (hit.transform != target.transform) {
|
|
if (debugThisTarget){Debug.Log($"Not selected by {name}: Line of sight to me is blocked by {hit.collider.gameObject.name}");}
|
|
continue;
|
|
}
|
|
|
|
// Skips targets too far
|
|
if (Vector3.Distance(transform.position, target.transform.position) > lockOnRange) {
|
|
if (debugThisTarget){Debug.Log($"Not selected by {name}: I'm too far! My distance is {Vector3.Distance(transform.position, target.transform.position)}");}
|
|
continue;
|
|
}
|
|
|
|
// Skip targets outside lock on angle
|
|
float angleFromCameraForward = Vector3.Angle(cameraTransform.forward, cameraTransform.position.DirectionTo(target.transform.position));
|
|
if (angleFromCameraForward > lockOnMaxAngle) {
|
|
if (debugThisTarget){Debug.Log($"Not selected by {name}: I'm not forward enough in front of the camera");}
|
|
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;
|
|
}
|
|
|
|
// Remove the main target that currently exists, if there is one.
|
|
if (mainTarget != null) {
|
|
QueueTargetRemoval(mainTarget.gameObject);
|
|
}
|
|
|
|
// Begin tracking target, set as main
|
|
AddNewTarget(closestTarget.gameObject, mainTargetWeight, true);
|
|
}
|
|
|
|
// Used by outside sources such as input to cancel lock-on.
|
|
public void RemoveMainTarget(){
|
|
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);
|
|
}
|
|
}
|
|
}
|