# 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: ```pascal 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 ```pascal procedure TRSWalker.InternalSetup(); ``` Internal walker method automatically called by Walker.Setup(). You probably will never need to call this directly. - - - ## Walker.Free ```pascal 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 ```pascal 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: ```pascal //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 ```pascal 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.ScaledSearch ```pascal 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 ```pascal 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 ```pascal function TRSWalker.GetMyPos(): TPoint; ``` Returns the players current position on the loaded map. Example:: ```pascal WriteLn(Walker.GetMyPos()); // Check to see the match percentage if needed WriteLn(Walker.Similarity); ``` - - - ## Walker.WorldToMM ```pascal 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: ```pascal 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 ```pascal 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 ```pascal 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 ```pascal 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 ```pascal 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() ```pascal 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 ```pascal 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 ```pascal 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 ```pascal 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 ```pascal 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: ```pascal Walker.WalkPath([[100,100],[120,120],[140,140],[160,160],[180,180]]); ``` - - - ## TRSWalker.WalkBlind ```pascal 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: ```pascal Walker.WalkBlind([300, 300]); ``` - - - ## TRSWalker.WebWalk ```pascal 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: ```pascal 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 ```pascal procedure TRSWalker.DebugPosition(); ``` Debugs the player position in the currently loaded map. Example: ```pascal var rsw: TRSWalker; begin rsw.Setup(); while True do rsw.DebugPosition(); end; ``` - - - ## TRSWalker.GetTileMS ```pascal 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: ```pascal Debug(rsw.GetTileMS(rsw.GetMypos() + [10, 10])); ``` - - - ## TRSWalker.MMToWorld ```pascal 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 ```pascal 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.