sync corp

Ramses/home/CorpControl.js

@@ -15,6 +15,7 @@ export async function main(ns) {
   let oOfficeData = {};
   let oWarehouseData = {};
   let bUnlockStatus = false;
+  let nTargetSize = 0;
   nListenPID = ns.run("/corp/HasCorp.js");
   await ns.nextPortWrite(nListenPID);
   let bCorpExists = ns.readPort(nListenPID);
@@ -70,7 +71,7 @@ export async function main(ns) {
         oCorpStatus.nStep = 30;
         break;
       case 30:
-        let nTargetSize = 4;
+        nTargetSize = 4;
         for (let sCity of aCitites) {
           nListenPID = ns.run("/corp/GetOfficeData.js", 1, sDivisionName, sCity);
           await ns.nextPortWrite(nListenPID);
@@ -84,7 +85,7 @@ export async function main(ns) {
           nListenPID = ns.run("/corp/GetOfficeData.js", 1, sDivisionName, sCity);
           await ns.nextPortWrite(nListenPID);
           oOfficeData = ns.readPort(nListenPID);
-          nListenPID = ns.run("/corp/HireWorkers.js", 1, sDivisionName, sCity, JSON.stringify(oOfficeData));
+          nListenPID = ns.run("/corp/HireWorkers.js", 1, sDivisionName, sCity, JSON.stringify(oOfficeData), JSON.stringify({nWorkerNumbers: [1, 1, 1, 1, 0, 0]}));
           await ns.nextPortWrite(nListenPID);
         }
         oCorpStatus.nStep = 50;
@@ -103,11 +104,27 @@ export async function main(ns) {
             ns.tprint(sCity, entry)
           })
         }
-        oCorpStatus.nStep = 200;
+        oCorpStatus.nStep = 60;
         break;
       case 60:
+        nTargetSize = 12;
+        for (let sCity of aCitites) {
+          nListenPID = ns.run("/corp/GetOfficeData.js", 1, sDivisionName, sCity);
+          await ns.nextPortWrite(nListenPID);
+          oOfficeData = ns.readPort(nListenPID);
+          await ns.nextPortWrite(ns.run("/corp/UpgradeOffice.js", 1, sDivisionName, sCity, nTargetSize, oOfficeData.size))
+        }
+        oCorpStatus.nStep = 70;
         break;
       case 70:
+        for (let sCity of aCitites) {
+          nListenPID = ns.run("/corp/GetOfficeData.js", 1, sDivisionName, sCity);
+          await ns.nextPortWrite(nListenPID);
+          oOfficeData = ns.readPort(nListenPID);
+          nListenPID = ns.run("/corp/HireWorkers.js", 1, sDivisionName, sCity, JSON.stringify(oOfficeData), JSON.stringify({nWorkerNumbers: [2, 2, 2, 2, 2, 2]}));
+          await ns.nextPortWrite(nListenPID);
+        }
+        oCorpStatus.nStep = 200;
         break;
       case 80:
         break;

Ramses/home/CorpStatus.txt

@@ -1 +1 @@
-{"nStep":200}
+{"nStep":70}

Ramses/home/Library.js

@@ -88,7 +88,7 @@ export function findBestTarget(ns, maxSec, maxPorts, currentHackLevel, manualTar
     bestEntry = null;
     let nMaxMoneyPerChance = 0;
     let nBestMoneyPerChance = 0;
-    serverList.forEach((entry)=> {
+    serverList.forEach((entry) => {
       if (entry.minSec <= maxSec && entry.minPorts <= maxPorts && entry.minHackLvl <= currentHackLevel) {
         nMaxMoneyPerChance = (entry.maxMoney * ns.hackAnalyzeChance(entry.serverName)) / entry.minSec;
         if (nMaxMoneyPerChance > nBestMoneyPerChance) {
@@ -203,12 +203,12 @@ export async function purchaseAndUpgradeServers(ns) {
     purchasedServers = listPurchasedServers(ns);
     for (let currentServer of purchasedServers) {
       currentMoney = ns.getServerMoneyAvailable("home");
-      if (ns.getServerMaxRam(currentServer) < targetRam){
+      if (ns.getServerMaxRam(currentServer) < targetRam) {
         if (ns.getPurchasedServerUpgradeCost(currentServer, targetRam) < currentMoney) {
           if (ns.upgradePurchasedServer(currentServer, targetRam)) {
             ns.print(currentServer + " upgraded to " + targetRam + " GB RAM");
             serverList = JSON.parse(ns.read("serverList.txt"));
-          let newServerList = serverList.map((entry) => { if (entry.serverName === currentServer){ entry.maxRam = targetRam} return entry});
+            let newServerList = serverList.map((entry) => { if (entry.serverName === currentServer) { entry.maxRam = targetRam } return entry });
             ns.write("serverList.txt", JSON.stringify(newServerList), "w");
             ns.tprint(cCyan + "Server: " + currentServer + " upgraded to: " + targetRam.toLocaleString() + " GB" + cReset);
             ns.toast("Server: " + currentServer + " upgraded to: " + targetRam.toLocaleString() + " GB", "info", 10000);
@@ -216,7 +216,8 @@ export async function purchaseAndUpgradeServers(ns) {
         } else {
           await ns.sleep(5000);
           continue
-      }};
+        }
+      };
     }
     ++i;
   }
@@ -278,8 +279,8 @@ export function listWorkServers(ns) {
     if (entry.rootAccess && entry.maxRam >= 1) {
       let sServerName = entry.serverName.padEnd(nServerColumnWidth, ' ');
       let nFreeRAM = entry.maxRam - ns.getServerUsedRam(entry.serverName);
-      let sFreeRAM = Math.floor(nFreeRAM).toLocaleString("en-US").padStart(nValueColumnWidth, ' ');
-      let sMaxRam = entry.maxRam.toLocaleString("en-US").padStart(nValueColumnWidth, ' ');
+      let sFreeRAM = ns.formatRam(nFreeRAM).padStart(nValueColumnWidth, ' ');
+      let sMaxRam = ns.formatRam(entry.maxRam).padStart(nValueColumnWidth, ' ');
       let sCores = entry.serverCores.toLocaleString("en-US").padStart(nCoresWidth, ' ');
       ns.printRaw(`┃ ${sServerName} ┃ ${sFreeRAM} / ${sMaxRam} ┃ ${sCores} ┃`);
       nTotalWorkerRAM += entry.maxRam;
@@ -291,6 +292,10 @@ export function listWorkServers(ns) {
 }
 
 export function sortJsonArrayByKey(array, primaryKey, secondaryKey) {
+
+  if (typeof (array) === "string") {
+    array = JSON.parse(array);
+  }
   return array.sort((a, b) => {
     const xPrimary = a[primaryKey];
     const yPrimary = b[primaryKey];
@@ -328,3 +333,43 @@ export function sortJsonArrayByKey(array, primaryKey, secondaryKey) {
   }
 }
 
+
+/** @param {NS} ns */
+export async function distributeScript(ns, sScript, nThreads, ...args) {
+  ns.tail();
+  ns.disableLog("ALL");
+
+  const sListName = "serverList.txt";
+
+  if (!ns.fileExists(sListName, "home")) { ns.print(`ERROR ${sListName} does not exist.`); return false; };
+  let sServerList = ns.read(sListName);
+  let aSortedList = sortJsonArrayByKey(sServerList, "serverCores", "maxRam").reverse();
+  ns.print(sScript);
+  ns.print(nThreads);
+  ns.print(...args);
+
+  const nScriptSize = ns.getScriptRam(sScript, "home");
+  let nTotalSize = nScriptSize * nThreads;
+
+  ns.print("nScriptSize = " + nScriptSize);
+  ns.print("nTotalSize = " + nTotalSize);
+
+  aSortedList.forEach((entry) => {
+    let sHost = entry.serverName;
+    ns.print("sHost = " + sHost)
+    ns.scp(sScript, sHost);
+    let nFreeRAM = ns.getServerMaxRam(entry.serverName) - ns.getServerUsedRam(entry.serverName);
+    if (nThreads >= 1 && entry.rootAccess && nFreeRAM >= nTotalSize) {
+      ns.exec(sScript, sHost, nThreads, ...args);
+      nThreads = 0;
+      nFreeRAM = ns.getServerMaxRam(entry.serverName) - ns.getServerUsedRam(entry.serverName);
+    }
+    else if (nThreads >= 1 && entry.rootAccess && nFreeRAM >= nScriptSize) {
+      let nThreadsDist = Math.floor(nFreeRAM / nScriptSize);
+      ns.print("room for : " + nThreadsDist + " scripts");
+      ns.exec(sScript, sHost, nThreadsDist, ...args);
+      nThreads -= nThreadsDist;
+      nFreeRAM = ns.getServerMaxRam(entry.serverName) - ns.getServerUsedRam(entry.serverName);
+    }
+  });
+}

Ramses/home/corp/CreateCorp.js

@@ -1,7 +1,6 @@
 /** @param {NS} ns */
 export async function main(ns) {
     let [sCorpName] = ns.args;
-      ns.corporation.createCorporation(sCorpName,false)
-    ns.writePort(ns.pid, true);
+    ns.writePort(ns.pid, ns.corporation.createCorporation(sCorpName,false));
   }
   

Ramses/home/corp/GetCorpData.js

@@ -1,4 +1,4 @@
 /** @param {NS} ns */
 export async function main(ns) {
-   ns.writePort(ns.pid,ns.corporation.getCorporation())
+   ns.writePort(ns.pid,ns.corporation.getCorporation());
 }

Ramses/home/corp/GetOfficeData.js

@@ -2,4 +2,6 @@
 export async function main(ns) {
   let [sDivName, sCity] = ns.args;
   ns.writePort(ns.pid, ns.corporation.getOffice(sDivName, sCity))
+  
+  ns.tprint(ns.corporation.getOffice(sDivName, sCity))
 }

Ramses/home/corp/HireWorkers.js

@@ -1,12 +1,23 @@
 /** @param {NS} ns */
 export async function main(ns) {
-  let [sDivName, sCity, oCurrentOffice] = ns.args;
-  oCurrentOffice = JSON.parse(oCurrentOffice)
-  if (oCurrentOffice.numEmployees < oCurrentOffice.size) {
-    (oCurrentOffice.employeeJobs.Operations < 1) ? ns.corporation.hireEmployee(sDivName, sCity, "Operations") : "";
-    (oCurrentOffice.employeeJobs.Engineer < 1) ? ns.corporation.hireEmployee(sDivName, sCity, "Engineer") : "";
-    (oCurrentOffice.employeeJobs.Business < 1) ? ns.corporation.hireEmployee(sDivName, sCity, "Business") : "";
-    (oCurrentOffice.employeeJobs.Management < 1) ? ns.corporation.hireEmployee(sDivName, sCity, "Management") : "";
+  let [sDivName, sCity, oCurrentOffice, oWorkerDistribution] = ns.args;
+  oCurrentOffice = JSON.parse(oCurrentOffice);
+  let aWorkerDistribution = JSON.parse(oWorkerDistribution).nWorkerNumbers;
+  ns.tprint(aWorkerDistribution);
+  let nTotalWorkers = 0;
+  const len = aWorkerDistribution.length;
+  for (let i = 0; i < len; i++) nTotalWorkers += aWorkerDistribution[i];
+  ns.tprint(typeof(oCurrentOffice.employeeJobs["Research & Development"]))
+  
+  while (oCurrentOffice.numEmployees < oCurrentOffice.size && oCurrentOffice.numEmployees < nTotalWorkers) {
+    (oCurrentOffice.employeeJobs.Operations < aWorkerDistribution[0]) ? ns.corporation.hireEmployee(sDivName, sCity, "Operations") : "";
+    (oCurrentOffice.employeeJobs.Engineer < aWorkerDistribution[1]) ? ns.corporation.hireEmployee(sDivName, sCity, "Engineer") : "";
+    (oCurrentOffice.employeeJobs.Business < aWorkerDistribution[2]) ? ns.corporation.hireEmployee(sDivName, sCity, "Business") : "";
+    (oCurrentOffice.employeeJobs.Management < aWorkerDistribution[3]) ? ns.corporation.hireEmployee(sDivName, sCity, "Management") : "";
+    ns.tprint("before")
+    (oCurrentOffice.employeeJobs.Research & Development < aWorkerDistribution[4]) ? ns.corporation.hireEmployee(sDivName, sCity, "Research & Development") : "";
+    ns.tprint("after")
+    (oCurrentOffice.employeeJobs.Intern < aWorkerDistribution[5]) ? ns.corporation.hireEmployee(sDivName, sCity, "Intern") : "";
   };
   ns.writePort(ns.pid, true);
 }

Ramses/home/lowram/Lowgrow.js

@@ -0,0 +1,62 @@
+/** @param {NS} ns */
+export async function main(ns) {
+    ns.tail();
+    const sTarget = ns.args[0]; // target server
+
+    // Lowram settings
+    const sBatchScript = "lowram/Lowhgw.js";
+    const sPrepScript = "lowram/Lowprep.js";
+    const sRunScript = "lowram/Lowrun.js";
+    const sLowGrowScript = "lowram/Lowgrow.js";
+    const sDistScript = "testdistribute.js";
+
+    const sGrowScript = "RMgrow.js";
+
+    const nThisScriptRAM = ns.getScriptRam(sLowGrowScript, "home");
+
+
+    let nMoney = ns.getServerMoneyAvailable(sTarget);
+    const nMaxMoney = ns.getServerMaxMoney(sTarget);
+
+
+    const startValue = nMoney; // First argument: starting value
+    const target = nMaxMoney; // Second argument: target value
+    let result = startValue; // Initialize result with the starting value
+    let n = 1;
+    // For loop that continues until the result exceeds or matches the target
+    for (; result < target; n++) {
+        result += 1; // Add 1 before multiplication
+        result *= n; // Multiply by the current step value
+    }
+    let nGrowThreadsNeeded = n * ns.growthAnalyze(sTarget, n, 1);
+    //ns.print("nGrowThreadsNeeded = " + nGrowThreadsNeeded);
+
+    //while (nMoney < nMaxMoney) {
+
+    let nFreeRam = ns.getServerMaxRam("home") - ns.getServerUsedRam("home");
+    //ns.print("nFreeRam = " + nFreeRam);
+    //ns.print("needed ram = " + Math.ceil(nFreeRam / ns.getScriptRam(sGrowScript, "home")));
+    //ns.print("needed ram? = " + ns.getScriptRam(sGrowScript, "home"));
+    if (nFreeRam >= (ns.getScriptRam(sGrowScript, "home") * nGrowThreadsNeeded)) {
+
+
+        let nGrowPID = ns.run(sGrowScript, Math.ceil(nGrowThreadsNeeded), sTarget);
+        await ns.nextPortWrite(nGrowPID);
+        await ns.sleep(1000);
+        nMoney = ns.getServerMoneyAvailable(sTarget);
+    }
+    else {
+        ns.print("Too smol");
+        let nGrowPID = ns.run(sGrowScript, Math.ceil((nFreeRam - nThisScriptRAM) / ns.getScriptRam(sGrowScript, "home")), sTarget);
+        await ns.nextPortWrite(nGrowPID);
+        await ns.sleep(1000);
+        nMoney = ns.getServerMoneyAvailable(sTarget);
+
+    }
+
+
+    //back to Lowrun
+    ns.spawn(sRunScript, { threads: 1, spawnDelay: 0 }, sTarget);
+
+
+}

Ramses/home/lowram/Lowhgw.js

@@ -0,0 +1,120 @@
+import { getGrowThreads, getSetting } from "Library.js";
+
+/** @param {NS} ns */
+export async function main(ns) {
+  ns.tail();
+  const sTarget = ns.args[0]; // target server
+  const sHackScript = "RMhack.js";
+  const sGrowScript = "RMgrow.js";
+  const sWeakenScript = "RMweaken.js";
+  const sServerListFile = "serverList.txt";
+  const sDistScript = "testdistribute.js";
+
+  const nHackScriptRAM = 1.75;
+  const nGrowScriptRAM = 1.7;
+  const nWeakenScriptRAM = 1.75;
+  const nThisScriptRAM = 4.70;
+
+  await ns.sleep(1);
+
+  while (true) {
+    let nMaxRAM = ns.getServerMaxRam("home");
+    let oServerlist = JSON.parse(ns.read(sServerListFile));
+
+    //let nMaxRAM = oServerlist[1].nMaxRAM;
+    ns.tprint("nMaxRAM = " + nMaxRAM);
+    //let nMaxRAM = [name, entry] of Object.entries(oServerlist);
+    //let nMaxRAM = oServerlist["home"].maxRam;
+    //ns.print("nMaxRAM = " + nMaxRAM);
+
+    let nWeakenTime = ns.getWeakenTime(sTarget);
+    let nGrowTime = nWeakenTime * 0.8;
+    let nHackTime = nWeakenTime / 4;
+
+    let nGrowDelay = nWeakenTime - nGrowTime;
+    let nHackDelay = nWeakenTime - nHackTime;
+
+    let nUsedRAM = nThisScriptRAM;
+
+    let nHackThreads;
+    let nGrowThreads;
+    let nGrowThreadsINT;
+    let nWeakenThreads;
+    let nWeakenThreadsINT;
+    let nCheckRAM;
+    let nTotalHackRAM;
+    let nTotalGrowRAM;
+    let nTotalWeakenRAM;
+    let nTempHackThreads;
+    let nTempGrowThreads;
+    let nTempGrowThreadsINT;
+    let nTempWeakenThreads;
+    let nTempWeakenThreadsINT;
+
+    for (let i = 1; nUsedRAM < nMaxRAM; i++) {
+
+      nTempHackThreads = i;
+      //ns.print("nTempHackThreads = " + nTempHackThreads);
+
+      nTempGrowThreads = Math.max(2, getGrowThreads(ns, sTarget, nTempHackThreads));
+      nTempGrowThreadsINT = Math.ceil(nTempGrowThreads);
+      //ns.print("nTempGrowThreads = " + nTempGrowThreads);
+      //ns.print("nTempGrowThreadsINT = " + nTempGrowThreadsINT);
+
+      //25 hacks or 12.5 grows
+      nTempWeakenThreads = Math.max(2, (nTempHackThreads / 25) + (nTempGrowThreadsINT / 12.5));
+      nTempWeakenThreadsINT = Math.ceil(nTempWeakenThreads);
+      //ns.print("nTempWeakenThreads = " + nTempWeakenThreads);
+      //ns.print("nTempWeakenThreadsINT = " + nTempWeakenThreadsINT);
+
+      nTotalHackRAM = (nTempHackThreads * nHackScriptRAM);
+      nTotalGrowRAM = (nTempGrowThreadsINT * nGrowScriptRAM);
+      nTotalWeakenRAM = (nTempWeakenThreadsINT * nWeakenScriptRAM);
+      //ns.print("nTotalHackRAM = " + nTotalHackRAM);
+      //ns.print("nTotalGrowRAM = " + nTotalGrowRAM);
+      //ns.print("nTotalWeakenRAM = " + nTotalWeakenRAM);
+
+
+
+      nCheckRAM = nThisScriptRAM + (nTempHackThreads * nHackScriptRAM) + (nTempGrowThreadsINT * nGrowScriptRAM) + (nTempWeakenThreadsINT * nWeakenScriptRAM);
+      //ns.print("nCheckRAM = " + nCheckRAM);
+
+      if (nCheckRAM < nMaxRAM) {
+        nUsedRAM = nCheckRAM;
+        nHackThreads = nTempHackThreads;
+        nGrowThreads = nTempGrowThreads;
+        nGrowThreadsINT = nTempGrowThreadsINT;
+        nWeakenThreads = nTempWeakenThreads;
+        nWeakenThreadsINT = nTempWeakenThreadsINT;
+      }
+      else {
+        break;
+      }
+      //ns.print("nMaxRAM = " + nMaxRAM + " nUsedRAM = " + nUsedRAM);
+    }
+    //ns.print("nMaxRAM = " + nMaxRAM + " nUsedRAM = " + nUsedRAM);
+
+
+    let nHackPID = ns.run(sHackScript, nHackThreads, sTarget, false, nHackDelay - 100);
+    let nGrowPID = ns.run(sGrowScript, nGrowThreadsINT, sTarget, false, nGrowDelay - 50);
+    let nWeakenPID = ns.run(sWeakenScript, nWeakenThreadsINT, sTarget, false, 0);
+    //ns.tail(nHackPID, "home", nHackThreads, sTarget, false, nHackDelay - 100);
+    //ns.tail(nGrowPID, "home", nGrowThreadsINT, sTarget, false, nGrowDelay - 50);
+    //ns.tail(nWeakenPID, "home", nWeakenThreadsINT, sTarget, false, 0);
+
+    await Promise.all([
+      ns.nextPortWrite(nHackPID),
+      ns.nextPortWrite(nGrowPID),
+      ns.nextPortWrite(nWeakenPID)
+    ])
+    await ns.sleep(1);
+
+    let nHackFinnish = ns.readPort(nHackPID);
+    let nGrowFinnish = ns.readPort(nGrowPID);
+    let nWeakenFinnish = ns.readPort(nWeakenPID);
+
+    ns.print("nHackFinnish = " + nHackFinnish);
+    ns.print("nGrowFinnish = " + nGrowFinnish);
+    ns.print("nWeakenFinnish = " + nWeakenFinnish);
+  }
+}

Ramses/home/lowram/Lowprep.js

@@ -0,0 +1,66 @@
+/** @param {NS} ns */
+export async function main(ns) {
+    ns.tail();
+    const sTarget = ns.args[0]; // target server
+
+    // declare objects
+    const oHome = ns.getServer("home");
+    //const oTarget = ns.getServer(sTarget);
+
+    // Lowram settings
+    const sBatchScript = "lowram/Lowhgw.js";
+    const sPrepScript = "lowram/Lowprep.js";
+    const sRunScript = "lowram/Lowrun.js";
+    const sGrowScript = "lowram/Lowgrow.js";
+    const sDistScript = "testdistribute.js";
+
+    //declare variables
+    const sWeakenScript = "RMweaken.js";
+    const nCores = oHome.cpuCores;
+    let nSecurity = ns.getServerSecurityLevel(sTarget);
+    const nMinSecurity = ns.getServerMinSecurityLevel(sTarget);
+    const nWeakenSTR = ns.weakenAnalyze(1, nCores);
+    let nThreads = Math.ceil((nSecurity - nMinSecurity) / nWeakenSTR);
+    //ns.print("nThreads = " + nThreads);
+
+
+    ns.tail(ns.pid, oHome.hostname, sTarget);
+    //ns.resizeTail(815, 395);
+    //ns.moveTail(1925, 0);
+
+    let nWeakenPID;
+
+    if (nThreads > 0) {
+        const nDelay = ns.getWeakenTime(sTarget);
+
+        ns.print("current security is: " + nSecurity);
+        ns.print("minimum security is: " + nMinSecurity);
+        ns.print("threads needed for weaken: " + nThreads);
+        ns.print(nThreads + " will reduce Security by " + ns.weakenAnalyze(nThreads, nCores));
+        ns.print(nThreads + " of " + sWeakenScript + " requires " + (ns.getScriptRam(sWeakenScript, "home") * nThreads) + " GB of RAM");
+        ns.print("weakening will take " + (nDelay / 1000 / 60) + " minutes");
+
+        ns.run(sDistScript, 1, sWeakenScript, nThreads, sTarget, false, 0);
+        await ns.sleep(nDelay+10);
+        /*
+        if ((ns.getServerMaxRam(oHome.hostname) - ns.getServerUsedRam(oHome.hostname)) >= (ns.getScriptRam(sWeakenScript, "home") * nThreads)) {
+            nWeakenPID = ns.exec(sWeakenScript, nThreads, sTarget);
+            //ns.print("Waiting for PID = " + nWeakenPID);
+            await ns.nextPortWrite(nWeakenPID);
+            nSecurity = ns.getServerSecurityLevel(sTarget);
+            //ns.print("Breach complete, security level is now at: " + nSecurity);
+        }
+        else {
+            nThreads = Math.floor(((ns.getServerMaxRam("home") - ns.getServerUsedRam("home")) / ns.getScriptRam(sWeakenScript)));
+            nWeakenPID = ns.exec(sWeakenScript, nThreads, sTarget);
+            //ns.print("Waiting for PID = " + nWeakenPID);
+            await ns.nextPortWrite(nWeakenPID);
+            nSecurity = ns.getServerSecurityLevel(sTarget);
+            //ns.print("Breach in progress, security level is now at: " + nSecurity);
+        }
+
+        */
+    }
+    //back to Lowrun
+    ns.spawn(sRunScript, { threads: 1, spawnDelay: 0 }, sTarget);
+}

Ramses/home/lowram/Lowrun.js

@@ -0,0 +1,33 @@
+/** @param {NS} ns */
+export async function main(ns) {
+    ns.tail();
+    const sTarget = ns.args[0]; // target server
+
+    // Lowram settings
+    const sBatchScript = "lowram/Lowhgw.js";
+    const sPrepScript = "lowram/Lowprep.js";
+    const sRunScript = "lowram/Lowrun.js";
+    const sGrowScript = "lowram/Lowgrow.js";
+    const sDistScript = "testdistribute.js";
+
+    await ns.sleep(1);
+    
+    const nTargetMoney = ns.getServerMoneyAvailable(sTarget);
+    const nTargetMaxMoney = ns.getServerMaxMoney(sTarget);
+    const nTargetSecurity = ns.getServerSecurityLevel(sTarget);
+    const nTargetMinSecurity = ns.getServerMinSecurityLevel(sTarget);
+
+    //ns.print(sTarget + " Money    = " + nTargetMoney.toLocaleString() + " / " + nTargetMaxMoney.toLocaleString());
+    //ns.print(sTarget + " Security = " + nTargetSecurity.toLocaleString() + " / " + nTargetMinSecurity.toLocaleString());
+
+    if (nTargetSecurity > nTargetMinSecurity + 1) {
+        ns.spawn(sPrepScript, { threads: 1, spawnDelay: 0 }, sTarget);
+    }
+    /*else if (nTargetMoney < nTargetMaxMoney) {
+        //ns.print("need to prep MONEY, running " + sGrowScript);
+        ns.spawn(sGrowScript, { threads: 1, spawnDelay: 0 }, sTarget);
+    }*/
+    else {
+        ns.spawn(sBatchScript, { threads: 1, spawnDelay: 0 }, sTarget);
+    }
+}

Ramses/home/testdistribute.js

@@ -0,0 +1,76 @@
+import { sortJsonArrayByKey } from "Library.js";
+
+/** @param {NS} ns */
+export async function main(ns) {
+    ns.tail();
+    ns.disableLog("ALL");
+    const sScript = ns.args[0]; // script
+    let nThreads = ns.args[1]; // threads
+    const sTarget = ns.args[2]; // target server
+    const bRepeat = ns.args[3]; // should this script loop
+    const nMsecDelay = ns.args[4]; // MsecDelay
+
+    const sWeakenScript = "RMweaken.js";
+    const sGrowScript = "RMgrow.js";
+    const sHackScript = "RMhack.js";
+
+    const sListName = "serverList.txt";
+    const sWorkerList = "WorkerList.txt";
+
+    if (!ns.fileExists(sListName, "home")) { ns.print(`ERROR ${sListName} does not exist.`); return false; };
+    let sServerList = ns.read(sListName);
+    let aSortedList = sortJsonArrayByKey(sServerList, "serverCores", "maxRam").reverse();
+    //ns.tprint(aSortedList);
+    ns.print(sScript);
+    ns.print(nThreads);
+    ns.print(sTarget);
+
+    const nScriptSize = ns.getScriptRam(sScript, "home");
+    let nTotalSize = nScriptSize * nThreads;
+
+    ns.print("nScriptSize = " + nScriptSize);
+    ns.print("nTotalSize = " + nTotalSize);
+
+    // get sorted list of most cores servers
+    /*
+    aSortedList.forEach((entry) => {
+        if (entry.rootAccess && entry.maxRam >= 1 && entry.serverCores > 1) {
+            // if cores equal to previous entry put into same array?
+        }
+    }) */
+    // get total free RAM per number of cores
+    // calculate effect of cores on each server with cores > 1
+    // update nThreads
+    // run weaken/grow on core servers until cores = 1
+
+    // get sorted list of biggest RAM servers
+    // get total free RAM on core 1 servers
+    // run remaining weaken/grow
+    // run hack untill RAM on cores 1 servers run out
+    // run remaining hacks on smallest to biggest core servers
+
+    aSortedList.forEach((entry) => {
+        let sHost = entry.serverName;
+        ns.print("sHost = " + sHost)
+        ns.scp(sScript, sHost);
+        let nFreeRAM = ns.getServerMaxRam(entry.serverName) - ns.getServerUsedRam(entry.serverName);
+        if (nThreads >= 1 && entry.rootAccess && nFreeRAM >= nTotalSize) {
+            ns.exec(sScript, sHost, nThreads, sTarget, bRepeat, nMsecDelay);
+            nThreads = 0;
+            nFreeRAM = ns.getServerMaxRam(entry.serverName) - ns.getServerUsedRam(entry.serverName);
+        }
+        else if (nThreads >= 1 && entry.rootAccess && nFreeRAM >= nScriptSize){
+            let nThreadsDist = Math.floor(nFreeRAM / nScriptSize);
+            ns.print("room for : " + nThreadsDist + " scripts");
+            ns.exec(sScript, sHost, nThreadsDist, sTarget, bRepeat, nMsecDelay);
+            nThreads -= nThreadsDist;
+            nFreeRAM = ns.getServerMaxRam(entry.serverName) - ns.getServerUsedRam(entry.serverName);
+        }
+    });
+
+    /*
+    for (i = 0; ; i++) {
+        let sHost = "";
+        ns.exec(sScript, sHost, nThreads, sTarget, bRepeat, nMsecDelay);
+    } */
+}