tobspr_shapez.io/src/ts/core/utils.ts

import { T } from "../translations";
import { rando } from "@nastyox/rando.js";
import { WEB_STEAM_SSO_AUTHENTICATED } from "./steam_sso";
const bigNumberSuffixTranslationKeys = ["thousands", "millions", "billions", "trillions"];
/**
 * Returns a platform name
 * {}
 */
export function getPlatformName(): "android" | "browser" | "ios" | "standalone" | "unknown" {
    if (G_IS_STANDALONE) {
        return "standalone";
    }
    else if (G_IS_BROWSER) {
        return "browser";
    }
    return "unknown";
}
/**
 * Makes a new 2D array with undefined contents
 * {}
 */
export function make2DUndefinedArray(w: number, h: number): Array<Array<any>> {
    const result = new Array(w);
    for (let x = 0; x < w; ++x) {
        result[x] = new Array(h);
    }
    return result;
}
/**
 * Creates a new map (an empty object without any props)
 */
export function newEmptyMap() {
    return Object.create(null);
}
/**
 * Returns a random integer in the range [start,end]
 */
export function randomInt(start: number, end: number) {
    return rando(start, end);
}
/**
 * Access an object in a very annoying way, used for obsfuscation.
 */
export function accessNestedPropertyReverse(obj: any, keys: Array<string>) {
    let result = obj;
    for (let i = keys.length - 1; i >= 0; --i) {
        result = result[keys[i]];
    }
    return result;
}
/**
 * Chooses a random entry of an array
 * @template T
 * {}
 */
export function randomChoice(arr: T[]): T {
    return arr[Math.floor(Math.random() * arr.length)];
}
/**
 * Deletes from an array by swapping with the last element
 */
export function fastArrayDelete(array: Array<any>, index: number) {
    if (index < 0 || index >= array.length) {
        throw new Error("Out of bounds");
    }
    // When the element is not the last element
    if (index !== array.length - 1) {
        // Get the last element, and swap it with the one we want to delete
        const last = array[array.length - 1];
        array[index] = last;
    }
    // Finally remove the last element
    array.length -= 1;
}
/**
 * Deletes from an array by swapping with the last element. Searches
 * for the value in the array first
 */
export function fastArrayDeleteValue(array: Array<any>, value: any) {
    if (array == null) {
        throw new Error("Tried to delete from non array!");
    }
    const index = array.indexOf(value);
    if (index < 0) {
        console.error("Value", value, "not contained in array:", array, "!");
        return value;
    }
    return fastArrayDelete(array, index);
}
/**
 * @see fastArrayDeleteValue
 */
export function fastArrayDeleteValueIfContained(array: Array<any>, value: any) {
    if (array == null) {
        throw new Error("Tried to delete from non array!");
    }
    const index = array.indexOf(value);
    if (index < 0) {
        return value;
    }
    return fastArrayDelete(array, index);
}
/**
 * Deletes from an array at the given index
 */
export function arrayDelete(array: Array<any>, index: number) {
    if (index < 0 || index >= array.length) {
        throw new Error("Out of bounds");
    }
    array.splice(index, 1);
}
/**
 * Deletes the given value from an array
 */
export function arrayDeleteValue(array: Array<any>, value: any) {
    if (array == null) {
        throw new Error("Tried to delete from non array!");
    }
    const index = array.indexOf(value);
    if (index < 0) {
        console.error("Value", value, "not contained in array:", array, "!");
        return value;
    }
    return arrayDelete(array, index);
}
/**
 * Compare two floats for epsilon equality
 * {}
 */
export function epsilonCompare(a: number, b: number, epsilon = 1e-5): boolean {
    return Math.abs(a - b) < epsilon;
}
/**
 * Interpolates two numbers
 */
export function lerp(a: number, b: number, x: number) {
    return a * (1 - x) + b * x;
}
/**
 * Finds a value which is nice to display, e.g. 15669 -> 15000. Also handles fractional stuff
 */
export function findNiceValue(num: number) {
    if (num > 1e8) {
        return num;
    }
    if (num < 0.00001) {
        return 0;
    }
    let roundAmount = 1;
    if (num > 50000) {
        roundAmount = 10000;
    }
    else if (num > 20000) {
        roundAmount = 5000;
    }
    else if (num > 5000) {
        roundAmount = 1000;
    }
    else if (num > 2000) {
        roundAmount = 500;
    }
    else if (num > 1000) {
        roundAmount = 100;
    }
    else if (num > 100) {
        roundAmount = 20;
    }
    else if (num > 20) {
        roundAmount = 5;
    }
    const niceValue = Math.floor(num / roundAmount) * roundAmount;
    if (num >= 10) {
        return Math.round(niceValue);
    }
    if (num >= 1) {
        return Math.round(niceValue * 10) / 10;
    }
    return Math.round(niceValue * 100) / 100;
}
/**
 * Finds a nice integer value
 * @see findNiceValue
 */
export function findNiceIntegerValue(num: number) {
    return Math.ceil(findNiceValue(num));
}
/**
 * Formats a big number
 * {}
 */
export function formatBigNumber(num: number, separator: string= = T.global.decimalSeparator): string {
    const sign = num < 0 ? "-" : "";
    num = Math.abs(num);
    if (num > 1e54) {
        return sign + T.global.infinite;
    }
    if (num < 10 && !Number.isInteger(num)) {
        return sign + num.toFixed(2);
    }
    if (num < 50 && !Number.isInteger(num)) {
        return sign + num.toFixed(1);
    }
    num = Math.floor(num);
    if (num < 1000) {
        return sign + "" + num;
    }
    else {
        let leadingDigits = num;
        let suffix = "";
        for (let suffixIndex = 0; suffixIndex < bigNumberSuffixTranslationKeys.length; ++suffixIndex) {
            leadingDigits = leadingDigits / 1000;
            suffix = T.global.suffix[bigNumberSuffixTranslationKeys[suffixIndex]];
            if (leadingDigits < 1000) {
                break;
            }
        }
        const leadingDigitsRounded = round1Digit(leadingDigits);
        const leadingDigitsNoTrailingDecimal = leadingDigitsRounded
            .toString()
            .replace(".0", "")
            .replace(".", separator);
        return sign + leadingDigitsNoTrailingDecimal + suffix;
    }
}
/**
 * Formats a big number, but does not add any suffix and instead uses its full representation
 * {}
 */
export function formatBigNumberFull(num: number, divider: string= = T.global.thousandsDivider): string {
    if (num < 1000) {
        return num + "";
    }
    if (num > 1e54) {
        return T.global.infinite;
    }
    let rest = num;
    let out = "";
    while (rest >= 1000) {
        out = (rest % 1000).toString().padStart(3, "0") + divider + out;
        rest = Math.floor(rest / 1000);
    }
    out = rest + divider + out;
    return out.substring(0, out.length - 1);
}
/**
 * Waits two frames so the ui is updated
 * {}
 */
export function waitNextFrame(): Promise<void> {
    return new Promise(function (resolve) {
        window.requestAnimationFrame(function () {
            window.requestAnimationFrame(function () {
                resolve();
            });
        });
    });
}
/**
 * Rounds 1 digit
 * {}
 */
export function round1Digit(n: number): number {
    return Math.floor(n * 10.0) / 10.0;
}
/**
 * Rounds 2 digits
 * {}
 */
export function round2Digits(n: number): number {
    return Math.floor(n * 100.0) / 100.0;
}
/**
 * Rounds 3 digits
 * {}
 */
export function round3Digits(n: number): number {
    return Math.floor(n * 1000.0) / 1000.0;
}
/**
 * Rounds 4 digits
 * {}
 */
export function round4Digits(n: number): number {
    return Math.floor(n * 10000.0) / 10000.0;
}
/**
 * Clamps a value between [min, max]
 */
export function clamp(v: number, minimum: number= = 0, maximum: number= = 1) {
    return Math.max(minimum, Math.min(maximum, v));
}
/**
 * Helper method to create a new div element
 */
export function makeDivElement(id: string= = null, classes: Array<string>= = [], innerHTML: string= = "") {
    const div = document.createElement("div");
    if (id) {
        div.id = id;
    }
    for (let i = 0; i < classes.length; ++i) {
        div.classList.add(classes[i]);
    }
    div.innerHTML = innerHTML;
    return div;
}
/**
 * Helper method to create a new div
 */
export function makeDiv(parent: Element, id: string= = null, classes: Array<string>= = [], innerHTML: string= = "") {
    const div = makeDivElement(id, classes, innerHTML);
    parent.appendChild(div);
    return div;
}
/**
 * Helper method to create a new button element
 */
export function makeButtonElement(classes: Array<string>= = [], innerHTML: string= = "") {
    const element = document.createElement("button");
    for (let i = 0; i < classes.length; ++i) {
        element.classList.add(classes[i]);
    }
    element.classList.add("styledButton");
    element.innerHTML = innerHTML;
    return element;
}
/**
 * Helper method to create a new button
 */
export function makeButton(parent: Element, classes: Array<string>= = [], innerHTML: string= = "") {
    const element = makeButtonElement(classes, innerHTML);
    parent.appendChild(element);
    return element;
}
/**
 * Removes all children of the given element
 */
export function removeAllChildren(elem: Element) {
    if (elem) {
        var range = document.createRange();
        range.selectNodeContents(elem);
        range.deleteContents();
    }
}
/**
 * Returns if the game supports this browser
 */
export function isSupportedBrowser() {
    // please note,
    // that IE11 now returns undefined again for window.chrome
    // and new Opera 30 outputs true for window.chrome
    // but needs to check if window.opr is not undefined
    // and new IE Edge outputs to true now for window.chrome
    // and if not iOS Chrome check
    // so use the below updated condition
    if (G_IS_STANDALONE) {
        return true;
    }
    // @ts-ignore
    var isChromium = window.chrome;
    var winNav = window.navigator;
    var vendorName = winNav.vendor;
    // @ts-ignore
    var isIEedge = winNav.userAgent.indexOf("Edge") > -1;
    var isIOSChrome = winNav.userAgent.match("CriOS");
    if (isIOSChrome) {
        // is Google Chrome on IOS
        return false;
    }
    else if (isChromium !== null &&
        typeof isChromium !== "undefined" &&
        vendorName === "Google Inc." &&
        isIEedge === false) {
        // is Google Chrome
        return true;
    }
    else {
        // not Google Chrome
        return false;
    }
}
/**
 * Formats an amount of seconds into something like "5s ago"
 * {}
 */
export function formatSecondsToTimeAgo(secs: number): string {
    const seconds = Math.floor(secs);
    const minutes = Math.floor(seconds / 60);
    const hours = Math.floor(minutes / 60);
    const days = Math.floor(hours / 24);
    if (seconds < 60) {
        if (seconds === 1) {
            return T.global.time.oneSecondAgo;
        }
        return T.global.time.xSecondsAgo.replace("<x>", "" + seconds);
    }
    else if (minutes < 60) {
        if (minutes === 1) {
            return T.global.time.oneMinuteAgo;
        }
        return T.global.time.xMinutesAgo.replace("<x>", "" + minutes);
    }
    else if (hours < 24) {
        if (hours === 1) {
            return T.global.time.oneHourAgo;
        }
        return T.global.time.xHoursAgo.replace("<x>", "" + hours);
    }
    else {
        if (days === 1) {
            return T.global.time.oneDayAgo;
        }
        return T.global.time.xDaysAgo.replace("<x>", "" + days);
    }
}
/**
 * Formats seconds into a readable string like "5h 23m"
 * {}
 */
export function formatSeconds(secs: number): string {
    const trans = T.global.time;
    secs = Math.ceil(secs);
    if (secs < 60) {
        return trans.secondsShort.replace("<seconds>", "" + secs);
    }
    else if (secs < 60 * 60) {
        const minutes = Math.floor(secs / 60);
        const seconds = secs % 60;
        return trans.minutesAndSecondsShort
            .replace("<seconds>", "" + seconds)
            .replace("<minutes>", "" + minutes);
    }
    else {
        const hours = Math.floor(secs / 3600);
        const minutes = Math.floor(secs / 60) % 60;
        return trans.hoursAndMinutesShort.replace("<minutes>", "" + minutes).replace("<hours>", "" + hours);
    }
}
/**
 * Formats a number like 2.51 to "2.5"
 */
export function round1DigitLocalized(speed: number, separator: string= = T.global.decimalSeparator) {
    return round1Digit(speed).toString().replace(".", separator);
}
/**
 * Formats a number like 2.51 to "2.51 items / s"
 */
export function formatItemsPerSecond(speed: number, double: boolean= = false, separator: string= = T.global.decimalSeparator) {
    return ((speed === 1.0
        ? T.ingame.buildingPlacement.infoTexts.oneItemPerSecond
        : T.ingame.buildingPlacement.infoTexts.itemsPerSecond.replace("<x>", round2Digits(speed).toString().replace(".", separator))) + (double ? "  " + T.ingame.buildingPlacement.infoTexts.itemsPerSecondDouble : ""));
}
/**
 * Rotates a flat 3x3 matrix clockwise
 * Entries:
 * 0 lo
 * 1 mo
 * 2 ro
 * 3 lm
 * 4 mm
 * 5 rm
 * 6 lu
 * 7 mu
 * 8 ru
 */
export function rotateFlatMatrix3x3(flatMatrix: Array<number>) {
    return [
        flatMatrix[6],
        flatMatrix[3],
        flatMatrix[0],
        flatMatrix[7],
        flatMatrix[4],
        flatMatrix[1],
        flatMatrix[8],
        flatMatrix[5],
        flatMatrix[2],
    ];
}
/**
 * Generates rotated variants of the matrix
 * {}
 */
export function generateMatrixRotations(originalMatrix: Array<number>): Object<number, Array<number>> {
    const result = {
        0: originalMatrix,
    };
    originalMatrix = rotateFlatMatrix3x3(originalMatrix);
    result[90] = originalMatrix;
    originalMatrix = rotateFlatMatrix3x3(originalMatrix);
    result[180] = originalMatrix;
    originalMatrix = rotateFlatMatrix3x3(originalMatrix);
    result[270] = originalMatrix;
    return result;
}

/**
 * Rotates a directional object
 * {}
 */
export function rotateDirectionalObject(obj: DirectionalObject, rotation): DirectionalObject {
    const queue = [obj.top, obj.right, obj.bottom, obj.left];
    while (rotation !== 0) {
        rotation -= 90;
        queue.push(queue.shift());
    }
    return {
        top: queue[0],
        right: queue[1],
        bottom: queue[2],
        left: queue[3],
    };
}
/**
 * Modulo which works for negative numbers
 */
export function safeModulo(n: number, m: number) {
    return ((n % m) + m) % m;
}
/**
 * Returns a smooth pulse between 0 and 1
 * {}
 */
export function smoothPulse(time: number): number {
    return Math.sin(time * 4) * 0.5 + 0.5;
}
/**
 * Fills in a <link> tag
 */
export function fillInLinkIntoTranslation(translation: string, link: string) {
    return translation
        .replace("<link>", "<a href='" + link + "' target='_blank'>")
        .replace("</link>", "</a>");
}
/**
 * Generates a file download
 */
export function generateFileDownload(filename: string, text: string) {
    var element = document.createElement("a");
    element.setAttribute("href", "data:text/plain;charset=utf-8," + encodeURIComponent(text));
    element.setAttribute("download", filename);
    element.style.display = "none";
    document.body.appendChild(element);
    element.click();
    document.body.removeChild(element);
}
/**
 * Starts a file chooser
 */
export function startFileChoose(acceptedType: string = ".bin") {
    var input = document.createElement("input");
    input.type = "file";
    input.accept = acceptedType;
    return new Promise(resolve => {
        input.onchange = _ => resolve(input.files[0]);
        input.click();
    });
}
const MAX_ROMAN_NUMBER = 49;
const romanLiteralsCache = ["0"];
/**
 *
 * {}
 */
export function getRomanNumber(number: number): string {
    number = Math.max(0, Math.round(number));
    if (romanLiteralsCache[number]) {
        return romanLiteralsCache[number];
    }
    if (number > MAX_ROMAN_NUMBER) {
        return String(number);
    }
    function formatDigit(digit, unit, quintuple, decuple) {
        switch (digit) {
            case 0:
                return "";
            case 1: // I
                return unit;
            case 2: // II
                return unit + unit;
            case 3: // III
                return unit + unit + unit;
            case 4: // IV
                return unit + quintuple;
            case 9: // IX
                return unit + decuple;
            default:
                // V, VI, VII, VIII
                return quintuple + formatDigit(digit - 5, unit, quintuple, decuple);
        }
    }
    let thousands = Math.floor(number / 1000);
    let thousandsPart = "";
    while (thousands > 0) {
        thousandsPart += "M";
        thousands -= 1;
    }
    const hundreds = Math.floor((number % 1000) / 100);
    const hundredsPart = formatDigit(hundreds, "C", "D", "M");
    const tens = Math.floor((number % 100) / 10);
    const tensPart = formatDigit(tens, "X", "L", "C");
    const units = number % 10;
    const unitsPart = formatDigit(units, "I", "V", "X");
    const formatted = thousandsPart + hundredsPart + tensPart + unitsPart;
    romanLiteralsCache[number] = formatted;
    return formatted;
}
/**
 * Returns the appropriate logo sprite path
 */
export function getLogoSprite() {
    if (G_IS_STANDALONE || WEB_STEAM_SSO_AUTHENTICATED) {
        return "logo.png";
    }
    if (G_IS_BROWSER) {
        return "logo_demo.png";
    }
    return "logo.png";
}
/**
 * Rejects a promise after X ms
 */
export function timeoutPromise(promise: Promise, timeout = 30000) {
    return Promise.race([
        new Promise((resolve, reject) => {
            setTimeout(() => reject("timeout of " + timeout + " ms exceeded"), timeout);
        }),
        promise,
    ]);
}