开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
KNpcAI.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：51k
源码类别：

模拟服务器

开发平台：

C/C++

KNpcAI.cpp：源码内容
  1. #include "KCore.h"
  2. #include "KNpc.h"
  3. #include "KNpcSet.h"
  4. #include "KSubWorld.h"
  5. #include "KMath.h"
  6. #include "KObj.h"
  7. #include "KPlayer.h"
  8. #include "KNpcAI.h"
  10. // flying add here, to use math lib
  11. #include <math.h>
  12. extern int GetRandomNumber(int nMin, int nMax);
  14. #define MAX_FOLLOW_DISTANCE 48
  15. #define FOLLOW_WALK_DISTANCE 100
  17. KNpcAI NpcAI;
  19. KNpcAI::KNpcAI()
  20. {
  21. m_nIndex = 0;
  22. m_bActivate = TRUE;
  23. }
  25. // flying modified this function.
  26. // Jun.4.2003
  27. void KNpcAI::Activate(int nIndex)
  28. {
  29. m_nIndex = nIndex;
  30. if (Npc[m_nIndex].IsPlayer())
  31. {
  32. // 新增的Player AI在这里调用实现。
  33. ProcessPlayer();
  34. return;
  35. }
  36. #ifdef _SERVER
  37. if (Npc[m_nIndex].m_CurrentLifeMax == 0)
  38. return;
  39. int nCurTime = SubWorld[Npc[m_nIndex].m_SubWorldIndex].m_dwCurrentTime;
  40. if (/*Npc[m_nIndex].m_nPeopleIdx ||*/Npc[m_nIndex].m_NextAITime <= nCurTime)
  41. {
  42. Npc[m_nIndex].m_NextAITime = nCurTime + Npc[m_nIndex].m_AIMAXTime;
  43. switch(Npc[m_nIndex].m_AiMode)
  44. {
  45. case 1:
  46. ProcessAIType01();
  47. break;
  48. case 2:
  49. ProcessAIType02();
  50. break;
  51. case 3:
  52. ProcessAIType03();
  53. break;
  54. case 4:
  55. ProcessAIType04();
  56. break;
  57. case 5:
  58. ProcessAIType05();
  59. break;
  60. case 6:
  61. ProcessAIType06();
  62. break;
  63. /* case 7:
  64. ProcessAIType7();
  65. break;
  66. case 8:
  67. ProcessAIType8();
  68. break;
  69. case 9:
  70. ProcessAIType9();
  71. break;
  72. case 10:
  73. ProcessAIType10();
  74. break;*/
  75. default:
  76. break;
  77. }
  78. }
  79. // flying add the code for the macro such as "_CLIENT".
  80. // because this code only run at client.
  81. #else
  82. if (Npc[m_nIndex].m_Kind > 3 && Npc[m_nIndex].m_AiMode > 10)
  83. {
  84. if (CanShowNpc())
  85. {
  86. // 让NPC随机休息一下，是个好建议。
  87. if (GetRandomNumber(0, 1))
  88. {
  89. Npc[m_nIndex].m_AiParam[5] = 0;
  90. Npc[m_nIndex].m_AiParam[4] = 5;
  91. return;
  92. }
  93. if (!KeepActiveRange())
  94. ProcessShowNpc();
  95. }
  96. }
  97. #endif
  98. }
  99. //---------------------------------------------------------------------
  100. // flying add these functions
  101. // Run at client.
  102. #ifndef _SERVER
  103. // 仅仅有画面效果的NPC
  104. int KNpcAI::ProcessShowNpc()
  105. {
  106.     int nResult  = false;
  107.     int nRetCode = false;
  109. switch (Npc[m_nIndex].m_AiMode)
  110. {
  111. // 飞鸟型
  112. case 11:
  113. nRetCode = ShowNpcType11();
  114.         if (!nRetCode)
  115.             goto Exit0;
  116. break;
  117. // 蜻蜓型
  118. case 12:
  119. nRetCode = ShowNpcType12();
  120.         if (!nRetCode)
  121.             goto Exit0;
  122. break;
  123. // 鱼类型
  124. case 13:
  125. nRetCode = ShowNpcType13();
  126.         if (!nRetCode)
  127.             goto Exit0;
  128. break;
  129. // 老鼠型
  130. case 14:
  131. nRetCode = ShowNpcType14();
  132.         if (!nRetCode)
  133.             goto Exit0;
  134. break;
  135. // 鸡犬型
  136. case 15:
  137. nRetCode = ShowNpcType15();
  138.         if (!nRetCode)
  139.             goto Exit0;
  140. break;
  141. // 兔子型
  142. case 16:
  143. nRetCode = ShowNpcType16();
  144.         if (!nRetCode)
  145.             goto Exit0;
  146. break;
  147. // 蝴蝶型
  148. case 17:
  149. nRetCode = ShowNpcType17();
  150.         if (!nRetCode)
  151.             goto Exit0;
  152. break;
  153. default:
  154. break;
  155. }
  157.     nResult = true;
  158. Exit0:
  159. return nResult;
  160. }
  162. // 飞鸟型
  163. int KNpcAI::ShowNpcType11()
  164. {
  165.     int nResult = false;
  166.     int nRetCode = false;
  168. KNpc& aNpc = Npc[m_nIndex];
  169. // Go the distance between P1 to P2
  170. int nDistance = 0;
  171. int nDesX = 0;
  172. int nDesY = 0;
  173. int nCurX = 0;
  174. int nCurY = 0;
  175. int nOffX = 0;
  176. int nOffY = 0;
  177. int nOffsetDir = 0;
  179. // 效果加强 随机调整高度
  180. aNpc.m_Height = GetRandomNumber(aNpc.m_AiParam[6] - 4, aNpc.m_AiParam[6]);
  182. aNpc.GetMpsPos(&nCurX, &nCurY);
  184. // 计算新角度 和 距离
  185. if (aNpc.m_AiParam[3] > 0)
  186. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  187. else
  188. nOffsetDir = aNpc.m_AiParam[2];
  190.     if (GetRandomNumber(0, 1))
  191. nOffsetDir = -nOffsetDir;
  193.     nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  195. // 取得运动所需的时间，保存在参数表中
  196. if (aNpc.m_CurrentWalkSpeed > 0)
  197. {
  198. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  199. aNpc.m_AiParam[5] = 0;
  200. }
  201. //if (KeepActiveShowRange())
  202. // aNpc.m_Dir += 32;
  203. aNpc.m_Dir += nOffsetDir;
  204. if (aNpc.m_Dir < 0)
  205. aNpc.m_Dir += 64;
  206. else
  207. aNpc.m_Dir %= 64;
  209.     // 根据三角函数计算偏移的X、Y数值
  210. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  211.     if (!nRetCode)
  212.         goto Exit0;
  214. // 获取目标坐标
  215. nDesX = nCurX + nOffX;
  216. nDesY = nCurY + nOffY;
  217. aNpc.SendCommand(do_walk, nDesX, nDesY);
  219.     nResult = true;
  220. Exit0:
  221. return nResult;
  222. }
  224. // 蜻蜓型
  225. // done
  226. int KNpcAI::ShowNpcType12()
  227. {
  228.     int nResult = false;
  229.     int nRetCode = false;
  231. // Go the distance between P1 to P2
  232. int nDistance = 0;
  233. int nDesX = 0;
  234. int nDesY = 0;
  235. int nCurX = 0;
  236. int nCurY = 0;
  237. int nOffX = 0;
  238. int nOffY = 0;
  239. int nOffsetDir = 0;
  240. KNpc& aNpc = Npc[m_nIndex];
  242. // 效果加强 随机调整高度
  243. aNpc.m_Height = GetRandomNumber(aNpc.m_AiParam[6] - 4, aNpc.m_AiParam[6]);
  245. aNpc.GetMpsPos(&nCurX, &nCurY);
  247. // 计算新角度 和 距离
  248. if (aNpc.m_AiParam[3] > 0)
  249. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  250. else
  251. nOffsetDir = aNpc.m_AiParam[2];
  252. if (GetRandomNumber(0, 1))
  253. nOffsetDir = -nOffsetDir;
  254. nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  256. // 取得运动所需的时间，保存在参数表中
  257. if (aNpc.m_CurrentWalkSpeed > 0)
  258. {
  259. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  260. aNpc.m_AiParam[5] = 0;
  261. }
  262. else
  263. {
  264. aNpc.m_AiParam[4] = 0;
  265. aNpc.m_AiParam[5] = 0;
  266. }
  267. aNpc.m_Dir += nOffsetDir;
  268. if (aNpc.m_Dir < 0)
  269. aNpc.m_Dir += 64;
  270. else
  271. aNpc.m_Dir %= 64;
  273. // 根据三角函数计算偏移的X、Y数值
  274. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  275. if (!nRetCode)
  276. goto Exit0;
  277. // 获取目标坐标
  278. nDesX = nCurX + nOffX;
  279. nDesY = nCurY + nOffY;
  280. aNpc.SendCommand(do_walk, nDesX, nDesY);
  282. nResult = true;
  283. Exit0:
  284. return nResult;
  285. }
  287. // 鱼类型
  288. // done
  289. int KNpcAI::ShowNpcType13()
  290. {
  291. int nResult  = false;
  292. int nRetCode = false;
  293. // Go the distance between P1 to P2
  294. int nDistance = 0;
  295. int nDesX = 0;
  296. int nDesY = 0;
  297. int nCurX = 0;
  298. int nCurY = 0;
  299. int nOffX = 0;
  300. int nOffY = 0;
  301. int nOffsetDir = 0;
  302. int nIndex = 0;
  303. KNpc& aNpc = Npc[m_nIndex];
  305. aNpc.GetMpsPos(&nCurX, &nCurY);
  307. // 计算新角度 和 距离
  308. if (aNpc.m_AiParam[3] > 0)
  309. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  310. else
  311. nOffsetDir = aNpc.m_AiParam[2];
  312. if (GetRandomNumber(0, 1))
  313. nOffsetDir = -nOffsetDir;
  314. nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  316. // 取得运动所需的时间，保存在参数表中
  317. if (aNpc.m_CurrentWalkSpeed > 0)
  318. {
  319. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  320. aNpc.m_AiParam[5] = 0;
  321. }
  322. else
  323. {
  324. aNpc.m_AiParam[4] = 0;
  325. aNpc.m_AiParam[5] = 0;
  326. }
  327. //if (KeepActiveShowRange())
  328. // aNpc.m_Dir += 32;
  329. // 附近有玩家
  330. nIndex = IsPlayerCome();
  331. if (nIndex > 0)
  332. {
  333. // do flee
  334. DoShowFlee(nIndex);
  335. goto Exit0;
  336. }
  337. // 根据三角函数计算偏移的X、Y数值
  338. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  339. // 获取目标坐标
  340. nDesX = nCurX + nOffX;
  341. nDesY = nCurY + nOffY;
  342. aNpc.SendCommand(do_walk, nDesX, nDesY);
  344. nResult = true;
  345. Exit0:
  346. return nResult;
  347. }
  349. // 老鼠型
  350. // done
  351. int KNpcAI::ShowNpcType14()
  352. {
  353. int nResult  = false;
  354. int nRetCode = false;
  356. int nDistance = 0;
  357. int nDesX = 0;
  358. int nDesY = 0;
  359. int nCurX = 0;
  360. int nCurY = 0;
  361. int nOffX = 0;
  362. int nOffY = 0;
  363. int nRandom = 0;
  364. int nOffsetDir = 0;
  365. KNpc& aNpc = Npc[m_nIndex];
  367. nRandom = GetRandomNumber(1, 10);
  368. // 掉头就跑
  369. if (nRandom < 4)
  370. nDistance = -nDistance;
  371. // 嗷嗷发呆
  372. else if (nRandom < 7)
  373. {
  374. aNpc.SendCommand(do_stand);
  375. goto Exit0;
  376. }
  377. aNpc.GetMpsPos(&nCurX, &nCurY);
  378. // 计算新角度 和 距离
  379. if (aNpc.m_AiParam[3] > 0)
  380. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  381. else
  382. nOffsetDir = aNpc.m_AiParam[2];
  383. if (GetRandomNumber(0, 1))
  384. nOffsetDir = -nOffsetDir;
  385. nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  386. // 取得运动所需的时间，保存在参数表中
  387. if (aNpc.m_CurrentWalkSpeed > 0)
  388. {
  389. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  390. aNpc.m_AiParam[5] = 0;
  391. }
  392. else
  393. {
  394. aNpc.m_AiParam[4] = 0;
  395. aNpc.m_AiParam[5] = 0;
  396. }
  398. aNpc.m_Dir += nOffsetDir;
  399. if (aNpc.m_Dir < 0)
  400. aNpc.m_Dir += 64;
  401. else
  402. aNpc.m_Dir %= 64;
  403. // 根据三角函数计算偏移的X、Y数值
  404. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  405. if (!nRetCode)
  406. goto Exit0;
  407. // 获取目标坐标
  408. nDesX = nCurX + nOffX;
  409. nDesY = nCurY + nOffY;
  410. aNpc.SendCommand(do_walk, nDesX, nDesY);
  412. nResult = true;
  413. Exit0:
  414. return nResult;
  415. }
  417. // 鸡犬型
  418. int KNpcAI::ShowNpcType15()
  419. {
  420. int nResult  = false;
  421. int nRetCode = false;
  422. // Go the distance between P1 to P2
  423. int nDistance = 0;
  424. int nDesX = 0;
  425. int nDesY = 0;
  426. int nCurX = 0;
  427. int nCurY = 0;
  428. int nOffX = 0;
  429. int nOffY = 0;
  430. int nOffsetDir = 0;
  431. int nIndex = 0;
  432. KNpc& aNpc = Npc[m_nIndex];
  434. aNpc.GetMpsPos(&nCurX, &nCurY);
  436. // 计算新角度 和 距离
  437. if (aNpc.m_AiParam[3] > 0)
  438. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  439. else
  440. nOffsetDir = aNpc.m_AiParam[2];
  441. if (GetRandomNumber(0, 1))
  442. nOffsetDir = -nOffsetDir;
  443. nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  445. // 取得运动所需的时间，保存在参数表中
  446. if (aNpc.m_CurrentWalkSpeed > 0)
  447. {
  448. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  449. aNpc.m_AiParam[5] = 0;
  450. }
  451. else
  452. {
  453. aNpc.m_AiParam[4] = 0;
  454. aNpc.m_AiParam[5] = 0;
  455. }
  456. //if (KeepActiveShowRange())
  457. // aNpc.m_Dir += 32;
  458. // 附近有玩家
  459. nIndex = IsPlayerCome();
  460. if (nIndex > 0)
  461. {
  462. // do flee
  463. DoShowFlee(nIndex);
  464. goto Exit0;
  465. }
  466. // 根据三角函数计算偏移的X、Y数值
  467. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  468. // 获取目标坐标
  469. nDesX = nCurX + nOffX;
  470. nDesY = nCurY + nOffY;
  471. aNpc.SendCommand(do_walk, nDesX, nDesY);
  473. nResult = true;
  474. Exit0:
  475. return nResult;
  476. }
  478. // 兔子型
  479. int KNpcAI::ShowNpcType16()
  480. {
  481. int nResult  = false;
  482. int nRetCode = false;
  484. // Go the distance between P1 to P2
  485. register int nDistance = 0;
  486. int nDesX = 0;
  487. int nDesY = 0;
  488. int nCurX = 0;
  489. int nCurY = 0;
  490. int nOffX = 0;
  491. int nOffY = 0;
  492. int nOffsetDir = 0;
  493. int nIndex = 0;
  494. KNpc& aNpc = Npc[m_nIndex];
  496. aNpc.GetMpsPos(&nCurX, &nCurY);
  498. // 计算新角度 和 距离
  499. if (aNpc.m_AiParam[3] > 0)
  500. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  501. else
  502. nOffsetDir = aNpc.m_AiParam[2];
  503. if (GetRandomNumber(0, 1))
  504. nOffsetDir = -nOffsetDir;
  505. nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  506. // 附近有玩家
  507. nIndex = IsPlayerCome();
  508. if (nIndex > 0)
  509. {
  510. // do flee
  511. nRetCode = DoShowFlee(nIndex);
  512. if (!nRetCode)
  513. goto Exit0;
  514. goto Exit1;
  515. }
  517. // 计算距离
  518. if (aNpc.m_CurrentWalkSpeed > 0)
  519. {
  520. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  521. aNpc.m_AiParam[5] = 0;
  522. }
  523. else
  524. {
  525. aNpc.m_AiParam[4] = 0;
  526. aNpc.m_AiParam[5] = 0;
  527. }
  529. // 计算新角度
  530. //if (KeepActiveShowRange())
  531. // aNpc.m_Dir += 32;
  532. aNpc.m_Dir += GetRandomNumber(0, 6);
  533. aNpc.m_Dir %= 64;
  534. // 根据三角函数计算偏移的X、Y数值
  535. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  536. if (!nRetCode)
  537. goto Exit0;
  538. // 获取目标坐标
  539. nDesX = nCurX + nOffX;
  540. nDesY = nCurY + nOffY;
  541. aNpc.SendCommand(do_walk, nDesX, nDesY);
  543. Exit1:
  544. nResult = true;
  545. Exit0:
  546. return nResult;
  547. }
  549. // 蝴蝶型
  550. int KNpcAI::ShowNpcType17()
  551. {
  552. int nResult  = false;
  553. int nRetCode = false;
  555. // Go the distance between P1 to P2
  556. int nDistance = 0;
  557. int nDesX = 0;
  558. int nDesY = 0;
  559. int nCurX = 0;
  560. int nCurY = 0;
  561. int nOffX = 0;
  562. int nOffY = 0;
  563. int nOffsetDir = 0;
  564. KNpc& aNpc = Npc[m_nIndex];
  566. // 效果加强 随机调整高度
  567. aNpc.m_Height = GetRandomNumber(aNpc.m_AiParam[6] - 4, aNpc.m_AiParam[6]);
  569. aNpc.GetMpsPos(&nCurX, &nCurY);
  571. // 计算新角度 和 距离
  572. if (aNpc.m_AiParam[3] > 0)
  573. nOffsetDir = GetRandomNumber(aNpc.m_AiParam[3], aNpc.m_AiParam[2]);
  574. else
  575. nOffsetDir = aNpc.m_AiParam[2];
  576. if (GetRandomNumber(0, 1))
  577. nOffsetDir = -nOffsetDir;
  578. nDistance = GetRandomNumber(aNpc.m_AiParam[0] - aNpc.m_AiParam[1], aNpc.m_AiParam[0]);
  580. // 取得运动所需的时间，保存在参数表中
  581. if (aNpc.m_CurrentWalkSpeed > 0)
  582. {
  583. aNpc.m_AiParam[4] = (int) nDistance / aNpc.m_CurrentWalkSpeed;
  584. aNpc.m_AiParam[5] = 0;
  585. }
  586. else
  587. {
  588. aNpc.m_AiParam[4] = 0;
  589. aNpc.m_AiParam[5] = 0;
  590. }
  591. if (KeepActiveRange())
  592. {
  593. //aNpc.SendCommand(do_walk, aNpc.m_OriginX, aNpc.m_OriginY);
  594. goto Exit0;
  595. //aNpc.m_Dir += 32;
  596. }
  597. aNpc.m_Dir += nOffsetDir;
  598. //aNpc.m_Dir += GetRandomNumber(32, 64);
  599. if (aNpc.m_Dir < 0)
  600. aNpc.m_Dir += 64;
  601. else
  602. aNpc.m_Dir %= 64;
  603. // 根据三角函数计算偏移的X、Y数值
  604. nRetCode = GetNpcMoveOffset(aNpc.m_Dir, nDistance, &nOffX, &nOffY);
  605. if (!nRetCode)
  606. goto Exit0;
  607. // 获取目标坐标
  608. nDesX = nCurX + nOffX;
  609. nDesY = nCurY + nOffY;
  610. aNpc.SendCommand(do_walk, nDesX, nDesY);
  612. nResult = true;
  613. Exit0:
  614. return nResult;
  615. }
  616. #endif
  617. //---------------------------------------------------------------------
  618. // Player AI add here.
  619. // flying comment
  620. void KNpcAI::ProcessPlayer()
  621. {
  622. #ifdef _SERVER
  623. TriggerObjectTrap();
  624. TriggerMapTrap();
  625. #else
  626. int i = Npc[m_nIndex].m_nPeopleIdx;
  627. if (i > 0)
  628. {
  629. FollowPeople(i);
  630. }
  631. i = Npc[m_nIndex].m_nObjectIdx;
  632. if (i > 0)
  633. {
  634. FollowObject(i);
  635. }
  636. #endif
  637. }
  639. #ifndef _SERVER
  640. void KNpcAI::FollowObject(int nIdx)
  641. {
  642. int nX1, nY1, nX2, nY2;
  643. Npc[m_nIndex].GetMpsPos(&nX1, &nY1);
  644. Object[nIdx].GetMpsPos(&nX2, &nY2);
  646. if ((nX1 - nX2) * (nX1 - nX2) + (nY1 - nY2) * (nY1 - nY2) < PLAYER_PICKUP_CLIENT_DISTANCE * PLAYER_PICKUP_CLIENT_DISTANCE)
  647. {
  648. //#ifndef _SERVER
  649. Player[CLIENT_PLAYER_INDEX].CheckObject(nIdx);
  650. //#endif
  651. }
  652. }
  653. #endif
  655. #ifndef _SERVER
  656. void KNpcAI::FollowPeople(int nIdx)
  657. {
  658. if (Npc[nIdx].m_Doing == do_death || Npc[nIdx].m_Doing == do_revive)
  659. {
  660. Npc[m_nIndex].m_nPeopleIdx = 0;
  661. return;
  662. }
  664. // 取得到目标的距离
  665. int distance = NpcSet.GetDistance(nIdx, m_nIndex);
  666. int nRelation = NpcSet.GetRelation(m_nIndex, nIdx);
  668. // 小于对话半径就开始对话
  669. if ((Npc[nIdx].m_Kind == kind_dialoger))
  670. {
  671. if (distance <= Npc[nIdx].m_DialogRadius)
  672. {
  673. int x, y;
  674. SubWorld[Npc[m_nIndex].m_SubWorldIndex].Map2Mps(Npc[m_nIndex].m_RegionIndex, Npc[m_nIndex].m_MapX, Npc[m_nIndex].m_MapY, Npc[m_nIndex].m_OffX, Npc[m_nIndex].m_OffY, &x, &y);
  675. Npc[m_nIndex].SendCommand(do_walk, x,y);
  677. // Send Command to Server
  678. SendClientCmdWalk(x, y);
  679. Player[CLIENT_PLAYER_INDEX].DialogNpc(nIdx);
  680. Npc[Player[CLIENT_PLAYER_INDEX].m_nIndex].m_nPeopleIdx = 0;
  681. Npc[nIdx].TurnTo(Player[CLIENT_PLAYER_INDEX].m_nIndex);
  683. return;
  684. }
  685. }
  687. // 距离小于攻击范围就开始攻击
  688. if (nRelation == relation_enemy)
  689. {
  690. if (distance <= Npc[m_nIndex].m_CurrentAttackRadius)
  691. {
  692. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, nIdx);
  694. // Send to Server
  695. SendClientCmdSkill(Npc[m_nIndex].m_ActiveSkillID, -1, Npc[nIdx].m_dwID);
  696. }
  697. // 嗷嗷追
  698. else
  699. {
  700. int nDesX, nDesY;
  701. Npc[nIdx].GetMpsPos(&nDesX, &nDesY);
  702. // modify by spe 2003/06/13
  703. if (Player[CLIENT_PLAYER_INDEX].m_RunStatus)
  704. {
  705. Npc[m_nIndex].SendCommand(do_run, nDesX, nDesY);
  706. SendClientCmdRun(nDesX, nDesY);
  707. }
  708. else
  709. {
  710. Npc[m_nIndex].SendCommand(do_walk, nDesX, nDesY);
  711. SendClientCmdWalk(nDesX, nDesY);
  712. }
  713. }
  714. return;
  715. }
  716. // 跟随
  717. if (Npc[nIdx].m_Kind == kind_player)
  718. {
  719. // flow
  720. int nDesX, nDesY;
  721. if (distance < MAX_FOLLOW_DISTANCE)
  722. {
  723. Npc[this->m_nIndex].GetMpsPos(&nDesX, &nDesY);
  724. Npc[m_nIndex].SendCommand(do_walk, nDesX, nDesY);
  725. SendClientCmdWalk(nDesX, nDesY);
  726. }
  727. else
  728. {
  729. Npc[nIdx].GetMpsPos(&nDesX, &nDesY);
  730. if (distance < FOLLOW_WALK_DISTANCE ||
  731. !Player[CLIENT_PLAYER_INDEX].m_RunStatus)
  732. {
  733. Npc[m_nIndex].SendCommand(do_walk, nDesX, nDesY);
  734. SendClientCmdWalk(nDesX, nDesY);
  735. }
  736. else
  737. {
  738. Npc[m_nIndex].SendCommand(do_run, nDesX, nDesY);
  739. SendClientCmdRun(nDesX, nDesY);
  740. }
  741. }
  742. }
  743. return;
  744. }
  745. #endif
  747. void KNpcAI::TriggerMapTrap()
  748. {
  749. Npc[m_nIndex].CheckTrap();
  750. }
  752. void KNpcAI::TriggerObjectTrap()
  753. {
  754. return;
  755. }
  757. int KNpcAI::GetNearestNpc(int nRelation)
  758. {
  759. int nRangeX = Npc[m_nIndex].m_VisionRadius;
  760. int nRangeY = nRangeX;
  761. int nSubWorld = Npc[m_nIndex].m_SubWorldIndex;
  762. int nRegion = Npc[m_nIndex].m_RegionIndex;
  763. int nMapX = Npc[m_nIndex].m_MapX;
  764. int nMapY = Npc[m_nIndex].m_MapY;
  765. int nRet;
  766. int nRMx, nRMy, nSearchRegion;
  768. nRangeX = nRangeX / SubWorld[nSubWorld].m_nCellWidth;
  769. nRangeY = nRangeY / SubWorld[nSubWorld].m_nCellHeight;
  771. // 检查视野范围内的格子里的NPC
  772. for (int i = 0; i < nRangeX; i++) // i, j由0开始而不是从-range开始是要保证Nearest
  773. {
  774. for (int j = 0; j < nRangeY; j++)
  775. {
  776. // 去掉边角几个格子，保证视野是椭圆形
  777. if ((i * i + j * j) > nRangeX * nRangeX)
  778. continue;
  780. // 确定目标格子实际的REGION和坐标确定
  781. nRMx = nMapX + i;
  782. nRMy = nMapY + j;
  783. nSearchRegion = nRegion;
  784. if (nRMx < 0)
  785. {
  786. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[2];
  787. nRMx += SubWorld[nSubWorld].m_nRegionWidth;
  788. }
  789. else if (nRMx >= SubWorld[nSubWorld].m_nRegionWidth)
  790. {
  791. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[6];
  792. nRMx -= SubWorld[nSubWorld].m_nRegionWidth;
  793. }
  794. if (nSearchRegion == -1)
  795. continue;
  796. if (nRMy < 0)
  797. {
  798. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[4];
  799. nRMy += SubWorld[nSubWorld].m_nRegionHeight;
  800. }
  801. else if (nRMy >= SubWorld[nSubWorld].m_nRegionHeight)
  802. {
  803. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[0];
  804. nRMy -= SubWorld[nSubWorld].m_nRegionHeight;
  805. }
  806. if (nSearchRegion == -1)
  807. continue;
  808. // 从REGION的NPC列表中查找满足条件的NPC
  809. nRet = SubWorld[nSubWorld].m_Region[nSearchRegion].FindNpc(nRMx, nRMy, m_nIndex, nRelation);
  810. if (nRet > 0)
  811. return nRet;
  813. // 确定目标格子实际的REGION和坐标确定
  814. nRMx = nMapX - i;
  815. nRMy = nMapY + j;
  816. nSearchRegion = nRegion;
  817. if (nRMx < 0)
  818. {
  819. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[2];
  820. nRMx += SubWorld[nSubWorld].m_nRegionWidth;
  821. }
  822. else if (nRMx >= SubWorld[nSubWorld].m_nRegionWidth)
  823. {
  824. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[6];
  825. nRMx -= SubWorld[nSubWorld].m_nRegionWidth;
  826. }
  827. if (nSearchRegion == -1)
  828. continue;
  829. if (nRMy < 0)
  830. {
  831. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[4];
  832. nRMy += SubWorld[nSubWorld].m_nRegionHeight;
  833. }
  834. else if (nRMy >= SubWorld[nSubWorld].m_nRegionHeight)
  835. {
  836. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[0];
  837. nRMy -= SubWorld[nSubWorld].m_nRegionHeight;
  838. }
  839. if (nSearchRegion == -1)
  840. continue;
  841. // 从REGION的NPC列表中查找满足条件的NPC
  842. nRet = SubWorld[nSubWorld].m_Region[nSearchRegion].FindNpc(nRMx, nRMy, m_nIndex, nRelation);
  843. if (nRet > 0)
  844. return nRet;
  846. // 确定目标格子实际的REGION和坐标确定
  847. nRMx = nMapX - i;
  848. nRMy = nMapY - j;
  849. nSearchRegion = nRegion;
  850. if (nRMx < 0)
  851. {
  852. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[2];
  853. nRMx += SubWorld[nSubWorld].m_nRegionWidth;
  854. }
  855. else if (nRMx >= SubWorld[nSubWorld].m_nRegionWidth)
  856. {
  857. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[6];
  858. nRMx -= SubWorld[nSubWorld].m_nRegionWidth;
  859. }
  860. if (nSearchRegion == -1)
  861. continue;
  862. if (nRMy < 0)
  863. {
  864. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[4];
  865. nRMy += SubWorld[nSubWorld].m_nRegionHeight;
  866. }
  867. else if (nRMy >= SubWorld[nSubWorld].m_nRegionHeight)
  868. {
  869. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[0];
  870. nRMy -= SubWorld[nSubWorld].m_nRegionHeight;
  871. }
  872. if (nSearchRegion == -1)
  873. continue;
  874. // 从REGION的NPC列表中查找满足条件的NPC
  875. nRet = SubWorld[nSubWorld].m_Region[nSearchRegion].FindNpc(nRMx, nRMy, m_nIndex, nRelation);
  876. if (nRet > 0)
  877. return nRet;
  879. // 确定目标格子实际的REGION和坐标确定
  880. nRMx = nMapX + i;
  881. nRMy = nMapY - j;
  882. nSearchRegion = nRegion;
  883. if (nRMx < 0)
  884. {
  885. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[2];
  886. nRMx += SubWorld[nSubWorld].m_nRegionWidth;
  887. }
  888. else if (nRMx >= SubWorld[nSubWorld].m_nRegionWidth)
  889. {
  890. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[6];
  891. nRMx -= SubWorld[nSubWorld].m_nRegionWidth;
  892. }
  893. if (nSearchRegion == -1)
  894. continue;
  895. if (nRMy < 0)
  896. {
  897. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[4];
  898. nRMy += SubWorld[nSubWorld].m_nRegionHeight;
  899. }
  900. else if (nRMy >= SubWorld[nSubWorld].m_nRegionHeight)
  901. {
  902. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[0];
  903. nRMy -= SubWorld[nSubWorld].m_nRegionHeight;
  904. }
  905. if (nSearchRegion == -1)
  906. continue;
  907. // 从REGION的NPC列表中查找满足条件的NPC
  908. nRet = SubWorld[nSubWorld].m_Region[nSearchRegion].FindNpc(nRMx, nRMy, m_nIndex, nRelation);
  909. if (nRet > 0)
  910. return nRet;
  911. }
  912. }
  913. return 0;
  914. }
  916. #ifndef _SERVER
  917. // flying add this
  918. // 查找离某个NPC最近的玩家
  919. int KNpcAI::IsPlayerCome()
  920. {
  921. int nResult = 0;
  922. int nPlayer = 0;
  923. int X1 = 0;
  924. int Y1 = 0;
  925. int X2 = 0;
  926. int Y2 = 0;
  927. int nDistance = 0;
  929. nPlayer = Player[CLIENT_PLAYER_INDEX].m_nIndex;
  930. nDistance = NpcSet.GetDistance(nPlayer, m_nIndex);
  931. // 鸡看的到的玩家
  932. if (nDistance < Npc[m_nIndex].m_VisionRadius)
  933. {
  934. // 分别处理走和跑
  935. if (Player[CLIENT_PLAYER_INDEX].m_RunStatus ||
  936. Npc[m_nIndex].m_CurrentVisionRadius > nDistance * 4)
  937. {
  938. nResult = nPlayer;
  939. }
  940. }
  941. return nResult;
  942. }
  943. #endif
  945. int KNpcAI::GetNpcNumber(int nRelation)
  946. {
  947. int nRangeX = Npc[m_nIndex].m_VisionRadius;
  948. int nRangeY = nRangeX;
  949. int nSubWorld = Npc[m_nIndex].m_SubWorldIndex;
  950. int nRegion = Npc[m_nIndex].m_RegionIndex;
  951. int nMapX = Npc[m_nIndex].m_MapX;
  952. int nMapY = Npc[m_nIndex].m_MapY;
  953. int nRet = 0;
  954. int nRMx, nRMy, nSearchRegion;
  956. nRangeX = nRangeX / SubWorld[nSubWorld].m_nCellWidth;
  957. nRangeY = nRangeY / SubWorld[nSubWorld].m_nCellHeight;
  959. // 检查视野范围内的格子里的NPC
  960. for (int i = -nRangeX; i < nRangeX; i++)
  961. {
  962. for (int j = -nRangeY; j < nRangeY; j++)
  963. {
  964. // 去掉边角几个格子，保证视野是椭圆形
  965. if ((i * i + j * j) > nRangeX * nRangeX)
  966. continue;
  968. // 确定目标格子实际的REGION和坐标确定
  969. nRMx = nMapX + i;
  970. nRMy = nMapY + j;
  971. nSearchRegion = nRegion;
  972. if (nRMx < 0)
  973. {
  974. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[2];
  975. nRMx += SubWorld[nSubWorld].m_nRegionWidth;
  976. }
  977. else if (nRMx >= SubWorld[nSubWorld].m_nRegionWidth)
  978. {
  979. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[6];
  980. nRMx -= SubWorld[nSubWorld].m_nRegionWidth;
  981. }
  982. if (nSearchRegion == -1)
  983. continue;
  984. if (nRMy < 0)
  985. {
  986. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[4];
  987. nRMy += SubWorld[nSubWorld].m_nRegionHeight;
  988. }
  989. else if (nRMy >= SubWorld[nSubWorld].m_nRegionHeight)
  990. {
  991. nSearchRegion = SubWorld[nSubWorld].m_Region[nSearchRegion].m_nConnectRegion[0];
  992. nRMy -= SubWorld[nSubWorld].m_nRegionHeight;
  993. }
  994. if (nSearchRegion == -1)
  995. continue;
  996. // 从REGION的NPC列表中查找满足条件的NPC
  997. int nNpcIdx = SubWorld[nSubWorld].m_Region[nSearchRegion].FindNpc(nRMx, nRMy, m_nIndex, nRelation);
  998. if (nNpcIdx > 0)
  999. nRet++;
  1000. }
  1001. }
  1002. return nRet;
  1003. }
  1005. void KNpcAI::KeepAttackRange(int nEnemy, int nRange)
  1006. {
  1007. int nX1, nY1, nX2, nY2, nDir, nWantX, nWantY;
  1009. Npc[m_nIndex].GetMpsPos(&nX1, &nY1);
  1010. Npc[nEnemy].GetMpsPos(&nX2, &nY2);
  1011. nDir = g_GetDirIndex(nX1, nY1, nX2, nY2);
  1013. nWantX = nX2 - ((nRange * g_DirCos(nDir, 64)) >> 10);
  1014. nWantY = nY2 - ((nRange * g_DirSin(nDir, 64)) >> 10);
  1016. Npc[m_nIndex].SendCommand(do_walk, nWantX, nWantY);
  1017. }
  1019. void KNpcAI::FollowAttack(int i)
  1020. {
  1021. if ( Npc[i].m_RegionIndex < 0 )
  1022. return;
  1024. int distance = NpcSet.GetDistance(m_nIndex, i);
  1026. #define MINI_ATTACK_RANGE 32
  1028. if (distance <= MINI_ATTACK_RANGE)
  1029. {
  1030. KeepAttackRange(i, MINI_ATTACK_RANGE);
  1031. return;
  1032. }
  1033. // Attack Enemy
  1034. if (distance <= Npc[m_nIndex].m_CurrentAttackRadius && InEyeshot(i))
  1035. {
  1036. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, i);
  1037. return;
  1038. }
  1040. // Move to Enemy
  1041. int x, y;
  1042. Npc[i].GetMpsPos(&x, &y);
  1044. Npc[m_nIndex].SendCommand(do_walk, x, y);
  1045. }
  1047. BOOL KNpcAI::InEyeshot(int nIdx)
  1048. {
  1049. int distance = NpcSet.GetDistance(nIdx, m_nIndex);
  1051. return (Npc[m_nIndex].m_VisionRadius > distance);
  1052. }
  1054. void KNpcAI::CommonAction()
  1055. {
  1056. // 如果是对话类的NPC，就原地不动
  1057. if (Npc[m_nIndex].m_Kind == kind_dialoger)
  1058. {
  1059. Npc[m_nIndex].SendCommand(do_stand);
  1060. return;
  1061. }
  1062. int nOffX, nOffY;
  1063. if (g_RandPercent(80))
  1064. {
  1065. nOffX = 0;
  1066. nOffY = 0;
  1067. }
  1068. else
  1069. {
  1071. nOffX = g_Random(Npc[m_nIndex].m_CurrentActiveRadius / 2);
  1072. nOffY = g_Random(Npc[m_nIndex].m_CurrentActiveRadius / 2);
  1073. if (nOffX & 1)
  1074. {
  1075. nOffX = - nOffX;
  1076. }
  1077. if (nOffY & 1)
  1078. {
  1079. nOffY = - nOffY;
  1080. }
  1081. }
  1082. Npc[m_nIndex].SendCommand(do_walk, Npc[m_nIndex].m_OriginX + nOffX, Npc[m_nIndex].m_OriginY + nOffY);
  1083. }
  1085. BOOL KNpcAI::KeepActiveRange()
  1086. {
  1087. int x, y;
  1089. Npc[m_nIndex].GetMpsPos(&x, &y);
  1090. int nRange = g_GetDistance(Npc[m_nIndex].m_OriginX, Npc[m_nIndex].m_OriginY, x, y);
  1092. // 发现超出活动范围，把当前活动范围缩小，避免在活动范围边缘来回晃。
  1093. if (Npc[m_nIndex].m_ActiveRadius < nRange)
  1094. {
  1095. Npc[m_nIndex].m_CurrentActiveRadius = Npc[m_nIndex].m_ActiveRadius / 2;
  1096. }
  1098. // 发现超出当前活动范围，往回走
  1099. if (Npc[m_nIndex].m_CurrentActiveRadius < nRange)
  1100. {
  1101. Npc[m_nIndex].SendCommand(do_walk, Npc[m_nIndex].m_OriginX, Npc[m_nIndex].m_OriginY);
  1102. return TRUE;
  1103. }
  1104. else // 在当前活动范围内，恢复当前活动范围大小。
  1105. {
  1106. Npc[m_nIndex].m_CurrentActiveRadius = Npc[m_nIndex].m_ActiveRadius;
  1107. return FALSE;
  1108. }
  1109. }
  1111. #ifndef _SERVER
  1112. // 15/16 AiMode NPC的逃逸动作
  1113. int KNpcAI::DoShowFlee(int nIdx)
  1114. {
  1115. int nResult  = false;
  1116. int nRetCode = false;
  1118. int x1, y1, x2, y2;
  1119. int nDistance = Npc[m_nIndex].m_AiParam[6];
  1121. Npc[m_nIndex].GetMpsPos(&x1, &y1);
  1122. //Npc[nIdx].GetMpsPos(&x2, &y2);
  1123. Npc[m_nIndex].m_Dir = Npc[nIdx].m_Dir;
  1124. nRetCode = GetNpcMoveOffset(Npc[m_nIndex].m_Dir, nDistance, &x2, &y2);
  1125. if (!nRetCode)
  1126. goto Exit0;
  1127. Npc[m_nIndex].m_AiParam[4] = (int) nDistance / Npc[m_nIndex].m_WalkSpeed;
  1128. Npc[m_nIndex].m_AiParam[5] = 0;
  1129. Npc[m_nIndex].SendCommand(do_walk, x1 + x2, y1 + y2);
  1131. nResult = true;
  1132. Exit0:
  1133. return nResult;
  1134. }
  1136. #endif
  1138. // 逃离Npc[nIdx]
  1139. void KNpcAI::Flee(int nIdx)
  1140. {
  1141. int x1, y1, x2, y2;
  1143. Npc[m_nIndex].GetMpsPos(&x1, &y1);
  1144. Npc[nIdx].GetMpsPos(&x2, &y2);
  1146. x1 = x1 * 2 - x2;
  1147. y1 = y1 * 2 - y2;
  1149. Npc[m_nIndex].SendCommand(do_walk, x1, y1);
  1150. }
  1152. //------------------------------------------------------------------------------
  1153. // 功能：普通主动类1
  1154. // m_AiParam[0] 无敌人时候的巡逻概率
  1155. // m_AiParam[1、2、3、4] 四种技能的使用概率，分别对应SkillList里的技能1 2 3 4
  1156. // m_AiParam[5、6] 看见敌人但比较远时，待机、巡逻的概率
  1157. //------------------------------------------------------------------------------
  1158. void KNpcAI::ProcessAIType01()
  1159. {
  1160. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1161. // 是否已超过活动半径
  1162. if (KeepActiveRange())
  1163. return;
  1165. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1166. // 如果原本没有锁定敌人或者这个敌人跑太远，重新锁定敌人
  1167. if (nEnemyIdx <= 0 || Npc[nEnemyIdx].m_dwID <= 0 || !InEyeshot(nEnemyIdx) )
  1168. {
  1169. nEnemyIdx = GetNearestNpc(relation_enemy);
  1170. Npc[m_nIndex].m_nPeopleIdx = nEnemyIdx;
  1171. }
  1173. // 周围没有敌人，一定概率待机/巡逻
  1174. if (nEnemyIdx <= 0)
  1175. {
  1176. // pAIParam[0]:巡逻概率
  1177. if (pAIParam[0] > 0 && g_RandPercent(pAIParam[0]))
  1178. { // 巡逻
  1179. CommonAction();
  1180. }
  1181. return;
  1182. }
  1184. // 如果敌人在所有技能攻击范围之外，一定概率选择待机/巡逻/向敌人靠近
  1185. if (KNpcSet::GetDistanceSquare(m_nIndex, nEnemyIdx) > pAIParam[MAX_AI_PARAM - 1])
  1186. {
  1187. int nRand;
  1188. nRand = g_Random(100);
  1189. if (nRand < pAIParam[5]) // 待机
  1190. return;
  1191. if (nRand < pAIParam[5] + pAIParam[6]) // 巡逻
  1192. {
  1193. CommonAction();
  1194. return;
  1195. }
  1196. FollowAttack(nEnemyIdx); // 向敌人靠近
  1197. return;
  1198. }
  1200. // 敌人在最大技能攻击范围之内，选择一种技能攻击
  1201. int nRand;
  1202. nRand = g_Random(100);
  1203. if (nRand < pAIParam[1])
  1204. {
  1205. if (!Npc[m_nIndex].SetActiveSkill(1))
  1206. {
  1207. CommonAction();
  1208. return;
  1209. }
  1210. }
  1211. else if (nRand < pAIParam[1] + pAIParam[2])
  1212. {
  1213. if (!Npc[m_nIndex].SetActiveSkill(2))
  1214. {
  1215. CommonAction();
  1216. return;
  1217. }
  1218. }
  1219. else if (nRand < pAIParam[1] + pAIParam[2] + pAIParam[3])
  1220. {
  1221. if (!Npc[m_nIndex].SetActiveSkill(3))
  1222. {
  1223. CommonAction();
  1224. return;
  1225. }
  1226. }
  1227. else if (nRand < pAIParam[1] + pAIParam[2] + pAIParam[3] + pAIParam[4])
  1228. {
  1229. if (!Npc[m_nIndex].SetActiveSkill(4))
  1230. {
  1231. CommonAction();
  1232. return;
  1233. }
  1234. }
  1235. else // 待机
  1236. {
  1237. return;
  1238. }
  1240. FollowAttack(nEnemyIdx);
  1241. }
  1244. //------------------------------------------------------------------------------
  1245. // 功能：普通主动类2
  1246. // m_AiParam[0] 无敌人时候的巡逻概率
  1247. // m_AiParam[1] 剩余生命低于这个百分比的时候执行相应处理
  1248. // m_AiParam[2] 在m_AiParam[1]的情况出现的时候是否执行相应处理的概率
  1249. // m_AiParam[3] 在m_AiParam[1]的情况出现并决定要执行相应处理，使用回复技能的概率 对应SkillList里面的技能 1
  1250. // m_AiParam[4、5、6] 三种攻击技能的使用概率，分别对应SkillList里的技能 2 3 4
  1251. // m_AiParam[7、8] 看见敌人但比较远时，待机、巡逻的概率
  1252. //------------------------------------------------------------------------------
  1253. void KNpcAI::ProcessAIType02()
  1254. {
  1255. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1256. // 是否已超过活动半径
  1257. if (KeepActiveRange())
  1258. return;
  1260. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1261. // 如果原本没有锁定敌人或者这个敌人跑太远，重新锁定敌人
  1262. if (nEnemyIdx <= 0 || Npc[nEnemyIdx].m_dwID <= 0 || !InEyeshot(nEnemyIdx) )
  1263. {
  1264. nEnemyIdx = GetNearestNpc(relation_enemy);
  1265. Npc[m_nIndex].m_nPeopleIdx = nEnemyIdx;
  1266. }
  1268. // 周围没有敌人，一定概率待机/巡逻
  1269. if (nEnemyIdx <= 0)
  1270. {
  1271. // pAIParam[0]:巡逻概率
  1272. if (pAIParam[0] > 0 && g_RandPercent(pAIParam[0]))
  1273. { // 巡逻
  1274. CommonAction();
  1275. }
  1276. return;
  1277. }
  1279. // 检测剩余生命是否符合条件，生命太少一定概率使用补血技能或逃跑
  1280. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[1])
  1281. {
  1282. if (g_RandPercent(pAIParam[2])) // 是否使用补血技能或逃跑
  1283. {
  1284. if (Npc[m_nIndex].m_AiAddLifeTime < pAIParam[9] && g_RandPercent(pAIParam[3])) // 使用补血技能
  1285. {
  1286. Npc[m_nIndex].SetActiveSkill(1);
  1287. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, m_nIndex);
  1288. Npc[m_nIndex].m_AiAddLifeTime++;
  1289. return;
  1290. }
  1291. else // 逃跑
  1292. {
  1293. Flee(nEnemyIdx);
  1294. return;
  1295. }
  1296. }
  1297. }
  1299. // 如果敌人在所有技能攻击范围之外，一定概率选择待机/巡逻/向敌人靠近
  1300. if (KNpcSet::GetDistanceSquare(m_nIndex, nEnemyIdx) > pAIParam[MAX_AI_PARAM - 1])
  1301. {
  1302. int nRand;
  1303. nRand = g_Random(100);
  1304. if (nRand < pAIParam[7]) // 待机
  1305. return;
  1306. if (nRand < pAIParam[7] + pAIParam[8]) // 巡逻
  1307. {
  1308. CommonAction();
  1309. return;
  1310. }
  1311. FollowAttack(nEnemyIdx); // 向敌人靠近
  1312. return;
  1313. }
  1315. // 敌人在最大技能攻击范围之内，选择一种技能攻击
  1316. int nRand;
  1317. nRand = g_Random(100);
  1318. if (nRand < pAIParam[4])
  1319. {
  1320. if (!Npc[m_nIndex].SetActiveSkill(2))
  1321. {
  1322. CommonAction();
  1323. return;
  1324. }
  1325. }
  1326. else if (nRand < pAIParam[4] + pAIParam[5])
  1327. {
  1328. if (!Npc[m_nIndex].SetActiveSkill(3))
  1329. {
  1330. CommonAction();
  1331. return;
  1332. }
  1333. }
  1334. else if (nRand < pAIParam[4] + pAIParam[5] + pAIParam[6])
  1335. {
  1336. if (!Npc[m_nIndex].SetActiveSkill(4))
  1337. {
  1338. CommonAction();
  1339. return;
  1340. }
  1341. }
  1342. else // 待机
  1343. {
  1344. return;
  1345. }
  1346. FollowAttack(nEnemyIdx);
  1347. }
  1349. //------------------------------------------------------------------------------
  1350. // 功能：普通主动类3
  1351. // m_AiParam[0] 无敌人时候的巡逻概率
  1352. // m_AiParam[1] 剩余生命低于这个百分比的时候执行相应处理
  1353. // m_AiParam[2] 在m_AiParam[1]的情况出现的时候是否执行相应处理的概率
  1354. // m_AiParam[3] 在m_AiParam[1]的情况出现并决定要执行相应处理，使用攻击技能的概率 对应SkillList里面的技能 1
  1355. // m_AiParam[4、5、6] 三种攻击技能的使用概率，分别对应SkillList里的技能 2 3 4
  1356. // m_AiParam[7、8] 看见敌人但比较远时，待机、巡逻的概率
  1357. //------------------------------------------------------------------------------
  1358. void KNpcAI::ProcessAIType03()
  1359. {
  1360. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1361. // 是否已超过活动半径
  1362. if (KeepActiveRange())
  1363. return;
  1365. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1366. // 如果原本没有锁定敌人或者这个敌人跑太远，重新锁定敌人
  1367. if (nEnemyIdx <= 0 || Npc[nEnemyIdx].m_dwID <= 0 || !InEyeshot(nEnemyIdx) )
  1368. {
  1369. nEnemyIdx = GetNearestNpc(relation_enemy);
  1370. Npc[m_nIndex].m_nPeopleIdx = nEnemyIdx;
  1371. }
  1373. // 周围没有敌人，一定概率待机/巡逻
  1374. if (nEnemyIdx <= 0)
  1375. {
  1376. // pAIParam[0]:巡逻概率
  1377. if (pAIParam[0] > 0 && g_RandPercent(pAIParam[0]))
  1378. { // 巡逻
  1379. CommonAction();
  1380. }
  1381. return;
  1382. }
  1384. // 检测剩余生命是否符合条件，生命太少一定概率使用攻击技能或逃跑
  1385. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[1])
  1386. {
  1387. if (g_RandPercent(pAIParam[2])) // 是否使用攻击技能或逃跑
  1388. {
  1389. if (g_RandPercent(pAIParam[3])) // 使用攻击技能
  1390. {
  1391. Npc[m_nIndex].SetActiveSkill(1);
  1392. FollowAttack(nEnemyIdx);
  1393. return;
  1394. }
  1395. else // 逃跑
  1396. {
  1397. Flee(nEnemyIdx);
  1398. return;
  1399. }
  1400. }
  1401. }
  1403. // 如果敌人在所有技能攻击范围之外，一定概率选择待机/巡逻/向敌人靠近
  1404. if (KNpcSet::GetDistanceSquare(m_nIndex, nEnemyIdx) > pAIParam[MAX_AI_PARAM - 1])
  1405. {
  1406. int nRand;
  1407. nRand = g_Random(100);
  1408. if (nRand < pAIParam[7]) // 待机
  1409. return;
  1410. if (nRand < pAIParam[7] + pAIParam[8]) // 巡逻
  1411. {
  1412. CommonAction();
  1413. return;
  1414. }
  1415. FollowAttack(nEnemyIdx); // 向敌人靠近
  1416. return;
  1417. }
  1419. // 敌人在最大技能攻击范围之内，选择一种技能攻击
  1420. int nRand;
  1421. nRand = g_Random(100);
  1422. if (nRand < pAIParam[4])
  1423. {
  1424. if (!Npc[m_nIndex].SetActiveSkill(2))
  1425. {
  1426. CommonAction();
  1427. return;
  1428. }
  1429. }
  1430. else if (nRand < pAIParam[4] + pAIParam[5])
  1431. {
  1432. if (!Npc[m_nIndex].SetActiveSkill(3))
  1433. {
  1434. CommonAction();
  1435. return;
  1436. }
  1437. }
  1438. else if (nRand < pAIParam[4] + pAIParam[5] + pAIParam[6])
  1439. {
  1440. if (!Npc[m_nIndex].SetActiveSkill(4))
  1441. {
  1442. CommonAction();
  1443. return;
  1444. }
  1445. }
  1446. else // 待机
  1447. {
  1448. return;
  1449. }
  1450. FollowAttack(nEnemyIdx);
  1451. }
  1453. //------------------------------------------------------------------------------
  1454. // 功能：普通被动类1
  1455. // m_AiParam[0] 无敌人时候的巡逻概率
  1456. // m_AiParam[1、2、3、4] 四种攻击技能的使用概率，分别对应SkillList里的技能 1 2 3 4
  1457. // m_AiParam[5、6] 看见敌人但比较远时，待机、巡逻的概率
  1458. //------------------------------------------------------------------------------
  1459. void KNpcAI::ProcessAIType04()
  1460. {
  1461. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1463. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1464. // 是否受到攻击，否，一定概率选择待机/巡逻
  1465. if (nEnemyIdx <= 0)
  1466. {
  1467. // pAIParam[0]:巡逻概率
  1468. if (pAIParam[0] > 0 && g_RandPercent(pAIParam[0]))
  1469. { // 巡逻
  1470. CommonAction();
  1471. }
  1472. return;
  1473. }
  1475. // 是否已超过活动半径
  1476. if (KeepActiveRange())
  1477. return;
  1479. // 如果敌人在所有技能攻击范围之外，一定概率选择待机/巡逻/向敌人靠近
  1480. if (KNpcSet::GetDistanceSquare(m_nIndex, nEnemyIdx) > pAIParam[MAX_AI_PARAM - 1])
  1481. {
  1482. int nRand;
  1483. nRand = g_Random(100);
  1484. if (nRand < pAIParam[5]) // 待机
  1485. return;
  1486. if (nRand < pAIParam[5] + pAIParam[6]) // 巡逻
  1487. {
  1488. CommonAction();
  1489. return;
  1490. }
  1491. FollowAttack(nEnemyIdx); // 向敌人靠近
  1492. return;
  1493. }
  1495. // 敌人在最大技能攻击范围之内，选择一种技能攻击
  1496. int nRand;
  1497. nRand = g_Random(100);
  1498. if (nRand < pAIParam[1])
  1499. {
  1500. if (!Npc[m_nIndex].SetActiveSkill(1))
  1501. {
  1502. CommonAction();
  1503. return;
  1504. }
  1505. }
  1506. else if (nRand < pAIParam[1] + pAIParam[2])
  1507. {
  1508. if (!Npc[m_nIndex].SetActiveSkill(2))
  1509. {
  1510. CommonAction();
  1511. return;
  1512. }
  1513. }
  1514. else if (nRand < pAIParam[1] + pAIParam[2] + pAIParam[3])
  1515. {
  1516. if (!Npc[m_nIndex].SetActiveSkill(3))
  1517. {
  1518. CommonAction();
  1519. return;
  1520. }
  1521. }
  1522. else if (nRand < pAIParam[1] + pAIParam[2] + pAIParam[3] + pAIParam[4])
  1523. {
  1524. if (!Npc[m_nIndex].SetActiveSkill(4))
  1525. {
  1526. CommonAction();
  1527. return;
  1528. }
  1529. }
  1530. else // 待机
  1531. {
  1532. return;
  1533. }
  1534. FollowAttack(nEnemyIdx);
  1535. }
  1537. //------------------------------------------------------------------------------
  1538. // 功能：普通被动类2
  1539. // m_AiParam[0] 无敌人时候的巡逻概率
  1540. // m_AiParam[1] 剩余生命低于这个百分比的时候执行相应处理
  1541. // m_AiParam[2] 在m_AiParam[1]的情况出现的时候是否执行相应处理的概率
  1542. // m_AiParam[3] 在m_AiParam[1]的情况出现并决定要执行相应处理，使用回复技能的概率 对应SkillList里面的技能 1
  1543. // m_AiParam[4、5、6] 三种攻击技能的使用概率，分别对应SkillList里的技能 2 3 4
  1544. // m_AiParam[7、8] 看见敌人但比较远时，待机、巡逻的概率
  1545. //------------------------------------------------------------------------------
  1546. void KNpcAI::ProcessAIType05()
  1547. {
  1548. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1550. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1551. // 是否受到攻击，否，一定概率选择待机/巡逻
  1552. if (nEnemyIdx <= 0)
  1553. {
  1554. // pAIParam[0]:巡逻概率
  1555. if (pAIParam[0] > 0 && g_RandPercent(pAIParam[0]))
  1556. { // 巡逻
  1557. CommonAction();
  1558. }
  1559. return;
  1560. }
  1562. // 是否已超过活动半径
  1563. if (KeepActiveRange())
  1564. return;
  1566. // 检测剩余生命是否符合条件，生命太少一定概率使用补血技能或逃跑
  1567. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[1])
  1568. {
  1569. if (g_RandPercent(pAIParam[2])) // 是否使用补血技能或逃跑
  1570. {
  1571. if (Npc[m_nIndex].m_AiAddLifeTime < pAIParam[9] && g_RandPercent(pAIParam[3])) // 使用补血技能
  1572. {
  1573. Npc[m_nIndex].m_AiAddLifeTime++;
  1574. Npc[m_nIndex].SetActiveSkill(1);
  1575. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, m_nIndex);
  1576. return;
  1577. }
  1578. else // 逃跑
  1579. {
  1580. Flee(nEnemyIdx);
  1581. return;
  1582. }
  1583. }
  1584. }
  1586. // 如果敌人在所有技能攻击范围之外，一定概率选择待机/巡逻/向敌人靠近
  1587. if (KNpcSet::GetDistanceSquare(m_nIndex, nEnemyIdx) > pAIParam[MAX_AI_PARAM - 1])
  1588. {
  1589. int nRand;
  1590. nRand = g_Random(100);
  1591. if (nRand < pAIParam[7]) // 待机
  1592. return;
  1593. if (nRand < pAIParam[7] + pAIParam[8]) // 巡逻
  1594. {
  1595. CommonAction();
  1596. return;
  1597. }
  1598. FollowAttack(nEnemyIdx); // 向敌人靠近
  1599. return;
  1600. }
  1602. // 敌人在最大技能攻击范围之内，选择一种技能攻击
  1603. int nRand;
  1604. nRand = g_Random(100);
  1605. if (nRand < pAIParam[4])
  1606. {
  1607. if (!Npc[m_nIndex].SetActiveSkill(2))
  1608. {
  1609. CommonAction();
  1610. return;
  1611. }
  1612. }
  1613. else if (nRand < pAIParam[4] + pAIParam[5])
  1614. {
  1615. if (!Npc[m_nIndex].SetActiveSkill(3))
  1616. {
  1617. CommonAction();
  1618. return;
  1619. }
  1620. }
  1621. else if (nRand < pAIParam[4] + pAIParam[5] + pAIParam[6])
  1622. {
  1623. if (!Npc[m_nIndex].SetActiveSkill(4))
  1624. {
  1625. CommonAction();
  1626. return;
  1627. }
  1628. }
  1629. else // 待机
  1630. {
  1631. return;
  1632. }
  1633. FollowAttack(nEnemyIdx);
  1634. }
  1636. //------------------------------------------------------------------------------
  1637. // 功能：普通被动类3
  1638. // m_AiParam[0] 无敌人时候的巡逻概率
  1639. // m_AiParam[1] 剩余生命低于这个百分比的时候执行相应处理
  1640. // m_AiParam[2] 在m_AiParam[1]的情况出现的时候是否执行相应处理的概率
  1641. // m_AiParam[3] 在m_AiParam[1]的情况出现并决定要执行相应处理，使用攻击技能的概率 对应SkillList里面的技能 1
  1642. // m_AiParam[4、5、6] 三种攻击技能的使用概率，分别对应SkillList里的技能 2 3 4
  1643. // m_AiParam[7、8] 看见敌人但比较远时，待机、巡逻的概率
  1644. //------------------------------------------------------------------------------
  1645. void KNpcAI::ProcessAIType06()
  1646. {
  1647. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1649. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1650. // 是否受到攻击，否，一定概率选择待机/巡逻
  1651. if (nEnemyIdx <= 0)
  1652. {
  1653. // pAIParam[0]:巡逻概率
  1654. if (pAIParam[0] > 0 && g_RandPercent(pAIParam[0]))
  1655. { // 巡逻
  1656. CommonAction();
  1657. }
  1658. return;
  1659. }
  1661. // 是否已超过活动半径
  1662. if (KeepActiveRange())
  1663. return;
  1665. // 检测剩余生命是否符合条件，生命太少一定概率使用攻击技能或逃跑
  1666. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[1])
  1667. {
  1668. if (g_RandPercent(pAIParam[2])) // 是否使用攻击技能或逃跑
  1669. {
  1670. if (g_RandPercent(pAIParam[3])) // 使用攻击技能
  1671. {
  1672. Npc[m_nIndex].SetActiveSkill(1);
  1673. FollowAttack(nEnemyIdx); // 向敌人靠近
  1674. return;
  1675. }
  1676. else // 逃跑
  1677. {
  1678. Flee(nEnemyIdx);
  1679. return;
  1680. }
  1681. }
  1682. }
  1684. // 如果敌人在所有技能攻击范围之外，一定概率选择待机/巡逻/向敌人靠近
  1685. if (KNpcSet::GetDistanceSquare(m_nIndex, nEnemyIdx) > pAIParam[MAX_AI_PARAM - 1])
  1686. {
  1687. int nRand;
  1688. nRand = g_Random(100);
  1689. if (nRand < pAIParam[7]) // 待机
  1690. return;
  1691. if (nRand < pAIParam[7] + pAIParam[8]) // 巡逻
  1692. {
  1693. CommonAction();
  1694. return;
  1695. }
  1696. FollowAttack(nEnemyIdx); // 向敌人靠近
  1697. return;
  1698. }
  1700. // 敌人在最大技能攻击范围之内，选择一种技能攻击
  1701. int nRand;
  1702. nRand = g_Random(100);
  1703. if (nRand < pAIParam[4])
  1704. {
  1705. if (!Npc[m_nIndex].SetActiveSkill(2))
  1706. {
  1707. CommonAction();
  1708. return;
  1709. }
  1710. }
  1711. else if (nRand < pAIParam[4] + pAIParam[5])
  1712. {
  1713. if (!Npc[m_nIndex].SetActiveSkill(3))
  1714. {
  1715. CommonAction();
  1716. return;
  1717. }
  1718. }
  1719. else if (nRand < pAIParam[4] + pAIParam[5] + pAIParam[6])
  1720. {
  1721. if (!Npc[m_nIndex].SetActiveSkill(4))
  1722. {
  1723. CommonAction();
  1724. return;
  1725. }
  1726. }
  1727. else // 待机
  1728. {
  1729. return;
  1730. }
  1731. FollowAttack(nEnemyIdx);
  1732. }
  1734. /*
  1735. // 一般主动型
  1736. void KNpcAI::ProcessAIType1()
  1737. {
  1738. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1739. // 是否已超过活动半径
  1740. if (KeepActiveRange())
  1741. return;
  1743. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[0])
  1744. {
  1745. if (g_RandPercent(pAIParam[1]))
  1746. {
  1747. Npc[m_nIndex].SetActiveSkill(1);
  1748. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, m_nIndex);
  1749. return;
  1750. }
  1751. }
  1753. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1755. if (nEnemyIdx <= 0 || Npc[nEnemyIdx].m_dwID <= 0 || !InEyeshot(nEnemyIdx) )
  1756. {
  1757. nEnemyIdx = GetNearestNpc(relation_enemy);
  1758. Npc[m_nIndex].m_nPeopleIdx = nEnemyIdx;
  1759. }
  1763. if (nEnemyIdx > 0)
  1764. {
  1765. int nRand;
  1766. nRand = g_Random(100);
  1767. if (nRand < pAIParam[2])
  1768. {
  1769. if (!Npc[m_nIndex].SetActiveSkill(2))
  1770. {
  1771. CommonAction();
  1772. return;
  1773. }
  1774. }
  1775. else if (nRand < pAIParam[2] + pAIParam[3])
  1776. {
  1777. if (!Npc[m_nIndex].SetActiveSkill(3))
  1778. {
  1779. CommonAction();
  1780. return;
  1781. }
  1782. }
  1783. else if (nRand < pAIParam[2] + pAIParam[3] + pAIParam[4])
  1784. {
  1785. if (!Npc[m_nIndex].SetActiveSkill(4))
  1786. {
  1787. CommonAction();
  1788. return;
  1789. }
  1790. }
  1792. // if (g_RandPercent(pAIParam[2]))
  1793. // {
  1794. // Npc[m_nIndex].SetActiveSkill(2);
  1795. // }
  1796. // else if (g_RandPercent(pAIParam[3]))
  1797. // {
  1798. // Npc[m_nIndex].SetActiveSkill(3);
  1799. // }
  1800. // else if (g_RandPercent(pAIParam[4]))
  1801. // {
  1802. // Npc[m_nIndex].SetActiveSkill(4);
  1803. // }
  1804. else
  1805. {
  1806. CommonAction();
  1807. return;
  1808. }
  1809. FollowAttack(nEnemyIdx);
  1810. return;
  1811. }
  1812. CommonAction();
  1813. }
  1814. */
  1816. /*
  1817. // 一般被动型
  1818. void KNpcAI::ProcessAIType2()
  1819. {
  1820. int *pAIParam = Npc[m_nIndex].m_AiParam;
  1822. if (KeepActiveRange())
  1823. return;
  1825. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[0])
  1826. {
  1827. if (g_RandPercent(pAIParam[1]))
  1828. {
  1829. Npc[m_nIndex].SetActiveSkill(1);
  1830. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, m_nIndex);
  1831. return;
  1832. }
  1833. }
  1835. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1836. if (nEnemyIdx <= 0 || !InEyeshot(nEnemyIdx))
  1837. return;
  1839. int nRand;
  1840. nRand = g_Random(100);
  1842. if (nRand < pAIParam[2])
  1843. {
  1844. if (!Npc[m_nIndex].SetActiveSkill(2))
  1845. {
  1846. CommonAction();
  1847. return;
  1848. }
  1849. }
  1850. else if (nRand < pAIParam[2] + pAIParam[3])
  1851. {
  1852. if (!Npc[m_nIndex].SetActiveSkill(3))
  1853. {
  1854. CommonAction();
  1855. return;
  1856. }
  1857. }
  1858. else if (nRand < pAIParam[2] + pAIParam[3] + pAIParam[4])
  1859. {
  1860. if (!Npc[m_nIndex].SetActiveSkill(4))
  1861. {
  1862. CommonAction();
  1863. return;
  1864. }
  1865. }
  1867. // if (g_RandPercent(pAIParam[2]))
  1868. // {
  1869. // Npc[m_nIndex].SetActiveSkill(2);
  1870. // }
  1871. // else if (g_RandPercent(pAIParam[3]))
  1872. // {
  1873. // Npc[m_nIndex].SetActiveSkill(3);
  1874. // }
  1875. // else if (g_RandPercent(pAIParam[4]))
  1876. // {
  1877. // Npc[m_nIndex].SetActiveSkill(4);
  1878. // }
  1879. else
  1880. {
  1881. CommonAction();
  1882. return;
  1883. }
  1884. FollowAttack(nEnemyIdx);
  1886. return;
  1887. }
  1888. */
  1890. /*
  1891. // 一般逃跑型
  1892. void KNpcAI::ProcessAIType3()
  1893. {
  1894. int* pAIParam = Npc[m_nIndex].m_AiParam;
  1896. if (KeepActiveRange())
  1897. return;
  1899. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1901. if (nEnemyIdx <= 0 || !InEyeshot(nEnemyIdx))
  1902. {
  1903. nEnemyIdx = GetNearestNpc(relation_enemy);
  1904. Npc[m_nIndex].m_nPeopleIdx = nEnemyIdx;
  1905. }
  1907. if (nEnemyIdx <= 0)
  1908. {
  1909. CommonAction();
  1910. return;
  1911. }
  1913. if (Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[0])
  1914. {
  1915. if (g_RandPercent(pAIParam[1]))
  1916. {
  1917. Flee(nEnemyIdx);
  1918. return;
  1919. }
  1920. }
  1922. int nRand;
  1923. nRand = g_Random(100);
  1925. if (nRand < pAIParam[2])
  1926. {
  1927. if (!Npc[m_nIndex].SetActiveSkill(1))
  1928. {
  1929. CommonAction();
  1930. return;
  1931. }
  1932. }
  1933. else if (nRand < pAIParam[2] + pAIParam[3])
  1934. {
  1935. if (!Npc[m_nIndex].SetActiveSkill(2))
  1936. {
  1937. CommonAction();
  1938. return;
  1939. }
  1940. }
  1941. else if (nRand < pAIParam[2] + pAIParam[3] + pAIParam[4])
  1942. {
  1943. if (!Npc[m_nIndex].SetActiveSkill(3))
  1944. {
  1945. CommonAction();
  1946. return;
  1947. }
  1948. }
  1950. // if (g_RandPercent(pAIParam[2]))
  1951. /// {
  1952. // Npc[m_nIndex].SetActiveSkill(1);
  1953. // }
  1954. // else if (g_RandPercent(pAIParam[3]))
  1955. // {
  1956. // Npc[m_nIndex].SetActiveSkill(2);
  1957. // }
  1958. // else if (g_RandPercent(pAIParam[4]))
  1959. // {
  1960. // Npc[m_nIndex].SetActiveSkill(3);
  1961. // }
  1962. else
  1963. {
  1964. CommonAction();
  1965. return;
  1966. }
  1967. FollowAttack(nEnemyIdx);
  1968. return;
  1969. }
  1970. */
  1972. /*
  1973. // 逃跑加强型
  1974. void KNpcAI::ProcessAIType4()
  1975. {
  1976. int* pAIParam = Npc[m_nIndex].m_AiParam;
  1978. if (KeepActiveRange())
  1979. return;
  1981. int nEnemyIdx = Npc[m_nIndex].m_nPeopleIdx;
  1983. if (nEnemyIdx <= 0 || !InEyeshot(nEnemyIdx))
  1984. {
  1985. nEnemyIdx = GetNearestNpc(relation_enemy);
  1986. Npc[m_nIndex].m_nPeopleIdx = nEnemyIdx;
  1987. }
  1989. if (nEnemyIdx <= 0)
  1990. {
  1991. CommonAction();
  1992. return;
  1993. }
  1995. int nLifePercent = Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax;
  1996. if (nLifePercent < pAIParam[0])
  1997. {
  1998. if (g_RandPercent(pAIParam[1]))
  1999. {
  2000. Flee(nEnemyIdx);
  2001. return;
  2002. }
  2003. }
  2004. if (nLifePercent < pAIParam[2])
  2005. {
  2006. if (g_RandPercent(pAIParam[3]))
  2007. {
  2008. Npc[m_nIndex].SetActiveSkill(1);
  2009. Npc[m_nIndex].SendCommand(do_skill, Npc[m_nIndex].m_ActiveSkillID, -1, m_nIndex);
  2010. return;
  2011. }
  2012. }
  2014. if (g_RandPercent(pAIParam[4]))
  2015. {
  2016. Npc[m_nIndex].SetActiveSkill(2);
  2017. }
  2018. else if (g_RandPercent(pAIParam[5]))
  2019. {
  2020. Npc[m_nIndex].SetActiveSkill(3);
  2021. }
  2022. else
  2023. {
  2024. CommonAction();
  2025. return;
  2026. }
  2027. FollowAttack(nEnemyIdx);
  2028. return;
  2029. }
  2030. */
  2032. /*
  2033. // 人多就跑型
  2034. void KNpcAI::ProcessAIType5()
  2035. {
  2036. int *pAIParam = Npc[m_nIndex].m_AiParam;
  2038. if (KeepActiveRange())
  2039. return;
  2041. int i = Npc[m_nIndex].m_nPeopleIdx;
  2043. if (!i || !InEyeshot(i))
  2044. {
  2045. i = GetNearestNpc(relation_enemy);
  2046. Npc[m_nIndex].m_nPeopleIdx = i;
  2047. }
  2049. if (!i)
  2050. {
  2051. CommonAction();
  2052. return;
  2053. }
  2055. int nEnemyNumber = GetNpcNumber(relation_enemy);
  2056. if (nEnemyNumber > pAIParam[0])
  2057. {
  2058. if (g_RandPercent(pAIParam[1]))
  2059. {
  2060. Flee(i);
  2061. return;
  2062. }
  2063. }
  2065. if (g_RandPercent(pAIParam[2]))
  2066. {
  2067. Npc[m_nIndex].SetActiveSkill(1);
  2068. }
  2069. else if (nEnemyNumber <= pAIParam[3] && g_RandPercent(pAIParam[4]))
  2070. {
  2071. Npc[m_nIndex].SetActiveSkill(2);
  2072. }
  2073. else
  2074. {
  2075. CommonAction();
  2076. return;
  2077. }
  2079. FollowAttack(i);
  2080. return;
  2081. }
  2082. */
  2084. /*
  2085. // 成群结队型
  2086. void KNpcAI::ProcessAIType6()
  2087. {
  2088. int *pAIParam = Npc[m_nIndex].m_AiParam;
  2090. if (KeepActiveRange())
  2091. return;
  2093. int i = Npc[m_nIndex].m_nPeopleIdx;
  2094. if (!i || !InEyeshot(i))
  2095. {
  2096. i = GetNearestNpc(relation_enemy);
  2097. Npc[m_nIndex].m_nPeopleIdx = i;
  2098. }
  2100. if (!i)
  2101. {
  2102. CommonAction();
  2103. return;
  2104. }
  2106. int nAllyNumber = GetNpcNumber(relation_none);
  2107. if (nAllyNumber <= pAIParam[0])
  2108. {
  2109. if (g_RandPercent(pAIParam[1]))
  2110. {
  2111. Flee(i);
  2112. return;
  2113. }
  2114. }
  2116. if (g_RandPercent(pAIParam[2]))
  2117. {
  2118. Npc[m_nIndex].SetActiveSkill(1);
  2119. }
  2120. else if (nAllyNumber > pAIParam[3] && g_RandPercent(pAIParam[4]))
  2121. {
  2122. Npc[m_nIndex].SetActiveSkill(2);
  2123. }
  2124. else
  2125. {
  2126. CommonAction();
  2127. return;
  2128. }
  2130. FollowAttack(i);
  2131. return;
  2132. }
  2133. */
  2135. /*
  2136. // 挨打聚堆型
  2137. void KNpcAI::ProcessAIType7()
  2138. {
  2139. int *pAIParam = Npc[m_nIndex].m_AiParam;
  2141. if (KeepActiveRange())
  2142. return;
  2144. int i = Npc[m_nIndex].m_nPeopleIdx;
  2145. if (!i || !InEyeshot(i))
  2146. {
  2147. i = GetNearestNpc(relation_enemy);
  2148. Npc[m_nIndex].m_nPeopleIdx = i;
  2149. }
  2151. if (!i)
  2152. {
  2153. CommonAction();
  2154. return;
  2155. }
  2157. int j = GetNearestNpc(relation_ally);
  2159. if (j && Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax < pAIParam[0])
  2160. {
  2161. if (g_RandPercent(pAIParam[1]))
  2162. {
  2163. int x, y;
  2164. Npc[j].GetMpsPos(&x, &y);
  2165. Npc[m_nIndex].SendCommand(do_walk, x, y);
  2166. return;
  2167. }
  2168. }
  2170. if (g_RandPercent(pAIParam[2]))
  2171. {
  2172. Npc[m_nIndex].SetActiveSkill(1);
  2173. }
  2174. else if (g_RandPercent(pAIParam[3]))
  2175. {
  2176. Npc[m_nIndex].SetActiveSkill(2);
  2177. }
  2178. else if (g_RandPercent(pAIParam[4]))
  2179. {
  2180. Npc[m_nIndex].SetActiveSkill(3);
  2181. }
  2182. else
  2183. {
  2184. CommonAction();
  2185. return;
  2186. }
  2187. FollowAttack(i);
  2188. return;
  2189. }
  2190. */
  2192. /*
  2193. // 主动送死型
  2194. void KNpcAI::ProcessAIType8()
  2195. {
  2196. int *pAIParam = Npc[m_nIndex].m_AiParam;
  2198. if (KeepActiveRange())
  2199. return;
  2201. int i = Npc[m_nIndex].m_nPeopleIdx;
  2203. if (!i || !InEyeshot(i))
  2204. {
  2205. i = GetNearestNpc(relation_enemy);
  2206. Npc[m_nIndex].m_nPeopleIdx = i;
  2207. }
  2209. if (!i)
  2210. {
  2211. CommonAction();
  2212. return;
  2213. }
  2215. if (g_RandPercent(pAIParam[0]))
  2216. {
  2217. int x, y;
  2219. Npc[i].GetMpsPos(&x, &y);
  2220. Npc[m_nIndex].SendCommand(do_walk, x, y);
  2221. }
  2222. else if (g_RandPercent(pAIParam[1]))
  2223. {
  2224. Npc[m_nIndex].SetActiveSkill(1);
  2225. }
  2226. else if (g_RandPercent(pAIParam[2]))
  2227. {
  2228. Npc[m_nIndex].SetActiveSkill(2);
  2229. }
  2230. else if (g_RandPercent(pAIParam[3]))
  2231. {
  2232. Npc[m_nIndex].SetActiveSkill(3);
  2233. }
  2234. else
  2235. {
  2236. CommonAction();
  2237. return;
  2238. }
  2239. FollowAttack(i);
  2240. return;
  2241. }
  2242. */
  2244. /*
  2245. // 越战越勇型
  2246. void KNpcAI::ProcessAIType9()
  2247. {
  2248. int *pAIParam = Npc[m_nIndex].m_AiParam;
  2250. if (KeepActiveRange())
  2251. return;
  2253. int i = Npc[m_nIndex].m_nPeopleIdx;
  2255. if (!i || !InEyeshot(i))
  2256. {
  2257. i = GetNearestNpc(relation_enemy);
  2258. Npc[m_nIndex].m_nPeopleIdx = i;
  2259. }
  2261. if (!i)
  2262. {
  2263. CommonAction();
  2264. return;
  2265. }
  2267. int nLifePercent = Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax;
  2269. if (g_RandPercent(pAIParam[0]))
  2270. {
  2271. Npc[m_nIndex].SetActiveSkill(1);
  2272. }
  2273. else if (nLifePercent < pAIParam[1] && g_RandPercent(pAIParam[2]))
  2274. {
  2275. Npc[m_nIndex].SetActiveSkill(2);
  2276. }
  2277. else if (nLifePercent < pAIParam[3] && g_RandPercent(pAIParam[4]))
  2278. {
  2279. Npc[m_nIndex].SetActiveSkill(3);
  2280. }
  2281. else
  2282. {
  2283. CommonAction();
  2284. return;
  2285. }
  2286. FollowAttack(i);
  2287. return;
  2288. }
  2289. */
  2291. /*
  2292. // 逃跑不掉型
  2293. void KNpcAI::ProcessAIType10()
  2294. {
  2295. int *pAIParam = Npc[m_nIndex].m_AiParam;
  2297. if (KeepActiveRange())
  2298. return;
  2300. int i = Npc[m_nIndex].m_nPeopleIdx;
  2302. if (!i || !InEyeshot(i))
  2303. {
  2304. i = GetNearestNpc(relation_enemy);
  2305. Npc[m_nIndex].m_nPeopleIdx = i;
  2306. }
  2308. if (!i)
  2309. {
  2310. CommonAction();
  2311. return;
  2312. }
  2314. int nLifePercent = Npc[m_nIndex].m_CurrentLife * 100 / Npc[m_nIndex].m_CurrentLifeMax;
  2316. if (nLifePercent < pAIParam[0] && g_RandPercent(pAIParam[1]))
  2317. {
  2318. Npc[m_nIndex].SetActiveSkill(1);
  2319. }
  2320. else if (nLifePercent < pAIParam[2] && g_RandPercent(pAIParam[3]))
  2321. {
  2322. Npc[m_nIndex].SetActiveSkill(2);
  2323. }
  2324. else if (nLifePercent < pAIParam[4] && g_RandPercent(pAIParam[5]))
  2325. {
  2326. Flee(i);
  2327. return;
  2328. }
  2329. else
  2330. {
  2331. CommonAction();
  2332. return;
  2333. }
  2335. FollowAttack(i);
  2336. return;
  2337. }
  2338. */