Implementing object option 4&5 packets +fixing custom map object actions

Author: Tynarus

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

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

src/game-engine/net/inbound-packets/object-interaction-packet.js renamed to src/game-engine/net/inbound-packets/object-interaction-packet.ts

@@ -1,49 +1,82 @@
-import { Position } from '../../world/position';
-import { filestore, world } from '../../game-server';
 import { logger } from '@runejs/core';
-import { getVarbitMorphIndex } from "../../util/varbits";
-const option1 = packet => {
+
+import { filestore, world } from '@engine/game-server';
+import { Position } from '@engine/world/position';
+import { getVarbitMorphIndex } from '@engine/util/varbits';
+import { PacketData } from '@engine/net/inbound-packets';
+import { Player, Rights } from '@engine/world/actor/player/player';
+
+
+interface ObjectInteractionData {
+    objectId: number;
+    x: number;
+    y: number;
+}
+
+type objectInteractionPacket = (packet: PacketData) => ObjectInteractionData;
+
+
+const option1: objectInteractionPacket = packet => {
     const { buffer } = packet;
     const objectId = buffer.get('short', 'u');
     const y = buffer.get('short', 'u');
     const x = buffer.get('short', 'u', 'le');
     return { objectId, x, y };
 };
 
-const option2 = packet => {
+const option2: objectInteractionPacket = packet => {
     const { buffer } = packet;
     const x = buffer.get('short', 'u', 'le');
     const y = buffer.get('short', 'u', 'le');
     const objectId = buffer.get('short', 'u', 'le');
     return { objectId, x, y };
 };
 
-const option3 = packet => {
+const option3: objectInteractionPacket = packet => {
     const { buffer } = packet;
     const y = buffer.get('short', 'u');
     const objectId = buffer.get('short', 'u');
     const x = buffer.get('short', 'u');
     return { objectId, x, y };
 };
 
+const option4: objectInteractionPacket = packet => {
+    const { buffer } = packet;
+    const x = buffer.get('short', 'u', 'le');
+    const objectId = buffer.get('short', 'u', 'le');
+    const y = buffer.get('short', 'u', 'le');
+    return { objectId, x, y };
+};
+
+const option5: objectInteractionPacket = packet => {
+    const { buffer } = packet;
+    const objectId = buffer.get('short', 'u');
+    const y = buffer.get('short', 'u', 'le');
+    const x = buffer.get('short', 'u', 'le');
+    return { objectId, x, y };
+};
+
+
+const objectInteractionPackets: { [key: number]: { packetDef: objectInteractionPacket, index: number } } = {
+    30:  { packetDef: option1, index: 0 },
+    164: { packetDef: option2, index: 1 },
+    183: { packetDef: option3, index: 2 },
+    229: { packetDef: option4, index: 3 },
+    62:  { packetDef: option5, index: 4 },
+};
 
 
-const objectInteractionPacket = (player, packet) => {
+const objectInteractionPacket = (player: Player, packet: PacketData) => {
     const { packetId } = packet;
 
-    const options = {
-        30: { packetDef: option1, index: 0 },
-        164: { packetDef: option2, index: 1 },
-        183: { packetDef: option3, index: 2 },
-        /*136: { packetDef: option4, index: 3 },
-        55:  { packetDef: option5, index: 4 },*/
-    };
-
-    const { objectId, x, y } = options[packetId].packetDef(packet);
+    const { objectId, x, y } = objectInteractionPackets[packetId].packetDef(packet);
     const level = player.position.level;
     const objectPosition = new Position(x, y, level);
     let { object: landscapeObject, cacheOriginal } = world.findObjectAtLocation(player, objectId, objectPosition);
     if(!landscapeObject) {
+        if(player.rights === Rights.ADMIN) {
+            player.sendMessage(`Custom object ${objectId} @[${objectPosition.key}]`);
+        }
         return;
     }
 
@@ -52,9 +85,8 @@ const objectInteractionPacket = (player, packet) => {
         let morphIndex = -1;
         if(objectConfig.varbitId === -1) {
             if(objectConfig.configId !== -1) {
-                const configValue = player.metadata['configs'] && player.metadata['configs'][objectConfig.configId] ? player.metadata['configs'][objectConfig.configId] : 0;
-                morphIndex = configValue;
-
+                morphIndex = player.metadata['configs'] && player.metadata['configs'][objectConfig.configId] ?
+                    player.metadata['configs'][objectConfig.configId] : 0;
             }
         } else {
             morphIndex = getVarbitMorphIndex(objectConfig.varbitId, player.metadata['configs']);
@@ -64,7 +96,7 @@ const objectInteractionPacket = (player, packet) => {
         }
     }
 
-    const actionIdx = options[packetId].index;
+    const actionIdx = objectInteractionPackets[packetId].index;
     let optionName = `action-${actionIdx + 1}`;
     if(objectConfig.options && objectConfig.options.length >= actionIdx) {
         if(!objectConfig.options[actionIdx]) {
@@ -83,16 +115,9 @@ const objectInteractionPacket = (player, packet) => {
     player.actionPipeline.call('object_interaction', player, landscapeObject, objectConfig, objectPosition, optionName.toLowerCase(), cacheOriginal);
 };
 
-export default [{
-    opcode: 30,
-    size: 6,
-    handler: objectInteractionPacket
-}, {
-    opcode: 164,
-    size: 6,
-    handler: objectInteractionPacket
-}, {
-    opcode: 183,
+
+export default Object.keys(objectInteractionPackets).map(opcode => ({
+    opcode: parseInt(opcode, 10),
     size: 6,
     handler: objectInteractionPacket
-}];
+}));

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

@@ -586,14 +586,14 @@ export class OutboundPackets {
         const offsetX = playerChunk.position.x - (topCornerMapChunk.position.x - 2);
         const offsetY = playerChunk.position.y - (topCornerMapChunk.position.y - 2);
 
-        const centerOffsetX = offsetX - 6; // 6 === center
-        const centerOffsetY = offsetY - 6; // 6 === center
+        mapData.centerOffsetX = offsetX - 6; // 6 === center
+        mapData.centerOffsetY = 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 + centerOffsetX;
-                    let mapTileOffsetY = y + centerOffsetY;
+                    let mapTileOffsetX = x + mapData.centerOffsetX;
+                    let mapTileOffsetY = y + mapData.centerOffsetY;
                     if(mapTileOffsetX < 0) {
                         mapTileOffsetX = 0;
                     }

src/game-engine/world/action/item-on-npc.action.ts

@@ -3,7 +3,6 @@ import { Position } from '@engine/world/position';
 import { ActionHook, getActionHooks } from '@engine/world/action/hooks';
 import { Item } from '@engine/world/items/item';
 import { Npc } from '@engine/world/actor/npc/npc';
-import { playerWalkTo } from '@engine/game-server';
 import { advancedNumberHookFilter, questHookFilter, stringHookFilter } from '@engine/world/action/hooks/hook-filters';
 import { ActionPipe, RunnableHooks } from '@engine/world/action/index';
 

src/game-engine/world/index.ts

@@ -3,7 +3,7 @@ import Quadtree from 'quadtree-lib';
 import { Player } from './actor/player/player';
 import { ChunkManager } from './map/chunk-manager';
 import { ExamineCache } from './config/examine-data';
-import { loadPlugins } from '@engine/game-server';
+import { loadPlugins, world } from '@engine/game-server';
 import { Position } from './position';
 import { Npc } from './actor/npc/npc';
 import TravelLocations from '@engine/world/config/travel-locations';
@@ -19,6 +19,8 @@ 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 { Chunk } from '@engine/world/map/chunk';
 
 
 export interface QuadtreeKey {
@@ -81,7 +83,18 @@ export class World {
                                 objectPosition: Position): { object: LandscapeObject, cacheOriginal: boolean } {
         const x = objectPosition.x;
         const y = objectPosition.y;
+
         const objectChunk = this.chunkManager.getChunkForWorldPosition(objectPosition);
+
+        if(actor instanceof Player && actor.metadata.customMap) {
+            const templateMapObject = this.findCustomMapObject(actor, objectId, objectPosition);
+            if(templateMapObject) {
+                return { object: templateMapObject, cacheOriginal: true };
+            }
+
+            return null;
+        }
+
         let cacheOriginal = true;
 
         let tileModifications;
@@ -129,6 +142,43 @@ export class World {
         };
     }
 
+    /**
+     * Locates a map template object from the actor's active custom map (if applicable).
+     * @param actor The actor to find the object for.
+     * @param objectId The ID of the object to find.
+     * @param objectPosition The position of the copied object to find the template of.
+     */
+    public findCustomMapObject(actor: Actor, objectId: number, objectPosition: Position): LandscapeObject | null {
+        const objectChunk = this.chunkManager.getChunkForWorldPosition(objectPosition);
+        const map = actor.metadata.customMap as ConstructedMap;
+        const mapChunk = world.chunkManager.getChunkForWorldPosition(map.position);
+
+        const chunkIndexX = objectChunk.position.x - (mapChunk.position.x - 2);
+        const chunkIndexY = objectChunk.position.y - (mapChunk.position.y - 2);
+
+        const centerOffsetX = map.centerOffsetX || 0;
+        const centerOffsetY = map.centerOffsetY || 0;
+
+        const objectTile = map.tileData[actor.position.level][chunkIndexX + centerOffsetX][chunkIndexY + centerOffsetY];
+
+        const tileX = objectTile >> 14 & 0x3ff;
+        const tileY = objectTile >> 3 & 0x7ff;
+        const tileOrientation = (0x6 & objectTile) >> 1;
+
+        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 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 realObject = mapTemplateChunk.getFilestoreLandscapeObject(objectId, templateObjectPosition);
+
+        return realObject || null;
+    }
+
     /**
      * Saves player data for every active player within the game world.
      */

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

@@ -27,4 +27,35 @@ export interface ConstructedMap {
     position: Position;
     emptySpace?: number;
     tileData: number[][][];
+    centerOffsetX?: number;
+    centerOffsetY?: number;
 }
+
+
+export const getRotatedObjectX = (orientation: number, localX: number, localY: number): number => {
+    orientation &= 0x3;
+    if(orientation === 0) {
+        return localX;
+    }
+    if(orientation === 1) {
+        return localY;
+    }
+    if(orientation === 2) {
+        return -localX + 7;
+    }
+    return 7 + -localY;
+};
+
+export const getRotatedObjectY = (orientation: number, localX: number, localY: number): number => {
+    orientation &= 0x3;
+    if(orientation === 0) {
+        return localY;
+    }
+    if(orientation === 1) {
+        return 7 + -localX;
+    }
+    if(orientation === 2) {
+        return -localY + 7;
+    }
+    return localX;
+};