Adding new ConstructedChunk abstract class within the API and cleaning...

...up region naming.

Author: Tynarus

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

@@ -12,9 +12,9 @@ import { stringToLong } from '@engine/util/strings';
 import { LandscapeObject } from '@runejs/filestore';
 import { xteaRegions } from '@engine/config';
 import { world } from '@engine/game-server';
-import { ConstructedMap } from '@engine/world/map/region';
-import { map } from 'rxjs/operators';
-import { Room } from '@plugins/skills/construction/con-house';
+import { ConstructedChunk, ConstructedRegion } from '@engine/world/map/region';
+
+
 
 /**
  * A helper class for sending various network packets back to the game client.
@@ -567,7 +567,7 @@ export class OutboundPackets {
         this.queue(packet);
     }
 
-    public constructMapRegion(mapData: ConstructedMap): void {
+    public constructMapRegion(mapData: ConstructedRegion): void {
         const packet = new Packet(23, PacketType.DYNAMIC_LARGE);
 
         packet.put(this.player.position.chunkLocalY, 'short');
@@ -578,23 +578,23 @@ export class OutboundPackets {
 
         packet.openBitBuffer();
 
-        const mapWorldX = mapData.position.x;
-        const mapWorldY = mapData.position.y;
+        const mapWorldX = mapData.renderPosition.x;
+        const mapWorldY = mapData.renderPosition.y;
 
         const topCornerMapChunk = world.chunkManager.getChunkForWorldPosition(new Position(mapWorldX, mapWorldY, this.player.position.level));
         const playerChunk = world.chunkManager.getChunkForWorldPosition(this.player.position);
 
         const offsetX = playerChunk.position.x - (topCornerMapChunk.position.x - 2);
         const offsetY = playerChunk.position.y - (topCornerMapChunk.position.y - 2);
 
-        mapData.centerOffsetX = offsetX - 6; // 6 === center
-        mapData.centerOffsetY = offsetY - 6; // 6 === center
+        mapData.drawOffsetX = offsetX - 6; // 6 === center
+        mapData.drawOffsetY = offsetY - 6; // 6 === center
 
         for(let level = 0; level < 4; level++) {
             for(let x = 0; x < 13; x++) {
                 for(let y = 0; y < 13; y++) {
-                    let mapTileOffsetX = x + mapData.centerOffsetX;
-                    let mapTileOffsetY = y + mapData.centerOffsetY;
+                    let mapTileOffsetX = x + mapData.drawOffsetX;
+                    let mapTileOffsetY = y + mapData.drawOffsetY;
                     if(mapTileOffsetX < 0) {
                         mapTileOffsetX = 0;
                     }
@@ -608,14 +608,15 @@ export class OutboundPackets {
                         mapTileOffsetY = 12;
                     }
 
-                    const room: Room | null = mapData.rooms[level][x][y];
-                    packet.putBits(1, room === null ? 0 : 1)
-                    if (room !== null) {
-                        packet.putBits(2, room.position.level & 0x3)
-                        packet.putBits(10, room.position.x / 8)
-                        packet.putBits(11, room.position.y / 8)
-                        packet.putBits(2, room.rotation)
-                        packet.putBits(1, 0) //unused
+                    const constructedChunk: ConstructedChunk | null = mapData.chunks[level][x][y];
+                    packet.putBits(1, constructedChunk === null ? 0 : 1)
+                    if (constructedChunk !== null) {
+                        const { templatePosition, rotation } = constructedChunk;
+                        packet.putBits(2, templatePosition?.level & 0x3);
+                        packet.putBits(10, templatePosition?.x / 8);
+                        packet.putBits(11, templatePosition?.y / 8);
+                        packet.putBits(2, rotation || 0);
+                        packet.putBits(1, 0); // unused
                     }
                 }
             }

src/game-engine/world/action/region-change.action.ts

@@ -78,7 +78,7 @@ export const regionChangeActionFactory = (player: Player,
     };
 
     if(originalMapRegionId !== currentMapRegionId) {
-        regionTypes.push('map');
+        regionTypes.push('region');
     }
 
     if(!Coords.equals(originalChunkCoords, currentChunkCoords)) {

src/game-engine/world/index.ts

@@ -19,7 +19,7 @@ import { loadActionFiles } from '@engine/world/action';
 import { LandscapeObject } from '@runejs/filestore';
 import { lastValueFrom, Subject } from 'rxjs';
 import { take } from 'rxjs/operators';
-import { ConstructedMap, getRotatedObjectX, getRotatedObjectY } from '@engine/world/map/region';
+import { ConstructedRegion, getRotatedLocalX, getRotatedLocalY } from '@engine/world/map/region';
 import { Chunk } from '@engine/world/map/chunk';
 
 
@@ -149,33 +149,33 @@ export class World {
      * @param objectPosition The position of the copied object to find the template of.
      */
     public findCustomMapObject(actor: Actor, objectId: number, objectPosition: Position): LandscapeObject | null {
-        const map = actor?.metadata?.customMap as ConstructedMap || null;
+        const map = actor?.metadata?.customMap as ConstructedRegion || null;
 
         if(!map) {
             return null;
         }
 
         const objectChunk = this.chunkManager.getChunkForWorldPosition(objectPosition);
-        const mapChunk = world.chunkManager.getChunkForWorldPosition(map.position);
+        const mapChunk = world.chunkManager.getChunkForWorldPosition(map.renderPosition);
 
         const chunkIndexX = objectChunk.position.x - (mapChunk.position.x - 2);
         const chunkIndexY = objectChunk.position.y - (mapChunk.position.y - 2);
 
-        const objectTile = map.tileData[actor.position.level][chunkIndexX][chunkIndexY];
+        const objectTile = map.chunks[actor.position.level][chunkIndexX][chunkIndexY];
 
-        const tileX = objectTile >> 14 & 0x3ff;
-        const tileY = objectTile >> 3 & 0x7ff;
-        const tileOrientation = (0x6 & objectTile) >> 1;
+        const tileX = objectTile.templatePosition.x;
+        const tileY = objectTile.templatePosition.y;
+        const tileOrientation = objectTile.rotation;
 
         const objectLocalX = objectPosition.x - (objectChunk.position.x + 6) * 8;
         const objectLocalY = objectPosition.y - (objectChunk.position.y + 6) * 8;
 
-        const mapTemplateWorldX = tileX * 8;
-        const mapTemplateWorldY = tileY * 8;
+        const mapTemplateWorldX = tileX;
+        const mapTemplateWorldY = tileY;
         const mapTemplateChunk = world.chunkManager.getChunkForWorldPosition(new Position(mapTemplateWorldX, mapTemplateWorldY, objectPosition.level));
 
-        const templateObjectPosition = new Position(mapTemplateWorldX + getRotatedObjectX(tileOrientation, objectLocalX, objectLocalY),
-            mapTemplateWorldY + getRotatedObjectY(tileOrientation, objectLocalX, objectLocalY), objectPosition.level);
+        const templateObjectPosition = new Position(mapTemplateWorldX + getRotatedLocalX(tileOrientation, objectLocalX, objectLocalY),
+            mapTemplateWorldY + getRotatedLocalY(tileOrientation, objectLocalX, objectLocalY), objectPosition.level);
         const realObject = mapTemplateChunk.getFilestoreLandscapeObject(objectId, templateObjectPosition);
 
         return realObject || null;

src/game-engine/world/map/region.ts

@@ -6,7 +6,8 @@
 import { Position } from '@engine/world/position';
 import { Room } from '@plugins/skills/construction/con-house';
 
-export type RegionType = 'map' | 'chunk';
+
+export type RegionType = 'mapfile' | 'region' | 'chunk';
 
 /**
  * A type for defining region tile sizes.
@@ -19,20 +20,37 @@ export type RegionSizeMap = {
  * A map of region types to tile sizes.
  */
 export const regionSizes: RegionSizeMap = {
-    'map': 64,
+    'mapfile': 104,
+    'region': 64,
     'chunk': 8
 };
 
 
-export interface ConstructedMap {
-    position: Position;
-    rooms: Room[][][];
-    centerOffsetX?: number;
-    centerOffsetY?: number;
+export abstract class ConstructedChunk {
+
+    public rotation: number;
+
+    protected constructor(rotation: number = 0) {
+        this.rotation = rotation;
+    }
+
+    public abstract getTemplatePosition(): Position;
+
+    public get templatePosition(): Position {
+        return this.getTemplatePosition();
+    }
+
+}
+
+export interface ConstructedRegion {
+    renderPosition: Position;
+    chunks: ConstructedChunk[][][];
+    drawOffsetX?: number;
+    drawOffsetY?: number;
 }
 
 
-export const getRotatedObjectX = (orientation: number, localX: number, localY: number): number => {
+export const getRotatedLocalX = (orientation: number, localX: number, localY: number): number => {
     if(orientation === 0) {
         return localX;
     }
@@ -53,7 +71,7 @@ export const getRotatedObjectX = (orientation: number, localX: number, localY: n
     return localY;
 };
 
-export const getRotatedObjectY = (orientation: number, localX: number, localY: number): number => {
+export const getRotatedLocalY = (orientation: number, localX: number, localY: number): number => {
     if(orientation === 0) {
         return localY;
     }

src/plugins/music/music-regions.plugin.ts

@@ -40,7 +40,7 @@ export default {
     pluginId: 'rs:music_regions',
     hooks: [{
         type: 'region_change',
-        regionType: 'map',
+        regionType: 'region',
         handler: regionChangedHandler
     }, {
         type: 'player_init',

src/plugins/skills/construction/con-house.ts

@@ -1,5 +1,6 @@
 import { MAP_SIZE, roomTemplates, RoomType } from '@plugins/skills/construction/con-constants';
 import { Position } from '@engine/world/position';
+import { ConstructedChunk } from '@engine/world/map/region';
 
 
 export class House {
@@ -23,18 +24,16 @@ export class House {
 }
 
 
-export class Room {
+export class Room extends ConstructedChunk {
 
     public readonly type: RoomType;
 
-    public rotation: number;
-
-    public constructor(type: RoomType, orientation: number = 0) {
+    public constructor(type: RoomType, rotation: number = 0) {
+        super(rotation);
         this.type = type;
-        this.rotation = orientation;
     }
 
-    public get position(): Position {
+    public getTemplatePosition(): Position {
         return roomTemplates[this.type];
     }
 

src/plugins/skills/construction/construction.plugin.ts

@@ -2,7 +2,7 @@ import { Position } from '@engine/world/position';
 import { Player } from '@engine/world/actor/player/player';
 import { PlayerCommandAction } from '@engine/world/action/player-command.action';
 import { PlayerInitAction } from '@engine/world/action/player-init.action';
-import { ConstructedMap } from '@engine/world/map/region';
+import { ConstructedRegion } from '@engine/world/map/region';
 
 import { instance1, instance1Max, instance1PohSpawn, instance2, instance2Max, MAP_SIZE } from './con-constants';
 import { House, Room } from './con-house';
@@ -49,9 +49,9 @@ const openHouse = (player: Player): void => {
     player.teleport(playerSpawn);
 
     player.metadata.customMap = {
-        position: pohPosition,
-        rooms: house.rooms
-    } as ConstructedMap;
+        renderPosition: pohPosition,
+        chunks: house.rooms
+    } as ConstructedRegion;
 
     player.sendMessage(`Welcome home.`);
 };