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

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

外挂编程

开发平台：

Windows_Unix

AI.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. # Helper functions for managing @ai_seq.
  13. #
  14. # Eventually, @ai_seq should never be referenced directly, and then it can be
  15. # moved into this package.
  17. package AI;
  19. use strict;
  20. use Globals;
  21. use Utils qw(binFind);
  22. use Log qw(message warning error debug);
  23. use Utils;
  24. use Field;
  25. use Exporter;
  26. use base qw(Exporter);
  27. use Translation;
  29. our @EXPORT = (
  30. qw/
  31. ai_clientSuspend
  32. ai_drop
  33. ai_follow
  34. ai_partyfollow
  35. ai_getAggressives
  36. ai_getPlayerAggressives
  37. ai_getMonstersAttacking
  38. ai_getSkillUseType
  39. ai_mapRoute_searchStep
  40. ai_items_take
  41. ai_route
  42. ai_route_getRoute
  43. ai_sellAutoCheck
  44. ai_setMapChanged
  45. ai_setSuspend
  46. ai_skillUse
  47. ai_skillUse2
  48. ai_storageAutoCheck
  49. cartGet
  50. cartAdd
  51. ai_talkNPC
  52. attack
  53. gather
  54. move
  55. sit
  56. stand
  57. take/
  58. );
  60. sub action {
  61. my $i = (defined $_[0] ? $_[0] : 0);
  62. return $ai_seq[$i];
  63. }
  65. sub args {
  66. my $i = (defined $_[0] ? $_[0] : 0);
  67. return %{$ai_seq_args[$i]};
  68. }
  70. sub dequeue {
  71. shift @ai_seq;
  72. shift @ai_seq_args;
  73. }
  75. sub queue {
  76. unshift @ai_seq, shift;
  77. my $args = shift;
  78. unshift @ai_seq_args, ((defined $args) ? $args : {});
  79. }
  81. sub clear {
  82. if (@_) {
  83. my $changed;
  84. for (my $i = 0; $i < @ai_seq; $i++) {
  85. if (defined binFind(@_, $ai_seq[$i])) {
  86. delete $ai_seq[$i];
  87. delete $ai_seq_args[$i];
  88. $changed = 1;
  89. }
  90. }
  92. if ($changed) {
  93. my (@new_seq, @new_args);
  94. for (my $i = 0; $i < @ai_seq; $i++) {
  95. if (defined $ai_seq[$i]) {
  96. push @new_seq, $ai_seq[$i];
  97. push @new_args, $ai_seq_args[$i];
  98. }
  99. }
  100. @ai_seq = @new_seq;
  101. @ai_seq_args = @new_args;
  102. }
  104. } else {
  105. undef @ai_seq;
  106. undef @ai_seq_args;
  107. }
  108. }
  110. sub suspend {
  111. my $i = (defined $_[0] ? $_[0] : 0);
  112. $ai_seq_args[$i]{suspended} = time if $i < @ai_seq_args;
  113. }
  115. sub mapChanged {
  116. my $i = (defined $_[0] ? $_[0] : 0);
  117. $ai_seq_args[$i]{mapChanged} = time if $i < @ai_seq_args;
  118. }
  120. sub findAction {
  121. return binFind(@ai_seq, $_[0]);
  122. }
  124. sub inQueue {
  125. foreach (@_) {
  126. # Apparently using a loop is faster than calling
  127. # binFind() (which is optimized in C), because
  128. # of function call overhead.
  129. #return 1 if defined binFind(@ai_seq, $_);
  130. foreach my $seq (@ai_seq) {
  131. return 1 if ($_ eq $seq);
  132. }
  133. }
  134. return 0;
  135. }
  137. sub isIdle {
  138. return $ai_seq[0] eq "";
  139. }
  141. sub is {
  142. foreach (@_) {
  143. return 1 if ($ai_seq[0] eq $_);
  144. }
  145. return 0;
  146. }
  149. ##########################################
  152. ##
  153. # ai_clientSuspend(packet_switch, duration, args...)
  154. # initTimeout: a number of seconds.
  155. #
  156. # Freeze the AI for $duration seconds. $packet_switch and @args are only
  157. # used internally and are ignored unless XKore mode is turned on.
  158. sub ai_clientSuspend {
  159. my ($type, $duration, @args) = @_;
  160. my %args;
  161. $args{type} = $type;
  162. $args{time} = time;
  163. $args{timeout} = $duration;
  164. @{$args{args}} = @args;
  165. AI::queue("clientSuspend", %args);
  166. debug "AI suspended by clientSuspend for $args{timeout} secondsn";
  167. }
  169. ##
  170. # ai_drop(items, max)
  171. # items: reference to an array of inventory item numbers.
  172. # max: the maximum amount to drop, for each item, or 0 for unlimited.
  173. #
  174. # Drop one or more items.
  175. #
  176. # Example:
  177. # # Drop inventory items 2 and 5.
  178. # ai_drop([2, 5]);
  179. # # Drop inventory items 2 and 5, but at most 30 of each item.
  180. # ai_drop([2, 5], 30);
  181. sub ai_drop {
  182. my $r_items = shift;
  183. my $max = shift;
  184. my %seq = ();
  186. if (@{$r_items} == 1) {
  187. # Dropping one item; do it immediately
  188. Misc::drop($r_items->[0], $max);
  189. } else {
  190. # Dropping multiple items; queue an AI sequence
  191. $seq{items} = @{$r_items};
  192. $seq{max} = $max;
  193. $seq{timeout} = 1;
  194. AI::queue("drop", %seq);
  195. }
  196. }
  198. sub ai_follow {
  199. my $name = shift;
  201. return 0 if (!$name);
  203. if (binFind(@ai_seq, "follow") eq "") {
  204. my %args;
  205. $args{name} = $name;
  206. push @ai_seq, "follow";
  207. push @ai_seq_args, %args;
  208. }
  210. return 1;
  211. }
  213. sub ai_partyfollow {
  214. # we have to enable re-calc of route based on master's possition regulary, even when it is
  215. # on route and move, otherwise we have finaly moved to the possition and found that the master
  216. # already teleported to another side of the map.
  218. # This however will give problem on few seq such as storageAuto as 'move' and 'route' might
  219. # be triggered to move to the NPC
  221. my %master;
  222. $master{id} = main::findPartyUserID($config{followTarget});
  223. if ($master{id} ne "" && !AI::inQueue("storageAuto","storageGet","sellAuto","buyAuto")) {
  225. $master{x} = $char->{party}{users}{$master{id}}{pos}{x};
  226. $master{y} = $char->{party}{users}{$master{id}}{pos}{y};
  227. ($master{map}) = $char->{party}{users}{$master{id}}{map} =~ /([sS]*).gat/;
  229. if ($master{map} ne $field{name} || $master{x} == 0 || $master{y} == 0) {
  230. delete $master{x};
  231. delete $master{y};
  232. }
  234. return unless ($master{map} ne $field{name} || exists $master{x});
  236. if ((exists $ai_v{master} && distance(%master, $ai_v{master}) > 15)
  237. || $master{map} != $ai_v{master}{map}
  238. || (timeOut($ai_v{master}{time}, 15) && distance(%master, $char->{pos_to}) > $config{followDistanceMax})) {
  240. $ai_v{master}{x} = $master{x};
  241. $ai_v{master}{y} = $master{y};
  242. $ai_v{master}{map} = $master{map};
  243. $ai_v{master}{time} = time;
  245. if ($ai_v{master}{map} ne $field{name}) {
  246. message TF("Calculating route to find master: %sn", $ai_v{master}{map}), "follow";
  247. } elsif (distance(%master, $char->{pos_to}) > $config{followDistanceMax} ) {
  248. message TF("Calculating route to find master: %s (%s,%s)n", $ai_v{master}{map}, $ai_v{master}{x}, $ai_v{master}{y}), "follow";
  249. } else {
  250. return;
  251. }
  253. AI::clear("move", "route", "mapRoute");
  254. ai_route($ai_v{master}{map}, $ai_v{master}{x}, $ai_v{master}{y}, distFromGoal => $config{followDistanceMin});
  256. my $followIndex = AI::findAction("follow");
  257. if (defined $followIndex) {
  258. $ai_seq_args[$followIndex]{ai_follow_lost_end}{timeout} = $timeout{ai_follow_lost_end}{timeout};
  259. }
  260. }
  261. }
  262. }
  264. ##
  265. # ai_getAggressives([check_mon_control], [party])
  266. # Returns: an array of monster IDs, or a number.
  267. #
  268. # Get a list of all aggressive monsters on screen.
  269. # The definition of "aggressive" is: a monster who has hit or missed me.
  270. #
  271. # If $check_mon_control is set, then all monsters in mon_control.txt
  272. # with the 'attack_auto' flag set to 2, will be considered as aggressive.
  273. # See also the manual for more information about this.
  274. #
  275. # If $party is set, then monsters that have fought with party members
  276. # (not just you) will be considered as aggressive.
  277. sub ai_getAggressives {
  278. my ($type, $party) = @_;
  279. my $wantArray = wantarray;
  280. my $num = 0;
  281. my @agMonsters;
  283. foreach my $monster (@{$monstersList->getItems()}) {
  284. my $control = Misc::mon_control($monster->name,$monster->{nameID}) if $type || !$wantArray;
  285. my $ID = $monster->{ID};
  286. next if (!timeOut($monster->{attack_failedLOS}, 6));
  288. if (($type && ($control->{attack_auto} == 2)) ||
  289. (($monster->{dmgToYou} || $monster->{missedYou}) && Misc::checkMonsterCleanness($ID)) ||
  290. ($party && ($monster->{dmgToParty} || $monster->{missedToParty} || $monster->{dmgFromParty})) &&
  291. timeOut($monster->{attack_failed}, $timeout{ai_attack_unfail}{timeout}))
  292. {
  293. # Remove monsters that are considered forced agressive (when set to 2 on Mon_Control)
  294. # but has not yet been damaged or attacked by party AND currently has no LOS
  295. # if this is not done, Kore will keep trying infinitely attack targets set to aggro but who
  296. # has no Line of Sight (ex.: GH Cemitery when on a higher position seeing an aggro monster in lower levels).
  297. # The other parameters are re-checked along, so you can continue to attack a monster who has
  298. # already been hit but lost the line for some reason.
  299. # Also, check if the forced aggressive is a clean target when it has not marked as "yours".
  300. my $myPos = calcPosition($char);
  301. my $pos = calcPosition($monster);
  303. next if (($type && $control->{attack_auto} == 2)
  304. && (($config{'attackCanSnipe'}) ? !Misc::checkLineSnipable($myPos, $pos) : (!Misc::checkLineWalkable($myPos, $pos) || !Misc::checkLineSnipable($myPos, $pos)))
  305. && !$monster->{dmgToYou} && !$monster->{missedYou}
  306. && ($party && (!$monster->{dmgToParty} && !$monster->{missedToParty} && !$monster->{dmgFromParty}))
  307. );
  309. # Continuing, check whether the forced Agro is really a clean monster;
  310. next if (($type && $control->{attack_auto} == 2) && !Misc::checkMonsterCleanness($ID));
  312. if ($wantArray) {
  313. # Function is called in array context
  314. push @agMonsters, $ID;
  316. } else {
  317. # Function is called in scalar context
  318. if ($control->{weight} > 0) {
  319. $num += $control->{weight};
  320. } elsif ($control->{weight} != -1) {
  321. $num++;
  322. }
  323. }
  324. }
  325. }
  327. if ($wantArray) {
  328. return @agMonsters;
  329. } else {
  330. return $num;
  331. }
  332. }
  334. sub ai_getPlayerAggressives {
  335. my $ID = shift;
  336. my @agMonsters;
  338. foreach (@monstersID) {
  339. next if ($_ eq "");
  340. if ($monsters{$_}{dmgToPlayer}{$ID} > 0 || $monsters{$_}{missedToPlayer}{$ID} > 0 || $monsters{$_}{dmgFromPlayer}{$ID} > 0 || $monsters{$_}{missedFromPlayer}{$ID} > 0) {
  341. push @agMonsters, $_;
  342. }
  343. }
  344. return @agMonsters;
  345. }
  347. ##
  348. # ai_getMonstersAttacking($ID)
  349. #
  350. # Get the monsters who are attacking player $ID.
  351. sub ai_getMonstersAttacking {
  352. my $ID = shift;
  353. my @agMonsters;
  354. foreach (@monstersID) {
  355. next unless $_;
  356. my $monster = $monsters{$_};
  357. push @agMonsters, $_ if $monster->{target} eq $ID;
  358. }
  359. return @agMonsters;
  360. }
  362. ##
  363. # ai_getSkillUseType(name)
  364. # name: the internal name of the skill (as found in skills.txt), such as
  365. # WZ_FIREPILLAR.
  366. # Returns: 1 if it's a location skill, 0 if it's an object skill.
  367. #
  368. # Determines whether a skill is a skill that's casted on a location, or one
  369. # that's casted on an object (monster/player/etc).
  370. # For example, Firewall is a location skill, while Cold Bolt is an object
  371. # skill.
  372. sub ai_getSkillUseType {
  373. my $skill = shift;
  374. return 1 if $skillsArea{$skill} == 1;
  375. return 0;
  376. }
  378. sub ai_mapRoute_searchStep {
  379. my $r_args = shift;
  381. unless ($r_args->{openlist} && %{$r_args->{openlist}}) {
  382. $r_args->{done} = 1;
  383. $r_args->{found} = '';
  384. return 0;
  385. }
  387. my $parent = (sort {$$r_args{'openlist'}{$a}{'walk'} <=> $$r_args{'openlist'}{$b}{'walk'}} keys %{$$r_args{'openlist'}})[0];
  388. debug "$parent, $$r_args{'openlist'}{$parent}{'walk'}n", "route/path";
  389. # Uncomment this if you want minimum MAP count. Otherwise use the above for minimum step count
  390. #foreach my $parent (keys %{$$r_args{'openlist'}})
  391. {
  392. my ($portal,$dest) = split /=/, $parent;
  393. if ($$r_args{'budget'} ne '' && $$r_args{'openlist'}{$parent}{'zenny'} > $$r_args{'budget'}) {
  394. #This link is too expensive
  395. delete $$r_args{'openlist'}{$parent};
  396. next;
  397. } else {
  398. #MOVE this entry into the CLOSELIST
  399. $$r_args{'closelist'}{$parent}{'walk'}   = $$r_args{'openlist'}{$parent}{'walk'};
  400. $$r_args{'closelist'}{$parent}{'zenny'}  = $$r_args{'openlist'}{$parent}{'zenny'};
  401. $$r_args{'closelist'}{$parent}{'parent'} = $$r_args{'openlist'}{$parent}{'parent'};
  402. #Then delete in from OPENLIST
  403. delete $$r_args{'openlist'}{$parent};
  404. }
  406. if ($portals_lut{$portal}{'dest'}{$dest}{'map'} eq $$r_args{'dest'}{'map'}) {
  407. if ($$r_args{'dest'}{'pos'}{'x'} eq '' && $$r_args{'dest'}{'pos'}{'y'} eq '') {
  408. $$r_args{'found'} = $parent;
  409. $$r_args{'done'} = 1;
  410. undef @{$$r_args{'mapSolution'}};
  411. my $this = $$r_args{'found'};
  412. while ($this) {
  413. my %arg;
  414. $arg{'portal'} = $this;
  415. my ($from,$to) = split /=/, $this;
  416. ($arg{'map'},$arg{'pos'}{'x'},$arg{'pos'}{'y'}) = split / /,$from;
  417. ($arg{dest_map}, $arg{dest_pos}{x}, $arg{dest_pos}{y}) = split(' ', $to);
  418. $arg{'walk'} = $$r_args{'closelist'}{$this}{'walk'};
  419. $arg{'zenny'} = $$r_args{'closelist'}{$this}{'zenny'};
  420. $arg{'steps'} = $portals_lut{$from}{'dest'}{$to}{'steps'};
  421. unshift @{$$r_args{'mapSolution'}},%arg;
  422. $this = $$r_args{'closelist'}{$this}{'parent'};
  423. }
  424. return;
  425. } elsif ( ai_route_getRoute(@{$$r_args{'solution'}}, $$r_args{'dest'}{'field'}, $portals_lut{$portal}{'dest'}{$dest}, $$r_args{'dest'}{'pos'}) ) {
  426. my $walk = "$$r_args{'dest'}{'map'} $$r_args{'dest'}{'pos'}{'x'} $$r_args{'dest'}{'pos'}{'y'}=$$r_args{'dest'}{'map'} $$r_args{'dest'}{'pos'}{'x'} $$r_args{'dest'}{'pos'}{'y'}";
  427. $$r_args{'closelist'}{$walk}{'walk'} = scalar @{$$r_args{'solution'}} + $$r_args{'closelist'}{$parent}{$dest}{'walk'};
  428. $$r_args{'closelist'}{$walk}{'parent'} = $parent;
  429. $$r_args{'closelist'}{$walk}{'zenny'} = $$r_args{'closelist'}{$parent}{'zenny'};
  430. $$r_args{'found'} = $walk;
  431. $$r_args{'done'} = 1;
  432. undef @{$$r_args{'mapSolution'}};
  433. my $this = $$r_args{'found'};
  434. while ($this) {
  435. my %arg;
  436. $arg{'portal'} = $this;
  437. my ($from,$to) = split /=/, $this;
  438. ($arg{'map'},$arg{'pos'}{'x'},$arg{'pos'}{'y'}) = split / /,$from;
  439. $arg{'walk'} = $$r_args{'closelist'}{$this}{'walk'};
  440. $arg{'zenny'} = $$r_args{'closelist'}{$this}{'zenny'};
  441. $arg{'steps'} = $portals_lut{$from}{'dest'}{$to}{'steps'};
  442. unshift @{$$r_args{'mapSolution'}},%arg;
  443. $this = $$r_args{'closelist'}{$this}{'parent'};
  444. }
  445. return;
  446. }
  447. }
  448. #get all children of each openlist
  449. foreach my $child (keys %{$portals_los{$dest}}) {
  450. next unless $portals_los{$dest}{$child};
  451. foreach my $subchild (keys %{$portals_lut{$child}{'dest'}}) {
  452. my $destID = $subchild;
  453. my $mapName = $portals_lut{$child}{'source'}{'map'};
  454. #############################################################
  455. my $penalty = int($routeWeights{lc($mapName)}) + int(($portals_lut{$child}{'dest'}{$subchild}{'steps'} ne '') ? $routeWeights{'NPC'} : $routeWeights{'PORTAL'});
  456. my $thisWalk = $penalty + $$r_args{'closelist'}{$parent}{'walk'} + $portals_los{$dest}{$child};
  457. if (!exists $$r_args{'closelist'}{"$child=$subchild"}) {
  458. if ( !exists $$r_args{'openlist'}{"$child=$subchild"} || $$r_args{'openlist'}{"$child=$subchild"}{'walk'} > $thisWalk ) {
  459. $$r_args{'openlist'}{"$child=$subchild"}{'parent'} = $parent;
  460. $$r_args{'openlist'}{"$child=$subchild"}{'walk'} = $thisWalk;
  461. $$r_args{'openlist'}{"$child=$subchild"}{'zenny'} = $$r_args{'closelist'}{$parent}{'zenny'} + $portals_lut{$child}{'dest'}{$subchild}{'cost'};
  462. }
  463. }
  464. }
  465. }
  466. }
  467. }
  469. sub ai_items_take {
  470. my ($x1, $y1, $x2, $y2) = @_;
  471. my %args;
  472. $args{pos}{x} = $x1;
  473. $args{pos}{y} = $y1;
  474. $args{pos_to}{x} = $x2;
  475. $args{pos_to}{y} = $y2;
  476. $args{ai_items_take_end}{time} = time;
  477. $args{ai_items_take_end}{timeout} = $timeout{ai_items_take_end}{timeout};
  478. $args{ai_items_take_start}{time} = time;
  479. $args{ai_items_take_start}{timeout} = $timeout{ai_items_take_start}{timeout};
  480. $args{ai_items_take_delay}{timeout} = $timeout{ai_items_take_delay}{timeout};
  481. AI::queue("items_take", %args);
  482. }
  484. sub ai_route {
  485. my $map = shift;
  486. my $x = shift;
  487. my $y = shift;
  488. my %args = @_;
  489. debug "On route to: $maps_lut{$map.'.rsw'}($map): $x, $yn", "route";
  491. # I can't use 'use' because of circular dependencies.
  492. require Task::Route;
  493. require Task::MapRoute;
  495. my $task;
  496. my @params = (
  497. x => $x,
  498. y => $y,
  499. maxDistance => $args{maxRouteDistance},
  500. maxTime => $args{maxRouteTime},
  501. distFromGoal => $args{distFromGoal},
  502. pyDistFromGoal => $args{pyDistFromGoal},
  503. avoidWalls => !$args{noAvoidWalls},
  504. notifyUponArrival => $args{notifyUponArrival}
  505. );
  506. if ($args{noMapRoute}) {
  507. $task = new Task::Route(@params);
  508. } else {
  509. $task = new Task::MapRoute(map => $map, @params);
  510. }
  511. $task->{attackID} = $args{attackID};
  512. $task->{attackOnRoute} = $args{attackOnRoute};
  513. $task->{noSitAuto} = $args{noSitAuto};
  514. $task->{LOSSubRoute} = $args{LOSSubRoute};
  516. AI::queue("route", $task);
  517. }
  519. #sellAuto for items_control - chobit andy 20030210
  520. sub ai_sellAutoCheck {
  521. foreach my $item (@{$char->inventory->getItems()}) {
  522. next if ($item->{equipped});
  523. my $control = Misc::items_control($item->{name});
  524. if ($control->{sell} && $item->{amount} > $control->{keep}) {
  525. return 1;
  526. }
  527. }
  528. }
  530. sub ai_setMapChanged {
  531. my $index = shift;
  532. $index = 0 if ($index eq "");
  533. if ($index < @ai_seq_args) {
  534. $ai_seq_args[$index]{'mapChanged'} = time;
  535. }
  536. }
  538. sub ai_setSuspend {
  539. my $index = shift;
  540. $index = 0 if ($index eq "");
  541. if ($index < @ai_seq_args) {
  542. $ai_seq_args[$index]{'suspended'} = time;
  543. }
  544. }
  546. sub ai_skillUse {
  547. return if ($char->{muted});
  548. my %args = (
  549. skillHandle => shift,
  550. lv => shift,
  551. maxCastTime => { time => time, timeout => shift },
  552. minCastTime => { time => time, timeout => shift },
  553. target => shift,
  554. y => shift,
  555. tag => shift,
  556. ret => shift,
  557. waitBeforeUse => { time => time, timeout => shift },
  558. prefix => shift
  559. );
  560. $args{giveup}{time} = time;
  561. $args{giveup}{timeout} = $timeout{ai_skill_use_giveup}{timeout};
  563. if ($args{y} ne "") {
  564. $args{x} = $args{target};
  565. delete $args{target};
  566. }
  567. AI::queue("skill_use", %args);
  568. }
  570. ##
  571. # ai_skillUse2($skill, $lvl, $maxCastTime, $minCastTime, $target)
  572. #
  573. # Calls ai_skillUse(), resolving $target to ($x, $y) if $skillID is an
  574. # area skill.
  575. #
  576. # FIXME: All code of the following structure:
  577. #
  578. # if (!ai_getSkillUseType(...)) {
  579. #     ai_skillUse(..., $ID);
  580. # } else {
  581. #     ai_skillUse(..., $x, $y);
  582. # }
  583. #
  584. # should be converted to use this helper function. Note that this
  585. # function uses objects instead of IDs for the skill and target.
  586. sub ai_skillUse2 {
  587. my ($skill, $lvl, $maxCastTime, $minCastTime, $target, $prefix) = @_;
  589. if (!ai_getSkillUseType($skill->getHandle())) {
  590. ai_skillUse($skill->getHandle(), $lvl, $maxCastTime, $minCastTime, $target->{ID}, undef, undef, undef, undef, $prefix);
  591. } else {
  592. ai_skillUse($skill->getHandle(), $lvl, $maxCastTime, $minCastTime, $target->{pos_to}{x}, $target->{pos_to}{y}, undef, undef, undef, $prefix);
  593. }
  594. }
  596. ##
  597. # ai_storageAutoCheck()
  598. #
  599. # Returns 1 if it is time to perform storageAuto sequence.
  600. # Returns 0 otherwise.
  601. sub ai_storageAutoCheck {
  602. return 0 if ($char->getSkillLevel(new Skill(handle => 'NV_BASIC')) < 6);
  603. if ($config{minStorageZeny}) {
  604. return 0 if ($char->{zenny} < $config{minStorageZeny});
  605. }
  606. foreach my $item (@{$char->inventory->getItems()}) {
  607. next if ($item->{equipped});
  608. my $control = Misc::items_control($item->{name});
  609. if ($control->{storage} && $item->{amount} > $control->{keep}) {
  610. return 1;
  611. }
  612. }
  613. return 0;
  614. }
  617. ##
  618. # cartGet(items)
  619. # items: a reference to an array of indices.
  620. #
  621. # Get one or more items from cart.
  622. # @items is a list of hashes; each has must have an "index" key, and may optionally have an "amount" key.
  623. # "index" is the index of the cart inventory item number. If "amount" is given, only the given amount of
  624. # items will retrieved from cart.
  625. #
  626. # Example:
  627. # # You want to get 5 Apples (inventory item 2) and all
  628. # # Fly Wings (inventory item 5) from cart.
  629. # my @items;
  630. # push @items, {index => 2, amount => 5};
  631. # push @items, {index => 5};
  632. # cartGet(@items);
  633. sub cartGet {
  634. my $items = shift;
  635. return unless ($items && @{$items});
  637. my %args;
  638. $args{items} = $items;
  639. $args{timeout} = $timeout{ai_cartAuto} ? $timeout{ai_cartAuto}{timeout} : 0.15;
  640. AI::queue("cartGet", %args);
  641. }
  643. ##
  644. # cartAdd(items)
  645. # items: a reference to an array of hashes.
  646. #
  647. # Put one or more items in cart.
  648. # @items is a list of hashes; each has must have an "index" key, and may optionally have an "amount" key.
  649. # "index" is the index of the inventory item number. If "amount" is given, only the given amount of items will be put in cart.
  650. #
  651. # Example:
  652. # # You want to add 5 Apples (inventory item 2) and all
  653. # # Fly Wings (inventory item 5) to cart.
  654. # my @items;
  655. # push @items, {index => 2, amount => 5};
  656. # push @items, {index => 5};
  657. # cartAdd(@items);
  658. sub cartAdd {
  659. my $items = shift;
  660. return unless ($items && @{$items});
  662. my %args;
  663. $args{items} = $items;
  664. $args{timeout} = $timeout{ai_cartAuto} ? $timeout{ai_cartAuto}{timeout} : 0.15;
  665. AI::queue("cartAdd", %args);
  666. }
  668. ##
  669. # ai_talkNPC(x, y, sequence)
  670. # x, y: the position of the NPC to talk to.
  671. # sequence: A string containing the NPC talk sequences.
  672. #
  673. # Talks to an NPC. You can specify an NPC position, or an NPC ID.
  674. #
  675. # $sequence is a list of whitespace-separated commands:
  676. # ~l
  677. # c       : Continue
  678. # r#      : Select option # from menu.
  679. # n       : Stop talking to NPC.
  680. # b       : Send the "Show shop item list" (Buy) packet.
  681. # w#      : Wait # seconds.
  682. # x       : Initialize conversation with NPC. Useful to perform multiple transaction with a single NPC.
  683. # t="str" : send the text str to NPC, double quote is needed only if the string contains space
  684. # ~l~
  685. #
  686. # Example:
  687. # # Sends "Continue", "Select option 0" to the NPC at (102, 300)
  688. # ai_talkNPC(102, 300, "c r0");
  689. sub ai_talkNPC {
  690. my %args;
  691. $args{'pos'}{'x'} = shift;
  692. $args{'pos'}{'y'} = shift;
  693. $args{'sequence'} = shift;
  694. $args{'sequence'} =~ s/^ +| +$//g;
  695. AI::queue("NPC", %args);
  696. }
  698. sub attack {
  699. my $ID = shift;
  700. my %args;
  702. my $target = Actor::get($ID);
  704. return if (!$target->{'pos_to'} || ! $target->{'pos'});
  706. $args{'ai_attack_giveup'}{'time'} = time;
  707. $args{'ai_attack_giveup'}{'timeout'} = $timeout{'ai_attack_giveup'}{'timeout'};
  708. $args{'ID'} = $ID;
  709. $args{'unstuck'}{'timeout'} = ($timeout{'ai_attack_unstuck'}{'timeout'} || 1.5);
  710. %{$args{'pos_to'}} = %{$target->{'pos_to'}};
  711. %{$args{'pos'}} = %{$target->{'pos'}};
  712. AI::queue("attack", %args);
  714. message TF("Attacking: %sn", $target);
  716. $startedattack = 1;
  718. Plugins::callHook('attack_start', {ID => $ID});
  720. #Mod Start
  721. AUTOEQUIP: {
  722. last AUTOEQUIP if (UNIVERSAL::isa($target, 'Actor::Player'));
  725. my $i = 0;
  726. my $Lequip = 0;
  727. my $Runeq =0;
  728. my (%eq_list,$Req,$Leq,$arrow,$j);
  729. while (exists $config{"autoSwitch_$i"}) {
  730. if (!$config{"autoSwitch_$i"}) {
  731. $i++;
  732. next;
  733. }
  735. if (existsInList($config{"autoSwitch_$i"}, $monsters{$ID}{'name'})) {
  736. message TF("Encounter Monster : %sn", $monsters{$ID}{'name'});
  737. if ($config{"autoSwitch_$i"."_rightHand"}) {
  739. if ($config{"autoSwitch_$i"."_rightHand"} eq "[NONE]" && $char->{equipment}{'rightHand'}) {
  740. $Runeq = 1;
  741. message TF("Auto UnEquiping [R]: %sn", $config{"autoSwitch_$i"."_rightHand"}), "equip";
  742. $char->{equipment}{'rightHand'}->unequip();
  743. }
  744. $Req = $char->inventory->getByName($config{"autoSwitch_${i}_rightHand"});
  745. if ($Req && !$Req->{equipped}){
  746. message TF("Auto Equiping [R]: %sn", $config{"autoSwitch_$i"."_rightHand"}), "equip";
  747. %eq_list = (rightHand => $Req->{invIndex});
  748. }
  750. }
  752. if ($config{"autoSwitch_${i}_leftHand"}) {
  753. if ($config{"autoSwitch_${i}_leftHand"} eq "[NONE]" && $char->{equipment}{leftHand}) {
  754. if (!($Runeq && $char->{equipment}{rightHand} == $char->{equipment}{leftHand})) {
  755. message TF("Auto UnEquiping [L]: %sn", $config{"autoSwitch_${i}_rightHand"}), "equip";
  756. $char->{equipment}{leftHand}->unequip();
  757. }
  758. }
  759. $Leq = $char->inventory->getByName($config{"autoSwitch_${i}_leftHand"});
  760. if ($Leq && !$Leq->{equipped}) {
  761. if ($Req == $Leq) {
  762. undef $Leq;
  763. foreach my $item (@{$char->inventory->getItems()}) {
  764. if ($item->{name} eq $config{"autoSwitch_${i}_leftHand"} && $item != $Req) {
  765. $Leq = $item;
  766. last;
  767. }
  768. }
  769. }
  771. if ($Leq) {
  772. message TF("Auto Equiping [L]: %s (%s)n", $config{"autoSwitch_$i"."_leftHand"}, $Leq), "equip";
  773. $eq_list{leftHand} = $Leq->{invIndex};
  774. }
  775. }
  776. }
  777. if (%eq_list) {
  778. Actor::Item::bulkEquip(%eq_list);
  779. }
  781. $arrow = $char->inventory->getByName($config{"autoSwitch_${i}_arrow"}) if ($config{"autoSwitch_${i}_arrow"});
  782. if ($arrow && !$arrow->{equipped}) {
  783. message TF("Auto Equiping [A]: %sn", $config{"autoSwitch_$i"."_arrow"}), "equip";
  784. $arrow->equip();
  785. }
  786. if ($config{"autoSwitch_$i"."_distance"} && $config{"autoSwitch_$i"."_distance"} != $config{'attackDistance'}) {
  787. $ai_v{'attackDistance'} = $config{'attackDistance'};
  788. $config{'attackDistance'} = $config{"autoSwitch_$i"."_distance"};
  789. message TF("Change Attack Distance to : %sn", $config{'attackDistance'}), "equip";
  790. }
  791. if ($config{"autoSwitch_$i"."_useWeapon"} ne "") {
  792. $ai_v{'attackUseWeapon'} = $config{'attackUseWeapon'};
  793. $config{'attackUseWeapon'} = $config{"autoSwitch_$i"."_useWeapon"};
  794. message TF("Change Attack useWeapon to : %sn", $config{'attackUseWeapon'}), "equip";
  795. }
  796. last AUTOEQUIP;
  797. }
  798. $i++;
  799. }
  802. undef $Leq;
  803. undef $Req;
  805. if ($config{"autoSwitch_default_rightHand"}) {
  807. if ($config{"autoSwitch_default_rightHand"} eq "[NONE]" && $char->{equipment}{'rightHand'}) {
  808. $Runeq = 1;
  809. message TF("Auto UnEquiping [R]: %sn", $config{"autoSwitch_default_rightHand"}), "equip";
  810. $char->{equipment}{'rightHand'}->unequip();
  811. }
  812. $Req = $char->inventory->getByName($config{"autoSwitch_default_rightHand"});
  813. if ($Req && !$Req->{equipped}){
  814. message TF("Auto Equiping [R]: %sn", $config{"autoSwitch_default_rightHand"}), "equip";
  815. %eq_list = (rightHand => $Req->{invIndex});
  816. }
  818. }
  820. if ($config{"autoSwitch_default_leftHand"}) {
  821. if ($config{"autoSwitch_default_leftHand"} eq "[NONE]" && $char->{equipment}{'leftHand'}) {
  822. if (!($Runeq && $char->{equipment}{'rightHand'} == $char->{equipment}{'leftHand'})) {
  823. message TF("Auto UnEquiping [L]: %sn", $config{"autoSwitch_default_leftHand"}), "equip";
  824. $char->{equipment}{'leftHand'}->unequip();
  825. }
  826. }
  827. $Leq = $char->inventory->getByName($config{"autoSwitch_default_leftHand"});
  829. if ($Leq && !$Leq->{equipped}) {
  830. if ($Req == $Leq) {
  831. undef $Leq;
  832. foreach my $item (@{$char->inventory->getItems()}) {
  833. if ($item->{name} eq $config{"autoSwitch_default_leftHand"} && $item != $Req) {
  834. $Leq = $item;
  835. last;
  836. }
  837. }
  838. }
  840. if ($Leq) {
  841. message TF("Auto Equiping [L]: %sn", $config{"autoSwitch_default_leftHand"}), "equip";
  842. $eq_list{leftHand} = $Leq->{invIndex};
  843. }
  844. }
  845. }
  846. if (%eq_list) {
  847. Actor::Item::bulkEquip(%eq_list);
  848. }
  851. if ($config{'autoSwitch_default_arrow'}) {
  852. $arrow = $char->inventory->getByName($config{"autoSwitch_default_arrow"});
  853. if ($arrow && !$arrow->{equipped}) {
  854. message TF("Auto equiping default [A]: %sn", $config{'autoSwitch_default_arrow'}), "equip";
  855. $arrow->equip();
  856. }
  857. }
  858. if ($ai_v{'attackDistance'} && $config{'attackDistance'} != $ai_v{'attackDistance'}) {
  859. $config{'attackDistance'} = $ai_v{'attackDistance'};
  860. message TF("Change Attack Distance to Default : %sn", $config{'attackDistance'}), "equip";
  861. }
  862. if ($ai_v{'attackUseWeapon'} ne "" && $config{'attackUseWeapon'} != $ai_v{'attackUseWeapon'}) {
  863. $config{'attackUseWeapon'} = $ai_v{'attackUseWeapon'};
  864. message TF("Change Attack useWeapon to default : %sn", $config{'attackUseWeapon'}), "equip";
  865. }
  866. } #END OF BLOCK AUTOEQUIP
  867. }
  869. sub gather {
  870. my $ID = shift;
  871. my %args;
  872. $args{ai_items_gather_giveup}{time} = time;
  873. $args{ai_items_gather_giveup}{timeout} = $timeout{ai_items_gather_giveup}{timeout};
  874. $args{ID} = $ID;
  875. $args{pos} = { %{$items{$ID}{pos}} };
  876. AI::queue("items_gather", %args);
  877. debug "Targeting for Gather: $items{$ID}{name} ($items{$ID}{binID})n";
  878. }
  880. sub move {
  881. my $x = shift;
  882. my $y = shift;
  883. my $attackID = shift;
  884. my %args;
  885. my $dist;
  886. $args{move_to}{x} = $x;
  887. $args{move_to}{y} = $y;
  888. $args{attackID} = $attackID;
  889. $args{time_move} = $char->{time_move};
  890. $dist = distance($char->{pos}, $args{move_to});
  891. $args{ai_move_giveup}{timeout} = $timeout{ai_move_giveup}{timeout};
  893. if ($x == 0 && $y == 0) {
  894. # die "BUG: move(0, 0) called!n";
  895. error "BUG: move(0, 0) called!n";
  896. return;
  897. }
  898. debug sprintf("Sending move from (%d,%d) to (%d,%d) - distance %.2fn",
  899. $char->{pos}{x}, $char->{pos}{y}, $x, $y, $dist), "ai_move";
  900. AI::queue("move", %args);
  901. }
  903. sub sit {
  904. require Task::SitStand;
  905. my $task = new Task::SitStand(mode => 'sit', wait => $timeout{ai_sit_wait}{timeout});
  906. AI::queue("sitting", $task);
  907. if (defined $config{sitAuto_look} && !$config{sitAuto_look_from_wall}) {
  908. Misc::look($config{sitAuto_look});
  909. } elsif (defined $config{sitAuto_look} && $config{sitAuto_look_from_wall}) {
  910. my $sitAutoLook = $config{sitAuto_look};
  911. my $wallRange = $config{sitAuto_look_from_wall};
  912. for (my $i=1;$i<=$wallRange;$i++) {
  913. if ((!$field->isWalkable($char->{pos}{x},$char->{pos}{y}+$wallRange) && $sitAutoLook == 0)
  914.   || (!$field->isWalkable($char->{pos}{x}-$wallRange,$char->{pos}{y}+$wallRange) && $sitAutoLook == 1)
  915.   || (!$field->isWalkable($char->{pos}{x}-$wallRange,$char->{pos}{y}) && $sitAutoLook == 2)
  916.   || (!$field->isWalkable($char->{pos}{x}-$wallRange,$char->{pos}{y}-$wallRange) && $sitAutoLook == 3)
  917.   ) {
  918. $sitAutoLook += 4;
  919. } elsif ((!$field->isWalkable($char->{pos}{x},$char->{pos}{y}-$wallRange) && $sitAutoLook == 4)
  920.   || (!$field->isWalkable($char->{pos}{x}+$wallRange,$char->{pos}{y}-$wallRange) && $sitAutoLook == 5)
  921.   || (!$field->isWalkable($char->{pos}{x}+$wallRange,$char->{pos}{y}) && $sitAutoLook == 6)
  922.   || (!$field->isWalkable($char->{pos}{x}+$wallRange,$char->{pos}{y}+$wallRange) && $sitAutoLook == 7)
  923.   ) {
  924. $sitAutoLook -= 4;
  925. }
  926. }
  927. Misc::look($sitAutoLook);
  928. }
  929. }
  931. sub stand {
  932. require Task::SitStand;
  933. my $task = new Task::SitStand(mode => 'stand', wait => $timeout{ai_stand_wait}{timeout});
  934. AI::queue("standing", $task);
  935. }
  937. sub take {
  938. my $ID = shift;
  939. my %args;
  940. return if (!$items{$ID});
  941. $args{ai_take_giveup}{time} = time;
  942. $args{ai_take_giveup}{timeout} = $timeout{ai_take_giveup}{timeout};
  943. $args{ID} = $ID;
  944. $args{pos} = {%{$items{$ID}{pos}}};
  945. AI::queue("take", %args);
  946. debug "Picking up: $items{$ID}{name} ($items{$ID}{binID})n";
  947. }
  949. return 1;