warcraft-3-w3ts-utils 0.1.12 → 0.1.13

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",
+]);

package/src/utils/misc.ts

@@ -0,0 +1,179 @@
+import { Effect, MapPlayer, Timer, Unit } from "w3ts";
+
+type ProperColors = "goldenrod" | "magenta" | "green" | "yellow" | "red" | "player1-red" | "player2-blue" | "player3-teal" | "player4-purple" | "player5-yellow" | "player6-orange";
+
+export function tColor(text: string | number, color?: ProperColors | null, hex?: PlayerColorHex | string | null, alpha?: string) {
+    if (color) {
+        return `|cff${properColorHexes.get(color) || "FFFFFF"}${alpha || ""}${text}|r`;
+    } else if (hex) {
+        return `|cff${hex}${alpha || ""}${text}|r`;
+    }
+
+    return String(text);
+}
+
+/**
+ * Colorizes the string according to the map player
+ */
+export function ptColor(player: MapPlayer, text: string) {
+    return `${tColor(text, undefined, playerColors[player.id])}`;
+}
+
+const properColorHexes = new Map<ProperColors, string>([
+    ["goldenrod", "ffcc00"],
+    ["green", "00FF00"],
+    ["yellow", "FFFF00"],
+    ["red", "FF0000"],
+    ["magenta", "FF00FF"],
+    ["player1-red", "ff0303"],
+    ["player2-blue", "0042ff"],
+    ["player3-teal", "1ce6b9"],
+    ["player4-purple", "540081"],
+    ["player5-yellow", "fffc00"],
+    ["player6-orange", "fe8a0e"],
+]);
+// enum PlayerColors {
+//     Player1 = "ff0303", // Red
+//     Player2 = "0042ff", // Blue
+//     Player3 = "1be7ba", // Teal
+//     Player4 = "550081", // Purple
+//     Player5 = "fefc00", // Yellow
+//     Player6 = "fe890d", // Orange
+//     Player7 = "21bf00", // Green
+//     Player8 = "e45caf", // Pink
+//     Player9 = "939596", // Gray
+//     Player10 = "7ebff1", // Light Blue
+//     Player11 = "106247", // Dark Green
+//     Player12 = "4f2b05", // Brown
+//     Player13 = "9c0000", // Maroon
+//     Player14 = "0000c3", // Navy
+//     Player15 = "00ebff", // Turquoise
+//     Player16 = "bd00ff", // Violet
+//     Player17 = "ecce87", // Wheat
+//     Player18 = "f7a58b", // Peach
+//     Player19 = "bfff81", // Mint
+//     Player20 = "dbb8eb", // Lavender
+//     Player21 = "4f5055", // Coal
+//     Player22 = "ecf0ff", // Snow
+//     Player23 = "00781e", // Emerald
+//     Player24 = "a56f34", // Peanut
+//     PlayerNeutral = "2e2d2e", // Black
+// }
+
+export enum PlayerColorHex {
+    Red = "ff0303",
+    Blue = "0042ff",
+    Teal = "1be7ba",
+    Purple = "550081",
+    Yellow = "fefc00",
+    Orange = "fe890d",
+    Green = "21bf00",
+    Pink = "e45caf",
+    Gray = "939596",
+    LightBlue = "7ebff1",
+    DarkGreen = "106247",
+    Brown = "4f2b05",
+    Maroon = "9c0000",
+    Navy = "0000c3",
+    Turquoise = "00ebff",
+    Violet = "bd00ff",
+    Wheat = "ecce87",
+    Peach = "f7a58b",
+    Mint = "bfff81",
+    Lavender = "dbb8eb",
+    Coal = "4f5055",
+    Snow = "ecf0ff",
+    Emerald = "00781e",
+    Peanut = "a56f34",
+    Black = "2e2d2e",
+}
+
+const playerColors = [
+    "ff0303", // Player 1: Red
+    "0042ff", // Player 2: Blue
+    "1be7ba", // Player 3: Teal
+    "550081", // Player 4: Purple
+    "fefc00", // Player 5: Yellow
+    "fe890d", // Player 6: Orange
+    "21bf00", // Player 7: Green
+    "e45caf", // Player 8: Pink
+    "939596", // Player 9: Gray
+    "7ebff1", // Player 10: Light Blue
+    "106247", // Player 11: Dark Green
+    "4f2b05", // Player 12: Brown
+    "9c0000", // Player 13: Maroon
+    "0000c3", // Player 14: Navy
+    "00ebff", // Player 15: Turquoise
+    "bd00ff", // Player 16: Violet
+    "ecce87", // Player 17: Wheat
+    "f7a58b", // Player 18: Peach
+    "bfff81", // Player 19: Mint
+    "dbb8eb", // Player 20: Lavender
+    "4f5055", // Player 21: Coal
+    "ecf0ff", // Player 22: Snow
+    "00781e", // Player 23: Emerald
+    "a56f34", // Player 24: Peanut
+    "2e2d2e", // Player Neutral: Black
+];
+
+/**
+ * Standardized format for notifying player of events.
+ */
+export function notifyPlayer(msg: string) {
+    print(`${tColor("!", "goldenrod")} - ${msg}`);
+}
+
+export function displayError(msg: string) {
+    print(`[ ${tColor("WARNING", "red")} ]: ${msg}`);
+}
+
+/**
+ * Returns degrees or radians?
+ */
+export function getRelativeAngleToUnit(unit: Unit, relativeUnit: Unit) {
+    const locA = GetUnitLoc(unit.handle);
+    const locB = GetUnitLoc(relativeUnit.handle);
+    const angle = AngleBetweenPoints(locA, locB);
+
+    RemoveLocation(locA);
+    RemoveLocation(locB);
+
+    return angle;
+}
+
+/**
+ * Manages state of effects in this context so you don't have to!
+ */
+export function useEffects() {
+    const effects: Effect[] = [];
+
+    return {
+        addEffect: (effect: Effect | undefined) => {
+            if (effect) {
+                effects.push(effect);
+            }
+        },
+        /**
+         * @returns reference to effects array
+         */
+        getEffects: () => {
+            return effects;
+        },
+        destroyAllEffects: () => {
+            effects.forEach((e) => {
+                e.destroy();
+            });
+        },
+    };
+}
+
+export function useTempEffect(effect: Effect | undefined, duration: number = 1.5) {
+    if (effect) {
+        const timer = Timer.create();
+
+        timer.start(duration, false, () => {
+            effect.destroy();
+            timer.destroy();
+        });
+    }
+}