wip

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) {
@@ -96,46 +127,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';
+import { Pathfinding } from '@server/world/actor/pathfinding';
 
 async function pathTo(player: Player, otherPlayer: Player): Promise<boolean> {
     const distance = Math.floor(otherPlayer.position.distanceBetween(player.position));
@@ -15,23 +15,35 @@ async function pathTo(player: Player, otherPlayer: Player): Promise<boolean> {
         return Promise.resolve(false);
     }
 
-    try {
-        await player.pathfinding.walkTo(otherPlayer.position, {
-            pathingDiameter: distance + 6,
-            ignoreDestination: true
+    //try {
+        let ignoreDestination = true;
+        let desiredPosition = otherPlayer.position;
+        /*if(otherPlayer.lastMovementPosition && otherPlayer.lastMovementPosition.distanceBetween(otherPlayer.position) < 1) {
+            desiredPosition = otherPlayer.lastMovementPosition;
+            ignoreDestination = false;
+        }*/
+
+        player.pathfinding.stopped = true;
+        player.pathfinding = new Pathfinding(player);
+        await player.pathfinding.walkTo(desiredPosition, {
+            pathingSearchRadius: distance + 2,
+            ignoreDestination
         });
 
         return Promise.resolve(true);
-    } catch(error) {
+    /*} catch(e) {
         player.clearFaceActor();
-        logger.warn(error.message);
-    }
+        player.actionsCancelled.next();
+        logger.error('Pathing error:');
+        logger.error(e && e.message ? e.message : 'Error while finding path.');
+    }*/
 }
 
 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();