欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Unity 攻击范围检测

程序员文章站 2024-03-18 20:03:40
...

 众所周知moba中的每个英雄都有一套自己的技能的攻击范围方式,有如廉颇一样的圆形范围,有火舞一样的直线范围,吕布的扇形方天戟范围,还有上图的牛魔大招时的矩形范围等等。

    一些技能是通过物理的碰撞检测来判断的,一些则是通过这样的范围来检测的。物理检测的诟病就在于开销过大,在能考虑不用物理来检测的情况下更倾向来自己通过算法模拟实现。

Unity 攻击范围检测

小菜的学习研究中,将这些自己算法检测的攻击范围划分了几种类型,并做了几个demo的演示。

 

如上演示,小菜简单的讲这些类型划分成了如下几类:

1). Circle                        圆形

2). Triangle                    三角形

3). Fanshaped                扇形

4). Rectangle                 矩形

5). Sector                       扇面

6). Ring                          环形

 

[Circle 圆形]

Unity 攻击范围检测

这应该是最简单的类型,只要去判断self和target的distance就可以做到了。

我们希望能直观看到范围的情况,故使用Debug.DrawLine做了调试的绘制。

绘制编码:

Unity 攻击范围检测

小菜不想由于各个对象高度的不同带来的检测差异,故用NormalizePosition将位置的y信息都归置成了0。

 

范围检测编码:

Unity 攻击范围检测

 

[Triangle 三角形]

Unity 攻击范围检测

三角形范围的判定,实际就是点在三角形内的判定。

数学上检测点在三角形内有三种推论方法。内角和法/同向法/重心法。

对数学感兴趣的可以参考:https://www.cnblogs.com/graphics/archive/2010/08/05/1793393.html

小菜这里直接套用了重心法检测。

Unity 攻击范围检测

检测编码:

Unity 攻击范围检测

 

绘制编码:

Unity 攻击范围检测

 

[Fanshaped 扇形]

Unity 攻击范围检测

 

扇形的范围检测我们实际可以抽象成两个步骤。

1).判断self和target的distance.

2).由于点乘Unity 攻击范围检测,使用点乘dot来计算self到target的单位向量,与self的forward向量(本身也是单位向量)来计算得夹角cos值。使用Mathf.Acos将其转化为弧度,再转换成角度做一次判断就好了。

 

绘制编码:

Unity 攻击范围检测

 

范围检测编码:

Unity 攻击范围检测

 

[Rectangle 矩形]

Unity 攻击范围检测

矩形的检测小菜大概是有两种方法:

1).通过点在矩形内的数学推导公式来计算。

2).通过点乘和distance来计算。

 

还是先将矩形绘制出来吧。

绘制编码:

Unity 攻击范围检测

 

范围检测:

通过点在矩形内的数学推导公式来计算矩形范围

Unity 攻击范围检测

判断一个点是否在两条线段之间夹着就转化成,判断一个点是否在某条线段的一边上,就可以利用叉乘的方向性,来判断夹角是否超过了180度 。

只要判断(AB X AE ) * (CDX CE)  >= 0 就说明E在AB,CD中间夹着,同理计算另两边DA和BC就可以了。

最后就是只需要判断

(AB X AE ) * (CD X CE)  >= 0 && (DA X DE ) * (BC X BE) >= 0 。

 

范围检测编码:

Unity 攻击范围检测

Unity 攻击范围检测

 

通过点乘和distance来计算矩形范围

还是先上一张图辅助理解吧。

Unity 攻击范围检测

两次点乘的结果在于判断target的前后和左右关系。

Unity 攻击范围检测

编码看似比上面的少很多,实际关联的理解可一点都不简单Unity 攻击范围检测Unity 攻击范围检测Unity 攻击范围检测

 

[Sector 扇面]

Unity 攻击范围检测

扇面和扇形的检测很相似,不同的只是多了一层距离的检测。

 

绘制编码:

Unity 攻击范围检测

 

Unity 攻击范围检测

 

范围检测编码:

Unity 攻击范围检测

 

[Ring 环形]

Unity 攻击范围检测

环形和圆形的检测很相似,也只是多了一层距离的检测。

绘制编码:

Unity 攻击范围检测

 

范围检测编码:

Unity 攻击范围检测

附上完整代码:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public enum CheckType
{
    None,

    /// <summary> 圆形 </summary>
    Circle,

    /// <summary> 三角形 </summary>
    Triangle,

    /// <summary> 扇形 </summary>
    Fanshaped,

    /// <summary> 矩形 </summary>
    Rectangle,

    /// <summary> 扇面 </summary>
    Sector,

    /// <summary> 环形 </summary>
    Ring,
}

[ExecuteInEditMode]
public class RangeCheckScript : MonoBehaviour
{
    public CheckType currType = CheckType.None;
    public Transform mPalyer;
    public Transform mTarget;
    public bool mCheckOpen = true;

    void Update()
    {
        if (!mCheckOpen)
            return;
        if (null != mPalyer)
            Debug.DrawLine(mPalyer.position, mPalyer.position + mPalyer.forward * 8,Color.yellow);


        bool bResult = false;
        switch (currType)
        {
            case CheckType.None:
                break;
            case CheckType.Circle:
                bResult = CircleCheck(mPalyer, mTarget, 6);
                break;
            case CheckType.Triangle:
                bResult = TriangleCheck(mPalyer, mTarget, 1, 10);
                break;
            case CheckType.Fanshaped:
                bResult = FanshapedCheck(mPalyer, mTarget, 45, 5);
                break;
            case CheckType.Rectangle:
                //bResult = SimulateRectangleCheck(mPalyer, mTarget, 2, 8);
                bResult = RectangleCheck(mPalyer, mTarget, 2, 8);
                break;
            case CheckType.Sector:
                bResult = SectorCheck(mPalyer, mTarget, 45, 5, 8);
                break;
            case CheckType.Ring:
                bResult = RingCheck(mPalyer, mTarget, 4, 8);
                break;
            default:
                break;
        }

        if (bResult)
            Debug.LogError("检测到目标");
    }

    /// <summary>
    /// 圆形范围检测
    /// </summary>
    private bool CircleCheck(Transform self, Transform target, float distance)
    {
        if (null == self || null == target)
            return false;

        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);

        int nCircleDentity = 360;
        Vector3 beginPoint = selfPosition;
        Vector3 endPoint = Vector3.zero;
        float tempStep = 2 * Mathf.PI / nCircleDentity;
        bool bFirst = true;
        for (float step = 0; step < 2 * Mathf.PI; step += tempStep)
        {
            float x = distance * Mathf.Cos(step);
            float z = distance * Mathf.Sin(step);
            endPoint.x = selfPosition.x + x;
            endPoint.z = selfPosition.z + z;

            if (bFirst)
                bFirst = false;
            else
                Debug.DrawLine(beginPoint, endPoint, Color.red);
            
            beginPoint = endPoint;
        }

        //---------------------范围检测-----------------------------------

        float currDistance = Vector3.Distance(selfPosition, targetPosition);
        if (currDistance <= distance)
            return true;

        return false;
    }

    /// <summary>
    /// 三角形范围检测
    /// </summary>
    private bool TriangleCheck(Transform self, Transform target, float halfWidth,float distance)
    {
        if (null == self || null == target)
            return false;

        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);
        Quaternion tempQuat = self.rotation;

        //三角形的三个点
        Vector3 leftPoint = selfPosition + (tempQuat * Vector3.left) * halfWidth;
        Vector3 rightPoint = selfPosition + (tempQuat * Vector3.right) * halfWidth;
        Vector3 forwardPoint = selfPosition + (tempQuat * Vector3.forward) * distance;

        Debug.DrawLine(leftPoint,rightPoint,Color.red);
        Debug.DrawLine(rightPoint, forwardPoint, Color.red);
        Debug.DrawLine(forwardPoint, leftPoint, Color.red);

        //---------------------范围检测-----------------------------------

        bool bResult = IsPointInTriangle(leftPoint, forwardPoint, rightPoint, targetPosition);
        return bResult;
    }

    /// <summary>
    /// 扇形范围检测
    /// </summary>
    private bool FanshapedCheck(Transform self, Transform target, float halfAngle, float distance)
    {
        if (null == self || null == target)
            return false;

        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);
        Quaternion selfQuat = self.rotation;

        int nCircleDentity = 360;
        Vector3 firstPoint = Vector3.zero;
        Vector3 beginPoint = selfPosition;
        Vector3 endPoint = Vector3.zero;
        float tempStep = 2 * Mathf.PI / nCircleDentity;
        float leftRadian =  Mathf.PI / 2  + Mathf.Deg2Rad * halfAngle;
        float rightRadian = Mathf.PI / 2 - Mathf.Deg2Rad * halfAngle;
        bool bFirst = true;
        for (float step = 0; step < 2 * Mathf.PI; step += tempStep)
        {
            float x = distance * Mathf.Cos(step);
            float z = distance * Mathf.Sin(step);
            endPoint.x = selfPosition.x + x;
            endPoint.z = selfPosition.z + z;

            if (step >= rightRadian && step <= leftRadian)
            {
                if (bFirst)
                {
                    firstPoint = endPoint;
                    bFirst = false;
                }
                Debug.DrawLine(beginPoint, endPoint, Color.red);

                beginPoint = endPoint;
            }
        }
        Debug.DrawLine(selfPosition, firstPoint, Color.red);
        Debug.DrawLine(selfPosition, beginPoint, Color.red);

        //---------------------范围检测-----------------------------------

        //计算距离
        float currDis = Vector3.Distance(selfPosition, targetPosition);
        if (currDis > distance)
            return false;

        //计算self到target的向量
        Vector3 dir = targetPosition - selfPosition;

        //点乘dir向量和自身的forward向量 cosq
        float dotForward = Vector3.Dot(dir.normalized, (selfQuat * Vector3.forward).normalized);

        //得到夹角弧度并转换成角度
        float radian = Mathf.Acos(dotForward);
        float currAngle = Mathf.Rad2Deg * radian;

        if (Mathf.Abs(currAngle) <= halfAngle)
            return true;

        return false;
    }

    /// <summary>
    ///  矩形范围检测(数学点和矩形关系判断)
    /// </summary>
    private bool SimulateRectangleCheck(Transform self, Transform target, float halfWidth, float distance)
    {
        if (null == self || null == target)
            return false;

        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);
        Vector3 selfEulerAngles = self.rotation.eulerAngles;
        Quaternion selfQuat = self.rotation;

        //矩形的四个点
        Vector3 leftPoint = selfPosition + (selfQuat * Vector3.left) * halfWidth;
        Vector3 rightPoint = selfPosition + (selfQuat * Vector3.right) * halfWidth;
        Vector3 leftUpPoint = leftPoint + (selfQuat * Vector3.forward) * distance;
        Vector3 rightUpPoint = rightPoint + (selfQuat * Vector3.forward) * distance;

        Debug.DrawLine(selfPosition, leftPoint, Color.red);
        Debug.DrawLine(selfPosition, rightPoint, Color.red);
        Debug.DrawLine(leftPoint, leftUpPoint, Color.red);
        Debug.DrawLine(rightPoint, rightUpPoint, Color.red);
        Debug.DrawLine(leftUpPoint, rightUpPoint, Color.red);

        //---------------------范围检测-----------------------------------

        Vector2 point = Vector2.zero;
        point.x = targetPosition.x;
        point.y = targetPosition.z;

        Vector2 point1 = Vector2.zero;
        point1.x = leftUpPoint.x;
        point1.y = leftUpPoint.z;

        Vector2 point2 = Vector2.zero;
        point2.x = rightUpPoint.x;
        point2.y = rightUpPoint.z;

        Vector2 point3 = Vector2.zero;
        point3.x = rightPoint.x;
        point3.y = rightPoint.z;

        Vector2 point4 = Vector2.zero;
        point4.x = leftPoint.x;
        point4.y = leftPoint.z;

        bool bResult = IsPointInRectangle(point1, point2, point3, point4, point);
        return bResult;
    }

    /// <summary>
    /// 矩形范围检测(点乘方式)
    /// </summary>
    private bool RectangleCheck(Transform self, Transform target, float halfWidth, float distance)
    {
        if (null == self || null == target)
            return false;

        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);
        Vector3 selfEulerAngles = self.rotation.eulerAngles;
        Quaternion selfQuat = self.rotation;

        //矩形的四个点
        Vector3 leftPoint = selfPosition + (selfQuat * Vector3.left) * halfWidth;
        Vector3 rightPoint = selfPosition + (selfQuat * Vector3.right) * halfWidth;
        Vector3 leftUpPoint = leftPoint + (selfQuat * Vector3.forward) * distance;
        Vector3 rightUpPoint = rightPoint + (selfQuat * Vector3.forward) * distance;

        Debug.DrawLine(selfPosition, leftPoint, Color.red);
        Debug.DrawLine(selfPosition, rightPoint, Color.red);
        Debug.DrawLine(leftPoint, leftUpPoint, Color.red);
        Debug.DrawLine(rightPoint, rightUpPoint, Color.red);
        Debug.DrawLine(leftUpPoint, rightUpPoint, Color.red);

        //---------------------范围检测-----------------------------------

        //计算self到target的向量
        Vector3 dir = targetPosition - selfPosition;

        //点乘dir向量和自身的forward向量
        float dotForward = Vector3.Dot(dir, (selfQuat * Vector3.forward).normalized);

        //target处于self的前方的height范围
        if (dotForward > 0 && dotForward <= distance)
        {
            float dotRight = Vector3.Dot(dir, (selfQuat * Vector3.right).normalized);

            //target处于self的左右halfWidth的范围
            if (Mathf.Abs(dotRight) <= halfWidth)
                return true;
        }
        return false;
    }

    /// <summary>
    /// 扇面范围检测
    /// </summary>
    private bool SectorCheck(Transform self, Transform target, float halfAngle, float nearDis, float farDis)
    {
        if (null == self || null == target)
            return false;

        if (nearDis > farDis)
        {
            float tempDis = nearDis;
            nearDis = farDis;
            farDis = tempDis;
        }
        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);
        Quaternion selfQuat = self.rotation;

        int nCircleDentity = 360;
        Vector3 nearFirstPoint = Vector3.zero;
        Vector3 nearBeginPoint = selfPosition;
        Vector3 nearEndPoint = Vector3.zero;
        Vector3 farFirstPoint = Vector3.zero;
        Vector3 farBeginPoint = selfPosition;
        Vector3 farEndPoint = Vector3.zero;
        float tempStep = 2 * Mathf.PI / nCircleDentity;
        float leftRadian = Mathf.PI / 2 + Mathf.Deg2Rad * halfAngle;
        float rightRadian = Mathf.PI / 2 - Mathf.Deg2Rad * halfAngle;
        bool bFirst = true;
        for (float step = 0; step < 2 * Mathf.PI; step += tempStep)
        {
            float nearX = nearDis * Mathf.Cos(step);
            float nearZ = nearDis * Mathf.Sin(step);

            float farX = farDis * Mathf.Cos(step);
            float farZ = farDis * Mathf.Sin(step);

            if (step >= rightRadian && step <= leftRadian)
            {
                //-------绘制近扇面
                nearEndPoint.x = selfPosition.x + nearX;
                nearEndPoint.z = selfPosition.z + nearZ;

                //-------绘制远扇面
                farEndPoint.x = selfPosition.x + farX;
                farEndPoint.z = selfPosition.z + farZ;

                if (bFirst)
                {
                    nearFirstPoint = nearEndPoint;
                    farFirstPoint = farEndPoint;
                    bFirst = false;
                }
                else
                {
                    Debug.DrawLine(nearBeginPoint, nearEndPoint, Color.red);
                    Debug.DrawLine(farBeginPoint, farEndPoint, Color.red);
                }
                    
                nearBeginPoint = nearEndPoint;
                farBeginPoint = farEndPoint;
            }
        }
        Debug.DrawLine(nearFirstPoint, farFirstPoint, Color.red);
        Debug.DrawLine(nearEndPoint, farEndPoint, Color.red);
        Debug.DrawLine(selfPosition, nearFirstPoint, Color.blue);
        Debug.DrawLine(selfPosition, nearEndPoint, Color.blue);

        //---------------------范围检测-----------------------------------

        //计算距离
        float currDis = Vector3.Distance(selfPosition, targetPosition);
        if (currDis < nearDis ||  currDis > farDis)
            return false;

        //计算self到target的向量
        Vector3 dir = targetPosition - selfPosition;

        //点乘dir向量和自身的forward向量 cosq
        float dotForward = Vector3.Dot(dir.normalized, (selfQuat * Vector3.forward).normalized);

        //得到夹角弧度并转换成角度
        float radian = Mathf.Acos(dotForward);
        float currAngle = Mathf.Rad2Deg * radian;

        if (Mathf.Abs(currAngle) <= halfAngle)
            return true;

        return false;
    }

    /// <summary>
    /// 双圆范围检测
    /// </summary>
    private bool RingCheck(Transform self, Transform target, float nearDis, float farDis)
    {
        if (null == self || null == target)
            return false;

        if (nearDis > farDis)
        {
            float tempDis = nearDis;
            nearDis = farDis;
            farDis = tempDis;
        }
        //---------------------绘制图形-----------------------------------

        Vector3 selfPosition = NormalizePosition(self.position);
        Vector3 targetPosition = NormalizePosition(target.position);

        int nCircleDentity = 360;
        Vector3 nearBeginPoint = selfPosition;
        Vector3 nearEndPoint = Vector3.zero;
        Vector3 farBeginPoint = selfPosition;
        Vector3 farEndPoint = Vector3.zero;
        float tempStep = 2 * Mathf.PI / nCircleDentity;
        bool bFirst = true;
        for (float step = 0; step < 2 * Mathf.PI; step += tempStep)
        {
            float nearX = nearDis * Mathf.Cos(step);
            float nearZ = nearDis * Mathf.Sin(step);
            nearEndPoint.x = selfPosition.x + nearX;
            nearEndPoint.z = selfPosition.z + nearZ;

            float farX = farDis * Mathf.Cos(step);
            float farZ = farDis * Mathf.Sin(step);
            farEndPoint.x = selfPosition.x + farX;
            farEndPoint.z = selfPosition.z + farZ;

            if (bFirst)
                bFirst = false;
            else
            {
                Debug.DrawLine(nearBeginPoint, nearEndPoint, Color.red);
                Debug.DrawLine(farBeginPoint, farEndPoint, Color.red);
            }

            nearBeginPoint = nearEndPoint;
            farBeginPoint = farEndPoint;
        }

        //---------------------范围检测-----------------------------------

        float currDistance = Vector3.Distance(selfPosition, targetPosition);
        if (currDistance >= nearDis && currDistance <= farDis )
            return true;

        return false;
    }

    /// <summary>
    /// 规范位置(去除高度带来的影响)
    /// </summary>
    private Vector3 NormalizePosition(Vector3 position,float hight = 0.0f)
    {
        Vector3 tempPosition = Vector3.zero;
        tempPosition.x = position.x;
        tempPosition.y = hight;
        tempPosition.z = position.z;

        return tempPosition;
    }

    /// <summary>
    /// 三角形检查
    /// </summary>
    private bool IsPointInTriangle(Vector3 point1, Vector3 point2, Vector3 point3, Vector3 targetPoint)
    {
        Vector3 v0 = point2 - point1;
        Vector3 v1 = point3 - point1;
        Vector3 v2 = targetPoint - point1;

        float dot00 = Vector3.Dot(v0, v0);
        float dot01 = Vector3.Dot(v0, v1);
        float dot02 = Vector3.Dot(v0, v2);
        float dot11 = Vector3.Dot(v1, v1);
        float dot12 = Vector3.Dot(v1, v2);

        float inverDeno = 1 / (dot00 * dot11 - dot01 * dot01);
        float u = (dot11 * dot02 - dot01 * dot12) * inverDeno;
        if (u < 0 || u > 1)
            return false;

        float v = (dot00 * dot12 - dot01 * dot02) * inverDeno;
        if (v < 0 || v > 1)
            return false;

        return u + v <= 1;
    }

    /// <summary>
    /// 判断点p是否在p1 p2 p3 p4构成的矩形内
    /// </summary>
    private bool IsPointInRectangle(Vector2 point1, Vector2 point2, Vector2 point3, Vector2 point4, Vector2 point)
    {
        return GetCross(point1, point2, point) * GetCross(point3, point4, point) >= 0
            && GetCross(point2, point3, point) * GetCross(point4, point1, point) >= 0;
    }

    /// <summary>
    /// 计算 |p1 p2| X |p1 p|
    /// </summary>
    private float GetCross(Vector2 point1, Vector2 point2, Vector2 point)
    {
        return ((point2.x - point1.x) * (point.y - point1.y) - (point.x - point1.x) * (point2.y - point1.y));
    }
}

 

相关标签: 数据结构和算法