warcraft-3-w3ts-utils 0.1.11 → 0.1.13

package/src/utils/point.ts

@@ -0,0 +1,81 @@
+import { Point, Rectangle } from "w3ts";
+const MAP_EDGE_BUFFER_DIST = 300;
+
+export function createValidPoint(maxAttempts: number, validatorFn: (p: Point) => {}) {
+    const MAX_ATTEMPTS = 65000; // 100 was about 10 seconds; 1000 gets good coverage
+    let currentAttempts = 0;
+    const worldBounds = Rectangle.fromHandle(GetWorldBounds());
+    if (!worldBounds) return;
+    const [maxX, maxY] = [GetCameraBoundMaxX(), GetCameraBoundMaxY()];
+
+    while (currentAttempts <= MAX_ATTEMPTS) {
+        const dirX = Math.floor(Math.random() * 100) >= 50 ? 1 : -1;
+        const dirY = Math.floor(Math.random() * 100) >= 50 ? 1 : -1;
+
+        //multiply dir by the buffer distance from max bounds since we can get a negative number
+        const randX = dirX * Math.ceil(Math.random() * maxX) - dirX * MAP_EDGE_BUFFER_DIST;
+        const randY = dirY * Math.ceil(Math.random() * maxY) - dirY * MAP_EDGE_BUFFER_DIST;
+
+        const p = Point.create(randX, randY);
+
+        const isValidPoint = validatorFn(p);
+
+        if (isValidPoint) {
+            // pointsChosen.push(p);
+            return p;
+        } else {
+            //well add it here later, just testing for now
+            currentAttempts++;
+        }
+    }
+}
+
+export function getRandomCoordinatesInCircularArea(relativeX: number, relativeY: number, radius: number) {
+    const randomTheta = Math.random() * 360;
+    const randomRadius = Math.random() * radius;
+
+    const randomX = relativeX + randomRadius * Cos(randomTheta);
+    const randomY = relativeY + randomRadius * Sin(randomTheta);
+
+    return {
+        x: randomX,
+        y: randomY,
+    };
+}
+
+export function getRandomCoordinatesOnCircle(relativeX: number, relativeY: number, radius: number) {
+    const randomTheta = Math.random() * 360;
+
+    const randomX = relativeX + radius * Cos(randomTheta);
+    const randomY = relativeY + radius * Sin(randomTheta);
+
+    return {
+        x: randomX,
+        y: randomY,
+    };
+}
+
+/**
+ * Returns degrees or radians?
+ */
+export function getAngleBetweenPoints(x1: number, y1: number, x2: number, y2: number) {
+    const locA = Location(x1, y1);
+    const locB = Location(x2, y2);
+
+    const angle = AngleBetweenPoints(locA, locB);
+    //arc tan
+    RemoveLocation(locA);
+    RemoveLocation(locB);
+
+    return angle;
+}
+
+export function distanceBetweenPoints(x1: number, y1: number, x2: number, y2: number) {
+    const deltaX = x1 - x2;
+    const deltaY = y1 - y2;
+    const squaredDist = deltaX * deltaX + deltaY * deltaY;
+    // const squaredDist = Math.pow(deltaX, 2) + Math.pow(deltaY, 2);
+    const dist = Math.sqrt(squaredDist);
+
+    return dist;
+}

package/src/utils/quests.ts

@@ -0,0 +1,38 @@
+import { Quest, Timer } from "w3ts";
+import { tColor } from "./misc";
+
+export function setup_quests() {
+    Timer.create().start(1, false, () => {
+        addQuest(
+            "Basic Game Info",
+            `\nA roguelite base assault game. \nChoose from a wide variety of units that are trained in various schools of magic and skills.\n Outsmart and counter your opponent..
+        `,
+            "ReplaceableTextures\\CommandButtons\\BTNPeasant.blp"
+        );
+
+        // \n${tColor("-fixSpawns", "goldenrod")}: Player 1 can only use this. This will fix add all player's spawn units to their corresponding spawn pool.
+        addQuest(
+            "Commands",
+            `
+            \n${tColor("-cam ####", "goldenrod")}: Sets the camera distance.
+            \n-playername xxxx   This will change your name.
+        `,
+            "ReplaceableTextures\\WorldEditUI\\Doodad-Cinematic.blp",
+            false
+        );
+
+        addQuest("|cffffcc00Evolution Castle Assault v0.01|r", "Created by JediMindTrix/NihilismIsDeath", "ReplaceableTextures\\CommandButtons\\BTNClayFigurine.blp", false);
+    });
+}
+
+export function addQuest(title: string, description: string, iconPath?: string, required: boolean = true) {
+    const q = Quest.create();
+    if (q) {
+        q.setTitle(title);
+        q.required = required;
+        q.setDescription(description);
+        if (iconPath) {
+            q.setIcon(iconPath);
+        }
+    }
+}

package/src/utils/textTag.ts

@@ -0,0 +1,80 @@
+import { TextTag, Trigger, Unit } from "w3ts";
+import { ptColor } from "./misc";
+import { delayedTimer } from "./timer";
+
+/**
+ * https://www.hiveworkshop.com/threads/floating-text.149719/
+ * 
+ * function CreateFloatingText takes string text, real x, real y, real heightOffset, real duration, real size returns nothing
+    local texttag tt = CreateTextTag()
+    call SetTextTagText(tt, text, size)
+    call SetTextTagPos(tt, x, y, heightOffset)
+    call SetTextTagColor(tt, 255, 255, 255, 255) // RGBA format
+    call SetTextTagVisibility(tt, true)
+    call SetTextTagLifespan(tt, duration)
+    call SetTextTagPermanent(tt, false)
+endfunction
+
+function ExampleUsage takes nothing returns nothing
+    call CreateFloatingText("Hello World", 0.0, 0.0, 25.0, 5.0, 10.0)
+endfunction
+ * @param unit 
+ * @param text 
+ * @param duration 
+ */
+export function createFloatingTextTagOnUnit(unit: Unit, text: string, config?: { duration?: number; yVelocity?: number; xVelocity?: number; useFade?: boolean }) {
+    const tag = TextTag.create();
+    tag?.setVisible(true);
+
+    tag?.setText(text, 10, true);
+
+    tag?.setLifespan(config?.duration === undefined ? 2 : config.duration);
+
+    if (config?.useFade !== false) {
+        tag?.setFadepoint(0.01);
+    }
+
+    tag?.setVelocity(config?.xVelocity === undefined ? 0 : config.xVelocity, config?.yVelocity === undefined ? 0.025 : config.yVelocity);
+    tag?.setPermanent(false);
+
+    tag?.setPosUnit(unit, 10);
+
+    if (config && config.duration && config.duration === 0) {
+        return;
+    }
+
+    delayedTimer(config?.duration ?? 2, () => {
+        tag?.destroy();
+    });
+}
+
+export function createPermanentTextTagOnPoint(text: string, x: number, y: number) {
+    const tag = TextTag.create();
+    tag?.setVisible(true);
+
+    tag?.setText(text, 20, true);
+    tag?.setLifespan(2);
+
+    tag?.setVelocity(0, 0);
+    tag?.setPermanent(true);
+    tag?.setPos(x, y, 20);
+}
+
+export function setup_createTextForSpellCast() {
+    const t = Trigger.create();
+
+    t.registerAnyUnitEvent(EVENT_PLAYER_UNIT_SPELL_EFFECT);
+
+    t.addAction(() => {
+        const u = Unit.fromEvent();
+
+        if (u) {
+            const spellNumber = GetSpellAbilityId();
+            const spellName = GetAbilityName(spellNumber);
+            if (!spellName || spellName === "Default String") return;
+            //alt + 0164 ¤
+            //alt + 0149 •
+            createFloatingTextTagOnUnit(u, ptColor(u.owner, "¤  ") + spellName);
+        }
+    });
+}

package/src/utils/timer.ts

@@ -0,0 +1,14 @@
+import { Timer } from "w3ts";
+
+/**
+ * @param duration milliseconds
+ */
+export function delayedTimer(duration: number, cb: (...args: any[]) => any) {
+    const timer = Timer.create();
+    timer.start(duration, false, () => {
+        cb();
+        timer.destroy();
+    });
+
+    return timer;
+}

package/src/utils/units.ts

@@ -0,0 +1,84 @@
+import { Group, MapPlayer, Timer, Unit } from "w3ts";
+import { adjustGold, adjustLumber } from "./players";
+
+export function createUnits(quantity: number, useFood: boolean, ...args: Parameters<typeof Unit.create>) {
+    const units: Unit[] = [];
+    for (let x = 0; x < quantity; x++) {
+        const u = Unit.create(...args);
+
+        if (u) {
+            u.setUseFood(useFood);
+            units.push(u);
+        }
+    }
+
+    return units;
+}
+
+/**
+ * Refund unit's gold and wood cost.
+ * @param u
+ */
+export function refundUnitCost(u: Unit) {
+    const gold = GetUnitGoldCost(u.typeId);
+    const wood = GetUnitWoodCost(u.typeId);
+    adjustGold(u.owner, gold);
+    adjustLumber(u.owner, wood);
+}
+
+/**
+ * Returns true if the ALIVE unit has the ability within their first 12 abilities
+ * @param unit
+ * @param abilityId
+ * @returns
+ */
+export function unitHasAbility(unit: Unit, abilityId: number): boolean {
+    for (let x = 0; x < 12; x++) {
+        const currentAbility = unit.getAbilityByIndex(x);
+
+        if (currentAbility && currentAbility === unit.getAbility(abilityId) && unit.isAlive()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+export function unitsInRange(x: number, y: number, radius: number, cb: (unit: Unit) => void) {
+    const g = Group.create();
+    if (g) {
+        g.enumUnitsInRange(x, y, radius, () => {
+            const unit = Unit.fromFilter();
+            if (unit) {
+                cb(unit);
+            }
+            return true;
+        });
+
+        g.destroy();
+    }
+}
+
+/**
+ *
+ * @param cb
+ * @param abilityId
+ * @param owner
+ */
+export function useTempDummyUnit(dummyUnitCode: number, cb: (dummy: Unit) => void, abilityId: number, owner: MapPlayer, x: number, y: number, config?: { facing?: number; abilityLevel?: number; dummyLifeSpan?: number }) {
+    let dummy: Unit | undefined = undefined;
+    dummy = Unit.create(owner, dummyUnitCode, x, y, config?.facing ?? 0);
+
+    const t = Timer.create();
+
+    if (dummy) {
+        dummy.addAbility(abilityId);
+        dummy.setAbilityManaCost(abilityId, config?.abilityLevel ? config.abilityLevel - 1 : 0, 0);
+        cb(dummy);
+
+        t.start(config?.dummyLifeSpan ?? 2, false, () => {
+            dummy?.destroy();
+            t.destroy();
+        });
+    }
+}