自动转向炮台(武器)的实现

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接: https://blog.csdn.net/wangjiangrong/article/details/98075122

前言

在一些射击类的游戏中,经常会有一些类似炮台的武器,可以上下左右旋转,对目标进行瞄准。又或者是人物身上的枪支,在准心转动的时候,保持着武器朝向准心的方向。本篇简单的进行了效果的实现,如下图:

首先需要了解下有关pitch,yaw,roll的含义

pitch是围绕X轴旋转,也叫做俯仰角(武器上下转动),如图:

yaw是围绕Y轴旋转,也叫偏航角(武器左右转动),如图:

roll是围绕Z轴旋转,也叫翻滚角,如图:

根据需求,我们一般只需要实现武器的pitch和yaw旋转即可,来达到瞄准指定位置的效果。

思路

首先类似于炮台,一般炮身和炮管会分开转动,比如炮身只可左右转动(yaw),炮管上下转动(pitch)。我们需要两个Transform来分别控制旋转,其中炮管要作为炮身子控件。但是枪支那种一般就不会分成两个控件,所以我们把两个Transform同时指向同一控件即可。同时再用一个Transform指向瞄准物,同时我们可以设置一些最大旋转角度限制。

需求1,武器一直瞄准瞄准物,但是当瞄准物在武器身后的时候不进行瞄准处理:可以计算武器到瞄准物和武器正前方直接的夹角,若夹角<90度,即做瞄准操作,否则则不处理。

需求2,yaw旋转:即根据Y轴旋转,eulerAngles.y进行变动,物体呈左右转动之势。因为是左右旋转,所以我们可以忽略武器和瞄准物的Y轴高度差距,使两者在同一高度的情况下(可以使用Vector3.ProjectOnPlane,将武器到瞄准物的向量映射到武器的xz平面上),计算武器forward的向量和武器到瞄准物的向量之间的夹角,若夹角为0则已瞄准,否则则改动eulerAngles.y的值,使Transform.forward变动,从而让夹角为0。(我们可以利用向量的叉乘Vector3.Cross,来判断两个向量之间的左右关系

需求3,picth旋转:基本和yaw旋转同理,只是改变的是eulerAngles.x的值。

实现

直接上代码,绑定在武器的父节点GameObject上,绑定好对应关联即可

using UnityEngine;

public class AutoRotationGun : MonoBehaviour
{
    //最大旋转角度限制
    public int MaxPitchAngle = 60;
    public int MaxYawAngle = 60;

    //旋转速度
    public int Speed = 20;
    
    //pitch转动的物体
    public Transform PitchTransform;
    //yaw转动的物体
    public Transform YawTransform;
    //瞄准物
    public Transform TargetTransform;

    Vector3 mPitchTarget, mYawTarget;
    float mCurrentPitchAngle, mCurrentYawAngle;

    //精度
    float mPrecision = 0.5f;

    Transform mTransform;

    float mPitchAngleOffset, mYawAngleOffset, mAimAngleOffset;
    Vector3 mPitchCross, mYawCross;

    void Start()
    {
        mTransform = transform;
    }

    void Update()
    {
        if (TargetTransform != null && IsCanAim())
        {
            //旋转不使用PitchTransform.Rotate(x,y,z),防止z轴的变化
            if (PitchTransform == YawTransform)
            {
                PitchTransform.localEulerAngles = new Vector3(PitchRotation(), YawRotation(), 0);
            }
            else
            {
                PitchTransform.localEulerAngles = new Vector3(PitchRotation(), 0, 0);
                YawTransform.localEulerAngles = new Vector3(0, YawRotation(), 0);
            }
        }
#if UNITY_EDITOR
        Debug.DrawRay(PitchTransform.position, PitchTransform.forward * 100, Color.red);
#endif
    }

    bool IsCanAim()
    {
        //武器到瞄准物的向量与武器的正前面的夹角在90度以内才可瞄准
        if (PitchTransform != null && YawTransform != null)
        {
            //mAimAngleOffset = Mathf.Acos(Vector3.Dot(transform.forward, (TargetTransform.position - PitchTransform.position).normalized)) * Mathf.Rad2Deg;
            mAimAngleOffset = Vector3.Angle(mTransform.forward, TargetTransform.position - PitchTransform.position);
            if (mAimAngleOffset < 90)
            {
                return true;
            }
        }
        return false;
    }

    float PitchRotation()
    {
        //当前旋转角度
        mCurrentPitchAngle = PitchTransform.localEulerAngles.x;
        if (mCurrentPitchAngle > 180)
        {
            mCurrentPitchAngle = -(360 - mCurrentPitchAngle);
        }
        
        //武器到瞄准物的向量,映射到武器的yz屏幕上的法向量
        mPitchTarget = Vector3.ProjectOnPlane(TargetTransform.position - PitchTransform.position, PitchTransform.right).normalized;
        
        //计算当前瞄准方向与预期方向的夹角。大于精度则需要pitch转动来调整
        mPitchAngleOffset = Vector3.Angle(PitchTransform.forward, mPitchTarget);

        if (mPitchAngleOffset > mPrecision)
        {
            //计算两个向量的叉乘,用于判断向量的左右关系
            mPitchCross = Vector3.Cross(mPitchTarget, PitchTransform.forward).normalized;
            if (mCurrentPitchAngle > -MaxPitchAngle && mPitchCross == PitchTransform.right)
            {
                return mCurrentPitchAngle - Speed * Time.deltaTime;
            }
            else if (mCurrentPitchAngle < MaxPitchAngle && mPitchCross != PitchTransform.right)
            {
                return mCurrentPitchAngle + Speed * Time.deltaTime;
            }
        }
        return mCurrentPitchAngle;
    }

    float YawRotation()
    {
        mCurrentYawAngle = YawTransform.localEulerAngles.y;
        if (mCurrentYawAngle > 180)
        {
            mCurrentYawAngle = -(360 - mCurrentYawAngle);
        }

        mYawTarget = Vector3.ProjectOnPlane(TargetTransform.position - YawTransform.position, YawTransform.up).normalized;
        mYawAngleOffset = Vector3.Angle(YawTransform.forward, mYawTarget);

        if (mYawAngleOffset > mPrecision)
        {
            mYawCross = Vector3.Cross(mYawTarget, YawTransform.forward).normalized;
            if (mCurrentYawAngle > -MaxYawAngle && mYawCross == YawTransform.up)
            {
                return mCurrentYawAngle - Speed * Time.deltaTime;
            }
            else if (mCurrentYawAngle < MaxYawAngle && mYawCross != YawTransform.up)
            {
                return mCurrentYawAngle + Speed * Time.deltaTime;
            }
        }
        return mCurrentYawAngle;
    }
}

 

猜你喜欢

转载自blog.csdn.net/wangjiangrong/article/details/98075122