Skip to content

Commit

Permalink
fix route
Browse files Browse the repository at this point in the history
  • Loading branch information
@Henrybk
Henrybk committed Jan 14, 2025
1 parent 7989d39 commit abcfcc8
Showing 1 changed file with 61 additions and 43 deletions.
104 changes: 61 additions & 43 deletions src/Task/Route.pm
View file
Original file line number Diff line number Diff line change
Expand Up @@ -211,37 +211,38 @@ sub iterate {
my $pos = $self->{actor}{pos};
my $pos_to = $self->{actor}{pos_to};

debug "Route $self->{actor}: Calculating. Your pos ($pos->{x} $pos->{y}). Your pos_to ($pos_to->{x} $pos_to->{y}).\n", "route";
my $calc_pos = calcPosFromPathfinding($field, $self->{actor});

debug "Route $self->{actor}: Calculating. Your pos ($pos->{x} $pos->{y}). Your pos_to ($pos_to->{x} $pos_to->{y}). calcPosFromPathfinding ($calc_pos->{x} $calc_pos->{y})\n", "route";

my $begin = time;

if (!$self->{meetingSubRoute} && !$self->{LOSSubRoute} && $pos_to->{x} == $self->{dest}{pos}{x} && $pos_to->{y} == $self->{dest}{pos}{y}) {
debug "Route $self->{actor}: Current position and destination are the same.\n", "route";
$self->setDone();

} elsif ($self->getRoute($self->{solution}, $self->{dest}{map}, $pos, $self->{dest}{pos}, $self->{avoidWalls}, $self->{randomFactor}, $self->{useManhattan}, 1)) {
} elsif ($self->getRoute($self->{solution}, $self->{dest}{map}, $calc_pos, $self->{dest}{pos}, $self->{avoidWalls}, $self->{randomFactor}, $self->{useManhattan}, 1)) {
$self->{stage} = ROUTE_SOLUTION_READY;

@{$self->{last_pos}}{qw(x y)} = @{$pos}{qw(x y)};
@{$self->{last_pos}}{qw(x y)} = @{$calc_pos}{qw(x y)};
@{$self->{last_pos_to}}{qw(x y)} = @{$pos_to}{qw(x y)};
$self->{start} = 1;
$self->{confirmed_correct_vector} = 0;

debug "Route $self->{actor} Solution Ready! Found path on ".$self->{dest}{map}->baseName." from ".$pos->{x}." ".$pos->{y}." to ".$self->{dest}{pos}{x}." ".$self->{dest}{pos}{y}.". Size: ".@{$self->{solution}}." steps.\n", "route";

# Changed in pathfinding.xs
#unshift(@{$self->{solution}}, { x => $pos->{x}, y => $pos->{y}});
debug "Route $self->{actor} Solution Ready! Found path on ".$self->{dest}{map}->baseName." from ".$calc_pos->{x}." ".$calc_pos->{y}." to ".$self->{dest}{pos}{x}." ".$self->{dest}{pos}{y}.". Size: ".@{$self->{solution}}." steps.\n", "route";

$self->iterate();

} else {
debug "Something's wrong; there is no path from " . $self->{dest}{map}->baseName . "($pos->{x},$pos->{y}) to " . $self->{dest}{map}->baseName . "($self->{dest}{pos}{x},$self->{dest}{pos}{y}).\n", "debug";
debug "Something's wrong; there is no path from " . $self->{dest}{map}->baseName . "($calc_pos->{x},$calc_pos->{y}) to " . $self->{dest}{map}->baseName . "($self->{dest}{pos}{x},$self->{dest}{pos}{y}).\n", "debug";
$self->setError(CANNOT_CALCULATE_ROUTE, "Unable to calculate a route.");
}

} elsif ($self->{stage} == ROUTE_SOLUTION_READY) {
my $begin = time;
my $solution = $self->{solution};

# TODO: What is this Fractional route motion bellow?
if ($self->{maxDistance} > 0 && $self->{maxDistance} < 1) {
# Fractional route motion
$self->{maxDistance} = int($self->{maxDistance} * scalar(@{$solution}));
Expand All @@ -253,11 +254,14 @@ sub iterate {
my $final_pos = $self->{solution}[-1];
if ( ($self->{pyDistFromGoal} || $self->{distFromGoal}) && ($self->{dest}{pos}{x} != $final_pos->{x} || $self->{dest}{pos}{y} != $final_pos->{y}) ) {
debug "Route $self->{actor} - final destination is not the same of pathfind, adjusting the trimsteps\n", "route";
# TODO: Reviews this code bellow
my $trim = blockDistance($self->{dest}{pos}, $final_pos);
$self->{pyDistFromGoal} -= $trim if $self->{pyDistFromGoal};
$self->{distFromGoal} -= $trim if $self->{distFromGoal};
}


# TODO: Neither distFromGoal or pyDistFromGoal consider pathfinding, only blockdistance or distance
# - maybe this should be done during walk route in a loop?
# Trim down solution tree for pyDistFromGoal or distFromGoal
if ($self->{pyDistFromGoal}) {
my $trimsteps = 0;
Expand Down Expand Up @@ -304,15 +308,15 @@ sub iterate {
$self->{step_index} = $config{$self->{actor}{configPrefix}.'route_step'};
}

my ($current_pos, $current_pos_to);
my ($current_pos, $current_pos_to, $current_calc_pos);

# $actor->{pos} is the position the character moved FROM in the last move packet received
@{$current_pos}{qw(x y)} = @{$self->{actor}{pos}}{qw(x y)};

# $actor->{pos_to} is the position the character moved TO in the last move packet received
@{$current_pos_to}{qw(x y)} = @{$self->{actor}{pos_to}}{qw(x y)};

my $current_calc_pos = calcPosFromPathfinding($field, $self->{actor});
$current_calc_pos = calcPosFromPathfinding($field, $self->{actor});

if ($current_calc_pos->{x} == $solution->[$#{$solution}]{x} && $current_calc_pos->{y} == $solution->[$#{$solution}]{y}) {
# Actor position is the destination; we've arrived at the destination
Expand All @@ -329,54 +333,63 @@ sub iterate {
} else {
# Failsafe
my $lookahead_failsafe_max = $self->{step_index} + 1;
my $lookahead_failsafe_count = 0;
my $lookahead_failsafe_count;

# This looks ahead in the solution array and finds the closest position in it to our current {pos}, then it looks $lookahead_failsafe_max further, just to be sure
my $best_pos_step = 0;
my $next_best_pos_step_try = 1;

while (1) {
if (adjustedBlockDistance($current_pos, $solution->[$best_pos_step]) > adjustedBlockDistance($current_pos, $solution->[$next_best_pos_step_try])) {
$best_pos_step = $next_best_pos_step_try;

$lookahead_failsafe_count = 0;
my $best_index;
my $best_dist;

foreach my $step_i (0..$#{$solution}) {
my $step = $solution->[$step_i];
if ($step->{x} == $current_calc_pos->{x} && $step->{y} == $current_calc_pos->{y}) {
$best_index = $step_i;
$best_dist = 0;
last;
}
my $dist = adjustedBlockDistance($current_calc_pos, $step);
if (!defined $best_dist || $best_dist > $dist) {
$best_index = $step_i;
$best_dist = $dist;
$lookahead_failsafe_count = 0;
} else {
$lookahead_failsafe_count++;
if ($lookahead_failsafe_count == $lookahead_failsafe_max) {
$lookahead_failsafe_count = 0;
last;
}
}
$next_best_pos_step_try++;

if ($next_best_pos_step_try > $#{$solution}) {
if ($lookahead_failsafe_count == $lookahead_failsafe_max) {
last;
}
}
my $best_pos_step = $best_index;

# This does the same, but with {pos_to}
my $best_pos_to_step = 0;
my $next_best_pos_to_step_try = 1;
while (1) {
if (adjustedBlockDistance($current_pos_to, $solution->[$best_pos_to_step]) > adjustedBlockDistance($current_pos_to, $solution->[$next_best_pos_to_step_try])) {
$best_pos_to_step = $next_best_pos_to_step_try;
undef $best_index;
undef $best_dist;
foreach my $step_i (0..$#{$solution}) {
my $step = $solution->[$step_i];
if ($step->{x} == $current_pos_to->{x} && $step->{y} == $current_pos_to->{y}) {
$best_index = $step_i;
$best_dist = 0;
last;
}
my $dist = adjustedBlockDistance($current_pos_to, $step);
if (!defined $best_dist || $best_dist > $dist) {
$best_index = $step_i;
$best_dist = $dist;
$lookahead_failsafe_count = 0;
} else {
$lookahead_failsafe_count++;
if ($lookahead_failsafe_count == $lookahead_failsafe_max) {
$lookahead_failsafe_count = 0;
last;
}
}
$next_best_pos_to_step_try++;

if ($next_best_pos_to_step_try > $#{$solution}) {
if ($lookahead_failsafe_count == $lookahead_failsafe_max) {
last;
}
}
my $best_pos_to_step = $best_index;

# Here there may be the need to check if 'pos' has changed yet best_pos_step is still the same, creating a lag in the movement

# Last change in pos and pos_to put us in a walk path oposite to the desired one
# TODO: This confirmed_correct_vector could probably be removed
if ($best_pos_step > $best_pos_to_step) {
if ($self->{confirmed_correct_vector}) {
debug "Route $self->{actor} - movement interrupted: reset route (last change in pos and pos_to put us in a walk path oposite to the desired one)\n", "route";
Expand All @@ -390,13 +403,16 @@ sub iterate {
}

# Last move was to the cell we are already at, lag?, buggy code?
if ($self->{start} || $best_pos_step == 0) {
if ($self->{start}) {
debug "Route $self->{actor} - not trimming down solution (" . @{$solution} . ") because we have not moved yet.\n", "route";

} elsif ($best_pos_step == 0) {
debug "Route $self->{actor} - not trimming down solution (" . @{$solution} . ") because best_pos_step is 0.\n", "route";

} else {
# Should we trimm only the known walk ones ($best_pos_step) or the known + the guessed (calcStepsWalkedFromTimeAndRoute)? Default was both.

# Currently testing delete up to known ($best_pos_step)(exclusive)
# Currently testing delete up to known + the guessed
debug "Route $self->{actor} - trimming down solution (" . @{$solution} . ") by ".($best_pos_step)." steps\n", "route";

splice(@{$solution}, 0, $best_pos_step);
Expand Down Expand Up @@ -469,7 +485,7 @@ sub iterate {
# We're stuck
my $msg = TF("Stuck at %s (%d,%d), while walking from (%d,%d) to (%d,%d).",
$self->{dest}{map}->baseName, @{$self->{actor}{pos_to}}{qw(x y)},
$current_pos->{x}, $current_pos->{y}, $self->{dest}{pos}{x}, $self->{dest}{pos}{y}
$current_calc_pos->{x}, $current_calc_pos->{y}, $self->{dest}{pos}{x}, $self->{dest}{pos}{y}
);
$msg .= T(" Teleporting to unstuck.") if ($config{$self->{actor}{configPrefix}.'teleportAuto_unstuck'});
$msg .= "\n";
Expand Down Expand Up @@ -506,9 +522,10 @@ sub iterate {

# But first, check whether the distance of the next point isn't abnormally large.
# If it is, then we've moved to an unexpected place. This could be caused by auto-attack, for example.
# TODO: This should be calcDistFromPath or something like that
my %nextPos = (x => $self->{next_pos}{x}, y => $self->{next_pos}{y});
if (blockDistance(\%nextPos, $current_pos) > 17) {
debug "Route $self->{actor} - movement interrupted: reset route (the distance of the next point is abnormally large ($current_pos->{x} $current_pos->{y} -> $nextPos{x} $nextPos{y}))\n", "route";
if (blockDistance(\%nextPos, $current_calc_pos) > 17) {
debug "Route $self->{actor} - movement interrupted: reset route (the distance of the next point is abnormally large ($current_calc_pos->{x} $current_calc_pos->{y} -> $nextPos{x} $nextPos{y}))\n", "route";
$self->{solution} = [];
$self->{stage} = CALCULATE_ROUTE;

Expand All @@ -521,7 +538,7 @@ sub iterate {
}
}

if ($current_pos_to->{x} == $self->{next_pos}{x} && $current_pos_to->{y} == $self->{next_pos}{y}) {
if (!$self->{start} && $current_pos_to->{x} == $self->{next_pos}{x} && $current_pos_to->{y} == $self->{next_pos}{y}) {
debug "[Route] Not sending next step ($self->{next_pos}{x}, $self->{next_pos}{y}) because our pos_to is the same as it.\n", "route";
if ($self->{lastStep} == 1 && !$self->{sendAttackWithMove} && $self->{meetingSubRoute}) {
debug "[Route] Also ending task now ang giving back control to AI::Attack.\n", "route";
Expand All @@ -539,6 +556,7 @@ sub iterate {

@{$self->{last_pos}}{qw(x y)} = @{$current_pos}{qw(x y)};
@{$self->{last_pos_to}}{qw(x y)} = @{$current_pos_to}{qw(x y)};
@{$self->{last_current_calc_pos}}{qw(x y)} = @{$current_calc_pos}{qw(x y)};

debug "Route $self->{actor} - next step moving to ($self->{next_pos}{x}, $self->{next_pos}{y}), index $self->{step_index}, $stepsleft steps left\n", "route";

Expand Down

0 comments on commit abcfcc8

Please sign in to comment.