libram 0.11.8 → 0.11.10

package/dist/Macro.test.js

@@ -70,10 +70,76 @@ describe(Macro, () => {
         const mock = $item `mock item`;
         expect(Macro.item(mock).toString()).toEqual(`use ${mock.name};`);
     });
+    it("item pair", () => {
+        const mock = $item `mock item`;
+        expect(Macro.item([mock, mock]).toString()).toEqual(`use ${mock.name}, ${mock.name};`);
+    });
+    it("item pair + single", () => {
+        const mock = $item `mock item`;
+        expect(Macro.item([mock, mock], mock).toString()).toEqual(`${Macro.item([mock, mock]).toString()}${Macro.item(mock).toString()}`);
+    });
+    it("item pair + pair", () => {
+        const mock = $item `mock item`;
+        expect(Macro.item([mock, mock], [mock, mock]).toString()).toEqual(`use ${mock.name}, ${mock.name};use ${mock.name}, ${mock.name};`);
+    });
     it("tryItem", () => {
         const mock = $item `mock item`;
         expect(Macro.tryItem(mock).toString()).toEqual(`if hascombatitem mock item;use ${mock.name};endif;`);
     });
+    it("tryItem same pair", () => {
+        const mock = $item `mock item`;
+        expect(Macro.tryItem([mock, mock]).toString()).toEqual(`if hastwocombatitems mock item;use mock item, mock item;endif;`);
+    });
+    it("tryItem different pair", () => {
+        const mock1 = $item `mock item`;
+        const mock2 = $item `mock item two`;
+        expect(Macro.tryItem([mock1, mock2]).toString()).toEqual(`if hascombatitem mock item && hascombatitem mock item two;use mock item, mock item two;endif;`);
+    });
+    it("tryItem same pair + single", () => {
+        const mock = $item `mock item`;
+        expect(Macro.tryItem([mock, mock], mock).toString()).toEqual(`${Macro.tryItem([mock, mock]).toString()}${Macro.tryItem(mock).toString()}`);
+    });
+    it("tryItem different pair + single", () => {
+        const mock1 = $item `mock item`;
+        const mock2 = $item `mock item two`;
+        expect(Macro.tryItem([mock1, mock2], mock1).toString()).toEqual(`${Macro.tryItem([mock1, mock2]).toString()}${Macro.tryItem(mock1).toString()}`);
+    });
+    it("funkslingItem same items", () => {
+        const mock = $item `mock item`;
+        expect(Macro.funkslingItem(mock, mock).toString()).toEqual(Macro.item([mock, mock]).toString());
+    });
+    it("funkslingItem different items", () => {
+        const mock1 = $item `mock item`;
+        const mock2 = $item `mock item two`;
+        expect(Macro.funkslingItem(mock1, mock2).toString()).toEqual(Macro.item([mock1, mock2]).toString());
+    });
+    it("funklingItem same pair + single", () => {
+        const mock = $item `mock item`;
+        expect(Macro.funkslingItem(mock, mock, mock).toString()).toEqual(Macro.item([mock, mock], mock).toString());
+    });
+    it("funklingItem different pair + single", () => {
+        const mock1 = $item `mock item`;
+        const mock2 = $item `mock item two`;
+        expect(Macro.funkslingItem(mock1, mock2, mock1).toString()).toEqual(Macro.item([mock1, mock2], mock1).toString());
+    });
+    it("tryFunklingItem same", () => {
+        const mock = $item `mock item`;
+        expect(Macro.tryFunkslingItem(mock, mock).toString()).toEqual(Macro.tryItem([mock, mock]).toString());
+    });
+    it("tryFunklingItem different", () => {
+        const mock1 = $item `mock item`;
+        const mock2 = $item `mock item two`;
+        expect(Macro.tryFunkslingItem(mock1, mock2).toString()).toEqual(Macro.tryItem([mock1, mock2]).toString());
+    });
+    it("tryFunklingItem same pair + single", () => {
+        const mock = $item `mock item`;
+        expect(Macro.tryFunkslingItem(mock, mock, mock).toString()).toEqual(Macro.tryItem([mock, mock], mock).toString());
+    });
+    it("tryFunklingItem different pair + single", () => {
+        const mock1 = $item `mock item`;
+        const mock2 = $item `mock item two`;
+        expect(Macro.tryFunkslingItem(mock1, mock2, mock1).toString()).toEqual(Macro.tryItem([mock1, mock2], mock1).toString());
+    });
     it("attack", () => {
         expect(Macro.attack().toString()).toEqual(`attack;`);
     });
@@ -105,6 +171,15 @@ describe(Macro.makeBALLSPredicate, () => {
         const mock = $item `mock combat item`;
         expect(Macro.makeBALLSPredicate(mock)).toEqual(`hascombatitem ${mock.name}`);
     });
+    it("Item Pair Same", () => {
+        const mock = $item `mock combat item`;
+        expect(Macro.makeBALLSPredicate([mock, mock])).toEqual(`hastwocombatitems ${mock.name}`);
+    });
+    it("Item Pair Different", () => {
+        const mock1 = $item `mock combat item`;
+        const mock2 = $item `mock combat item two`;
+        expect(Macro.makeBALLSPredicate([mock1, mock2])).toEqual(`hascombatitem ${mock1.name} && hascombatitem ${mock2.name}`);
+    });
     it("Item Overlapping", () => {
         const mock = $item `spider web`;
         expect(Macro.makeBALLSPredicate(mock)).toEqual(`hascombatitem ${mock.id}`);

package/dist/combat.d.ts

@@ -283,6 +283,40 @@ export declare class Macro {
      * @returns {Macro} This object itself.
      */
     static tryItem<T extends Macro>(this: Constructor<T>, ...items: (ItemOrName | [ItemOrName, ItemOrName])[]): T;
+    /**
+     * Add one or more item steps to the macro, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    funkslingItem(...items: ItemOrName[]): this;
+    /**
+     * Create a new macro with one or more item steps, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    static funkslingItem<T extends Macro>(this: Constructor<T>, ...items: ItemOrName[]): T;
+    /**
+     * Add one or more item steps to the macro, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    tryFunkslingItem(...items: ItemOrName[]): this;
+    /**
+     * Create a new macro with one or more item steps, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    static tryFunkslingItem<T extends Macro>(this: Constructor<T>, ...items: ItemOrName[]): T;
     /**
      * Add an attack step to the macro.
      *
@@ -402,6 +436,40 @@ export declare class StrictMacro extends Macro {
      * @returns {StrictMacro} This object itself.
      */
     static tryItem<T extends StrictMacro>(this: Constructor<T>, ...items: (Item | [Item, Item])[]): T;
+    /**
+     * Add one or more item steps to the macro, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    funkslingItem(...items: Item[]): this;
+    /**
+     * Create a new macro with one or more item steps, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    static funkslingItem<T extends StrictMacro>(this: Constructor<T>, ...items: Item[]): T;
+    /**
+     * Add one or more item steps to the macro, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    tryFunkslingItem(...items: Item[]): this;
+    /**
+     * Create a new macro with one or more item steps, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    static tryFunkslingItem<T extends StrictMacro>(this: Constructor<T>, ...items: Item[]): T;
     /**
      * Add one or more skill-cast-and-repeat steps to the macro, where each step checks if you have the skill first.
      *

package/dist/combat.js

@@ -98,6 +98,19 @@ function skillBallsMacroName(skillOrName) {
         ? skill.name
         : skill.id;
 }
+/**
+ * Reduces a list of items into pairs to funksling.
+ *
+ * @param items - The items to be reduced.
+ * @returns The reduced list of items or item pairs.
+ */
+function funkslingReduce(...items) {
+    return items.reduce((acc, item, i, arr) => i % 2 === 0
+        ? acc.concat(i + 1 < arr.length
+            ? [[item, arr[i + 1]]]
+            : [item])
+        : acc, []);
+}
 export class InvalidMacroError extends Error {
 }
 /**
@@ -537,6 +550,48 @@ export class Macro {
     static tryItem(...items) {
         return new this().tryItem(...items);
     }
+    /**
+     * Add one or more item steps to the macro, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    funkslingItem(...items) {
+        return this.item(...funkslingReduce(...items));
+    }
+    /**
+     * Create a new macro with one or more item steps, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    static funkslingItem(...items) {
+        return new this().funkslingItem(...items);
+    }
+    /**
+     * Add one or more item steps to the macro, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    tryFunkslingItem(...items) {
+        return this.tryItem(...funkslingReduce(...items));
+    }
+    /**
+     * Create a new macro with one or more item steps, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {Macro} This object itself.
+     */
+    static tryFunkslingItem(...items) {
+        return new this().tryFunkslingItem(...items);
+    }
     /**
      * Add an attack step to the macro.
      *
@@ -717,6 +772,48 @@ export class StrictMacro extends Macro {
     static tryItem(...items) {
         return new this().tryItem(...items);
     }
+    /**
+     * Add one or more item steps to the macro, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    funkslingItem(...items) {
+        return super.funkslingItem(...items);
+    }
+    /**
+     * Create a new macro with one or more item steps, and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    static funkslingItem(...items) {
+        return new this().funkslingItem(...items);
+    }
+    /**
+     * Add one or more item steps to the macro, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    tryFunkslingItem(...items) {
+        return super.tryFunkslingItem(...items);
+    }
+    /**
+     * Create a new macro with one or more item steps, where each step checks to see if you have the item first,
+     * and automatically attempting to funksling as many of the items as possible.
+     * This function does not check if you can funksling or not.
+     *
+     * @param items Items to use.
+     * @returns {StrictMacro} This object itself.
+     */
+    static tryFunkslingItem(...items) {
+        return new this().tryFunkslingItem(...items);
+    }
     /**
      * Add one or more skill-cast-and-repeat steps to the macro, where each step checks if you have the skill first.
      *

package/dist/overlappingNames.js

@@ -22,6 +22,7 @@ export const overlappingItemNames = [
     "spoon",
 ];
 export const overlappingSkillNames = [
+    "Lightning Bolt",
     "Shoot",
     "Thrust-Smack",
     "Headbutt",
@@ -41,4 +42,5 @@ export const overlappingSkillNames = [
     "Boil",
     "Slice",
     "Rainbow",
+    "Lightning Bolt",
 ];