refactor: 'ground item' -> 'world item'

Author: Jameskmonger

src/engine/action/action-pipeline.ts

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

src/engine/action/pipe/index.ts

@@ -2,7 +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-ground-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-ground-item.action.ts renamed to src/engine/action/pipe/item-on-world-item.action.ts

@@ -4,30 +4,30 @@ import { ActionHook, getActionHooks, questHookFilter, ActionPipe, RunnableHooks
 
 
 /**
- * Defines an item-on-item action hook.
+ * Defines an item-on-world-item action hook.
  *
  * @author jameskmonger
  */
-export interface ItemOnGroundItemActionHook extends ActionHook<ItemOnGroundItemAction, itemOnGroundItemActionHandler> {
+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, groundItem?: number }[];
+    items: { item?: number, worldItem?: number }[];
 }
 
 
 /**
- * The item-on-ground-item action hook handler function to be called when the hook's conditions are met.
+ * The item-on-world-item action hook handler function to be called when the hook's conditions are met.
  */
-export type itemOnGroundItemActionHandler = (itemOnGroundItemAction: ItemOnGroundItemAction) => void;
+export type itemOnWorldItemActionHandler = (itemOnWorldItemAction: ItemOnWorldItemAction) => void;
 
 
 /**
- * Details about an item-on-ground-item action being performed.
+ * Details about an item-on-world-item action being performed.
  *
  * @author jameskmonger
  */
-export interface ItemOnGroundItemAction {
+export interface ItemOnWorldItemAction {
     /**
      * The player performing the action.
      */
@@ -60,34 +60,34 @@ export interface ItemOnGroundItemAction {
 }
 
 /**
- * The pipe that the game engine hands item-on-ground-item actions off to.
+ * The pipe that the game engine hands item-on-world-item actions off to.
  *
- * This will call the `item_on_ground_item` action hooks, if any are registered and match the action being performed.
+ * This will call the `item_on_world_item` action hooks, if any are registered and match the action being performed.
  *
- * Both `item` and `groundItem` are optional, but if they are provided then they must match the items in use.
+ * Both `item` and `worldItem` are optional, but if they are provided then they must match the items in use.
  *
  * @author jameskmonger
  */
-const itemOnGroundItemActionPipe = (
+const itemOnWorldItemActionPipe = (
     player: Player,
     usedItem: Item, usedWithItem: WorldItem,
     usedWidgetId: number, usedContainerId: number, usedSlot: number
-): RunnableHooks<ItemOnGroundItemAction> => {
+): RunnableHooks<ItemOnWorldItemAction> => {
     if(player.busy) {
         return;
     }
 
     // Find all item on item action plugins that match this action
-    let matchingHooks = getActionHooks<ItemOnGroundItemActionHook>('item_on_ground_item', plugin => {
+    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, groundItem }) => {
+            return (plugin.items.some(({ item, worldItem }) => {
                 const itemMatch = item === undefined || item === used;
-                const groundItemMatch = groundItem === undefined || groundItem === usedWith;
+                const worldItemMatch = worldItem === undefined || worldItem === usedWith;
 
-                return itemMatch && groundItemMatch;
+                return itemMatch && worldItemMatch;
             }));
         }
 
@@ -102,7 +102,7 @@ const itemOnGroundItemActionPipe = (
 
     if(matchingHooks.length === 0) {
         player.outgoingPackets.chatboxMessage(
-            `Unhandled item on ground item interaction: ${usedItem.itemId} on ${usedWithItem.itemId}`);
+            `Unhandled item on world item interaction: ${usedItem.itemId} on ${usedWithItem.itemId}`);
         return null;
     }
 
@@ -118,6 +118,6 @@ const itemOnGroundItemActionPipe = (
 
 
 /**
- * Item-on-item action pipe definition.
+ * Item-on-world-item action pipe definition.
  */
-export default [ 'item_on_ground_item', itemOnGroundItemActionPipe ] as ActionPipe;
+export default [ 'item_on_world_item', itemOnWorldItemActionPipe ] as ActionPipe;

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

@@ -5,17 +5,17 @@ import { PacketData } from '@engine/net';
 import { Position } from '@engine/world';
 
 /**
- * Parses the item on ground item packet and calls the `item_on_ground_item` action pipeline.
+ * 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 item being used on is on the ground.
+ * 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 itemOnGroundItemPacket = (player: Player, packet: PacketData) => {
+const itemOnWorldItemPacket = (player: Player, packet: PacketData) => {
     const { buffer } = packet;
 
     const usedWithX = buffer.get('short', 'u');
@@ -37,24 +37,24 @@ const itemOnGroundItemPacket = (player: Player, packet: PacketData) => {
         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 ground item case (A) for ${usedSlot} (${usedItemId}) on ${usedWithItemId} (${usedWithX}, ${usedWithY}) by ${player.username}`);
+            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 ground item case (B) for ${usedItem.itemId}:${usedItemId} on ${usedWithItem.itemId}:${usedWithItemId} by ${player.username}`);
+            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_ground_item', player, usedItem, usedWithItem, usedWidgetId, usedContainerId, usedSlot);
+        player.actionPipeline.call('item_on_world_item', player, usedItem, usedWithItem, usedWidgetId, usedContainerId, usedSlot);
     } else {
-        logger.warn(`Unhandled item on ground item case (C) using widgets ${usedWidgetId}:${usedContainerId} by ${player.username}`);
+        logger.warn(`Unhandled item on world item case (C) using widgets ${usedWidgetId}:${usedContainerId} by ${player.username}`);
     }
 
 };
 
 export default {
     opcode: 172,
     size: 14,
-    handler: itemOnGroundItemPacket
+    handler: itemOnWorldItemPacket
 };