Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Fix route bug implemented in last PR #3946

Merged
merged 1 commit into from
Jan 14, 2025
Merged

Fix route bug implemented in last PR #3946

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
104 changes: 61 additions & 43 deletions src/Task/Route.pm
View file
Open in desktop
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
Loading