init commit

getNodes.js

@@ -0,0 +1,204 @@
+import { crack } from "crack.js";
+/** @param {NS} ns */
+function printHelp(ns) {
+    ns.tprint(
+        "This is a core script which handles basic node (or server/host) operations.\n" +
+        "Some functions are available via an API, some are only available through\n" +
+        "the command line interface.\n\n" +
+        "API REFERENCE:\n" + 
+        "isHackable(ns, node): boolean\n"
+    );
+}
+
+/** @param {NS} ns */
+export async function totalAvailableThreads(ns, script) {
+    var nodes = await getNodes(ns);
+    var threads = 0;
+
+    nodes.forEach(function(node) {
+        threads += Math.floor(ns.getServerMaxRam(node) / ns.getScriptRam(script));
+    });
+
+    return threads;
+}
+
+/** @param {NS} ns */
+export function isHackable(ns, node) {
+    if(node == "" || node == "\n" || node == "home" || node == "darkweb") {
+        return false;
+    }
+
+    if(node.slice(0, 6) == "server-") {
+        return true;
+    }
+
+    // Skip servers I cannot hack.
+    if(ns.getHackingLevel() < ns.getServerRequiredHackingLevel(node)) {
+        return false;
+    }
+
+    // Crack if I don't have root access.
+    if(!ns.hasRootAccess(node)) {
+        if(!crack(ns, node)) {
+            return false;
+        }
+    }
+    
+    return true;
+}
+
+/** @param {NS} ns */
+export async function getNodesByRam(ns) {
+    let nodes = (await ns.read("nodes.txt")).split("\n");
+    const n = nodes.length;
+
+    for (let i = 0; i < n - 1; i++) {
+        let swapped = false; // Flag to optimize: if no swaps occur, the array is sorted
+    
+        for (let j = 0; j < n - i - 1; j++) {
+            if (ns.getServerMaxRam(nodes[j]) > ns.getServerMaxRam(nodes[j + 1])) {
+                // Swap arr[j] and arr[j+1]
+                [nodes[j], nodes[j + 1]] = [nodes[j + 1], nodes[j]]; // Array destructuring for swap
+                swapped = true;
+            }
+        }
+    
+        // If no two elements were swapped in inner loop, the array is sorted
+        if (swapped === false) {
+            break;
+        }
+    }
+    nodes = nodes.reverse();
+    while(ns.getServerMaxRam(nodes[nodes.length - 1]) == 0) {
+        nodes.pop();
+    }
+
+    return nodes;
+}
+
+/** @param {NS} ns */
+export async function getNodesByPriority(ns) {
+    const nodes = (await ns.read("nodes.txt")).split("\n");
+    const n = nodes.length;
+
+    for (let i = 0; i < n - 1; i++) {
+        let swapped = false; // Flag to optimize: if no swaps occur, the array is sorted
+    
+        for (let j = 0; j < n - i - 1; j++) {
+            if (ns.getServerMaxMoney(nodes[j]) > ns.getServerMaxMoney(nodes[j + 1])) {
+                // Swap arr[j] and arr[j+1]
+                [nodes[j], nodes[j + 1]] = [nodes[j + 1], nodes[j]]; // Array destructuring for swap
+                swapped = true;
+            }
+        }
+    
+        // If no two elements were swapped in inner loop, the array is sorted
+        if (swapped === false) {
+            break;
+        }
+    }
+    return nodes.reverse();
+}
+
+/** @param {NS} ns */
+async function getNodesByHackable(ns) {
+    const nodes = (await ns.read("nodes.txt")).split("\n");
+    var hackableNodes = [];
+
+    for (let i = 0; i < nodes.length; i++) {
+        if(isHackable(ns, nodes[i])) {
+            hackableNodes.push(nodes[i]);
+        }
+    }
+
+    return hackableNodes;
+}
+
+/** @param {NS} ns */
+export async function getNodes(ns) {
+    const nodes = await ns.read("nodes.txt");
+    return nodes.split("\n");
+}
+
+/** @param {NS} ns */
+export function getIdealNode(ns) {
+	var nodes = ['home']
+	for (var i = 0; i < nodes.length; i++) {
+		var node = ns.scan(nodes[i]);
+		for (var j = 0; j < node.length; j++) {
+			if (nodes.indexOf(node[j]) === -1 && isHackable(ns, node[j])) {
+				nodes.push(node[j]);
+			}
+		}
+	}
+
+    var idealNode = "n00dles";
+    nodes.forEach(function(n) {
+        if(ns.getServerMaxMoney(n) > ns.getServerMaxMoney(idealNode)) {
+            idealNode = n;
+        }
+    });
+
+    return idealNode;
+}
+
+/** @param {NS} ns */
+async function write(ns, nodes) {
+    await ns.write("nodes.txt", "", "w");
+
+    var hackableNodes = [];
+    for(var i = 0; i < nodes.length; i++) {
+        if(isHackable(ns, nodes[i])) {
+            hackableNodes.push(nodes[i]);
+        }
+    }
+
+    for(var i = 0; i < hackableNodes.length; i++) {
+        let text = hackableNodes[i];
+        if(i != hackableNodes.length - 1) {
+            text += "\n";
+        }
+
+        await ns.write("nodes.txt", text, "a");
+    }
+}
+
+/** @param {NS} ns */
+export async function main(ns) {
+    var nodes = ['home']
+    for (var i = 0; i < nodes.length; i++) {
+        var node = ns.scan(nodes[i]);
+        for (var j = 0; j < node.length; j++) {
+            if (nodes.indexOf(node[j]) === -1) {
+                nodes.push(node[j]);
+            }
+        }
+    }
+
+    if(ns.args.length == 0) {
+        ns.tprint(nodes);
+    } else if(ns.args[0] == "--update" || ns.args[0] == "-u") {
+        await write(ns, nodes);
+
+    // Get the ideal node to target.
+    } else if(ns.args[0] == "--priority" || ns.args[0] == "-p") {
+        ns.tprint("nodes by priority: " + await getNodesByPriority(ns));
+
+    } else if(ns.args[0] == "--hackable" || ns.args[0] == "-ha") {
+        var hackableNodes = await getNodesByHackable(ns);
+        ns.tprint(hackableNodes.length + " hackable nodes: " + hackableNodes);
+
+    } else if(ns.args[0] == "--help" || ns.args[0] == "-h") {
+        printHelp(ns);
+        exit();
+
+    // Kill all scripts except on home.
+    } else if(ns.args[0] == "--killall" || ns.args[0] == "-k") {
+        var nodes = await getNodes(ns);
+        nodes.forEach(function(n) {
+            ns.killall(n);
+        });
+    }
+
+    return nodes;
+}