From 83ba1af0ccb9b5d149f0c05ac33b3f46c322b9fc Mon Sep 17 00:00:00 2001
From: Isaac Shoebottom <ir.shoebottom@gmail.com>
Date: Mon, 6 Nov 2023 20:20:36 -0400
Subject: [PATCH] Refactor hacknet logic

---
 servers/home/hacknet.ts | 55 +++++++++++++++++++----------------------
 1 file changed, 26 insertions(+), 29 deletions(-)

diff --git a/servers/home/hacknet.ts b/servers/home/hacknet.ts
index 011ee99..6281302 100644
--- a/servers/home/hacknet.ts
+++ b/servers/home/hacknet.ts
@@ -13,37 +13,35 @@
  *   If the upgrade mps is less than the average mps, then buy a new node.
  */
 
-enum Type {
-	newNode = "node", level = "level", ram = "ram", core = "code",
+enum UpgradeType {
+	level = "level", ram = "ram", core = "code",
 }
 
 export async function main(ns: NS) {
 	let timeout: number = <number> ns.args[0]
 
 	let nodes = ns.hacknet.numNodes()
-	// If there are no nodes, buy one
+	// If there are no nodes, buyUpgrade one
 	if (nodes === 0) {
 		ns.hacknet.purchaseNode()
 		nodes = 1
 	}
 
-	let costs: { type: Type, cost: number }[] = []
+	let costs: { type: UpgradeType, cost: number }[] = []
 	while (true) {
 		costs = []
 		// Go through each node and get the cheapest upgrade
 		for (let i = 0; i < nodes; i++) {
 			costs.push(getCheapestCost(ns, i))
 		}
-		// Buy the cheapest upgrade from all nodes
-		let cheapest = Math.min(...costs.map(c => c.cost))
-		// Find the index of the cheapest cost in the list
-		let index = costs.findIndex(c => c.cost === cheapest)
-		// Wait to buy the cheapest upgrade
-		try {
-			await buy(ns, costs[index].type, costs[index].cost, index, timeout)
-		} catch (e) {
-			ns.tprint(e)
-			ns.exit()
+		// Get the cheapest upgrade object
+		let cheapest = costs.reduce((prev, curr) => prev.cost < curr.cost ? prev : curr)
+
+		// Nodes have a lot more value, so only need node price to be 1/10th the cost of the cheapest upgrade
+		if (ns.hacknet.getPurchaseNodeCost() / 10 < cheapest.cost) {
+			await buyNode(ns, ns.hacknet.getPurchaseNodeCost(), timeout)
+		} else {
+			await buyUpgrade(ns, cheapest.type, cheapest.cost, costs.indexOf(cheapest), timeout)
 		}
 		// Make sure that the number of nodes is up-to-date
 		nodes = ns.hacknet.numNodes()
@@ -51,7 +49,7 @@ export async function main(ns: NS) {
 }
 
 /**
- * Wait until the player has enough money to buy something
+ * Wait until the player has enough money to buyUpgrade something
  * @param ns Global NS object
  * @param money Amount of money to wait for
  * @param timeout=-1 Number of seconds to wait before timing out.
@@ -69,38 +67,37 @@ async function waitUntilMoney(ns: NS, money: number, timeout: number = -1) {
 	}
 }
 
-async function buy(ns: NS, type: Type, cost: number, node: number, timeout: number) {
+async function buyUpgrade(ns: NS, type: UpgradeType, cost: number, node: number, timeout: number) {
 	await waitUntilMoney(ns, cost, timeout)
 	switch (type) {
-		case Type.newNode:
-			ns.hacknet.purchaseNode()
-			break
-		case Type.level:
+		case UpgradeType.level:
 			ns.hacknet.upgradeLevel(node)
 			break
-		case Type.ram:
+		case UpgradeType.ram:
 			ns.hacknet.upgradeRam(node)
 			break
-		case Type.core:
+		case UpgradeType.core:
 			ns.hacknet.upgradeCore(node)
 			break
 	}
 }
 
+async function buyNode(ns: NS, cost: number, timeout: number) {
+	await waitUntilMoney(ns, cost, timeout)
+	ns.hacknet.purchaseNode()
+}
+
 function getCheapestCost(ns: NS, node: number) {
-	let nodeCost = ns.hacknet.getPurchaseNodeCost()
 	let levelCost = ns.hacknet.getLevelUpgradeCost(node)
 	let ramCost = ns.hacknet.getRamUpgradeCost(node)
 	let coreCost = ns.hacknet.getCoreUpgradeCost(node)
-	let cheapest = Math.min(nodeCost, levelCost, ramCost, coreCost)
+	let cheapest = Math.min(levelCost, ramCost, coreCost)
 	switch (cheapest) {
-		case nodeCost:
-			return { type: Type.newNode, cost: nodeCost }
 		case levelCost:
-			return { type: Type.level, cost: levelCost }
+			return { type: UpgradeType.level, cost: levelCost }
 		case ramCost:
-			return { type: Type.ram, cost: ramCost }
+			return { type: UpgradeType.ram, cost: ramCost }
 		case coreCost:
-			return { type: Type.core, cost: coreCost }
+			return { type: UpgradeType.core, cost: coreCost }
 	}
 }