Unity 攻击范围检测
众所周知moba中的每个英雄都有一套自己的技能的攻击范围方式，有如廉颇一样的圆形范围，有火舞一样的直线范围，吕布的扇形方天戟范围，还有上图的牛魔大招时的矩形范围等等。
一些技能是通过物理的碰撞检测来判断的，一些则是通过这样的范围来检测的。物理检测的诟病就在于开销过大，在能考虑不用物理来检测的情况下更倾向来自己通过算法模拟实现。
小菜的学习研究中，将这些自己算法检测的攻击范围划分了几种类型，并做了几个demo的演示。
如上演示，小菜简单的讲这些类型划分成了如下几类：
1). Circle 圆形
2). Triangle 三角形
3). Fanshaped 扇形
4). Rectangle 矩形
5). Sector 扇面
6). Ring 环形
[Circle 圆形]
这应该是最简单的类型，只要去判断self和target的distance就可以做到了。
我们希望能直观看到范围的情况，故使用Debug.DrawLine做了调试的绘制。
绘制编码：
小菜不想由于各个对象高度的不同带来的检测差异，故用NormalizePosition将位置的y信息都归置成了0。
范围检测编码：
[Triangle 三角形]
三角形范围的判定，实际就是点在三角形内的判定。
数学上检测点在三角形内有三种推论方法。内角和法/同向法/重心法。
对数学感兴趣的可以参考：https://www.cnblogs.com/graphics/archive/2010/08/05/1793393.html
小菜这里直接套用了重心法检测。
检测编码：
绘制编码：
[Fanshaped 扇形]
扇形的范围检测我们实际可以抽象成两个步骤。
1).判断self和target的distance.
2).由于点乘，使用点乘dot来计算self到target的单位向量，与self的forward向量（本身也是单位向量）来计算得夹角cos值。使用Mathf.Acos将其转化为弧度，再转换成角度做一次判断就好了。
绘制编码：
范围检测编码：
[Rectangle 矩形]
矩形的检测小菜大概是有两种方法：
1).通过点在矩形内的数学推导公式来计算。
2).通过点乘和distance来计算。
还是先将矩形绘制出来吧。
绘制编码：
范围检测：
通过点在矩形内的数学推导公式来计算矩形范围
判断一个点是否在两条线段之间夹着就转化成，判断一个点是否在某条线段的一边上，就可以利用叉乘的方向性，来判断夹角是否超过了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 。
范围检测编码：
通过点乘和distance来计算矩形范围
还是先上一张图辅助理解吧。
两次点乘的结果在于判断target的前后和左右关系。
编码看似比上面的少很多，实际关联的理解可一点都不简单
。
[Sector 扇面]
扇面和扇形的检测很相似，不同的只是多了一层距离的检测。
绘制编码：
范围检测编码：
[Ring 环形]
环形和圆形的检测很相似，也只是多了一层距离的检测。
绘制编码：
范围检测编码：
附上完整代码：
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public enum CheckType
{
None,
/// 圆形
Circle,
/// 三角形
Triangle,
/// 扇形
Fanshaped,
/// 矩形
Rectangle,
/// 扇面
Sector,
/// 环形
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("检测到目标");
}
///
/// 圆形范围检测
///
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;
}
///
/// 三角形范围检测
///
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;
}
///
/// 扇形范围检测
///
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;
}
///
/// 矩形范围检测(数学点和矩形关系判断)
///
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;
}
///
/// 矩形范围检测(点乘方式)
///
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;
}
///
/// 扇面范围检测
///
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;
}
///
/// 双圆范围检测
///
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;
}
///
/// 规范位置(去除高度带来的影响)
///
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;
}
///
/// 三角形检查
///
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;
}
///
/// 判断点p是否在p1 p2 p3 p4构成的矩形内
///
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;
}
///
/// 计算 |p1 p2| X |p1 p|
///
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));
}
}