A_Bitburner_Saga/Mizzajl/home/wip/RMcontroller.js

/** @param {NS} ns */
export async function main(ns) {
  //Arguments
  const sTarget = ns.args[0]; // target server

  ns.tail("RMcontroller.js", "home", sTarget);

  //Settings
  const oHome = ns.getServer("home");
  const nCores = oHome.cpuCores;
  const sScript = ns.getScriptName();
  const sWeaken = "RMweaken.js";
  const sGrow = "RMgrow.js";
  const sHack = "RMhack.js";
  const nScriptRAM = ns.getScriptRam(sScript, "home");
  const nWeakenRAM = ns.getScriptRam(sWeaken, "home");
  const nGrowRAM = ns.getScriptRam(sGrow, "home");
  const nHackRAM = ns.getScriptRam(sHack, "home");
  const nHomeUsedRAM = ns.getServerUsedRam("home");
  const nHomeMaxRAM = ns.getServerMaxRam("home");
  let nHomeFreeRAM = nHomeMaxRAM - nHomeUsedRAM;

  const nDelays = [0, 100, 200, 300];


  //abort script if sTarget is undefined
  if (sTarget === undefined) {
    ns.tprint("1st arg sTarget is undefined");
    return false;
  }

  //target server info
  const nMinSecurity = ns.getServerMinSecurityLevel(sTarget);
  const nMaxMoney = ns.getServerMaxMoney(sTarget);

  let nWeakenTime1 = ns.getWeakenTime(sTarget);
  let nWeakenTime2 = nWeakenTime1 + nDelays[3];
  let nGrowTime = nWeakenTime1 * 0.8;
  let nHackTime = nWeakenTime1 / 4;

  //let nHackSecurityGain = ns.hackAnalyzeSecurity(1, sTarget);
  //let nHackSecurityGain = 0.002;
  //let nHackThreadsEstimate = Math.max(Math.floor(1 / nHackSecurityGain),1);
  //let nHackThreadsEstimate = 10;
  //ns.tprint("nHackSecurityGain = " + nHackSecurityGain);
  //ns.tprint("nHackThreadsEstimate = " + nHackThreadsEstimate);
  const nHackTotalRAM = nHackRAM * 25;

  //let nGrowSecurityGain = ns.growthAnalyzeSecurity(1, sTarget, nCores);
  //let nGrowSecurityGain = 0.004;
  //let nGrowThreadsEstimate = Math.max(Math.floor(1 / nGrowSecurityGain),1);
  //ns.tprint("nGrowSecurityGain = " + nGrowSecurityGain);
  //ns.tprint("nGrowThreadsEstimate = " + nGrowThreadsEstimate);
  const nGrowTotalRAM = nGrowRAM * 12.5;

  //let nWeakenSecurity = ns.weakenAnalyze(1, nCores);
  //let nWeakenSecurity = 0.05;
  //let nWeakenThreadsEstimate = Math.max(Math.ceil(1 / nWeakenSecurity),1);
  //ns.tprint("nWeakenSecurity = " + nWeakenSecurity);
  //ns.tprint("nWeakenThreadsEstimate = " + nWeakenThreadsEstimate);
  const nWeakenTotalRAM = nWeakenRAM * 1;

  const nTotalRAM = nHackTotalRAM + nGrowTotalRAM + (nWeakenTotalRAM * 2)
  const nTotalBatches = Math.floor((nHomeFreeRAM - nScriptRAM) / nTotalRAM);

  let nHackThreadsEstimate = nTotalBatches * 25;
  let nWeakenThreadsEstimate1 = nTotalBatches * 1;
  let nGrowThreadsEstimate = nTotalBatches * 12.5;
  let nWeakenThreadsEstimate2 = nTotalBatches * 1;

  ns.tprint("RAM per Cycle = " + nTotalRAM);
  ns.tprint("how many batches can i run at the same time? = " + nTotalBatches);

  //await ns.grow(server, { additionalMsec: nMsecDelay });
  let nGrowDelay = nWeakenTime1 - nGrowTime;
  let nHackDelay = nWeakenTime1 - nHackTime;


  const nCycleDuration = nWeakenTime2 + nDelays[3];
  ns.tprint("nCycleDuration = " + nCycleDuration);

  const nBatchFrequency = Math.ceil(nCycleDuration / nTotalBatches);
  ns.tprint("nBatchFrequency = " + nBatchFrequency);

  while (true) {

    //server stats
    let nCurrentSecurity = ns.getServerSecurityLevel(sTarget);
    let nCurrentMoney = ns.getServerMoneyAvailable(sTarget);

    //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);

    //Calculate estimate time of completion
    nOffset = ns.getWeakenTime(sTarget);
    let nSafeTime = nOffset + nDelays[3] + 1000;
    let nWeakTime = new Date(currentDate.getTime() + nSafeTime);
    let sWeakTime = nWeakTime.toLocaleTimeString('sw-SV');  //swedish time

    //Print estimated time of completion
    ns.print("Weakening " + sTarget + " Estimated complete at " + sWeakTime);

    //hack
    const nHackPID = ns.exec(sHack, "home", nHackThreadsEstimate, sTarget, false, nHackDelay + nDelays[0]);
    //ns.tail(nHackPID, "home", "home", nHackThreadsEstimate, sTarget, 0, nHackDelay + nDelays[0]);

    //weaken 1
    const nWeakenPID1 = ns.exec(sWeaken, "home", nWeakenThreadsEstimate1, sTarget, false, nDelays[1]);
    //ns.tail(nWeakenPID, "home", "home", nWeakenThreadsEstimate, sTarget, 0, nDelays[1]);

    //grow
    const nGrowPID = ns.exec(sGrow, "home", nGrowThreadsEstimate, sTarget, false, nGrowDelay + nDelays[2]);
    //ns.tail(nGrowPID, "home", "home", nGrowThreadsEstimate, sTarget, 0, nGrowDelay + nDelays[2]);

    //weaken 2
    const nWeakenPID2 = ns.exec(sWeaken, "home", nWeakenThreadsEstimate2, sTarget, false, nDelays[3]);
    //ns.tail(nWeakenPID2, "home", "home", nWeakenThreadsEstimate, sTarget, 0, nDelays[3]);

    //await ns.sleep(nSafeTime);

    /*
        await ns.nextPortWrite(nHackPID);
        await ns.nextPortWrite(nWeakenPID1);
        await ns.nextPortWrite(nGrowPID);
        await ns.nextPortWrite(nWeakenPID2);
    
        ns.print("nHackPeek = " + nHackPeek);
        ns.print("nWeaken1Peek = " + nWeaken1Peek);   
        ns.print("nGrowPeek = " + nGrowPeek);
        ns.print("nWeaken2Peek = " + nWeaken2Peek);
    */


    let nHackPeek = ns.peek(nHackPID);
    let nWeaken1Peek = ns.peek(nWeakenPID1);
    let nGrowPeek = ns.peek(nGrowPID);
    let nWeaken2Peek = ns.peek(nWeakenPID2);


    if (nHackPeek === true || nWeaken1Peek === true || nGrowPeek === true || nWeaken2Peek === true) {
      ns.print("some of the ports are already written to...");
      ns.print("nHackPeek = " + nHackPeek);
      ns.print("nWeaken1Peek = " + nWeaken1Peek);
      ns.print("nGrowPeek = " + nGrowPeek);
      ns.print("nWeaken2Peek = " + nWeaken2Peek);
    }

    await Promise.all([
      ns.nextPortWrite(nHackPID),
      ns.nextPortWrite(nWeakenPID1),
      ns.nextPortWrite(nGrowPID),
      ns.nextPortWrite(nWeakenPID2)
    ])


    ns.print("hack:    " + nHackPID + " completed at " + ns.readPort(nHackPID));
    ns.print("weaken1: " + nWeakenPID1 + " completed at " + ns.readPort(nWeakenPID1));
    ns.print("grow:    " + nGrowPID + " completed at " + ns.readPort(nGrowPID));
    ns.print("weaken2: " + nWeakenPID2 + " completed at " + ns.readPort(nWeakenPID2));
    await ns.sleep(100);
  }
}