bitburner scripts

balanced-hack.js

/** @param {NS} ns */
export async function main(ns) {
    var target = ns.args[0];
    var moneyThresh = ns.getServerMaxMoney(target) * 0.9;
    var securityThresh = ns.getServerMinSecurityLevel(target) + 5;
    while (true) {
        if (ns.getServerSecurityLevel(target) > securityThresh) {
            await ns.weaken(target, { stock: true });
        } else if (ns.getServerMoneyAvailable(target) < moneyThresh) {
            await ns.grow(target, { stock: true });
        } else {
            let moneyStolen = await ns.hack(target, { stock: true });
            ns.tprint(`${ns.nFormat(moneyStolen, "$00,00a")}`)
        }
    }
}

server-broker.js

export let globalTarget = 'iron-gym'


// use ns.nFormat
function formatCurrency(number) {
	return number.toLocaleString({ minimumFractionDigits: 2 })
}

/** @param {NS} ns */
async function getAccessToServ(ns, hostname) {
	if (ns.getServerNumPortsRequired(hostname) <= 5) {
		ns.brutessh(hostname);
		ns.ftpcrack(hostname);
		ns.sqlinject(hostname);
		ns.httpworm(hostname);
		ns.relaysmtp(hostname)
		try {
			ns.nuke(hostname);
			ns.tprint(`SUCCESS NUKED ${hostname} Access Granted \$.`)
		} catch (e) {
			ns.tprint(`ERROR Unexpected failure; couldn't get root access on serv: ${hostname}`)
		}
	}
}

/** @param {NS} ns */
async function executeScript(ns, hostname) {
	let scriptToInject = ns.args[0]
	ns.scp(scriptToInject, hostname)
	let maxRam = ns.getServerMaxRam(hostname)
	let scriptRam = ns.getScriptRam(scriptToInject)
	let concurrency = Math.floor(maxRam / scriptRam)
	if (concurrency > 0) {
		ns.print(`SUCCESS Running ${scriptToInject} with ${concurrency} threads on ${hostname}`)
		ns.exec(scriptToInject, hostname, concurrency, ns.args[1] ? ns.args[1] : globalTarget)
		return concurrency
	}
	return 0
}

/** @param {NS} ns */
async function killAllScripts(ns, hostname) {
	ns.killall(hostname)
}

/** @param {NS} ns */
export async function getServerInformation(ns, hostname) {
	let stats = {
		'hostname': hostname,
		'moneyRatio': ns.getServerMoneyAvailable(hostname) / ns.getServerMaxMoney(hostname),
		'moneyAvailable': ns.getServerMoneyAvailable(hostname),
		'maxMoney': ns.getServerMaxMoney(hostname),
		'minSecurityLevel': ns.getServerMinSecurityLevel(hostname),
		'hackingLevelRequired': ns.getServerRequiredHackingLevel(hostname),
		'securityLevel': ns.getServerSecurityLevel(hostname),
		'maxRam': ns.getServerMaxRam(hostname),
		'usedRam': ns.getServerUsedRam(hostname),
		'rootAccess': ns.hasRootAccess(hostname)
	}
	return stats
}

/** @param {NS} ns */
async function dfs(ns, mapFunction) {
	let output = []
	let visitedServers = []
	let serversToVisit = ["home"]
	while (serversToVisit.length > 0) {
		// grab the first server to visit, fetch its neighboring networks, p
		let currentServer = serversToVisit.shift()
		visitedServers.push(currentServer)
		let servers = ns.scan(currentServer)

		output.push(await mapFunction(ns, currentServer))
		// visit all of connected servers if they haven't been explored yet
		for (let server of servers) {
			if (!visitedServers.includes(server) && !serversToVisit.includes(server)) {
				serversToVisit.push(server)
			}
		}
	}
	return output
}

/** @param {NS} ns */
async function getHackableServers(ns) {
	let allServerInformation = await dfs(ns, getServerInformation)

	let sortedByMoneyAvailable = allServerInformation
		.filter(servInfo => {
			return servInfo.rootAccess
				&& servInfo.maxMoney > 0
				&& ~~(servInfo.hackingLevelRequired * 3) <= ns.getHackingLevel()
		})
		.sort((a, b) => b.maxMoney - a.maxMoney)

	// sortedByMoneyAvailable.map(serv => ns.tprint(`[${serv.hostname}] - \$${formatCurrency(serv.moneyAvailable)} of \$${formatCurrency(serv.maxMoney)} - Sec Level: ${serv.securityLevel} - Hack Level: ${serv.hackingLevelRequired}\n`))
	return sortedByMoneyAvailable
}

/** @param {NS} ns */
async function hackAndExecuteScript(ns, hostname) {
	if (hostname !== "home") {
		await killAllScripts(ns, hostname)

		if (!ns.hasRootAccess(hostname)) {
			ns.tprint(`No root access - attempting to get access on ${hostname}`)
			await getAccessToServ(ns, hostname)
		}

		if (ns.args[0] && ns.hasRootAccess(hostname)) {
			await executeScript(ns, hostname)
		}
	}
}

/** @param {NS} ns */
async function listNumOfThreads(ns, hostname) {
	let runningThreads = 0
	let scripts = ns.ps(hostname)
	scripts.forEach(s => {
		runningThreads += s.threads
	})

	return runningThreads
}

/** @param {NS} ns */
export async function main(ns) {
	// await printEachServerInformation(ns)
	// if (ns.args[0]) {
	// 	await dfs(ns, hackAndExecuteScript)
	// }
	// let allThreads = await dfs(ns, listNumOfThreads)
	// ns.tprint('Total Threads: ' + allThreads.reduce((a,b) => a +b, 0))
	let servs = await getHackableServers(ns)
	let scriptToInject = "balanced-hack.js"
	let topFiveServs = servs.slice(0, 5)
	for (let pserv of ns.getPurchasedServers()) {
		ns.scp(scriptToInject, pserv)
		let maxRam = ns.getServerMaxRam(pserv)
		let scriptRam = ns.getScriptRam(scriptToInject)
		for (let servTohack of topFiveServs) {
			// for each server we own, we're going to spawn enough threads to manage hacking each of the five servs in a balanced distributed format.
			let concurrency = Math.floor(maxRam / scriptRam) / 5
			if (concurrency > 0) {
				ns.tprint(`Launching ${concurrency} threads of ${scriptToInject} on ${servTohack.hostname}`)
				ns.exec(scriptToInject, pserv, concurrency, servTohack.hostname)
			}
		}
	}
}