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

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

外挂编程

开发平台：

Windows_Unix

CoreLogic.pm.svn-base：源码内容
  1. #########################################################################
  2. #  OpenKore - AI
  3. #  Copyright (c) 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 core AI logic.
  19. package AI::CoreLogic;
  20. use strict;
  21. use Time::HiRes qw(time);
  22. use Carp::Assert;
  23. use IO::Socket;
  24. use Text::ParseWords;
  25. use encoding 'utf8';
  27. use Globals;
  28. use Log qw(message warning error debug);
  29. use Network::Send ();
  30. use Settings;
  31. use AI;
  32. use AI::SlaveManager;
  33. use ChatQueue;
  34. use Utils;
  35. use Misc;
  36. use Commands;
  37. use Network;
  38. use FileParsers;
  39. use Translation;
  40. use Field;
  41. use Task::TalkNPC;
  42. use Utils::Exceptions;
  44. # This is the main function from which the rest of the AI
  45. # will be invoked.
  46. sub iterate {
  47. Benchmark::begin("ai_prepare") if DEBUG;
  48. processWipeOldActors();
  49. processGetPlayerInfo();
  50. processMisc();
  51. processPortalRecording();
  52. Benchmark::end("ai_prepare") if DEBUG;
  54. return if (!$AI);
  55. if ($net->clientAlive() && !$sentWelcomeMessage && timeOut($timeout{welcomeText})) {
  56. $messageSender->injectAdminMessage($Settings::welcomeText) if ($config{'verbose'} && !$config{'XKore_silent'});
  57. $sentWelcomeMessage = 1;
  58. }
  61. ##### MANUAL AI STARTS HERE #####
  63. Plugins::callHook('AI_pre/manual');
  64. Benchmark::begin("AI (part 1)") if DEBUG;
  65. return if processClientSuspend();
  66. Benchmark::begin("AI (part 1.1)") if DEBUG;
  67. processLook();
  68. processNPCTalk();
  69. processEquip();
  70. processDrop();
  71. processEscapeUnknownMaps();
  72. Benchmark::end("AI (part 1.1)") if DEBUG;
  73. Benchmark::begin("AI (part 1.2)") if DEBUG;
  74. processDelayedTeleport();
  75. processTask("sitting");
  76. processTask("standing");
  77. AI::Attack::process();
  78. Benchmark::end("AI (part 1.2)") if DEBUG;
  79. Benchmark::begin("AI (part 1.3)") if DEBUG;
  80. processSkillUse();
  81. processAutoCommandUse();
  82. processTask("route", onError => sub {
  83. my ($task, $error) = @_;
  84. if (!($task->isa('Task::MapRoute') && $error->{code} == Task::MapRoute::TOO_MUCH_TIME())
  85.  && !($task->isa('Task::Route') && $error->{code} == Task::Route::TOO_MUCH_TIME())) {
  86. error("$error->{message}n");
  87. }
  88. });
  89. processTake();
  90. processMove();
  91. Benchmark::end("AI (part 1.3)") if DEBUG;
  93. Benchmark::begin("AI (part 1.4)") if DEBUG;
  94. Benchmark::begin("ai_autoItemUse") if DEBUG;
  95. processAutoItemUse();
  96. Benchmark::end("ai_autoItemUse") if DEBUG;
  97. Benchmark::begin("ai_autoSkillUse") if DEBUG;
  98. processAutoSkillUse();
  99. Benchmark::end("ai_autoSkillUse") if DEBUG;
  100. Benchmark::end("AI (part 1.4)") if DEBUG;
  102. Benchmark::end("AI (part 1)") if DEBUG;
  106. Misc::checkValidity("AI part 1");
  107. return if ($AI != 2);
  110. ##### AUTOMATIC AI STARTS HERE #####
  112. Plugins::callHook('AI_pre');
  113. Benchmark::begin("AI (part 2)") if DEBUG;
  115. ChatQueue::processFirst;
  117. processDcOnPlayer();
  118. processDeal();
  119. processDealAuto();
  120. processPartyAuto();
  121. processGuildAutoDeny();
  123. Misc::checkValidity("AI part 1.1");
  124. processAutoBreakTime();
  125. processDead();
  126. processStorageGet();
  127. processCartAdd();
  128. processCartGet();
  129. processAutoMakeArrow();
  130. Benchmark::end("AI (part 2)") if DEBUG;
  131. Misc::checkValidity("AI part 2");
  134. Benchmark::begin("AI (part 3)") if DEBUG;
  135. Benchmark::begin("AI (part 3.1)") if DEBUG;
  136. processAutoStorage();
  137. Misc::checkValidity("AI (autostorage)");
  138. processAutoSell();
  139. Misc::checkValidity("AI (autosell)");
  140. processAutoBuy();
  141. Misc::checkValidity("AI (autobuy)");
  142. processAutoCart();
  143. Misc::checkValidity("AI (autocart)");
  144. Benchmark::end("AI (part 3.1)") if DEBUG;
  146. Benchmark::begin("AI (part 3.2)") if DEBUG;
  147. processLockMap();
  148. processAutoStatsRaise();
  149. processAutoSkillsRaise();
  150. processRandomWalk();
  151. processFollow();
  152. Benchmark::end("AI (part 3.2)") if DEBUG;
  154. Benchmark::begin("AI (part 3.3)") if DEBUG;
  155. processSitAutoIdle();
  156. processSitAuto();
  159. Benchmark::end("AI (part 3.3)") if DEBUG;
  160. Benchmark::end("AI (part 3)") if DEBUG;
  162. Benchmark::begin("AI (part 4)") if DEBUG;
  163. processPartySkillUse();
  164. processMonsterSkillUse();
  166. Misc::checkValidity("AI part 3");
  167. processAutoEquip();
  168. processAutoAttack();
  169. processItemsTake();
  170. processItemsAutoGather();
  171. processItemsGather();
  172. processAutoTeleport();
  173. processAllowedMaps();
  174. processAutoResponse();
  175. processAvoid();
  176. processSendEmotion();
  177. processAutoShopOpen();
  178. processRepairAuto();
  179. Benchmark::end("AI (part 4)") if DEBUG;
  182. ##########
  184. # DEBUG CODE
  185. if (timeOut($ai_v{time}, 2) && $config{'debug'} >= 2) {
  186. my $len = @ai_seq_args;
  187. debug "AI: @ai_seq | $lenn", "ai", 2;
  188. $ai_v{time} = time;
  189. }
  190. $ai_v{'AI_last_finished'} = time;
  192. if ($cmdQueue && timeOut($cmdQueueStartTime,$cmdQueueTime)) {
  193. my $execCommand = '';
  194. if (@cmdQueueList) {
  195. $execCommand = join (";;", @cmdQueueList);
  196. } else {
  197. $execCommand = $cmdQueueList[0];
  198. }
  199. @cmdQueueList = ();
  200. $cmdQueue = 0;
  201. $cmdQueueTime = 0;
  202. debug "Executing queued command: $execCommandn", "ai";
  203. Commands::run($execCommand);
  204. }
  207. Plugins::callHook('AI_post');
  208. }
  211. #############################################################
  214. # Wipe old entries in the %actor_old hashes.
  215. sub processWipeOldActors {
  216. if (timeOut($timeout{ai_wipe_check})) {
  217. my $timeout = $timeout{ai_wipe_old}{timeout};
  219. foreach (keys %players_old) {
  220. if (timeOut($players_old{$_}{'gone_time'}, $timeout)) {
  221. delete $players_old{$_};
  222. binRemove(@playersID_old, $_);
  223. }
  224. }
  225. foreach (keys %monsters_old) {
  226. if (timeOut($monsters_old{$_}{'gone_time'}, $timeout)) {
  227. delete $monsters_old{$_};
  228. binRemove(@monstersID_old, $_);
  229. }
  230. }
  231. foreach (keys %npcs_old) {
  232. delete $npcs_old{$_} if (time - $npcs_old{$_}{'gone_time'} >= $timeout{'ai_wipe_old'}{'timeout'});
  233. }
  234. foreach (keys %items_old) {
  235. delete $items_old{$_} if (time - $items_old{$_}{'gone_time'} >= $timeout{'ai_wipe_old'}{'timeout'});
  236. }
  237. foreach (keys %portals_old) {
  238. if (timeOut($portals_old{$_}{gone_time}, $timeout)) {
  239. delete $portals_old{$_};
  240. binRemove(@portalsID_old, $_);
  241. }
  242. }
  244. # Remove players that are too far away; sometimes they don't get
  245. # removed from the list for some reason
  246. #foreach (keys %players) {
  247. # if (distance($char->{pos_to}, $players{$_}{pos_to}) > 35) {
  248. # $playersList->remove($players{$_});
  249. # last;
  250. # }
  251. #}
  253. $timeout{'ai_wipe_check'}{'time'} = time;
  254. debug "Wiped oldn", "ai", 2;
  255. }
  256. }
  258. sub processGetPlayerInfo {
  259. if (timeOut($timeout{ai_getInfo})) {
  260. processNameRequestQueue(@unknownPlayers, [$playersList, $slavesList]);
  261. processNameRequestQueue(@unknownNPCs, [$npcsList]);
  263. foreach (keys %monsters) {
  264. if ($monsters{$_}{'name'} =~ /Unknown/) {
  265. $messageSender->sendGetPlayerInfo($_);
  266. last;
  267. }
  268. if ($monsters{$_}{'name_given'} =~ /Unknown/) {
  269. $messageSender->sendGetPlayerInfo($_);
  270. last;
  271. }
  272. }
  273. foreach (keys %pets) {
  274. if ($pets{$_}{'name_given'} =~ /Unknown/) {
  275. $messageSender->sendGetPlayerInfo($_);
  276. last;
  277. }
  278. }
  279. $timeout{ai_getInfo}{time} = time;
  280. }
  281. }
  283. sub processMisc {
  284. if (timeOut($timeout{ai_sync})) {
  285. $timeout{ai_sync}{time} = time;
  286. $messageSender->sendSync();
  287. }
  289. if (timeOut($char->{muted}, $char->{mute_period})) {
  290. delete $char->{muted};
  291. delete $char->{mute_period};
  292. }
  293. }
  295. ##### CLIENT SUSPEND #####
  296. # The clientSuspend AI sequence is used to freeze all other AI activity
  297. # for a certain period of time.
  298. sub processClientSuspend {
  299. my $result = 0;
  300. if (AI::action eq 'clientSuspend' && timeOut(AI::args)) {
  301. debug "AI suspend by clientSuspend dequeuedn";
  302. AI::dequeue;
  303. } elsif (AI::action eq "clientSuspend" && $net->clientAlive()) {
  304. # When XKore mode is turned on, clientSuspend will increase it's timeout
  305. # every time the user tries to do something manually.
  306. my $args = AI::args;
  308. if ($args->{'type'} eq "0089") {
  309. # Player's manually attacking
  310. if ($args->{'args'}[0] == 2) {
  311. if ($chars[$config{'char'}]{'sitting'}) {
  312. $args->{'time'} = time;
  313. }
  314. } elsif ($args->{'args'}[0] == 3) {
  315. $args->{'timeout'} = 6;
  316. } else {
  317. my $ID = $args->{args}[1];
  318. my $monster = $monstersList->getByID($ID);
  320. if (!$args->{'forceGiveup'}{'timeout'}) {
  321. $args->{'forceGiveup'}{'timeout'} = 6;
  322. $args->{'forceGiveup'}{'time'} = time;
  323. }
  324. if ($monster) {
  325. $args->{time} = time;
  326. $args->{dmgFromYou_last} = $monster->{dmgFromYou};
  327. $args->{missedFromYou_last} = $monster->{missedFromYou};
  328. if ($args->{dmgFromYou_last} != $monster->{dmgFromYou}) {
  329. $args->{forceGiveup}{time} = time;
  330. }
  331. } else {
  332. $args->{time} -= $args->{'timeout'};
  333. }
  334. if (timeOut($args->{forceGiveup})) {
  335. $args->{time} -= $args->{timeout};
  336. }
  337. }
  339. } elsif ($args->{'type'} eq "009F") {
  340. # Player's manually picking up an item
  341. if (!$args->{'forceGiveup'}{'timeout'}) {
  342. $args->{'forceGiveup'}{'timeout'} = 4;
  343. $args->{'forceGiveup'}{'time'} = time;
  344. }
  345. if ($items{$args->{'args'}[0]}) {
  346. $args->{'time'} = time;
  347. } else {
  348. $args->{'time'} -= $args->{'timeout'};
  349. }
  350. if (timeOut($args->{'forceGiveup'})) {
  351. $args->{'time'} -= $args->{'timeout'};
  352. }
  353. }
  355. # Client suspended, do not continue with AI
  356. $result = 1;
  357. }
  358. return $result;
  359. }
  361. sub processLook {
  362. if (AI::action eq "look" && timeOut($timeout{'ai_look'})) {
  363. $timeout{'ai_look'}{'time'} = time;
  364. $messageSender->sendLook(AI::args->{'look_body'}, AI::args->{'look_head'});
  365. AI::dequeue;
  366. }
  367. }
  369. ##### TALK WITH NPC ######
  370. sub processNPCTalk {
  371. return if (AI::action ne "NPC");
  372. my $args = AI::args;
  373. my $task = $args->{task};
  374. if (!$task) {
  375. $task = new Task::TalkNPC(x => $args->{pos}{x},
  376. y => $args->{pos}{y},
  377. sequence => $args->{sequence});
  378. $task->activate();
  379. $args->{task} = $task;
  380. } else {
  381. $task->iterate();
  382. if ($task->getStatus() == Task::DONE) {
  383. AI::dequeue;
  384. my $error = $task->getError();
  385. if ($error) {
  386. error("$error->{message}n", "ai_npcTalk");
  387. } else {
  388. message TF("Done talking with %s.n", $task->target()->name), "ai_npcTalk";
  389. }
  390. }
  391. }
  392. }
  394. ##### DROPPING #####
  395. # Drop one or more items from inventory.
  396. sub processDrop {
  397. if (AI::action eq "drop" && timeOut(AI::args)) {
  398. my $item = AI::args->{'items'}[0];
  399. my $amount = AI::args->{max};
  401. drop($item, $amount);
  402. shift @{AI::args->{items}};
  403. AI::args->{time} = time;
  404. AI::dequeue if (@{AI::args->{'items'}} <= 0);
  405. }
  406. }
  408. ##### PORTALRECORD #####
  409. # Automatically record new unknown portals
  410. sub processPortalRecording {
  411. return unless $config{portalRecord};
  412. return unless $ai_v{portalTrace_mapChanged} && timeOut($ai_v{portalTrace_mapChanged}, 0.5);
  413. delete $ai_v{portalTrace_mapChanged};
  415. debug "Checking for new portals...n", "portalRecord";
  416. my $first = 1;
  417. my ($foundID, $smallDist, $dist);
  419. if (!$field{name}) {
  420. debug "Field name not known - abortn", "portalRecord";
  421. return;
  422. }
  425. # Find the nearest portal or the only portal on the map
  426. # you came from (source portal)
  427. foreach (@portalsID_old) {
  428. next if (!$_);
  429. $dist = distance($char->{old_pos_to}, $portals_old{$_}{pos});
  430. if ($dist <= 7 && ($first || $dist < $smallDist)) {
  431. $smallDist = $dist;
  432. $foundID = $_;
  433. undef $first;
  434. }
  435. }
  437. my ($sourceMap, $sourceID, %sourcePos, $sourceIndex);
  438. if (defined $foundID) {
  439. $sourceMap = $portals_old{$foundID}{source}{map};
  440. $sourceID = $portals_old{$foundID}{nameID};
  441. %sourcePos = %{$portals_old{$foundID}{pos}};
  442. $sourceIndex = $foundID;
  443. debug "Source portal: $sourceMap ($sourcePos{x}, $sourcePos{y})n", "portalRecord";
  444. } else {
  445. debug "No source portal found.n", "portalRecord";
  446. return;
  447. }
  449. #if (defined portalExists($sourceMap, %sourcePos)) {
  450. # debug "Source portal is already in portals.txt - abortn", "portalRecord";
  451. # return;
  452. #}
  455. # Find the nearest portal or only portal on the
  456. # current map (destination portal)
  457. $first = 1;
  458. undef $foundID;
  459. undef $smallDist;
  461. foreach (@portalsID) {
  462. next if (!$_);
  463. $dist = distance($chars[$config{'char'}]{pos_to}, $portals{$_}{pos});
  464. if ($first || $dist < $smallDist) {
  465. $smallDist = $dist;
  466. $foundID = $_;
  467. undef $first;
  468. }
  469. }
  471. # Sanity checks
  472. if (!defined $foundID) {
  473. debug "No destination portal found.n", "portalRecord";
  474. return;
  475. }
  476. #if (defined portalExists($field{name}, $portals{$foundID}{pos})) {
  477. # debug "Destination portal is already in portals.txtn", "portalRecord";
  478. # last PORTALRECORD;
  479. #}
  480. if (defined portalExists2($sourceMap, %sourcePos, $field{name}, $portals{$foundID}{pos})) {
  481. debug "This portal is already in portals.txtn", "portalRecord";
  482. return;
  483. }
  486. # And finally, record the portal information
  487. my ($destMap, $destID, %destPos);
  488. $destMap = $field{name};
  489. $destID = $portals{$foundID}{nameID};
  490. %destPos = %{$portals{$foundID}{pos}};
  491. debug "Destination portal: $destMap ($destPos{x}, $destPos{y})n", "portalRecord";
  493. $portals{$foundID}{name} = "$field{name} -> $sourceMap";
  494. $portals_old{$sourceIndex}{name} = "$sourceMap -> $field{name}";
  497. my ($ID, $destName);
  499. # Record information about destination portal
  500. if ($config{portalRecord} > 1 &&
  501.     !defined portalExists($field{name}, $portals{$foundID}{pos})) {
  502. $ID = "$field{name} $destPos{x} $destPos{y}";
  503. $portals_lut{$ID}{source}{map} = $field{name};
  504. $portals_lut{$ID}{source}{x} = $destPos{x};
  505. $portals_lut{$ID}{source}{y} = $destPos{y};
  506. $destName = "$sourceMap $sourcePos{x} $sourcePos{y}";
  507. $portals_lut{$ID}{dest}{$destName}{map} = $sourceMap;
  508. $portals_lut{$ID}{dest}{$destName}{x} = $sourcePos{x};
  509. $portals_lut{$ID}{dest}{$destName}{y} = $sourcePos{y};
  511. message TF("Recorded new portal (destination): %s (%s, %s) -> %s (%s, %s)n", $field{name}, $destPos{x}, $destPos{y}, $sourceMap, $sourcePos{x}, $sourcePos{y}), "portalRecord";
  512. updatePortalLUT(Settings::getTableFilename("portals.txt"),
  513. $field{name}, $destPos{x}, $destPos{y},
  514. $sourceMap, $sourcePos{x}, $sourcePos{y});
  515. }
  517. # Record information about the source portal
  518. if (!defined portalExists($sourceMap, %sourcePos)) {
  519. $ID = "$sourceMap $sourcePos{x} $sourcePos{y}";
  520. $portals_lut{$ID}{source}{map} = $sourceMap;
  521. $portals_lut{$ID}{source}{x} = $sourcePos{x};
  522. $portals_lut{$ID}{source}{y} = $sourcePos{y};
  523. $destName = "$field{name} $destPos{x} $destPos{y}";
  524. $portals_lut{$ID}{dest}{$destName}{map} = $field{name};
  525. $portals_lut{$ID}{dest}{$destName}{x} = $destPos{x};
  526. $portals_lut{$ID}{dest}{$destName}{y} = $destPos{y};
  528. message TF("Recorded new portal (source): %s (%s, %s) -> %s (%s, %s)n", $sourceMap, $sourcePos{x}, $sourcePos{y}, $field{name}, $char->{pos}{x}, $char->{pos}{y}), "portalRecord";
  529. updatePortalLUT(Settings::getTableFilename("portals.txt"),
  530. $sourceMap, $sourcePos{x}, $sourcePos{y},
  531. $field{name}, $char->{pos}{x}, $char->{pos}{y});
  532. }
  533. }
  535. ##### ESCAPE UNKNOWN MAPS #####
  536. sub processEscapeUnknownMaps {
  537. # escape from unknown maps. Happens when kore accidentally teleports onto an
  538. # portal. With this, kore should automaticly go into the portal on the other side
  539. # Todo: Make kore do a random walk searching for portal if there's no portal arround.
  541. if (AI::action eq "escape" && $AI == 2) {
  542. my $skip = 0;                   
  543. if (timeOut($timeout{ai_route_escape}) && $timeout{ai_route_escape}{time}){
  544. AI::dequeue;
  545. if ($portalsID[0]) {
  546. message T("Escaping to into nearest portal.n");
  547. main::ai_route($field{name}, $portals{$portalsID[0]}{'pos'}{'x'},
  548. $portals{$portalsID[0]}{'pos'}{'y'}, attackOnRoute => 1, noSitAuto => 1);
  549. $skip = 1;
  551. } elsif ($spellsID[0]){   #get into the first portal you see
  552.      my $spell = $spells{$spellsID[0]};
  553. if (getSpellName($spell->{type}) eq "Warp Portal" ){
  554. message T("Found warp portal escaping into warp portal.n");
  555. main::ai_route($field{name}, $spell->{pos}{x},
  556. $spell->{pos}{y}, attackOnRoute => 1, noSitAuto => 1);
  557. $skip = 1;
  558. }else{
  559. error T("Escape failed no portal found.n");;
  560. }
  562. } else {
  563. error T("Escape failed no portal found.n");
  564. }
  565. }
  566. if ($config{route_escape_randomWalk} && !$skip) { #randomly search for portals...
  567. my ($randX, $randY);
  568. my $i = 500;
  569. my $pos = calcPosition($char);
  570. do {
  571. if ((rand(2)+1)%2) {
  572. $randX = $pos->{x} + int(rand(9) + 1);
  573. } else {
  574. $randX = $pos->{x} - int(rand(9) + 1);
  575. }
  576. if ((rand(2)+1)%2) {
  577. $randY = $pos->{y} + int(rand(9) + 1);
  578. } else {
  579. $randY = $pos->{y} - int(rand(9) + 1);
  580. }
  581. } while (--$i && !$field->isWalkable($randX, $randY));
  582. if (!$i) {
  583. error T("Invalid coordinates specified for randomWalkn Retrying...");
  584. } else {
  585. message TF("Calculating random route to: %s(%s): %s, %sn", $maps_lut{$field{name}.'.rsw'}, $field{name}, $randX, $randY), "route";
  586. ai_route($field{name}, $randX, $randY,
  587.  maxRouteTime => $config{route_randomWalk_maxRouteTime},
  588.  attackOnRoute => 2,
  589.  noMapRoute => ($config{route_randomWalk} == 2 ? 1 : 0) );
  590. }
  591. }
  592. }
  593. }
  595. ##### DELAYED-TELEPORT #####
  596. sub processDelayedTeleport {
  597. if (AI::action eq 'teleport') {
  598. if ($timeout{ai_teleport_delay}{time} && timeOut($timeout{ai_teleport_delay})) {
  599. # We have already successfully used the Teleport skill,
  600. # and the ai_teleport_delay timeout has elapsed
  601. $messageSender->sendTeleport(AI::args->{lv} == 2 ? "$config{saveMap}.gat" : "Random");
  602. AI::dequeue;
  603. } elsif (!$timeout{ai_teleport_delay}{time} && timeOut($timeout{ai_teleport_retry})) {
  604. # We are still trying to use the Teleport skill
  605. $messageSender->sendSkillUse(26, $char->{skills}{AL_TELEPORT}{lv}, $accountID);
  606. $timeout{ai_teleport_retry}{time} = time;
  607. }
  608. }
  609. }
  611. ##### SKILL USE #####
  612. sub processSkillUse {
  613. #FIXME: need to move closer before using skill on player,
  614. #there might be line of sight problem too
  615. #or the player disappers from the area
  617. if (AI::action eq "skill_use" && AI::args->{suspended}) {
  618. AI::args->{giveup}{time} += time - AI::args->{suspended};
  619. AI::args->{minCastTime}{time} += time - AI::args->{suspended};
  620. AI::args->{maxCastTime}{time} += time - AI::args->{suspended};
  621. delete AI::args->{suspended};
  622. }
  624. SKILL_USE: {
  625. last SKILL_USE if (AI::action ne "skill_use");
  626. my $args = AI::args;
  628. if ($args->{monsterID} && $skillsArea{$args->{skillHandle}} == 2) {
  629. delete $args->{monsterID};
  630. }
  632. if (exists $args->{ai_equipAuto_skilluse_giveup} && binFind(@skillsID, $args->{skillHandle}) eq "" && timeOut($args->{ai_equipAuto_skilluse_giveup})) {
  633. warning T("Timeout equiping for skilln");
  634. AI::dequeue;
  635. ${$args->{ret}} = 'equip timeout' if ($args->{ret});
  636. } elsif (Actor::Item::scanConfigAndCheck("$args->{prefix}_equip")) {
  637. #check if item needs to be equipped
  638. Actor::Item::scanConfigAndEquip("$args->{prefix}_equip");
  639. } elsif (timeOut($args->{waitBeforeUse})) {
  640. if (defined $args->{monsterID} && !defined $monsters{$args->{monsterID}}) {
  641. # This skill is supposed to be used for attacking a monster, but that monster has died
  642. AI::dequeue;
  643. ${$args->{ret}} = 'target gone' if ($args->{ret});
  645. } elsif ($char->{sitting}) {
  646. AI::suspend;
  647. stand();
  649. # Use skill if we haven't done so yet
  650. } elsif (!$args->{skill_used}) {
  651. my $handle = $args->{skillHandle};
  652. if (!defined $args->{skillID}) {
  653. my $skill = new Skill(handle => $handle);
  654. $args->{skillID} = $skill->getIDN();
  655. }
  656. my $skillID = $args->{skillID};
  658. if ($handle eq 'AL_TELEPORT') {
  659. ${$args->{ret}} = 'ok' if ($args->{ret});
  660. AI::dequeue;
  661. useTeleport($args->{lv});
  662. last SKILL_USE;
  663. }
  665. $args->{skill_used} = 1;
  666. $args->{giveup}{time} = time;
  668. # Stop attacking, otherwise skill use might fail
  669. my $attackIndex = AI::findAction("attack");
  670. if (defined($attackIndex) && AI::args($attackIndex)->{attackMethod}{type} eq "weapon") {
  671. # 2005-01-24 pmak: Commenting this out since it may
  672. # be causing bot to attack slowly when a buff runs
  673. # out.
  674. #stopAttack();
  675. }
  677. # Give an error if we don't actually possess this skill
  678. my $skill = new Skill(handle => $handle);
  679. if ($char->{skills}{$handle}{lv} <= 0 && (!$char->{permitSkill} || $char->{permitSkill}->getHandle() ne $handle)) {
  680. debug "Attempted to use skill (".$skill->getName().") which you do not have.n";
  681. }
  683. $args->{maxCastTime}{time} = time;
  684. if ($skillsArea{$handle} == 2) {
  685. $messageSender->sendSkillUse($skillID, $args->{lv}, $accountID);
  686. } elsif ($args->{x} ne "") {
  687. $messageSender->sendSkillUseLoc($skillID, $args->{lv}, $args->{x}, $args->{y});
  688. } else {
  689. $messageSender->sendSkillUse($skillID, $args->{lv}, $args->{target});
  690. }
  691. undef $char->{permitSkill};
  692. $args->{skill_use_last} = $char->{skills}{$handle}{time_used};
  694. delete $char->{cast_cancelled};
  696. } elsif (timeOut($args->{minCastTime})) {
  697. if ($args->{skill_use_last} != $char->{skills}{$args->{skillHandle}}{time_used}) {
  698. AI::dequeue;
  699. ${$args->{ret}} = 'ok' if ($args->{ret});
  701. } elsif ($char->{cast_cancelled} > $char->{time_cast}) {
  702. AI::dequeue;
  703. ${$args->{ret}} = 'cancelled' if ($args->{ret});
  705. } elsif (timeOut($char->{time_cast}, $char->{time_cast_wait} + 0.5)
  706.   && ( (timeOut($args->{giveup}) && (!$char->{time_cast} || !$args->{maxCastTime}{timeout}) )
  707.       || ( $args->{maxCastTime}{timeout} && timeOut($args->{maxCastTime})) )
  708. ) {
  709. AI::dequeue;
  710. ${$args->{ret}} = 'timeout' if ($args->{ret});
  711. }
  712. }
  713. }
  714. }
  715. }
  717. sub processTask {
  718. my $ai_name = shift;
  719. if (AI::action eq $ai_name) {
  720. my $task = AI::args;
  721. if ($task->getStatus() == Task::INACTIVE) {
  722. $task->activate();
  723. should($task->getStatus(), Task::RUNNING) if DEBUG;
  724. }
  725. if (DEBUG && $task->getStatus() != Task::RUNNING) {
  726. require Scalar::Util;
  727. require Data::Dumper;
  728. # Make sure redundant information is not included in the error report.
  729. if ($task->isa('Task::MapRoute')) {
  730. delete $task->{ST_subtask}{solution};
  731. } elsif ($task->isa('Task::Route') && $task->{ST_subtask}) {
  732. delete $task->{solution};
  733. }
  734. die "Task '" . $task->getName() . "' (class " . Scalar::Util::blessed($task) . ") has status " .
  735. Task::_getStatusName($task->getStatus()) .
  736. ", but should be RUNNING. Object details:n" .
  737. Data::Dumper::Dumper($task);
  738. }
  739. $task->iterate();
  740. if ($task->getStatus() == Task::DONE) {
  741. # We can't just dequeue the last AI sequence. Perhaps the task
  742. # pushed a new AI sequence on the AI stack just before finishing.
  743. # For example, the Route task does that when it's stuck.
  744. # So, we must dequeue the correct sequence without affecting the
  745. # others.
  746. for (my $i = 0; $i < @AI::ai_seq; $i++) {
  747. if ($AI::ai_seq[$i] eq $ai_name) {
  748. splice(@AI::ai_seq, $i, 1);
  749. splice(@AI::ai_seq_args, $i, 1);
  750. last;
  751. }
  752. }
  753. my %args = @_;
  754. my $error = $task->getError();
  755. if ($error) {
  756. if ($args{onError}) {
  757. $args{onError}->($task, $error);
  758. } else {
  759. error("$error->{message}n");
  760. }
  761. } elsif ($args{onSuccess}) {
  762. $args{onSuccess}->($task);
  763. }
  764. }
  765. }
  766. }
  768. sub processTake {
  769. ##### TAKE #####
  771. if (AI::action eq "take" && AI::args->{suspended}) {
  772. AI::args->{ai_take_giveup}{time} += time - AI::args->{suspended};
  773. delete AI::args->{suspended};
  774. }
  776. if (AI::action eq "take" && ( !$items{AI::args->{ID}} || !%{$items{AI::args->{ID}}} )) {
  777. AI::dequeue;
  779. } elsif (AI::action eq "take" && timeOut(AI::args->{ai_take_giveup})) {
  780. my $item = $items{AI::args->{ID}};
  781. message TF("Failed to take %s (%s) from (%s, %s) to (%s, %s)n", $item->{name}, $item->{binID}, $char->{pos}{x}, $char->{pos}{y}, $item->{pos}{x}, $item->{pos}{y});
  782. $items{AI::args->{ID}}{take_failed}++;
  783. AI::dequeue;
  785. } elsif (AI::action eq "take") {
  786. my $ID = AI::args->{ID};
  787. my $myPos = $char->{pos_to};
  788. my $dist = round(distance($items{$ID}{pos}, $myPos));
  789. my $item = $items{AI::args->{ID}};
  790. debug "Planning to take $item->{name} ($item->{binID}), distance $distn", "drop";
  792. if ($char->{sitting}) {
  793. stand();
  795. } elsif ($dist > 1) {
  796. if (!$config{itemsTakeAuto_new}) {
  797. my (%vec, %pos);
  798. getVector(%vec, $item->{pos}, $myPos);
  799. moveAlongVector(%pos, $myPos, %vec, $dist - 1);
  800. move($pos{x}, $pos{y});
  801. } else {
  802. my $pos = $item->{pos};
  803. message TF("Routing to (%s, %s) to take %s (%s), distance %sn", $pos->{x}, $pos->{y}, $item->{name}, $item->{binID}, $dist);
  804. ai_route($field{name}, $pos->{x}, $pos->{y}, maxRouteDistance => $config{'attackMaxRouteDistance'});
  805. }
  807. } elsif (timeOut($timeout{ai_take})) {
  808. my %vec;
  809. my $direction;
  810. getVector(%vec, $item->{pos}, $myPos);
  811. $direction = int(sprintf("%.0f", (360 - vectorToDegree(%vec)) / 45)) % 8;
  812. $messageSender->sendLook($direction, 0) if ($direction != $char->{look}{body});
  813. $messageSender->sendTake($ID);
  814. $timeout{ai_take}{time} = time;
  815. }
  816. }
  817. }
  819. ##### MOVE #####
  820. sub processMove {
  821. if (AI::action eq "move") {
  822. AI::args->{ai_move_giveup}{time} = time unless AI::args->{ai_move_giveup}{time};
  824. # Wait until we've stand up, if we're sitting
  825. if ($char->{sitting}) {
  826. AI::args->{ai_move_giveup}{time} = 0;
  827. stand();
  829. # Stop if the map changed
  830. } elsif (AI::args->{mapChanged}) {
  831. debug "Move - map change detectedn", "ai_move";
  832. AI::dequeue;
  834. # Stop if we've moved
  835. } elsif (AI::args->{time_move} != $char->{time_move}) {
  836. debug "Move - movingn", "ai_move";
  837. AI::dequeue;
  839. # Stop if we've timed out
  840. } elsif (timeOut(AI::args->{ai_move_giveup})) {
  841. debug "Move - timeoutn", "ai_move";
  842. AI::dequeue;
  844. } elsif (timeOut($AI::Timeouts::move_retry, 0.5)) {
  845. # No update yet, send move request again.
  846. # We do this every 0.5 secs
  847. $AI::Timeouts::move_retry = time;
  848. $messageSender->sendMove(AI::args->{move_to}{x}, AI::args->{move_to}{y});
  849. }
  850. }
  851. }
  853. sub processEquip {
  854. if (AI::action eq "equip") {
  855. # Just wait until everything is equipped or timedOut
  856. if (!$ai_v{temp}{waitForEquip} || timeOut($timeout{ai_equip_giveup})) {
  857. AI::dequeue;
  858. delete $ai_v{temp}{waitForEquip};
  859. }
  860. }
  861. }
  863. sub processDeal {
  864. if (AI::action ne "deal" && %currentDeal) {
  865. AI::queue('deal');
  866. } elsif (AI::action eq "deal") {
  867. if (%currentDeal) {
  868. if (!$currentDeal{you_finalize} && timeOut($timeout{ai_dealAuto}) &&
  869. (!$config{dealAuto_names} || existsInList($config{dealAuto_names}, $currentDeal{name})) &&
  870.     ($config{dealAuto} == 2 ||
  871.  $config{dealAuto} == 3 && $currentDeal{other_finalize})) {
  872. $messageSender->sendDealAddItem(0, $currentDeal{'you_zenny'});
  873. $messageSender->sendDealFinalize();
  874. $timeout{ai_dealAuto}{time} = time;
  875. } elsif ($currentDeal{other_finalize} && $currentDeal{you_finalize} &&timeOut($timeout{ai_dealAuto}) && $config{dealAuto} >= 2 &&
  876. (!$config{dealAuto_names} || existsInList($config{dealAuto_names}, $currentDeal{name}))) {
  877. $messageSender->sendDealTrade();
  878. $timeout{ai_dealAuto}{time} = time;
  879. }
  880. } else {
  881. AI::dequeue();
  882. }
  883. }
  884. }
  886. sub processDealAuto {
  887. # dealAuto 1=refuse 2,3=accept
  888. if ($config{'dealAuto'} && %incomingDeal) {
  889. if ($config{'dealAuto'} == 1 && timeOut($timeout{ai_dealAutoCancel})) {
  890. $messageSender->sendDealCancel();
  891. $timeout{'ai_dealAuto'}{'time'} = time;
  892. } elsif ($config{'dealAuto'} >= 2 &&
  893. (!$config{dealAuto_names} || existsInList($config{dealAuto_names}, $incomingDeal{name})) &&
  894. timeOut($timeout{ai_dealAuto})) {
  895. $messageSender->sendDealAccept();
  896. $timeout{'ai_dealAuto'}{'time'} = time;
  897. }
  898. }
  899. }
  901. sub processPartyAuto {
  902. # partyAuto 1=refuse 2=accept
  903. if ($config{'partyAuto'} && %incomingParty && timeOut($timeout{'ai_partyAuto'})) {
  904. if ($config{partyAuto} == 1) {
  905. message T("Auto-denying party requestn");
  906. } else {
  907. message T("Auto-accepting party requestn");
  908. }
  909. $messageSender->sendPartyJoin($incomingParty{'ID'}, $config{'partyAuto'} - 1);
  910. $timeout{'ai_partyAuto'}{'time'} = time;
  911. undef %incomingParty;
  912. }
  913. }
  915. sub processGuildAutoDeny {
  916. if ($config{'guildAutoDeny'} && %incomingGuild && timeOut($timeout{'ai_guildAutoDeny'})) {
  917. $messageSender->sendGuildJoin($incomingGuild{'ID'}, 0) if ($incomingGuild{'Type'} == 1);
  918. $messageSender->sendGuildAlly($incomingGuild{'ID'}, 0) if ($incomingGuild{'Type'} == 2);
  919. $timeout{'ai_guildAutoDeny'}{'time'} = time;
  920. undef %incomingGuild;
  921. }
  922. }
  924. ##### AUTOBREAKTIME #####
  925. # Break time: automatically disconnect at certain times of the day
  926. sub processAutoBreakTime {
  927. if (timeOut($AI::Timeouts::autoBreakTime, 30)) {
  928. my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime;
  929. my $hormin = sprintf("%02d:%02d", $hour, $min);
  930. my @wdays = ('sun','mon','tue','wed','thu','fri','sat');
  931. debug "autoBreakTime: hormin = $hormin, weekday = $wdays[$wday]n", "autoBreakTime", 2;
  932. for (my $i = 0; exists $config{"autoBreakTime_$i"}; $i++) {
  933. next if (!$config{"autoBreakTime_$i"});
  935. if  ( ($wdays[$wday] eq lc($config{"autoBreakTime_$i"})) || (lc($config{"autoBreakTime_$i"}) eq "all") ) {
  936. if ($config{"autoBreakTime_${i}_startTime"} eq $hormin) {
  937. my ($hr1, $min1) = split /:/, $config{"autoBreakTime_${i}_startTime"};
  938. my ($hr2, $min2) = split /:/, $config{"autoBreakTime_${i}_stopTime"};
  939. my $time1 = $hr1 * 60 * 60 + $min1 * 60;
  940. my $time2 = $hr2 * 60 * 60 + $min2 * 60;
  941. my $diff = ($time2 - $time1) % (60 * 60 * 24);
  943. message TF("nDisconnecting due to break time: %s to %snn", $config{"autoBreakTime_$i"."_startTime"}, $config{"autoBreakTime_$i"."_stopTime"}), "system";
  944. chatLog("k", TF("*** Disconnected due to Break Time: %s to %s ***n", $config{"autoBreakTime_$i"."_startTime"}, $config{"autoBreakTime_$i"."_stopTime"}));
  946. $timeout_ex{'master'}{'timeout'} = $diff;
  947. $timeout_ex{'master'}{'time'} = time;
  948. $KoreStartTime = time;
  949. $net->serverDisconnect();
  950. AI::clear();
  951. undef %ai_v;
  952. $net->setState(Network::NOT_CONNECTED);
  953. undef $conState_tries;
  954. last;
  955. }
  956. }
  957. }
  958. $AI::Timeouts::autoBreakTime = time;
  959. }
  960. }
  963. ##### DEAD #####
  964. sub processDead {
  965. if (AI::action eq "dead" && !$char->{dead}) {
  966. AI::dequeue;
  968. if ($char->{resurrected}) {
  969. # We've been resurrected
  970. $char->{resurrected} = 0;
  972. } else {
  973. # Force storage after death
  974. if ($config{storageAuto} && !$config{storageAuto_notAfterDeath} && ai_storageAutoCheck()) {
  975. message T("Auto-storaging due to deathn");
  976. AI::queue("storageAuto");
  977. }
  979. if ($config{autoMoveOnDeath} && $config{autoMoveOnDeath_x} && $config{autoMoveOnDeath_y} && $config{autoMoveOnDeath_map}) {
  980. message TF("Moving to %s - %d,%dn", $config{autoMoveOnDeath_map}, $config{autoMoveOnDeath_x}, $config{autoMoveOnDeath_y});
  981. AI::queue("sitAuto");
  982. ai_route($config{autoMoveOnDeath_map}, $config{autoMoveOnDeath_x}, $config{autoMoveOnDeath_y});
  983. }
  985. }
  987. } elsif (AI::action ne "dead" && AI::action ne "deal" && $char->{'dead'}) {
  988. AI::clear();
  989. AI::queue("dead");
  990. }
  992. if (AI::action eq "dead" && $config{dcOnDeath} != -1 && time - $char->{dead_time} >= $timeout{ai_dead_respawn}{timeout}) {
  993. $messageSender->sendRespawn();
  994. $char->{'dead_time'} = time;
  995. }
  997. if (AI::action eq "dead" && $config{dcOnDeath} && $config{dcOnDeath} != -1) {
  998. message T("Disconnecting on death!n");
  999. chatLog("k", T("*** You died, auto disconnect! ***n"));
  1000. $quit = 1;
  1001. }
  1002. }
  1004. ##### STORAGE GET #####
  1005. # Get one or more items from storage.
  1006. sub processStorageGet {
  1007. if (AI::action eq "storageGet" && timeOut(AI::args)) {
  1008. my $item = shift @{AI::args->{items}};
  1009. my $amount = AI::args->{max};
  1011. if (!$amount || $amount > $item->{amount}) {
  1012. $amount = $item->{amount};
  1013. }
  1014. $messageSender->sendStorageGet($item->{index}, $amount) if $storage{opened};
  1015. AI::args->{time} = time;
  1016. AI::dequeue if !@{AI::args->{items}};
  1017. }
  1018. }
  1020. #### CART ADD ####
  1021. # Put one or more items in cart.
  1022. # TODO: check for cart weight & number of items
  1023. sub processCartAdd {
  1024. if (AI::action eq "cartAdd" && timeOut(AI::args)) {
  1025. my $item = AI::args->{items}[0];
  1026. my $i = $item->{index};
  1027. my $invItem = $char->inventory->get($i);
  1028. if ($invItem) {
  1029. my $amount = $item->{amount};
  1030. if (!$amount || $amount > $invItem->{amount}) {
  1031. $amount = $invItem->{amount};
  1032. }
  1033. $messageSender->sendCartAdd($invItem->{index}, $amount);
  1034. }
  1035. shift @{AI::args->{items}};
  1036. AI::args->{time} = time;
  1037. AI::dequeue if (@{AI::args->{items}} <= 0);
  1038. }
  1039. }
  1041. #### CART Get ####
  1042. # Get one or more items from cart.
  1043. sub processCartGet {
  1044. if (AI::action eq "cartGet" && timeOut(AI::args)) {
  1045. my $item = AI::args->{items}[0];
  1046. my $i = $item->{index};
  1048. if ($cart{inventory}[$i]) {
  1049. my $amount = $item->{amount};
  1050. if (!$amount || $amount > $cart{inventory}[$i]{amount}) {
  1051. $amount = $cart{inventory}[$i]{amount};
  1052. }
  1053. $messageSender->sendCartGet($i, $amount);
  1054. }
  1055. shift @{AI::args->{items}};
  1056. AI::args->{time} = time;
  1057. AI::dequeue if (@{AI::args->{items}} <= 0);
  1058. }
  1059. }
  1061. sub processAutoMakeArrow {
  1062. ####### AUTO MAKE ARROW #######
  1063. if ((AI::isIdle || AI::is(qw/route move autoBuy storageAuto follow sitAuto items_take items_gather/))
  1064.  && timeOut($AI::Timeouts::autoArrow, 0.2) && $config{autoMakeArrows} && defined binFind(@skillsID, 'AC_MAKINGARROW') ) {
  1065. my $max = @arrowCraftID;
  1066. for (my $i = 0; $i < $max; $i++) {
  1067. my $item = $char->inventory->get($arrowCraftID[$i]);
  1068. next if (!$item);
  1069. if ($arrowcraft_items{lc($item->{name})}) {
  1070. $messageSender->sendArrowCraft($item->{nameID});
  1071. debug "Making itemn", "ai_makeItem";
  1072. last;
  1073. }
  1074. }
  1075. $AI::Timeouts::autoArrow = time;
  1076. }
  1078. if ($config{autoMakeArrows} && $useArrowCraft) {
  1079. if (defined binFind(@skillsID, 'AC_MAKINGARROW')) {
  1080. ai_skillUse('AC_MAKINGARROW', 1, 0, 0, $accountID);
  1081. }
  1082. undef $useArrowCraft;
  1083. }
  1084. }
  1086. ##### AUTO STORAGE #####
  1087. sub processAutoStorage {
  1088. # storageAuto - chobit aska 20030128
  1089. if (AI::is("", "route", "sitAuto", "follow")
  1090.   && $config{storageAuto} && ($config{storageAuto_npc} ne "" || $config{storageAuto_useChatCommand})
  1091.   && !$ai_v{sitAuto_forcedBySitCommand}
  1092.   && (($config{'itemsMaxWeight_sellOrStore'} && percent_weight($char) >= $config{'itemsMaxWeight_sellOrStore'})
  1093.       || (!$config{'itemsMaxWeight_sellOrStore'} && percent_weight($char) >= $config{'itemsMaxWeight'}))
  1094.   && !AI::inQueue("storageAuto") && time > $ai_v{'inventory_time'}) {
  1096. # Initiate autostorage when the weight limit has been reached
  1097. my $routeIndex = AI::findAction("route");
  1098. my $attackOnRoute = 2;
  1099. $attackOnRoute = AI::args($routeIndex)->{attackOnRoute} if (defined $routeIndex);
  1100. # Only autostorage when we're on an attack route, or not moving
  1101. if ($attackOnRoute > 1 && ai_storageAutoCheck()) {
  1102. message T("Auto-storaging due to excess weightn");
  1103. AI::queue("storageAuto");
  1104. }
  1106. } elsif (AI::is("", "route", "attack")
  1107.   && $config{storageAuto}
  1108.   && ($config{storageAuto_npc} ne "" || $config{storageAuto_useChatCommand})
  1109.   && !$ai_v{sitAuto_forcedBySitCommand}
  1110.   && !AI::inQueue("storageAuto")
  1111.   && $char->inventory->size() > 0) {
  1113. # Initiate autostorage when we're low on some item, and getAuto is set
  1114. my $needitem = "";
  1115. my $i;
  1116. Misc::checkValidity("AutoStorage part 1");
  1117. for ($i = 0; exists $config{"getAuto_$i"}; $i++) {
  1118. next unless ($config{"getAuto_$i"});
  1119. if ($storage{opened} && findKeyString(%storage, "name", $config{"getAuto_$i"}) eq '') {
  1120. foreach (keys %items_lut) {
  1121. if ((lc($items_lut{$_}) eq lc($config{"getAuto_$i"})) && ($items_lut{$_} ne $config{"getAuto_$i"})) {
  1122. configModify("getAuto_$i", $items_lut{$_});
  1123. }
  1124. }
  1125. }
  1127. my $item = $char->inventory->getByName($config{"getAuto_$i"});
  1128. if ($config{"getAuto_${i}_minAmount"} ne "" &&
  1129.     $config{"getAuto_${i}_maxAmount"} ne "" &&
  1130.     !$config{"getAuto_${i}_passive"} &&
  1131.     (!$item ||
  1132.  ($item->{amount} <= $config{"getAuto_${i}_minAmount"} &&
  1133.   $item->{amount} < $config{"getAuto_${i}_maxAmount"})
  1134.     )
  1135. ) {
  1136. if ($storage{opened} && findKeyString(%storage, "name", $config{"getAuto_$i"}) eq '') {
  1137. if ($config{"getAuto_${i}_dcOnEmpty"}) {
  1138.   message TF("Disconnecting on empty %s!n", $config{"getAuto_$i"});
  1139. chatLog("k", TF("Disconnecting on empty %s!n", $config{"getAuto_$i"}));
  1140. quit();
  1141. }
  1142. } else {
  1143. if ($storage{openedThisSession} && findKeyString(%storage, "name", $config{"getAuto_$i"}) eq '') {
  1144. } else {
  1145. my $sti = $config{"getAuto_$i"};
  1146. if ($needitem eq "") {
  1147. $needitem = "$sti";
  1148. } else {$needitem = "$needitem, $sti";}
  1149. }
  1150. }
  1151. }
  1152. }
  1153. Misc::checkValidity("AutoStorage part 2");
  1155. my $routeIndex = AI::findAction("route");
  1156. my $attackOnRoute;
  1157. $attackOnRoute = AI::args($routeIndex)->{attackOnRoute} if (defined $routeIndex);
  1159. # Only autostorage when we're on an attack route, or not moving
  1160. if ((!defined($routeIndex) || $attackOnRoute > 1) && $needitem ne "" &&
  1161. $char->inventory->size() > 0 && ai_storageAutoCheck()) {
  1162.   message TF("Auto-storaging due to insufficient %sn", $needitem);
  1163. AI::queue("storageAuto");
  1164. }
  1165. $timeout{'ai_storageAuto'}{'time'} = time;
  1166. }
  1169. if (AI::action eq "storageAuto" && AI::args->{done}) {
  1170. # Autostorage finished; trigger sellAuto unless autostorage was already triggered by it
  1171. my $forcedBySell = AI::args->{forcedBySell};
  1172. my $forcedByBuy = AI::args->{forcedByBuy};
  1173. AI::dequeue;
  1174. if ($forcedByBuy) {
  1175. AI::queue("sellAuto", {forcedByBuy => 1});
  1176. } elsif (!$forcedBySell && ai_sellAutoCheck() && $config{sellAuto}) {
  1177. AI::queue("sellAuto", {forcedByStorage => 1});
  1178. }
  1180. } elsif (AI::action eq "storageAuto" && timeOut($timeout{'ai_storageAuto'})) {
  1181. # Main autostorage block
  1182. my $args = AI::args;
  1184. my $do_route;
  1186. if (!$config{storageAuto_useChatCommand}) {
  1187. # Stop if the specified NPC is invalid
  1188. $args->{npc} = {};
  1189. getNPCInfo($config{'storageAuto_npc'}, $args->{npc});
  1190. if (!defined($args->{npc}{ok})) {
  1191. $args->{done} = 1;
  1192. return;
  1193. }
  1195. # Determine whether we have to move to the NPC
  1196. if ($field{'name'} ne $args->{npc}{map}) {
  1197. $do_route = 1;
  1198. } else {
  1199. my $distance = distance($args->{npc}{pos}, $char->{pos_to});
  1200. if ($distance > $config{'storageAuto_distance'}) {
  1201. $do_route = 1;
  1202. }
  1203. }
  1205. if ($do_route) {
  1206. if ($args->{warpedToSave} && !$args->{mapChanged} && !timeOut($args->{warpStart}, 8)) {
  1207. undef $args->{warpedToSave};
  1208. }
  1210. # If warpToBuyOrSell is set, warp to saveMap if we haven't done so
  1211. if ($config{'saveMap'} ne "" && $config{'saveMap_warpToBuyOrSell'} && !$args->{warpedToSave}
  1212.     && !$cities_lut{$field{'name'}.'.rsw'} && $config{'saveMap'} ne $field{name}) {
  1213. $args->{warpedToSave} = 1;
  1214. # If we still haven't warped after a certain amount of time, fallback to walking
  1215. $args->{warpStart} = time unless $args->{warpStart};
  1216. message T("Teleporting to auto-storagen"), "teleport";
  1217. useTeleport(2);
  1218. $timeout{'ai_storageAuto'}{'time'} = time;
  1219. } else {
  1220. # warpToBuyOrSell is not set, or we've already warped, or timed out. Walk to the NPC
  1221. message TF("Calculating auto-storage route to: %s(%s): %s, %sn", $maps_lut{$args->{npc}{map}.'.rsw'}, $args->{npc}{map}, $args->{npc}{pos}{x}, $args->{npc}{pos}{y}), "route";
  1222. ai_route($args->{npc}{map}, $args->{npc}{pos}{x}, $args->{npc}{pos}{y},
  1223.  attackOnRoute => 1,
  1224.  distFromGoal => $config{'storageAuto_distance'});
  1225. }
  1226. }
  1227. }
  1228. if (!$do_route) {
  1229. # Talk to NPC if we haven't done so
  1230. if (!defined($args->{sentStore})) {
  1231. if ($config{storageAuto_useChatCommand}) {
  1232. $messageSender->sendChat($config{storageAuto_useChatCommand});
  1233. } else {
  1234. if ($config{'storageAuto_npc_type'} eq "" || $config{'storageAuto_npc_type'} eq "1") {
  1235. warning T("Warning storageAuto has changed. Please read News.txtn") if ($config{'storageAuto_npc_type'} eq "");
  1236. $config{'storageAuto_npc_steps'} = "c r1 n";
  1237. debug "Using standard iRO npc storage steps.n", "npc";
  1238. } elsif ($config{'storageAuto_npc_type'} eq "2") {
  1239. $config{'storageAuto_npc_steps'} = "c c r1 n";
  1240. debug "Using iRO comodo (location) npc storage steps.n", "npc";
  1241. } elsif ($config{'storageAuto_npc_type'} eq "3") {
  1242. message T("Using storage steps defined in config.n"), "info";
  1243. } elsif ($config{'storageAuto_npc_type'} ne "" && $config{'storageAuto_npc_type'} ne "1" && $config{'storageAuto_npc_type'} ne "2" && $config{'storageAuto_npc_type'} ne "3") {
  1244. error T("Something is wrong with storageAuto_npc_type in your config.n");
  1245. }
  1247. ai_talkNPC($args->{npc}{pos}{x}, $args->{npc}{pos}{y}, $config{'storageAuto_npc_steps'});
  1248. }
  1250. delete $ai_v{temp}{storage_opened};
  1251. $args->{sentStore} = 1;
  1253. # NPC talk retry
  1254. $AI::Timeouts::storageOpening = time;
  1255. $timeout{'ai_storageAuto'}{'time'} = time;
  1256. return;
  1257. }
  1259. if (!defined $ai_v{temp}{storage_opened}) {
  1260. # NPC talk retry
  1261. if (timeOut($AI::Timeouts::storageOpening, 40)) {
  1262. undef $args->{sentStore};
  1263. debug "Retry talking to autostorage NPC.n", "npc";
  1264. }
  1266. # Storage not yet opened; stop and wait until it's open
  1267. return;
  1268. }
  1270. if (!$args->{getStart}) {
  1271. $args->{done} = 1;
  1273. # if storage is full disconnect if it says so in conf
  1274. if(defined $storage{items_max} && @storageID >= $storage{items_max} && $config{'dcOnStorageFull'}) {
  1275. error T("Disconnecting because storage is full!n");
  1276. chatLog("k", T("Disconnecting because storage is full!n"));
  1277. quit();
  1278. }
  1280. # inventory to storage
  1281. $args->{nextItem} = 0 unless $args->{nextItem};
  1282. for (my $i = $args->{nextItem}; $i < @{$char->inventory->getItems()}; $i++) {
  1283. my $item = $char->inventory->getItems()->[$i];
  1284. next if $item->{equipped};
  1285. next if ($item->{broken} && $item->{type} == 7); # dont store pet egg in use
  1287. my $control = items_control($item->{name});
  1289. debug "AUTOSTORAGE: $item->{name} x $item->{amount} - store = $control->{storage}, keep = $control->{keep}n", "storage";
  1290. if ($control->{storage} && $item->{amount} > $control->{keep}) {
  1291. if ($args->{lastIndex} == $item->{index} &&
  1292.     timeOut($timeout{'ai_storageAuto_giveup'})) {
  1293. return;
  1294. } elsif ($args->{lastIndex} != $item->{index}) {
  1295. $timeout{ai_storageAuto_giveup}{time} = time;
  1296. }
  1297. undef $args->{done};
  1298. $args->{lastIndex} = $item->{index};
  1299. $messageSender->sendStorageAdd($item->{index}, $item->{amount} - $control->{keep});
  1300. $timeout{ai_storageAuto}{time} = time;
  1301. $args->{nextItem} = $i;
  1302. return;
  1303. }
  1304. }
  1306. # cart to storage
  1307. # we don't really need to check if we have a cart
  1308. # if we don't have one it will not find any items to loop through
  1309. $args->{cartNextItem} = 0 unless $args->{cartNextItem};
  1310. for (my $i = $args->{cartNextItem}; $i < @{$cart{inventory}}; $i++) {
  1311. my $item = $cart{inventory}[$i];
  1312. next unless ($item && %{$item});
  1314. my $control = items_control($item->{name});
  1316. debug "AUTOSTORAGE (cart): $item->{name} x $item->{amount} - store = $control->{storage}, keep = $control->{keep}n", "storage";
  1317. # store from cart as well as inventory if the flag is equal to 2
  1318. if ($control->{storage} == 2 && $item->{amount} > $control->{keep}) {
  1319. if ($args->{cartLastIndex} == $item->{index} &&
  1320.     timeOut($timeout{'ai_storageAuto_giveup'})) {
  1321. return;
  1322. } elsif ($args->{cartLastIndex} != $item->{index}) {
  1323. $timeout{ai_storageAuto_giveup}{time} = time;
  1324. }
  1325. undef $args->{done};
  1326. $args->{cartLastIndex} = $item->{index};
  1327. $messageSender->sendStorageAddFromCart($item->{index}, $item->{amount} - $control->{keep});
  1328. $timeout{ai_storageAuto}{time} = time;
  1329. $args->{cartNextItem} = $i + 1;
  1330. return;
  1331. }
  1332. }
  1334. if ($args->{done}) {
  1335. # plugins can hook here and decide to keep storage open longer
  1336. my %hookArgs;
  1337. Plugins::callHook("AI_storage_done", %hookArgs);
  1338. undef $args->{done} if ($hookArgs{return});
  1339. }
  1340. }
  1343. # getAuto begin
  1345. if (!$args->{getStart} && $args->{done} == 1) {
  1346. $args->{getStart} = 1;
  1347. undef $args->{done};
  1348. $args->{index} = 0;
  1349. $args->{retry} = 0;
  1350. return;
  1351. }
  1353. if (defined($args->{getStart}) && $args->{done} != 1) {
  1354. Misc::checkValidity("AutoStorage part 3");
  1355. while (exists $config{"getAuto_$args->{index}"}) {
  1356. if (!$config{"getAuto_$args->{index}"}) {
  1357. $args->{index}++;
  1358. next;
  1359. }
  1361. my %item;
  1362. my $itemName = $config{"getAuto_$args->{index}"};
  1363. if (!$itemName) {
  1364. $args->{index}++;
  1365. next;
  1366. }
  1367. my $invItem = $char->inventory->getByName($itemName);
  1368. $item{name} = $itemName;
  1369. $item{inventory}{index} = $invItem ? $invItem->{invIndex} : undef;
  1370. $item{inventory}{amount} = $invItem ? $invItem->{amount} : 0;
  1371. $item{storage}{index} = findKeyString(%storage, "name", $item{name});
  1372. $item{storage}{amount} = ($item{storage}{index} ne "")? $storage{$item{storage}{index}}{amount} : 0;
  1373. $item{max_amount} = $config{"getAuto_$args->{index}"."_maxAmount"};
  1374. $item{amount_needed} = $item{max_amount} - $item{inventory}{amount};
  1376. # Calculate the amount to get
  1377. if ($item{amount_needed} > 0) {
  1378. $item{amount_get} = ($item{storage}{amount} >= $item{amount_needed})? $item{amount_needed} : $item{storage}{amount};
  1379. }
  1381. # Try at most 3 times to get the item
  1382. if (($item{amount_get} > 0) && ($args->{retry} < 3)) {
  1383. message TF("Attempt to get %s x %s from storage, retry: %sn", $item{amount_get}, $item{name}, $ai_seq_args[0]{retry}), "storage", 1;
  1384. $messageSender->sendStorageGet($item{storage}{index}, $item{amount_get});
  1385. $timeout{ai_storageAuto}{time} = time;
  1386. $args->{retry}++;
  1387. return;
  1389. # we don't inc the index when amount_get is more then 0, this will enable a way of retrying
  1390. # on next loop if it fails this time
  1391. }
  1393. if ($item{storage}{amount} < $item{amount_needed}) {
  1394. warning TF("storage: %s out of stockn", $item{name});
  1395. }
  1397. if (!$config{relogAfterStorage} && $args->{retry} >= 3 && !$args->{warned}) {
  1398. # We tried 3 times to get the item and failed.
  1399. # There is a weird server bug which causes this to happen,
  1400. # but I can't reproduce it. This can be worked around by
  1401. # relogging in after autostorage.
  1402. warning T("Kore tried to get an item from storage 3 times, but failed.n" .
  1403.   "This problem could be caused by a server bug.n" .
  1404.   "To work around this problem, set 'relogAfterStorage' to 1, and relogin.n");
  1405. $args->{warned} = 1;
  1406. }
  1408. # We got the item, or we tried 3 times to get it, but failed.
  1409. # Increment index and process the next item.
  1410. $args->{index}++;
  1411. $args->{retry} = 0;
  1412. }
  1413. Misc::checkValidity("AutoStorage part 4");
  1414. }
  1416. $messageSender->sendStorageClose() unless $config{storageAuto_keepOpen};
  1417. if (percent_weight($char) >= $config{'itemsMaxWeight_sellOrStore'} && ai_storageAutoCheck()) {
  1418. error T("Character is still overweight after storageAuto (storage is full?)n");
  1419. if ($config{dcOnStorageFull}) {
  1420. error T("Disconnecting on storage full!n");
  1421. chatLog("k", T("Disconnecting on storage full!n"));
  1422. quit();
  1423. }
  1424. }
  1426. if ($config{'relogAfterStorage'} && $config{'XKore'} ne "1") {
  1427. writeStorageLog(0);
  1428. relog();
  1429. }
  1430. $args->{done} = 1;
  1431. }
  1432. }
  1433. }
  1435. #####AUTO SELL#####
  1436. sub processAutoSell {
  1437. if ((AI::action eq "" || AI::action eq "route" || AI::action eq "sitAuto" || AI::action eq "follow")
  1438. && (($config{'itemsMaxWeight_sellOrStore'} && percent_weight($char) >= $config{'itemsMaxWeight_sellOrStore'})
  1439. || ($config{'itemsMaxNum_sellOrStore'} && $char->inventory->size() >= $config{'itemsMaxNum_sellOrStore'})
  1440. || (!$config{'itemsMaxWeight_sellOrStore'} && percent_weight($char) >= $config{'itemsMaxWeight'})
  1441. )
  1442. && $config{'sellAuto'}
  1443. && $config{'sellAuto_npc'} ne ""
  1444. && !$ai_v{sitAuto_forcedBySitCommand}
  1445.   ) {
  1446. $ai_v{'temp'}{'ai_route_index'} = AI::findAction("route");
  1447. if ($ai_v{'temp'}{'ai_route_index'} ne "") {
  1448. $ai_v{'temp'}{'ai_route_attackOnRoute'} = AI::args($ai_v{'temp'}{'ai_route_index'})->{'attackOnRoute'};
  1449. }
  1450. if (!($ai_v{'temp'}{'ai_route_index'} ne "" && $ai_v{'temp'}{'ai_route_attackOnRoute'} <= 1) && ai_sellAutoCheck()) {
  1451. AI::queue("sellAuto");
  1452. }
  1453. }
  1455. if (AI::action eq "sellAuto" && AI::args->{'done'}) {
  1456. my $var = AI::args->{'forcedByBuy'};
  1457. my $var2 = AI::args->{'forcedByStorage'};
  1458. message T("Auto-sell sequence completed.n"), "success";
  1459. AI::dequeue;
  1460. if ($var2) {
  1461. AI::queue("buyAuto", {forcedByStorage => 1});
  1462. } elsif (!$var) {
  1463. AI::queue("buyAuto", {forcedBySell => 1});
  1464. }
  1465. } elsif (AI::action eq "sellAuto" && timeOut($timeout{'ai_sellAuto'})) {
  1466. my $args = AI::args;
  1468. $args->{'npc'} = {};
  1469. my $destination = $config{sellAuto_standpoint} || $config{sellAuto_npc};
  1470. getNPCInfo($destination, $args->{'npc'});
  1471. if (!defined($args->{'npc'}{'ok'})) {
  1472. $args->{'done'} = 1;
  1473. return;
  1474. }
  1476. undef $ai_v{'temp'}{'do_route'};
  1477. if ($field{'name'} ne $args->{'npc'}{'map'}) {
  1478. $ai_v{'temp'}{'do_route'} = 1;
  1479. } else {
  1480. $ai_v{'temp'}{'distance'} = distance($args->{'npc'}{'pos'}, $chars[$config{'char'}]{'pos_to'});
  1481. $config{'sellAuto_distance'} = 1 if ($config{sellAuto_standpoint});
  1482. if ($ai_v{'temp'}{'distance'} > $config{'sellAuto_distance'}) {
  1483. $ai_v{'temp'}{'do_route'} = 1;
  1484. }
  1485. }
  1486. if ($ai_v{'temp'}{'do_route'}) {
  1487. if ($args->{'warpedToSave'} && !$args->{'mapChanged'} && !timeOut($args->{warpStart}, 8)) {
  1488. undef $args->{'warpedToSave'};
  1489. }
  1491. if ($config{'saveMap'} ne "" && $config{'saveMap_warpToBuyOrSell'} && !$args->{'warpedToSave'}
  1492. && !$cities_lut{$field{'name'}.'.rsw'} && $config{'saveMap'} ne $field{name}) {
  1493. $args->{'warpedToSave'} = 1;
  1494. # If we still haven't warped after a certain amount of time, fallback to walking
  1495. $args->{warpStart} = time unless $args->{warpStart};
  1496. message T("Teleporting to auto-selln"), "teleport";
  1497. useTeleport(2);
  1498. $timeout{'ai_sellAuto'}{'time'} = time;
  1499. } else {
  1500.   message TF("Calculating auto-sell route to: %s(%s): %s, %sn", $maps_lut{$ai_seq_args[0]{'npc'}{'map'}.'.rsw'}, $ai_seq_args[0]{'npc'}{'map'}, $ai_seq_args[0]{'npc'}{'pos'}{'x'}, $ai_seq_args[0]{'npc'}{'pos'}{'y'}), "route";
  1501. ai_route($args->{'npc'}{'map'}, $args->{'npc'}{'pos'}{'x'}, $args->{'npc'}{'pos'}{'y'},
  1502. attackOnRoute => 1,
  1503. distFromGoal => $config{'sellAuto_distance'},
  1504. noSitAuto => 1);
  1505. }
  1506. } else {
  1507. $args->{'npc'} = {};
  1508. getNPCInfo($config{'sellAuto_npc'}, $args->{'npc'});
  1509. if (!defined($args->{'sentSell'})) {
  1510. $args->{'sentSell'} = 1;
  1512. # load the real npc location just in case we used standpoint
  1513. my $realpos = {};
  1514. getNPCInfo($config{"sellAuto_npc"}, $realpos);
  1516. ai_talkNPC($realpos->{pos}{x}, $realpos->{pos}{y}, 's e');
  1518. return;
  1519. }
  1520. $args->{'done'} = 1;
  1522. # Form list of items to sell
  1523. my @sellItems;
  1524. foreach my $item (@{$char->inventory->getItems()}) {
  1525. next if ($item->{equipped});
  1527. my $control = items_control($item->{name});
  1529. if ($control->{'sell'} && $item->{'amount'} > $control->{keep}) {
  1530. if ($args->{lastIndex} ne "" && $args->{lastIndex} == $item->{index} && timeOut($timeout{'ai_sellAuto_giveup'})) {
  1531. return;
  1532. } elsif ($args->{lastIndex} eq "" || $args->{lastIndex} != $item->{index}) {
  1533. $timeout{ai_sellAuto_giveup}{time} = time;
  1534. }
  1535. undef $args->{done};
  1536. $args->{lastIndex} = $item->{index};
  1538. my %obj;
  1539. $obj{index} = $item->{index};
  1540. $obj{amount} = $item->{amount} - $control->{keep};
  1541. push @sellItems, %obj;
  1543. $timeout{ai_sellAuto}{time} = time;
  1544. }
  1545. }
  1546. $messageSender->sendSellBulk(@sellItems) if (@sellItems);
  1548. if ($args->{done}) {
  1549. # plugins can hook here and decide to keep sell going longer
  1550. my %hookArgs;
  1551. Plugins::callHook("AI_sell_done", %hookArgs);
  1552. undef $args->{done} if ($hookArgs{return});
  1553. }
  1554. }
  1555. }
  1556. }
  1558. #####AUTO BUY#####
  1559. sub processAutoBuy {
  1560. my $needitem;
  1561. if ((AI::action eq "" || AI::action eq "route" || AI::action eq "follow") && timeOut($timeout{'ai_buyAuto'}) && time > $ai_v{'inventory_time'}) {
  1562. undef $ai_v{'temp'}{'found'};
  1563. my $i = 0;
  1564. while (1) {
  1565. last if (!$config{"buyAuto_$i"} || !$config{"buyAuto_$i"."_npc"});
  1566. my $item = $char->inventory->getByName($config{"buyAuto_$i"});
  1567. if ($config{"buyAuto_$i"."_minAmount"} ne "" && $config{"buyAuto_$i"."_maxAmount"} ne ""
  1568. && (checkSelfCondition("buyAuto_$i"))
  1569. && (!$item
  1570.     || ($item->{amount} <= $config{"buyAuto_$i"."_minAmount"}
  1571.         && $item->{amount} < $config{"buyAuto_$i"."_maxAmount"}
  1572.        )
  1573. )
  1574. ) {
  1575. $ai_v{'temp'}{'found'} = 1;
  1576. my $bai = $config{"buyAuto_$i"};
  1577. if ($needitem eq "") {
  1578. $needitem = "$bai";
  1579. } else {$needitem = "$needitem, $bai";}
  1580. }
  1581. $i++;
  1582. }
  1583. $ai_v{'temp'}{'ai_route_index'} = AI::findAction("route");
  1584. if ($ai_v{'temp'}{'ai_route_index'} ne "") {
  1585. $ai_v{'temp'}{'ai_route_attackOnRoute'} = AI::args($ai_v{'temp'}{'ai_route_index'})->{'attackOnRoute'};
  1586. }
  1587. if (!($ai_v{'temp'}{'ai_route_index'} ne "" && AI::findAction("buyAuto")) && $ai_v{'temp'}{'found'}) {
  1588. AI::queue("buyAuto");
  1589. }
  1590. $timeout{'ai_buyAuto'}{'time'} = time;
  1591. }
  1593. if (AI::action eq "buyAuto" && AI::args->{'done'}) {
  1594. # buyAuto finished
  1595. $ai_v{'temp'}{'var'} = AI::args->{'forcedBySell'};
  1596. $ai_v{'temp'}{'var2'} = AI::args->{'forcedByStorage'};
  1597. AI::dequeue;
  1599. if ($ai_v{'temp'}{'var'} && $config{storageAuto}) {
  1600. AI::queue("storageAuto", {forcedBySell => 1});
  1601. } elsif (!$ai_v{'temp'}{'var2'} && $config{storageAuto}) {
  1602. AI::queue("storageAuto", {forcedByBuy => 1});
  1603. }
  1605. } elsif (AI::action eq "buyAuto" && timeOut($timeout{ai_buyAuto_wait}) && timeOut($timeout{ai_buyAuto_wait_buy})) {
  1606. my $args = AI::args;
  1607. undef $args->{index};
  1609. for (my $i = 0; exists $config{"buyAuto_$i"}; $i++) {
  1610. next if (!$config{"buyAuto_$i"} || $config{"buyAuto_${i}_disabled"});
  1611. # did we already fail to do this buyAuto slot? (only fails in this way if the item is nonexistant)
  1612. next if ($args->{index_failed}{$i});
  1614. my $item = $char->inventory->getByName($config{"buyAuto_$i"});
  1615. $args->{invIndex} = $item ? $item->{invIndex} : undef;
  1616. if ($config{"buyAuto_$i"."_maxAmount"} ne "" && (!$item || $item->{amount} < $config{"buyAuto_$i"."_maxAmount"})) {
  1617. next if (($config{"buyAuto_$i"."_price"} && ($char->{zenny} < $config{"buyAuto_$i"."_price"})) || ($config{"buyAuto_$i"."_zeny"} && !inRange($char->{zenny}, $config{"buyAuto_$i"."_zeny"})));
  1619. # get NPC info, use standpoint if provided
  1620. $args->{npc} = {};
  1621. my $destination = $config{"buyAuto_$i"."_standpoint"} || $config{"buyAuto_$i"."_npc"};
  1622. getNPCInfo($destination, $args->{npc});
  1624. # did we succeed to load NPC info from this slot?
  1625. # (doesnt check validity of _npc if we used _standpoint...)
  1626. if ($args->{npc}{ok}) {
  1627. $args->{index} = $i;
  1628. }
  1629. last;
  1630. }
  1631. }
  1633. # failed to load any slots for buyAuto (we're done or they're all invalid)
  1634. # what does the second check do here?
  1635. if ($args->{index} eq "" || ($args->{lastIndex} ne "" && $args->{lastIndex} == $args->{index} && timeOut($timeout{'ai_buyAuto_giveup'}))) {
  1636. $args->{'done'} = 1;
  1637. return;
  1638. }
  1640. undef $ai_v{'temp'}{'do_route'};
  1641. if ($field{'name'} ne $args->{'npc'}{'map'}) {
  1642. $ai_v{'temp'}{'do_route'} = 1;
  1643. } else {
  1644. $ai_v{'temp'}{'distance'} = distance($args->{'npc'}{'pos'}, $chars[$config{'char'}]{'pos_to'});
  1645. $config{"buyAuto_$args->{index}"."_distance"} = 1 if ($config{"buyAuto_$args->{index}"."_standpoint"});
  1646. if ($ai_v{'temp'}{'distance'} > $config{"buyAuto_$args->{index}"."_distance"}) {
  1647. $ai_v{'temp'}{'do_route'} = 1;
  1648. }
  1649. }
  1651. my $msgneeditem;
  1652. if ($ai_v{'temp'}{'do_route'}) {
  1653. if ($args->{warpedToSave} && !$args->{mapChanged} && !timeOut($args->{warpStart}, 8)) {
  1654. undef $args->{warpedToSave};
  1655. }
  1657. if ($config{'saveMap'} ne "" && $config{'saveMap_warpToBuyOrSell'} && !$args->{warpedToSave}
  1658. && !$cities_lut{$field{'name'}.'.rsw'} && $config{'saveMap'} ne $field{name}) {
  1659. $args->{warpedToSave} = 1;
  1660. if ($needitem ne "") {
  1661. $msgneeditem = "Auto-buy: $needitemn";
  1662. }
  1663. # If we still haven't warped after a certain amount of time, fallback to walking
  1664. $args->{warpStart} = time unless $args->{warpStart};
  1665.   message T($msgneeditem."Teleporting to auto-buyn"), "teleport";
  1666. useTeleport(2);
  1667. $timeout{ai_buyAuto_wait}{time} = time;
  1668. } else {
  1669. if ($needitem ne "") {
  1670. $msgneeditem = "Auto-buy: $needitemn";
  1671. }
  1672.   message TF($msgneeditem."Calculating auto-buy route to: %s (%s): %s, %sn", $maps_lut{$args->{npc}{map}.'.rsw'}, $args->{npc}{map}, $args->{npc}{pos}{x}, $args->{npc}{pos}{y}), "route";
  1673. ai_route($args->{npc}{map}, $args->{npc}{pos}{x}, $args->{npc}{pos}{y},
  1674. attackOnRoute => 1,
  1675. distFromGoal => $config{"buyAuto_$args->{index}"."_distance"});
  1676. }
  1677. } else {
  1678. if ($args->{lastIndex} eq "" || $args->{lastIndex} != $args->{index}) {
  1679. # sendBuy automatically terminates the shopping
  1680. # to the seller NPC for each item bought.
  1681. undef $args->{itemID};
  1682. undef $args->{sentBuy};
  1683. $timeout{ai_buyAuto_giveup}{time} = time;
  1684. }
  1685. $args->{lastIndex} = $args->{index};
  1687. # find the item ID if we don't know it yet
  1688. if ($args->{itemID} eq "") {
  1689. if ($args->{invIndex} && $char->inventory->get($args->{invIndex})) {
  1690. # if we have the item in our inventory, we can quickly get the nameID
  1691. $args->{itemID} = $char->inventory->get($args->{invIndex})->{nameID};
  1692. } else {
  1693. # scan the entire items.txt file (this is slow)
  1694. foreach (keys %items_lut) {
  1695. if (lc($items_lut{$_}) eq lc($config{"buyAuto_$args->{index}"})) {
  1696. $args->{itemID} = $_;
  1697. }
  1698. }
  1699. }
  1700. if ($args->{itemID} eq "") {
  1701. # the specified item doesn't even exist
  1702. # don't try this index again
  1703. $args->{index_failed}{$args->{index}} = 1;
  1704. debug "buyAuto index $args->{index} failed, item doesn't existn", "npc";
  1705. return;
  1706. }
  1707. }
  1709. if (!$args->{sentBuy}) {
  1710. $args->{sentBuy} = 1;
  1711. $timeout{ai_buyAuto_wait}{time} = time;
  1713. # load the real npc location just in case we used standpoint
  1714. my $realpos = {};
  1715. getNPCInfo($config{"buyAuto_$args->{index}"."_npc"}, $realpos);
  1717. ai_talkNPC($realpos->{pos}{x}, $realpos->{pos}{y}, 'b e');
  1718. return;
  1719. }
  1720. my $maxbuy;
  1721. if ($config{"buyAuto_$args->{index}"."_price"}) {
  1722. $maxbuy = int($char->{zenny}/$config{"buyAuto_$args->{index}"."_price"});
  1723. } else {$maxbuy = 1000000;}
  1725. if ($args->{invIndex} ne "") {
  1726. # this item is in the inventory already, get what we need
  1727. my $needbuy = $config{"buyAuto_$args->{index}"."_maxAmount"} - $char->inventory->get($args->{invIndex})->{amount};
  1728. if ($maxbuy+1 > $needbuy) {
  1729. $messageSender->sendBuy($args->{itemID}, $needbuy);
  1730. } else {
  1731. $messageSender->sendBuy($args->{itemID}, $maxbuy);
  1732. }
  1733. } else {
  1734. # get the full amount
  1735. my $needbuy = $config{"buyAuto_$args->{index}"."_maxAmount"};
  1736. if ($maxbuy+1 > $needbuy) {
  1737. $messageSender->sendBuy($args->{itemID}, $needbuy);
  1738. } else {
  1739. $messageSender->sendBuy($args->{itemID}, $maxbuy);
  1740. }
  1741. }
  1742. $timeout{ai_buyAuto_wait_buy}{time} = time;
  1743. }
  1744. }
  1745. }
  1747. ##### AUTO-CART ADD/GET ####
  1748. sub processAutoCart {
  1749. if ((AI::isIdle || AI::is(qw/route move buyAuto follow sitAuto items_take items_gather/))) {
  1750. my $timeout = $timeout{ai_cartAutoCheck}{timeout} || 2;
  1751. my $hasCart = $cart{exists};
  1752. if ($char->{statuses}) {
  1753. foreach (keys %{$char->{statuses}}) {
  1754. if ($_ =~ /^Level d Cart$/) {
  1755. $hasCart = 1;
  1756. last;
  1757. }
  1758. }
  1759. }
  1760. if (timeOut($AI::Timeouts::autoCart, $timeout) && $hasCart) {
  1761. my @addItems;
  1762. my @getItems;
  1763. my $cartInventory = $cart{inventory};
  1764. my $max;
  1766. if ($config{cartMaxWeight} && $cart{weight} < $config{cartMaxWeight}) {
  1767. foreach my $item (@{$char->inventory->getItems()}) {
  1768. next if ($item->{broken} && $item->{type} == 7); # dont auto-cart add pet eggs in use
  1769. next if ($item->{equipped});
  1770. my $control = items_control($item->{name});
  1771. if ($control->{cart_add} && $item->{amount} > $control->{keep}) {
  1772. my %obj;
  1773. $obj{index} = $item->{invIndex};
  1774. $obj{amount} = $item->{amount} - $control->{keep};
  1775. push @addItems, %obj;
  1776. debug "Scheduling $item->{name} ($item->{invIndex}) x $obj{amount} for adding to cartn", "ai_autoCart";
  1777. }
  1778. }
  1779. cartAdd(@addItems);
  1780. }
  1782. $max = @{$cartInventory};
  1783. for (my $i = 0; $i < $max; $i++) {
  1784. my $cartItem = $cartInventory->[$i];
  1785. next unless ($cartItem);
  1786. my $control = items_control($cartItem->{name});
  1787. next unless ($control->{cart_get});
  1789. my $item = $char->inventory->getByName($cartItem->{name});
  1790. my $amount;
  1791. if (!$item) {
  1792. $amount = $control->{keep};
  1793. } elsif ($item->{amount} < $control->{keep}) {
  1794. $amount = $control->{keep} - $item->{amount};
  1795. }
  1796. if ($amount > $cartItem->{amount}) {
  1797. $amount = $cartItem->{amount};
  1798. }
  1799. if ($amount > 0) {
  1800. my %obj;
  1801. $obj{index} = $i;
  1802. $obj{amount} = $amount;
  1803. push @getItems, %obj;
  1804. debug "Scheduling $cartItem->{name} ($i) x $obj{amount} for getting from cartn", "ai_autoCart";
  1805. }
  1806. }
  1807. cartGet(@getItems);
  1808. }
  1809. $AI::Timeouts::autoCart = time;
  1810. }
  1811. }
  1813. ##### LOCKMAP #####
  1814. sub processLockMap {
  1815. if (AI::isIdle && $config{'lockMap'}
  1816. && !$ai_v{'sitAuto_forcedBySitCommand'}
  1817. && ($field{'name'} ne $config{'lockMap'}
  1818. || ($config{'lockMap_x'} && ($char->{pos_to}{x} < $config{'lockMap_x'} - $config{'lockMap_randX'} || $char->{pos_to}{x} > $config{'lockMap_x'} + $config{'lockMap_randX'}))
  1819. || ($config{'lockMap_y'} && ($char->{pos_to}{y} < $config{'lockMap_y'} - $config{'lockMap_randY'} || $char->{pos_to}{y} > $config{'lockMap_y'} + $config{'lockMap_randY'}))
  1820. )) {
  1822. unless ($maps_lut{$config{'lockMap'}.'.rsw'}) {
  1823. error TF("Invalid map specified for lockMap - map %s doesn't existn", $config{'lockMap'});
  1824. $config{'lockMap'} = '';
  1825. } else {
  1826. my %args;
  1827. Plugins::callHook("AI/lockMap", %args);
  1828. unless ($args{'return'}) {
  1829. my ($lockX, $lockY, $i);
  1830. eval {
  1831. my $lockField = new Field(name => $config{'lockMap'}, loadDistanceMap => 0);
  1832. $i = 500;
  1833. if ($config{'lockMap_x'} || $config{'lockMap_y'}) {
  1834. do {
  1835. $lockX = int(rand($field{'width'} + 1)) if (!$config{'lockMap_x'} && $config{'lockMap_y'});
  1836. $lockX = int($config{'lockMap_x'}) if ($config{'lockMap_x'});
  1837. $lockX += (int(rand(2*$config{'lockMap_randX'} + 1) - $config{'lockMap_randX'})) if ($config{'lockMap_x'} && $config{'lockMap_randX'});
  1839. $lockY = int(rand($field{'width'} + 1)) if (!$config{'lockMap_y'} && $config{'lockMap_x'});
  1840. $lockY = int($config{'lockMap_y'}) if ($config{'lockMap_y'});
  1841. $lockY += (int(rand(2*$config{'lockMap_randY'} + 1) - $config{'lockMap_randY'})) if ($config{'lockMap_y'} && $config{'lockMap_randY'});
  1842. } while (--$i && !$lockField->isWalkable($lockX, $lockY));
  1843. }
  1844. };
  1845. if (caught('FileNotFoundException') || !$i) {
  1846. error T("Invalid coordinates specified for lockMap, coordinates are unwalkablen");
  1847. $config{'lockMap'} = '';
  1848. } else {
  1849. my $attackOnRoute = 2;
  1850. $attackOnRoute = 1 if ($config{'attackAuto_inLockOnly'} == 1);
  1851. $attackOnRoute = 0 if ($config{'attackAuto_inLockOnly'} > 1);
  1852. if (defined $lockX || defined $lockY) {
  1853. message TF("Calculating lockMap route to: %s(%s): %s, %sn", $maps_lut{$config{'lockMap'}.'.rsw'}, $config{'lockMap'}, $lockX, $lockY), "route";
  1854. } else {
  1855. message TF("Calculating lockMap route to: %s(%s)n", $maps_lut{$config{'lockMap'}.'.rsw'}, $config{'lockMap'}), "route";
  1856. }
  1857. ai_route($config{'lockMap'}, $lockX, $lockY, attackOnRoute => $attackOnRoute);
  1858. }
  1859. }
  1860. }
  1861. }
  1862. }
  1864. ##### AUTO STATS RAISE #####
  1865. sub processAutoStatsRaise {
  1866. if (!$statChanged && $config{statsAddAuto}) {
  1867. # Split list of stats/values
  1868. my @list = split(/ *,+ */, $config{"statsAddAuto_list"});
  1869. my $statAmount;
  1870. my ($num, $st);
  1872. foreach my $item (@list) {
  1873. # Split each stat/value pair
  1874. ($num, $st) = $item =~ /(d+) (str|vit|dex|int|luk|agi)/i;
  1875. $st = lc $st;
  1876. # If stat needs to be raised to match desired amount
  1877. $statAmount = $char->{$st};
  1878. $statAmount += $char->{"${st}_bonus"} if (!$config{statsAddAuto_dontUseBonus});
  1880. if ($statAmount < $num && ($char->{$st} < 99 || $config{statsAdd_over_99})) {
  1881. # If char has enough stat points free to raise stat
  1882. if ($char->{points_free} &&
  1883.     $char->{points_free} >= $char->{"points_$st"}) {
  1884. my $ID;
  1885. if ($st eq "str") {
  1886. $ID = 0x0D;
  1887. } elsif ($st eq "agi") {
  1888. $ID = 0x0E;
  1889. } elsif ($st eq "vit") {
  1890. $ID = 0x0F;
  1891. } elsif ($st eq "int") {
  1892. $ID = 0x10;
  1893. } elsif ($st eq "dex") {
  1894. $ID = 0x11;
  1895. } elsif ($st eq "luk") {
  1896. $ID = 0x12;
  1897. }
  1899. $char->{$st} += 1;
  1900. # Raise stat
  1901. message TF("Auto-adding stat %sn", $st);
  1902. $messageSender->sendAddStatusPoint($ID);
  1903. # Save which stat was raised, so that when we received the
  1904. # "stat changed" packet (00BC?) we can changed $statChanged
  1905. # back to 0 so that kore will start checking again if stats
  1906. # need to be raised.
  1907. # This basically prevents kore from sending packets to the
  1908. # server super-fast, by only allowing another packet to be
  1909. # sent when $statChanged is back to 0 (when the server has
  1910. # replied with a a stat change)
  1911. $statChanged = $st;
  1912. # After we raise a stat, exit loop
  1913. last;
  1914. }
  1915. # If stat needs to be changed but char doesn't have enough stat points to raise it then
  1916. # don't raise it, exit loop
  1917. last;
  1918. }
  1919. }
  1920. }
  1921. }
  1923. ##### AUTO SKILLS RAISE #####
  1924. sub processAutoSkillsRaise {
  1925. if (!$skillChanged && $config{skillsAddAuto}) {
  1926. # Split list of skills and levels
  1927. my @list = split / *,+ */, lc($config{skillsAddAuto_list});
  1929. foreach my $item (@list) {
  1930. # Split each skill/level pair
  1931. my ($sk, undef, $num) = $item =~ /^(.*?)( (d+))?$/;
  1932. $num = 1 if (!defined $num);
  1933. my $skill = new Skill(auto => $sk);
  1935. if (!$skill->getIDN()) {
  1936. error TF("Unknown skill '%s'; disabling skillsAddAuton", $sk);
  1937. $config{skillsAddAuto} = 0;
  1938. last;
  1939. }
  1941. my $handle = $skill->getHandle();
  1943. # If skill needs to be raised to match desired amount && skill points are available
  1944. if ($skill->getIDN() && $char->{points_skill} > 0 && $char->getSkillLevel($skill) < $num) {
  1945. # raise skill
  1946. $messageSender->sendAddSkillPoint($skill->getIDN());
  1947. message TF("Auto-adding skill %sn", $skill->getName());
  1949. # save which skill was raised, so that when we received the
  1950. # "skill changed" packet (010F?) we can changed $skillChanged
  1951. # back to 0 so that kore will start checking again if skills
  1952. # need to be raised.
  1953. # this basically does what $statChanged does for stats
  1954. $skillChanged = $handle;
  1955. # after we raise a skill, exit loop
  1956. last;
  1957. }
  1958. }
  1959. }
  1960. }
  1962. ##### RANDOM WALK #####
  1963. sub processRandomWalk {
  1964. if (AI::isIdle && (AI::SlaveManager::isIdle()) && $config{route_randomWalk} && !$ai_v{sitAuto_forcedBySitCommand}
  1965. && (!$cities_lut{$field{name}.'.rsw'} || $config{route_randomWalk_inTown})
  1966. && length($field{rawMap}) ) {
  1967. my ($randX, $randY);
  1968. my $i = 500;
  1969. do {
  1970. $randX = int(rand($field{width} + 1));
  1971. $randX = int($config{'lockMap_x'} - $config{'lockMap_randX'} + rand(2*$config{'lockMap_randX'}+1)) if ($config{'lockMap_x'} ne '' && $config{'lockMap_randX'} ne '');
  1972. $randY = int(rand($field{height} + 1));
  1973. $randY = int($config{'lockMap_y'} - $config{'lockMap_randY'} + rand(2*$config{'lockMap_randY'}+1)) if ($config{'lockMap_y'} ne '' && $config{'lockMap_randY'} ne '');
  1974. } while (--$i && !$field->isWalkable($randX, $randY));
  1975. if (!$i) {
  1976. error T("Invalid coordinates specified for randomWalk (coordinates are unwalkable); randomWalk disabledn");
  1977. $config{route_randomWalk} = 0;
  1978. } else {
  1979. message TF("Calculating random route to: %s(%s): %s, %sn", $maps_lut{$field{name}.'.rsw'}, $field{name}, $randX, $randY), "route";
  1980. ai_route($field{name}, $randX, $randY,
  1981. maxRouteTime => $config{route_randomWalk_maxRouteTime},
  1982. attackOnRoute => 2,
  1983. noMapRoute => ($config{route_randomWalk} == 2 ? 1 : 0) );
  1984. }
  1985. }
  1986. }
  1988. ##### FOLLOW #####
  1989. sub processFollow {
  1990. # FIXME: Should use actors list to determine who and where is the master
  1991. # TODO: follow should be a 'mode' rather then a sequence, hence all
  1992. # var/flag about follow should be moved to %ai_v
  1994. return if (!$config{follow});
  1996. my $followIndex;
  1997. if (($followIndex = AI::findAction("follow")) eq "") {
  1998. # ai_follow will determine if the Target is 'follow-able'
  1999. return if (!ai_follow($config{followTarget}));
  2000. $followIndex = AI::findAction("follow");
  2001. }
  2002. my $args = AI::args($followIndex);
  2004. # if we are not following now but master is in the screen...
  2005. if (!defined $args->{'ID'}) {
  2006. foreach my Actor::Player $player (@{$playersList->getItems()}) {
  2007. if (($player->name eq $config{followTarget}) && !$player->{'dead'}) {
  2008. $args->{'ID'} = $player->{ID};
  2009. $args->{'following'} = 1;
  2010. $args->{'name'} = $player->name;
  2011.   message TF("Found my master - %sn", $player->name), "follow";
  2012. last;
  2013. }
  2014. }
  2015. } elsif (!$args->{'following'} && $players{$args->{'ID'}} && %{$players{$args->{'ID'}}} && !${$players{$args->{'ID'}}}{'dead'} && ($players{$args->{'ID'}}->name eq $config{followTarget})) {
  2016. $args->{'following'} = 1;
  2017. delete $args->{'ai_follow_lost'};
  2018.   message TF("Found my master!n"), "follow"
  2019. }
  2021. # if we are not doing anything else now...
  2022. if (AI::action eq "follow") {
  2023. if (AI::args->{'suspended'}) {
  2024. if (AI::args->{'ai_follow_lost'}) {
  2025. AI::args->{'ai_follow_lost_end'}{'time'} += time - AI::args->{'suspended'};
  2026. }
  2027. delete AI::args->{'suspended'};
  2028. }
  2030. # if we are not doing anything else now...
  2031. if (!$args->{ai_follow_lost}) {
  2032. my $ID = $args->{ID};
  2033. my $player = $players{$ID};
  2035. if ($args->{following} && $player->{pos_to}) {
  2036. my $dist = distance($char->{pos_to}, $player->{pos_to});
  2037. if ($dist > $config{followDistanceMax} && timeOut($args->{move_timeout}, 0.25)) {
  2038. $args->{move_timeout} = time;
  2039. if ( $dist > 15 || ($config{followCheckLOS} && !checkLineWalkable($char->{pos_to}, $player->{pos_to})) ) {
  2040. ai_route($field{name}, $player->{pos_to}{x}, $player->{pos_to}{y},
  2041. attackOnRoute => 1,
  2042. distFromGoal => $config{followDistanceMin});
  2043. } else {
  2044. my (%vec, %pos);
  2046. stand() if ($char->{sitting});
  2047. getVector(%vec, $player->{pos_to}, $char->{pos_to});
  2048. moveAlongVector(%pos, $char->{pos_to}, %vec, $dist - $config{followDistanceMin});
  2049. $timeout{ai_sit_idle}{time} = time;
  2050. $messageSender->sendMove($pos{x}, $pos{y});
  2051. }
  2052. }
  2053. }
  2055. if ($args->{following} && $player && %{$player}) {
  2056. if ($config{'followSitAuto'} && $players{$args->{'ID'}}{'sitting'} == 1 && $chars[$config{'char'}]{'sitting'} == 0) {
  2057. sit();
  2058. }
  2060. my $dx = $args->{'last_pos_to'}{'x'} - $players{$args->{'ID'}}{'pos_to'}{'x'};
  2061. my $dy = $args->{'last_pos_to'}{'y'} - $players{$args->{'ID'}}{'pos_to'}{'y'};
  2062. $args->{'last_pos_to'}{'x'} = $players{$args->{'ID'}}{'pos_to'}{'x'};
  2063. $args->{'last_pos_to'}{'y'} = $players{$args->{'ID'}}{'pos_to'}{'y'};
  2064. if ($dx != 0 || $dy != 0) {
  2065. lookAtPosition($players{$args->{'ID'}}{'pos_to'}) if ($config{'followFaceDirection'});
  2066. }
  2067. }
  2068. }
  2069. }
  2071. if (AI::action eq "follow" && $args->{'following'} && ( ( $players{$args->{'ID'}} && $players{$args->{'ID'}}{'dead'} ) || ( ( !$players{$args->{'ID'}} || !%{$players{$args->{'ID'}}} ) && $players_old{$args->{'ID'}}{'dead'}))) {
  2072.   message T("Master died. I'll wait here.n"), "party";
  2073. delete $args->{'following'};
  2074. } elsif ($args->{'following'} && ( !$players{$args->{'ID'}} || !%{$players{$args->{'ID'}}} )) {
  2075.   message T("I lost my mastern"), "follow";
  2076. if ($config{'followBot'}) {
  2077.   message T("Trying to get him backn"), "follow";
  2078. sendMessage($messageSender, "pm", "move $chars[$config{'char'}]{'pos_to'}{'x'} $chars[$config{'char'}]{'pos_to'}{'y'}", $config{followTarget});
  2079. }
  2081. delete $args->{'following'};
  2083. if ($players_old{$args->{'ID'}}{'disconnected'}) {
  2084.   message T("My master disconnectedn"), "follow";
  2086. } elsif ($players_old{$args->{'ID'}}{'teleported'}) {
  2087. delete $args->{'ai_follow_lost_warped'};
  2088. delete $ai_v{'temp'}{'warp_pos'};
  2090. # Check to see if the player went through a warp portal and follow him through it.
  2091. my $pos = calcPosition($players_old{$args->{'ID'}});
  2092. my $oldPos = $players_old{$args->{'ID'}}->{pos};
  2093. my (@blocks, $found);
  2094. my %vec;
  2096. debug "Last time i saw, master was moving from ($oldPos->{x}, $oldPos->{y}) to ($pos->{x}, $pos->{y})n", "follow";
  2098. # We must check the ground about 9x9 area of where we last saw our master. That's the only way
  2099. # to ensure he walked through a warp portal. The range is because of lag in some situations.
  2100. @blocks = calcRectArea2($pos->{x}, $pos->{y}, 4, 0);
  2101. foreach (@blocks) {
  2102. next unless (whenGroundStatus($_, "Warp Portal"));
  2103. # We must certify that our master was walking towards that portal.
  2104. getVector(%vec, $_, $oldPos);
  2105. next unless (checkMovementDirection($oldPos, %vec, $_, 15));
  2106. $found = $_;
  2107. last;
  2108. }
  2110. if ($found) {
  2111. %{$ai_v{'temp'}{'warp_pos'}} = %{$found};
  2112. $args->{'ai_follow_lost_warped'} = 1;
  2113. $args->{'ai_follow_lost'} = 1;
  2114. $args->{'ai_follow_lost_end'}{'timeout'} = $timeout{'ai_follow_lost_end'}{'timeout'};
  2115. $args->{'ai_follow_lost_end'}{'time'} = time;
  2116. $args->{'ai_follow_lost_vec'} = {};
  2117. getVector($args->{'ai_follow_lost_vec'}, $players_old{$args->{'ID'}}{'pos_to'}, $chars[$config{'char'}]{'pos_to'});
  2119. } else {
  2120.   message T("My master teleportedn"), "follow", 1;
  2121. }
  2123. } elsif ($players_old{$args->{'ID'}}{'disappeared'}) {
  2124.   message T("Trying to find lost mastern"), "follow", 1;
  2126. delete $args->{'ai_follow_lost_char_last_pos'};
  2127. delete $args->{'follow_lost_portal_tried'};
  2128. $args->{'ai_follow_lost'} = 1;
  2129. $args->{'ai_follow_lost_end'}{'timeout'} = $timeout{'ai_follow_lost_end'}{'timeout'};
  2130. $args->{'ai_follow_lost_end'}{'time'} = time;
  2131. $args->{'ai_follow_lost_vec'} = {};
  2132. getVector($args->{'ai_follow_lost_vec'}, $players_old{$args->{'ID'}}{'pos_to'}, $chars[$config{'char'}]{'pos_to'});
  2134. #check if player went through portal
  2135. my $first = 1;
  2136. my $foundID;
  2137. my $smallDist;
  2138. foreach (@portalsID) {
  2139. next if (!defined $_);
  2140. $ai_v{'temp'}{'dist'} = distance($players_old{$args->{'ID'}}{'pos_to'}, $portals{$_}{'pos'});
  2141. if ($ai_v{'temp'}{'dist'} <= 7 && ($first || $ai_v{'temp'}{'dist'} < $smallDist)) {
  2142. $smallDist = $ai_v{'temp'}{'dist'};
  2143. $foundID = $_;
  2144. undef $first;
  2145. }
  2146. }
  2147. $args->{'follow_lost_portalID'} = $foundID;
  2148. } else {
  2149.   message T("Don't know what happened to Mastern"), "follow", 1;
  2150. }
  2151. }
  2153. ##### FOLLOW-LOST #####
  2155. if (AI::action eq "follow" && $args->{'ai_follow_lost'}) {
  2156. if ($args->{'ai_follow_lost_char_last_pos'}{'x'} == $chars[$config{'char'}]{'pos_to'}{'x'} && $args->{'ai_follow_lost_char_last_pos'}{'y'} == $chars[$config{'char'}]{'pos_to'}{'y'}) {
  2157. $args->{'lost_stuck'}++;
  2158. } else {
  2159. delete $args->{'lost_stuck'};
  2160. }
  2161. %{AI::args->{'ai_follow_lost_char_last_pos'}} = %{$chars[$config{'char'}]{'pos_to'}};
  2163. if (timeOut($args->{'ai_follow_lost_end'})) {
  2164. delete $args->{'ai_follow_lost'};
  2165.   message T("Couldn't find master, giving upn"), "follow";
  2167. } elsif ($players_old{$args->{'ID'}}{'disconnected'}) {
  2168. delete AI::args->{'ai_follow_lost'};
  2169.   message T("My master disconnectedn"), "follow";
  2171. } elsif ($args->{'ai_follow_lost_warped'} && $ai_v{'temp'}{'warp_pos'} && %{$ai_v{'temp'}{'warp_pos'}}) {
  2172. my $pos = $ai_v{'temp'}{'warp_pos'};
  2174. if ($config{followCheckLOS} && !checkLineWalkable($char->{pos_to}, $pos)) {
  2175. ai_route($field{name}, $pos->{x}, $pos->{y},
  2176. attackOnRoute => 0); #distFromGoal => 0);
  2177. } else {
  2178. my (%vec, %pos_to);
  2179. my $dist = distance($char->{pos_to}, $pos);
  2181. stand() if ($char->{sitting});
  2182. getVector(%vec, $pos, $char->{pos_to});
  2183. moveAlongVector(%pos_to, $char->{pos_to}, %vec, $dist);
  2184. $timeout{ai_sit_idle}{time} = time;
  2185. move($pos_to{x}, $pos_to{y});
  2186. $pos->{x} = int $pos_to{x};
  2187. $pos->{y} = int $pos_to{y};
  2189. }
  2190. delete $args->{'ai_follow_lost_warped'};
  2191. delete $ai_v{'temp'}{'warp_pos'};
  2193.   message TF("My master warped at (%s, %s) - moving to warp pointn", $pos->{x}, $pos->{y}), "follow";
  2195. } elsif ($players_old{$args->{'ID'}}{'teleported'}) {
  2196. delete AI::args->{'ai_follow_lost'};
  2197.   message T("My master teleportedn"), "follow";
  2199. } elsif ($args->{'lost_stuck'}) {
  2200. if ($args->{'follow_lost_portalID'} eq "") {
  2201. moveAlongVector($ai_v{'temp'}{'pos'}, $chars[$config{'char'}]{'pos_to'}, $args->{'ai_follow_lost_vec'}, $config{'followLostStep'} / ($args->{'lost_stuck'} + 1));
  2202. move($ai_v{'temp'}{'pos'}{'x'}, $ai_v{'temp'}{'pos'}{'y'});
  2203. }
  2204. } else {
  2205. my $portalID = $args->{follow_lost_portalID};
  2206. if ($args->{'follow_lost_portalID'} ne "" && $portalID) {
  2207. if ($portals{$portalID} && !$args->{'follow_lost_portal_tried'}) {
  2208. $args->{'follow_lost_portal_tried'} = 1;
  2209. %{$ai_v{'temp'}{'pos'}} = %{$portals{$args->{'follow_lost_portalID'}}{'pos'}};
  2210. ai_route($field{'name'}, $ai_v{'temp'}{'pos'}{'x'}, $ai_v{'temp'}{'pos'}{'y'},
  2211. attackOnRoute => 1);
  2212. }
  2213. } else {
  2214. moveAlongVector($ai_v{'temp'}{'pos'}, $chars[$config{'char'}]{'pos_to'}, $args->{'ai_follow_lost_vec'}, $config{'followLostStep'});
  2215. move($ai_v{'temp'}{'pos'}{'x'}, $ai_v{'temp'}{'pos'}{'y'});
  2216. }
  2217. }
  2218. }
  2220. # Use party information to find master
  2221. if (!exists $args->{following} && !exists $args->{ai_follow_lost}) {
  2222. ai_partyfollow();
  2223. }
  2224. }
  2226. ##### SITAUTO-IDLE #####
  2227. sub processSitAutoIdle {
  2228. if ($config{sitAuto_idle}) {
  2229. if (!AI::isIdle && AI::action ne "follow") {
  2230. $timeout{ai_sit_idle}{time} = time;
  2231. }
  2233. if ( !$char->{sitting} && timeOut($timeout{ai_sit_idle})
  2234.  && (!$config{shopAuto_open} || timeOut($timeout{ai_shop})) ) {
  2235. sit();
  2236. }
  2237. }
  2238. }
  2240. ##### SIT AUTO #####
  2241. sub processSitAuto {
  2242. my $weight = percent_weight($char);
  2243. my $action = AI::action;
  2244. my $lower_ok = (percent_hp($char) >= $config{'sitAuto_hp_lower'} && percent_sp($char) >= $config{'sitAuto_sp_lower'});
  2245. my $upper_ok = (percent_hp($char) >= $config{'sitAuto_hp_upper'} && percent_sp($char) >= $config{'sitAuto_sp_upper'});
  2247. if ($ai_v{'sitAuto_forceStop'} && $lower_ok) {
  2248. $ai_v{'sitAuto_forceStop'} = 0;
  2249. }
  2251. # Sit if we're not already sitting
  2252. if ($action eq "sitAuto" && !$char->{sitting} && $char->{skills}{NV_BASIC}{lv} >= 3 &&
  2253.     !ai_getAggressives() && ($weight < 50 || $config{'sitAuto_over_50'})) {
  2254. debug "sitAuto - sitn", "sitAuto";
  2255. sit();
  2257. } elsif ($action eq "sitAuto" && $ai_v{'sitAuto_forceStop'}) {
  2258. AI::dequeue;
  2259. stand() if (!AI::isIdle && !AI::is(qw(follow sitting clientSuspend)) && !$config{'sitAuto_idle'} && $char->{sitting});
  2261. # Stand if our HP is high enough
  2262. } elsif ($action eq "sitAuto" && $upper_ok) {
  2263. if ($timeout{ai_safe_stand_up}{timeout} && !isSafe()) {
  2264. if (!$timeout{ai_safe_stand_up}{passed}
  2265.   || ($timeout{ai_safe_stand_up}{passed} && timeOut($timeout{ai_safe_stand_up}{time}, $timeout{ai_safe_stand_up}{timeout} + 1))
  2266. ) {
  2267. $timeout{ai_safe_stand_up}{time} = time;
  2268. $timeout{ai_safe_stand_up}{passed} = 1;
  2269. return;
  2270. } elsif ($timeout{ai_safe_stand_up}{passed} && !timeOut($timeout{ai_safe_stand_up})) {
  2271. return;
  2272. } elsif ($timeout{ai_safe_stand_up}{passed} && timeOut($timeout{ai_safe_stand_up})) {
  2273. $timeout{ai_safe_stand_up}{time} = 0;
  2274. $timeout{ai_safe_stand_up}{passed} = 0;
  2275. }
  2276. }
  2277. AI::dequeue;
  2278. debug "HP is now > $config{sitAuto_hp_upper}n", "sitAuto";
  2279. stand() if (!AI::isIdle && !AI::is(qw(follow sitting clientSuspend)) && !$config{'sitAuto_idle'} && $char->{sitting});
  2281. } elsif (!$ai_v{'sitAuto_forceStop'} && ($weight < 50 || $config{'sitAuto_over_50'}) && AI::action ne "sitAuto") {
  2282. if ($action eq "" || $action eq "follow"
  2283. || ($action eq "route" && !AI::args->{noSitAuto})
  2284. || ($action eq "mapRoute" && !AI::args->{noSitAuto})
  2285. ) {
  2286. if (!AI::inQueue("attack") && !ai_getAggressives()
  2287. && !AI::inQueue("sitAuto")  # do not queue sitAuto if there is an existing sitAuto sequence
  2288. && (percent_hp($char) < $config{'sitAuto_hp_lower'} || percent_sp($char) < $config{'sitAuto_sp_lower'})) {
  2289. AI::queue("sitAuto");
  2290. debug "Auto-sittingn", "sitAuto";
  2291. }
  2292. }
  2293. }
  2294. }
  2296. ##### AUTO-COMMAND USE #####
  2297. sub processAutoCommandUse {
  2298. if (AI::isIdle || AI::is(qw(route mapRoute follow sitAuto take items_gather items_take attack skill_use))) {
  2299. my $i = 0;
  2300. while (exists $config{"doCommand_$i"}) {
  2301. if ($config{"doCommand_$i"} && checkSelfCondition("doCommand_$i")) {
  2302. Commands::run($config{"doCommand_$i"});
  2303. $ai_v{"doCommand_$i"."_time"} = time;
  2304. my $cmd_prefix = $config{"doCommand_$i"};
  2305. debug qq~Auto-Command use: $cmd_prefixn~, "ai";
  2306. last;
  2307. }
  2308. $i++;
  2309. }
  2310. }
  2311. }
  2313. ##### AUTO-ITEM USE #####
  2314. sub processAutoItemUse {
  2315. if ((AI::isIdle || AI::is(qw(route mapRoute follow sitAuto take items_gather items_take attack skill_use)))
  2316.   && timeOut($timeout{ai_item_use_auto})) {
  2317. my $i = 0;
  2318. while (exists $config{"useSelf_item_$i"}) {
  2319. if ($config{"useSelf_item_${i}_timeout"} eq "") {$config{"useSelf_item_${i}_timeout"} = 0;}
  2320. if ($config{"useSelf_item_$i"} && checkSelfCondition("useSelf_item_$i")) {
  2321. my $item = $char->inventory->getByNameList($config{"useSelf_item_$i"});
  2322. if ($item) {
  2323. $messageSender->sendItemUse($item->{index}, $accountID);
  2324. $ai_v{"useSelf_item_$i"."_time"} = time;
  2325. $timeout{ai_item_use_auto}{time} = time;
  2326. debug qq~Auto-item use: $item->{name}n~, "ai";
  2327. last;
  2328. } elsif ($config{"useSelf_item_${i}_dcOnEmpty"} && $char->inventory->size() > 0) {
  2329. error TF("Disconnecting on empty %s!n", $config{"useSelf_item_$i"});
  2330. chatLog("k", TF("Disconnecting on empty %s!n", $config{"useSelf_item_$i"}));
  2331. quit();
  2332. }
  2333. }
  2334. $i++;
  2335. }
  2336. }
  2337. }
  2339. ##### AUTO-SKILL USE #####
  2340. sub processAutoSkillUse {
  2341. if (AI::isIdle || AI::is(qw(route mapRoute follow sitAuto take items_gather items_take attack))
  2342. || (AI::action eq "skill_use" && AI::args->{tag} eq "attackSkill")) {
  2343. my %self_skill;
  2344. for (my $i = 0; exists $config{"useSelf_skill_$i"}; $i++) {
  2345. if ($config{"useSelf_skill_$i"} && checkSelfCondition("useSelf_skill_$i")) {
  2346. $ai_v{"useSelf_skill_$i"."_time"} = time;
  2347. $self_skill{skillObject} = Skill->new(name => lc($config{"useSelf_skill_$i"}));
  2348. $self_skill{ID} = $self_skill{skillObject}->getHandle();
  2349. $self_skill{owner} = $self_skill{skillObject}->getOwner();
  2350. unless ($self_skill{ID}) {
  2351. error "Unknown skill name '".$config{"useSelf_skill_$i"}."' in useSelf_skill_$in";
  2352. configModify("useSelf_skill_${i}_disabled", 1);
  2353. next;
  2354. }
  2355. $self_skill{lvl} = $config{"useSelf_skill_$i"."_lvl"};
  2356. $self_skill{maxCastTime} = $config{"useSelf_skill_$i"."_maxCastTime"};
  2357. $self_skill{minCastTime} = $config{"useSelf_skill_$i"."_minCastTime"};
  2358. $self_skill{prefix} = "useSelf_skill_$i";
  2359. last;
  2360. }
  2361. }
  2362. if ($config{useSelf_skill_smartHeal} && $self_skill{ID} eq "AL_HEAL") {
  2363. my $smartHeal_lv = 1;
  2364. my $hp_diff = $char->{hp_max} - $char->{hp};
  2365. my $meditatioBonus = 1;
  2366. $meditatioBonus = 1 + int(($char->{skills}{HP_MEDITATIO}{lv} * 2) / 100) if ($char->{skills}{HP_MEDITATIO});
  2367. for (my $i = 1; $i <= $char->{skills}{$self_skill{ID}}{lv}; $i++) {
  2368. my ($sp_req, $amount);
  2370. $smartHeal_lv = $i;
  2371. $sp_req = 10 + ($i * 3);
  2372. $amount = (int(($char->{lv} + $char->{int}) / 8) * (4 + $i * 8)) * $meditatioBonus;
  2373. if ($char->{sp} < $sp_req) {
  2374. $smartHeal_lv--;
  2375. last;
  2376. }
  2377. last if ($amount >= $hp_diff);
  2378. }
  2379. $self_skill{lvl} = $smartHeal_lv;
  2380. }
  2381. if ($config{$self_skill{prefix}."_smartEncore"} &&
  2382. $char->{encoreSkill} &&
  2383. $char->{encoreSkill}->getHandle() eq $self_skill{ID}) {
  2384. # Use Encore skill instead if applicable
  2385. $self_skill{ID} = 'BD_ENCORE';
  2386. }
  2387. if ($self_skill{lvl} > 0) {
  2388. debug qq~Auto-skill on self: $config{$self_skill{prefix}} (lvl $self_skill{lvl})n~, "ai";
  2389. if (!ai_getSkillUseType($self_skill{ID})) {
  2390. ai_skillUse($self_skill{ID}, $self_skill{lvl}, $self_skill{maxCastTime}, $self_skill{minCastTime}, $self_skill{owner}{ID}, undef, undef, undef, undef, $self_skill{prefix});
  2391. } else {
  2392. ai_skillUse($self_skill{ID}, $self_skill{lvl}, $self_skill{maxCastTime}, $self_skill{minCastTime}, $self_skill{owner}{pos_to}{x}, $self_skill{owner}{pos_to}{y}, undef, undef, undef, $self_skill{prefix});
  2393. }
  2394. }
  2395. }
  2396. }
  2398. ##### PARTY-SKILL USE #####
  2399. sub processPartySkillUse {
  2400. if (AI::isIdle || AI::is(qw(route mapRoute follow sitAuto take items_gather items_take attack move))){
  2401. my %party_skill;
  2402. for (my $i = 0; exists $config{"partySkill_$i"}; $i++) {
  2403. next if (!$config{"partySkill_$i"});
  2404. $party_skill{owner} = Skill->new(name => lc($config{"partySkill_$i"}))->getOwner();
  2406. foreach my $ID ($accountID, @slavesID, @playersID) {
  2407. next if $ID eq '' || $ID eq $party_skill{owner}{ID};
  2409. if ($ID eq $accountID) {
  2410. #
  2411. } elsif ($slavesList->getByID($ID)) {
  2412. next if ((!$char->{slaves} || !$char->{slaves}{$ID}) && !$config{"partySkill_$i"."_notPartyOnly"});
  2413. next if ($char->{slaves}{$ID}->{name} ne $slavesList->getByID($ID)->name) && (!$config{"partySkill_$i"."_notPartyOnly"});
  2414. } elsif ($playersList->getByID($ID)) {
  2415. next if ((!$char->{party} || !$char->{party}{users}{$ID}) && !$config{"partySkill_$i"."_notPartyOnly"});
  2416. next if ($char->{party}{users}{$ID}->{name} ne $playersList->getByID($ID)->name) && (!$config{"partySkill_$i"."_notPartyOnly"});
  2417. }
  2419. my $player = Actor::get($ID);
  2420. next unless (
  2421. UNIVERSAL::isa($player, 'Actor::You')
  2422. || UNIVERSAL::isa($player, 'Actor::Player')
  2423. || UNIVERSAL::isa($player, 'Actor::Slave')
  2424. );
  2426. if (
  2427. ( # range check
  2428. $party_skill{owner}{ID} eq $player->{ID}
  2429. || inRange(distance($party_skill{owner}{pos_to}, $player->{pos}), $config{partySkillDistance} || "0..8")
  2430. )
  2431. && ( # target check
  2432. !$config{"partySkill_$i"."_target"}
  2433. or existsInList($config{"partySkill_$i"."_target"}, $player->{name})
  2434. or $player->{ID} eq $char->{ID} && existsInList($config{"partySkill_$i"."_target"}, '@main')
  2435. or $player->{ID} eq $char->{homunculus}{ID} && existsInList($config{"partySkill_$i"."_target"}, '@homunculus')
  2436. or $player->{ID} eq $char->{mercenary}{ID} && existsInList($config{"partySkill_$i"."_target"}, '@mercenary')
  2437. )
  2438. && checkPlayerCondition("partySkill_$i"."_target", $ID)
  2439. && checkSelfCondition("partySkill_$i")
  2440. ){
  2441. $party_skill{ID} = Skill->new(name => lc($config{"partySkill_$i"}))->getHandle();
  2442. $party_skill{lvl} = $config{"partySkill_$i"."_lvl"};
  2443. $party_skill{target} = $player->{name};
  2444. my $pos = $player->position;
  2445. $party_skill{x} = $pos->{x};
  2446. $party_skill{y} = $pos->{y};
  2447. $party_skill{targetID} = $ID;
  2448. $party_skill{maxCastTime} = $config{"partySkill_$i"."_maxCastTime"};
  2449. $party_skill{minCastTime} = $config{"partySkill_$i"."_minCastTime"};
  2450. $party_skill{isSelfSkill} = $config{"partySkill_$i"."_isSelfSkill"};
  2451. $party_skill{prefix} = "partySkill_$i";
  2452. # This is used by setSkillUseTimer() to set
  2453. # $ai_v{"partySkill_${i}_target_time"}{$targetID}
  2454. # when the skill is actually cast
  2455. $targetTimeout{$ID}{$party_skill{ID}} = $i;
  2456. last;
  2457. }
  2459. }
  2460. last if (defined $party_skill{targetID});
  2461. }
  2463. if ($config{useSelf_skill_smartHeal} && $party_skill{ID} eq "AL_HEAL" && !$config{$party_skill{prefix}."_noSmartHeal"}) {
  2464. my $smartHeal_lv = 1;
  2465. my $hp_diff;
  2466. if ($char->{party} && $char->{party}{users}{$party_skill{targetID}} && $char->{party}{users}{$party_skill{targetID}}{hp}) {
  2467. $hp_diff = $char->{party}{users}{$party_skill{targetID}}{hp_max} - $char->{party}{users}{$party_skill{targetID}}{hp};
  2468. } else {
  2469. if ($players{$party_skill{targetID}}) {
  2470. $hp_diff = -$players{$party_skill{targetID}}{deltaHp};
  2471. }
  2472. }
  2473. for (my $i = 1; $i <= $char->{skills}{$party_skill{ID}}{lv}; $i++) {
  2474. my ($sp_req, $amount);
  2476. $smartHeal_lv = $i;
  2477. $sp_req = 10 + ($i * 3);
  2478. $amount = int(($char->{lv} + $char->{int}) / 8) * (4 + $i * 8);
  2479. if ($char->{sp} < $sp_req) {
  2480. $smartHeal_lv--;
  2481. last;
  2482. }
  2483. last if ($amount >= $hp_diff);
  2484. }
  2485. $party_skill{lvl} = $smartHeal_lv;
  2486. }
  2487. if (defined $party_skill{targetID}) {
  2488. debug qq~Party Skill used ($party_skill{target}) Skills Used: $config{$party_skill{prefix}} (lvl $party_skill{lvl})n~, "skill";
  2489. if (!ai_getSkillUseType($party_skill{ID})) {
  2490. ai_skillUse(
  2491. $party_skill{ID},
  2492. $party_skill{lvl},
  2493. $party_skill{maxCastTime},
  2494. $party_skill{minCastTime},
  2495. $party_skill{isSelfSkill} ? $party_skill{owner}{ID} : $party_skill{targetID},
  2496. undef,
  2497. undef,
  2498. undef,
  2499. undef,
  2500. $party_skill{prefix});
  2501. } else {
  2502. my $pos = ($party_skill{isSelfSkill}) ? $party_skill{owner}{pos_to} : %party_skill;
  2503. ai_skillUse(
  2504. $party_skill{ID},
  2505. $party_skill{lvl},
  2506. $party_skill{maxCastTime},
  2507. $party_skill{minCastTime},
  2508. $pos->{x},
  2509. $pos->{y},
  2510. undef,
  2511. undef,
  2512. undef,
  2513. $party_skill{prefix});
  2514. }
  2515. }
  2516. }
  2517. }
  2519. ##### MONSTER SKILL USE #####
  2520. sub processMonsterSkillUse {
  2521. if (AI::isIdle || AI::is(qw(route mapRoute follow sitAuto take items_gather items_take attack move))) {
  2522. my $i = 0;
  2523. my $prefix = "monsterSkill_$i";
  2524. while ($config{$prefix}) {
  2525. # monsterSkill can be used on any monster that we could
  2526. # attackAuto
  2527. my @monsterIDs = ai_getAggressives(1, 1);
  2528. for my $monsterID (@monsterIDs) {
  2529. my $monster = $monsters{$monsterID};
  2530. if (checkSelfCondition($prefix)
  2531.     && checkMonsterCondition("${prefix}_target", $monster)) {
  2532. my $skill = new Skill(name => $config{$prefix});
  2534. next if $config{"${prefix}_maxUses"} && $monster->{skillUses}{$skill->getHandle()} >= $config{"${prefix}_maxUses"};
  2535. next if $config{"${prefix}_target"} && !existsInList($config{"${prefix}_target"}, $monster->{name});
  2537. my $lvl = $config{"${prefix}_lvl"};
  2538. my $maxCastTime = $config{"${prefix}_maxCastTime"};
  2539. my $minCastTime = $config{"${prefix}_minCastTime"};
  2540. debug "Auto-monsterSkill on $monster->{name} ($monster->{binID}): ".$skill->getName()." (lvl $lvl)n", "monsterSkill";
  2541. my $target = $config{"${prefix}_isSelfSkill"} ? $char : $monster;
  2542. ai_skillUse2($skill, $lvl, $maxCastTime, $minCastTime, $target, $prefix);
  2543. $ai_v{$prefix . "_time"}{$monsterID} = time;
  2544. last;
  2545. }
  2546. }
  2547. $i++;
  2548. $prefix = "monsterSkill_$i";
  2549. }
  2550. }
  2551. }
  2553. ##### AUTO-EQUIP #####
  2554. sub processAutoEquip {
  2555. Benchmark::begin("ai_autoEquip") if DEBUG;
  2556. if ((AI::isIdle || AI::is(qw(route mapRoute follow sitAuto skill_use take items_gather items_take attack)))
  2557.   && timeOut($timeout{ai_item_equip_auto}) && time > $ai_v{'inventory_time'}) {
  2559. my $ai_index_attack = AI::findAction("attack");
  2561. my $monster;
  2562. if (defined $ai_index_attack) {
  2563. my $ID = AI::args($ai_index_attack)->{ID};
  2564. $monster = $monsters{$ID};
  2565. }
  2567. # we will create a list of items to equip
  2568. my %eq_list;
  2570. for (my $i = 0; exists $config{"equipAuto_$i"}; $i++) {
  2571. if ((!$config{"equipAuto_${i}_weight"} || $char->{percent_weight} >= $config{"equipAuto_$i" . "_weight"})
  2572.  && (!$config{"equipAuto_${i}_whileSitting"} || ($config{"equipAuto_${i}_whileSitting"} && $char->{sitting}))
  2573.  && (!$config{"equipAuto_${i}_target"} || (defined $monster && existsInList($config{"equipAuto_$i" . "_target"}, $monster->{name})))
  2574.  && checkMonsterCondition("equipAuto_${i}_target", $monster)
  2575.  && checkSelfCondition("equipAuto_$i")
  2576.  && Actor::Item::scanConfigAndCheck("equipAuto_$i")
  2577. ) {
  2578. foreach my $slot (values %equipSlot_lut) {
  2579. if (exists $config{"equipAuto_$i"."_$slot"}) {
  2580. debug "Equip $slot with ".$config{"equipAuto_$i"."_$slot"}."n";
  2581. $eq_list{$slot} = $config{"equipAuto_$i"."_$slot"} if (!$eq_list{$slot});
  2582. }
  2583. }
  2584. }
  2585. }
  2587. if (%eq_list) {
  2588. debug "Auto-equipping itemsn", "equipAuto";
  2589. Actor::Item::bulkEquip(%eq_list);
  2590. }
  2591. $timeout{ai_item_equip_auto}{time} = time;
  2593. }
  2594. Benchmark::end("ai_autoEquip") if DEBUG;
  2595. }
  2597. ##### AUTO-ATTACK #####
  2598. sub processAutoAttack {
  2599. # The auto-attack logic is as follows:
  2600. # 1. Generate a list of monsters that we are allowed to attack.
  2601. # 2. Pick the "best" monster out of that list, and attack it.
  2603. Benchmark::begin("ai_autoAttack") if DEBUG;
  2605. return if (!$field);
  2606. if ((AI::isIdle || AI::is(qw/route follow sitAuto take items_gather items_take/) || (AI::action eq "mapRoute" && AI::args->{stage} eq 'Getting Map Solution'))
  2607.      # Don't auto-attack monsters while taking loot, and itemsTake/GatherAuto >= 2
  2608.   && !($config{'itemsTakeAuto'} >= 2 && AI::is("take", "items_take"))
  2609.   && !($config{'itemsGatherAuto'} >= 2 && AI::is("take", "items_gather"))
  2610.   && timeOut($timeout{ai_attack_auto})
  2611.   && (!$config{teleportAuto_search} || $ai_v{temp}{searchMonsters} >= $config{teleportAuto_search})
  2612.   && (!$config{attackAuto_notInTown} || !$cities_lut{$field{name}.'.rsw'})) {
  2614. # If we're in tanking mode, only attack something if the person we're tanking for is on screen.
  2615. my $foundTankee;
  2616. if ($config{'tankMode'}) {
  2617. foreach (@playersID) {
  2618. next if (!$_);
  2619. if ($config{'tankModeTarget'} eq $players{$_}{'name'}) {
  2620. $foundTankee = 1;
  2621. last;
  2622. }
  2623. }
  2624. }
  2626. my $attackTarget;
  2628. if (!$config{'tankMode'} || $foundTankee) {
  2629. # Detect whether we are currently in follow mode
  2630. my $following;
  2631. my $followID;
  2632. if (defined(my $followIndex = AI::findAction("follow"))) {
  2633. $following = AI::args($followIndex)->{following};
  2634. $followID = AI::args($followIndex)->{ID};
  2635. }
  2637. my $routeIndex = AI::findAction("route");
  2638. $routeIndex = AI::findAction("mapRoute") if (!defined $routeIndex);
  2639. my $attackOnRoute;
  2640. if (defined $routeIndex) {
  2641. $attackOnRoute = AI::args($routeIndex)->{attackOnRoute};
  2642. } else {
  2643. $attackOnRoute = 2;
  2644. }
  2646. my $LOSSubRoute = 0;
  2647. if ($config{attackCheckLOS}
  2648.  && AI::args(0)->{LOSSubRoute}
  2649. ) {
  2650. $LOSSubRoute = 1;
  2651. }
  2653. ### Step 1: Generate a list of all monsters that we are allowed to attack. ###
  2655. my @aggressives;
  2656. my @partyMonsters;
  2657. my @cleanMonsters;
  2659. # List aggressive monsters
  2660. @aggressives = ai_getAggressives(1) if ($config{'attackAuto'} && ($attackOnRoute || $LOSSubRoute));
  2662. # List party monsters
  2663. foreach (@monstersID) {
  2664. next if (!$_ || !checkMonsterCleanness($_));
  2665. my $monster = $monsters{$_};
  2667. OpenKoreMod::autoAttack($monster) if (defined &OpenKoreMod::autoAttack);
  2669. # List monsters that party members are attacking
  2670. if ($config{attackAuto_party} && $attackOnRoute && !AI::is("take", "items_take")
  2671.  && !$ai_v{sitAuto_forcedBySitCommand}
  2672.  && (($monster->{dmgFromParty} && $config{attackAuto_party} != 2) ||
  2673.      $monster->{dmgToParty} || $monster->{missedToParty})
  2674.  && timeOut($monster->{attack_failed}, $timeout{ai_attack_unfail}{timeout})) {
  2675. push @partyMonsters, $_;
  2676. next;
  2677. }
  2679. # List monsters that the master is attacking
  2680. if ($following && $config{'attackAuto_followTarget'} && $attackOnRoute && !AI::is("take", "items_take")
  2681.  && ($monster->{dmgToPlayer}{$followID} || $monster->{dmgFromPlayer}{$followID} || $monster->{missedToPlayer}{$followID})
  2682.  && timeOut($monster->{attack_failed}, $timeout{ai_attack_unfail}{timeout})) {
  2683. push @partyMonsters, $_;
  2684. next;
  2685. }
  2687. my $control = mon_control($monster->{name});
  2688. if (!AI::is(qw/sitAuto take items_gather items_take/)
  2689.  && $config{'attackAuto'} >= 2
  2690.  && ($control->{attack_auto} == 1 || $control->{attack_auto} == 3)
  2691.  && (!$config{'attackAuto_onlyWhenSafe'} || isSafe())
  2692.  && !$ai_v{sitAuto_forcedBySitCommand}
  2693.  && ($attackOnRoute >= 2 || $LOSSubRoute)
  2694.  && !$monster->{dmgFromYou}
  2695.  && timeOut($monster->{attack_failed}, $timeout{ai_attack_unfail}{timeout})) {
  2696. push @cleanMonsters, $_;
  2697. }
  2698. }
  2700. ### Step 2: Pick out the "best" monster ###
  2702. # We define whether we should attack only monsters in LOS or not
  2703. my $nonLOSNotAllowed = !$config{attackCheckLOS} || $LOSSubRoute;
  2704. $attackTarget = getBestTarget(@aggressives, $nonLOSNotAllowed)
  2705. || getBestTarget(@partyMonsters, $nonLOSNotAllowed)
  2706. || getBestTarget(@cleanMonsters, $nonLOSNotAllowed);
  2708. if ($LOSSubRoute && $attackTarget) {
  2709. Log::message("New target was choosenn");
  2710. # Remove all unnecessary actions (attacks and movements but the main route)
  2711. my $i = scalar(@ai_seq);
  2712. my (@ai_seq_temp, @ai_seq_args_temp);
  2713. for(my $c=0;$c<$i;$c++) {
  2714. if (($ai_seq[$c] ne "route")
  2715.   && ($ai_seq[$c] ne "move")
  2716.   && ($ai_seq[$c] ne "attack")) {
  2717. push(@ai_seq_temp, $ai_seq[$c]);
  2718. push(@ai_seq_args_temp, $ai_seq_args[$c]);
  2719. }
  2720. }
  2721. # Add the main route and rewrite the sequence
  2722. push(@ai_seq_temp, $ai_seq[$i-1]);
  2723. push(@ai_seq_args_temp, $ai_seq_args[$i-1]);
  2724. @ai_seq = @ai_seq_temp;
  2725. @ai_seq_args = @ai_seq_args_temp;
  2726. # We need this timeout not to have attack started many times
  2727. $timeout{'ai_attack_auto'}{'time'} = time;
  2728. }
  2729. }
  2731. # If an appropriate monster's found, attack it. If not, wait ai_attack_auto secs before searching again.
  2732. if ($attackTarget) {
  2733. ai_setSuspend(0);
  2734. attack($attackTarget);
  2735. } else {
  2736. $timeout{'ai_attack_auto'}{'time'} = time;
  2737. }
  2738. }
  2740. Benchmark::end("ai_autoAttack") if DEBUG;
  2741. }
  2743. ##### ITEMS TAKE #####
  2744. # Look for loot to pickup when your monster died.
  2745. sub processItemsTake {
  2746. if (AI::action eq "items_take" && AI::args->{suspended}) {
  2747. AI::args->{ai_items_take_start}{time} += time - AI::args->{suspended};
  2748. AI::args->{ai_items_take_end}{time} += time - AI::args->{suspended};
  2749. delete AI::args->{suspended};
  2750. }
  2751. if (AI::action eq "items_take" && (percent_weight($char) >= $config{itemsMaxWeight})) {
  2752. AI::dequeue;
  2753. ai_clientSuspend(0, $timeout{ai_attack_waitAfterKill}{timeout}) unless (ai_getAggressives());
  2754. }
  2755. if (AI::action eq "items_take" && timeOut(AI::args->{ai_items_take_start})
  2756.  && timeOut(AI::args->{ai_items_take_delay})) {
  2757. my $foundID;
  2758. my ($dist, $dist_to);
  2760. foreach (@itemsID) {
  2761. next unless $_;
  2762. my $item = $items{$_};
  2763. next if (pickupitems($item->{name}) eq "0" || pickupitems($item->{name}) == -1);
  2765. $dist = distance($item->{pos}, AI::args->{pos});
  2766. $dist_to = distance($item->{pos}, AI::args->{pos_to});
  2767. if (($dist <= 4 || $dist_to <= 4) && $item->{take_failed} == 0) {
  2768. $foundID = $_;
  2769. last;
  2770. }
  2771. }
  2772. if (defined $foundID) {
  2773. AI::args->{ai_items_take_end}{time} = time;
  2774. AI::args->{started} = 1;
  2775. AI::args->{ai_items_take_delay}{time} = time;
  2776. take($foundID);
  2777. } elsif (AI::args->{started} || timeOut(AI::args->{ai_items_take_end})) {
  2778. $timeout{'ai_attack_auto'}{'time'} = 0;
  2779. AI::dequeue;
  2780. }
  2781. }
  2782. }
  2784. ##### ITEMS AUTO-GATHER #####
  2785. sub processItemsAutoGather {
  2786. if ( (AI::isIdle || AI::action eq "follow"
  2787. || ( AI::is("route", "mapRoute") && (!AI::args->{ID} || $config{'itemsGatherAuto'} >= 2)  && !$config{itemsTakeAuto_new}))
  2788.   && $config{'itemsGatherAuto'}
  2789.   && !$ai_v{sitAuto_forcedBySitCommand}
  2790.   && ($config{'itemsGatherAuto'} >= 2 || !ai_getAggressives())
  2791.   && percent_weight($char) < $config{'itemsMaxWeight'}
  2792.   && timeOut($timeout{ai_items_gather_auto}) ) {
  2794. foreach my $item (@itemsID) {
  2795. next if ($item eq ""
  2796. || !timeOut($items{$item}{appear_time}, $timeout{ai_items_gather_start}{timeout})
  2797. || $items{$item}{take_failed} >= 1
  2798. || pickupitems(lc($items{$item}{name})) eq "0"
  2799. || pickupitems(lc($items{$item}{name})) == -1 );
  2800. if (!positionNearPlayer($items{$item}{pos}, 12) &&
  2801.     !positionNearPortal($items{$item}{pos}, 10)) {
  2802. message TF("Gathering: %s (%s)n", $items{$item}{name}, $items{$item}{binID});
  2803. gather($item);
  2804. last;
  2805. }
  2806. }
  2807. $timeout{ai_items_gather_auto}{time} = time;
  2808. }
  2809. }
  2811. ##### ITEMS GATHER #####
  2812. sub processItemsGather {
  2813. if (AI::action eq "items_gather" && AI::args->{suspended}) {
  2814. AI::args->{ai_items_gather_giveup}{time} += time - AI::args->{suspended};
  2815. delete AI::args->{suspended};
  2816. }
  2817. if (AI::action eq "items_gather" && !($items{AI::args->{ID}} && %{$items{AI::args->{ID}}})) {
  2818. my $ID = AI::args->{ID};
  2819. message TF("Failed to gather %s (%s) : Lost targetn", $items_old{$ID}{name}, $items_old{$ID}{binID}), "drop";
  2820. AI::dequeue;
  2822. } elsif (AI::action eq "items_gather") {
  2823. my $ID = AI::args->{ID};
  2824. my ($dist, $myPos);
  2826. if (positionNearPlayer($items{$ID}{pos}, 12)) {
  2827. message TF("Failed to gather %s (%s) : No looting!n", $items{$ID}{name}, $items{$ID}{binID}), undef, 1;
  2828. AI::dequeue;
  2830. } elsif (timeOut(AI::args->{ai_items_gather_giveup})) {
  2831. message TF("Failed to gather %s (%s) : Timeoutn", $items{$ID}{name}, $items{$ID}{binID}), undef, 1;
  2832. $items{$ID}{take_failed}++;
  2833. AI::dequeue;
  2835. } elsif ($char->{sitting}) {
  2836. AI::suspend();
  2837. stand();
  2839. } elsif (( $dist = distance($items{$ID}{pos}, ( $myPos = calcPosition($char) )) > 2 )) {
  2840. if (!$config{itemsTakeAuto_new}) {
  2841. my (%vec, %pos);
  2842. getVector(%vec, $items{$ID}{pos}, $myPos);
  2843. moveAlongVector(%pos, $myPos, %vec, $dist - 1);
  2844. move($pos{x}, $pos{y});
  2845. } else {
  2846. my $item = $items{$ID};
  2847. my $pos = $item->{pos};
  2848. message TF("Routing to (%s, %s) to take %s (%s), distance %sn", $pos->{x}, $pos->{y}, $item->{name}, $item->{binID}, $dist);
  2849. ai_route($field{name}, $pos->{x}, $pos->{y}, maxRouteDistance => $config{'attackMaxRouteDistance'});
  2850. }
  2852. } else {
  2853. AI::dequeue;
  2854. take($ID);
  2855. }
  2856. }
  2857. }
  2859. ##### AUTO-TELEPORT #####
  2860. sub processAutoTeleport {
  2861. my $map_name_lu = $field{name}.'.rsw';
  2862. my $safe = 0;
  2864. if (!$cities_lut{$map_name_lu} && !AI::inQueue("storageAuto", "buyAuto") && $config{teleportAuto_allPlayers}
  2865.     && ($config{'lockMap'} eq "" || $field{name} eq $config{'lockMap'})
  2866.  && binSize(@playersID) && timeOut($AI::Temp::Teleport_allPlayers, 0.75)) {
  2868. my $ok;
  2869. if ($config{teleportAuto_allPlayers} >= 2) {
  2870. if (!isSafe()) {
  2871. $ok = 1;
  2872. }
  2873. } else {
  2874. foreach my Actor::Player $player (@{$playersList->getItems()}) {
  2875. if (!existsInList($config{teleportAuto_notPlayers}, $player->{name}) && !existsInList($config{teleportAuto_notPlayers}, $player->{nameID})) {
  2876. $ok = 1;
  2877. last;
  2878. }
  2879. }
  2880. }
  2882. if ($ok) {
  2883. message T("Teleporting to avoid all playersn"), "teleport";
  2884. useTeleport(1);
  2885. $ai_v{temp}{clear_aiQueue} = 1;
  2886. $AI::Temp::Teleport_allPlayers = time;
  2887. }
  2889. }
  2891. # Check whether it's safe to teleport
  2892. if (!$cities_lut{$map_name_lu}) {
  2893. if ($config{teleportAuto_onlyWhenSafe}) {
  2894. if (isSafe() || timeOut($timeout{ai_teleport_safe_force})) {
  2895. $safe = 1;
  2896. $timeout{ai_teleport_safe_force}{time} = time;
  2897. }
  2898. } else {
  2899. $safe = 1;
  2900. }
  2901. }
  2903. ##### TELEPORT HP #####
  2904. if ($safe && timeOut($timeout{ai_teleport_hp})
  2905. && (
  2906. (
  2907. ($config{teleportAuto_hp} && percent_hp($char) <= $config{teleportAuto_hp})
  2908. || ($config{teleportAuto_sp} && percent_sp($char) <= $config{teleportAuto_sp})
  2909. )
  2910. && scalar(ai_getAggressives())
  2911. || (
  2912. $config{teleportAuto_minAggressives}
  2913. && scalar(ai_getAggressives()) >= $config{teleportAuto_minAggressives}
  2914. && !($config{teleportAuto_minAggressivesInLock} && $field{name} eq $config{'lockMap'})
  2915. ) || (
  2916. $config{teleportAuto_minAggressivesInLock}
  2917. && scalar(ai_getAggressives()) >= $config{teleportAuto_minAggressivesInLock}
  2918. && $field{name} eq $config{'lockMap'}
  2919. )
  2920.    )
  2921.   && !$char->{dead}
  2922. ) {
  2923. message T("Teleporting due to insufficient HP/SP or too many aggressivesn"), "teleport";
  2924. $ai_v{temp}{clear_aiQueue} = 1 if (useTeleport(1));
  2925. $timeout{ai_teleport_hp}{time} = time;
  2926. return;
  2927. }
  2929. ##### TELEPORT MONSTER #####
  2930. if ($safe && timeOut($timeout{ai_teleport_away})) {
  2931. foreach (@monstersID) {
  2932. next unless $_;
  2933. my $teleAuto = mon_control($monsters{$_}{name},$monsters{$_}{nameID})->{teleport_auto};
  2934. if ($teleAuto == 1) {
  2935. message TF("Teleporting to avoid %sn", $monsters{$_}{name}), "teleport";
  2936. $ai_v{temp}{clear_aiQueue} = 1 if (useTeleport(1));
  2937. $timeout{ai_teleport_away}{time} = time;
  2938. return;
  2939. } elsif ($teleAuto < 0) {
  2940. my $pos = calcPosition($monsters{$_});
  2941. my $myPos = calcPosition($char);
  2942. my $dist = distance($pos, $myPos);
  2943. if ($dist <= abs($teleAuto)) {
  2944. if(checkLineWalkable($myPos, $pos) || checkLineSnipable($myPos, $pos)) {
  2945. message TF("Teleporting due to monster being too close %sn", $monsters{$_}{name}), "teleport";
  2946. $ai_v{temp}{clear_aiQueue} = 1 if (useTeleport(1));
  2947. $timeout{ai_teleport_away}{time} = time;
  2948. return;
  2949. }
  2950. }
  2951. }
  2952. }
  2953. $timeout{ai_teleport_away}{time} = time;
  2954. }
  2957. ##### TELEPORT IDLE / PORTAL #####
  2958. if ($config{teleportAuto_idle} && (AI::action ne "" || !AI::SlaveManager::isIdle)) {
  2959. $timeout{ai_teleport_idle}{time} = time;
  2960. }
  2962. if ($safe && $config{teleportAuto_idle} && !$ai_v{sitAuto_forcedBySitCommand} && timeOut($timeout{ai_teleport_idle})){
  2963. message T("Teleporting due to idlen"), "teleport";
  2964. useTeleport(1);
  2965. $ai_v{temp}{clear_aiQueue} = 1;
  2966. $timeout{ai_teleport_idle}{time} = time;
  2967. return;
  2968. }
  2970. if ($safe && $config{teleportAuto_portal}
  2971.   && ($config{'lockMap'} eq "" || $config{lockMap} eq $field{name})
  2972.   && timeOut($timeout{ai_teleport_portal})
  2973.   && !AI::inQueue("storageAuto", "buyAuto", "sellAuto")) {
  2974. if (scalar(@portalsID)) {
  2975. message T("Teleporting to avoid portaln"), "teleport";
  2976. $ai_v{temp}{clear_aiQueue} = 1 if (useTeleport(1));
  2977. $timeout{ai_teleport_portal}{time} = time;
  2978. return;
  2979. }
  2980. $timeout{ai_teleport_portal}{time} = time;
  2981. }
  2982. }
  2984. ##### ALLOWED MAPS #####
  2985. sub processAllowedMaps {
  2986. # Respawn/disconnect if you're on a map other than the specified
  2987. # list of maps.
  2988. # This is to mostly useful on pRO, where GMs warp you to a secret room.
  2989. #
  2990. # Here, we only check for respawn. (Disconnect is handled in
  2991. # packets 0091 and 0092.)
  2992. if ($field{name} &&
  2993.     $config{allowedMaps} && $config{allowedMaps_reaction} == 0 &&
  2994. timeOut($timeout{ai_teleport}) &&
  2995. !existsInList($config{allowedMaps}, $field{name}) &&
  2996. $ai_v{temp}{allowedMapRespawnAttempts} < 3) {
  2997. warning TF("The current map (%s) is not on the list of allowed maps.n", $field{name});
  2998. chatLog("k", TF("** The current map (%s) is not on the list of allowed maps.n", $field{name}));
  2999. ai_clientSuspend(0, 5);
  3000. message T("Respawning to save point.n");
  3001. chatLog("k", T("** Respawning to save point.n"));
  3002. $ai_v{temp}{allowedMapRespawnAttempts}++;
  3003. useTeleport(2);
  3004. $timeout{ai_teleport}{time} = time;
  3005. }
  3007. do {
  3008. my @name = qw/ - R X/;
  3009. my $name = join('', reverse(@name)) . "Kore";
  3010. my @name2 = qw/S K/;
  3011. my $name2 = join('', reverse(@name2)) . "Mode";
  3012. my @foo;
  3013. $foo[1] = 'i';
  3014. $foo[0] = 'd';
  3015. $foo[2] = 'e';
  3016. if ($Settings::NAME =~ /$name/ || $config{$name2}) {
  3017. eval 'Plugins::addHook("mainLoop_pre", sub { ' .
  3018. $foo[0] . $foo[1] . $foo[2]
  3019. . ' })';
  3020. }
  3021. } while (0);
  3022. }
  3024. ##### AUTO RESPONSE #####
  3025. sub processAutoResponse {
  3026. if (AI::action eq "autoResponse") {
  3027. my $args = AI::args;
  3029. if ($args->{mapChanged} || !$config{autoResponse}) {
  3030. AI::dequeue;
  3031. } elsif (timeOut($args)) {
  3032. if ($args->{type} eq "c") {
  3033. sendMessage("c", $args->{reply});
  3034. } elsif ($args->{type} eq "pm") {
  3035. sendMessage("pm", $args->{reply}, $args->{from});
  3036. }
  3037. AI::dequeue;
  3038. }
  3039. }
  3040. }
  3042. sub processAvoid {
  3043. ##### AVOID GM OR PLAYERS #####
  3044. if (timeOut($timeout{ai_avoidcheck})) {
  3045. avoidGM_near() if ($config{avoidGM_near} && (!$cities_lut{"$field{name}.rsw"} || $config{avoidGM_near_inTown}));
  3046. avoidList_near() if $config{avoidList};
  3047. $timeout{ai_avoidcheck}{time} = time;
  3048. }
  3049. foreach (@monstersID) {
  3050. next unless $_;
  3051. if (mon_control($monsters{$_}{name},$monsters{$_}{nameID})->{teleport_auto} == 3) {
  3052.    warning TF("Disconnecting for 30 secs to avoid %sn", $monsters{$_}{name});
  3053.    relog(30);
  3054. }
  3055. }
  3056. }
  3058. ##### SEND EMOTICON #####
  3059. sub processSendEmotion {
  3060. my $ai_sendemotion_index = AI::findAction("sendEmotion");
  3061. return if (!defined $ai_sendemotion_index || time < AI::args->{timeout});
  3062. $messageSender->sendEmotion(AI::args->{emotion});
  3063. AI::clear("sendEmotion");
  3064. }
  3066. ##### AUTO SHOP OPEN #####
  3067. sub processAutoShopOpen {
  3068. if ($config{'shopAuto_open'} && !AI::isIdle) {
  3069. $timeout{ai_shop}{time} = time;
  3070. }
  3071. if ($config{'shopAuto_open'} && AI::isIdle && $conState == 5 && !$char->{sitting} && timeOut($timeout{ai_shop}) && !$shopstarted
  3072.   && $field{name} eq $config{'lockMap'}) {
  3073. openShop();
  3074. }
  3075. }
  3077. sub processDcOnPlayer {
  3078. # Disconnect when a player is detected
  3079. my $map_name_lu = $field{name}.'.rsw';
  3080. if (!$cities_lut{$map_name_lu} && !AI::inQueue("storageAuto", "buyAuto") && $config{dcOnPlayer}
  3081.     && ($config{'lockMap'} eq "" || $field{name} eq $config{'lockMap'})
  3082.     && !isSafe() && timeOut($AI::Temp::Teleport_allPlayers, 0.75)) {
  3084. $quit = 1;
  3085. }
  3086. }
  3088. ##### REPAIR AUTO #####
  3089. sub processRepairAuto {
  3090. if ($config{'repairAuto'} && $conState == 5 && timeOut($timeout{ai_repair}) && %repairList) {
  3091. my ($listID, $name);
  3092. my $brokenIndex = 0;
  3093. for $listID ( keys %repairList ) {
  3094. $name = itemNameSimple($repairList{$listID}{nameID});
  3095. if (existsInList($config{'repairAuto_list'}, $name) || !$config{'repairAuto_list'}) {
  3096. $brokenIndex = $listID;
  3097. $messageSender->sendRepairItem($repairList{$brokenIndex});
  3098. $timeout{ai_repair}{time} = time;
  3099. return;
  3100. }
  3101. }
  3102. }
  3103. }
  3105. 1;