WayPoints / lockmapwp.pl = planLockMapWalk??

=o
Usando la versión mas nueva del openkore svn de su pagina oficial de descarga, y con lo de la nueva parchada de iRO, me doy cuenta que muchos de los plugins populares que se usaban de una forma ejemplar y te auxiliaban en extremo se han vuelto obsoletos. Y tal parece que eso le paso a mi querido pluggin de WayPoints..


Ya que no se ha sacado ninguna actualización al respecto... se supone que hay un sucesor de nombre mas largo: planLockMapWalk, el cual te obliga a crear un nuevo archivo .pl, poner nuevos comandos en el config.txt, crear un archivo (openkore_ready/control) de txt de nombre planwalk.txt y modificar el (\openkore_ready\src\AI) CoreLogic.pm

La cosa es que a mi me tira error si modifico el CoreLogic.pm

Si no lo modifico, según la guía, el nuevo pluggin no funciona..

La guía es del foro oficial en ingles del OpenKore
http://forums.openkore.com/viewtopic.php?f=34&t=13558&start=20

Pues mi duda más que nada es saber si hay un nuevo "lockmapwp" para estas nuevas versiones de OpenKore.. si no, pues un poco de ayuda no caería mal para usar el planLockMapWalk

Saludos.

el plan lock map no lo conozco, tendria que investigar al respecto, asi como investigar si es posible hacer funcionar el lockmapwp.pl (por segunda vez).


Hace un tiempo ese plugin habia dejado de funcionar, y eliminando una linea del código quedaba funcional nuevamente, ahora supongo habria que editar algo....

Saludos!

Sinceramente me gustaría más que volviera a funcionar el lockmapwp.pl. Pues le dejas la indicación en waypoints de como debe recorrer el mapa de una forma inteligente y segura. Por segura me refiero a que si uso el pluggin no uso el macros que me desestabiliza otras acciones como eh leído por ahí. Aparte que con los waypoints ya indicados recorres TODO el mapa, sin que la mob se esconda en una esquina que el route_randomWalk jamás revisó.
Si es posible hacerlo funcionar, te lo encargo mucho, -Fox-

tendré que verlo bien... tengo muy pocos conocimiento de perl xD , de echo los que tengo me los gane intruseando el openkore xD....

Se me ocurre que cierta instrucción cambio de lugar en el openkore, o quizás de nombre, por lo que se podría si es que cambio de lugar importarla al plugin ( el plugin lo que hace es al parecer indicar de donde importara ciertas funciones....


La primera vez que dejo de funcionar fue por que la AI fue reestructurada, y el plugin hacia cierta llamada a la AI del hommunculo, no tengo idea por quel o hacia xD, la cosa es que yo eliminando esa linea que hacia esa llamada se arreglo el problema....


Ahora imagino que habrá que editar la llamada a una función o variable, o tratar de editar el openkore para que funcione como cuando el plugin funcionaba...

Te dejo las ideas por si quieres investigar... yo tendré que darme un tiempo para hacerlo...


SAludos!

Sinceramente Fox, me hablas en chino.
Chequé en otras paginas que hacer, pero me llevan a otras ondas, y ondas que no tienen que ver..
Y el idioma que usan es mas raro, lineas con signos y emblemas que no se en que alterarian el funcionamiento del bot o simplemente hacerlo "crashear".

Solo me queda depender de tí, y pues tómate tu tiempo, si puedes hacerlo y lo logras que mejor! Te voy a idolatrar xD
Saludos!

Señores, grandes noticias!

No hice funcionar al lockmapwp.pl, pero hice funcionar al nuevo navegador para estas nuevas actualizaciones de OpenKore! PlanLockMapWalk.pl.

Lo primero!
El código del plugin:

Código:

# planLockMapWalk by Snoopy

package planLockMapWalk;

use strict;
#use warnings;

use Time::HiRes qw(time);

use Globals;
use Utils;
use Misc;
use AI;
use Log qw(debug message warning error);
use Translation;
#use encoding 'utf8';

my $nSpot = 0;
my $planMap = "";
my $cfID;
my $planwalk_file = "";
my @points = ();

Plugins::register('planLockMapWalk', 'Auto Plan to walk.', \&on_unload, \&on_reload);

my $hooks = Plugins::addHooks(
  ['configModify', \&on_configModify, undef],
  ['start3', \&on_start3, undef],
  ['postloadfiles', \&on_loadfiles, undef],
  ['pref_RandomWalk', \&pref_planWalk, undef],
  ['post_RandomWalk', \&post_planWalk, undef]
);

my $chooks = Commands::register(
  ['planwalk', "Plan Lock Map Walk plugin", \&commandHandler]
);

sub on_unload {
  Plugins::delHooks($hooks);
}

sub on_reload {
  message "planLockMapWalk plugin reloading\n";
  Plugins::delHooks($hooks);
  &on_start3
}

sub on_configModify {
  my (undef, $args) = @_;
  if ($args->{key} eq 'planWalk_file') {
      $planwalk_file = $args->{val};
      Settings::removeFile($cfID);
      $cfID = Settings::addControlFile($planwalk_file, loader => [ \&parsePlanWalk, undef]);
      Settings::loadByHandle($cfID);
  } elsif ($args->{key} eq 'lockMap') {
      if ($planMap ne $args->{val}) {
        $planMap = $args->{val};
        $nSpot = 0;
#        message T("..... change lockMap...\n");
        Settings::loadByHandle($cfID);
      }
  }
}

sub on_start3 {
  &checkFile;
  Settings::removeFile($cfID) if ($cfID);
  $cfID = Settings::addControlFile($planwalk_file, loader => [ \&parsePlanWalk]);
  Settings::loadByHandle($cfID);
}

sub on_loadfiles {
  if ($char && ($planMap ne $config{lockMap} || $planwalk_file ne $config{planWalk_file})) {
#      message TF("1. %s : %s , 2. %s : %s\n", $planMap, $config{lockMap}, $planwalk_file, $config{planWalk_file});
      $planMap = $config{lockMap};
      $planwalk_file = (defined $config{planWalk_file})? $config{planWalk_file} : "planwalk.txt";
      Settings::removeFile($cfID) if ($cfID);
      $cfID = Settings::addControlFile($planwalk_file, loader => [ \&parsePlanWalk]);
      Settings::loadByHandle($cfID);
  }
}

# checks planwalk file
sub checkFile {
  $planMap = $config{lockMap};
  $planwalk_file = (defined $config{planWalk_file})? $config{planWalk_file} : "planwalk.txt";
}

# onFile(Re)load
sub parsePlanWalk {
  my $file = shift;
#  message TF("The plak walk on %s in file: %s\n", $planMap, $file);

  my $flag1 = 0;
  @points = ();
  if (-e $file && $planMap) {
#  if (-e $file) {
      open my $fp, "<:utf8", $file;
      while (<$fp>) {
        $. == 1 && s/^\x{FEFF}//; # utf bom
        s/(.*)[\s\t]+#.*$/$1/;  # remove last comments
        s/^\s*#.*$//;      # remove comments
        s/^\s*//;      # remove leading whitespaces
        s/\s*[\r\n]?$//g;  # remove trailing whitespaces and eol
        s/  +/ /g;      # trim down spaces - very cool for user's string data?
        next unless ($_);
        if (/^\[(.+)\]$/) {
            $flag1 = ($1 eq $planMap) ? 1 : 0;
#            $flag1 = ($1 eq $config{lockMap}) ? 1 : 0;
        } elsif ($flag1) {
            if (/^(\d+):(\d+)$/) {
              push @points, {'xPos' => $1, 'yPos' => $2};
            }
        }
      }
#      foreach my $pp (@points) {
#        message TF("Point : %s, %s\n", $pp->{xPos}, $pp->{yPos});
#      }
  }
}

sub pref_planWalk {
  return if (!$config{autoPlanLockMapWalk} || $config{lockMap} ne $field->baseName);

  my (undef, $args) = @_;
  my $ret = 1;
  my $maxRouteTime = $config{planWalk_maxRouteTime} ? $config{planWalk_maxRouteTime} :
      ($config{route_randomWalk_maxRouteTime} ? $config{route_randomWalk_maxRouteTime} : 120);

  $nSpot = @points - 1 if ($nSpot >= @points);
  if ($nSpot >= 0) {
      my ($to_x, $to_y);
      $to_x = $points[$nSpot]->{xPos};
      $to_y = $points[$nSpot]->{yPos};

      if ($to_x eq "" || $to_y eq "") {
        error T("Empty coordinates setting for planLockMapWalk; planLockMapWalk disabled\n");
        $config{autoPlanLockMapWalk} = '0';
      } elsif ($field->isWalkable($to_x, $to_y)) {
        AI::clear(qw/move route mapRoute/);
        message TF("Do plan walking route to: %s: %s, %s\n", $field->descString(), $to_x, $to_y), "route";
        main::ai_route($field->baseName, $to_x, $to_y,
            maxRouteTime => $maxRouteTime,
            attackOnRoute => 2,
            noMapRoute => ($config{route_randomWalk} == 2 ? 1 : 0));
        $ret = 0;
      } else {
        error TF("Invalid coordinates specified (%d, %d) for planLockMapWalk (coordinates are unwalkable); planLockMapWalk disabled\n", $to_x, $to_y);
        $config{autoPlanLockMapWalk} = '0';
      }
      $nSpot++;
      $nSpot = 0 if ($nSpot >= @points);
  }
  $args->{return} = $ret;
}

sub post_planWalk {
}

sub commandHandler {
  message TF("The Plan Lock Map is : %s (Step: %d)\n", ($planMap) ? $planMap : "???", $nSpot - 1);
  message TF("The configuration file is : %s \n", ($planwalk_file) ? $planwalk_file : "???");
  for(my $i = 0 ; $i < @points ; $i++) {
      message TF("Walk Point(%d) : %s, %s\n", $i, $points[$i]->{xPos}, $points[$i]->{yPos});
  }
}

1;

Lo copian a un archivo de texto (.txt) después de copiado guardan, cierran y modifican la extención a .pl

Lo segundo! Y en lo que me trabe más, modificar el archivo: openkore_ready\src\AI\CoreLogic.pm
Les recomiendo que antes de modificarlo, hagan una copia de ese archivo por si no les funciona a la primera.
Primero cambiarás la extención de .pm a .txt, abres el archivo y buscarás el título: ##### RANDOM WALK #####
Modificarás la parte original por este code:

Código:

##### RANDOM WALK #####
sub processRandomWalk {
   if (AI::isIdle && (AI::SlaveManager::isIdle()) && $config{route_randomWalk} && !$ai_v{sitAuto_forcedBySitCommand}
      && (!$field->isCity || $config{route_randomWalk_inTown})
      && length($field->{rawMap}) ) {

my %hookArgs;
      $hookArgs{prefix} = "pref_RandomWalk";
      $hookArgs{return} = 1;
      Plugins::callHook('pref_RandomWalk', \%hookArgs);

      if ($hookArgs{return}) {      my ($randX, $randY);
      my $i = 500;
      do {
         $randX = int(rand($field->width)) + 1;
         $randX = int($config{'lockMap_x'} - $config{'lockMap_randX'} + rand(2*$config{'lockMap_randX'}))+1 if ($config{'lockMap_x'} ne '' && $config{'lockMap_randX'} ne '');
         $randY = int(rand($field->height)) + 1;
         $randY = int($config{'lockMap_y'} - $config{'lockMap_randY'} + rand(2*$config{'lockMap_randY'}))+1 if ($config{'lockMap_y'} ne '' && $config{'lockMap_randY'} ne '');
      } while (--$i && !$field->isWalkable($randX, $randY));
      if (!$i) {
         error T("Invalid coordinates specified for randomWalk (coordinates are unwalkable); randomWalk disabled\n");
         $config{route_randomWalk} = 0;
      } else {
         message TF("Calculating random route to: %s: %s, %s\n", $field->descString(), $randX, $randY), "route";
         ai_route($field->baseName, $randX, $randY,
            maxRouteTime => $config{route_randomWalk_maxRouteTime},
            attackOnRoute => 2,
            noMapRoute => ($config{route_randomWalk} == 2 ? 1 : 0) );
      }
   }


$hookArgs{prefix} = "post_RandomWalk";
      $hookArgs{return} = 1;
      Plugins::callHook('post_RandomWalk', \%hookArgs);
  }
}



Guardas y modificas la extención de nuevo a .pm

en la carpeta de control del OpenKore crearás un archivo de texto con el nombre: planwalk.txt. Es ahí dónde escribirás los Waypoints a los que tu Bot se dirigirá.
Ejemplo:

Código:

[pay_dun01]
24:33
56:81
29:96
44:182
71:188
38:208
62:233
44:262
etc:etc...

En el config.txt agregarás 3 líneas:

Código:

autoPlanLockMapWalk 1
planWalk_file planwalk.txt
planWalk_maxRouteTime 300

Y listo! No se si cabe mencionar pero ahí va. Este plugin requiere que el route_randomWalk esté activado. Anteriormente el lockmapwp.pl requería que se apagara para que el bot recibiera una orden y se moviera a la siguiente ubicación. Con este no hay problema.

Gracias a Fox por los animos y las ideas. =D
Fuente de esta Guía.