Working on fixing tilemaps and adding debugging tools for map regions

Author: Tynarus

package-lock.json

@@ -30,7 +30,7 @@
     "dependencies": {
         "@hapi/joi": "^16.1.8",
         "@runejs/core": "^1.3.2",
-        "@runejs/filestore": "^0.13.1",
+        "@runejs/filestore": "^0.13.3",
         "@runejs/login-server": "^1.1.0",
         "@runejs/update-server": "^1.1.1",
         "bcrypt": "^5.0.0",

package.json

@@ -36,16 +36,17 @@ export async function loadPackets(): Promise<Map<number, InboundPacket>> {
     return incomingPackets;
 }
 
-export function handlePacket(player: Player, packetId: number, packetSize: number, buffer: ByteBuffer): void {
+export function handlePacket(player: Player, packetId: number, packetSize: number, buffer: ByteBuffer): boolean {
     const incomingPacket = incomingPackets.get(packetId);
 
     if (!incomingPacket) {
         logger.info(`Unknown packet ${packetId} with size ${packetSize} received.`);
-        return;
+        return false;
     }
 
     new Promise<void>(resolve => {
         incomingPacket.handler(player, { packetId, packetSize, buffer });
         resolve();
     }).catch(error => logger.error(`Error handling inbound packet ${packetId} with size ${packetSize}: ${error}`));
+    return true;
 }

src/game-engine/net/inbound-packets.ts

@@ -83,7 +83,12 @@ export class GameServerConnection implements SocketConnectionHandler {
             this.activeBuffer.copy(packetData, 0, this.activeBuffer.readerIndex, this.activeBuffer.readerIndex + this.activePacketSize);
             this.activeBuffer.readerIndex += this.activePacketSize;
         }
-        handlePacket(this.player, this.activePacketId, this.activePacketSize, packetData);
+
+        if(!handlePacket(this.player, this.activePacketId, this.activePacketSize, packetData)) {
+            logger.error(`Player packets out of sync for ${this.player.username}, resetting packet buffer...`);
+            logger.error(`If you're seeing this, there's a packet that needs fixing. :)`);
+            clearBuffer = true;
+        }
 
         if(clearBuffer) {
             this.activeBuffer = null;

src/game-engine/net/server/game-server.ts

@@ -120,14 +120,7 @@ export class Pathfinding {
         const tiles = [];
         for(let x = lowestX; x < highestX; x++) {
             for(let y = lowestY; y < highestY; y++) {
-                let tile = world.chunkManager.tileMap.get(`${x},${y},${this.actor.position.level}`);
-                if(!tile) {
-                    tile = new Tile(x, y, this.actor.position.level);
-                    tile.bridge = false;
-                    tile.nonWalkable = false;
-                }
-
-                tiles.push(tile);
+                tiles.push(world.chunkManager.getTile(new Position(x, y, this.actor.position.level)));
             }
         }
 
@@ -280,9 +273,9 @@ export class Pathfinding {
 
     public canMoveTo(origin: Position, destination: Position): boolean {
         const destinationChunk: Chunk = world.chunkManager.getChunkForWorldPosition(destination);
-        const tile: Tile = world.chunkManager.tileMap.get(destination.key);
+        const tile: Tile = world.chunkManager.getTile(destination);
 
-        if(tile?.nonWalkable) {
+        if(tile?.blocked) {
             return false;
         }
 
@@ -383,7 +376,7 @@ export class Pathfinding {
     public findLocalCornerChunk(cornerX: number, cornerY: number, origin: Position): { localX: number, localY: number, chunk: Chunk } {
         const cornerPosition: Position = new Position(cornerX, cornerY, origin.level + 1);
         let cornerChunk: Chunk = world.chunkManager.getChunkForWorldPosition(cornerPosition);
-        const tileAbove: Tile = world.chunkManager.tileMap.get(cornerPosition.key);
+        const tileAbove: Tile = world.chunkManager.getTile(cornerPosition);
         if(!tileAbove?.bridge) {
             cornerPosition.level = cornerPosition.level - 1;
             cornerChunk = world.chunkManager.getChunkForWorldPosition(cornerPosition);

src/game-engine/world/actor/pathfinding.ts

@@ -0,0 +1,7 @@
+/**
+ * Options for sending chat messages to a player.
+ */
+export interface SendMessageOptions {
+    dialogue?: boolean;
+    console?: boolean;
+}

src/game-engine/world/actor/player/model.ts

@@ -54,6 +54,7 @@ import { Quest } from '@engine/world/actor/player/quest';
 import { regionChangeActionFactory } from '@engine/world/action/region-change.action';
 import { MusicPlayerMode } from '@plugins/music/music-tab.plugin';
 import { getVarbitMorphIndex } from '@engine/util/varbits';
+import { SendMessageOptions } from '@engine/world/actor/player/model';
 
 
 export const playerOptions: { option: string, index: number, placement: 'TOP' | 'BOTTOM' }[] = [
@@ -571,17 +572,35 @@ export class Player extends Actor {
     }
 
     /**
-     * Sends a message to the player via the chatbox.
+     * Sends a message to the player via the chat-box.
      * @param messages The single message or array of lines to send to the player.
      * @param showDialogue Whether or not to show the message in a "Click to continue" dialogue.
      * @returns A Promise<void> that resolves when the player has clicked the "click to continue" button or
      * after their chat messages have been sent.
      */
-    public async sendMessage(messages: string | string[], showDialogue: boolean = false): Promise<boolean> {
+    public async sendMessage(messages: string | string[], showDialogue?: boolean): Promise<boolean>;
+
+    /**
+     * Sends a message to the player via the chat-box (and the debug console if specified).
+     * @param messages The single message or array of lines to send to the player.
+     * @param options A list of options to provide for sending the message - includes values for `dialogue` and `console`
+     * to enable sending the message as a dialogue message and/or adding the message to the debug console.
+     * @returns A Promise<void> that resolves when the player has clicked the "click to continue" button or
+     * after their chat messages have been sent.
+     */
+    public async sendMessage(messages: string | string[], options: SendMessageOptions): Promise<boolean>;
+
+    public async sendMessage(messages: string | string[], options: boolean | SendMessageOptions): Promise<boolean> {
         if(!Array.isArray(messages)) {
             messages = [ messages ];
         }
 
+        let showDialogue = false;
+        let showInConsole = false;
+        if(typeof options === 'boolean') {
+            showDialogue = true;
+        }
+
         if(!showDialogue) {
             messages.forEach(message => this.outgoingPackets.chatboxMessage(message));
         } else {
@@ -593,6 +612,10 @@ export class Player extends Actor {
                 text => (messages as string[]).join(' ')
             ]);
         }
+
+        if(showInConsole) {
+            messages.forEach(message => this.outgoingPackets.consoleMessage(message));
+        }
     }
 
     /**

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

@@ -364,6 +364,13 @@ export class World {
         return await this.registerNpc(npc);
     }
 
+    /**
+     * Returns the number of remaining open player slots before this world reaches maximum capacity.
+     */
+    public playerSlotsRemaining(): number {
+        return this.playerList.filter(player => !player).length;
+    }
+
     public findPlayer(playerUsername: string): Player {
         playerUsername = playerUsername.toLowerCase();
         return this.playerList?.find(p => p !== null && p.username.toLowerCase() === playerUsername) || null;
@@ -383,6 +390,11 @@ export class World {
         }
     }
 
+    /**
+     * Registers a new player to the game world.
+     * Returns false if the world is full, otherwise returns true when the player has been registered.
+     * @param player The player to register.
+     */
     public registerPlayer(player: Player): boolean {
         if(!player) {
             return false;
@@ -400,6 +412,10 @@ export class World {
         return true;
     }
 
+    /**
+     * Clears the given player's game world slot, signalling that they have disconnected fully.
+     * @param player The player to remove from the world list.
+     */
     public deregisterPlayer(player: Player): void {
         this.playerList[player.worldIndex] = null;
     }

src/game-engine/world/index.ts

@@ -7,27 +7,28 @@ import { LandscapeFile, LandscapeObject, MapFile } from '@runejs/filestore';
 
 export class Tile {
 
-    public settings: number;
-    public nonWalkable: boolean;
-    public bridge: boolean;
+    public settings: number = 0;
+    public blocked: boolean = false;
+    public bridge: boolean = false;
 
     public constructor(public x: number, public y: number, public level: number, settings?: number) {
-        if(settings !== undefined) {
+        if(settings) {
             this.setSettings(settings);
         }
     }
 
     public setSettings(settings: number): void {
         this.settings = settings;
-        this.nonWalkable = (this.settings & 0x1) == 0x1;
-        this.bridge = (this.settings & 0x2) == 0x2;
+        this.blocked = (this.settings & 0x1) === 1;
+        this.bridge = (this.settings & 0x2) === 2;
     }
 
 }
 
 export interface MapRegion {
     tiles: Tile[];
     objects: LandscapeObject[];
+    mapFile: MapFile;
 }
 
 
@@ -37,20 +38,54 @@ export interface MapRegion {
 export class ChunkManager {
 
     public readonly regionMap: Map<string, MapRegion> = new Map<string, MapRegion>();
-    public readonly tileMap: Map<string, Tile> = new Map<string, Tile>();
     private readonly chunkMap: Map<string, Chunk>;
 
     public constructor() {
         this.chunkMap = new Map<string, Chunk>();
     }
 
+    public getTile(position: Position): Tile {
+        const chunkX = position.chunkX + 6;
+        const chunkY = position.chunkY + 6;
+        const mapRegionX = Math.floor(chunkX / 8);
+        const mapRegionY = Math.floor(chunkY / 8);
+        const mapWorldPositionX = (mapRegionX & 0xff) * 64;
+        const mapWorldPositionY = mapRegionY * 64;
+        const regionSettings = this.regionMap.get(`${mapRegionX},${mapRegionY}`)?.mapFile?.tileSettings;
+
+        this.registerMapRegion(mapRegionX, mapRegionY);
+
+        if(!regionSettings) {
+            return new Tile(position.x, position.y, position.level);
+        }
+
+        const tileX = position.x - mapWorldPositionX;
+        const tileY = position.y - mapWorldPositionY;
+        const tileLevel = position.level;
+        let tileSettings = regionSettings[tileLevel][tileX][tileY];
+
+        if(tileLevel < 3) {
+            // Check for a bridge tile above the active tile
+            const tileAboveSettings = regionSettings[tileLevel + 1][tileX][tileY];
+            if((tileAboveSettings & 0x2) === 2) {
+                // Set this tile as walkable if the tile above is a bridge -
+                // This is because the maps are stored with bridges being one level
+                // above where their collision maps need to be
+                tileSettings = 0;
+            }
+        }
+
+        return new Tile(position.x, position.y, tileLevel, tileSettings);
+    }
+
     public registerMapRegion(mapRegionX: number, mapRegionY: number): void {
         const key = `${mapRegionX},${mapRegionY}`;
 
         if(this.regionMap.has(key)) {
             // Map region already registered
             return;
         }
+        this.regionMap.set(key, null);
 
         let mapFile: MapFile;
         let landscapeFile: LandscapeFile;
@@ -66,69 +101,25 @@ export class ChunkManager {
             logger.error(`Error decoding landscape file ${mapRegionX},${mapRegionY}`);
         }
 
-        const region: MapRegion = { tiles: [],
+        const region: MapRegion = { mapFile, tiles: [],
             objects: landscapeFile?.landscapeObjects || [] };
 
-        // Parse map tiles for game engine use
-        for(let level = 0; level < 4; level++) {
-            for(let x = 0; x < 64; x++) {
-                for(let y = 0; y < 64; y++) {
-                    const tileSettings = mapFile?.tileSettings[level][x][y] || 0;
-                    region.tiles.push(new Tile(x, y, level, tileSettings));
-                }
-            }
-        }
-
         this.regionMap.set(key, region);
-        this.registerTiles(region.tiles);
-
-        const worldX = (mapRegionX & 0xff) * 64;
-        const worldY = mapRegionY * 64;
-        this.registerObjects(region.objects, worldX, worldY);
+        this.registerObjects(region.objects, region.tiles || []);
     }
 
-    public registerTiles(tiles: Tile[]): void {
-        if(!tiles || tiles.length === 0) {
-            return;
-        }
-
-        for(const tile of tiles) {
-            const key = `${tile.x},${tile.y},${tile.level}`;
-
-            if(tile.bridge) {
-                // Move this tile down one level if it's a bridge tile
-                const newTile = new Tile(tile.x, tile.y, tile.level - 1, 0);
-                this.tileMap.set(`${newTile.x},${newTile.y},${newTile.level}`, newTile);
-
-                // And also add the bridge tile itself, so that game objects know about it
-                this.tileMap.set(key, tile);
-            } else if(tile.nonWalkable) { // No need to know about walkable tiles for collision maps, only nonwalkable
-                if(!this.tileMap.has(key)) {
-                    // Otherwise add a new tile if it hasn't already been set (IE by a bridge tile above)
-                    this.tileMap.set(key, tile);
-                }
-            }
-        }
-    }
-
-    public registerObjects(objects: LandscapeObject[], mapRegionStartX: number, mapRegionStartY: number): void {
+    public registerObjects(objects: LandscapeObject[], tiles: Tile[]): void {
         if(!objects || objects.length === 0) {
             return;
         }
 
         for(const object of objects) {
             const position = new Position(object.x, object.y, object.level);
 
-            const tile = this.tileMap.get(position.key);
-            if(tile?.bridge) {
-                // Object is on a bridge tile, move it down a level to create proper collision maps
-                position.level -= 1;
-            }
-
-            const tileAbove = this.tileMap.get(`${object.x},${object.y},${object.level + 1}`);
-            if(tileAbove?.bridge) {
-                // Object is below a bridge tile, move it down a level to create proper collision maps
-                position.level -= 1;
+            if(tiles.some(tile => (tile?.settings & 0x2) === 2 &&
+                tile?.x === object.x && tile?.y === object.y && tile?.level >= object.level)) {
+                // Object is on or underneath a bridge tile and needs to move down one level
+                position.move(object.x, object.y, object.level - 1);
             }
 
             this.getChunkForWorldPosition(position).setFilestoreLandscapeObject(object);
@@ -175,6 +166,7 @@ export class ChunkManager {
         } else {
             const chunk = new Chunk(pos);
             this.chunkMap.set(pos.key, chunk);
+            chunk.registerMapRegion();
             return chunk;
         }
     }

src/game-engine/world/map/chunk-manager.ts

@@ -30,13 +30,11 @@ export class Chunk {
         this._npcs = [];
         this._collisionMap = new CollisionMap(position.x, position.y, position.level, { chunk: this });
         this._filestoreLandscapeObjects = new Map<string, LandscapeObject>();
-        this.registerMapRegion();
     }
 
     public registerMapRegion(): void {
-        const mapRegionX = Math.floor(this.position.x / 8);
-        const mapRegionY = Math.floor(this.position.y / 8);
-
+        const mapRegionX = Math.floor((this.position.x + 6) / 8);
+        const mapRegionY = Math.floor((this.position.y + 6) / 8);
         world.chunkManager.registerMapRegion(mapRegionX, mapRegionY);
     }