#########################################################################
# OpenKore - Attack AI
# Copyright (c) 2006 OpenKore Team
#
# This software is open source, licensed under the GNU General Public
# License, version 2.
# Basically, this means that you're allowed to modify and distribute
# this software. However, if you distribute modified versions, you MUST
# also distribute the source code.
# See http://www.gnu.org/licenses/gpl.html for the full license.
#
# $Revision: 4286 $
# $Id: Commands.pm 4286 2006-04-17 14:02:27Z illusion_kore $
#
#########################################################################
#
# This module contains the attack AI's code.
package AI::Attack;
use strict;
use Carp::Assert;
use Time::HiRes qw(time);
use Globals;
use AI;
use Actor;
use Field;
use Log qw(message debug warning);
use Translation qw(T TF);
use Network::Send ();
use Skill;
use Misc;
use Utils;
use Utils::Benchmark;
use Utils::PathFinding;
sub process {
Benchmark::begin("ai_attack") if DEBUG;
my $args = AI::args;
if (AI::action eq "attack" && AI::args->{suspended}) {
$args->{ai_attack_giveup}{time} += time - $args->{suspended};
delete $args->{suspended};
}
if (AI::action eq "attack" && $args->{move_start}) {
# We've just finished moving to the monster.
# Don't count the time we spent on moving
$args->{ai_attack_giveup}{time} += time - $args->{move_start};
undef $args->{unstuck}{time};
undef $args->{move_start};
} elsif (AI::action eq "attack" && $args->{avoiding} && $args->{attackID}) {
my $target = Actor::get($args->{attackID});
$args->{ai_attack_giveup}{time} = time + $target->{time_move_calc} + 3;
undef $args->{avoiding};
} elsif (((AI::action eq "route" && AI::action(1) eq "attack") || (AI::action eq "move" && AI::action(2) eq "attack"))
&& $args->{attackID} && timeOut($AI::Temp::attack_route_adjust, 1)) {
# We're on route to the monster; check whether the monster has moved
my $ID = $args->{attackID};
my $attackSeq = (AI::action eq "route") ? AI::args(1) : AI::args(2);
my $target = Actor::get($ID);
if ($target->{type} ne 'Unknown' && $attackSeq->{monsterPos} && %{$attackSeq->{monsterPos}}
&& round(distance(calcPosition($target), $attackSeq->{monsterPos})) > $attackSeq->{attackMethod}{maxDistance}) {
# Monster has moved; stop moving and let the attack AI readjust route
AI::dequeue;
AI::dequeue if (AI::action eq "route");
$attackSeq->{ai_attack_giveup}{time} = time;
debug "Target has moved more than $attackSeq->{attackMethod}{maxDistance} blocks; readjusting route\n", "ai_attack";
} elsif ($target->{type} ne 'Unknown' && $attackSeq->{monsterPos} && %{$attackSeq->{monsterPos}}
&& round(distance(calcPosition($target), calcPosition($char))) <= $attackSeq->{attackMethod}{maxDistance}) {
# Monster is within attack range; stop moving
AI::dequeue;
AI::dequeue if (AI::action eq "route");
$attackSeq->{ai_attack_giveup}{time} = time;
debug "Target at ($attackSeq->{monsterPos}{x},$attackSeq->{monsterPos}{y}) is now within " .
"$attackSeq->{attackMethod}{maxDistance} blocks; stop moving\n", "ai_attack";
}
$AI::Temp::attack_route_adjust = time;
}
if (AI::action eq "attack") {
my $ID = $args->{ID};
if (targetGone()) {
finishAttacking();
} elsif (shouldGiveUp()) {
giveUp();
} else {
if (timeOut($args->{attackMainTimeout}, 0.1)) {
$args->{attackMainTimeout} = time;
main();
}
}
}
# Check for kill steal and mob-training while moving
if ((AI::is("move", "route") && $args->{attackID} && AI::inQueue("attack")
&& timeOut($args->{movingWhileAttackingTimeout}, 0.2))) {
my $ID = AI::args->{attackID};
my $monster = $monsters{$ID};
# Check for kill steal while moving
#if ($monster && !Misc::checkMonsterCleanness($ID)) {
#message T("Dropping target - you will not kill steal others\n");
#stopAttack();
#$monster->{ignore} = 1;
# Right now, the queue is either
# move, route, attack
# -or-
# route, attack
#AI::dequeue;
#AI::dequeue;
#AI::dequeue if (AI::action eq "attack");
#if ($config{teleportAuto_dropTargetKS}) {
# message T("Teleport due to dropping attack target\n");
# useTeleport(1);
#}
#}
# Mob-training, stop attacking the monster if it is already aggressive
if ((my $control = mon_control($monster->{name},$monster->{nameID}))) {
if ($control->{attack_auto} == 3
&& ($monster->{dmgToYou} || $monster->{missedYou} || $monster->{dmgFromYou})) {
message TF("Dropping target - %s (%s) has been provoked\n", $monster->{name}, $monster->{binID});
stopAttack();
$monster->{ignore} = 1;
# Right now, the queue is either
# move, route, attack
# -or-
# route, attack
AI::dequeue;
AI::dequeue;
AI::dequeue if (AI::action eq "attack");
}
}
$args->{movingWhileAttackingTimeout} = time;
}
Benchmark::end("ai_attack") if DEBUG;
}
sub shouldGiveUp {
my $args = AI::args;
return !$config{attackNoGiveup} && (timeOut($args->{ai_attack_giveup}) || $args->{unstuck}{count} > 5);
}
sub giveUp {
my $ID = AI::args->{ID};
my $target = Actor::get($ID);
$target->{attack_failed} = time if ($monsters{$ID});
AI::dequeue;
message T("Can't reach or damage target, dropping target\n"), "ai_attack";
if ($config{'teleportAuto_dropTarget'}) {
message T("Teleport due to dropping attack target\n");
useTeleport(1);
}
}
sub targetGone {
my $args = AI::args;
return !$monsters{$args->{ID}} && (!$players{$args->{ID}} || $players{$args->{ID}}{dead});
}
sub finishAttacking {
my $args = AI::args;
$timeout{'ai_attack'}{'time'} -= $timeout{'ai_attack'}{'timeout'};
my $ID = $args->{ID};
AI::dequeue;
if ($monsters_old{$ID} && $monsters_old{$ID}{dead}) {
message T("Target died\n"), "ai_attack";
Plugins::callHook("target_died");
monKilled();
# Pickup loot when monster's dead
if ($AI == 2 && $config{'itemsTakeAuto'} && $monsters_old{$ID}{dmgFromYou} > 0 && !$monsters_old{$ID}{ignore}) {
AI::clear("items_take");
ai_items_take($monsters_old{$ID}{pos}{x}, $monsters_old{$ID}{pos}{y},
$monsters_old{$ID}{pos_to}{x}, $monsters_old{$ID}{pos_to}{y});
} else {
# Cheap way to suspend all movement to make it look real
ai_clientSuspend(0, $timeout{'ai_attack_waitAfterKill'}{'timeout'});
}
## kokal start
## mosters counting
my $i = 0;
my $found = 0;
while ($monsters_Killed[$i]) {
if ($monsters_Killed[$i]{'nameID'} eq $monsters_old{$ID}{'nameID'}) {
$monsters_Killed[$i]{'count'}++;
monsterLog($monsters_Killed[$i]{'name'});
$found = 1;
last;
}
$i++;
}
if (!$found) {
$monsters_Killed[$i]{'nameID'} = $monsters_old{$ID}{'nameID'};
$monsters_Killed[$i]{'name'} = $monsters_old{$ID}{'name'};
$monsters_Killed[$i]{'count'} = 1;
monsterLog($monsters_Killed[$i]{'name'})
}
## kokal end
} elsif ($config{teleportAuto_lostTarget}) {
message T("Target lost, teleporting.\n"), "ai_attack";
useTeleport(1);
} else {
message T("Target lost\n"), "ai_attack";
}
Plugins::callHook('attack_end', {ID => $ID})
}
#sub dropTargetWhileMoving {
# my $ID = AI::args->{attackID};
# message T("Dropping target - you will not kill steal others\n");
# stopAttack();
# $monsters{$ID}{ignore} = 1;
#
# Right now, the queue is either
# move, route, attack
# -or-
# route, attack
# AI::dequeue;
# AI::dequeue;
# AI::dequeue if (AI::action eq "attack");
# if ($config{teleportAuto_dropTargetKS}) {
# message T("Teleport due to dropping attack target\n");
# useTeleport(1);
# }
#}
sub main {
my $args = AI::args;
Benchmark::begin("ai_attack (part 1)") if DEBUG;
Benchmark::begin("ai_attack (part 1.1)") if DEBUG;
# The attack sequence hasn't timed out and the monster is on screen
# Update information about the monster and the current situation
my $args = AI::args;
my $followIndex = AI::findAction("follow");
my $following;
my $followID;
if (defined $followIndex) {
$following = AI::args($followIndex)->{following};
$followID = AI::args($followIndex)->{ID};
}
my $ID = $args->{ID};
my $target = Actor::get($ID);
my $myPos = $char->{pos_to};
my $monsterPos = $target->{pos_to};
my $monsterDist = round(distance($myPos, $monsterPos));
my ($realMyPos, $realMonsterPos, $realMonsterDist, $hitYou);
my $realMyPos = calcPosition($char);
my $realMonsterPos = calcPosition($target);
my $realMonsterDist = round(distance($realMyPos, $realMonsterPos));
if (!$config{'runFromTarget'}) {
$myPos = $realMyPos;
$monsterPos = $realMonsterPos;
}
my $cleanMonster = checkMonsterCleanness($ID);
# If the damage numbers have changed, update the giveup time so we don't timeout
if ($args->{dmgToYou_last} != $target->{dmgToYou}
|| $args->{missedYou_last} != $target->{missedYou}
|| $args->{dmgFromYou_last} != $target->{dmgFromYou}
|| $args->{lastSkillTime} != $char->{last_skill_time}) {
$args->{ai_attack_giveup}{time} = time;
debug "Update attack giveup time\n", "ai_attack", 2;
}
$hitYou = ($args->{dmgToYou_last} != $target->{dmgToYou}
|| $args->{missedYou_last} != $target->{missedYou});
$args->{dmgToYou_last} = $target->{dmgToYou};
$args->{missedYou_last} = $target->{missedYou};
$args->{dmgFromYou_last} = $target->{dmgFromYou};
$args->{missedFromYou_last} = $target->{missedFromYou};
$args->{lastSkillTime} = $char->{last_skill_time};
Benchmark::end("ai_attack (part 1.1)") if DEBUG;
Benchmark::begin("ai_attack (part 1.2)") if DEBUG;
# Determine what combo skill to use
delete $args->{attackMethod};
my $lastSkill;
if ($char->{last_skill_used}) {
$lastSkill = Skill->new(idn => $char->{last_skill_used})->getName();
}
my $i = 0;
while (exists $config{"attackComboSlot_$i"}) {
if (!$config{"attackComboSlot_$i"}) {
$i++;
next;
}
if ($config{"attackComboSlot_${i}_afterSkill"} eq $lastSkill
&& ( !$config{"attackComboSlot_${i}_maxUses"} || $args->{attackComboSlot_uses}{$i} < $config{"attackComboSlot_${i}_maxUses"} )
&& ( !$config{"attackComboSlot_${i}_autoCombo"} || ($char->{combo_packet} && $config{"attackComboSlot_${i}_autoCombo"}) )
&& ( !defined($args->{ID}) || $args->{ID} eq $char->{last_skill_target} || !$config{"attackComboSlot_${i}_isSelfSkill"})
&& checkSelfCondition("attackComboSlot_$i")
&& (!$config{"attackComboSlot_${i}_monsters"} || existsInList($config{"attackComboSlot_${i}_monsters"}, $target->{name}))
&& (!$config{"attackComboSlot_${i}_notMonsters"} || !existsInList($config{"attackComboSlot_${i}_notMonsters"}, $target->{name}))
&& checkMonsterCondition("attackComboSlot_${i}_target", $target)) {
$args->{attackComboSlot_uses}{$i}++;
delete $char->{last_skill_used};
if ($config{"attackComboSlot_${i}_autoCombo"}) {
$char->{combo_packet} = 1500 if ($char->{combo_packet} > 1500);
# eAthena seems to have a bug where the combo_packet overflows and gives an
# abnormally high number. This causes kore to get stuck in a waitBeforeUse timeout.
$config{"attackComboSlot_${i}_waitBeforeUse"} = ($char->{combo_packet} / 1000);
}
delete $char->{combo_packet};
$args->{attackMethod}{type} = "combo";
$args->{attackMethod}{comboSlot} = $i;
$args->{attackMethod}{distance} = $config{"attackComboSlot_${i}_dist"};
$args->{attackMethod}{maxDistance} = $config{"attackComboSlot_${i}_dist"};
$args->{attackMethod}{isSelfSkill} = $config{"attackComboSlot_${i}_isSelfSkill"};
last;
}
$i++;
}
# Determine what skill to use to attack
if (!$args->{attackMethod}{type}) {
if ($config{'attackUseWeapon'}) {
$args->{attackMethod}{distance} = $config{'attackDistance'};
$args->{attackMethod}{maxDistance} = $config{'attackMaxDistance'};
$args->{attackMethod}{type} = "weapon";
} else {
$args->{attackMethod}{distance} = 30;
$args->{attackMethod}{maxDistance} = 30;
undef $args->{attackMethod}{type};
}
$i = 0;
while (exists $config{"attackSkillSlot_$i"}) {
if (!$config{"attackSkillSlot_$i"}) {
$i++;
next;
}
my $skill = new Skill(name => $config{"attackSkillSlot_$i"});
if (checkSelfCondition("attackSkillSlot_$i")
&& (!$config{"attackSkillSlot_$i"."_maxUses"} ||
$target->{skillUses}{$skill->getHandle()} < $config{"attackSkillSlot_$i"."_maxUses"})
&& (!$config{"attackSkillSlot_$i"."_maxAttempts"} || $args->{attackSkillSlot_attempts}{$i} < $config{"attackSkillSlot_$i"."_maxAttempts"})
&& (!$config{"attackSkillSlot_$i"."_monsters"} || existsInList($config{"attackSkillSlot_$i"."_monsters"}, $target->{'name'}))
&& (!$config{"attackSkillSlot_$i"."_notMonsters"} || !existsInList($config{"attackSkillSlot_$i"."_notMonsters"}, $target->{'name'}))
&& (!$config{"attackSkillSlot_$i"."_previousDamage"} || inRange($target->{dmgTo}, $config{"attackSkillSlot_$i"."_previousDamage"}))
&& checkMonsterCondition("attackSkillSlot_${i}_target", $target)
) {
$args->{attackSkillSlot_attempts}{$i}++;
$args->{attackMethod}{distance} = $config{"attackSkillSlot_$i"."_dist"};
$args->{attackMethod}{maxDistance} = $config{"attackSkillSlot_$i"."_dist"};
$args->{attackMethod}{type} = "skill";
$args->{attackMethod}{skillSlot} = $i;
last;
}
$i++;
}
if ($config{'runFromTarget'} && $config{'runFromTarget_dist'} > $args->{attackMethod}{distance}) {
$args->{attackMethod}{distance} = $config{'runFromTarget_dist'};
}
}
$args->{attackMethod}{maxDistance} ||= $config{attackMaxDistance};
$args->{attackMethod}{distance} ||= $config{attackDistance};
if ($args->{attackMethod}{maxDistance} < $args->{attackMethod}{distance}) {
$args->{attackMethod}{maxDistance} = $args->{attackMethod}{distance};
}
Benchmark::end("ai_attack (part 1.2)") if DEBUG;
Benchmark::end("ai_attack (part 1)") if DEBUG;
if ($char->{sitting}) {
ai_setSuspend(0);
stand();
# } elsif (!$cleanMonster) {
#Drop target if it's already attacked by someone else
#message T("Dropping target - you will not kill steal others\n"), "ai_attack";
#$messageSender->sendMove($realMyPos->{x}, $realMyPos->{y});
#AI::dequeue;
#if ($config{teleportAuto_dropTargetKS}) {
# message T("Teleporting due to dropping attack target\n"), "teleport";
# useTeleport(1);
#}
} elsif (
$config{attackCheckLOS} && $args->{attackMethod}{distance} > 2
&& (($config{attackCanSnipe} && !checkLineSnipable($realMyPos, $realMonsterPos))
|| (!$config{attackCanSnipe} && $realMonsterDist < $args->{attackMethod}{maxDistance} && !checkLineWalkable($realMyPos, $realMonsterPos)))
) {
# We are a ranged attacker without LOS
# Calculate squares around monster within shooting range, but not
# closer than runFromTarget_dist
my @stand = calcRectArea2($realMonsterPos->{x}, $realMonsterPos->{y},
$args->{attackMethod}{distance},
$config{runFromTarget} ? $config{runFromTarget_dist} : 0);
my ($master, $masterPos);
if ($config{follow}) {
foreach (keys %players) {
if ($players{$_}{name} eq $config{followTarget}) {
$master = $players{$_};
last;
}
}
$masterPos = calcPosition($master) if $master;
}
# Determine which of these spots are snipable
my $best_spot;
my $best_dist;
for my $spot (@stand) {
# Is this spot acceptable?
# 1. It must have LOS to the target ($realMonsterPos).
# 2. It must be within $config{followDistanceMax} of
# $masterPos, if we have a master.
if (
(($config{attackCanSnipe} && checkLineSnipable($spot, $realMonsterPos))
&& checkLineWalkable($spot, $realMonsterPos))
&& $field->isWalkable($spot->{x}, $spot->{y})
&& ($realMyPos->{x} != $spot->{x} && $realMyPos->{y} != $spot->{y})
&& (!$master || round(distance($spot, $masterPos)) <= $config{followDistanceMax})
) {
my $dist = distance($realMyPos, $spot);
if (!defined($best_dist) || $dist < $best_dist) {
$best_dist = $dist;
$best_spot = $spot;
}
}
}
# Move to the closest spot
my $msg = "No LOS from ($realMyPos->{x}, $realMyPos->{y}) to target ($realMonsterPos->{x}, $realMonsterPos->{y})";
if ($best_spot) {
message TF("%s; moving to (%s, %s)\n", $msg, $best_spot->{x}, $best_spot->{y});
if ($config{attackChangeTarget} == 1) {
# Restart attack from processAutoAttack
AI::dequeue;
ai_route($field{name}, $best_spot->{x}, $best_spot->{y}, LOSSubRoute => 1);
} else {
ai_route($field{name}, $best_spot->{x}, $best_spot->{y});
}
} else {
warning TF("%s; no acceptable place to stand\n", $msg);
$target->{attack_failedLOS} = time;
AI::dequeue;
AI::dequeue;
AI::dequeue if (AI::action eq "attack");
}
} elsif ($config{'runFromTarget'} && ($realMonsterDist < $config{'runFromTarget_dist'} || $hitYou)) {
#my $begin = time;
# Get a list of blocks that we can run to
my @blocks = calcRectArea($myPos->{x}, $myPos->{y},
# If the monster hit you while you're running, then your recorded
# location may be out of date. So we use a smaller distance so we can still move.
($hitYou) ? $config{'runFromTarget_dist'} / 2 : $config{'runFromTarget_dist'});
# Find the distance value of the block that's farthest away from a wall
my $highest;
foreach (@blocks) {
my $dist = ord(substr($field{dstMap}, $_->{y} * $field{width} + $_->{x}));
if (!defined $highest || $dist > $highest) {
$highest = $dist;
}
}
# Get rid of rediculously large route distances (such as spots that are on a hill)
# Get rid of blocks that are near a wall
my $pathfinding = new PathFinding;
use constant AVOID_WALLS => 4;
for (my $i = 0; $i < @blocks; $i++) {
# We want to avoid walls (so we don't get cornered), if possible
my $dist = ord(substr($field{dstMap}, $blocks[$i]{y} * $field{width} + $blocks[$i]{x}));
if ($highest >= AVOID_WALLS && $dist < AVOID_WALLS) {
delete $blocks[$i];
next;
}
$pathfinding->reset(
field => \%field,
start => $myPos,
dest => $blocks[$i]);
my $ret = $pathfinding->runcount;
if ($ret <= 0 || $ret > $config{'runFromTarget_dist'} * 2) {
delete $blocks[$i];
next;
}
}
# Find the block that's farthest to us
my $largestDist;
my $bestBlock;
foreach (@blocks) {
next unless defined $_;
my $dist = distance($monsterPos, $_);
if (!defined $largestDist || $dist > $largestDist) {
$largestDist = $dist;
$bestBlock = $_;
}
}
#message "Time spent: " . (time - $begin) . "\n";
#debug_showSpots('runFromTarget', \@blocks, $bestBlock);
$args->{avoiding} = 1;
move($bestBlock->{x}, $bestBlock->{y}, $ID);
} elsif ($realMonsterDist > $args->{attackMethod}{maxDistance}
&& timeOut($args->{ai_attack_giveup}, 0.5)) {
# The target monster moved; move to target
$args->{move_start} = time;
$args->{monsterPos} = {%{$monsterPos}};
my $pos = meetingPosition($target, $args->{attackMethod}{maxDistance});
my $dist = sprintf("%.1f", $monsterDist);
debug "Target distance $dist is >$args->{attackMethod}{maxDistance}; moving to target: " .
"from ($myPos->{x},$myPos->{y}) to ($pos->{x},$pos->{y})\n", "ai_attack";
my $result = ai_route($field{'name'}, $pos->{x}, $pos->{y},
maxRouteTime => $config{'attackMaxRouteTime'},
attackID => $ID,
noMapRoute => 1,
noAvoidWalls => 1);
if (!$result) {
# Unable to calculate a route to target
$target->{attack_failed} = time;
AI::dequeue;
message T("Unable to calculate a route to target, dropping target\n"), "ai_attack";
if ($config{'teleportAuto_dropTarget'}) {
message T("Teleport due to dropping attack target\n");
useTeleport(1);
}
}
} elsif ((!$config{'runFromTarget'} || $realMonsterDist >= $config{'runFromTarget_dist'})
&& (!$config{'tankMode'} || !$target->{dmgFromYou})) {
# Attack the target. In case of tanking, only attack if it hasn't been hit once.
if (!$args->{firstAttack}) {
$args->{firstAttack} = 1;
my $pos = "$myPos->{x},$myPos->{y}";
debug "Ready to attack target (which is $realMonsterDist blocks away); we're at ($pos)\n", "ai_attack";
}
$args->{unstuck}{time} = time if (!$args->{unstuck}{time});
if (!$target->{dmgFromYou} && timeOut($args->{unstuck})) {
# We are close enough to the target, and we're trying to attack it,
# but some time has passed and we still haven't dealed any damage.
# Our recorded position might be out of sync, so try to unstuck
$args->{unstuck}{time} = time;
debug("Attack - trying to unstuck\n", "ai_attack");
move($myPos->{x}, $myPos->{y});
$args->{unstuck}{count}++;
}
if ($args->{attackMethod}{type} eq "weapon" && timeOut($timeout{ai_attack})) {
if (Actor::Item::scanConfigAndCheck("attackEquip")) {
#check if item needs to be equipped
Actor::Item::scanConfigAndEquip("attackEquip");
} else {
$messageSender->sendAttack($ID,
($config{'tankMode'}) ? 0 : 7);
$timeout{ai_attack}{time} = time;
delete $args->{attackMethod};
}
} elsif ($args->{attackMethod}{type} eq "skill") {
my $slot = $args->{attackMethod}{skillSlot};
delete $args->{attackMethod};
ai_setSuspend(0);
my $skill = new Skill(name => lc($config{"attackSkillSlot_$slot"}));
if (!ai_getSkillUseType($skill->getHandle())) {
ai_skillUse(
$skill->getHandle(),
$config{"attackSkillSlot_${slot}_lvl"},
$config{"attackSkillSlot_${slot}_maxCastTime"},
$config{"attackSkillSlot_${slot}_minCastTime"},
$config{"attackSkillSlot_${slot}_isSelfSkill"} ? $accountID : $ID,
undef,
"attackSkill",
undef,
undef,
"attackSkillSlot_${slot}");
} else {
my $pos = calcPosition($config{"attackSkillSlot_${slot}_isSelfSkill"} ? $char : $target);
ai_skillUse(
$skill->getHandle(),
$config{"attackSkillSlot_${slot}_lvl"},
$config{"attackSkillSlot_${slot}_maxCastTime"},
$config{"attackSkillSlot_${slot}_minCastTime"},
$pos->{x},
$pos->{y},
"attackSkill",
undef,
undef,
"attackSkillSlot_${slot}");
}
$args->{monsterID} = $ID;
debug "Auto-skill on monster ".getActorName($ID).": ".qq~$config{"attackSkillSlot_$slot"} (lvl $config{"attackSkillSlot_${slot}_lvl"})\n~, "ai_attack";
} elsif ($args->{attackMethod}{type} eq "combo") {
my $slot = $args->{attackMethod}{comboSlot};
my $isSelfSkill = $args->{attackMethod}{isSelfSkill};
my $skill = Skill->new(name => $config{"attackComboSlot_$slot"})->getHandle();
delete $args->{attackMethod};
if (!ai_getSkillUseType($skill)) {
my $targetID = ($isSelfSkill) ? $accountID : $ID;
ai_skillUse(
$skill,
$config{"attackComboSlot_${slot}_lvl"},
$config{"attackComboSlot_${slot}_maxCastTime"},
$config{"attackComboSlot_${slot}_minCastTime"},
$targetID,
undef,
undef,
undef,
$config{"attackComboSlot_${slot}_waitBeforeUse"});
} else {
my $pos = ($isSelfSkill) ? $char->{pos_to} : $target->{pos_to};
ai_skillUse(
$skill,
$config{"attackComboSlot_${slot}_lvl"},
$config{"attackComboSlot_${slot}_maxCastTime"},
$config{"attackComboSlot_${slot}_minCastTime"},
$pos->{x},
$pos->{y},
undef,
undef,
$config{"attackComboSlot_${slot}_waitBeforeUse"});
}
$args->{monsterID} = $ID;
}
} elsif ($config{tankMode}) {
if ($args->{dmgTo_last} != $target->{dmgTo}) {
$args->{ai_attack_giveup}{time} = time;
}
$args->{dmgTo_last} = $target->{dmgTo};
}
}
1;