Unity技能范围检测 --

 Unity 攻击范围检测_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 环形]

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

绘制编码：

范围检测编码：

附上完整代码：

1. using System.Collections;

2. using System.Collections.Generic;

3. using UnityEngine;

5. public enum CheckType

6. {

7. None,

9. /// <summary> 圆形 </summary>

10. Circle,

12. /// <summary> 三角形 </summary>

13. Triangle,

15. /// <summary> 扇形 </summary>

16. Fanshaped,

18. /// <summary> 矩形 </summary>

19. Rectangle,

21. /// <summary> 扇面 </summary>

22. Sector,

24. /// <summary> 环形 </summary>

25. Ring,

26. }

28. [ExecuteInEditMode]

29. public class RangeCheckScript : MonoBehaviour

30. {

31. public CheckType currType = CheckType.None;

32. public Transform mPalyer;

33. public Transform mTarget;

34. public bool mCheckOpen = true;

36. void Update()

37. {

38. if (!mCheckOpen)

39. return;

40. if (null != mPalyer)

41. Debug.DrawLine(mPalyer.position, mPalyer.position + mPalyer.forward * 8,Color.yellow);

44. bool bResult = false;

45. switch (currType)

46. {

47. case CheckType.None:

48. break;

49. case CheckType.Circle:

50. bResult = CircleCheck(mPalyer, mTarget, 6);

51. break;

52. case CheckType.Triangle:

53. bResult = TriangleCheck(mPalyer, mTarget, 1, 10);

54. break;

55. case CheckType.Fanshaped:

56. bResult = FanshapedCheck(mPalyer, mTarget, 45, 5);

57. break;

58. case CheckType.Rectangle:

59. //bResult = SimulateRectangleCheck(mPalyer, mTarget, 2, 8);

60. bResult = RectangleCheck(mPalyer, mTarget, 2, 8);

61. break;

62. case CheckType.Sector:

63. bResult = SectorCheck(mPalyer, mTarget, 45, 5, 8);

64. break;

65. case CheckType.Ring:

66. bResult = RingCheck(mPalyer, mTarget, 4, 8);

67. break;

68. default:

69. break;

70. }

72. if (bResult)

73. Debug.LogError("检测到目标");

74. }

76. /// <summary>

77. /// 圆形范围检测

78. /// </summary>

79. private bool CircleCheck(Transform self, Transform target, float distance)

80. {

81. if (null == self || null == target)

82. return false;

84. //---------------------绘制图形-----------------------------------

86. Vector3 selfPosition = NormalizePosition(self.position);

87. Vector3 targetPosition = NormalizePosition(target.position);

89. int nCircleDentity = 360;

90. Vector3 beginPoint = selfPosition;

91. Vector3 endPoint = Vector3.zero;

92. float tempStep = 2 * Mathf.PI / nCircleDentity;

93. bool bFirst = true;

94. for (float step = 0; step < 2 * Mathf.PI; step += tempStep)

95. {

96. float x = distance * Mathf.Cos(step);

97. float z = distance * Mathf.Sin(step);

98. endPoint.x = selfPosition.x + x;

99. endPoint.z = selfPosition.z + z;

101. if (bFirst)

102. bFirst = false;

103. else

104. Debug.DrawLine(beginPoint, endPoint, Color.red);

106. beginPoint = endPoint;

107. }

109. //---------------------范围检测-----------------------------------

111. float currDistance = Vector3.Distance(selfPosition, targetPosition);

112. if (currDistance <= distance)

113. return true;

115. return false;

116. }

118. /// <summary>

119. /// 三角形范围检测

120. /// </summary>

121. private bool TriangleCheck(Transform self, Transform target, float halfWidth,float distance)

122. {

123. if (null == self || null == target)

124. return false;

126. //---------------------绘制图形-----------------------------------

128. Vector3 selfPosition = NormalizePosition(self.position);

129. Vector3 targetPosition = NormalizePosition(target.position);

130. Quaternion tempQuat = self.rotation;

132. //三角形的三个点

133. Vector3 leftPoint = selfPosition + (tempQuat * Vector3.left) * halfWidth;

134. Vector3 rightPoint = selfPosition + (tempQuat * Vector3.right) * halfWidth;

135. Vector3 forwardPoint = selfPosition + (tempQuat * Vector3.forward) * distance;

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

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

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

141. //---------------------范围检测-----------------------------------

143. bool bResult = IsPointInTriangle(leftPoint, forwardPoint, rightPoint, targetPosition);

144. return bResult;

145. }

147. /// <summary>

148. /// 扇形范围检测

149. /// </summary>

150. private bool FanshapedCheck(Transform self, Transform target, float halfAngle, float distance)

151. {

152. if (null == self || null == target)

153. return false;

155. //---------------------绘制图形-----------------------------------

157. Vector3 selfPosition = NormalizePosition(self.position);

158. Vector3 targetPosition = NormalizePosition(target.position);

159. Quaternion selfQuat = self.rotation;

161. int nCircleDentity = 360;

162. Vector3 firstPoint = Vector3.zero;

163. Vector3 beginPoint = selfPosition;

164. Vector3 endPoint = Vector3.zero;

165. float tempStep = 2 * Mathf.PI / nCircleDentity;

166. float leftRadian = Mathf.PI / 2 + Mathf.Deg2Rad * halfAngle;

167. float rightRadian = Mathf.PI / 2 - Mathf.Deg2Rad * halfAngle;

168. bool bFirst = true;

169. for (float step = 0; step < 2 * Mathf.PI; step += tempStep)

170. {

171. float x = distance * Mathf.Cos(step);

172. float z = distance * Mathf.Sin(step);

173. endPoint.x = selfPosition.x + x;

174. endPoint.z = selfPosition.z + z;

176. if (step >= rightRadian && step <= leftRadian)

177. {

178. if (bFirst)

179. {

180. firstPoint = endPoint;

181. bFirst = false;

182. }

183. Debug.DrawLine(beginPoint, endPoint, Color.red);

185. beginPoint = endPoint;

186. }

187. }

188. Debug.DrawLine(selfPosition, firstPoint, Color.red);

189. Debug.DrawLine(selfPosition, beginPoint, Color.red);

191. //---------------------范围检测-----------------------------------

193. //计算距离

194. float currDis = Vector3.Distance(selfPosition, targetPosition);

195. if (currDis > distance)

196. return false;

198. //计算self到target的向量

199. Vector3 dir = targetPosition - selfPosition;

201. //点乘dir向量和自身的forward向量 cosq

202. float dotForward = Vector3.Dot(dir.normalized, (selfQuat * Vector3.forward).normalized);

204. //得到夹角弧度并转换成角度

205. float radian = Mathf.Acos(dotForward);

206. float currAngle = Mathf.Rad2Deg * radian;

208. if (Mathf.Abs(currAngle) <= halfAngle)

209. return true;

211. return false;

212. }

214. /// <summary>

215. /// 矩形范围检测(数学点和矩形关系判断)

216. /// </summary>

217. private bool SimulateRectangleCheck(Transform self, Transform target, float halfWidth, float distance)

218. {

219. if (null == self || null == target)

220. return false;

222. //---------------------绘制图形-----------------------------------

224. Vector3 selfPosition = NormalizePosition(self.position);

225. Vector3 targetPosition = NormalizePosition(target.position);

226. Vector3 selfEulerAngles = self.rotation.eulerAngles;

227. Quaternion selfQuat = self.rotation;

229. //矩形的四个点

230. Vector3 leftPoint = selfPosition + (selfQuat * Vector3.left) * halfWidth;

231. Vector3 rightPoint = selfPosition + (selfQuat * Vector3.right) * halfWidth;

232. Vector3 leftUpPoint = leftPoint + (selfQuat * Vector3.forward) * distance;

233. Vector3 rightUpPoint = rightPoint + (selfQuat * Vector3.forward) * distance;

235. Debug.DrawLine(selfPosition, leftPoint, Color.red);

236. Debug.DrawLine(selfPosition, rightPoint, Color.red);

237. Debug.DrawLine(leftPoint, leftUpPoint, Color.red);

238. Debug.DrawLine(rightPoint, rightUpPoint, Color.red);

239. Debug.DrawLine(leftUpPoint, rightUpPoint, Color.red);

241. //---------------------范围检测-----------------------------------

243. Vector2 point = Vector2.zero;

244. point.x = targetPosition.x;

245. point.y = targetPosition.z;

247. Vector2 point1 = Vector2.zero;

248. point1.x = leftUpPoint.x;

249. point1.y = leftUpPoint.z;

251. Vector2 point2 = Vector2.zero;

252. point2.x = rightUpPoint.x;

253. point2.y = rightUpPoint.z;

255. Vector2 point3 = Vector2.zero;

256. point3.x = rightPoint.x;

257. point3.y = rightPoint.z;

259. Vector2 point4 = Vector2.zero;

260. point4.x = leftPoint.x;

261. point4.y = leftPoint.z;

263. bool bResult = IsPointInRectangle(point1, point2, point3, point4, point);

264. return bResult;

265. }

267. /// <summary>

268. /// 矩形范围检测(点乘方式)

269. /// </summary>

270. private bool RectangleCheck(Transform self, Transform target, float halfWidth, float distance)

271. {

272. if (null == self || null == target)

273. return false;

275. //---------------------绘制图形-----------------------------------

277. Vector3 selfPosition = NormalizePosition(self.position);

278. Vector3 targetPosition = NormalizePosition(target.position);

279. Vector3 selfEulerAngles = self.rotation.eulerAngles;

280. Quaternion selfQuat = self.rotation;

282. //矩形的四个点

283. Vector3 leftPoint = selfPosition + (selfQuat * Vector3.left) * halfWidth;

284. Vector3 rightPoint = selfPosition + (selfQuat * Vector3.right) * halfWidth;

285. Vector3 leftUpPoint = leftPoint + (selfQuat * Vector3.forward) * distance;

286. Vector3 rightUpPoint = rightPoint + (selfQuat * Vector3.forward) * distance;

288. Debug.DrawLine(selfPosition, leftPoint, Color.red);

289. Debug.DrawLine(selfPosition, rightPoint, Color.red);

290. Debug.DrawLine(leftPoint, leftUpPoint, Color.red);

291. Debug.DrawLine(rightPoint, rightUpPoint, Color.red);

292. Debug.DrawLine(leftUpPoint, rightUpPoint, Color.red);

294. //---------------------范围检测-----------------------------------

296. //计算self到target的向量

297. Vector3 dir = targetPosition - selfPosition;

299. //点乘dir向量和自身的forward向量

300. float dotForward = Vector3.Dot(dir, (selfQuat * Vector3.forward).normalized);

302. //target处于self的前方的height范围

303. if (dotForward > 0 && dotForward <= distance)

304. {

305. float dotRight = Vector3.Dot(dir, (selfQuat * Vector3.right).normalized);

307. //target处于self的左右halfWidth的范围

308. if (Mathf.Abs(dotRight) <= halfWidth)

309. return true;

310. }

311. return false;

312. }

314. /// <summary>

315. /// 扇面范围检测

316. /// </summary>

317. private bool SectorCheck(Transform self, Transform target, float halfAngle, float nearDis, float farDis)

318. {

319. if (null == self || null == target)

320. return false;

322. if (nearDis > farDis)

323. {

324. float tempDis = nearDis;

325. nearDis = farDis;

326. farDis = tempDis;

327. }

328. //---------------------绘制图形-----------------------------------

330. Vector3 selfPosition = NormalizePosition(self.position);

331. Vector3 targetPosition = NormalizePosition(target.position);

332. Quaternion selfQuat = self.rotation;

334. int nCircleDentity = 360;

335. Vector3 nearFirstPoint = Vector3.zero;

336. Vector3 nearBeginPoint = selfPosition;

337. Vector3 nearEndPoint = Vector3.zero;

338. Vector3 farFirstPoint = Vector3.zero;

339. Vector3 farBeginPoint = selfPosition;

340. Vector3 farEndPoint = Vector3.zero;

341. float tempStep = 2 * Mathf.PI / nCircleDentity;

342. float leftRadian = Mathf.PI / 2 + Mathf.Deg2Rad * halfAngle;

343. float rightRadian = Mathf.PI / 2 - Mathf.Deg2Rad * halfAngle;

344. bool bFirst = true;

345. for (float step = 0; step < 2 * Mathf.PI; step += tempStep)

346. {

347. float nearX = nearDis * Mathf.Cos(step);

348. float nearZ = nearDis * Mathf.Sin(step);

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

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

353. if (step >= rightRadian && step <= leftRadian)

354. {

355. //-------绘制近扇面

356. nearEndPoint.x = selfPosition.x + nearX;

357. nearEndPoint.z = selfPosition.z + nearZ;

359. //-------绘制远扇面

360. farEndPoint.x = selfPosition.x + farX;

361. farEndPoint.z = selfPosition.z + farZ;

363. if (bFirst)

364. {

365. nearFirstPoint = nearEndPoint;

366. farFirstPoint = farEndPoint;

367. bFirst = false;

368. }

369. else

370. {

371. Debug.DrawLine(nearBeginPoint, nearEndPoint, Color.red);

372. Debug.DrawLine(farBeginPoint, farEndPoint, Color.red);

373. }

375. nearBeginPoint = nearEndPoint;

376. farBeginPoint = farEndPoint;

377. }

378. }

379. Debug.DrawLine(nearFirstPoint, farFirstPoint, Color.red);

380. Debug.DrawLine(nearEndPoint, farEndPoint, Color.red);

381. Debug.DrawLine(selfPosition, nearFirstPoint, Color.blue);

382. Debug.DrawLine(selfPosition, nearEndPoint, Color.blue);

384. //---------------------范围检测-----------------------------------

386. //计算距离

387. float currDis = Vector3.Distance(selfPosition, targetPosition);

388. if (currDis < nearDis || currDis > farDis)

389. return false;

391. //计算self到target的向量

392. Vector3 dir = targetPosition - selfPosition;

394. //点乘dir向量和自身的forward向量 cosq

395. float dotForward = Vector3.Dot(dir.normalized, (selfQuat * Vector3.forward).normalized);

397. //得到夹角弧度并转换成角度

398. float radian = Mathf.Acos(dotForward);

399. float currAngle = Mathf.Rad2Deg * radian;

401. if (Mathf.Abs(currAngle) <= halfAngle)

402. return true;

404. return false;

405. }

407. /// <summary>

408. /// 双圆范围检测

409. /// </summary>

410. private bool RingCheck(Transform self, Transform target, float nearDis, float farDis)

411. {

412. if (null == self || null == target)

413. return false;

415. if (nearDis > farDis)

416. {

417. float tempDis = nearDis;

418. nearDis = farDis;

419. farDis = tempDis;

420. }

421. //---------------------绘制图形-----------------------------------

423. Vector3 selfPosition = NormalizePosition(self.position);

424. Vector3 targetPosition = NormalizePosition(target.position);

426. int nCircleDentity = 360;

427. Vector3 nearBeginPoint = selfPosition;

428. Vector3 nearEndPoint = Vector3.zero;

429. Vector3 farBeginPoint = selfPosition;

430. Vector3 farEndPoint = Vector3.zero;

431. float tempStep = 2 * Mathf.PI / nCircleDentity;

432. bool bFirst = true;

433. for (float step = 0; step < 2 * Mathf.PI; step += tempStep)

434. {

435. float nearX = nearDis * Mathf.Cos(step);

436. float nearZ = nearDis * Mathf.Sin(step);

437. nearEndPoint.x = selfPosition.x + nearX;

438. nearEndPoint.z = selfPosition.z + nearZ;

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

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

442. farEndPoint.x = selfPosition.x + farX;

443. farEndPoint.z = selfPosition.z + farZ;

445. if (bFirst)

446. bFirst = false;

447. else

448. {

449. Debug.DrawLine(nearBeginPoint, nearEndPoint, Color.red);

450. Debug.DrawLine(farBeginPoint, farEndPoint, Color.red);

451. }

453. nearBeginPoint = nearEndPoint;

454. farBeginPoint = farEndPoint;

455. }

457. //---------------------范围检测-----------------------------------

459. float currDistance = Vector3.Distance(selfPosition, targetPosition);

460. if (currDistance >= nearDis && currDistance <= farDis )

461. return true;

463. return false;

464. }

466. /// <summary>

467. /// 规范位置(去除高度带来的影响)

468. /// </summary>

469. private Vector3 NormalizePosition(Vector3 position,float hight = 0.0f)

470. {

471. Vector3 tempPosition = Vector3.zero;

472. tempPosition.x = position.x;

473. tempPosition.y = hight;

474. tempPosition.z = position.z;

476. return tempPosition;

477. }

479. /// <summary>

480. /// 三角形检查

481. /// </summary>

482. private bool IsPointInTriangle(Vector3 point1, Vector3 point2, Vector3 point3, Vector3 targetPoint)

483. {

484. Vector3 v0 = point2 - point1;

485. Vector3 v1 = point3 - point1;

486. Vector3 v2 = targetPoint - point1;

488. float dot00 = Vector3.Dot(v0, v0);

489. float dot01 = Vector3.Dot(v0, v1);

490. float dot02 = Vector3.Dot(v0, v2);

491. float dot11 = Vector3.Dot(v1, v1);

492. float dot12 = Vector3.Dot(v1, v2);

494. float inverDeno = 1 / (dot00 * dot11 - dot01 * dot01);

495. float u = (dot11 * dot02 - dot01 * dot12) * inverDeno;

496. if (u < 0 || u > 1)

497. return false;

499. float v = (dot00 * dot12 - dot01 * dot02) * inverDeno;

500. if (v < 0 || v > 1)

501. return false;

503. return u + v <= 1;

504. }

506. /// <summary>

507. /// 判断点p是否在p1 p2 p3 p4构成的矩形内

508. /// </summary>

509. private bool IsPointInRectangle(Vector2 point1, Vector2 point2, Vector2 point3, Vector2 point4, Vector2 point)

510. {

511. return GetCross(point1, point2, point) * GetCross(point3, point4, point) >= 0

512. && GetCross(point2, point3, point) * GetCross(point4, point1, point) >= 0;

513. }

515. /// <summary>

516. /// 计算 |p1 p2| X |p1 p|

517. /// </summary>

518. private float GetCross(Vector2 point1, Vector2 point2, Vector2 point)

519. {

520. return ((point2.x - point1.x) * (point.y - point1.y) - (point.x - point1.x) * (point2.y - point1.y));

521. }

522. }