isaacscript-common 6.6.1-dev.1 → 6.6.1-dev.2

package/functions/ambush.js

@@ -0,0 +1,35 @@
+import { SackSubType } from "isaac-typescript-definitions";
+import { runNextGameFrame } from "../features/runInNFrames";
+import { removeEntities } from "./entity";
+import { getCoins, spawnSackWithSeed } from "./pickups";
+/** Hard-coding this makes it easier to clean up the pickups afterwards. */
+const SACK_SEED_THAT_SPAWNS_TWO_COINS = 6;
+/**
+ * Helper function to start a Challenge Room or the Boss Rush.
+ *
+ * Specifically, this is performed by spawning a sack on top of the player, waiting a game frame,
+ * and then removing the sack and the pickups that the sack dropped.
+ */
+export function startAmbush() {
+    const player = Isaac.GetPlayer();
+    const sack = spawnSackWithSeed(SackSubType.NULL, player.Position, SACK_SEED_THAT_SPAWNS_TWO_COINS);
+    // The sack will play the "Appear" animation and the player will not be able to interact with it
+    // while this is occurring. By stopping the animation, it will transition to the "Idle" animation
+    // and be interactable on the next game frame.
+    const sprite = sack.GetSprite();
+    sprite.Stop();
+    const sackPtr = EntityPtr(sack);
+    runNextGameFrame(() => {
+        const futureSack = sackPtr.Ref;
+        if (futureSack === undefined) {
+            return;
+        }
+        futureSack.Remove();
+        const sackPtrHash = GetPtrHash(futureSack);
+        const coins = getCoins();
+        const coinsFromSack = coins.filter((pickup) => pickup.SpawnerEntity !== undefined &&
+            GetPtrHash(pickup.SpawnerEntity) === sackPtrHash);
+        removeEntities(coinsFromSack);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW1idXNoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvYW1idXNoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFeEQsMkVBQTJFO0FBQzNFLE1BQU0sK0JBQStCLEdBQUcsQ0FBUyxDQUFDO0FBRWxEOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLFdBQVc7SUFDekIsTUFBTSxNQUFNLEdBQUcsS0FBSyxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ2pDLE1BQU0sSUFBSSxHQUFHLGlCQUFpQixDQUM1QixXQUFXLENBQUMsSUFBSSxFQUNoQixNQUFNLENBQUMsUUFBUSxFQUNmLCtCQUErQixDQUNoQyxDQUFDO0lBRUYsZ0dBQWdHO0lBQ2hHLGlHQUFpRztJQUNqRyw4Q0FBOEM7SUFDOUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDO0lBQ2hDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNkLE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUNoQyxnQkFBZ0IsQ0FBQyxHQUFHLEVBQUU7UUFDcEIsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQztRQUMvQixJQUFJLFVBQVUsS0FBSyxTQUFTLEVBQUU7WUFDNUIsT0FBTztTQUNSO1FBRUQsVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ3BCLE1BQU0sV0FBVyxHQUFHLFVBQVUsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUMzQyxNQUFNLEtBQUssR0FBRyxRQUFRLEVBQUUsQ0FBQztRQUN6QixNQUFNLGFBQWEsR0FBRyxLQUFLLENBQUMsTUFBTSxDQUNoQyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQ1QsTUFBTSxDQUFDLGFBQWEsS0FBSyxTQUFTO1lBQ2xDLFVBQVUsQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLEtBQUssV0FBVyxDQUNuRCxDQUFDO1FBQ0YsY0FBYyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQ2hDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyJ9

package/functions/array.js

@@ -0,0 +1,423 @@
+import { getRandomInt } from "./random";
+import { getRandomSeed, isRNG, newRNG } from "./rng";
+import { isNumber, isTable } from "./types";
+import { erange, repeat } from "./utils";
+/**
+ * Helper function for determining if two arrays contain the exact same elements. Note that this
+ * only performs a shallow comparison.
+ */
+export function arrayEquals(array1, array2) {
+    if (array1.length !== array2.length) {
+        return false;
+    }
+    return array1.every((array1Element, i) => {
+        const array2Element = array2[i];
+        return array1Element === array2Element;
+    });
+}
+/**
+ * Shallow copies and removes the specified element(s) from the array. Returns the copied array. If
+ * the specified element(s) are not found in the array, it will simply return a shallow copy of the
+ * array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will only remove the first
+ * matching element. If you want to remove all of the elements, use the `arrayRemoveAll` function
+ * instead.
+ */
+export function arrayRemove(originalArray, ...elementsToRemove) {
+    const array = copyArray(originalArray);
+    arrayRemoveInPlace(array, ...elementsToRemove);
+    return array;
+}
+/**
+ * Shallow copies and removes the specified element(s) from the array. Returns the copied array. If
+ * the specified element(s) are not found in the array, it will simply return a shallow copy of the
+ * array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will remove every matching
+ * element. If you want to only remove the first matching element, use the `arrayRemove` function
+ * instead.
+ */
+export function arrayRemoveAll(originalArray, ...elementsToRemove) {
+    const array = copyArray(originalArray);
+    arrayRemoveAllInPlace(array, ...elementsToRemove);
+    return array;
+}
+/**
+ * Removes all of the specified element(s) from the array. If the specified element(s) are not found
+ * in the array, this function will do nothing.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will remove every matching
+ * element. If you want to only remove the first matching element, use the `arrayRemoveInPlace`
+ * function instead.
+ *
+ * @returns True if one or more elements were removed, false otherwise.
+ */
+export function arrayRemoveAllInPlace(array, ...elementsToRemove) {
+    let removedOneOrMoreElements = false;
+    for (const element of elementsToRemove) {
+        let index;
+        do {
+            index = array.indexOf(element);
+            if (index > -1) {
+                removedOneOrMoreElements = true;
+                array.splice(index, 1);
+            }
+        } while (index > -1);
+    }
+    return removedOneOrMoreElements;
+}
+/**
+ * Removes the specified element(s) from the array. If the specified element(s) are not found in the
+ * array, this function will do nothing.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will only remove the first
+ * matching element. If you want to remove all of the elements, use the `arrayRemoveAllInPlace`
+ * function instead.
+ *
+ * @returns True if one or more elements were removed, false otherwise.
+ */
+export function arrayRemoveInPlace(array, ...elementsToRemove) {
+    let removedOneOrMoreElements = false;
+    for (const element of elementsToRemove) {
+        const index = array.indexOf(element);
+        if (index > -1) {
+            removedOneOrMoreElements = true;
+            array.splice(index, 1);
+        }
+    }
+    return removedOneOrMoreElements;
+}
+/**
+ * Shallow copies and removes the elements at the specified indexes from the array. Returns the
+ * copied array. If the specified indexes are not found in the array, it will simply return a
+ * shallow copy of the array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export function arrayRemoveIndex(originalArray, ...indexesToRemove) {
+    const indexesToRemoveSet = new Set(indexesToRemove);
+    const array = [];
+    originalArray.forEach((element, i) => {
+        if (!indexesToRemoveSet.has(i)) {
+            array.push(element);
+        }
+    });
+    return array;
+}
+/**
+ * Removes the elements at the specified indexes from the array. If the specified indexes are not
+ * found in the array, this function will do nothing. Returns true if one or more elements were
+ * removed.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * @returns Whether or not any array elements were removed.
+ */
+export function arrayRemoveIndexInPlace(array, ...indexesToRemove) {
+    const legalIndexes = indexesToRemove.filter((i) => i >= 0 && i < array.length);
+    legalIndexes.sort();
+    if (legalIndexes.length === 0) {
+        return false;
+    }
+    for (let i = array.length - 1; i >= 0; i--) {
+        array.splice(i, 1);
+    }
+    return true;
+}
+export function arrayToString(array) {
+    if (array.length === 0) {
+        return "[]";
+    }
+    const strings = array.map((element) => tostring(element));
+    const commaSeparatedStrings = strings.join(", ");
+    return `[${commaSeparatedStrings}]`;
+}
+/**
+ * Helper function to combine two or more arrays. Returns a new array that is the composition of all
+ * of the specified arrays.
+ *
+ * This function is variadic, meaning that you can specify N arguments to combine N arrays. Note
+ * that this will only perform a shallow copy of the array elements.
+ */
+export function combineArrays(...arrays) {
+    const elements = [];
+    for (const array of arrays) {
+        for (const element of array) {
+            elements.push(element);
+        }
+    }
+    return elements;
+}
+/**
+ * Helper function to perform a shallow copy.
+ *
+ * @param oldArray The array to copy.
+ * @param numElements Optional. If specified, will only copy the first N elements. By default, the
+ *                    entire array will be copied.
+ */
+export function copyArray(oldArray, numElements) {
+    if (numElements === undefined) {
+        numElements = oldArray.length;
+    }
+    const newArray = [];
+    for (let i = 0; i < numElements; i++) {
+        const oldElement = oldArray[i];
+        if (oldElement !== undefined) {
+            newArray.push(oldElement);
+        }
+    }
+    return newArray;
+}
+/** Helper function to remove all of the elements in an array in-place. */
+export function emptyArray(array) {
+    array.splice(0, array.length);
+}
+/**
+ * Helper function to get all possible combinations of the given array. This includes the
+ * combination of an empty array.
+ *
+ * For example, if this function is provided an array containing 1, 2, and 3, then it will return an
+ * array containing the following arrays:
+ *
+ * - [] (if `includeEmptyArray` is set to true)
+ * - [1]
+ * - [2]
+ * - [3]
+ * - [1, 2]
+ * - [1, 3]
+ * - [2, 3]
+ * - [1, 2, 3]
+ *
+ * From: https://github.com/firstandthird/combinations/blob/master/index.js
+ *
+ * @param array The array to get the combinations of.
+ * @param includeEmptyArray Whether or not to include an empty array in the combinations.
+ * @param min Optional. The minimum number of elements to include in each combination. Default is 1.
+ * @param max Optional. The maximum number of elements to include in each combination. Default is
+ *            the length of the array.
+ */
+export function getArrayCombinations(array, includeEmptyArray, min, max) {
+    if (min === undefined || min <= 0) {
+        min = 1;
+    }
+    if (max === undefined || max <= 0) {
+        max = array.length;
+    }
+    const addCombinations = (n, src, got, all) => {
+        if (n === 0) {
+            if (got.length > 0) {
+                all[all.length] = got;
+            }
+            return;
+        }
+        for (let j = 0; j < src.length; j++) {
+            const value = src[j]; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            addCombinations(n - 1, src.slice(j + 1), got.concat([value]), all);
+        }
+    };
+    const all = [];
+    for (let i = min; i < array.length; i++) {
+        addCombinations(i, array, [], all);
+    }
+    if (array.length === max) {
+        all.push(array);
+    }
+    // Finally, account for the empty array combination.
+    if (includeEmptyArray) {
+        all.unshift([]);
+    }
+    return all;
+}
+/**
+ * Helper function to get an array containing the indexes of an array.
+ *
+ * For example, an array of `["Apple", "Banana"]` would return an array of `[0, 1]`.
+ */
+export function getArrayIndexes(array) {
+    return erange(array.length);
+}
+/**
+ * Helper function to return the last element of an array.
+ *
+ * If the array is empty, this will return undefined.
+ */
+export function getLastElement(array) {
+    return array[array.length - 1];
+}
+/**
+ * Helper function to get a random element from the provided array.
+ *
+ * @param array The array to get an element from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export function getRandomArrayElement(array, seedOrRNG = getRandomSeed(), exceptions = []) {
+    if (array.length === 0) {
+        error("Failed to get a random array element since the provided array is empty.");
+    }
+    const arrayWithoutExceptions = arrayRemove(array, ...exceptions);
+    const randomIndex = getRandomArrayIndex(arrayWithoutExceptions, seedOrRNG);
+    const randomElement = arrayWithoutExceptions[randomIndex];
+    if (randomElement === undefined) {
+        error(`Failed to get a random array element since the random index of ${randomIndex} was not valid.`);
+    }
+    return randomElement;
+}
+/**
+ * Helper function to get a random element from the provided array. Once the random element is
+ * decided, it is then removed from the array (in-place).
+ *
+ * @param array The array to get an element from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export function getRandomArrayElementAndRemove(array, seedOrRNG = getRandomSeed(), exceptions = []) {
+    const randomArrayElement = getRandomArrayElement(array, seedOrRNG, exceptions);
+    arrayRemoveInPlace(array, randomArrayElement);
+    return randomArrayElement;
+}
+/**
+ * Helper function to get a random index from the provided array.
+ *
+ * @param array The array to get the index from.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ * @param exceptions Optional. An array of indexes that will be skipped over when getting the random
+ *                   index. Default is an empty array.
+ */
+export function getRandomArrayIndex(array, seedOrRNG = getRandomSeed(), exceptions = []) {
+    if (array.length === 0) {
+        error("Failed to get a random array index since the provided array is empty.");
+    }
+    return getRandomInt(0, array.length - 1, seedOrRNG, exceptions);
+}
+/**
+ * Initializes an array with all elements containing the specified default value.
+ *
+ * For example:
+ *
+ * ```ts
+ * const playerTransformations = initArray(false, PlayerForm.NUM_PLAYER_FORMS - 1);
+ * ```
+ */
+export function initArray(defaultValue, size) {
+    const array = [];
+    repeat(size, () => {
+        array.push(defaultValue);
+    });
+    return array;
+}
+/**
+ * Since Lua uses tables for every non-primitive data structure, it is non-trivial to determine if a
+ * particular table is being used as an array. `isArray` returns true if:
+ *
+ * - the table contains all numerical indexes that are contiguous, starting at 1
+ * - the table has no keys (i.e. an "empty" table)
+ */
+export function isArray(object) {
+    if (!isTable(object)) {
+        return false;
+    }
+    // First, if there is a metatable, this cannot be a simple array and must be a more complex
+    // object.
+    const metatable = getmetatable(object);
+    if (metatable !== undefined) {
+        return false;
+    }
+    // Second, handle the case of non-numerical keys.
+    const keys = Object.keys(object);
+    const hasAllNumberKeys = keys.every((key) => isNumber(key));
+    if (!hasAllNumberKeys) {
+        return false;
+    }
+    const tableLength = object.length();
+    if (tableLength === 0) {
+        return true;
+    }
+    // Third, check for non-contiguous elements. (Lua tables start at an index of 1.)
+    for (let i = 1; i <= tableLength; i++) {
+        const element = object.get(i);
+        if (element === undefined) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Helper function to see if every element in the array is N + 1.
+ *
+ * For example, `[2, 3, 4]` would return true, and `[2, 3, 5]` would return false.
+ */
+export function isArrayContiguous(array) {
+    let lastValue;
+    for (const element of array) {
+        if (lastValue === undefined) {
+            lastValue = element - 1;
+        }
+        if (element !== lastValue - 1) {
+            return false;
+        }
+    }
+    return true;
+}
+/** Checks if an array is in the provided 2-dimensional array. */
+export function isArrayInArray(arrayToMatch, parentArray) {
+    return parentArray.some((element) => arrayEquals(element, arrayToMatch));
+}
+/**
+ * Shallow copies and shuffles the array using the Fisher-Yates algorithm. Returns the copied array.
+ *
+ * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @param originalArray The array to shuffle.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export function shuffleArray(originalArray, seedOrRNG = getRandomSeed()) {
+    const array = copyArray(originalArray);
+    shuffleArrayInPlace(array, seedOrRNG);
+    return array;
+}
+/**
+ * Shuffles the provided array in-place using the Fisher-Yates algorithm.
+ *
+ * From: https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @param array The array to shuffle.
+ * @param seedOrRNG Optional. The `Seed` or `RNG` object to use. If an `RNG` object is provided, the
+ *                  `RNG.Next` method will be called. Default is `getRandomSeed()`.
+ */
+export function shuffleArrayInPlace(array, seedOrRNG = getRandomSeed()) {
+    let currentIndex = array.length;
+    const rng = isRNG(seedOrRNG) ? seedOrRNG : newRNG(seedOrRNG);
+    while (currentIndex > 0) {
+        currentIndex -= 1;
+        const randomIndex = getRandomArrayIndex(array, rng);
+        swapArrayElements(array, currentIndex, randomIndex);
+    }
+}
+/** Helper function to sum every value in an array together. */
+export function sumArray(array) {
+    return array.reduce((accumulator, element) => accumulator + element);
+}
+/**
+ * Helper function to swap two different array elements. (The elements will be swapped in-place.)
+ */
+export function swapArrayElements(array, i, j) {
+    const value1 = array[i]; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    const value2 = array[j]; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    array[i] = value2;
+    array[j] = value1;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"array.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/array.ts"],"names":[],"mappings":"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"}

package/functions/benchmark.js

@@ -0,0 +1,28 @@
+import { log } from "./log";
+/**
+ * Helper function to benchmark the performance of a function.
+ *
+ * This function is variadic, which means that you can supply as many as you want to benchmark.
+ *
+ * @returns An array containing the average time in milliseconds for each function. (This will also
+ *          be printed to the log.)
+ */
+export function benchmark(numTrials, ...functions) {
+    log(`Benchmarking ${functions.length} function(s) with ${numTrials} trials.`);
+    const averages = [];
+    functions.forEach((func, i) => {
+        let totalTimeMilliseconds = 0;
+        for (let j = 0; j < numTrials; j++) {
+            const startTimeMilliseconds = Isaac.GetTime();
+            func();
+            const endTimeMilliseconds = Isaac.GetTime();
+            const elapsedTimeMilliseconds = endTimeMilliseconds - startTimeMilliseconds;
+            totalTimeMilliseconds += elapsedTimeMilliseconds;
+        }
+        const averageTimeMilliseconds = totalTimeMilliseconds / numTrials;
+        log(`The average time of the function at index ${i} is: ${averageTimeMilliseconds} milliseconds`);
+        averages.push(averageTimeMilliseconds);
+    });
+    return averages;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVuY2htYXJrLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvaXNhYWNzY3JpcHQtY29tbW9uL3NyYy9mdW5jdGlvbnMvYmVuY2htYXJrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxHQUFHLEVBQUUsTUFBTSxPQUFPLENBQUM7QUFFNUI7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSxTQUFTLENBQ3ZCLFNBQWMsRUFDZCxHQUFHLFNBQTRCO0lBRS9CLEdBQUcsQ0FBQyxnQkFBZ0IsU0FBUyxDQUFDLE1BQU0scUJBQXFCLFNBQVMsVUFBVSxDQUFDLENBQUM7SUFFOUUsTUFBTSxRQUFRLEdBQVUsRUFBRSxDQUFDO0lBQzNCLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxFQUFFLEVBQUU7UUFDNUIsSUFBSSxxQkFBcUIsR0FBRyxDQUFDLENBQUM7UUFDOUIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFNBQVMsRUFBRSxDQUFDLEVBQUUsRUFBRTtZQUNsQyxNQUFNLHFCQUFxQixHQUFHLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUM5QyxJQUFJLEVBQUUsQ0FBQztZQUNQLE1BQU0sbUJBQW1CLEdBQUcsS0FBSyxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQzVDLE1BQU0sdUJBQXVCLEdBQzNCLG1CQUFtQixHQUFHLHFCQUFxQixDQUFDO1lBQzlDLHFCQUFxQixJQUFJLHVCQUF1QixDQUFDO1NBQ2xEO1FBQ0QsTUFBTSx1QkFBdUIsR0FBRyxxQkFBcUIsR0FBRyxTQUFTLENBQUM7UUFDbEUsR0FBRyxDQUNELDZDQUE2QyxDQUFDLFFBQVEsdUJBQXVCLGVBQWUsQ0FDN0YsQ0FBQztRQUNGLFFBQVEsQ0FBQyxJQUFJLENBQUMsdUJBQXVCLENBQUMsQ0FBQztJQUN6QyxDQUFDLENBQUMsQ0FBQztJQUVILE9BQU8sUUFBUSxDQUFDO0FBQ2xCLENBQUMifQ==

package/functions/bitwise.js

@@ -0,0 +1,74 @@
+import { addFlag } from "./flag";
+/** Helper function to convert a set of flags to a single `BitFlags` object. */
+export function arrayToBitFlags(array) {
+    let flags = 0;
+    for (const flag of array) {
+        flags = addFlag(flags, flag);
+    }
+    return flags;
+}
+/** Helper function to convert an array of bits to the resulting decimal number. */
+export function convertBinaryToDecimal(bits) {
+    const bitsString = bits.join("");
+    return parseInt(bitsString, 2);
+}
+/**
+ * Helper function to convert a number to an array of bits.
+ *
+ * @param number The number to convert.
+ * @param minLength Optional. Equal to the minimum amount of bits that should be returned. If the
+ *                  converted number of bits is below this number, 0's will be padded to the left
+ *                  side until the minimum length is met. Default is undefined (which will not cause
+ *                  any padding).
+ */
+export function convertDecimalToBinary(number, minLength) {
+    const bits = [];
+    const bitsString = number.toString(2);
+    for (const bitString of bitsString) {
+        const bit = tonumber(bitString);
+        if (bit === undefined) {
+            error(`Failed to convert the following number to binary: ${number}`);
+        }
+        bits.push(bit);
+    }
+    if (minLength !== undefined) {
+        while (bits.length < minLength) {
+            bits.unshift(0);
+        }
+    }
+    return bits;
+}
+/**
+ * Helper function to count the number of bits that are set to 1 in a binary representation of a
+ * number.
+ */
+export function countSetBits(n) {
+    let count = 0;
+    while (n > 0) {
+        n &= n - 1;
+        count += 1;
+    }
+    return count;
+}
+/** Helper function to get the value of a specific but in a binary representation of a number. */
+export function getKBitOfN(k, n) {
+    return (n >>> k) & 1;
+}
+/** Helper function to get the number of bits in a binary representation of a number. */
+export function getNumBitsOfN(n) {
+    let numBits = 0;
+    while (n > 0) {
+        numBits += 1;
+        n >>>= 1;
+    }
+    return numBits;
+}
+/** Helper function to convert a set of flags to a single `BitFlags` object. */
+export function setToBitFlags(set) {
+    let flags = 0;
+    for (const flag of set.values()) {
+        flags = addFlag(flags, flag);
+    }
+    return flags;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/bombs.js

@@ -0,0 +1,11 @@
+/** Helper function to find out how large a bomb explosion is based on the damage inflicted. */
+export function getBombRadiusFromDamage(damage) {
+    if (damage > 175) {
+        return 105;
+    }
+    if (damage <= 140) {
+        return 75;
+    }
+    return 90;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYm9tYnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9pc2FhY3NjcmlwdC1jb21tb24vc3JjL2Z1bmN0aW9ucy9ib21icy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrRkFBK0Y7QUFDL0YsTUFBTSxVQUFVLHVCQUF1QixDQUFDLE1BQWE7SUFDbkQsSUFBSSxNQUFNLEdBQUcsR0FBRyxFQUFFO1FBQ2hCLE9BQU8sR0FBRyxDQUFDO0tBQ1o7SUFFRCxJQUFJLE1BQU0sSUFBSSxHQUFHLEVBQUU7UUFDakIsT0FBTyxFQUFFLENBQUM7S0FDWDtJQUVELE9BQU8sRUFBRSxDQUFDO0FBQ1osQ0FBQyJ9