Merge pull request #179 from rune-js/feature/combat

Fixing player following

Author: TheBlackParade

package.json

@@ -4,8 +4,8 @@
     "description": "",
     "main": "src/game-server.ts",
     "scripts": {
-        "start": "concurrently \"npm run build:watch\" \"node --max-old-space-size=4096 dist/main.js\"",
-        "start:server": "concurrently \"npm run build\" \"node --max-old-space-size=4096 dist/main.js\"",
+        "start": "npm run build && concurrently \"npm run build:watch\" \"node --max-old-space-size=4096 dist/main.js\"",
+        "start:server": "npm run build && node --max-old-space-size=4096 dist/main.js",
         "lint": "tslint --project tsconfig.json",
         "fake-players": "concurrently \"npm run build:watch\" \"node --max-old-space-size=4096 dist/main.js -fakePlayers\"",
         "fake-players-tick": "concurrently \"npm run build:watch\" \"node --max-old-space-size=4096 dist/main.js -fakePlayers -tickTime\"",

src/error-handling.ts

@@ -35,7 +35,7 @@ export function initErrorHandling(): void {
         }
 
         logger.error(`Unhandled promise rejection from ${promise}, reason: ${error}`);
-        if(error.hasOwnProperty('stack')) {
+        if(error && error.hasOwnProperty('stack')) {
             logger.error((error as any).stack);
         }
     });

src/game-server.ts

@@ -77,7 +77,38 @@ function generateCrcTable(): void {
     crcTable = buffer;
 }
 
-export function runGameServer(): void {
+function openServer(): void {
+    net.createServer(socket => {
+        socket.setNoDelay(true);
+        socket.setKeepAlive(true);
+        socket.setTimeout(30000);
+
+        let clientConnection = new ClientConnection(socket);
+
+        socket.on('data', data => {
+            if(clientConnection) {
+                clientConnection.parseIncomingData(new ByteBuffer(data));
+            }
+        });
+
+        socket.on('close', () => {
+            if(clientConnection) {
+                clientConnection.connectionDestroyed();
+                clientConnection = null;
+            }
+        });
+
+        socket.on('error', error => {
+            logger.error('Socket destroyed due to connection error.');
+            logger.error(error.message);
+            socket.destroy();
+        });
+    }).listen(serverConfig.port, serverConfig.host);
+
+    logger.info(`Game server listening on port ${ serverConfig.port }.`);
+}
+
+export async function runGameServer(): Promise<void> {
     serverConfig = parseServerConfig();
 
     if(!serverConfig) {
@@ -97,46 +128,15 @@ export function runGameServer(): void {
     // delete cache.indices;
 
     world = new World();
-    injectPlugins().then(() => {
-        world.init();
-
-        // delete cache.mapData;
-
-        if(process.argv.indexOf('-fakePlayers') !== -1) {
-            world.generateFakePlayers();
-        }
+    await injectPlugins();
 
-        net.createServer(socket => {
-            logger.info('Socket opened');
+    world.init(); // .then(() => delete cache.mapData);
 
-            socket.setNoDelay(true);
-            socket.setKeepAlive(true);
-            socket.setTimeout(30000);
-
-            let clientConnection = new ClientConnection(socket);
-
-            socket.on('data', data => {
-                if(clientConnection) {
-                    clientConnection.parseIncomingData(new ByteBuffer(data));
-                }
-            });
-
-            socket.on('close', () => {
-                if(clientConnection) {
-                    clientConnection.connectionDestroyed();
-                    clientConnection = null;
-                }
-            });
-
-            socket.on('error', error => {
-                logger.error(error.message);
-                socket.destroy();
-                logger.error('Socket destroyed due to connection error.');
-            });
-        }).listen(serverConfig.port, serverConfig.host);
+    if(process.argv.indexOf('-fakePlayers') !== -1) {
+        world.generateFakePlayers();
+    }
 
-        logger.info(`Game server listening on port ${serverConfig.port}.`);
-    });
+    openServer();
 
     const watcher = watch('dist/plugins/');
     watcher.on('ready', () => {

src/plugins/combat/combat.js

@@ -1,14 +1,25 @@
-import { ActionType, DamageType, schedule } from '../rune.js';
+import { DamageType } from '../../world/actor/update-flags';
+import { ActionType } from '../plugin';
+import { loopingAction, walkToAction } from '../../world/actor/player/action/action';
+import { schedule } from '../../task/task';
 
+// Work-in-progress...
 const action = async details => {
     const { player, npc } = details;
 
-    npc.updateFlags.addDamage(1, DamageType.DAMAGE, 4, 5);
-    npc.say(`Ow!`);
+    const loop = loopingAction({ ticks: 5, player, npc });
+    const loopSub = loop.event.subscribe(async () => {
+        if(player.position.distanceBetween(npc.position) > 1) {
+            walkToAction(player, npc.position);
+            return;
+        }
 
-    await schedule(4);
+        npc.updateFlags.addDamage(1, DamageType.DAMAGE, 4, 5);
 
-    player.updateFlags.addDamage(1, DamageType.DAMAGE, 4, 5);
+        await schedule(3);
+
+        player.updateFlags.addDamage(1, DamageType.DAMAGE, 4, 5);
+    });
 };
 
 module.exports = {

src/plugins/commands/path-command.ts

@@ -9,7 +9,7 @@ const action: commandAction = (details) => {
     const y: number = args.y as number;
     const pathingDiameter: number = args.diameter as number;
 
-    player.pathfinding.walkTo(new Position(x, y, player.position.level), { pathingDiameter });
+    player.pathfinding.walkTo(new Position(x, y, player.position.level), { pathingSearchRadius: pathingDiameter });
 };
 
 export default new RunePlugin({

src/plugins/areas/lumbridge/hans.js renamed to src/plugins/npcs/lumbridge/hans.js

@@ -1,7 +1,7 @@
 import { ActionType, RunePlugin } from '@server/plugins/plugin';
 import { playerAction } from '@server/world/actor/player/action/player-action';
 import { Player } from '@server/world/actor/player/player';
-import { logger } from '@runejs/logger';
+
 
 async function pathTo(player: Player, otherPlayer: Player): Promise<boolean> {
     const distance = Math.floor(otherPlayer.position.distanceBetween(player.position));
@@ -11,27 +11,26 @@ async function pathTo(player: Player, otherPlayer: Player): Promise<boolean> {
         throw new Error(`Distance too great!`);
     }
 
-    if(distance <= 1) {
-        return Promise.resolve(false);
+    let ignoreDestination = true;
+    let desiredPosition = otherPlayer.position;
+    if(otherPlayer.lastMovementPosition/* && otherPlayer.lastMovementPosition.distanceBetween(otherPlayer.position) < 1*/) {
+        desiredPosition = otherPlayer.lastMovementPosition;
+        ignoreDestination = false;
     }
 
-    try {
-        await player.pathfinding.walkTo(otherPlayer.position, {
-            pathingDiameter: distance + 6,
-            ignoreDestination: true
-        });
+    await player.pathfinding.walkTo(desiredPosition, {
+        pathingSearchRadius: distance + 2,
+        ignoreDestination
+    });
 
-        return Promise.resolve(true);
-    } catch(error) {
-        player.clearFaceActor();
-        logger.warn(error.message);
-    }
+    return Promise.resolve(true);
 }
 
 export const action: playerAction = (details) => {
     const { player, otherPlayer } = details;
 
     player.face(otherPlayer, false, false, false);
+
     pathTo(player, otherPlayer);
 
     const subscription = otherPlayer.movementEvent.subscribe(() => {

src/plugins/player/follow-player-plugin.ts

@@ -28,7 +28,8 @@ export abstract class Actor {
     private _busy: boolean;
     public readonly metadata: { [key: string]: any } = {};
     private _combatActions: CombatAction[];
-    public readonly pathfinding: Pathfinding;
+    public pathfinding: Pathfinding;
+    public lastMovementPosition: Position;
 
     protected constructor() {
         this.updateFlags = new UpdateFlags();