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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
Attack.pm.svn-base
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：23k
源码类别：

外挂编程

开发平台：

Windows_Unix

Attack.pm.svn-base：源码内容
  1. #########################################################################
  2. #  OpenKore - Attack AI
  3. #  Copyright (c) 2006 OpenKore Team
  4. #
  5. #  This software is open source, licensed under the GNU General Public
  6. #  License, version 2.
  7. #  Basically, this means that you're allowed to modify and distribute
  8. #  this software. However, if you distribute modified versions, you MUST
  9. #  also distribute the source code.
  10. #  See http://www.gnu.org/licenses/gpl.html for the full license.
  11. #
  12. #  $Revision: 4286 $
  13. #  $Id: Commands.pm 4286 2006-04-17 14:02:27Z illusion_kore $
  14. #
  15. #########################################################################
  16. #
  17. # This module contains the attack AI's code.
  18. package AI::Attack;
  20. use strict;
  21. use Carp::Assert;
  22. use Time::HiRes qw(time);
  24. use Globals;
  25. use AI;
  26. use Actor;
  27. use Field;
  28. use Log qw(message debug warning);
  29. use Translation qw(T TF);
  30. use Network::Send ();
  31. use Skill;
  32. use Misc;
  33. use Utils;
  34. use Utils::Benchmark;
  35. use Utils::PathFinding;
  38. sub process {
  39. Benchmark::begin("ai_attack") if DEBUG;
  40. my $args = AI::args;
  42. if (AI::action eq "attack" && AI::args->{suspended}) {
  43. $args->{ai_attack_giveup}{time} += time - $args->{suspended};
  44. delete $args->{suspended};
  45. }
  47. if (AI::action eq "attack" && $args->{move_start}) {
  48. # We've just finished moving to the monster.
  49. # Don't count the time we spent on moving
  50. $args->{ai_attack_giveup}{time} += time - $args->{move_start};
  51. undef $args->{unstuck}{time};
  52. undef $args->{move_start};
  54. } elsif (AI::action eq "attack" && $args->{avoiding} && $args->{attackID}) {
  55. my $target = Actor::get($args->{attackID});
  56. $args->{ai_attack_giveup}{time} = time + $target->{time_move_calc} + 3;
  57. undef $args->{avoiding};
  59. } elsif (((AI::action eq "route" && AI::action(1) eq "attack") || (AI::action eq "move" && AI::action(2) eq "attack"))
  60.    && $args->{attackID} && timeOut($AI::Temp::attack_route_adjust, 1)) {
  61. # We're on route to the monster; check whether the monster has moved
  62. my $ID = $args->{attackID};
  63. my $attackSeq = (AI::action eq "route") ? AI::args(1) : AI::args(2);
  64. my $target = Actor::get($ID);
  66. if ($target->{type} ne 'Unknown' && $attackSeq->{monsterPos} && %{$attackSeq->{monsterPos}}
  67.  && round(distance(calcPosition($target), $attackSeq->{monsterPos})) > $attackSeq->{attackMethod}{maxDistance}) {
  68. # Monster has moved; stop moving and let the attack AI readjust route
  69. AI::dequeue;
  70. AI::dequeue if (AI::action eq "route");
  72. $attackSeq->{ai_attack_giveup}{time} = time;
  73. debug "Target has moved more than $attackSeq->{attackMethod}{maxDistance} blocks; readjusting routen", "ai_attack";
  75. } elsif ($target->{type} ne 'Unknown' && $attackSeq->{monsterPos} && %{$attackSeq->{monsterPos}}
  76.  && round(distance(calcPosition($target), calcPosition($char))) <= $attackSeq->{attackMethod}{maxDistance}) {
  77. # Monster is within attack range; stop moving
  78. AI::dequeue;
  79. AI::dequeue if (AI::action eq "route");
  81. $attackSeq->{ai_attack_giveup}{time} = time;
  82. debug "Target at ($attackSeq->{monsterPos}{x},$attackSeq->{monsterPos}{y}) is now within " .
  83. "$attackSeq->{attackMethod}{maxDistance} blocks; stop movingn", "ai_attack";
  84. }
  85. $AI::Temp::attack_route_adjust = time;
  86. }
  88. if (AI::action eq "attack") {
  89. my $ID = $args->{ID};
  90. if (targetGone()) {
  91. finishAttacking();
  92. } elsif (shouldGiveUp()) {
  93. giveUp();
  94. } else {
  95. if (timeOut($args->{attackMainTimeout}, 0.1)) {
  96. $args->{attackMainTimeout} = time;
  97. main();
  98. }
  99. }
  100. }
  102. # Check for kill steal and mob-training while moving
  103. if ((AI::is("move", "route") && $args->{attackID} && AI::inQueue("attack")
  104. && timeOut($args->{movingWhileAttackingTimeout}, 0.2))) {
  106. my $ID = AI::args->{attackID};
  107. my $monster = $monsters{$ID};
  109. # Check for kill steal while moving
  110. if ($monster && !Misc::checkMonsterCleanness($ID)) {
  111. message T("Dropping target - you will not kill steal othersn");
  112. stopAttack();
  113. $monster->{ignore} = 1;
  115. # Right now, the queue is either
  116. #   move, route, attack
  117. # -or-
  118. #   route, attack
  119. AI::dequeue;
  120. AI::dequeue;
  121. AI::dequeue if (AI::action eq "attack");
  122. if ($config{teleportAuto_dropTargetKS}) {
  123. message T("Teleport due to dropping attack targetn");
  124. useTeleport(1);
  125. }
  126. }
  128. # Mob-training, stop attacking the monster if it is already aggressive
  129. if ((my $control = mon_control($monster->{name},$monster->{nameID}))) {
  130. if ($control->{attack_auto} == 3
  131. && ($monster->{dmgToYou} || $monster->{missedYou} || $monster->{dmgFromYou})) {
  133. message TF("Dropping target - %s (%s) has been provokedn", $monster->{name}, $monster->{binID});
  134. stopAttack();
  135. $monster->{ignore} = 1;
  136. # Right now, the queue is either
  137. #   move, route, attack
  138. # -or-
  139. #   route, attack
  140. AI::dequeue;
  141. AI::dequeue;
  142. AI::dequeue if (AI::action eq "attack");
  143. }
  144. }
  146. $args->{movingWhileAttackingTimeout} = time;
  147. }
  149. Benchmark::end("ai_attack") if DEBUG;
  150. }
  152. sub shouldGiveUp {
  153. my $args = AI::args;
  154. return !$config{attackNoGiveup} && (timeOut($args->{ai_attack_giveup}) || $args->{unstuck}{count} > 5);
  155. }
  157. sub giveUp {
  158. my $ID = AI::args->{ID};
  159. my $target = Actor::get($ID);
  160. $target->{attack_failed} = time if ($monsters{$ID});
  161. AI::dequeue;
  162. message T("Can't reach or damage target, dropping targetn"), "ai_attack";
  163. if ($config{'teleportAuto_dropTarget'}) {
  164. message T("Teleport due to dropping attack targetn");
  165. useTeleport(1);
  166. }
  167. }
  169. sub targetGone {
  170. my $args = AI::args;
  171. return !$monsters{$args->{ID}} && (!$players{$args->{ID}} || $players{$args->{ID}}{dead});
  172. }
  174. sub finishAttacking {
  175. my $args = AI::args;
  176. $timeout{'ai_attack'}{'time'} -= $timeout{'ai_attack'}{'timeout'};
  177. my $ID = $args->{ID};
  178. AI::dequeue;
  179. if ($monsters_old{$ID} && $monsters_old{$ID}{dead}) {
  180. message T("Target diedn"), "ai_attack";
  181. Plugins::callHook("target_died");
  182. monKilled();
  184. # Pickup loot when monster's dead
  185. if ($AI == 2 && $config{'itemsTakeAuto'} && $monsters_old{$ID}{dmgFromYou} > 0 && !$monsters_old{$ID}{ignore}) {
  186. AI::clear("items_take");
  187. ai_items_take($monsters_old{$ID}{pos}{x}, $monsters_old{$ID}{pos}{y},
  188.       $monsters_old{$ID}{pos_to}{x}, $monsters_old{$ID}{pos_to}{y});
  189. } else {
  190. # Cheap way to suspend all movement to make it look real
  191. ai_clientSuspend(0, $timeout{'ai_attack_waitAfterKill'}{'timeout'});
  192. }
  194. ## kokal start
  195. ## mosters counting
  196. my $i = 0;
  197. my $found = 0;
  198. while ($monsters_Killed[$i]) {
  199. if ($monsters_Killed[$i]{'nameID'} eq $monsters_old{$ID}{'nameID'}) {
  200. $monsters_Killed[$i]{'count'}++;
  201. monsterLog($monsters_Killed[$i]{'name'});
  202. $found = 1;
  203. last;
  204. }
  205. $i++;
  206. }
  207. if (!$found) {
  208. $monsters_Killed[$i]{'nameID'} = $monsters_old{$ID}{'nameID'};
  209. $monsters_Killed[$i]{'name'} = $monsters_old{$ID}{'name'};
  210. $monsters_Killed[$i]{'count'} = 1;
  211. monsterLog($monsters_Killed[$i]{'name'})
  212. }
  213. ## kokal end
  215. } elsif ($config{teleportAuto_lostTarget}) {
  216. message T("Target lost, teleporting.n"), "ai_attack";
  217. useTeleport(1);
  218. } else {
  219. message T("Target lostn"), "ai_attack";
  220. }
  222. Plugins::callHook('attack_end', {ID => $ID})
  224. }
  226. sub dropTargetWhileMoving {
  227. my $ID = AI::args->{attackID};
  228. message T("Dropping target - you will not kill steal othersn");
  229. stopAttack();
  230. $monsters{$ID}{ignore} = 1;
  232. # Right now, the queue is either
  233. #   move, route, attack
  234. # -or-
  235. #   route, attack
  236. AI::dequeue;
  237. AI::dequeue;
  238. AI::dequeue if (AI::action eq "attack");
  239. if ($config{teleportAuto_dropTargetKS}) {
  240. message T("Teleport due to dropping attack targetn");
  241. useTeleport(1);
  242. }
  243. }
  245. sub main {
  246. my $args = AI::args;
  248. Benchmark::begin("ai_attack (part 1)") if DEBUG;
  249. Benchmark::begin("ai_attack (part 1.1)") if DEBUG;
  250. # The attack sequence hasn't timed out and the monster is on screen
  252. # Update information about the monster and the current situation
  253. my $args = AI::args;
  254. my $followIndex = AI::findAction("follow");
  255. my $following;
  256. my $followID;
  257. if (defined $followIndex) {
  258. $following = AI::args($followIndex)->{following};
  259. $followID = AI::args($followIndex)->{ID};
  260. }
  262. my $ID = $args->{ID};
  263. my $target = Actor::get($ID);
  264. my $myPos = $char->{pos_to};
  265. my $monsterPos = $target->{pos_to};
  266. my $monsterDist = round(distance($myPos, $monsterPos));
  268. my ($realMyPos, $realMonsterPos, $realMonsterDist, $hitYou);
  269. my $realMyPos = calcPosition($char);
  270. my $realMonsterPos = calcPosition($target);
  271. my $realMonsterDist = round(distance($realMyPos, $realMonsterPos));
  272. if (!$config{'runFromTarget'}) {
  273. $myPos = $realMyPos;
  274. $monsterPos = $realMonsterPos;
  275. }
  277. my $cleanMonster = checkMonsterCleanness($ID);
  280. # If the damage numbers have changed, update the giveup time so we don't timeout
  281. if ($args->{dmgToYou_last}   != $target->{dmgToYou}
  282.  || $args->{missedYou_last}  != $target->{missedYou}
  283.  || $args->{dmgFromYou_last} != $target->{dmgFromYou}
  284.  || $args->{lastSkillTime} != $char->{last_skill_time}) {
  285. $args->{ai_attack_giveup}{time} = time;
  286. debug "Update attack giveup timen", "ai_attack", 2;
  287. }
  288. $hitYou = ($args->{dmgToYou_last} != $target->{dmgToYou}
  289. || $args->{missedYou_last} != $target->{missedYou});
  290. $args->{dmgToYou_last} = $target->{dmgToYou};
  291. $args->{missedYou_last} = $target->{missedYou};
  292. $args->{dmgFromYou_last} = $target->{dmgFromYou};
  293. $args->{missedFromYou_last} = $target->{missedFromYou};
  294. $args->{lastSkillTime} = $char->{last_skill_time};
  296. Benchmark::end("ai_attack (part 1.1)") if DEBUG;
  297. Benchmark::begin("ai_attack (part 1.2)") if DEBUG;
  299. # Determine what combo skill to use
  300. delete $args->{attackMethod};
  301. my $lastSkill;
  302. if ($char->{last_skill_used}) {
  303. $lastSkill = Skill->new(idn => $char->{last_skill_used})->getName();
  304. }
  305. my $i = 0;
  306. while (exists $config{"attackComboSlot_$i"}) {
  307. if (!$config{"attackComboSlot_$i"}) {
  308. $i++;
  309. next;
  310. }
  312. if ($config{"attackComboSlot_${i}_afterSkill"} eq $lastSkill
  313.  && ( !$config{"attackComboSlot_${i}_maxUses"} || $args->{attackComboSlot_uses}{$i} < $config{"attackComboSlot_${i}_maxUses"} )
  314.  && ( !$config{"attackComboSlot_${i}_autoCombo"} || ($char->{combo_packet} && $config{"attackComboSlot_${i}_autoCombo"}) )
  315.  && ( !defined($args->{ID}) || $args->{ID} eq $char->{last_skill_target} || !$config{"attackComboSlot_${i}_isSelfSkill"})
  316.  && checkSelfCondition("attackComboSlot_$i")
  317.  && (!$config{"attackComboSlot_${i}_monsters"} || existsInList($config{"attackComboSlot_${i}_monsters"}, $target->{name}))
  318.  && (!$config{"attackComboSlot_${i}_notMonsters"} || !existsInList($config{"attackComboSlot_${i}_notMonsters"}, $target->{name}))
  319.  && checkMonsterCondition("attackComboSlot_${i}_target", $target)) {
  321. $args->{attackComboSlot_uses}{$i}++;
  322. delete $char->{last_skill_used};
  323. if ($config{"attackComboSlot_${i}_autoCombo"}) {
  324. $char->{combo_packet} = 1500 if ($char->{combo_packet} > 1500);
  325. # eAthena seems to have a bug where the combo_packet overflows and gives an
  326. # abnormally high number. This causes kore to get stuck in a waitBeforeUse timeout.
  327. $config{"attackComboSlot_${i}_waitBeforeUse"} = ($char->{combo_packet} / 1000);
  328. }
  329. delete $char->{combo_packet};
  330. $args->{attackMethod}{type} = "combo";
  331. $args->{attackMethod}{comboSlot} = $i;
  332. $args->{attackMethod}{distance} = $config{"attackComboSlot_${i}_dist"};
  333. $args->{attackMethod}{maxDistance} = $config{"attackComboSlot_${i}_dist"};
  334. $args->{attackMethod}{isSelfSkill} = $config{"attackComboSlot_${i}_isSelfSkill"};
  335. last;
  336. }
  337. $i++;
  338. }
  340. # Determine what skill to use to attack
  341. if (!$args->{attackMethod}{type}) {
  342. if ($config{'attackUseWeapon'}) {
  343. $args->{attackMethod}{distance} = $config{'attackDistance'};
  344. $args->{attackMethod}{maxDistance} = $config{'attackMaxDistance'};
  345. $args->{attackMethod}{type} = "weapon";
  346. } else {
  347. $args->{attackMethod}{distance} = 30;
  348. $args->{attackMethod}{maxDistance} = 30;
  349. undef $args->{attackMethod}{type};
  350. }
  352. $i = 0;
  353. while (exists $config{"attackSkillSlot_$i"}) {
  354. if (!$config{"attackSkillSlot_$i"}) {
  355. $i++;
  356. next;
  357. }
  359. my $skill = new Skill(name => $config{"attackSkillSlot_$i"});
  360. if (checkSelfCondition("attackSkillSlot_$i")
  361. && (!$config{"attackSkillSlot_$i"."_maxUses"} ||
  362.     $target->{skillUses}{$skill->getHandle()} < $config{"attackSkillSlot_$i"."_maxUses"})
  363. && (!$config{"attackSkillSlot_$i"."_maxAttempts"} || $args->{attackSkillSlot_attempts}{$i} < $config{"attackSkillSlot_$i"."_maxAttempts"})
  364. && (!$config{"attackSkillSlot_$i"."_monsters"} || existsInList($config{"attackSkillSlot_$i"."_monsters"}, $target->{'name'}))
  365. && (!$config{"attackSkillSlot_$i"."_notMonsters"} || !existsInList($config{"attackSkillSlot_$i"."_notMonsters"}, $target->{'name'}))
  366. && (!$config{"attackSkillSlot_$i"."_previousDamage"} || inRange($target->{dmgTo}, $config{"attackSkillSlot_$i"."_previousDamage"}))
  367. && checkMonsterCondition("attackSkillSlot_${i}_target", $target)
  368. ) {
  369. $args->{attackSkillSlot_attempts}{$i}++;
  370. $args->{attackMethod}{distance} = $config{"attackSkillSlot_$i"."_dist"};
  371. $args->{attackMethod}{maxDistance} = $config{"attackSkillSlot_$i"."_dist"};
  372. $args->{attackMethod}{type} = "skill";
  373. $args->{attackMethod}{skillSlot} = $i;
  374. last;
  375. }
  376. $i++;
  377. }
  379. if ($config{'runFromTarget'} && $config{'runFromTarget_dist'} > $args->{attackMethod}{distance}) {
  380. $args->{attackMethod}{distance} = $config{'runFromTarget_dist'};
  381. }
  382. }
  384. $args->{attackMethod}{maxDistance} ||= $config{attackMaxDistance};
  385. $args->{attackMethod}{distance} ||= $config{attackDistance};
  386. if ($args->{attackMethod}{maxDistance} < $args->{attackMethod}{distance}) {
  387. $args->{attackMethod}{maxDistance} = $args->{attackMethod}{distance};
  388. }
  390. Benchmark::end("ai_attack (part 1.2)") if DEBUG;
  391. Benchmark::end("ai_attack (part 1)") if DEBUG;
  395. if ($char->{sitting}) {
  396. ai_setSuspend(0);
  397. stand();
  399. } elsif (!$cleanMonster) {
  400. # Drop target if it's already attacked by someone else
  401. message T("Dropping target - you will not kill steal othersn"), "ai_attack";
  402. $messageSender->sendMove($realMyPos->{x}, $realMyPos->{y});
  403. AI::dequeue;
  404. if ($config{teleportAuto_dropTargetKS}) {
  405. message T("Teleporting due to dropping attack targetn"), "teleport";
  406. useTeleport(1);
  407. }
  409. } elsif (
  410. $config{attackCheckLOS} && $args->{attackMethod}{distance} > 2
  411. && (($config{attackCanSnipe} && !checkLineSnipable($realMyPos, $realMonsterPos))
  412. || (!$config{attackCanSnipe} && $realMonsterDist < $args->{attackMethod}{maxDistance} && !checkLineWalkable($realMyPos, $realMonsterPos)))
  413. ) {
  414. # We are a ranged attacker without LOS
  415. # Calculate squares around monster within shooting range, but not
  416. # closer than runFromTarget_dist
  417. my @stand = calcRectArea2($realMonsterPos->{x}, $realMonsterPos->{y},
  418.   $args->{attackMethod}{distance},
  419.   $config{runFromTarget} ? $config{runFromTarget_dist} : 0);
  421. my ($master, $masterPos);
  422. if ($config{follow}) {
  423. foreach (keys %players) {
  424. if ($players{$_}{name} eq $config{followTarget}) {
  425. $master = $players{$_};
  426. last;
  427. }
  428. }
  429. $masterPos = calcPosition($master) if $master;
  430. }
  432. # Determine which of these spots are snipable
  433. my $best_spot;
  434. my $best_dist;
  435. for my $spot (@stand) {
  436. # Is this spot acceptable?
  437. # 1. It must have LOS to the target ($realMonsterPos).
  438. # 2. It must be within $config{followDistanceMax} of
  439. #    $masterPos, if we have a master.
  440. if (
  441.     (($config{attackCanSnipe} && checkLineSnipable($spot, $realMonsterPos))
  442. && checkLineWalkable($spot, $realMonsterPos))
  443. && $field->isWalkable($spot->{x}, $spot->{y})
  444. && ($realMyPos->{x} != $spot->{x} && $realMyPos->{y} != $spot->{y})
  445. && (!$master || round(distance($spot, $masterPos)) <= $config{followDistanceMax})
  446. ) {
  447. my $dist = distance($realMyPos, $spot);
  448. if (!defined($best_dist) || $dist < $best_dist) {
  449. $best_dist = $dist;
  450. $best_spot = $spot;
  451. }
  452. }
  453. }
  455. # Move to the closest spot
  456. my $msg = "No LOS from ($realMyPos->{x}, $realMyPos->{y}) to target ($realMonsterPos->{x}, $realMonsterPos->{y})";
  457. if ($best_spot) {
  458. message TF("%s; moving to (%s, %s)n", $msg, $best_spot->{x}, $best_spot->{y});
  459. if ($config{attackChangeTarget} == 1) {
  460. # Restart attack from processAutoAttack
  461. AI::dequeue;
  462. ai_route($field{name}, $best_spot->{x}, $best_spot->{y}, LOSSubRoute => 1);
  463. } else {
  464. ai_route($field{name}, $best_spot->{x}, $best_spot->{y});
  465. }
  466. } else {
  467. warning TF("%s; no acceptable place to standn", $msg);
  468. $target->{attack_failedLOS} = time;
  469. AI::dequeue;
  470. AI::dequeue;
  471. AI::dequeue if (AI::action eq "attack");
  472. }
  474. } elsif ($config{'runFromTarget'} && ($realMonsterDist < $config{'runFromTarget_dist'} || $hitYou)) {
  475. #my $begin = time;
  476. # Get a list of blocks that we can run to
  477. my @blocks = calcRectArea($myPos->{x}, $myPos->{y},
  478. # If the monster hit you while you're running, then your recorded
  479. # location may be out of date. So we use a smaller distance so we can still move.
  480. ($hitYou) ? $config{'runFromTarget_dist'} / 2 : $config{'runFromTarget_dist'});
  482. # Find the distance value of the block that's farthest away from a wall
  483. my $highest;
  484. foreach (@blocks) {
  485. my $dist = ord(substr($field{dstMap}, $_->{y} * $field{width} + $_->{x}));
  486. if (!defined $highest || $dist > $highest) {
  487. $highest = $dist;
  488. }
  489. }
  491. # Get rid of rediculously large route distances (such as spots that are on a hill)
  492. # Get rid of blocks that are near a wall
  493. my $pathfinding = new PathFinding;
  494. use constant AVOID_WALLS => 4;
  495. for (my $i = 0; $i < @blocks; $i++) {
  496. # We want to avoid walls (so we don't get cornered), if possible
  497. my $dist = ord(substr($field{dstMap}, $blocks[$i]{y} * $field{width} + $blocks[$i]{x}));
  498. if ($highest >= AVOID_WALLS && $dist < AVOID_WALLS) {
  499. delete $blocks[$i];
  500. next;
  501. }
  503. $pathfinding->reset(
  504. field => %field,
  505. start => $myPos,
  506. dest => $blocks[$i]);
  507. my $ret = $pathfinding->runcount;
  508. if ($ret <= 0 || $ret > $config{'runFromTarget_dist'} * 2) {
  509. delete $blocks[$i];
  510. next;
  511. }
  512. }
  514. # Find the block that's farthest to us
  515. my $largestDist;
  516. my $bestBlock;
  517. foreach (@blocks) {
  518. next unless defined $_;
  519. my $dist = distance($monsterPos, $_);
  520. if (!defined $largestDist || $dist > $largestDist) {
  521. $largestDist = $dist;
  522. $bestBlock = $_;
  523. }
  524. }
  526. #message "Time spent: " . (time - $begin) . "n";
  527. #debug_showSpots('runFromTarget', @blocks, $bestBlock);
  528. $args->{avoiding} = 1;
  529. move($bestBlock->{x}, $bestBlock->{y}, $ID);
  531. } elsif ($realMonsterDist > $args->{attackMethod}{maxDistance}
  532.   && timeOut($args->{ai_attack_giveup}, 0.5)) {
  533. # The target monster moved; move to target
  534. $args->{move_start} = time;
  535. $args->{monsterPos} = {%{$monsterPos}};
  537. my $pos = meetingPosition($target, $args->{attackMethod}{maxDistance});
  539. my $dist = sprintf("%.1f", $monsterDist);
  540. debug "Target distance $dist is >$args->{attackMethod}{maxDistance}; moving to target: " .
  541. "from ($myPos->{x},$myPos->{y}) to ($pos->{x},$pos->{y})n", "ai_attack";
  543. my $result = ai_route($field{'name'}, $pos->{x}, $pos->{y},
  544. maxRouteTime => $config{'attackMaxRouteTime'},
  545. attackID => $ID,
  546. noMapRoute => 1,
  547. noAvoidWalls => 1);
  548. if (!$result) {
  549. # Unable to calculate a route to target
  550. $target->{attack_failed} = time;
  551. AI::dequeue;
  552. message T("Unable to calculate a route to target, dropping targetn"), "ai_attack";
  553. if ($config{'teleportAuto_dropTarget'}) {
  554. message T("Teleport due to dropping attack targetn");
  555. useTeleport(1);
  556. }
  557. }
  559. } elsif ((!$config{'runFromTarget'} || $realMonsterDist >= $config{'runFromTarget_dist'})
  560.  && (!$config{'tankMode'} || !$target->{dmgFromYou})) {
  561. # Attack the target. In case of tanking, only attack if it hasn't been hit once.
  562. if (!$args->{firstAttack}) {
  563. $args->{firstAttack} = 1;
  564. my $pos = "$myPos->{x},$myPos->{y}";
  565. debug "Ready to attack target (which is $realMonsterDist blocks away); we're at ($pos)n", "ai_attack";
  566. }
  568. $args->{unstuck}{time} = time if (!$args->{unstuck}{time});
  569. if (!$target->{dmgFromYou} && timeOut($args->{unstuck})) {
  570. # We are close enough to the target, and we're trying to attack it,
  571. # but some time has passed and we still haven't dealed any damage.
  572. # Our recorded position might be out of sync, so try to unstuck
  573. $args->{unstuck}{time} = time;
  574. debug("Attack - trying to unstuckn", "ai_attack");
  575. move($myPos->{x}, $myPos->{y});
  576. $args->{unstuck}{count}++;
  577. }
  579. if ($args->{attackMethod}{type} eq "weapon" && timeOut($timeout{ai_attack})) {
  580. if (Actor::Item::scanConfigAndCheck("attackEquip")) {
  581. #check if item needs to be equipped
  582. Actor::Item::scanConfigAndEquip("attackEquip");
  583. } else {
  584. $messageSender->sendAttack($ID,
  585. ($config{'tankMode'}) ? 0 : 7);
  586. $timeout{ai_attack}{time} = time;
  587. delete $args->{attackMethod};
  588. }
  589. } elsif ($args->{attackMethod}{type} eq "skill") {
  590. my $slot = $args->{attackMethod}{skillSlot};
  591. delete $args->{attackMethod};
  593. ai_setSuspend(0);
  594. my $skill = new Skill(name => lc($config{"attackSkillSlot_$slot"}));
  595. if (!ai_getSkillUseType($skill->getHandle())) {
  596. ai_skillUse(
  597. $skill->getHandle(),
  598. $config{"attackSkillSlot_${slot}_lvl"},
  599. $config{"attackSkillSlot_${slot}_maxCastTime"},
  600. $config{"attackSkillSlot_${slot}_minCastTime"},
  601. $config{"attackSkillSlot_${slot}_isSelfSkill"} ? $accountID : $ID,
  602. undef,
  603. "attackSkill",
  604. undef,
  605. undef,
  606. "attackSkillSlot_${slot}");
  607. } else {
  608. my $pos = calcPosition($config{"attackSkillSlot_${slot}_isSelfSkill"} ? $char : $target);
  609. ai_skillUse(
  610. $skill->getHandle(),
  611. $config{"attackSkillSlot_${slot}_lvl"},
  612. $config{"attackSkillSlot_${slot}_maxCastTime"},
  613. $config{"attackSkillSlot_${slot}_minCastTime"},
  614. $pos->{x},
  615. $pos->{y},
  616. "attackSkill",
  617. undef,
  618. undef,
  619. "attackSkillSlot_${slot}");
  620. }
  621. $args->{monsterID} = $ID;
  623. debug "Auto-skill on monster ".getActorName($ID).": ".qq~$config{"attackSkillSlot_$slot"} (lvl $config{"attackSkillSlot_${slot}_lvl"})n~, "ai_attack";
  625. } elsif ($args->{attackMethod}{type} eq "combo") {
  626. my $slot = $args->{attackMethod}{comboSlot};
  627. my $isSelfSkill = $args->{attackMethod}{isSelfSkill};
  628. my $skill = Skill->new(name => $config{"attackComboSlot_$slot"})->getHandle();
  629. delete $args->{attackMethod};
  631. if (!ai_getSkillUseType($skill)) {
  632. my $targetID = ($isSelfSkill) ? $accountID : $ID;
  633. ai_skillUse(
  634. $skill,
  635. $config{"attackComboSlot_${slot}_lvl"},
  636. $config{"attackComboSlot_${slot}_maxCastTime"},
  637. $config{"attackComboSlot_${slot}_minCastTime"},
  638. $targetID,
  639. undef,
  640. undef,
  641. undef,
  642. $config{"attackComboSlot_${slot}_waitBeforeUse"});
  643. } else {
  644. my $pos = ($isSelfSkill) ? $char->{pos_to} : $target->{pos_to};
  645. ai_skillUse(
  646. $skill,
  647. $config{"attackComboSlot_${slot}_lvl"},
  648. $config{"attackComboSlot_${slot}_maxCastTime"},
  649. $config{"attackComboSlot_${slot}_minCastTime"},
  650. $pos->{x},
  651. $pos->{y},
  652. undef,
  653. undef,
  654. $config{"attackComboSlot_${slot}_waitBeforeUse"});
  655. }
  656. $args->{monsterID} = $ID;
  657. }
  659. } elsif ($config{tankMode}) {
  660. if ($args->{dmgTo_last} != $target->{dmgTo}) {
  661. $args->{ai_attack_giveup}{time} = time;
  662. }
  663. $args->{dmgTo_last} = $target->{dmgTo};
  664. }
  665. }
  667. 1;