bitburner/scripts/node-manager.js

104 lines
3.8 KiB
JavaScript
Raw Normal View History

2022-03-09 14:06:14 -05:00
import {ArgError, ArgParser} from './scripts/lib/arg-parser';
2022-02-10 12:10:26 -05:00
2022-02-04 17:06:44 -05:00
/**
2022-03-09 14:06:14 -05:00
* Buy, upgrade & manage Hacknet nodes automatically.
* @params ns {NS} - BitBurner API
2022-02-04 17:06:44 -05:00
*/
2022-02-04 11:49:05 -05:00
export async function main(ns) {
2022-03-09 14:06:14 -05:00
// Setup
2022-02-10 12:10:26 -05:00
ns.disableLog('ALL');
2022-03-09 14:06:14 -05:00
const historyLength = 17;
const messageHistory = Array(historyLength).fill('');
let args, nodeCount = ns.hacknet.numNodes();
const argParser = new ArgParser('node-manager.js', 'Buy, upgrade & manage Hacknet nodes automatically. Tail for live updates.', null, [
{name: 'limit', desc: 'Limit the number of nodes the manager will buy, defaults to 8', optional: true, default: 8, type: 'num'},
{name: 'balance', desc: 'Prevent spending bellow point', flags: ['-b', '--balance'], type: 'num'}
]);
try {
args = argParser.parse(ns.args);
} catch(err) {
if(err instanceof ArgError) return ns.tprint(argParser.help(err.message));
throw err;
}
2022-02-04 16:17:48 -05:00
2022-02-04 17:06:44 -05:00
/**
* Print header with logs
2022-02-10 12:43:41 -05:00
* @param message - message to append to logs
2022-02-04 17:06:44 -05:00
*/
2022-02-04 16:17:48 -05:00
function log(message) {
ns.clearLog();
ns.print('===================================================');
2022-03-09 14:06:14 -05:00
ns.print(`Node Manager: ${nodeCount}/${args['limit']} Nodes`);
2022-02-04 16:17:48 -05:00
ns.print('===================================================');
2022-02-09 22:18:01 -05:00
if(message != null) messageHistory.push(message);
messageHistory.splice(0, messageHistory.length - historyLength);
messageHistory.forEach(m => ns.print(m));
2022-02-04 16:17:48 -05:00
}
2022-03-09 14:06:14 -05:00
// Run
2022-02-04 16:17:48 -05:00
log();
2022-02-04 11:49:05 -05:00
while(true) {
2022-02-09 22:18:01 -05:00
const balance = ns.getServerMoneyAvailable('home');
2022-02-04 11:49:05 -05:00
2022-02-04 17:06:44 -05:00
// Check if we should buy a new node
2022-03-09 14:06:14 -05:00
if(nodeCount < args['limit'] && balance - ns.hacknet.getPurchaseNodeCost() >= args['balance']) {
2022-02-04 14:29:15 -05:00
nodeCount++;
ns.hacknet.purchaseNode();
2022-02-04 16:17:48 -05:00
log(`Buying Node ${nodeCount}`);
2022-02-04 14:29:15 -05:00
} else {
2022-02-04 17:06:44 -05:00
// Create an ordered list of nodes by their cheapest upgrade
2022-02-09 22:18:01 -05:00
const nodes = Array(nodeCount).fill(null)
2022-02-04 17:06:44 -05:00
.map((ignore, i) => ({ // Gather information
2022-02-04 14:29:15 -05:00
index: i,
cacheCost: ns.hacknet.getCacheUpgradeCost(i),
coreCost: ns.hacknet.getCoreUpgradeCost(i),
levelCost: ns.hacknet.getLevelUpgradeCost(i),
ramCost: ns.hacknet.getRamUpgradeCost(i),
...ns.hacknet.getNodeStats(i)
2022-02-04 17:06:44 -05:00
})).map(node => { // Figure out cheapest upgrade
2022-02-04 14:29:15 -05:00
if(node.cacheCost != 0 && node.cacheCost != Infinity && node.cacheCost <= node.coreCost && node.cacheCost <= node.levelCost && node.cacheCost <= node.ramCost) {
node.bestUpgrade = {
2022-02-10 12:10:26 -05:00
name: 'cache',
2022-02-04 14:29:15 -05:00
cost: node.cacheCost,
purchase: () => ns.hacknet.upgradeCache(node.index)
};
} else if(node.coreCost != 0 && node.coreCost != Infinity && node.coreCost <= node.cacheCost && node.coreCost <= node.levelCost && node.coreCost <= node.ramCost) {
node.bestUpgrade = {
2022-02-10 12:10:26 -05:00
name: 'cores',
2022-02-04 14:29:15 -05:00
cost: node.coreCost,
purchase: () => ns.hacknet.upgradeCore(node.index)
};
} else if(node.ramCost != 0 && node.ramCost != Infinity && node.ramCost <= node.cacheCost && node.ramCost <= node.levelCost && node.ramCost <= node.coreCost) {
node.bestUpgrade = {
2022-02-10 12:10:26 -05:00
name: 'ram',
2022-02-04 14:29:15 -05:00
cost: node.ramCost,
purchase: () => ns.hacknet.upgradeRam(node.index)
};
} else {
node.bestUpgrade = {
2022-02-10 12:10:26 -05:00
name: 'level',
2022-02-04 14:29:15 -05:00
cost: node.levelCost,
purchase: () => ns.hacknet.upgradeLevel(node.index)
};
}
return node;
2022-02-04 17:06:44 -05:00
}).sort((a, b) => { // Sort by cheapest upgrade
2022-02-04 14:29:15 -05:00
if(a.bestUpgrade.cost > b.bestUpgrade.cost) return 1;
if(a.bestUpgrade.cost < b.bestUpgrade.cost) return -1;
return 0;
});
2022-02-04 17:06:44 -05:00
// Apply the cheapest upgrade
2022-03-09 14:06:14 -05:00
if(nodes.length && balance - nodes[0].bestUpgrade.cost >= args['balance']) {
2022-02-09 22:18:01 -05:00
const cost = Math.round(nodes[0].bestUpgrade.cost * 100) / 100;
2022-02-10 12:10:26 -05:00
log(`Node ${nodes[0].index} - ${nodes[0].bestUpgrade.name} ${nodes[0][nodes[0].bestUpgrade.name] + 1} - $${cost}`);
2022-02-09 22:18:01 -05:00
nodes[0].bestUpgrade.purchase();
2022-02-04 14:29:15 -05:00
}
}
2022-02-04 11:49:05 -05:00
2022-02-04 17:06:44 -05:00
// Check again in 1s
2022-02-04 14:29:15 -05:00
await ns.sleep(1000);
2022-02-04 11:49:05 -05:00
}
2022-02-10 12:12:29 -05:00
}