warcraft-3-w3ts-utils 0.1.11 → 0.1.13

package/src/utils/abilities.ts

@@ -0,0 +1,158 @@
+import { Timer, Trigger, Unit } from "w3ts";
+
+/**
+ * Good for once a unit gets near you, but not good while they are near you since the event is only triggered on entry, not during
+ * @param unit
+ * @param range
+ * @param cb
+ * @param config
+ * @returns
+ */
+export function unitGetsNearThisUnit(
+  unit: Unit,
+  range: number,
+  cb: (u: Unit) => void,
+  config?: {
+    uniqueUnitsOnly: boolean;
+    filter?: boolexpr | (() => boolean);
+    onDestroy?: (unitsEffected: Unit[]) => void;
+  }
+) {
+  const trig = Trigger.create();
+
+  /**
+   * A unique set of the units effected
+   */
+  let effectedUnitPool: Unit[] = [];
+
+  trig.registerUnitInRage(unit.handle, range, config?.filter ?? (() => true));
+
+  trig.addAction(() => {
+    const u = Unit.fromEvent();
+
+    if (!u) {
+      return;
+    }
+
+    if (!effectedUnitPool.includes(u)) {
+      effectedUnitPool.push(u);
+    }
+
+    if (config?.uniqueUnitsOnly && !effectedUnitPool.includes(u)) {
+      cb(u);
+    } else {
+      cb(u);
+    }
+  });
+
+  const destroy = () => {
+    if (config?.onDestroy) {
+      config?.onDestroy(effectedUnitPool);
+    }
+
+    trig.destroy();
+  };
+
+  const clearUniqueUnits = () => {
+    effectedUnitPool = [];
+  };
+
+  return {
+    cleanupUnitGetsNearThisUnit: (delay?: number) => {
+      if (delay) {
+        const timer = Timer.create();
+        timer.start(delay, false, () => {
+          destroy();
+          timer.destroy();
+        });
+        return;
+      }
+
+      destroy();
+    },
+    clearUniqueUnits,
+  };
+}
+
+/**
+ *
+ * @param cb
+ * @param abilityId
+ * @param dummyLifeTime Maybe be necessary to have a long lifetime so spells like chain lightning will have time to bounce to all targets
+ * @param owner
+ */
+// export function useTempDummyUnit(cb: (dummy: Unit) => void, abilityId: number, dummyLifeTime: number, owner: MapPlayer, x: number, y: number, facing: number, config?: { abilityLevel?: number; modelType?: "cenariusGhost" }) {
+//     let dummy: Unit | undefined = undefined;
+
+//     if (config?.modelType === "cenariusGhost") {
+//         dummy = Unit.create(owner, UNITS.dummyCaster_cenariusGhost, x, y, facing);
+//         dummy?.setScale(1, 1, 1);
+//     } else {
+//         dummy = Unit.create(owner, UNITS.dummyCaster, x, y, facing);
+//     }
+
+//     const t = Timer.create();
+
+//     if (dummy) {
+//         dummy.addAbility(abilityId);
+//         dummy.setAbilityManaCost(abilityId, config?.abilityLevel ? config.abilityLevel - 1 : 0, 0);
+//         cb(dummy);
+
+//         t.start(dummyLifeTime, false, () => {
+//             dummy?.destroy();
+//             t.destroy();
+//         });
+//     }
+// }
+
+/**
+ * Creates a trigger to monitor when a unit is attacked
+ *
+ * We could also have all functions execute in this single trigger's context instead of creating new triggers each time the function is used.
+ * @param cb
+ * @param config
+ */
+export function onUnitAttacked(
+  cb: (attacker: Unit, victim: Unit) => void,
+  config: { attackerCooldown?: boolean; procChance?: number }
+) {
+  const attackerTriggerCooldown = new Set<Unit>();
+  const t = Trigger.create();
+
+  t.registerAnyUnitEvent(EVENT_PLAYER_UNIT_ATTACKED);
+
+  t.addAction(() => {
+    const attacker = Unit.fromHandle(GetAttacker());
+    const victim = Unit.fromHandle(GetAttackedUnitBJ());
+
+    if (!attacker || !victim) {
+      return;
+    }
+
+    //Attack was not below the proc chance, and thus we will not use the cb function
+    if (
+      config.procChance &&
+      Math.ceil(Math.random() * 100) >= config.procChance
+    ) {
+      return;
+    }
+
+    //Attacker has already used the trigger
+    if (config.attackerCooldown && attackerTriggerCooldown.has(attacker)) {
+      return;
+    }
+
+    attackerTriggerCooldown.add(attacker);
+
+    //Finally, after all conditions have been met, use the cb function
+    cb(attacker, victim);
+
+    const t = Timer.create();
+
+    //removes the attacker from the cooldown group after 1/3 of that units attack cooldown has passed.
+    t.start(attacker.getAttackCooldown(0) / 3, false, () => {
+      attackerTriggerCooldown.delete(attacker);
+      t.destroy();
+    });
+  });
+}

package/src/utils/camera.ts

@@ -0,0 +1,63 @@
+import { Trigger } from "w3ts";
+import { forEachPlayer } from "./players";
+
+type CameraDistances = "mid" | "far" | "max";
+
+export function enableCameraZoom() {
+  const t = Trigger.create();
+  forEachPlayer((p) => {
+    SetCameraFieldForPlayer(p.handle, CAMERA_FIELD_FARZ, 10000, 0.25);
+
+    t.registerPlayerChatEvent(p, "-cam", false);
+
+    t.addAction(() => {
+      const str = GetEventPlayerChatString();
+      const triggeringPlayer = GetTriggerPlayer();
+      if (str && triggeringPlayer) {
+        const [command, distance] = str?.split(" ");
+        SetCameraFieldForPlayer(
+          triggeringPlayer,
+          CAMERA_FIELD_FARZ,
+          10000,
+          0.25
+        );
+
+        if ((distance as CameraDistances) === "mid") {
+          SetCameraFieldForPlayer(
+            triggeringPlayer,
+            CAMERA_FIELD_TARGET_DISTANCE,
+            4500,
+            0.25
+          );
+          return;
+        } else if ((distance as CameraDistances) === "far") {
+          SetCameraFieldForPlayer(
+            triggeringPlayer,
+            CAMERA_FIELD_TARGET_DISTANCE,
+            6000,
+            0.25
+          );
+          return;
+        } else if ((distance as CameraDistances) === "max") {
+          SetCameraFieldForPlayer(
+            triggeringPlayer,
+            CAMERA_FIELD_TARGET_DISTANCE,
+            7800,
+            0.25
+          );
+          return;
+        }
+
+        const distanceAsNumber = Number(distance);
+        if (typeof distanceAsNumber !== "number") return;
+
+        SetCameraFieldForPlayer(
+          triggeringPlayer,
+          CAMERA_FIELD_TARGET_DISTANCE,
+          distanceAsNumber,
+          0.25
+        );
+      }
+    });
+  });
+}

package/src/utils/chat-command.ts

@@ -0,0 +1,22 @@
+import { MapPlayer, Trigger } from "w3ts";
+
+/**
+ * Setup trigger to listen for a chat command for the players specified in the array. Execute function when triggered
+ * @param command -cam , -name, -start, etc
+ * @param players
+ * @param fn
+ */
+export function createChatCommand(players: MapPlayer[], command: string, exact: boolean, fn: (player: MapPlayer, data: { trigger: Trigger; command: string; data?: string }) => void) {
+    const trigger = Trigger.create();
+
+    players.forEach((p) => {
+        trigger.registerPlayerChatEvent(p, command, exact);
+
+        trigger.addAction(() => {
+            const str = GetEventPlayerChatString();
+            const [_, data] = str?.split(" ") ?? [];
+
+            fn(p, { trigger, command, data });
+        });
+    });
+}

package/src/utils/color.ts

@@ -0,0 +1,139 @@
+export const playerRGBMap = new Map<number, { r: number; g: number; b: number }>([
+    [0, { r: 255, g: 0, b: 0 }],
+    [1, { r: 0, g: 0, b: 255 }],
+    [2, { r: 0, g: 255, b: 255 }],
+    [3, { r: 128, g: 0, b: 128 }],
+    [4, { r: 255, g: 255, b: 0 }],
+    [5, { r: 254, g: 137, b: 13 }],
+    [6, { r: 32, g: 192, b: 0 }],
+    [7, { r: 229, g: 91, b: 176 }],
+    [8, { r: 149, g: 150, b: 151 }],
+    [9, { r: 126, g: 191, b: 241 }],
+    [10, { r: 16, g: 98, b: 70 }],
+    [11, { r: 78, g: 42, b: 4 }],
+    [12, { r: 155, g: 0, b: 0 }],
+    [13, { r: 0, g: 0, b: 195 }],
+    [14, { r: 155, g: 234, b: 255 }],
+    [15, { r: 190, g: 0, b: 254 }],
+    [16, { r: 235, g: 205, b: 135 }],
+    [17, { r: 248, g: 164, b: 139 }],
+    [18, { r: 191, g: 255, b: 128 }],
+    [19, { r: 220, g: 185, b: 235 }],
+    [20, { r: 40, g: 40, b: 40 }],
+    [21, { r: 235, g: 240, b: 255 }],
+    [22, { r: 0, g: 120, b: 30 }],
+    [23, { r: 164, g: 111, b: 51 }],
+]);
+
+export const playerHexColorMap = new Map<number, string>([
+    [0, "ff0303"],
+    [1, "0042ff"],
+    [2, "1ce6b9"],
+    [3, "540081"],
+    [4, "fffc00"],
+    [5, "fe8a0e"],
+]);
+
+/**
+ * 
+ * 
+PlayerStrings[0].colour = "|c00ff0303"
+        PlayerStrings[1].colour = "|c000042ff"
+        PlayerStrings[2].colour = "|c001ce6b9"
+        PlayerStrings[3].colour = "|c00540081"
+        PlayerStrings[4].colour = "|c00fffc00"
+        PlayerStrings[5].colour = "|c00fe8a0e"
+        PlayerStrings[6].colour = "|c0020c000"
+        PlayerStrings[7].colour = "|c00e55bb0"
+        PlayerStrings[8].colour = "|c00959697"
+        PlayerStrings[9].colour = "|c007ebff1"
+        PlayerStrings[10].colour = "|c00106246"
+        PlayerStrings[11].colour = "|c004e2a04"
+        PlayerStrings[12].colour = "|c009b0000"
+        PlayerStrings[13].colour = "|c000000c3"
+        PlayerStrings[14].colour = "|c0000eaff"
+        PlayerStrings[15].colour = "|c00be00fe"
+        PlayerStrings[16].colour = "|c00ebcd87"
+        PlayerStrings[17].colour = "|c00f8a48b"
+        PlayerStrings[18].colour = "|c00bfff80"
+        PlayerStrings[19].colour = "|c00dcb9eb"
+        PlayerStrings[20].colour = "|c00282828"
+        PlayerStrings[21].colour = "|c00ebf0ff"
+        PlayerStrings[22].colour = "|c0000781e"
+        PlayerStrings[23].colour = "|c00a46f33"
+        -- RGB
+        PlayerStrings[0].red = 255
+        PlayerStrings[0].green = 3
+        PlayerStrings[0].blue = 3
+        PlayerStrings[1].red = 0
+        PlayerStrings[1].green = 66
+        PlayerStrings[1].blue = 255
+        PlayerStrings[2].red = 28
+        PlayerStrings[2].green = 230
+        PlayerStrings[2].blue = 185
+        PlayerStrings[3].red = 84
+        PlayerStrings[3].green = 0
+        PlayerStrings[3].blue = 129
+        PlayerStrings[4].red = 255
+        PlayerStrings[4].green = 254
+        PlayerStrings[4].blue = 0
+        PlayerStrings[5].red = 254
+        PlayerStrings[5].green = 138
+        PlayerStrings[5].blue = 14
+        PlayerStrings[6].red = 32
+        PlayerStrings[6].green = 192
+        PlayerStrings[6].blue = 0
+        PlayerStrings[7].red = 229
+        PlayerStrings[7].green = 91
+        PlayerStrings[7].blue = 176
+        PlayerStrings[8].red = 149
+        PlayerStrings[8].green = 150
+        PlayerStrings[8].blue = 151
+        PlayerStrings[9].red = 126
+        PlayerStrings[9].green = 191
+        PlayerStrings[9].blue = 241
+        PlayerStrings[10].red = 16
+        PlayerStrings[10].green = 98
+        PlayerStrings[10].blue = 70
+        PlayerStrings[11].red = 78
+        PlayerStrings[11].green = 42
+        PlayerStrings[11].blue = 4
+        PlayerStrings[12].red = 155
+        PlayerStrings[12].green = 0
+        PlayerStrings[12].blue = 0
+        PlayerStrings[13].red = 0
+        PlayerStrings[13].green = 0
+        PlayerStrings[13].blue = 195
+        PlayerStrings[14].red = 155
+        PlayerStrings[14].green = 234
+        PlayerStrings[14].blue = 255
+        PlayerStrings[15].red = 190
+        PlayerStrings[15].green = 0
+        PlayerStrings[15].blue = 254
+        PlayerStrings[16].red = 235
+        PlayerStrings[16].green = 205
+        PlayerStrings[16].blue = 135
+        PlayerStrings[17].red = 248
+        PlayerStrings[17].green = 164
+        PlayerStrings[17].blue = 139
+        PlayerStrings[18].red = 191
+        PlayerStrings[18].green = 255
+        PlayerStrings[18].blue = 128
+        PlayerStrings[19].red = 220
+        PlayerStrings[19].green = 185
+        PlayerStrings[19].blue = 235
+        PlayerStrings[20].red = 40
+        PlayerStrings[20].green = 40
+        PlayerStrings[20].blue = 40
+        PlayerStrings[21].red = 235
+        PlayerStrings[21].green = 240
+        PlayerStrings[21].blue = 255
+        PlayerStrings[22].red = 0
+        PlayerStrings[22].green = 120
+        PlayerStrings[22].blue = 30
+        PlayerStrings[23].red = 164
+        PlayerStrings[23].green = 111
+        PlayerStrings[23].blue = 51
+ * 
+ * 
+ */

package/src/utils/index.ts

@@ -0,0 +1,15 @@
+export * from "./abilities";
+export * from "./camera";
+export * from "./chat-command";
+export * from "./color";
+export * from "./item";
+export * from "./math";
+export * from "./minimapIcons";
+export * from "./misc";
+export * from "./physics";
+export * from "./players";
+export * from "./point";
+export * from "./quests";
+export * from "./textTag";
+export * from "./timer";
+export * from "./units";

package/src/utils/item.ts

@@ -0,0 +1,163 @@
+import { Effect, Item, Trigger, Unit } from "w3ts";
+import { notifyPlayer, useTempEffect } from "./misc";
+
+/**
+ * Checks if the unit has an item in their item slots
+ * @param u
+ * @param itemTypeId
+ * @returns
+ */
+export function unitHasItem(u: Unit, itemTypeId: number): boolean {
+    for (let x = 0; x < 6; x++) {
+        if (u.getItemInSlot(x)?.typeId === itemTypeId) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+// Player should pick up recipes when needed. if they are missing items then the recipe cost is refunded
+function trig_itemRecipeSystem() {
+    //takes a set of items
+    //unit or unit clicks
+    const t = Trigger.create();
+
+    t.registerAnyUnitEvent(EVENT_PLAYER_UNIT_PICKUP_ITEM);
+    t.addAction(() => {
+        const recipeItem = Item.fromEvent();
+        const unit = Unit.fromHandle(GetTriggerUnit());
+
+        if (!unit || !recipeItem) {
+            return;
+        }
+
+        //for every item they have, if any has the word recipe, then we check to see if they have the items needed to satisfy the recipe
+        for (let x = 0; x < 6; x++) {
+            const currItem = unit?.getItemInSlot(x);
+            if (currItem?.name.toLowerCase().includes("recipe")) {
+                checkItemRecipeRequirements(unit, currItem);
+            }
+        }
+    });
+}
+
+function checkItemRecipeRequirements(unit: Unit, recipeItem: Item) {
+    if (recipeItem.name.toLowerCase().includes("recipe")) {
+        let requiredItems: RecipeItemRequirement[] | null = null;
+        let itemToCreateId: number | null = null;
+
+        for (const [key, value] of itemRecipesMap.entries()) {
+            if (key.recipeId === recipeItem.typeId) {
+                requiredItems = value;
+                itemToCreateId = key.itemId;
+            }
+        }
+
+        if (!requiredItems) {
+            print("Missing required items data for the recipe ", recipeItem.name);
+            return;
+        }
+
+        /**
+         * unique list of item types and their quantity and charges that we found on the unit
+         */
+        const matchingItems: RecipeItemRequirement[] = [];
+
+        //Loop through the units item slots
+        for (let x = 0; x < 6; x++) {
+            const currItem = unit?.getItemInSlot(x);
+
+            //Check that the current item matches at least one of the item types in the requirement list
+            if (currItem && requiredItems.some((req) => req.itemTypeId === currItem.typeId)) {
+                const alreadyStoredItemIndex = matchingItems.findIndex((itemReq) => itemReq.itemTypeId === currItem.typeId);
+
+                //If we already came across this item in the unit inventory then increment the quantity
+                if (alreadyStoredItemIndex && matchingItems[alreadyStoredItemIndex]) {
+                    matchingItems[alreadyStoredItemIndex].quantity++;
+                }
+                //otherwise it is our first match with this item type, so add it to our array of matching items
+                else {
+                    matchingItems.push({ itemTypeId: currItem.typeId, quantity: 1, charges: 0 });
+                }
+            }
+        }
+
+        //Check that every item required is found in the units inventory satisfies the quantity requirement for the recipe
+        const satisfiesRecipe =
+            requiredItems.every((reqItemData) => {
+                const matching = matchingItems?.find((matchingItemData) => matchingItemData.itemTypeId === reqItemData.itemTypeId);
+
+                if (matching) {
+                    return matching.quantity >= reqItemData.quantity;
+                }
+
+                return false;
+            }) && matchingItems.length > 0;
+
+        if (!itemToCreateId) {
+            print("Missing the item type id of the item to create for this recipe: ", recipeItem.name);
+        }
+
+        //destroys more items than it needds to
+        if (satisfiesRecipe && itemToCreateId) {
+            //add the item
+            requiredItems.forEach((req: RecipeItemRequirement) => {
+                for (let x = 0; x < req.quantity; x++) {
+                    for (let x = 0; x < 6; x++) {
+                        const currItem = unit?.getItemInSlot(x);
+                        if (currItem?.typeId === req.itemTypeId) {
+                            currItem?.destroy();
+                            break;
+                        }
+                    }
+                }
+            });
+
+            recipeItem.destroy();
+
+            unit.addItemById(itemToCreateId);
+
+            useTempEffect(Effect.create("Abilities\\Spells\\Other\\Monsoon\\MonsoonBoltTarget.mdl", unit.x, unit.y));
+            const clap = Effect.create("Abilities\\Spells\\Human\\Thunderclap\\ThunderClapCaster.mdl", unit.x, unit.y);
+            clap?.setScaleMatrix(0.5, 0.5, 0.5);
+            useTempEffect(clap);
+        }
+
+        if (!satisfiesRecipe) {
+            //refund the gold
+            notifyPlayer(`Missing recipe requirements for: ${recipeItem.name}.`);
+        }
+
+        //use if or rf to store item gold cost in the world editor
+    }
+}
+
+/***
+ * Determines items that are created by recipes.
+ */
+export function registerItemsRecipes(recipesConfiguration: Map<RecipeItem, RecipeItemRequirement[]>) {
+    itemRecipesMap = recipesConfiguration;
+    trig_itemRecipeSystem();
+}
+
+export interface RecipeItemRequirement {
+    itemTypeId: number; //ITEMS;
+    quantity: number;
+    charges: number;
+}
+
+export interface RecipeItem {
+    recipeId: number;
+    itemId: number;
+}
+
+let itemRecipesMap = new Map<RecipeItem, RecipeItemRequirement[]>([
+    // [
+    //     { recipeId: ITEMS.recipe_blinkTreads, itemId: ITEMS.blinkTreads },
+    //     [
+    //         { itemTypeId: ITEMS.bootsOfSpeed, quantity: 1, charges: 0 }, //
+    //         { itemTypeId: ITEMS.blinkDagger, quantity: 1, charges: 0 }, //
+    //     ],
+    // ],
+]);

package/src/utils/math.ts

@@ -0,0 +1,14 @@
+/**
+ * @deprecated
+ * @param a
+ * @param b
+ * @returns
+ */
+export function distanceBetweenCoords(a: { x: number; y: number }, b: { x: number; y: number }) {
+    const deltaX = a.x - b.x;
+    const deltaY = a.y - b.y;
+    const squaredDist = Math.pow(deltaX, 2) + Math.pow(deltaY, 2);
+    const dist = Math.sqrt(squaredDist);
+
+    return dist;
+}

package/src/utils/minimapIcons.ts

@@ -0,0 +1,34 @@
+export type MINIMAP_ICONS =
+    | "UI\\Minimap\\MiniMap-ControlPoint.mdl"
+    | "UI\\Minimap\\MiniMap-QuestGiver.mdl"
+    | "UI\\Minimap\\Minimap-QuestObjectiveBonus.mdl"
+    | "UI\\Minimap\\Minimap-QuestObjectivePrimary.mdl"
+    | "UI\\Minimap\\Minimap-QuestTurnIn.mdl"
+    | "UI\\Minimap\\MiniMap-Hero.mdl"
+    | "UI\\Minimap\\Minimap-Ping.mdl"
+    | "UI\\Minimap\\MiniMap-Item.mdl"
+    | "UI\\Minimap\\MiniMap-NeutralBuilding.mdl";
+
+export enum MinimapIconPath {
+    controlPoint = "UI\\Minimap\\MiniMap-ControlPoint.mdl",
+    questGiver = "UI\\Minimap\\MiniMap-QuestGiver.mdl",
+    questObjectiveBonus = "UI\\Minimap\\Minimap-QuestObjectiveBonus.mdl",
+    questObjectivePrimary = "UI\\Minimap\\Minimap-QuestObjectivePrimary.mdl",
+    questTurnIn = "UI\\Minimap\\Minimap-QuestTurnIn.mdl",
+    hero = "UI\\Minimap\\MiniMap-Hero.mdl",
+    item = "UI\\Minimap\\MiniMap-Item.mdl",
+    neutralBuilding = "UI\\Minimap\\MiniMap-NeutralBuilding.mdl",
+    ping = "UI\\Minimap\\Minimap-Ping.mdl",
+}
+
+export const minimapIconPathsSet = new Set<MINIMAP_ICONS>([
+    "UI\\Minimap\\MiniMap-ControlPoint.mdl",
+    "UI\\Minimap\\MiniMap-Hero.mdl",
+    "UI\\Minimap\\MiniMap-Item.mdl",
+    "UI\\Minimap\\MiniMap-NeutralBuilding.mdl",
+    "UI\\Minimap\\MiniMap-QuestGiver.mdl",
+    "UI\\Minimap\\Minimap-Ping.mdl",
+    "UI\\Minimap\\Minimap-QuestObjectiveBonus.mdl",
+    "UI\\Minimap\\Minimap-QuestObjectivePrimary.mdl",
+    "UI\\Minimap\\Minimap-QuestTurnIn.mdl",
+]);