BB Util

Util.ts

import { NS, Server } from "@ns";
import { copyHackFilesToServers } from "util/CopyFiles";

export enum Task {
    Hack = "hacks/SimpleHack.js",
    Grow = "hacks/SimpleGrow.js",
    Weaken = "hacks/SimpleWeaken.js",
}

export enum PortMessages {
    ServersBroken = "ServersBroken",
}

export type HashSpendingAction = "Improve Studying" | "Sell for Money" | "Increase Maximum Money";

const PurchasedServerBaseName = "a";

export function getCurrentDateTime() {
    // Get the current date and time
    let now = new Date(Date.now());

    // Extract the date and time components
    let date: number | string = now.getDate();
    let month: number | string = now.getMonth() + 1;
    let year: number | string = now.getFullYear();

    let hours: number | string = now.getHours();
    let minutes: number | string = now.getMinutes();
    let seconds: number | string = now.getSeconds();

    // Format the date and time components to have two digits
    date = date < 10 ? "0" + date : date;
    month = month < 10 ? "0" + month : month;
    hours = hours < 10 ? "0" + hours : hours;
    minutes = minutes < 10 ? "0" + minutes : minutes;
    seconds = seconds < 10 ? "0" + seconds : seconds;

    // Combine the date and time components into a string
    let formattedDateTime = `${date}/${month}/${year} - ${hours}:${minutes}:${seconds}`;

    return formattedDateTime;
}

export async function getPurchasedServers(ns: NS, portNumber: number) {
    const portHandle = ns.getPortHandle(portNumber);
    portHandle.clear();

    ns.exec("scripts/GetMyServers.js", "home", 1, portNumber);
    await portHandle.nextWrite();

    return JSON.parse(portHandle.read() as string) as Server[];
}

export async function getTargetServersForHack(ns: NS, portNumber: number, purchasedServers: Server[]) {
    const portHandle = ns.getPortHandle(portNumber);

    const args = [JSON.stringify(purchasedServers), portNumber];
    portHandle.clear();
    ns.exec("scripts/GetTargetServers.js", "home", 1, ...args);

    await portHandle.nextWrite();
    return JSON.parse(portHandle.read() as string) as Server[];
}

export function makeColour(r: number, g: number, b: number, foreGround: boolean = true) {
    return `\u001b[${foreGround ? 3 : 4}8;2;${r};${g};${b}m`;
}

export function buyAllTorStuff(ns: NS) {
    ns.singularity.purchaseTor();

    for (const prog of ns.singularity.getDarkwebPrograms()) {
        ns.singularity.purchaseProgram(prog);
    }
}

export function getServers(ns: NS) {
    const player = ns.getPlayer();

    const totalServers = getAllServers(ns.scan, "home", []).filter((s) => !s.includes("hacknet"));

    // my servers
    const boughtServers = getMyServers();
    const myServers = totalServers
        .map(ns.getServer)
        .filter((s) => s.hasAdminRights)
        .filter((s) => boughtServers.includes(s.hostname));

    // attack
    const targetServers = totalServers
        .map(ns.getServer)
        .filter((s) => !boughtServers.includes(s.hostname))
        .filter((s) => s.moneyMax! > 0)
        .filter((s) => Math.ceil(player.skills.hacking / 2) >= s.requiredHackingSkill!)
        .sort((a, b) => b.moneyMax! - a.moneyMax!);

    myServers.unshift(ns.getServer("home"));
    return { myServers, targetServers };
}

export function getMyServers() {
    return Array(25)
        .fill(0)
        .map((_, i) => {
            if (i - 1 === -1) return PurchasedServerBaseName;
            return `${PurchasedServerBaseName}-${i - 1}`;
        });
}

export function buyServers(ns: NS) {
    const serversBought = ns.getPurchasedServers();
    const updateScripts = (server: string) => {
        ns.scp(["hacks/SimpleGrow.js", "hacks/SimpleHack.js", "hacks/SimpleWeaken.js"], server, "home");
    };

    let boughtServers = false;

    // upgrade servers
    for (const server of serversBought) {
        if (ns.getServerMaxRam(server) === ns.getPurchasedServerMaxRam()) {
            continue;
        }

        const money = ns.getPlayer().money;
        const memory = ns.getServerMaxRam(server);
        const idx = Math.floor(Math.log2(memory));
        const ramQty = Math.floor(Math.pow(2, idx + 2));

        const cost = ns.getPurchasedServerUpgradeCost(server, ramQty);

        if (cost < Math.floor(money * 0.33)) {
            if (ns.upgradePurchasedServer(server, ramQty)) {
                updateScripts(server);
                ns.print(`Server ${server} upgraded => RAM: ${ramQty}`);
            }
        }
    }

    // Purchase server if server costs < 10% of money.
    let purchaseServer = false;
    let ramQty = 1;

    const costPurchase = () => ns.getPurchasedServerCost(ramQty) < Math.floor(ns.getPlayer().money * 0.1);
    const maxIdx = Math.floor(Math.log2(ns.getPurchasedServerMaxRam()));

    for (let i = maxIdx; i > 0; i--) {
        ramQty = Math.pow(2, i);

        if (costPurchase()) {
            purchaseServer = true;
            break;
        }
    }

    // buy server
    if (serversBought.length < ns.getPurchasedServerLimit() && purchaseServer) {
        const newServer = ns.purchaseServer(PurchasedServerBaseName, ramQty);

        if (newServer != "") {
            boughtServers = true;
            serversBought.push(newServer);
            ns.print(`Purchased new server, ${newServer}`);
            updateScripts(newServer);
        }
    }

    return boughtServers;
}

export function spendHashes(ns: NS, action: HashSpendingAction, targetServer: string | undefined, upgradeCount: number = 1) {
    if (ns.hacknet.hashCost(action, upgradeCount) > ns.hacknet.numHashes()) {
        action = "Increase Maximum Money";
    }

    const hasFinished = ns.hacknet.spendHashes(action, targetServer, upgradeCount);

    if (hasFinished) {
        ns.print(`Spending hashes on ${action}`);
        ns.print(`Bought ${action}`);
    }
}

export function breakServers(ns: NS, servers: Server[]) {
    const run = (file: string, host: string, program: (x: string) => void) => {
        try {
            program(host);
        } catch (e: any) {}
    };

    for (const server of servers) {
        copyHackFilesToServers(ns, [server]);

        const host = server.hostname;

        if (!server.sshPortOpen) run("BruteSSH.exe", host, ns.brutessh);
        if (!server.ftpPortOpen) run("FTPCrack.exe", host, ns.ftpcrack);
        if (!server.httpPortOpen) run("HTTPWorm.exe", host, ns.httpworm);
        if (!server.sqlPortOpen) run("SQLInject.exe", host, ns.sqlinject);
        if (!server.smtpPortOpen) run("relaySMTP.exe", host, ns.relaysmtp);

        const portsOpened = [
            server.sshPortOpen,
            server.ftpPortOpen,
            server.httpPortOpen,
            server.sqlPortOpen,
            server.smtpPortOpen,
        ].reduce((a, b) => a + Number(b), 0);

        if (!server.hasAdminRights && (server.numOpenPortsRequired as number) <= portsOpened) {
            ns.nuke(host);
        }
    }
}

export function getHoursSinceReset(ns: NS) {
    return (Date.now() - ns.getResetInfo().lastAugReset) / 3600000;
}

export function getAllServers(scan: (x: string) => string[], server: string, existingServers: string[]) {
    const newServers = scan(server) // pad
        .filter((ss) => !existingServers.includes(ss));

    if (newServers.length === 0) {
        return [server];
    }

    existingServers.push(...newServers);

    for (const s of newServers) {
        const nextServers = getAllServers(scan, s, existingServers);
        existingServers.push(...nextServers);
    }

    return [...new Set(existingServers)];
}

export function getThreadCountForSimpleOps(ns: NS, srcServer: Server, script: string, percent: number = 0.99) {
    const available = Math.ceil(srcServer.maxRam) - Math.ceil(srcServer.ramUsed);
    let scriptUsage = script === "hacks/SimpleHack.js" ? 1.7 : 1.75;

    if (available <= 0) {
        return 0;
    }

    const threads = Math.floor((percent * available) / scriptUsage);
    return threads;
}

export function getThreadCount(ns: NS, srcServer: Server, script: string, percent: number = 0.99) {
    const available = Math.ceil(srcServer.maxRam) - Math.ceil(srcServer.ramUsed);
    const scriptUsage = ns.getScriptRam(script, srcServer.hostname);

    if (available === 0 || scriptUsage === 0) {
        return 0;
    }

    const threads = Math.floor((percent * available) / scriptUsage);
    return threads;
}

/***
 * Thanks to quacksouls for this:
 * https://gist.github.com/quacksouls/dde4532740c2204425fa83bba3ceb8fa
 */
export function shell(cmd) {
    // Template code from the official documentation of Bitburner:
    //
    // https://bitburner.readthedocs.io/en/latest/netscript/advancedfunctions/inject_html.html
    const input: any = globalThis["document"].getElementById("terminal-input");
    input.value = cmd;
    const handler = Object.keys(input)[1];
    input[handler].onChange({
        target: input,
    });
    input[handler].onKeyDown({
        key: "Enter",
        preventDefault: () => null,
    });
}