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

package/functions/math.js

@@ -0,0 +1,103 @@
+import { Direction } from "isaac-typescript-definitions";
+import { directionToVector } from "./direction";
+/**
+ * Helper function to normalize an integer.
+ *
+ * - If `x` is less than `min`, then it will be clamped to `min`.
+ * - If `x` is greater than `max`, then it will be clamped to `max`.
+ */
+export function clamp(x, min, max) {
+    return Math.max(min, Math.min(x, max));
+}
+export function getAngleDifference(angle1, angle2) {
+    const subtractedAngle = angle1 - angle2;
+    return ((subtractedAngle + 180) % 360) - 180;
+}
+/**
+ * Helper function to get an array of equidistant points on the circumference around a circle.
+ * Useful for equally distributing things in a circle pattern.
+ *
+ * @param centerPos A position that represents the center of the center to get the points from.
+ * @param radius The radius of the circle.
+ * @param numPoints The number of points on the circumference of the circle to get.
+ * @param xMultiplier An optional multiplier to get the points around an oval. Default is 1.
+ * @param yMultiplier An optional multiplier to get the points around an oval. Default is 1.
+ * @param initialDirection By default, the first point on the circle will be on the top center, but
+ *                         this can be optionally changed by specifying this argument.
+ */
+export function getCircleDiscretizedPoints(centerPos, radius, numPoints, xMultiplier = 1, yMultiplier = 1, initialDirection = Direction.UP) {
+    const vector = directionToVector(initialDirection);
+    const initialPosition = vector.mul(radius);
+    const positions = [];
+    for (let i = 0; i < numPoints; i++) {
+        const rotatedPosition = initialPosition.Rotated((i * 360) / numPoints);
+        rotatedPosition.X *= xMultiplier;
+        rotatedPosition.Y *= yMultiplier;
+        const positionFromCenter = centerPos.add(rotatedPosition);
+        positions.push(positionFromCenter);
+    }
+    return positions;
+}
+/**
+ * Helper function to check if a given position is within a given rectangle.
+ *
+ * This is an inclusive check, meaning that it will return true if the position is on the border of
+ * the rectangle.
+ */
+export function inRectangle(position, topLeft, bottomRight) {
+    return (position.X >= topLeft.X &&
+        position.X <= bottomRight.X &&
+        position.Y >= topLeft.Y &&
+        position.Y <= bottomRight.Y);
+}
+/**
+ * From: https://www.geeksforgeeks.org/check-if-any-point-overlaps-the-given-circle-and-rectangle/
+ */
+export function isCircleIntersectingRectangle(circleCenter, circleRadius, rectangleTopLeft, rectangleBottomRight) {
+    const nearestX = Math.max(rectangleTopLeft.X, Math.min(circleCenter.X, rectangleBottomRight.X));
+    const nearestY = Math.max(rectangleTopLeft.Y, Math.min(circleCenter.Y, rectangleBottomRight.Y));
+    const nearestPointToCircleOnRectangle = Vector(nearestX, nearestY);
+    const distanceToCenterOfCircle = nearestPointToCircleOnRectangle.Distance(circleCenter);
+    return distanceToCenterOfCircle <= circleRadius;
+}
+export function isEven(num) {
+    // This is benchmarked to be faster than using the modulus operator by 3%.
+    return (num & 1) === 0;
+}
+export function isOdd(num) {
+    // This is benchmarked to be faster than using the modulus operator by 3%.
+    return (num & 1) === 1;
+}
+export function lerp(a, b, pos) {
+    return a + (b - a) * pos;
+}
+export function lerpAngleDegrees(aStart, aEnd, percent) {
+    return aStart + getAngleDifference(aStart, aEnd) * percent;
+}
+/**
+ * If rounding fails, this function returns 0.
+ * From: http://lua-users.org/wiki/SimpleRound
+ *
+ * @param num The number to round.
+ * @param numDecimalPlaces Default is 0.
+ */
+export function round(num, numDecimalPlaces = 0) {
+    const roundedNum = tonumber(string.format(`%.${numDecimalPlaces}f`, num));
+    return roundedNum === undefined ? 0 : roundedNum;
+}
+/**
+ * @returns 1 if n is positive, -1 if n is negative, or 0 if n is 0.
+ */
+export function sign(n) {
+    if (n > 0) {
+        return 1;
+    }
+    if (n < 0) {
+        return -1;
+    }
+    return 0;
+}
+export function tanh(x) {
+    return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/functions/mergeTests.js

@@ -0,0 +1,213 @@
+import { SerializationType } from "../enums/SerializationType";
+import { merge } from "../features/saveDataManager/merge";
+import { deepCopy } from "./deepCopy";
+import { log } from "./log";
+import { isRNG, newRNG } from "./rng";
+import { isSerializedIsaacAPIClass } from "./serialization";
+import { copyVector, isVector } from "./vector";
+export function mergeTests() {
+    oldTableHasUpdatedValue();
+    newTableHasSameValue();
+    oldTableHasUpdatedValueFromNull();
+    oldTableHasSerializedIsaacAPIClass();
+    oldTableHasFilledInterface();
+    oldTableHasVector();
+    oldTableHasVectorSerialized();
+    oldTableHasRNG();
+    oldTableHasRNGSerialized();
+    log("All merge tests passed!");
+}
+function oldTableHasUpdatedValue() {
+    const key = "foo";
+    const oldValue = "bar";
+    const newValue = "baz";
+    const oldTable = {
+        foo: oldValue,
+    };
+    const newTable = {
+        foo: newValue,
+    };
+    merge(oldTable, newTable, "oldTableHasUpdatedValue");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue !== newValue) {
+        error(`The old table does not have a value of: ${newValue}`);
+    }
+}
+function newTableHasSameValue() {
+    const key = "foo";
+    const oldValue = "bar";
+    const newValue = "baz";
+    const oldTable = {
+        foo: oldValue,
+    };
+    const newTable = {
+        foo: newValue,
+    };
+    merge(oldTable, newTable, "newTableHasSameValue");
+    const newTableValue = newTable.get(key);
+    if (newTableValue !== newValue) {
+        error(`The new table does not have a value of: ${newValue}`);
+    }
+}
+function oldTableHasUpdatedValueFromNull() {
+    const key = "foo";
+    const newValue = "baz";
+    const oldTable = {
+        foo: null,
+    };
+    const newTable = {
+        foo: newValue,
+    };
+    merge(oldTable, newTable, "oldTableHasUpdatedValueFromNull");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue !== newValue) {
+        error(`The old table does not have a value of: ${newValue}`);
+    }
+}
+function oldTableHasSerializedIsaacAPIClass() {
+    const x = 50;
+    const y = 60;
+    const vector = Vector(x, y);
+    const vectorSerialized = copyVector(vector, SerializationType.SERIALIZE);
+    if (!isSerializedIsaacAPIClass(vectorSerialized)) {
+        error('The "isSerializedIsaacAPIClass" function says that a serialized vector is not serialized.');
+    }
+}
+function oldTableHasFilledInterface() {
+    const key = "foo";
+    const newValue = "baz";
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    merge(oldTable, newTable, "oldTableHasFilledInterface");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (oldTableValue.bar !== newValue) {
+        error('The old table\'s key of "bar" was not filled.');
+    }
+}
+function oldTableHasVector() {
+    log("Starting test: oldTableHasVector");
+    const key = "foo";
+    const x = 50;
+    const y = 60;
+    const newValue = Vector(x, y);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    merge(oldTable, newTable, "oldTableHasVector");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (oldTableValue.bar.X !== x) {
+        error(`The old table's value for "x" does not match: ${x}`);
+    }
+    if (oldTableValue.bar.Y !== y) {
+        error(`The old table's value for "y" does not match: ${y}`);
+    }
+    if (!isVector(oldTableValue.bar)) {
+        error("The old table's value is not a Vector object.");
+    }
+}
+function oldTableHasVectorSerialized() {
+    log("Starting test: oldTableHasVectorSerialized");
+    const key = "foo";
+    const x = 50;
+    const y = 60;
+    const newValue = Vector(x, y);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    const newTableSerialized = deepCopy(newTable, SerializationType.SERIALIZE);
+    merge(oldTable, newTableSerialized, "oldTableHasVectorSerialized");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (oldTableValue.bar.X !== x) {
+        error(`The old table's value for "x" does not match: ${x}`);
+    }
+    if (oldTableValue.bar.Y !== y) {
+        error(`The old table's value for "y" does not match: ${y}`);
+    }
+    if (!isVector(oldTableValue.bar)) {
+        error("The old table's value is not a Vector object (during the serialized test).");
+    }
+}
+function oldTableHasRNG() {
+    log("Starting test: oldTableHasRNG");
+    const key = "foo";
+    const seed = 50;
+    const newValue = newRNG(seed);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    merge(oldTable, newTable, "oldTableHasRNG");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (!isRNG(oldTableValue.bar)) {
+        error("The old table's value is not an RNG object.");
+    }
+    const newSeed = oldTableValue.bar.GetSeed();
+    if (newSeed !== seed) {
+        error(`The old table's seed not match: ${seed}`);
+    }
+}
+function oldTableHasRNGSerialized() {
+    log("Starting test: oldTableHasRNGSerialized");
+    const key = "foo";
+    const seed = 50;
+    const newValue = newRNG(seed);
+    const oldTable = {
+        foo: null,
+    };
+    const foo = {
+        bar: newValue,
+    };
+    const newTable = {
+        foo,
+    };
+    const newTableSerialized = deepCopy(newTable, SerializationType.SERIALIZE);
+    merge(oldTable, newTableSerialized, "oldTableHasRNGSerialized");
+    const oldTableValue = oldTable.get(key);
+    if (oldTableValue === undefined) {
+        error(`The old table's key of "${key}" was not filled.`);
+    }
+    if (!isRNG(oldTableValue.bar)) {
+        error("The old table's value is not an RNG object (during the serialized test).");
+    }
+    const newSeed = oldTableValue.bar.GetSeed();
+    if (newSeed !== seed) {
+        error(`The old table's seed not match: ${seed}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mergeTests.js","sourceRoot":"","sources":["../../../../packages/isaacscript-common/src/functions/mergeTests.ts"],"names":[],"mappings":"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"}

package/functions/minimap.js

@@ -0,0 +1,80 @@
+import { DisplayFlagZero } from "isaac-typescript-definitions";
+import { game } from "../cachedClasses";
+import { getRoomDescriptor } from "./roomData";
+import { getRoomsInGrid } from "./rooms";
+/**
+ * Helper function to set the value of `DisplayFlag` for every room on the floor to 0.
+ *
+ * This function automatically calls the `Level.UpdateVisibility` after setting the flags so that
+ * the changes will be immediately visible.
+ */
+export function clearFloorDisplayFlags() {
+    const level = game.GetLevel();
+    for (const room of getRoomsInGrid()) {
+        room.DisplayFlags = DisplayFlagZero;
+    }
+    // We must call the "Level.UpdateVisibility" method for the changes to be visible.
+    level.UpdateVisibility();
+}
+/**
+ * Helper function to get the minimap `DisplayFlag` value for every room on the floor. Returns a map
+ * that is indexed by the room's safe grid index.
+ */
+export function getFloorDisplayFlags() {
+    const displayFlagsMap = new Map();
+    const roomsInGrid = getRoomsInGrid();
+    for (const roomDescriptor of roomsInGrid) {
+        displayFlagsMap.set(roomDescriptor.SafeGridIndex, roomDescriptor.DisplayFlags);
+    }
+    return displayFlagsMap;
+}
+/**
+ * Helper function to get a particular room's minimap display flags (e.g. whether or not it is
+ * visible and so on).
+ *
+ * @param roomGridIndex Optional. Default is the current room index.
+ */
+export function getRoomDisplayFlags(roomGridIndex) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    return roomDescriptor.DisplayFlags;
+}
+/**
+ * Helper function to set the minimap `DisplayFlag` value for multiple rooms at once.
+ *
+ * This function automatically calls the `Level.UpdateVisibility` after setting the flags so that
+ * the changes will be immediately visible.
+ *
+ * @param displayFlagsMap A map of the display flags that is indexed by the room's safe grid index.
+ */
+export function setDisplayFlags(displayFlagsMap) {
+    const level = game.GetLevel();
+    for (const [roomGridIndex, displayFlags] of displayFlagsMap.entries()) {
+        if (MinimapAPI === undefined) {
+            setRoomDisplayFlags(roomGridIndex, displayFlags);
+        }
+        else {
+            const roomDescriptor = MinimapAPI.GetRoomByIdx(roomGridIndex);
+            if (roomDescriptor !== undefined) {
+                roomDescriptor.DisplayFlags = displayFlags;
+            }
+        }
+    }
+    // We must call the "Level.UpdateVisibility" method for the changes to be visible.
+    level.UpdateVisibility();
+}
+/** Alias for the `setDisplayFlags` function. */
+export function setFloorDisplayFlags(displayFlagsMap) {
+    setDisplayFlags(displayFlagsMap);
+}
+/**
+ * Helper function to set a particular room's minimap display flags (e.g. whether or not it is
+ * visible and so on).
+ *
+ * @param roomGridIndex Set to undefined to use the current room index.
+ * @param displayFlags The bit flags value to set. (See the `DisplayFlag` enum.)
+ */
+export function setRoomDisplayFlags(roomGridIndex, displayFlags) {
+    const roomDescriptor = getRoomDescriptor(roomGridIndex);
+    roomDescriptor.DisplayFlags = displayFlags;
+}
+//# sourceMappingURL=data:application/json;base64,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