New Setup?

2024-10-06 10:23:13 +02:00
parent 4ac218bba3
commit 0824fbb6f1
115 changed files with 9187 additions and 0 deletions
--- a/Ramses/home/batch.js
+++ b/Ramses/home/batch.js
@@ -0,0 +1,205 @@
+import { getGrowThreads } from "myLibrary.js";
+
+/** @param {NS} ns */
+export async function main(ns) {
+  //Arguments
+  const nArgs = ns.args.length
+  const sTarget = ns.args[0]; // target server
+  let nFrequency = ns.args[1]; // frequency to run the Hack / Grow / Weaken
+  const bIgnoreRAM = ns.args[2]; //if true the script will run even if estimated RAM is too low
+  const bTail = ns.args[3]; //if true the script will run even if estimated RAM is too low
+
+  //host and script info
+  //const sThisRunner = ns.getHostname();
+  //const sThisScript = ns.getScriptName();
+  if (bTail === true) { ns.tail(); }
+
+  //logs
+  ns.disableLog("ALL");
+
+  //Settings
+  const sHackScript = "RMhack.js";
+  const sGrowScript = "RMgrow.js";
+  const sWeakenScript = "RMweaken.js";
+
+  const nHackThreads = 5;   //1
+
+  const nHackScriptRAM = 1.75;
+  const nGrowScriptRAM = 1.7;
+  const nWeakenScriptRAM = 1.75;
+
+
+  //abort script if sTarget is undefined
+  if (sTarget === undefined) { ns.tprint("1st arg sTarget is undefined"); return false; }
+
+  //how often do we run script in milliseconds
+  if (nFrequency === undefined) { nFrequency = 1000; }
+
+  //target server info
+  const nMinSecurity = ns.getServerMinSecurityLevel(sTarget);
+  const nMaxMoney = ns.getServerMaxMoney(sTarget);
+
+  //abort script if sTarget cant have money
+  if (nMaxMoney <= 0) { ns.tprint("sTarget (" + sTarget + ") has no nMaxMoney"); return false; }
+
+  let nCurrentSecurity = ns.getServerSecurityLevel(sTarget);
+  let nCurrentMoney = ns.getServerMoneyAvailable(sTarget);
+
+  let nBonusWeaken = 0;
+  let nBonusGrow = 0;
+
+  /*if (nCurrentSecurity > nMinSecurity + 3) {
+    nBonusWeaken = 4;
+  }
+  if (nCurrentMoney <= nMaxMoney * 0.8) {
+    nBonusGrow = 9;
+  }*/
+
+  let nGrowThreads = Math.max(12 + nBonusGrow, getGrowThreads(ns, sTarget, nHackThreads));
+  let nGrowThreadsINT = Math.ceil(nGrowThreads);
+
+  //25 hacks or 12.5 grows
+  let nWeakenThreads = Math.max(1 + nBonusWeaken, (nHackThreads / 25) + (nGrowThreads / 12.5));
+  let nWeakenThreadsINT = Math.ceil(nWeakenThreads);
+
+  //main variables
+  const oRunner = ns.getServer();   //which server object is running this script
+  const sRunner = oRunner.hostname; //hostname string of the server running the script
+  const nCores = oRunner.cpuCores;
+
+  //const sRunner = ns.getHostname(); //hostname string of the server running the script
+  let nMaxRAM = ns.getServerMaxRam(sRunner);
+  let nUsedRAM = ns.getServerUsedRam(sRunner);
+  let nFreeRam = nMaxRAM - nUsedRAM;
+  //const sScriptName = ns.getScriptName();
+  //const nScriptSize = ns.getScriptRam(sScriptName, sRunner);
+  //let nMoney = ns.getServerMoneyAvailable(sTarget);
+  let nHomeServerReserve = Math.min(nMaxRAM / 8, 64);
+
+  if (sRunner !== "home") {
+    nHomeServerReserve = 0;
+  }
+
+/*
+  let nWeakenPower = ns.weakenAnalyze(1, nCores); // default 0.05 (always?)
+  ns.tprint("nWeakenPower = " + nWeakenPower + " with " + nCores + " nCores");
+
+  let nHackSecurity = ns.hackAnalyzeSecurity(1, sTarget); // default 0.002
+  ns.tprint("nHackSecurity = " + nHackSecurity + " on " + sTarget + " sTarget");
+
+  let nGrowSecurity = ns.growthAnalyzeSecurity(1, "", nCores);// default 0.004 (always?)
+  ns.tprint("nGrowSecurity = " + nGrowSecurity + " on " + "_" + " sTarget" + " with " + nCores + " nCores");
+*/
+  while (true) {
+
+    //server stats
+    nCurrentSecurity = ns.getServerSecurityLevel(sTarget);
+    nCurrentMoney = ns.getServerMoneyAvailable(sTarget);
+
+    nBonusWeaken = 0;
+    if (nCurrentSecurity > nMinSecurity + 3) {
+      nBonusWeaken = 4;
+    }
+    nBonusGrow = 0;
+    if (nCurrentMoney <= nMaxMoney * 0.8) {
+      nBonusGrow = 11;
+    }
+
+
+    nGrowThreads = Math.max(1 + nBonusGrow, getGrowThreads(ns, sTarget, nHackThreads));
+    nGrowThreadsINT = Math.ceil(nGrowThreads);
+
+    //25 hacks or 12.5 grows
+    nWeakenThreads = Math.max(1 + nBonusWeaken, (nHackThreads / 25) + (nGrowThreads / 12.5));
+    nWeakenThreadsINT = Math.ceil(nWeakenThreads);
+
+    //timestamp
+    let currentDate = new Date();
+    let nOffset;
+
+    ns.print("Cash: " + (Math.floor(nCurrentMoney * 1000) / 1000) + " / " + nMaxMoney);
+    ns.print("Security: " + (Math.floor(nCurrentSecurity * 1000) / 1000) + " / " + nMinSecurity);
+
+    nMaxRAM = ns.getServerMaxRam(sRunner);
+    nUsedRAM = ns.getServerUsedRam(sRunner);
+    nFreeRam = nMaxRAM - nUsedRAM;
+
+    while (nFreeRam <= (nWeakenScriptRAM * nWeakenThreads) + nHomeServerReserve + 6) {
+      await ns.sleep(100);
+      nMaxRAM = ns.getServerMaxRam(sRunner);
+      nUsedRAM = ns.getServerUsedRam(sRunner);
+      nFreeRam = nMaxRAM - nUsedRAM;
+    }
+
+    if (nFreeRam > (nWeakenScriptRAM * nWeakenThreads) + nHomeServerReserve + 6) {
+      //Calculate estimate time of completion
+      nOffset = ns.getWeakenTime(sTarget);
+      let nWeakTime = new Date(currentDate.getTime() + nOffset);
+      let sWeakTime = nWeakTime.toLocaleTimeString('sw-SV');  //swedish time
+
+      //Print estimated time of completion
+      ns.print("Weakening " + sTarget + " Estimated complete at " + sWeakTime);
+      ns.print("Weakening with " + nWeakenThreadsINT + " threads on " + sTarget);
+      let nWeakenPID = ns.run(sWeakenScript, nWeakenThreadsINT, sTarget);
+      if (nWeakenPID === 0) { ns.print("Weaken Failed..."); }
+    }
+
+    nMaxRAM = ns.getServerMaxRam(sRunner);
+    nUsedRAM = ns.getServerUsedRam(sRunner);
+    nFreeRam = nMaxRAM - nUsedRAM;
+
+    while (nFreeRam <= (nGrowScriptRAM * nGrowThreads) + nHomeServerReserve + 6) {
+      await ns.sleep(100);
+      nMaxRAM = ns.getServerMaxRam(sRunner);
+      nUsedRAM = ns.getServerUsedRam(sRunner);
+      nFreeRam = nMaxRAM - nUsedRAM;
+
+    }
+
+    if (nCurrentSecurity <= (nMinSecurity + 1) && nFreeRam > (nGrowScriptRAM * nGrowThreads) + nHomeServerReserve + 6) {
+
+      //Calculate estimate time of completion
+      nOffset = ns.getGrowTime(sTarget);
+      let nGrowTime = new Date(currentDate.getTime() + nOffset);
+      let sGrowTime = nGrowTime.toLocaleTimeString('sw-SV');  //swedish time
+
+      //Print estimated time of completion
+      ns.print("Growing " + sTarget + " Estimated complete at " + sGrowTime);
+      ns.print("Growing with " + nGrowThreadsINT + " threads on " + sTarget);
+      let nGrowPID = ns.run(sGrowScript, nGrowThreadsINT, sTarget);
+      if (nGrowPID === 0) { ns.print("Grow Failed..."); }
+
+
+      nMaxRAM = ns.getServerMaxRam(sRunner);
+      nUsedRAM = ns.getServerUsedRam(sRunner);
+      nFreeRam = nMaxRAM - nUsedRAM;
+
+      while (nFreeRam <= (nHackScriptRAM * nHackThreads) + nHomeServerReserve + 6) {
+        await ns.sleep(100);
+        nMaxRAM = ns.getServerMaxRam(sRunner);
+        nUsedRAM = ns.getServerUsedRam(sRunner);
+        nFreeRam = nMaxRAM - nUsedRAM;
+
+      }
+
+      if (nCurrentMoney >= nMaxMoney * 0.8 && nFreeRam > (nHackScriptRAM * nHackThreads) + nHomeServerReserve + 6) {
+
+        //Calculate estimate time of completion
+        nOffset = ns.getHackTime(sTarget);
+        let nHackTime = new Date(currentDate.getTime() + nOffset);
+        let sHackTime = nHackTime.toLocaleTimeString('sw-SV');  //swedish time
+
+        //Print estimated time of completion
+        ns.print("Hacking " + sTarget + " Estimated complete at " + sHackTime);
+        ns.print("Hacking with " + nHackThreads + " threads on " + sTarget);
+        let mHackPID = ns.run(sHackScript, nHackThreads, sTarget);
+        if (mHackPID === 0) { ns.print("Hack Failed..."); }
+
+      }
+
+    }
+    await ns.sleep(nFrequency);
+    ns.print("-------------------------------------------------------------------------");
+  }
+
+}