Bitburner: Automatisation pour les nœuds Hacknet

Automatisation complète pour les nœuds Hacknet qui recherche la mise à niveau la plus rentable et la choisit.

Comment ça fonctionne

L'algorithme recherche le ratio le plus rentable.

Rapport = Croissance de la production divisé par Coût de mise à niveau
Croissance de la production = Production après mise à niveau divisé par La production actuelle

je te recommande pour passer un plus grand temps d'itération de boucle (par exemple. 100 000) ou laissez la valeur par défaut pour permettre aux nœuds hacknet de collecter plus d'argent afin qu'ils puissent comparer plus de mises à niveau au lieu de constamment mettre à niveau la moins chère.

Usage

Pas à pas

  1. Ouvrir le terminal
  2. Taper “nano hacknet-bot.ns” créer un fichier
  3. Effacez le fichier et collez le code ci-dessous
  4. Enregistrer le fichier
  5. Retournez au terminal
  6. Taper “exécuter hacknet-bot.ns” exécuter un script

Vous pouvez définir un temps de fréquence de boucle en passant un argument de script supplémentaire
par exemple. “exécuter hacknet-bot.ns 10000”

Fréquence de boucle par défaut. est de 60 000 ms = 1 min.

Vous pouvez également copier le code de https://www.paste.org/121034.

Code

/** @param {N.-É.} ns **/
export const main = async ns => {
	// helpers
	const getMoney = () => ns.getPlayer().de l'argent;
	const getProduction = (niveau, RAM, noyaux) => (niveau * 1.5) * Math.pow(1.035, RAM - 1) * ((noyaux + 5) / 6);
 
	// intervalle de boucle passé en paramètre de script, default interval is 60 000ms
	const interval = ns.args[0] || 60000;
 
	// main loop
	while (vrai) {
		// loop through all hacknet nodes
		for (indice variable = 0; indice < attendre ns.hacknet.numNodes(); indice++) { // votre argent actuel const money = getMoney(); // votre multiplicateur de production à partir des augmentations installées const prodMultiplier = wait ns.getHacknetMultipliers().production; // obtenir les statistiques du nœud actuel const nodeStats = wait ns.hacknet.getNodeStats(indice); const curRam = nodeStats.ram; const curLevel = nodeStats.level; const curCores = nodeStats.cores; const curProd = nodeStats.production; // obtenir les coûts des mises à niveau const ramUpgradeCost = wait ns.hacknet.getRamUpgradeCost(indice); const levelUpgradeCost = wait ns.hacknet.getLevelUpgradeCost(indice); const coreUpgradeCost = wait ns.hacknet.getCoreUpgradeCost(indice); // vérifiez la rentabilité des mises à niveau et si vous avez assez d'argent // UPGRADE RATIO = croissance de la production après la mise à niveau / production actuelle const prodGrowthAfterLevelUpgrade = (obtenirProduction(curLevel + 1, curRam, curCores) * prodMultiplicateur) - curProd; const levelUpgradeRatio = argent >= attend levelUpgradeCost 
				? prodGrowthAfterLevelUpgrade / wait levelUpgradeCost
				: 0;
 
			const prodGrowthAfterRamUpgrade = (obtenirProduction(curLevel, courir * 2, curCores) * prodMultiplicateur) - curProd;
			const ramUpgradeRatio = argent >= attendre ramUpgradeCost
				? prodGrowthAfterRamUpgrade / wait ramUpgradeCost
				: 0;
 
			const prodGrowthAfterCoresUpgrade = (obtenirProduction(curLevel, curRam, curCores + 1) * prodMultiplicateur) - curProd;
			const coresUpgradeRatio = argent >= attendre coreUpgradeCost 
				? prodGrowthAfterCoresUpgrade / wait coreUpgradeCost
				: 0;
 
			// check if you have enough money for any upgrade
			const ratios = [levelUpgradeRatio, ramUpgradeRatio, coresUpgradeRatio];
			si (ratios.chaque(rapport => rapport === 0)) {
				Continuez;
			}
 
			// find the most profitability upgrade
			const mostProfitUpgrade = Math.max(...rapports);
			const mostProfitUpgradeIndex = ratios.findIndex(rapport => ratio === mostProfitUpgrade);
 
			// execute the most profitability upgrade
			switch (mostProfitUpgradeIndex) {
				cas 0:
					attendre ns.hacknet.upgradeLevel(indice, 1);
					Pause;	
				cas 1:
					attendre ns.hacknet.upgradeRam(indice, 1);
					Pause;	
				cas 2:
					attendre ns.hacknet.upgradeCore(indice, 1);
					Pause;
				défaut:
					Continuez;
			}
		}
 
		// check if you can buy new node machine
		if (Gagner de l'argent() > attendre ns.hacknet.getPurchaseNodeCost()) {
			attendre ns.hacknet.purchaseNode();
		}
		
		// sleep to prevent crash because of infinite loop
		await ns.sleep(intervalle);
	}
}

Par syw1

Plus de guides:

Soyez le premier à commenter

Laisser une réponse

Votre adresse de messagerie ne sera pas publiée.


*