139 lines
3.5 KiB
C#
139 lines
3.5 KiB
C#
using UnityEngine;
|
|
|
|
public class AimTarget : MonoBehaviour
|
|
{
|
|
[SerializeField]
|
|
private Transform defaultAimTarget;
|
|
|
|
[SerializeField]
|
|
private Transform pullAimTarget;
|
|
|
|
[SerializeField]
|
|
private Transform pullLeftTarget;
|
|
|
|
[SerializeField]
|
|
private Transform pullRightTarget;
|
|
|
|
[SerializeField]
|
|
private Transform root;
|
|
|
|
[SerializeField]
|
|
private Transform debugAimTarget;
|
|
|
|
public float minX = -30f;
|
|
|
|
public float maxX = 30f;
|
|
|
|
public float minY = -45f;
|
|
|
|
public float maxY = 45f;
|
|
|
|
public float minZ = -10f;
|
|
|
|
public float maxZ = 10f;
|
|
|
|
public float radius = 1f;
|
|
|
|
public int step = 2;
|
|
|
|
public float pullDecay = 5f;
|
|
|
|
private bool _isPulled;
|
|
|
|
private Vector3 aimPosition;
|
|
|
|
private float _pullPower;
|
|
|
|
private float _pullDir;
|
|
|
|
public float aimTargetSlerpAmount = 10f;
|
|
|
|
public float pullPower => _pullPower;
|
|
|
|
public void Pull(float x, float dir = 0f)
|
|
{
|
|
_isPulled = true;
|
|
_pullPower = x;
|
|
_pullDir = dir;
|
|
aimPosition = pullAimTarget.position;
|
|
if (dir < 0f)
|
|
{
|
|
aimPosition = Vector3.Lerp(pullAimTarget.position, pullRightTarget.position, Mathf.Abs(dir) * 2f);
|
|
}
|
|
if (dir > 0f)
|
|
{
|
|
aimPosition = Vector3.Lerp(pullAimTarget.position, pullLeftTarget.position, dir * 2f);
|
|
}
|
|
}
|
|
|
|
public void LookAt(Transform target, Vector3 forward)
|
|
{
|
|
if (!_isPulled)
|
|
{
|
|
aimPosition = target.position;
|
|
}
|
|
}
|
|
|
|
public void SetPullDir(float dir)
|
|
{
|
|
}
|
|
|
|
public void ResetView()
|
|
{
|
|
aimPosition = Vector3.zero;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
Quaternion to = Quaternion.LookRotation((aimPosition - root.position).normalized, Vector3.up);
|
|
float num = (_isPulled ? (Time.deltaTime * aimTargetSlerpAmount * _pullPower) : (aimTargetSlerpAmount * Time.deltaTime));
|
|
root.rotation = Quaternion.RotateTowards(root.rotation, to, num * 60f);
|
|
RootRotationClamp();
|
|
debugAimTarget.transform.position = Vector3.Slerp(debugAimTarget.position, aimPosition, num);
|
|
if (!_isPulled)
|
|
{
|
|
aimPosition = defaultAimTarget.position;
|
|
}
|
|
_pullPower = 0f;
|
|
_isPulled = false;
|
|
}
|
|
|
|
private void RootRotationClamp()
|
|
{
|
|
Vector3 localEulerAngles = root.localEulerAngles;
|
|
localEulerAngles.x = UtilsFunctions.NormalizeAngle(localEulerAngles.x);
|
|
localEulerAngles.y = UtilsFunctions.NormalizeAngle(localEulerAngles.y);
|
|
localEulerAngles.z = UtilsFunctions.NormalizeAngle(localEulerAngles.z);
|
|
localEulerAngles.x = Mathf.Clamp(localEulerAngles.x, minX, maxX);
|
|
localEulerAngles.y = Mathf.Clamp(localEulerAngles.y, minY, maxY);
|
|
localEulerAngles.z = Mathf.Clamp(localEulerAngles.z, minZ, maxZ);
|
|
root.localEulerAngles = localEulerAngles;
|
|
}
|
|
|
|
private void OnDrawGizmos()
|
|
{
|
|
Vector3 position = base.transform.position;
|
|
Gizmos.color = Color.green;
|
|
for (float num = minX; num < maxX; num += (float)step)
|
|
{
|
|
Vector3 vector = Quaternion.Euler(num, 0f, 0f) * Vector3.forward;
|
|
Vector3 vector2 = Quaternion.Euler(num + (float)step, 0f, 0f) * Vector3.forward;
|
|
Gizmos.DrawLine(position + vector * radius, position + vector2 * radius);
|
|
}
|
|
Gizmos.color = Color.blue;
|
|
for (float num2 = minY; num2 < maxY; num2 += (float)step)
|
|
{
|
|
Vector3 vector3 = Quaternion.Euler(0f, num2, 0f) * Vector3.forward;
|
|
Vector3 vector4 = Quaternion.Euler(0f, num2 + (float)step, 0f) * Vector3.forward;
|
|
Gizmos.DrawLine(position + vector3 * radius * 0.9f, position + vector4 * radius * 0.9f);
|
|
}
|
|
Gizmos.color = Color.red;
|
|
for (float num3 = minZ; num3 < maxZ; num3 += (float)step)
|
|
{
|
|
Vector3 vector5 = Quaternion.Euler(0f, 0f, num3) * Vector3.up;
|
|
Vector3 vector6 = Quaternion.Euler(0f, 0f, num3 + (float)step) * Vector3.up;
|
|
Gizmos.DrawLine(position + vector5 * radius * 0.8f, position + vector6 * radius * 0.8f);
|
|
}
|
|
}
|
|
}
|