feat: add scheduler to Actor and World

This also refactors the `Player.loggedIn` property into an
`Actor.active` property so that I can use it in the generic
`Actor`-level task processing

refactor: move active to base Actor class, create init/destroy methods

feat: add a scheduler to Actor

feat: add a scheduler to World

Author: Jameskmonger

src/engine/world/actor/actor.ts

@@ -13,6 +13,8 @@ import { Animation, Graphic, UpdateFlags } from './update-flags';
 import { Skills } from './skills';
 import { Pathfinding } from './pathfinding';
 import { ActorMetadata } from './metadata';
+import { Task, TaskScheduler } from '@engine/task';
+import { logger } from '@runejs/common';
 
 
 export type ActorType = 'player' | 'npc';
@@ -52,6 +54,13 @@ export abstract class Actor {
     protected randomMovementInterval;
     protected _instance: WorldInstance = null;
 
+    /**
+     * Is this actor currently active? If true, the actor will have its task queue processed.
+     *
+     * This is true for players that are currently logged in, and NPCs that are currently in the world.
+     */
+    protected active: boolean;
+
     /**
      * @deprecated - use new action system instead
      */
@@ -64,6 +73,8 @@ export abstract class Actor {
     private _faceDirection: number;
     private _bonuses: { offensive: OffensiveBonuses, defensive: DefensiveBonuses, skill: SkillBonuses };
 
+    private readonly scheduler = new TaskScheduler();
+
     protected constructor(actorType: ActorType) {
         this.type = actorType;
         this._walkDirection = -1;
@@ -72,6 +83,22 @@ export abstract class Actor {
         this.clearBonuses();
     }
 
+    /**
+     * Adds a task to the actor's scheduler queue. These tasks will be stopped when the become inactive.
+     *
+     * If the task has a stack type of `NEVER`, other tasks in the same group will be cancelled.
+     *
+     * @param task The task to add
+     */
+    public enqueueTask(task: Task): void {
+        if (!this.active) {
+            logger.warn(`Attempted to enqueue task for logged out player`);
+            return;
+        }
+
+        this.scheduler.enqueue(task);
+    }
+
     public clearBonuses(): void {
         this._bonuses = {
             offensive: {
@@ -439,6 +466,28 @@ export abstract class Actor {
         return true;
     }
 
+    /**
+     * Initialise the actor.
+     */
+    protected init() {
+        this.active = true;
+    }
+
+    /**
+     * Destroy this actor.
+     *
+     * This will stop the processing of its action queue.
+     */
+    protected destroy() {
+        this.active = false;
+
+        this.scheduler.clear();
+    }
+
+    protected tick() {
+        this.scheduler.tick();
+    }
+
     public abstract equals(actor: Actor): boolean;
 
     public get position(): Position {
@@ -520,5 +569,4 @@ export abstract class Actor {
     public get bonuses(): { offensive: OffensiveBonuses, defensive: DefensiveBonuses, skill: SkillBonuses } {
         return this._bonuses;
     }
-
 }

src/engine/world/actor/npc.ts

@@ -103,6 +103,8 @@ export class Npc extends Actor {
     }
 
     public async init(): Promise<void> {
+        super.init();
+
         activeWorld.chunkManager.getChunkForWorldPosition(this.position).addNpc(this);
 
         if(this.movementRadius > 0) {
@@ -147,6 +149,7 @@ export class Npc extends Actor {
     }
 
     public kill(respawn: boolean = true): void {
+        this.destroy();
 
         activeWorld.chunkManager.getChunkForWorldPosition(this.position).removeNpc(this);
         clearInterval(this.randomMovementInterval);
@@ -158,6 +161,8 @@ export class Npc extends Actor {
     }
 
     public async tick(): Promise<void> {
+        super.tick();
+
         return new Promise<void>(resolve => {
             this.walkingQueue.process();
             resolve();

src/engine/world/actor/player/player.ts

@@ -130,7 +130,6 @@ export class Player extends Actor {
     private readonly _outgoingPackets: OutboundPacketHandler;
     private readonly _equipment: ItemContainer;
     private _rights: Rights;
-    private loggedIn: boolean;
     private _loginDate: Date;
     private _lastAddress: string;
     private firstTimePlayer: boolean;
@@ -172,7 +171,8 @@ export class Player extends Actor {
     }
 
     public async init(): Promise<void> {
-        this.loggedIn = true;
+        super.init();
+
         this.updateFlags.mapRegionUpdateRequired = true;
         this.updateFlags.appearanceUpdateRequired = true;
 
@@ -277,7 +277,7 @@ export class Player extends Actor {
     }
 
     public logout(): void {
-        if(!this.loggedIn) {
+        if(!this.active) {
             return;
         }
 
@@ -288,6 +288,8 @@ export class Player extends Actor {
         activeWorld.playerTree.remove(this.quadtreeKey);
         this.save();
 
+        this.destroy();
+
         this.actionsCancelled.complete();
         this.walkingQueue.movementEvent.complete();
         this.walkingQueue.movementQueued.complete();
@@ -297,7 +299,6 @@ export class Player extends Actor {
         activeWorld.chunkManager.getChunkForWorldPosition(this.position).removePlayer(this);
         activeWorld.deregisterPlayer(this);
 
-        this.loggedIn = false;
         logger.info(`${this.username} has logged out.`);
     }
 
@@ -371,6 +372,8 @@ export class Player extends Actor {
     }
 
     public async tick(): Promise<void> {
+        super.tick();
+
         return new Promise<void>(resolve => {
             this.walkingQueue.process();
 

src/engine/world/world.ts

@@ -12,6 +12,7 @@ import { loadActionFiles } from '@engine/action';
 import { ChunkManager, ConstructedRegion, getTemplateLocalX, getTemplateLocalY } from '@engine/world/map';
 import { TravelLocations, ExamineCache, parseScenerySpawns } from '@engine/world/config';
 import { loadPlugins } from '@engine/plugins';
+import { TaskScheduler, Task } from '@engine/task';
 
 
 export interface QuadtreeKey {
@@ -39,6 +40,7 @@ export class World {
     public readonly npcTree: Quadtree<QuadtreeKey>;
     public readonly globalInstance = new WorldInstance();
     public readonly tickComplete: Subject<void> = new Subject<void>();
+    private readonly scheduler = new TaskScheduler();
 
     private readonly debugCycleDuration: boolean = process.argv.indexOf('-tickTime') !== -1;
 
@@ -69,6 +71,19 @@ export class World {
         logger.info(`Shutting down world...`);
     }
 
+    /**
+     * Adds a task to the world scheduler queue. These tasks will run forever until they are cancelled.
+     *
+     * @warning Did you mean to add a world task, rather than an Actor task?
+     *
+     * If the task has a stack type of `NEVER`, other tasks in the same group will be cancelled.
+     *
+     * @param task The task to add
+     */
+    public enqueueTask(task: Task): void {
+        this.scheduler.enqueue(task);
+    }
+
     /**
      * Searched for an object by ID at the given position in any of the player's active instances.
      * @param actor The actor to find the object for.
@@ -441,6 +456,9 @@ export class World {
 
     public async worldTick(): Promise<void> {
         const hrStart = Date.now();
+
+        this.scheduler.tick();
+
         const activePlayers: Player[] = this.playerList.filter(player => player !== null);
 
         if(activePlayers.length === 0) {