Merge branch 'develop' into fix-setting-level

Author: SchauweM

jest.config.ts

@@ -153,10 +153,9 @@ export default {
   // testLocationInResults: false,
 
   // The glob patterns Jest uses to detect test files
-  // testMatch: [
-  //   "**/__tests__/**/*.[jt]s?(x)",
-  //   "**/?(*.)+(spec|test).[tj]s?(x)"
-  // ],
+  testMatch: [
+    "**/*.test.ts"
+  ],
 
   // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
   // testPathIgnorePatterns: [

src/engine/action/action-pipeline.ts

@@ -31,6 +31,7 @@ export type ActionType =
     | 'item_on_npc'
     | 'item_on_player'
     | 'item_on_item'
+    | 'item_on_world_item'
     | 'item_swap'
     | 'move_item'
     | 'spawned_item_interaction'

src/engine/action/pipe/index.ts

@@ -2,6 +2,7 @@ export * from './button.action';
 export * from './equipment-change.action';
 export * from './item-interaction.action';
 export * from './item-on-item.action';
+export * from './item-on-world-item.action';
 export * from './item-on-npc.action';
 export * from './item-on-object.action';
 export * from './item-on-player.action';

src/engine/action/pipe/item-on-world-item.action.ts

@@ -0,0 +1,123 @@
+import { Player } from '@engine/world/actor';
+import { Item, WorldItem } from '@engine/world';
+import { ActionHook, getActionHooks, questHookFilter, ActionPipe, RunnableHooks } from '@engine/action';
+
+
+/**
+ * Defines an item-on-world-item action hook.
+ *
+ * @author jameskmonger
+ */
+export interface ItemOnWorldItemActionHook extends ActionHook<ItemOnWorldItemAction, itemOnWorldItemActionHandler> {
+    /**
+     * The item pairs being used. Both items are optional so that you can specify a single item, a pair of items, or neither.
+     */
+    items: { item?: number, worldItem?: number }[];
+}
+
+
+/**
+ * The item-on-world-item action hook handler function to be called when the hook's conditions are met.
+ */
+export type itemOnWorldItemActionHandler = (itemOnWorldItemAction: ItemOnWorldItemAction) => void;
+
+
+/**
+ * Details about an item-on-world-item action being performed.
+ *
+ * @author jameskmonger
+ */
+export interface ItemOnWorldItemAction {
+    /**
+     * The player performing the action.
+     */
+    player: Player;
+
+    /**
+     * The item being used.
+     */
+    usedItem: Item;
+
+    /**
+     * The WorldItem that the first item is being used on.
+     */
+    usedWithItem: WorldItem;
+
+    /**
+     * The ID of the UI widget that the item being used is in.
+     */
+    usedWidgetId: number;
+
+    /**
+     * The ID of the container that the item being used is in.
+     */
+    usedContainerId: number;
+
+    /**
+     * The slot within the container that the item being used is in.
+     */
+    usedSlot: number;
+}
+
+/**
+ * The pipe that the game engine hands item-on-world-item actions off to.
+ *
+ * This will call the `item_on_world_item` action hooks, if any are registered and match the action being performed.
+ *
+ * Both `item` and `worldItem` are optional, but if they are provided then they must match the items in use.
+ *
+ * @author jameskmonger
+ */
+const itemOnWorldItemActionPipe = (
+    player: Player,
+    usedItem: Item, usedWithItem: WorldItem,
+    usedWidgetId: number, usedContainerId: number, usedSlot: number
+): RunnableHooks<ItemOnWorldItemAction> => {
+    if(player.busy) {
+        return;
+    }
+
+    // Find all item on item action plugins that match this action
+    let matchingHooks = getActionHooks<ItemOnWorldItemActionHook>('item_on_world_item', plugin => {
+        if(questHookFilter(player, plugin)) {
+            const used = usedItem.itemId;
+            const usedWith = usedWithItem.itemId;
+
+            return (plugin.items.some(({ item, worldItem }) => {
+                const itemMatch = item === undefined || item === used;
+                const worldItemMatch = worldItem === undefined || worldItem === usedWith;
+
+                return itemMatch && worldItemMatch;
+            }));
+        }
+
+        return false;
+    });
+
+    const questActions = matchingHooks.filter(plugin => plugin.questRequirement !== undefined);
+
+    if(questActions.length !== 0) {
+        matchingHooks = questActions;
+    }
+
+    if(matchingHooks.length === 0) {
+        player.outgoingPackets.chatboxMessage(
+            `Unhandled item on world item interaction: ${usedItem.itemId} on ${usedWithItem.itemId}`);
+        return null;
+    }
+
+    return {
+        hooks: matchingHooks,
+        action: {
+            player,
+            usedItem, usedWithItem,
+            usedWidgetId, usedContainerId, usedSlot
+        }
+    }
+};
+
+
+/**
+ * Item-on-world-item action pipe definition.
+ */
+export default [ 'item_on_world_item', itemOnWorldItemActionPipe ] as ActionPipe;

src/engine/net/inbound-packets/item-on-world-item.packet.ts

@@ -0,0 +1,60 @@
+import { logger } from '@runejs/common';
+import { widgets } from '@engine/config';
+import { Player } from '@engine/world/actor';
+import { PacketData } from '@engine/net';
+import { Position } from '@engine/world';
+
+/**
+ * Parses the item on world item packet and calls the `item_on_world_item` action pipeline.
+ *
+ * This will check that the item being used is in the player's inventory, and that the world item exists in the correct location.
+ * The action pipeline will not be called if either of these conditions are not met.
+ *
+ * @param player The player that sent the packet.
+ * @param packet The packet to parse.
+ *
+ * @author jameskmonger
+ */
+const itemOnWorldItemPacket = (player: Player, packet: PacketData) => {
+    const { buffer } = packet;
+
+    const usedWithX = buffer.get('short', 'u');
+    const usedSlot = buffer.get('short', 'u');
+    const usedWithItemId = buffer.get('short', 'u');
+    const usedContainerId = buffer.get('short', 's', 'be');
+    const usedWidgetId = buffer.get('short', 's', 'be');
+    const usedWithY = buffer.get('short', 'u', 'le');
+    const usedItemId = buffer.get('short', 'u', 'le');
+
+    const position = new Position(usedWithX, usedWithY, player.position.level);
+
+    if(usedWidgetId === widgets.inventory.widgetId && usedContainerId === widgets.inventory.containerId) {
+        // TODO (James) we should use constants for these rather than magic numbers
+        if(usedSlot < 0 || usedSlot > 27) {
+            return;
+        }
+
+        const usedItem = player.inventory.items[usedSlot];
+        const usedWithItem = player.instance.getTileModifications(position).mods.worldItems.find(p => p.itemId === usedWithItemId);
+        if(!usedItem || !usedWithItem) {
+            logger.warn(`Unhandled item on world item case (A) for ${usedSlot} (${usedItemId}) on ${usedWithItemId} (${usedWithX}, ${usedWithY}) by ${player.username}`);
+            return;
+        }
+
+        if(usedItem.itemId !== usedItemId || usedWithItem.itemId !== usedWithItemId) {
+            logger.warn(`Unhandled item on world item case (B) for ${usedItem.itemId}:${usedItemId} on ${usedWithItem.itemId}:${usedWithItemId} by ${player.username}`);
+            return;
+        }
+
+        player.actionPipeline.call('item_on_world_item', player, usedItem, usedWithItem, usedWidgetId, usedContainerId, usedSlot);
+    } else {
+        logger.warn(`Unhandled item on world item case (C) using widgets ${usedWidgetId}:${usedContainerId} by ${player.username}`);
+    }
+
+};
+
+export default {
+    opcode: 172,
+    size: 14,
+    handler: itemOnWorldItemPacket
+};