Walker

Walker, also commonly refered to as RSWalker and RSW is the go to tool for walking and accurate positioning.

How does it work?

The details are quite complex but to put it simply, the way it works is:

  • A large image of the game map is loaded. This image has to include the region you are on or things won’t work as expected.

  • A screenshot of your minimap is taken and, rotated north and cleaned (player, npc and item dots are removed).

  • This minimap screenshot is then searched on our loaded map image, the closest match is then returned as our position.

  • Once we have an accurate position, we can do all sort of things:

    • Accurately get the position of a tile

    • Accurately hover any visible tile with the help of mm2ms

    • Color search a tile

Things to keep in mind with TRSWalker:

  • Coordinates are relative to the map loaded. They are literally your pixel position in the map image. If you load map A and B and map B contains map A somewhere that is not it’s top-left corner, their coordinates will not match even if you are standing in the same tile. So if you get your position and it tells you are at X = 300 and Y = 500 it means you are in the pixel X = 300 and Y = 500 of your map image.

  • Because we search our minimap inside our map to find our position, smaller maps are much faster. It’s not exactly porportional but almost, so if you have a map that has a total of 1000 pixels and it takes 50ms to get your position, a map with 2000 pixels will take almost exactly 100ms.

  • A map image cannot be smaller than the minimap and should not even be anywhere close to it’s size. Any area you think you might be standing on on your script should have at the very minimum a 75 extra pixels of “padding” because that’s the maximum visible distance of the minimap and even then, slightly more is recommended.

Variables for users to tweak:

  • ScreenWalk: When set to true, walker will use only the mainscreen to walk instead of the minimap.

  • AdaptiveWalk: When set to true, will enable and disable ScreenWalk depending on your distance to the target, making walking use a mix of minimap and mainscreen walking. The closer your are to the target the more likely it is to use the mainscreen and the further you are the less likely. You can also play with RSW_ADAPTIVE_SCREEN_TOGGLE_DISTANCES values to customize the behavior.


PRSWalker

TRSWalker pointer.


TRSWalker_OnWalkEvent

Callback object method to use while walking. This can be used to perform custom tasks while walking.

Example:

procedure TRSWalker.WalkerTasks(Walker: PRSWalker; Position: TPoint; Destination: TPoint);
begin
  Antiban.RandomTab();
end;

var
  rsw: TRSWalker;
begin
  rsw.Setup('world');
  rsw.OnWalkingEvent := @rsw.WalkerTasks;
end;

TRSWalker

TRSWalker is the record responsbile for walking and position.


Walker.InternalSetup

procedure TRSWalker.InternalSetup();

Internal walker method automatically called by Walker.Setup(). You probably will never need to call this directly.


Walker.Free

procedure TRSWalker.Free;

Internal walker method automatically called on script termination. You probably will never need to call this directly. If you do, you won’t be able to use your walker until you set it up again.


Walker.Setup

procedure TRSWalker.Setup(map: String; Scaling: Int32 = 8);
procedure TRSWalker.Setup(scaling: Int32 = 8); overload;
procedure TRSWalker.SetupRegions(map: String; aRegions: TBoxArray; scaling: Int32 = 8);
procedure TRSWalker.SetupRegions(aRegions: TBoxArray; scaling: Int32 = 8); overload;
procedure TRSWalker.SetupRegion(map: String; aRegion: TBox; scaling: Int32 = 8);
procedure TRSWalker.SetupRegion(aRegion: TBox; scaling: Int32 = 8); overload;
procedure TRSWalker.SetupFromURL(url: String; map: String = ''; scaling: Int32 = 8; force: Boolean = False); overload;

Setup method to be called in scripts. There’s several versions of the method you can call depending on the features you want to use. All of them have a scaling parameter in common that defaults to 8. This is used to adjust the downscaling of the map used, lower downscaling makes walker more accurate at the cost of speed. The speed difference is more or less porportional to the scaling, higher being faster. Unless you have issues with wrong positions you should probably not touch it.

Map is the map name you want to load. The file is assumed to be in the walker maps directory: Simba/Includes/SRL/osr/walker/maps If the map is not there, an error will be thrown. You can optionally load only certain regions of the map. This is useful if there’s a map that has the area you want but it’s too slow due to it’s size. The regions are specified as a TBoxArray and they are cropped from the map you specify on setup and joined into a single map image. This type of setup retains the coordinates of the original map image. You can also optionally omit the Map name to make walker use the default SRL map which you can find in: Simba/Includes/SRL/osr/walker/map.png

Example:

//The following are several setup examples. Keep in mind that if the file doesn't exist in the maps folder, Walker will throw an error.
var
  rsw: TRSWalker;

begin
  rsw.Setup('world');
  rsw.Setup('world.png');
  rsw.Setup('world', 6);
  rsw.Setup();
  rsw.SetupRegions([[4460, 1900, 4800, 2250], [75, 75, 1000, 1000]]); //loads GE and lunar isle.
end;

Walker.AddRegion

procedure TRSWalker.AddRegion(map: String; start: TPoint);
procedure TRSWalker.AddRegions(map: String; aRegions: TBoxArray);
procedure TRSWalker.AddRegion(map: String; aRegion: TBox); overload;
procedure TRSWalker.AddRegions(aRegions: TBoxArray); overload;
procedure TRSWalker.AddRegion(aRegion: TBox); overload;
procedure TRSWalker.AddRegionFromURL(url: String; start: TPoint; map: String = ''; force: Boolean = False); overload;

Add a region to walker on the fly after it is already setup.


Walker.CleanMinimap

procedure TRSWalker.CleanMinimap(Bitmap: TMufasaBitmap); static;

Internal walker method used to clear minimap dots from the minimap. You probably don’t need to use this.


Walker.GetCleanMinimap()

function TRSWalker.GetCleanMinimap(): TMufasaBitmap; static;

Internal walker method used to “screenshot” the minimap and clean it with Walker.CleanMinimap(). You probably don’t need to use this directly but you can see what it does in the following example.

Example:

var
  rsw: TRSWalker;

begin
  rsw.GetCleanMinimap().Debug();
end;

Walker.ScaleMinimap

function TRSWalker.ScaleMinimap(Bitmap: TMufasaBitmap; Scaling: Int32): TMufasaBitmap;

Internal walker method used to scale down the minimap to whatever TRSWalker.Scaling is. You probably don’t need to use this directly but you can see what it does in the following example.

Example:

var
  rsw: TRSWalker;

begin
  rsw.ScaleMinimap(rsw.GetCleanMinimap(), rsw.Scaling).Debug();
end;

Walker.ScaledSearch

function TRSWalker.ScaledSearch(Bitmap: TMufasaBitmap; Samples: Int32): TPointArray;

Internal walker method used to get an initial TPointArray of possible positions. This is performed in a scaled down map with a scaled down minimap. This is very innacurate by itself but by ruling down most of the map in a scaled search before doing a full sized search speed has a dramatic boost. You probably won’t ever need to call this directly.


Walker.FullSearch

function TRSWalker.FullSearch(Templ, World: TMufasaBitmap; Position: TPoint; out Match: Single): TPoint;

Internal walker method used to get the player position. This is used by TRSWalker.GetMyPos() to determine how likely is the Position passed in, our actual position. This likelyhood is returned with Match which ranges from 0 to 1. You probably won’t ever need to call this directly.


Walker.GetMyPos

function TRSWalker.GetMyPos(): TPoint;

Returns the players current position on the loaded map.

Example::

WriteLn(Walker.GetMyPos());

// Check to see the match percentage if needed
WriteLn(Walker.Similarity);

Walker.WorldToMM

function TRSWalker.WorldToMM(playerPoint, walkerPoint: TPoint; Radians: Double): TPoint;
function TRSWalker.WorldToMM(walkerPoint: TPoint): TPoint; overload;

Converts a walker coordinate to a point in the minimap.

Example:

var
  rsw: TRSWalker;
  p: TPoint;
  bitmap: TMufasaBitmap;

begin
  rsw.Setup([RSWalkerRegions.GRAND_EXCHANGE]); //Make sure you are in GE for this example.
  p := rsw.WorldToMM([4620, 2100]);            //This is just a random point in the ge with SRL map.

  bitmap.FromClient();
  bitmap.DrawCross(p, 4, $FFFFFF);
  bitmap.Free();
end;

Walker.CheckRunEnergy

procedure TRSWalker.CheckRunEnergy();

Internal method used to check and enable the player run. You will probably never need to call this directly.

The values used are hardcoded and if you don’t like them, it’s recommended you override the method. The following example shows how one could override the function to enable run at 50% energy everytime, keep in mind though, you shouldn’t do this, you should add randomness to it!



- - -

## Walker.AdaptiveWalkCheck
```pascal
procedure TRSWalker.AdaptiveWalkCheck(Position: TPoint);

Internal method used to check if adaptive walk should toggle and toggle TRSWalker.ScreenWalk. You will probably never need to call this directly.


Walker.DoMouseAhead

procedure TRSWalker.DoMouseAhead(Position: TPoint; Forced: Boolean = False);

Internal method used to pre-hover the next walking step. You will probably never need to call this directly.


Walker.WaitMoving

procedure TRSWalker.WaitMoving(Destination: TPoint; WaitUntilDistance: Int32);

Internal method used to wait while we are moving using walker. You will probably never need to call this directly.

This is where TRSWalker.OnWalkingEvent are called.


Walker.Click

function TRSWalker.Click(minimapPoint: TPoint; Randomness: Int32): Boolean;

Internal method used by walker to handle clicking while walking. You will probably never need to call this directly.

If you wish to modify certain walker behaviors, it can be a good approach to override this function.


Walker.WalkStepHelper()

function TRSWalker.WalkStepHelper(playerPoint, walkerPoint: TPoint; out minimapPoint: TPoint): Boolean;

Internal method used by walker to help walking steps. You will probably never need to call this directly.


Walker.WalkFinalStep

function TRSWalker.WalkFinalStep(playerPoint, walkerPoint: TPoint; WaitUntilDistance: Int32): Boolean;

Internal method used by walker when finishing walking a path. You will probably never need to call this directly but it can be used to take a single step.


Walker.WalkStep

function TRSWalker.WalkStep(playerPoint, walkerPoint: TPoint): Boolean;

Internal method used by walker while walking a path. You will probably never need to call this directly.


Walker.IsWalkable

function TRSWalker.IsWalkable(walkerPoint: TPoint; playerPoint: TPoint; Angle: Double): Boolean;

Internal method used by walker to decide if the destination point is within 1 click reach. You will probably never need to call this directly.


TRSWalker.WalkPath

function TRSWalker.WalkPath(Path: TPointArray; WaitUntilDistance: Int32 = 0): Boolean;

Walks a path of points taken from the loaded map. We advice that WaitUntilDistance is not 0.

Parameters:

  • Path Array of points taken from the loaded map to walk. Must be ordered from start to finish.

  • WaitUntilDistance Determines when the method returns once the final point has been clicked. Default value: 0. | WaitUntilDistance=0 waits until the player has reached the final point. | WaitUntilDistance=20 waits until the player is within 20 pixels of the final point.

Example:

Walker.WalkPath([[100,100],[120,120],[140,140],[160,160],[180,180]]);

TRSWalker.WalkBlind

function TRSWalker.WalkBlind(Destination: TPoint; WaitUntilDistance: Int32 = 0): Boolean;

“Blindly” walks to a point taken from the loaded map. A straight line is generated between the player’s position and destination which is then walked.

Parameters:

  • Destination Destination point taken from the loaded map.

  • WaitUntilDistance Determines when the method returns once the final point has been clicked. Default value: 0. | WaitUntilDistance=0 waits until the player has reached the final point. | WaitUntilDistance=20 waits until the player is within 20 pixels of the final point.

Example:

Walker.WalkBlind([300, 300]);

TRSWalker.WebWalk

function TRSWalker.WebWalk(Destination: TPoint; WaitUntilDistance: Int32 = 0; PathRandomness: Double = 0): Boolean;

Web walks to the destination point on the loaded map. Does not handle any obstacles. Please run webber.simba to see how webgraphs are built.

Pre built webgraphs are available for “World” and “Zeah” when used.

Parameters:

  • Destination Destination point taken from the loaded map.

  • WaitUntilDistance Determines when the method returns once the final point has been clicked. Default value: 0. | WaitUntilDistance=0 waits until the player has reached the final point. | WaitUntilDistance=20 waits until the player is within 20 pixels of the final point.

  • PathRandomness Randomness to add to the path so the absoulte shortest path isn’t always taken. Must be between 0..1

Example:

var Walker: TRSWalker;

Walker.Setup('world');
Walker.WebWalk([4595, 3575]); // Lumbridge

// Or use a location from the webgraph
Walker.WebWalk(WorldWeb.LOCATION_LUMBRIDGE);

TRSWalker.DebugPosition

procedure TRSWalker.DebugPosition();

Debugs the player position in the currently loaded map.

Example:

var
  rsw: TRSWalker;
begin
  rsw.Setup();
  while True do
    rsw.DebugPosition();
end;

TRSWalker.GetTileMS

function TRSWalker.GetTileMSEx(Me, Loc: TPoint; Height:Double=0; Offx,Offy:Double=0): TRectangle;
function TRSWalker.GetTileMS(Loc: TPoint; Height:Double=0; Offx,Offy:Double=0): TRectangle;

Returns a tile on the mainscreen with the help of walker and mm2ms.

Example:

Debug(rsw.GetTileMS(rsw.GetMypos() + [10, 10]));

TRSWalker.MMToWorld

function TRSWalker.MMToWorldEx(me, loc: TPoint; roll: Single = $FFFF): TPoint;
function TRSWalker.MMToWorld(loc: TPoint; roll: Single = $FFFF): TPoint;

Converts a point on the minimap to a walker point.


TRSWalker.MSToWorld

function TRSWalker.MSToWorldEx(Me, Loc: TPoint; Height: Int32 = 0; Accuracy: Double = 0.2): TPoint;
function TRSWalker.MSToWorld(Loc: TPoint; Height: Int32=0; Accuracy:Double=0.2): TPoint;

Converts a point on the mainscreen to a walker point.