Merge branch 'develop' into development

Author: src

src/plugins/skills/smithing/forging-plugin.ts renamed to src/plugins/skills/smithing/forging.plugin.ts

@@ -1,13 +1,27 @@
-import { itemOnObjectActionHandler } from '@engine/world/action/item-on-object.action';
+import { itemOnObjectActionHandler, ItemOnObjectActionHook } from '@engine/world/action/item-on-object.action';
 import { widgets } from '@engine/config';
 import { Skill } from '@engine/world/actor/skills';
-import { bars, smithables, widgetItems } from '@plugins/skills/smithing/forging-constants';
+import { anvilIds, bars, smithables, widgetItems } from '@plugins/skills/smithing/forging-constants';
 import { itemIds } from '@engine/world/config/item-ids';
 import { Smithable } from '@plugins/skills/smithing/forging-types';
-import { itemInteractionActionHandler } from '@engine/world/action/item-interaction.action';
-import { loopingEvent } from '@engine/game-server';
+import {
+    ItemInteractionAction,
+    ItemInteractionActionHook
+} from '@engine/world/action/item-interaction.action';
 import { Player } from '@engine/world/actor/player/player';
 import { findItem } from '@engine/config';
+import { TaskExecutor } from '@engine/world/action';
+import { Position } from '@engine/world/position';
+
+/**
+ * The amount of items the player wants to forge.
+ */
+let wantedAmount = 0;
+
+/**
+ * The amount of items already forged.
+ */
+let forgedAmount = 0;
 
 const mapWidgetItemsToFlatArray = (input) => {
     const result = [];
@@ -29,91 +43,118 @@ const mapToFlatArray = (input) => {
     return results;
 };
 
+/**
+ * Lookup a smithable from just an item id.
+ * @param itemId
+ */
 const findSmithableByItemId = (itemId) : Smithable => {
     return mapToFlatArray(smithables).find((smithable) => {
         return smithable.item.itemId === itemId;
     });
 };
 
-const smithItem: itemInteractionActionHandler = (details) => {
-    const { player, option, itemDetails } = details;
-
-    const smithable = findSmithableByItemId(itemDetails.gameId);
-
+/**
+ * Check if the player is able to perform the action.
+ * @param task
+ */
+const canActivate = (task: TaskExecutor<ItemInteractionAction>): boolean => {
+    const { actor, player, actionData } = task.getDetails();
+    const itemId = actionData.itemId;
+    const smithable = findSmithableByItemId(itemId);
 
     // In case the smithable doesn't exist.
     if (!smithable) {
-        return;
+        return false;
     }
 
     // Check if the player has the level required.
     if (smithable.level > player.skills.getLevel(Skill.SMITHING)) {
         const item = findItem(smithable.item.itemId);
         player.sendMessage(`You have to be at least level ${smithable.level} to smith ${item.name}s.`, true);
-        return;
+        return false;
     }
 
-    const amountInInventory = player.inventory.findAll(smithable.ingredient.itemId).length;
+    // Check if the player has sufficient materials.
+    if (!hasMaterials(player, smithable)) {
+        const bar = findItem(smithable.ingredient.itemId);
+        player.sendMessage(`You don't have enough ${bar.name}s.`, true);
+        return false;
+    }
 
-    // Close the forging interface.
     player.interfaceState.closeAllSlots();
 
-    const loop = loopingEvent({ player: details.player });
-    let elapsedTicks = 0;
-    let wantedAmount = 0;
-    let forgedAmount = 0;
+    return true;
+};
+
+/**
+ * The actual forging loop.
+ * @param task
+ * @param taskIteration
+ */
+const activate = (task: TaskExecutor<ItemInteractionAction>, taskIteration: number): boolean => {
+    const { player, actionData } = task.getDetails();
+    const itemId = actionData.itemId;
+    const smithable = findSmithableByItemId(itemId);
 
     // How many? Quick and dirty.
-    switch (option) {
+    switch (actionData.option) {
         case 'make'     : wantedAmount = 1; break;
         case 'make-5'   : wantedAmount = 5; break;
         case 'make-10'  : wantedAmount = 10; break;
     }
 
-    if (!hasIngredients(details.player, smithable)) {
-        player.interfaceState.closeAllSlots();
-        const bar = findItem(smithable.ingredient.itemId);
-        player.sendMessage(`You don't have enough ${bar.name}s.`, true);
-    }
-
-    loop.event.subscribe(() => {
-        if (!hasIngredients(details.player, smithable) || wantedAmount === forgedAmount) {
-            loop.cancel();
-            return;
-        }
-
-        if (elapsedTicks % 5 === 0) {
-            player.playAnimation(898);
+    for(let m=0; m<wantedAmount; m++) {
+        player.playAnimation(898);
+        if(taskIteration % 4 === 0) {
+            if (!hasMaterials(player, smithable) || wantedAmount === forgedAmount) {
+                return false;
+            }
 
             // Remove ingredients
             for (let i=0; i<smithable.ingredient.amount; i++) {
                 player.inventory.removeFirst(smithable.ingredient.itemId);
-                details.player.outgoingPackets.sendUpdateAllWidgetItems(widgets.inventory, details.player.inventory);
             }
 
             // Add item to inventory
-            for (let i=0; i<smithable.item.amount; i++) {
-                player.inventory.add(smithable.item.itemId);
-            }
+            player.inventory.add({
+                itemId: smithable.item.itemId, amount: smithable.item.amount
+            });
 
-            // Give the experience
+            player.outgoingPackets.sendUpdateAllWidgetItems(widgets.inventory, player.inventory);
             player.skills.addExp(Skill.SMITHING, smithable.experience);
 
             forgedAmount++;
+            return true;
         }
+    }
 
-        elapsedTicks++;
-    });
+    // Reset the properties, and strap in for the next batch.
+    if (forgedAmount === wantedAmount) {
+        forgedAmount = 0;
+        wantedAmount = 0;
+        return false;
+    }
 };
 
-const hasIngredients = (player: Player, smithable: Smithable) => {
+/**
+ * Checks if the player has enough materials
+ * @param player
+ * @param smithable
+ */
+const hasMaterials = (player: Player, smithable: Smithable) => {
     return smithable.ingredient.amount <= player.inventory.findAll(smithable.ingredient.itemId).length;
 };
 
+/**
+ * Opens the forging interface, and loads the items.
+ * @param details
+ */
 const openForgingInterface: itemOnObjectActionHandler = (details) => {
-    const { player, item } = details;
+    const { player, item, object } = details;
     const amountInInventory = player.inventory.findAll(item).length;
 
+    player.face(new Position(object.x, object.y));
+
     // The player does not have a hammer.
     if (!player.inventory.has(itemIds.hammer)) {
         player.sendMessage(`You need a hammer to work the metal with.`, true);
@@ -143,17 +184,28 @@ const openForgingInterface: itemOnObjectActionHandler = (details) => {
     });
 };
 
-export default [
-    {
-        type: 'item_on_object',
-        itemIds: [...bars.keys()],
-        objectIds: [2783],
-        options: ['use'],
-        action:  openForgingInterface
-    },
-    {
-        type: 'item_action',
-        itemIds: [...mapWidgetItemsToFlatArray(widgetItems)],
-        action: smithItem
-    }
-];
+export default {
+    pluginId: 'rs:forging',
+    hooks: [
+        {
+            type: 'item_on_object',
+            itemIds: [...bars.keys()],
+            objectIds: anvilIds,
+            walkTo: true,
+
+            cancelOtherActions: true,
+            handler: openForgingInterface
+        } as ItemOnObjectActionHook,
+        {
+            type: 'item_interaction',
+            itemIds: [...mapWidgetItemsToFlatArray(smithables)],
+            options: ['make', 'make-5', 'make-10'],
+            cancelOtherActions: true,
+            task: {
+                canActivate,
+                activate,
+                interval: 1
+            }
+        } as ItemInteractionActionHook
+    ]
+};