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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
ROAAi.cpp
资源名称：ROA3.40.rar　[点击查看]
上传用户：tianheyiqi
上传日期：2010-04-16
资源大小：282k
文件大小：21k
源码类别：

外挂编程

开发平台：

Visual C++

ROAAi.cpp：源码内容
  1. #include <stdafx.h>
  3. #include "ROA.h"
  4. #include "ROAUtils.h"
  6. AICOMMANDQUEUE::AICOMMANDQUEUE()
  7. {
  8. priority = eAiPriMax;
  9. dwTarget = 0xFFFFFFFF;
  10. }
  12. AICOMMANDQUEUE::~AICOMMANDQUEUE()
  13. {
  15. }
  17. BOOL AICOMMANDQUEUE::update(AICOMMAND command)
  18. {
  19. // CString strOutput;
  20. // strOutput.Format("------ Update %s(%X)", utlGetStatusDescription(command.eAction), command.dwTarget);
  21. // utlLogout(strOutput, eLogInfo, true);
  23. SetAt(0, command);
  24. return(true);
  25. }
  27. BOOL AICOMMANDQUEUE::cancelAll()
  28. {
  29. if(GetSize() <= 0)
  30. return(false);
  32. int nSize = GetSize();
  34. for(int i=0; i<nSize; i++)
  35. cancel();
  37. return(TRUE);
  38. }
  40. BOOL AICOMMANDQUEUE::cancel()
  41. {
  42. CString strOutput;
  43. if(GetSize() <= 0)
  44. return(false);
  46. AICOMMAND command;
  47. int nIndex;
  49. command = GetAt(0);
  51. strOutput.Format("------ Cancel %s(%X)", utlGetStatusDescription(command.eAction), command.dwTarget);
  52. utlLogout(strOutput, eLogCommon, true);
  54. nIndex = monsters.FindId(command.dwTarget);
  55. if(-1 != nIndex)
  56. {
  57. monsters[nIndex].bAiIgnore = true;
  58. } else
  59. {
  60. nIndex = items.FindId(command.dwTarget);
  61. if(-1 != nIndex)
  62. {
  63. items[nIndex].bAiIgnore = true;
  64. }
  65. }
  67. finish();
  68. return(TRUE);
  69. }
  71. BOOL AICOMMANDQUEUE::finishAll()
  72. {
  73. int nSize = GetSize();
  74. if(nSize <= 0)
  75. return(false);
  77. for(int i=0; i<nSize; i++)
  78. finish();
  80. return(true);
  81. }
  83. BOOL AICOMMANDQUEUE::finish()
  84. {
  85. CString strOutput;
  87. if(GetSize() <= 0)
  88. return(false);
  90. AICOMMAND command;
  91. command = GetAt(0);
  93. strOutput.Format("------ Removing %s(%X)", utlGetStatusDescription(command.eAction), command.dwTarget);
  94. utlLogout(strOutput, eLogInfo, true);
  96. RemoveAt(0);
  97. if(0 == GetSize())
  98. {
  99. priority = eAiPriMax;
  100. dwTarget = 0xFFFFFFFF;
  101. utlChangeGlobalAction(eAiIdle);
  102. }
  104. return(true);
  105. }
  107. BOOL AICOMMANDQUEUE::extend(AICOMMAND command)
  108. {
  109. BOOL bRtn = false;
  110. CString strOutput;
  111. if(GetSize() > 0)
  112. {
  113. strOutput.Format("------ Extend  %s(%X)", utlGetStatusDescription(command.eAction), command.dwTarget);
  114. utlLogout(strOutput, eLogInfo, true);
  116. InsertAt(0, command);
  117. bRtn = true;
  118. }
  119. else
  120. {
  121. ASSERT(false);
  122. }
  123. return(bRtn);
  124. }
  126. BOOL AICOMMANDQUEUE::push(AICOMMAND command, AIPRIORITY ePri)
  127. {
  128. ASSERT(GetSize() == 0);
  130. BOOL bRtn = false;
  131. CString strOutput;
  132. if(ePri < priority)
  133. {
  134. Add(command);
  135. priority = ePri;
  136. dwTarget = command.dwTarget;
  137. bRtn = true;
  139. strOutput.Format("------ Add  %s(%X)", utlGetStatusDescription(command.eAction), command.dwTarget);
  140. utlLogout(strOutput, eLogInfo, true);
  141. }
  142. return(bRtn);
  143. }
  145. BOOL AICOMMANDQUEUE::pop(AICOMMAND &command)
  146. {
  147. BOOL bFound = false;
  149. if(GetSize() > 0)
  150. {
  151. command = GetAt(0);
  152. bFound = true;
  153. }
  155. return(bFound);
  156. }
  158. int doAi()
  159. {
  160. //check for status
  161. AICOMMAND command;
  162. DWORD dwTarget;
  163. CString strOutput, strTemp;
  164. DWORD dwDamage;
  165. int nMinDist, nDist;
  166. BOOL bFound = false;
  167. int i;
  169. pos pos1, pos2;
  170. pos_list *poslist = (pos_list*)&route.size;
  171. DWORD dwDamage1;
  172. int nMinLevel, nLevel;
  173. CDWordArray dwTargetArray;
  174. CDWordArray dwDamageArray;
  176. // Check for eAiPriItem0
  177. if(aiQueue.priority <= eAiPriItem0)
  178. {
  179. // already in eAiPriItem0, no compare
  180. goto DONE;
  181. }
  182. if(aiGetItemToPickup(eIpGrab, dwTarget))
  183. {
  184. // ignore weight
  185. if(aiQueue.dwTarget != dwTarget)
  186. {
  187. aiQueue.finishAll();
  188. command.eAction = eAiPickup;
  189. command.ePhase = ePhaseNone;
  190. command.dwTarget = dwTarget;
  191. strOutput.Format("------ Prepare to pickup %s", utlFindTargetItem(dwTarget));
  192. utlLogout(strOutput, eLogCommon, true);
  193. aiQueue.push(command, eAiPriItem0);
  194. }
  195. goto DONE;
  196. }
  198. // Check for eAiPriFlee
  199. /*
  200. if(aiCheckTeleportCondition())
  201. {
  202. BOOL bFound = false;
  203. for(int i=0; i<inventory.GetSize(); i++)
  204. {
  205. if(inventory[i].dwId == 601)
  206. {
  207. bFound = true;
  208. break;
  209. }
  210. }
  211. if(bUseFlywing && bFound)
  212. {
  213. aiQueue.finishAll();
  214. sendUseItem((WORD)inventory[i].dwIndex, dwAccountId);
  215. }
  216. else
  217. {
  218. if(bFlyUsed)
  219. {
  220. aiQueue.finishAll();
  221. sendTeleport("Random");
  222. }
  223. else
  224. {
  225. if(bFound)
  226. {
  227. aiQueue.finishAll();
  228. sendUseItem(i, dwAccountId);
  229. sendTeleport("Random");
  230. }
  231. else
  232. {
  233. // .... 
  234. }
  235. }
  236. }
  237. goto DONE;
  238. }
  239. */
  240. // Check for eAiPriCounter
  241. if(aiQueue.priority < eAiPriCounter)
  242. {
  243. goto DONE;
  244. }
  245. bFound = false;
  246. dwTarget = 0;
  247. dwDamage = 0;
  248. nMinDist = 999;
  249. if(damages.FindDamageFrom(dwAccountId, dwTargetArray, dwDamageArray))
  250. {
  251. // Choose a monster by distance and damage
  252. for(i=0; i<dwTargetArray.GetSize(); i++)
  253. {
  254. nDist = (int)utlDistanceFrom(you.pntTo, monsters[monsters.FindId(dwTargetArray[i])].pntTo);
  255. dwDamage1 = dwDamageArray[i];
  257. if(nMinDist - nDist > 2)
  258. {
  259. dwTarget = dwTargetArray[i];
  260. dwDamage = dwDamage1;
  261. nMinDist = nDist;
  262. continue;
  263. }
  264. if(dwDamage1 > dwDamage)
  265. {
  266. dwTarget = dwTargetArray[i];
  267. dwDamage = dwDamage1;
  268. nMinDist = nDist;
  269. continue;
  270. }
  271. }
  272. if(dwTarget != aiQueue.dwTarget)
  273. {
  274. aiQueue.finishAll();
  275. command.eAction = eAiAttack;
  276. command.ePhase = ePhaseNone;
  277. command.dwTarget = dwTarget;
  278. strOutput.Format("------ Prepare to counter-attack %s", utlFindTarget(dwTarget));
  279. utlLogout(strOutput, eLogCommon, true);
  280. aiQueue.push(command, eAiPriCounter);
  281. }
  282. goto DONE;
  283. }
  285. //Aggresive monster
  287. if(action == eAtkPhaseAttacking)
  288. {
  289. // Attacking
  290. goto DONE;
  291. }
  293. // Check for eAiPriRecess
  294. if(aiQueue.priority < eAiPriRecess)
  295. {
  296. goto DONE;
  297. }
  298. if(you.bSit && you.wHp < you.wHpMax * 0.6)
  299. {
  300. goto DONE;
  301. }
  302. if(you.wHp < you.wHpMax * 0.3 && !you.bSit && aiQueue.priority != eAiPriRecess)
  303. {
  304. command.eAction = eAiSit;
  305. command.ePhase = ePhaseNone;
  306. aiQueue.finishAll();
  307. aiQueue.push(command, eAiPriRecess);
  308. goto DONE;
  309. }
  311. // Check for eAiPriItem1
  312. if(aiQueue.priority <= eAiPriItem1)
  313. {
  314. goto DONE;
  315. }
  316. if(aiGetItemToPickup(eIpGather, dwTarget) && ((double)you.dwWeight / you.dwWeightMax)< 0.48)
  317. {
  318. // weight
  319. if(aiQueue.dwTarget != dwTarget)
  320. {
  321. aiQueue.finishAll();
  322. command.eAction = eAiPickup;
  323. command.ePhase = ePhaseNone;
  324. command.dwTarget = dwTarget;
  325. strOutput.Format("------ Prepare to pickup %s", utlFindTargetItem(dwTarget));
  326. utlLogout(strOutput, eLogCommon, true);
  327. aiQueue.push(command, eAiPriItem1);
  328. }
  329. goto DONE;
  330. }
  332. // Check for eAiPriMonster
  333. if(aiQueue.priority <= eAiPriMonster)
  334. {
  335. goto DONE;
  336. }
  337. bFound = false;
  338. nMinLevel = 0;
  339. nMinDist = 999;
  340. nLevel = -1;
  341. dwTarget = 0;
  342. for(i=0; i<monsters.GetSize(); i++)
  343. {
  344. if(!monsters[i].bClean)
  345. {
  346. // no kill steal
  347. continue;
  348. }
  349. if(monsters[i].bAiIgnore)
  350. {
  351. // Ignore
  352. continue;
  353. }
  354. nDist = (int)utlDistanceFrom(you.pntTo, monsters[i].pntTo);
  355. // nLevel = atoi(mapMonsterInfo.FindValue(monsters[i].wType, eMonsterLev));
  356. if(nMinDist - nDist > 2)
  357. {
  358. dwTarget = monsters[i].dwId;
  359. nMinDist = nDist;
  360. nMinLevel = nLevel;
  361. bFound = true;
  362. continue;
  363. }
  364. if(nLevel > nMinLevel)
  365. {
  366. dwTarget = monsters[i].dwId;
  367. nMinDist = nDist;
  368. nMinLevel = nLevel;
  369. bFound = true;
  370. }
  371. }
  372. if(bFound)
  373. {
  374. if(dwTarget != aiQueue.dwTarget)
  375. {
  376. aiQueue.finishAll();
  377. command.eAction = eAiAttack;
  378. command.ePhase = ePhaseNone;
  379. command.dwTarget = dwTarget;
  380. strOutput.Format("------ Prepare to attack %s", utlFindTarget(dwTarget));
  381. utlLogout(strOutput, eLogCommon, true);
  383. aiQueue.push(command, eAiPriMonster);
  384. }
  385. goto DONE;
  386. }
  388. // Check for eAiPriItem2
  389. if(aiQueue.priority <= eAiPriItem2)
  390. {
  391. goto DONE;
  392. }
  393. if(aiGetItemToPickup(eIpPickup, dwTarget) && ((double)you.dwWeight / you.dwWeightMax)< 0.40 )
  394. {
  395. // weight
  396. if(aiQueue.dwTarget != dwTarget)
  397. {
  398. aiQueue.finishAll();
  399. command.eAction = eAiPickup;
  400. command.ePhase = ePhaseNone;
  401. command.dwTarget = dwTarget;
  402. strOutput.Format("------ Prepare to pickup %s", utlFindTargetItem(dwTarget));
  403. utlLogout(strOutput, eLogCommon, true);
  404. aiQueue.push(command, eAiPriItem2);
  405. }
  406. goto DONE;
  407. }
  409. // Random walk
  410. if(aiQueue.priority <= eAiPriRandom)
  411. {
  412. goto DONE;
  413. }
  414. bFound = true;
  415. if( route.size == 0 ||
  416. route.curPoint > route.size-1 ||
  417. (you.pntTo.x != route.array[route.curPoint].x ||
  418.  you.pntTo.y != route.array[route.curPoint].y))
  419. {
  420. // need recalculate
  421. // if((you.wHp < you.wHpMax * 0.8 || you.wSp < you.wSpMax * 0.8) && !you.bSit)
  422. // {
  423. // // Take a rest while calculating, mmmm....
  424. // sendSit();
  425. // }
  426. pos1.x = (WORD)you.pntTo.x;
  427. pos1.y = (WORD)you.pntTo.y;
  428. while(true)
  429. {
  430. pos2.x = (int)((double)rand()/RAND_MAX * field.m_szField.cx);
  431. pos2.y = (int)((double)rand()/RAND_MAX * field.m_szField.cy);
  432. if(!field.m_byFields[pos2.x + field.m_szField.cx * pos2.y])
  433. {
  434. break;
  435. }
  436. }
  437. DWORD session = (*CalcPath_init)(poslist, (char*)field.m_byFields, field.m_szField.cx, field.m_szField.cy, 
  438. &pos2, &pos1, MAX_ROUTE_TIMEOUT);
  439. bFound = !((*CalcPath_pathStep)(session));
  440. (*CalcPath_destory)(session);
  441. route.curPoint = 0;
  442. }
  443. if(bFound && route.size > 0)
  444. {
  445. route.curPoint += (int)((double)rand()/RAND_MAX *MAX_ROUTE_STEPONCE + MAX_ROUTE_STEPONCE);
  446. if(route.curPoint > (int)route.size-1)
  447. route.curPoint = route.size-1;
  449. command.eAction = eAiMove;
  450. command.ePhase = ePhaseNone;
  451. command.dwTarget = 0;
  452. command.pntMoveTo.x = route.array[route.curPoint].x;
  453. command.pntMoveTo.y = route.array[route.curPoint].y;
  455. strOutput.Format("------ Prepare to walk to (%d, %d), step: %d/%d", command.pntMoveTo.x, command.pntMoveTo.y, route.curPoint, route.size-1);
  456. utlLogout(strOutput, eLogCommon, true);
  457. aiQueue.push(command, eAiPriRandom);
  459. if(route.curPoint >= (int)route.size-1)
  460. route.curPoint = 0;
  462. goto DONE;
  463. }
  465. DONE:
  466. processCommandQueue();
  467. return(0);
  468. }
  470. int processCommandQueue()
  471. {
  472. AICOMMAND command;
  473. CString strOutput;
  475. if(!aiQueue.pop(command))
  476. {
  477. return(-1);
  478. }
  480. switch(command.eAction)
  481. {
  482. case eAiAttack:
  483. aiProcessAttackCommand(&command);
  484. break;
  485. case eAiSit:
  486. aiProcessSitCommand(&command);
  487. break;
  488. case eAiStand:
  489. aiProcessStandCommand(&command);
  490. break;
  491. case eAiMove:
  492. aiProcessMoveCommand(&command);
  493. break;
  494. case eAiPickup:
  495. aiProcessPickupCommand(&command);
  496. break;
  497. }
  499. return(0);
  500. }
  502. int aiProcessAttackCommand(AICOMMAND *pCommand)
  503. {
  504. POINT pnt;
  505. int nIndex = monsters.FindId(pCommand->dwTarget);
  506. CString strOutput;
  507. AICOMMAND *pNewCommand = NULL;
  508. static DWORD dwQuiken = GetTickCount();
  509. MONSTER monster;
  511. // Check if finish
  512. if(-1 == nIndex)
  513. {
  514. aiQueue.finish();
  515. goto DONE;
  516. }
  518. monster = monsters[nIndex];
  519. while(true)
  520. {
  521. switch(pCommand->ePhase)
  522. {
  523. case ePhaseNone:
  524. if(utlDistanceFrom(monster.pntTo, you.pntTo) > 3)
  525. {
  526. // move needed
  527. if(field.FindNearestPoint(you.pntTo, monster.pntTo, &pnt))
  528. {
  529. pNewCommand = new AICOMMAND;
  530. pNewCommand->eAction = eAiMove;
  531. pNewCommand->pntMoveTo = pnt;
  532. pNewCommand->dwTarget = monster.dwId;
  533. }
  534. else
  535. {
  536. strOutput.Format("%s can not be reached.",
  537. utlFindTarget(monster.dwId));
  538. utlLogout(strOutput, eLogError, true);
  539. aiQueue.cancelAll();
  540. }
  541. goto DONE;
  542. }
  543. else
  544. {
  545. // Proceed
  546. utlChangeAttackPhase(pCommand, eAtkPhaseEquip);
  547. }
  548. break;
  549. case eAtkPhaseEquip:
  550. // Change equipment
  551. utlChangeAttackPhase(pCommand, eAtkPhaseSkillUse);
  552. break;
  553. case eAtkPhaseEquipping:
  554. //
  555. break;
  556. case eAtkPhaseSkillUse:
  557. // Use Skill
  558. utlChangeAttackPhase(pCommand, eAtkPhaseAttack);
  559. if(you.wSp > 30 && !you.bTwoHandsQuiken && GetTickCount() > dwQuiken + 300000)
  560. {
  561. // sendUseSkill(10, 60, dwAccountId);
  562. dwQuiken = GetTickCount();
  563. goto DONE;
  564. }
  565. break;
  566. case eAtkPhaseAttack:
  567. if(utlDistanceFrom(monster.pntTo, you.pntTo) > 3)
  568. {
  569. // Re-move
  570. utlChangeAttackPhase(pCommand, (AIATTACKPHASE)ePhaseNone);
  571. }
  572. else
  573. {
  574. // Attack
  575. nIndex = damages.FindDamage(dwAccountId, pCommand->dwTarget);
  576. if(-1 != nIndex)
  577. {
  578. pCommand->dwLastDamage = damages[nIndex].dwDamage;
  579. }
  580. else
  581. {
  582. pCommand->dwLastDamage =0;
  583. }
  584. pCommand->dwTimeout = GetTickCount() + TIMEOUT_ATTACK;
  585. utlChangeAttackPhase(pCommand, eAtkPhaseAttacking);
  586. sendAttack(pCommand->dwTarget, 7);
  587. goto DONE;
  588. }
  589. break;
  590. case eAtkPhaseAttacking:
  591. if(utlDistanceFrom(monster.pntTo, you.pntTo) > 3)
  592. {
  593. // Re-move
  594. utlChangeAttackPhase(pCommand, (AIATTACKPHASE)ePhaseNone);
  595. }
  596. else
  597. {
  598. if(GetTickCount() > pCommand->dwTimeout)
  599. {
  600. DWORD intCurDamage = 0;
  601. nIndex = damages.FindDamage(dwAccountId, pCommand->dwTarget);
  602. if(-1 != nIndex)
  603. {
  604. intCurDamage = damages[nIndex].dwDamage;
  605. }
  606. if(intCurDamage == pCommand->dwLastDamage)
  607. {
  608. strOutput.Format("%s can not be attacked!",
  609. utlFindTarget(monster.dwId));
  610. utlLogout(strOutput, eLogError, true);
  612. // Can not hurt target
  613. aiQueue.cancelAll();
  614. }
  615. else
  616. {
  617. // Keep on attacking
  618. pCommand->dwLastDamage = intCurDamage;
  619. pCommand->dwTimeout = GetTickCount() + TIMEOUT_ATTACK;
  620. utlChangeAttackPhase(pCommand, (AIATTACKPHASE)eAtkPhaseAttacking);
  621. }
  622. }
  623. goto DONE;
  624. }
  625. break;
  626. }
  627. }
  629. DONE:
  630. if(pNewCommand)
  631. {
  632. aiQueue.extend(*pNewCommand);
  633. delete pNewCommand;
  634. }
  635. return(0);
  636. }
  638. int aiProcessPickupCommand(AICOMMAND *pCommand)
  639. {
  640. POINT pnt;
  641. int nIndex = items.FindId(pCommand->dwTarget);
  642. CString strOutput;
  643. AICOMMAND *pNewCommand = NULL;
  644. ITEM item;
  646. // Check if finish
  647. if(-1 == nIndex)
  648. {
  649. aiQueue.finishAll();
  650. goto DONE;
  651. }
  653. item = items[nIndex];
  654. while(true)
  655. {
  656. switch(pCommand->ePhase)
  657. {
  658. case ePhaseNone:
  659. if(utlDistanceFrom(item.pntPos, you.pntTo) > 3)
  660. {
  661. // Calculate route
  662. if(field.FindNearestPoint(you.pntTo, item.pntPos, &pnt))
  663. {
  664. pNewCommand = new AICOMMAND;
  665. pNewCommand->eAction = eAiMove;
  666. pNewCommand->pntMoveTo = pnt;
  667. pNewCommand->dwTarget = item.dwId;
  668. }
  669. else
  670. {
  671. strOutput.Format("%s@ can not be reached!", utlFindTargetItem(item.dwId));
  672. utlLogout(strOutput, eLogError, true);
  673. aiQueue.cancelAll();
  674. }
  675. goto DONE;
  676. }
  677. else
  678. {
  679. // Proceed
  680. utlChangePickupPhase(pCommand, ePickupPhasePick);
  681. }
  682. break;
  683. case ePickupPhaseLook:
  684. utlChangePickupPhase(pCommand, ePickupPhasePick);
  685. break;
  686. case ePickupPhaseLooking:
  687. //
  688. break;
  689. case ePickupPhasePick:
  690. if(utlDistanceFrom(items[nIndex].pntPos, you.pntTo) > 3)
  691. {
  692. // Retry
  693. utlChangePickupPhase(pCommand, (AIPICKUPPHASE)ePhaseNone);
  694. }
  695. else
  696. {
  697. // Start pickup
  698. pCommand->dwTimeout = GetTickCount() + TIMEOUT_PICKUP;
  699. utlChangePickupPhase(pCommand, ePickupPhasePicking);
  700. sendTake(pCommand->dwTarget);
  701. goto DONE;
  702. }
  703. break;
  704. case ePickupPhasePicking:
  705. sendTake(pCommand->dwTarget);
  706. if(item.nPickupFailed)
  707. {
  708. // Retry
  709. utlChangePickupPhase(pCommand, (AIPICKUPPHASE)ePhaseNone);
  710. items[nIndex].nPickupFailed = 0;
  711. strOutput.Format("Failed to pickup %s, retry!", utlFindTargetItem(item.dwId));
  712. utlLogout(strOutput, eLogError, true);
  713. }
  714. else
  715. {
  716. if(GetTickCount() > pCommand->dwTimeout)
  717. {
  718. strOutput.Format("Pickup %s timeout!", utlFindTargetItem(item.dwId));
  719. utlLogout(strOutput, eLogError, true);
  720. aiQueue.cancelAll();
  721. }
  722. goto DONE;
  723. }
  724. break;
  725. }
  726. }
  728. DONE:
  729. if(pNewCommand)
  730. {
  731. aiQueue.extend(*pNewCommand);
  732. delete pNewCommand;
  733. }
  735. return(0);
  736. }
  738. int aiProcessSitCommand(AICOMMAND *pCommand)
  739. {
  740. if(you.bSit)
  741. {
  742. aiQueue.finish();
  743. }
  744. else
  745. {
  746. switch(pCommand->ePhase)
  747. {
  748. case ePhaseNone:
  749. pCommand->dwTimeout = GetTickCount() + TIMEOUT_SIT;
  750. utlChangeSitPhase(pCommand, eSitPhaseSitting);
  751. sendSit();
  752. break;
  753. case eSitPhaseSitting:
  754. if(GetTickCount() > pCommand->dwTimeout)
  755. aiQueue.cancelAll();
  756. break;
  757. }
  758. }
  760. return(0);
  761. }
  763. int aiProcessStandCommand(AICOMMAND *pCommand)
  764. {
  765. if(!you.bSit)
  766. {
  767. aiQueue.finish();
  768. }
  769. else
  770. {
  771. switch(pCommand->ePhase)
  772. {
  773. case ePhaseNone:
  774. pCommand->dwTimeout = GetTickCount() + TIMEOUT_STAND;
  775. utlChangeStandPhase(pCommand, eStandPhaseStanding);
  776. sendStand();
  777. break;
  778. case eStandPhaseStanding:
  779. if(GetTickCount() > pCommand->dwTimeout)
  780. aiQueue.cancelAll();
  781. break;
  782. }
  783. }
  785. return(0);
  786. }
  788. int aiProcessMoveCommand(AICOMMAND *pCommand)
  789. {
  790. CString strOutput;
  791. BOOL bFound = false;
  792. BOOL bNeedRemove = false;
  793. AICOMMAND *pNewCommand = NULL;
  795. // check for cancel
  796. do
  797. {
  798. if(pCommand->dwTarget != 0 &&
  799. -1 == monsters.FindId(pCommand->dwTarget) &&
  800. -1 == items.FindId(pCommand->dwTarget))
  801. {
  802. // lost target
  803. strOutput.Format("Lost target(%X), giveup!", pCommand->dwTarget);
  804. bNeedRemove = true;
  805. break;
  806. }
  808. if(pCommand->dwTarget != 0 && -1 != monsters.FindId(pCommand->dwTarget))
  809. {
  810. if(GetTickCount() - monsters[monsters.FindId(pCommand->dwTarget)].dwAppearTime > 120000)
  811. {
  812. // lost target
  813. strOutput.Format("Target(%X) timeout, giveup!", pCommand->dwTarget);
  814. bNeedRemove = true;
  815. break;
  816. }
  817. }
  819. if(pCommand->dwTarget != 0 && -1 != items.FindId(pCommand->dwTarget))
  820. {
  821. if(GetTickCount() - items[items.FindId(pCommand->dwTarget)].dwAppearTime > 120000)
  822. {
  823. // lost target
  824. strOutput.Format("Target(%X) timeout, giveup!", pCommand->dwTarget);
  825. bNeedRemove = true;
  826. break;
  827. }
  828. }
  830. if(utlDistanceFrom(you.pntTo, pCommand->pntMoveTo) > 30)
  831. {
  832. // Too far
  833. strOutput.Format("Target(%X) is too far from you, giveup!", pCommand->dwTarget);
  834. bNeedRemove = true;
  835. break;
  836. }
  838. // Check for portals
  839. for(int i=0; i<portals.GetSize(); i++)
  840. {
  841. if(utlDistanceFrom(portals[i].pntPos, pCommand->pntMoveTo) <= 10)
  842. {
  843. // lost target
  844. strOutput.Format("Portal found, giveup!", pCommand->dwTarget);
  845. bNeedRemove = true;
  846. break;
  847. }
  848. }
  849. }while(0);
  851. if(bNeedRemove)
  852. {
  853. utlLogout(strOutput, eLogError, true);
  854. aiQueue.cancelAll();
  855. goto DONE;
  856. }
  858. // Process phase change
  859. while(true)
  860. {
  861. switch(pCommand->ePhase)
  862. {
  863. case ePhaseNone:
  864. if(!you.bSit)
  865. {
  866. // Proceed
  867. utlChangeMovePhase(pCommand, (AIMOVEPHASE)eMovePhaseMove);
  868. }
  869. else
  870. {
  871. // Generate stand command
  872. pNewCommand = new AICOMMAND;
  873. pNewCommand->eAction = eAiStand;
  874. pNewCommand->ePhase = ePhaseNone;
  875. goto DONE;
  876. }
  877. break;
  878. case eMovePhaseMove:
  879. pCommand->pntMoveFrom = you.pntTo;
  880. pCommand->dwTimeout = GetTickCount()+(DWORD)(SECOND_PER_BLOCK*utlDistanceFrom(pCommand->pntMoveFrom, pCommand->pntMoveTo));
  881. utlChangeMovePhase(pCommand, eMovePhaseMoving);
  882. sendMove(pCommand->pntMoveTo);
  883. goto DONE;
  884. break;
  885. case eMovePhaseMoving:
  886. if(GetTickCount() > pCommand->dwTimeout)
  887. {
  888. if(you.pntTo.x == pCommand->pntMoveTo.x &&
  889. you.pntTo.y == pCommand->pntMoveTo.y)
  890. {
  891. aiQueue.finish();
  892. goto DONE;
  893. }
  894. if(you.pntTo.x == pCommand->pntMoveFrom.x &&
  895. you.pntTo.y == pCommand->pntMoveFrom.y)
  896. {
  897. // Timeup: not moved, maybe can not reach
  898. if(GetTickCount() > pCommand->dwTimeout + TIMEOUT_MOVE)
  899. {
  900. strOutput.Format("Move to %s@(%d, %d) timeout, giveup!", utlFindTarget(pCommand->dwTarget), pCommand->pntMoveTo.x, pCommand->pntMoveTo.y);
  901. utlLogout(strOutput, eLogError, true);
  902. aiQueue.cancelAll(); 
  903. }
  904. goto DONE;
  905. }
  906. // Timeup: moved but has not reached, try again
  907. utlChangeMovePhase(pCommand, eMovePhaseMove);
  908. }
  909. else
  910. {
  911. goto DONE;
  912. }
  913. break;
  914. }
  915. }
  917. DONE:
  919. if(pNewCommand)
  920. {
  921. aiQueue.extend(*pNewCommand);
  922. delete pNewCommand;
  923. }
  925. return(0);
  926. }
  928. BOOL aiGetUnderAttackFrom(DWORD &dwTarget)
  929. {
  930. BOOL bRtn = false;
  931. for(int i=0; i<monsters.GetSize(); i++)
  932. {
  933. if(-1 != damages.FindDamage(monsters[i].dwId, dwAccountId))
  934. {
  935. dwTarget = monsters[i].dwId;
  936. bRtn = true;
  937. break;
  938. }
  939. }
  940. return(bRtn);
  941. }
  943. BOOL aiGetItemToPickup(ITEMPRIORITY priority, DWORD &dwTarget)
  944. {
  945. BOOL bRtn = false;
  946. int nPriFound;
  947. for(int i=0; i<items.GetSize(); i++)
  948. {
  949. nPriFound = atoi(mapItem.FindValue(items[i].wType, eItemPriority));
  950. if(nPriFound <= priority && !items[i].bAiIgnore)
  951. {
  952. dwTarget = items[i].dwId;
  953. bRtn = true;
  954. break;
  955. }
  956. }
  957. return(bRtn);
  958. }
  960. BOOL aiCheckTeleportCondition()
  961. {
  962. BOOL bRtn = false;
  963. CDWordArray dwTargetArray, dwDamageArray;
  965. if(action == eAiAttack && you.wHp < you.wHpMax * 0.2)
  966. {
  967. bRtn = true;
  968. }
  969. if(damages.FindDamageFrom(dwAccountId, dwTargetArray, dwDamageArray))
  970. {
  971. if(dwTargetArray.GetSize() > 6)
  972. bRtn = true;
  973. }
  975. return(bRtn);
  976. }