Adding an implementation of A Star pathfinding.

Author: TheBlackParade

src/plugins/commands/path-command.ts

@@ -0,0 +1,34 @@
+import { ActionType, RunePlugin } from '@server/plugins/plugin';
+import { commandAction } from '@server/world/actor/player/action/input-command-action';
+import { Position } from '@server/world/position';
+
+const action: commandAction = (details) => {
+    const { player, args } = details;
+
+    const x: number = args.x as number;
+    const y: number = args.y as number;
+    const diameter: number = args.diameter as number;
+
+    player.pathfinding.walkTo(new Position(x, y, player.position.level), diameter);
+};
+
+export default new RunePlugin({
+    type: ActionType.COMMAND,
+    commands: [ 'path' ],
+    args: [
+        {
+            name: 'x',
+            type: 'number'
+        },
+        {
+            name: 'y',
+            type: 'number'
+        },
+        {
+            name: 'diameter',
+            type: 'number',
+            defaultValue: 64
+        }
+    ],
+    action
+});

src/world/actor/pathfinding.ts

@@ -3,23 +3,19 @@ import { Actor } from '@server/world/actor/actor';
 import { Position } from '../position';
 import { Chunk } from '@server/world/map/chunk';
 import { Tile } from '@runejs/cache-parser';
+import { Player } from '@server/world/actor/player/player';
 
 class Point {
 
     private _parent: Point = null;
-    private _cost: number;
-    private _heuristic: number;
-    private _depth: number;
+    private _cost: number = 0;
 
-    public constructor(private readonly _x: number, private readonly _y: number) {
-    }
-
-    public compare(point: Point): number {
-        return this._cost - point._cost;
+    public constructor(private readonly _x: number, private readonly _y: number,
+                       public readonly indexX: number, public readonly indexY: number) {
     }
 
     public equals(point: Point): boolean {
-        if(this._cost === point._cost && this._heuristic === point._heuristic && this._depth === point._depth) {
+        if(this._cost === point._cost) {
             if(this._parent === null && point._parent !== null) {
                 return false;
             } else if(this._parent !== null && !this._parent.equals(point._parent)) {
@@ -55,23 +51,6 @@ class Point {
     public set cost(value: number) {
         this._cost = value;
     }
-
-    public get heuristic(): number {
-        return this._heuristic;
-    }
-
-    public set heuristic(value: number) {
-        this._heuristic = value;
-    }
-
-    public get depth(): number {
-        return this._depth;
-    }
-
-    public set depth(value: number) {
-        this._depth = value;
-    }
-
 }
 
 export class Pathfinding {
@@ -84,26 +63,51 @@ export class Pathfinding {
     public constructor(private actor: Actor) {
     }
 
-    public pathTo(destinationX: number, destinationY: number, diameter: number = 32): void {
+    public walkTo(position: Position, pathingDiameter: number = 16): void {
+        const path = this.pathTo(position.x, position.y, pathingDiameter);
+
+        if(!path) {
+            throw new Error(`Unable to find path.`);
+        }
+
+        const walkingQueue = this.actor.walkingQueue;
+
+        if(this.actor instanceof Player) {
+            this.actor.walkingTo = null;
+        }
+
+        walkingQueue.clear();
+        walkingQueue.valid = true;
+
+        for(const point of path) {
+            walkingQueue.add(point.x, point.y);
+        }
+    }
+
+    public pathTo(destinationX: number, destinationY: number, diameter: number = 16): Point[] {
         // @TODO check if destination is too far away
 
-        const currentPos = this.actor.position;
         const radius = Math.floor(diameter / 2);
-        const startX = currentPos.x;
-        const startY = currentPos.y;
-        const pathingStartX = startX - radius;
-        const pathingStartY = startY - radius;
+        const pathingStartX = this.actor.position.x - radius;
+        const pathingStartY = this.actor.position.y - radius;
+
+        if(destinationX < pathingStartX || destinationY < pathingStartY) {
+            throw new Error(`Pathing diameter too small!`);
+        }
+
+        const pointLen = diameter + 1; // + 1 for the center row & column
+        this.points = [];
 
-        this.points = new Array(diameter).fill(new Array(diameter));
+        for(let x = 0; x < pointLen; x++) {
+            this.points.push([]);
 
-        for(let x = 0; x < diameter; x++) {
-            for(let y = 0; y < diameter; y++) {
-                this.points[x][y] = new Point(x + startX, y + startY);
+            for(let y = 0; y < pointLen; y++) {
+                this.points[x].push(new Point(pathingStartX + x, pathingStartY + y, x, y));
             }
         }
 
         // Center point
-        this.openPoints.push(this.points[radius + 1][radius + 1]);
+        this.openPoints.push(this.points[radius][radius]);
 
         while(this.openPoints.length > 0) {
             this.currentPoint = this.calculateBestPoint();
@@ -115,18 +119,137 @@ export class Pathfinding {
             this.openPoints.splice(this.openPoints.indexOf(this.currentPoint), 1);
             this.closedPoints.push(this.currentPoint);
 
-            let x = this.currentPoint.x;
-            let y = this.currentPoint.y;
             let level = this.actor.position.level;
-            let currentPosition = new Position(x, y, level);
+            let { x, y, indexX, indexY } = this.currentPoint;
+
+            // West
+            if(indexX > 0 && this.canPathNSEW(new Position(x - 1, y, level), 0x1280108)) {
+                this.calculateCost(this.points[indexX - 1][indexY]);
+            }
+
+            // East
+            if(indexX < pointLen - 1 && this.canPathNSEW(new Position(x + 1, y, level), 0x1280180)) {
+                this.calculateCost(this.points[indexX + 1][indexY]);
+            }
+
+            // South
+            if(indexY > 0 && this.canPathNSEW(new Position(x, y - 1, level), 0x1280102)) {
+                this.calculateCost(this.points[indexX][indexY - 1]);
+            }
+
+            // North
+            if(indexY < pointLen - 1 && this.canPathNSEW(new Position(x, y + 1, level), 0x1280120)) {
+                this.calculateCost(this.points[indexX][indexY + 1]);
+            }
+
+            // South-West
+            if(indexX > 0 && indexY > 0) {
+                if(this.canPathDiagonally(this.currentPoint.x, this.currentPoint.y, new Position(x - 1, y - 1, level), -1, -1,
+                    0x128010e, 0x1280108, 0x1280102)) {
+                    this.calculateCost(this.points[indexX - 1][indexY - 1]);
+                }
+            }
+
+            // South-East
+            if(indexX < pointLen - 1 && indexY > 0) {
+                if(this.canPathDiagonally(this.currentPoint.x, this.currentPoint.y, new Position(x + 1, y - 1, level), 1, -1,
+                    0x1280183, 0x1280180, 0x1280102)) {
+                    this.calculateCost(this.points[indexX + 1][indexY - 1]);
+                }
+            }
+
+            // North-West
+            if(indexX > 0 && indexY < pointLen - 1) {
+                if(this.canPathDiagonally(this.currentPoint.x, this.currentPoint.y, new Position(x - 1, y + 1, level), -1, 1,
+                    0x1280138, 0x1280108, 0x1280120)) {
+                    this.calculateCost(this.points[indexX - 1][indexY + 1]);
+                }
+            }
+
+            // North-East
+            if(indexX < pointLen - 1 && indexY < pointLen - 1) {
+                if(this.canPathDiagonally(this.currentPoint.x, this.currentPoint.y, new Position(x + 1, y + 1, level), 1, 1,
+                    0x12801e0, 0x1280180, 0x1280120)) {
+                    this.calculateCost(this.points[indexX + 1][indexY + 1]);
+                }
+            }
+        }
+
+        const destinationPoint = this.points[destinationX - pathingStartX][destinationY - pathingStartY];
+
+        if(destinationPoint === null || destinationPoint.parent === null) {
+            return null;
+        }
+
+        // build path
+        const path: Point[] = [];
+        let point = destinationPoint;
+
+        while(!point.equals(this.points[radius][radius])) {
+            path.push(point);
+            point = point.parent;
+
+            if(point === null) {
+                return null;
+            }
+        }
+
+        return path.reverse();
+    }
+
+    private calculateCost(point: Point): void {
+        const differenceX = this.currentPoint.x - point.x;
+        const differenceY = this.currentPoint.y - point.y;
+        const nextStepCost = this.currentPoint.cost + ((Math.abs(differenceX) + Math.abs(differenceY)) * 10);
+
+        if(nextStepCost < point.cost) {
+            this.openPoints.splice(this.openPoints.indexOf(point));
+            this.closedPoints.splice(this.closedPoints.indexOf(point));
+        }
+
+        if(this.openPoints.indexOf(point) === -1 && this.closedPoints.indexOf(point) === -1) {
+            point.parent = this.currentPoint;
+            point.cost = nextStepCost;
+            this.openPoints.push(point);
+        }
+    }
+
+    private calculateBestPoint(): Point {
+        let bestPoint: Point = null;
+
+        for(const point of this.openPoints) {
+            if(bestPoint === null) {
+                bestPoint = point;
+                continue;
+            }
 
-            let testPosition = new Position(x - 1, y, level);
-            if(this.canMoveTo(currentPosition, testPosition)) {
-                const point = this.points[x - 1][y];
+            if(point.cost < bestPoint.cost) {
+                bestPoint = point;
             }
         }
+
+        return bestPoint;
     }
 
+    private canPathNSEW(position: Position, i: number): boolean {
+        const chunk = world.chunkManager.getChunkForWorldPosition(position);
+        const destinationAdjacency: number[][] = chunk.collisionMap.adjacency;
+        const destinationLocalX: number = position.x - chunk.collisionMap.insetX;
+        const destinationLocalY: number = position.y - chunk.collisionMap.insetY;
+        return Pathfinding.canMoveNSEW(destinationAdjacency, destinationLocalX, destinationLocalY, i);
+    }
+
+    private canPathDiagonally(originX: number, originY: number, position: Position, offsetX: number, offsetY: number,
+                              destMask: number, cornerMask1: number, cornerMask2: number): boolean {
+        const chunk = world.chunkManager.getChunkForWorldPosition(position);
+        const destinationAdjacency: number[][] = chunk.collisionMap.adjacency;
+        const destinationLocalX: number = position.x - chunk.collisionMap.insetX;
+        const destinationLocalY: number = position.y - chunk.collisionMap.insetY;
+        return Pathfinding.canMoveDiagonally(position, destinationAdjacency, destinationLocalX, destinationLocalY,
+            originX, originY, offsetX, offsetY, destMask, cornerMask1, cornerMask2);
+    }
+
+
     public canMoveTo(origin: Position, destination: Position): boolean {
         const destinationChunk: Chunk = world.chunkManager.getChunkForWorldPosition(destination);
         const tile: Tile = destinationChunk.getTile(destination);
@@ -143,28 +266,28 @@ export class Pathfinding {
 
         // West
         if(destination.x < initialX && destination.y == initialY) {
-            if((destinationAdjacency[destinationLocalX][destinationLocalY] & 0x1280108) != 0) {
+            if(!Pathfinding.canMoveNSEW(destinationAdjacency, destinationLocalX, destinationLocalY, 0x1280108)) {
                 return false;
             }
         }
 
         // East
         if(destination.x > initialX && destination.y == initialY) {
-            if((destinationAdjacency[destinationLocalX][destinationLocalY] & 0x1280180) != 0) {
+            if(!Pathfinding.canMoveNSEW(destinationAdjacency, destinationLocalX, destinationLocalY, 0x1280180)) {
                 return false;
             }
         }
 
         // South
         if(destination.y < initialY && destination.x == initialX) {
-            if((destinationAdjacency[destinationLocalX][destinationLocalY] & 0x1280102) != 0) {
+            if(!Pathfinding.canMoveNSEW(destinationAdjacency, destinationLocalX, destinationLocalY, 0x1280102)) {
                 return false;
             }
         }
 
         // North
         if(destination.y > initialY && destination.x == initialX) {
-            if((destinationAdjacency[destinationLocalX][destinationLocalY] & 0x1280120) != 0) {
+            if(!Pathfinding.canMoveNSEW(destinationAdjacency, destinationLocalX, destinationLocalY, 0x1280120)) {
                 return false;
             }
         }
@@ -204,6 +327,10 @@ export class Pathfinding {
         return true;
     }
 
+    public static canMoveNSEW(destinationAdjacency: number[][], destinationLocalX: number, destinationLocalY: number, i: number): boolean {
+        return (destinationAdjacency[destinationLocalX][destinationLocalY] & i) === 0;
+    }
+
     public static canMoveDiagonally(origin: Position, destinationAdjacency: number[][], destinationLocalX: number, destinationLocalY: number,
                                       initialX: number, initialY: number, offsetX: number, offsetY: number, destMask: number, cornerMask1: number, cornerMask2: number): boolean {
         const cornerX1: number = initialX + offsetX;
@@ -232,21 +359,4 @@ export class Pathfinding {
         return { localX, localY, chunk: cornerChunk };
     }
 
-    private calculateBestPoint(): Point {
-        let bestPoint: Point = null;
-
-        for(const point of this.openPoints) {
-            if(bestPoint === null) {
-                bestPoint = point;
-                continue;
-            }
-
-            if(point.cost < bestPoint.cost) {
-                bestPoint = point;
-            }
-        }
-
-        return bestPoint;
-    }
-
 }

src/world/actor/player/action/input-command-action.ts

@@ -1,5 +1,6 @@
 import { Player } from '../player';
 import { ActionPlugin } from '@server/plugins/plugin';
+import { logger } from '@runejs/logger/dist/logger';
 
 /**
  * The definition for a command action function.
@@ -115,6 +116,7 @@ export const inputCommandAction = (player: Player, command: string, inputArgs: s
             }
         } catch(commandError) {
             player.outgoingPackets.chatboxMessage(`Command error: ${commandError}`);
+            logger.error(commandError);
         }
     });
 };