warcraft-3-w3ts-utils 0.1.3 → 0.1.6

package/dist/utils/physics.d.ts

@@ -0,0 +1,52 @@
+import { Effect, Unit } from "w3ts";
+interface ApplyForceConfig {
+    /**
+     * Default: 0
+     */
+    sustainedForceDuration?: number;
+    /**
+     * Default: -2400 units per second
+     */
+    frictionConstant?: number;
+    /**
+     * The unit will not phase through unpathable areas
+     */
+    obeyPathing?: boolean;
+    whileActive?: (currentSpeed?: number, timeElapsed?: number) => void;
+    onStart?: (currentSpeed?: number, timeElapsed?: number) => void;
+    onEnd?: (currentSpeed?: number, timeElapsed?: number) => void;
+    /**
+     *
+     */
+    targetSpeed?: number;
+    /**
+     * In seconds
+     */
+    accelerationTime?: number;
+    /**
+     * This will be used to decide if the unit the force is applied on is allowed to deviate from their current path.
+     */
+    strictPathing?: boolean;
+    animationIndexNumber?: number;
+    dummyUnitPlayerIndex: number;
+    dummyUnitFourCC: number;
+}
+/**
+ * @param angle degrees
+ * @param unit
+ * @param initialSpeed meters per second
+ * @param affectHeight determines whether or not to change unit height whilst force is applied
+ */
+export declare function applyForce(angle: number, unit: Unit, initialSpeed: number, config: ApplyForceConfig): {
+    destroyForceEffect: (runOnEnd?: boolean) => void;
+};
+/**
+ * @param angle degrees
+ * @param effect
+ * @param initialSpeed meters per second
+ * @param affectHeight determines whether or not to change unit height whilst force is applied
+ */
+export declare function applyForceForEffect(angle: number, effect: Effect, initialSpeed: number, config?: ApplyForceConfig): {
+    destroyForceEffect: () => void;
+};
+export {};

package/dist/utils/physics.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyForce = applyForce;
+exports.applyForceForEffect = applyForceForEffect;
+// import { WTS_Units } from "src/enums/WTS_Enums";
+// import { PlayerIndex } from "src/player/player-data";
+const w3ts_1 = require("w3ts");
+const globals_1 = require("w3ts/globals");
+/**
+ * @param angle degrees
+ * @param unit
+ * @param initialSpeed meters per second
+ * @param affectHeight determines whether or not to change unit height whilst force is applied
+ */
+function applyForce(angle, unit, initialSpeed, config) {
+    const timer = w3ts_1.Timer.create();
+    const refreshInterval = 0.01;
+    const updatesPerSecond = 1 / refreshInterval;
+    const frictionConstant = 4800; //meters per second friction decay
+    let currentSpeed = initialSpeed;
+    let timeElapsed = 0;
+    const clickMoveOrder = 851971;
+    const moveOrders = [
+        851986 /* OrderId.Move */,
+        851984 /* OrderId.Attackground */,
+        851990 /* OrderId.Patrol */,
+        851983 /* OrderId.Attack */,
+        clickMoveOrder,
+    ];
+    let forceDummyUnit = undefined;
+    const defaultX = 11800;
+    const defaultY = -5700;
+    //Cancel unit commands - if a unit already has a move command and are applied a force, they will bug out sometimes and walk in the opposite direction
+    // unit.issueImmediateOrder(OrderId.Stop);
+    /**
+     * Prematurely end the force effect
+     */
+    function destroyForceEffect(runOnEnd = false) {
+        if (runOnEnd && config?.onEnd) {
+            config.onEnd();
+        }
+        ResetUnitAnimation(unit.handle);
+        forceDummyUnit?.destroy();
+        timer.destroy();
+    }
+    /**
+     * These are the positions the unit would be if there were no minor disturbances
+     */
+    let theoreticalX = unit.x;
+    let theoreticalY = unit.y;
+    /**
+     * The distance the true unit position can be from the theoretical position. Helps stop sliding against walls, etc.
+     */
+    // const BREAK_DISTANCE = 100;
+    if (!forceDummyUnit) {
+        forceDummyUnit = w3ts_1.Unit.create(globals_1.Players[config.dummyUnitPlayerIndex], config.dummyUnitPlayerIndex, defaultX, defaultY);
+    }
+    // unit.issueImmediateOrder(OrderId.Stop);
+    if (config?.animationIndexNumber) {
+        ResetUnitAnimation(unit.handle);
+        SetUnitAnimationByIndex(unit.handle, config.animationIndexNumber);
+    }
+    timer.start(refreshInterval, true, () => {
+        //If for whatever reason the unit no longer exists.
+        if (!unit) {
+            destroyForceEffect();
+            return destroyForceEffect;
+        }
+        // if (distanceBetweenPoints(unit.x, unit.y, theoreticalX, theoreticalY) > BREAK_DISTANCE) {
+        //     print("unit was to far away from theoretical distance");
+        //     const e = Effect.create("Abilities\\Spells\\Other\\TalkToMe\\TalkToMe", theoreticalX, theoreticalY);
+        //     e?.setScaleMatrix(2, 2, 2);
+        //     unit.issueImmediateOrder(OrderId.Stop);
+        //     destroyForceEffect(true);
+        //     return;
+        // }
+        //if the unit's move speed vector is greater than the remaining applied force vector then we may stop the applied force function; should only run while the unit has the move order
+        // if (config?.obeyPathing && !config.strictPathing && currentSpeed > unit.moveSpeed) {
+        //     unit.issueImmediateOrder(OrderId.Stop);
+        // }
+        //should probably only do strict pathing so nothing else interfers with the unit moving
+        if (forceDummyUnit && config?.strictPathing) {
+            const isWindWalked = UnitHasBuffBJ(forceDummyUnit.handle, FourCC("BOwk"));
+            if (!isWindWalked) {
+                forceDummyUnit.issueImmediateOrder(852129 /* OrderId.Windwalk */);
+            }
+            // forceDummyUnit.issueImmediateOrder(OrderId.Stop);
+            //Move dummy to the position we want the unit to be in
+            forceDummyUnit.x = unit.x;
+            forceDummyUnit.y = unit.y;
+            forceDummyUnit.issueImmediateOrder(851972 /* OrderId.Stop */);
+            //flooring values since it can be off sometimes by a thousandth
+            if (Math.floor(forceDummyUnit.x) !== Math.floor(unit.x) ||
+                Math.floor(forceDummyUnit.y) !== Math.floor(unit.y)) {
+                // print(`Collision detected! Dummy x: ${forceDummyUnit.x} y: ${forceDummyUnit.y} Unit x: ${unit.x} y: ${unit.y}`);
+                const e = w3ts_1.Effect.create("Abilities\\Spells\\Other\\TalkToMe\\TalkToMe", forceDummyUnit.x, forceDummyUnit.y);
+                e?.setScaleMatrix(2, 2, 2);
+                destroyForceEffect(true);
+                return;
+            }
+        }
+        const xVelocity = (currentSpeed / updatesPerSecond) * Math.cos(Deg2Rad(angle));
+        const yVelocity = (currentSpeed / updatesPerSecond) * Math.sin(Deg2Rad(angle));
+        //Complete execution when current speed of the initial force has decayed
+        if (currentSpeed <= 0) {
+            destroyForceEffect(true);
+            return;
+        }
+        //Runs when the force is first applied
+        if (config?.onStart && currentSpeed === initialSpeed) {
+            config.onStart(currentSpeed, timeElapsed);
+        }
+        //Runs at any point while the function is executing
+        if (config?.whileActive) {
+            config.whileActive(currentSpeed, timeElapsed);
+        }
+        theoreticalX += xVelocity;
+        theoreticalY += yVelocity;
+        //basically the same thing now since we are no longer issuing the stop command on the unit.
+        //also the moment another force is applied to the unit the previous force will stop being applied.
+        if (config?.strictPathing) {
+            unit.x = theoreticalX;
+            unit.y = theoreticalY;
+        }
+        else {
+            unit.x += xVelocity;
+            unit.y += yVelocity;
+        }
+        timeElapsed += refreshInterval;
+        if (config?.sustainedForceDuration &&
+            timeElapsed <= config.sustainedForceDuration) {
+            return;
+        }
+        currentSpeed -= frictionConstant / updatesPerSecond;
+    });
+    return { destroyForceEffect };
+}
+/**
+ * @param angle degrees
+ * @param effect
+ * @param initialSpeed meters per second
+ * @param affectHeight determines whether or not to change unit height whilst force is applied
+ */
+function applyForceForEffect(angle, effect, initialSpeed, config) {
+    const timer = w3ts_1.Timer.create();
+    const refreshInterval = 0.01;
+    const updatesPerSecond = 1 / refreshInterval;
+    const frictionConstant = 1200; //meters per second friction decay
+    let currentSpeed = initialSpeed;
+    let timeElapsed = 0;
+    //Cancel unit commands - if a unit already has a move command and are applied a force, they will bug out sometimes and walk in the opposite direction
+    timer.start(refreshInterval, true, () => {
+        //if the unit's move speed vector is greater than the remaining applied force vector then we may stop the applied force function; should only run while the unit has the move order
+        const xVelocity = (currentSpeed / updatesPerSecond) * Math.cos(Deg2Rad(angle));
+        const yVelocity = (currentSpeed / updatesPerSecond) * Math.sin(Deg2Rad(angle));
+        //On end hook runs before the timer is destroyed and the function ends
+        if (config?.onEnd && currentSpeed <= 0) {
+            config.onEnd(currentSpeed, timeElapsed);
+        }
+        //Complete execution when current speed of the initial force has decayed
+        if (currentSpeed <= 0) {
+            timer.destroy();
+            return;
+        }
+        //Runs when the force is first applied
+        if (config?.onStart && currentSpeed === initialSpeed) {
+            config.onStart(currentSpeed, timeElapsed);
+        }
+        //Runs at any point while the function is executing
+        if (config?.whileActive) {
+            config.whileActive(currentSpeed, timeElapsed);
+        }
+        effect.x += xVelocity;
+        effect.y += yVelocity;
+        timeElapsed += refreshInterval;
+        if (config?.sustainedForceDuration &&
+            timeElapsed <= config.sustainedForceDuration) {
+            return;
+        }
+        currentSpeed -= frictionConstant / updatesPerSecond;
+    });
+    function destroyForceEffect() {
+        timer.destroy();
+    }
+    return { destroyForceEffect };
+}
+// const unitIsMovingVector_x = (unit.moveSpeed / updatesPerSecond) * Math.cos(Deg2Rad(unit.facing));
+// const unitIsMovingVector_y = (unit.moveSpeed / updatesPerSecond) * Math.sin(Deg2Rad(unit.facing));
+// if ((moveOrders.includes(unit.currentOrder) && unitIsMovingVector_x > xVelocity) || unitIsMovingVector_y > yVelocity) {
+//     print("moving velocity exceeded applied force velocity");
+//     timer.destroy();
+//     return;
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/players.d.ts

@@ -0,0 +1,50 @@
+import { MapPlayer, Rectangle, Unit } from "w3ts";
+/**
+ * Does a callback for every unit of the player that has the ability
+ * @param player
+ * @param abilityId
+ * @param cb
+ */
+export declare function forEachUnitOfPlayerWithAbility(player: MapPlayer, abilityId: number, cb: (unit: Unit) => void): void;
+/**
+ * Calls a function for each player playing and is an ally of red.
+ * @warning specific to map
+ */
+export declare function forEachAlliedPlayer(cb: (player: MapPlayer, index: number) => void): void;
+export declare function forEachPlayer(cb: (player: MapPlayer, index: number) => void): void;
+/**
+ * Executes the callback function for each unit matching the unit type for the player
+ * @param unitType Unit Type Id or the Unit Type String "hcas", etc
+ */
+export declare function forEachUnitTypeOfPlayer(unitType: number | string, player: MapPlayer, cb: (unit: Unit) => void): void;
+/**
+ * Doesn;'t appear to actually work?
+ * @broken
+ * @param unitName
+ * @param unitType
+ * @param fn
+ */
+export declare function forEachUnitOfType(unitName: string, unitType: number | string, fn: (unit: Unit) => void): void;
+/**
+ * @param unitType Unit Type Id or the Unit Type String "hcas", etc
+ */
+export declare function forEachUnitOfPlayer(player: MapPlayer, cb: (unit: Unit) => void): void;
+/**
+ * Executes the callback function for each unit matching the unit type for the player
+ * @param unitType Unit Type Id or the Unit Type String "hcas", etc
+ */
+export declare function forEachUnitInRectangle(rectangle: Rectangle, cb: (unit: Unit) => void): void;
+export declare function isPlaying(player: MapPlayer | player): boolean;
+export declare function isUser(player: MapPlayer | player): boolean;
+export declare function isComputer(player: MapPlayer): boolean;
+export declare function isPlayingUser(player: MapPlayer | player): boolean;
+export declare function adjustPlayerState(player: MapPlayer, whichState: playerstate, amount: number): void;
+export declare function adjustGold(player: MapPlayer, amount: number): void;
+export declare function adjustLumber(player: MapPlayer, amount: number): void;
+export declare function adjustFoodCap(player: MapPlayer, amount: number): void;
+export declare function adjustFoodUsed(player: MapPlayer, amount: number): void;
+export declare function playerHasResources(player: MapPlayer, data: {
+    gold?: number;
+    lumber?: number;
+}): boolean;
+export declare function setPlayerName(): void;

package/dist/utils/players.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachUnitOfPlayerWithAbility = forEachUnitOfPlayerWithAbility;
+exports.forEachAlliedPlayer = forEachAlliedPlayer;
+exports.forEachPlayer = forEachPlayer;
+exports.forEachUnitTypeOfPlayer = forEachUnitTypeOfPlayer;
+exports.forEachUnitOfType = forEachUnitOfType;
+exports.forEachUnitOfPlayer = forEachUnitOfPlayer;
+exports.forEachUnitInRectangle = forEachUnitInRectangle;
+exports.isPlaying = isPlaying;
+exports.isUser = isUser;
+exports.isComputer = isComputer;
+exports.isPlayingUser = isPlayingUser;
+exports.adjustPlayerState = adjustPlayerState;
+exports.adjustGold = adjustGold;
+exports.adjustLumber = adjustLumber;
+exports.adjustFoodCap = adjustFoodCap;
+exports.adjustFoodUsed = adjustFoodUsed;
+exports.playerHasResources = playerHasResources;
+exports.setPlayerName = setPlayerName;
+const w3ts_1 = require("w3ts");
+const globals_1 = require("w3ts/globals");
+/**
+ * Does a callback for every unit of the player that has the ability
+ * @param player
+ * @param abilityId
+ * @param cb
+ */
+function forEachUnitOfPlayerWithAbility(player, abilityId, cb) {
+    forEachUnitOfPlayer(player, (u) => {
+        for (let x = 0; x < 12; x++) {
+            const currentAbility = u.getAbilityByIndex(x);
+            if (currentAbility && currentAbility === u.getAbility(abilityId) && u.isAlive()) {
+                cb(u);
+            }
+        }
+    });
+}
+/**
+ * Calls a function for each player playing and is an ally of red.
+ * @warning specific to map
+ */
+function forEachAlliedPlayer(cb) {
+    globals_1.Players.forEach((player, index) => {
+        //For testing purposes, include player[9] (the human ally) so their units can also be included when iterating the units OR i should make a separate function for all units.
+        if (player.slotState === PLAYER_SLOT_STATE_PLAYING && player.isPlayerAlly(globals_1.Players[0]) && player != globals_1.Players[25] && player != globals_1.Players[27]) {
+            cb(player, index);
+        }
+    });
+}
+function forEachPlayer(cb) {
+    globals_1.Players.forEach((p, index) => {
+        cb(p, index);
+    });
+}
+/**
+ * Executes the callback function for each unit matching the unit type for the player
+ * @param unitType Unit Type Id or the Unit Type String "hcas", etc
+ */
+function forEachUnitTypeOfPlayer(unitType, player, cb) {
+    if (typeof unitType === "string") {
+        unitType = FourCC(unitType);
+    }
+    const g = w3ts_1.Group.create();
+    g?.enumUnitsOfPlayer(player, () => {
+        const unit = w3ts_1.Group.getFilterUnit();
+        if (unit && unit?.typeId === unitType) {
+            cb(unit);
+        }
+        return true;
+    });
+    g?.destroy();
+}
+/**
+ * Doesn;'t appear to actually work?
+ * @broken
+ * @param unitName
+ * @param unitType
+ * @param fn
+ */
+function forEachUnitOfType(unitName, unitType, fn) {
+    if (typeof unitType === "string") {
+        unitType = FourCC(unitType);
+    }
+    print(unitName);
+    const g = w3ts_1.Group.create();
+    g?.enumUnitsOfType(unitName, () => {
+        const unit = w3ts_1.Group.getFilterUnit();
+        if (unit && unit?.typeId === unitType) {
+            fn(unit);
+        }
+        return true;
+    });
+    print(`Total units of name ${unitName} found: ${g?.size}`);
+    g?.destroy();
+}
+/**
+ * @param unitType Unit Type Id or the Unit Type String "hcas", etc
+ */
+function forEachUnitOfPlayer(player, cb) {
+    const g = w3ts_1.Group.create();
+    g?.enumUnitsOfPlayer(player, () => {
+        const unit = w3ts_1.Group.getFilterUnit();
+        if (!unit) {
+            print("Enumerating over a unit that doesn't exist!");
+        }
+        if (unit) {
+            cb(unit);
+        }
+        return true;
+    });
+    g?.destroy();
+}
+/**
+ * Executes the callback function for each unit matching the unit type for the player
+ * @param unitType Unit Type Id or the Unit Type String "hcas", etc
+ */
+function forEachUnitInRectangle(rectangle, cb) {
+    const g = w3ts_1.Group.create();
+    g?.enumUnitsInRect(rectangle, () => {
+        const unit = w3ts_1.Group.getFilterUnit();
+        if (unit) {
+            cb(unit);
+        }
+        return true;
+    });
+    g?.destroy();
+}
+function isPlaying(player) {
+    if (player instanceof w3ts_1.MapPlayer) {
+        return player.slotState === PLAYER_SLOT_STATE_PLAYING;
+    }
+    return GetPlayerSlotState(player) === PLAYER_SLOT_STATE_PLAYING;
+}
+function isUser(player) {
+    if (player instanceof w3ts_1.MapPlayer) {
+        return GetPlayerController(player.handle) === MAP_CONTROL_USER;
+    }
+    return GetPlayerController(player) === MAP_CONTROL_USER;
+}
+function isComputer(player) {
+    if (player instanceof w3ts_1.MapPlayer) {
+        return GetPlayerController(player.handle) === MAP_CONTROL_COMPUTER;
+    }
+    return GetPlayerController(player) === MAP_CONTROL_COMPUTER;
+}
+function isPlayingUser(player) {
+    return isUser(player) && isPlaying(player);
+}
+function adjustPlayerState(player, whichState, amount) {
+    player.setState(whichState, player.getState(whichState) + amount);
+}
+function adjustGold(player, amount) {
+    player.setState(PLAYER_STATE_RESOURCE_GOLD, player.getState(PLAYER_STATE_RESOURCE_GOLD) + amount);
+}
+function adjustLumber(player, amount) {
+    player.setState(PLAYER_STATE_RESOURCE_LUMBER, player.getState(PLAYER_STATE_RESOURCE_LUMBER) + amount);
+}
+function adjustFoodCap(player, amount) {
+    player.setState(PLAYER_STATE_RESOURCE_FOOD_CAP, player.getState(PLAYER_STATE_RESOURCE_FOOD_CAP) + amount);
+}
+function adjustFoodUsed(player, amount) {
+    player.setState(PLAYER_STATE_RESOURCE_FOOD_USED, player.getState(PLAYER_STATE_RESOURCE_FOOD_USED) + amount);
+}
+function playerHasResources(player, data) {
+    let hasGold = true;
+    let hasLumber = true;
+    if (data.gold && data.gold != 0) {
+        hasGold = player.getState(PLAYER_STATE_RESOURCE_GOLD) >= data.gold;
+    }
+    if (data.lumber && data.lumber != 0) {
+        hasLumber = player.getState(PLAYER_STATE_RESOURCE_LUMBER) >= data.lumber;
+    }
+    return hasGold && hasLumber;
+}
+function setPlayerName() {
+    const t = w3ts_1.Trigger.create();
+    forEachPlayer((p) => {
+        t.registerPlayerChatEvent(p, "-playername ", false);
+        t.addAction(() => {
+            const str = GetEventPlayerChatString();
+            const newName = str?.replace("-playername", "");
+            if (newName) {
+                SetPlayerName(p.handle, newName);
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/point.d.ts

@@ -0,0 +1,15 @@
+import { Point } from "w3ts";
+export declare function createValidPoint(maxAttempts: number, validatorFn: (p: Point) => {}): Point | undefined;
+export declare function getRandomCoordinatesInCircularArea(relativeX: number, relativeY: number, radius: number): {
+    x: number;
+    y: number;
+};
+export declare function getRandomCoordinatesOnCircle(relativeX: number, relativeY: number, radius: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Returns degrees or radians?
+ */
+export declare function getAngleBetweenPoints(x1: number, y1: number, x2: number, y2: number): number;
+export declare function distanceBetweenPoints(x1: number, y1: number, x2: number, y2: number): number;

package/dist/utils/point.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidPoint = createValidPoint;
+exports.getRandomCoordinatesInCircularArea = getRandomCoordinatesInCircularArea;
+exports.getRandomCoordinatesOnCircle = getRandomCoordinatesOnCircle;
+exports.getAngleBetweenPoints = getAngleBetweenPoints;
+exports.distanceBetweenPoints = distanceBetweenPoints;
+const w3ts_1 = require("w3ts");
+const MAP_EDGE_BUFFER_DIST = 300;
+function createValidPoint(maxAttempts, validatorFn) {
+    const MAX_ATTEMPTS = 65000; // 100 was about 10 seconds; 1000 gets good coverage
+    let currentAttempts = 0;
+    const worldBounds = w3ts_1.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 = w3ts_1.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++;
+        }
+    }
+}
+function getRandomCoordinatesInCircularArea(relativeX, relativeY, radius) {
+    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,
+    };
+}
+function getRandomCoordinatesOnCircle(relativeX, relativeY, radius) {
+    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?
+ */
+function getAngleBetweenPoints(x1, y1, x2, y2) {
+    const locA = Location(x1, y1);
+    const locB = Location(x2, y2);
+    const angle = AngleBetweenPoints(locA, locB);
+    //arc tan
+    RemoveLocation(locA);
+    RemoveLocation(locB);
+    return angle;
+}
+function distanceBetweenPoints(x1, y1, x2, y2) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/quests.d.ts

@@ -0,0 +1,2 @@
+export declare function setup_quests(): void;
+export declare function addQuest(title: string, description: string, iconPath?: string, required?: boolean): void;

package/dist/utils/quests.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup_quests = setup_quests;
+exports.addQuest = addQuest;
+const w3ts_1 = require("w3ts");
+const misc_1 = require("./misc");
+function setup_quests() {
+    w3ts_1.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${(0, misc_1.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);
+    });
+}
+function addQuest(title, description, iconPath, required = true) {
+    const q = w3ts_1.Quest.create();
+    if (q) {
+        q.setTitle(title);
+        q.required = required;
+        q.setDescription(description);
+        if (iconPath) {
+            q.setIcon(iconPath);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlc3RzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3F1ZXN0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLG9DQXNCQztBQUVELDRCQVVDO0FBckNELCtCQUFvQztBQUNwQyxpQ0FBZ0M7QUFFaEMsU0FBZ0IsWUFBWTtJQUN4QixZQUFLLENBQUMsTUFBTSxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFO1FBQ2hDLFFBQVEsQ0FDSixpQkFBaUIsRUFDakI7U0FDSCxFQUNHLHFEQUFxRCxDQUN4RCxDQUFDO1FBRUYsb0pBQW9KO1FBQ3BKLFFBQVEsQ0FDSixVQUFVLEVBQ1Y7Z0JBQ0ksSUFBQSxhQUFNLEVBQUMsV0FBVyxFQUFFLFdBQVcsQ0FBQzs7U0FFdkMsRUFDRyx3REFBd0QsRUFDeEQsS0FBSyxDQUNSLENBQUM7UUFFRixRQUFRLENBQUMsNENBQTRDLEVBQUUseUNBQXlDLEVBQUUsMERBQTBELEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDekssQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDO0FBRUQsU0FBZ0IsUUFBUSxDQUFDLEtBQWEsRUFBRSxXQUFtQixFQUFFLFFBQWlCLEVBQUUsV0FBb0IsSUFBSTtJQUNwRyxNQUFNLENBQUMsR0FBRyxZQUFLLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDekIsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUNKLENBQUMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDbEIsQ0FBQyxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7UUFDdEIsQ0FBQyxDQUFDLGNBQWMsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUM5QixJQUFJLFFBQVEsRUFBRSxDQUFDO1lBQ1gsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUN4QixDQUFDO0lBQ0wsQ0FBQztBQUNMLENBQUMifQ==