batch.js

import find from './find';
const DEFAULT_STEAL_MAX = 0.75;
/** @param {NS} ns */
export async function main(ns) {
  ns.clearLog();
  ns.disableLog('ALL');
  const serverName = ns.args[1] || 'n00dles';
  const stealMax = ns.args[0] || DEFAULT_STEAL_MAX;
  const res = [];
  find(ns, 'home', res);
  const all = res.map(d => d.name).filter(item => {
    if (ns.getServerRequiredHackingLevel(item) > ns.getHackingLevel()) {
      return false;
    }
    if (ns.getServerMaxRam(item) < 2048) {
      return false;
    }
    return true;
  })

  // const all = ['home'];
  let buffer;
  let i = 0;

  const hacking = ns.formulas.hacking;

  async function getHome() {
    function needwait(home) {
      const maxRam = ns.getServerMaxRam(home);
      const threashHold = 1024 * 4;
      if (ns.getServerUsedRam(home) > maxRam - threashHold) {
        return true;
      }
      return false;
    }

    for (const home of all) {
      if (!needwait(home)) {
        return home;
      }
    }

    await ns.sleep(100);
    return await getHome();
  }

  while (true) {
    const home = await getHome();
    if (home) {
      const cores = ns.getServer(home).cpuCores;
      batch(home, cores);
      if (i > 1e11) {
        i = 0;
      }
    }
  }

  // batch('home', ns.getServer("home").cpuCores);

  function batch(home, cores) {
    const server = ns.getServer(serverName);
    const player = ns.getPlayer();
    const hackTime = hacking.hackTime(server, player);
    const growTime = hacking.growTime(server, player);
    const weakenTime = hacking.weakenTime(server, player);
    const hackingPercent = hacking.hackPercent(server, player) || 1;

    const hackThreads = Math.ceil(stealMax / hackingPercent) || 1
    // const increasedSecurityByHack = ns.hackAnalyzeSecurity(hackThreads, serverName);
    const increasedSecurityByHack = ns.hackAnalyzeSecurity(hackThreads);
    ns.tprint('increasedSecurityByHack: ', hackThreads, '      ', increasedSecurityByHack);
    const weakenThreadsByHack = getWeakenThreads(increasedSecurityByHack, cores);// Math.ceil(increasedSecurityByHack / 0.05) || 1;

    const hackWillGetMoney = ns.hackAnalyze(serverName) * hackThreads * server.moneyMax;
    const growThreads = hacking.growThreads({ ...server, moneyAvailable: Math.floor(server.moneyMax - hackWillGetMoney) }, player, server.moneyMax, cores) || 1;
    // const increasedSecurityByGrow = ns.growthAnalyzeSecurity(growThreads, serverName, cores);
    const increasedSecurityByGrow = ns.growthAnalyzeSecurity(growThreads);
    ns.tprint('increasedSecurityByGrow: ', growThreads, '          ', increasedSecurityByGrow)
    const weakenThreadsByGrow = getWeakenThreads(increasedSecurityByGrow, cores); // Math.ceil(increasedSecurityByGrow / 0.05) || 1;

    buffer = i * 2000;
    let x = 200;
    const hack_offset = weakenTime - hackTime + buffer - x;
    const weaken_hack_offset = buffer;
    const grow_offset = weakenTime - growTime + buffer + x;
    const weaken_grow_offset = buffer + x * 2;

    ns.exec('hackonce.js', home, hackThreads, serverName, hack_offset);
    ns.exec('weakenonce.js', home, weakenThreadsByHack, serverName, weaken_hack_offset);
    ns.exec('growonce.js', home, growThreads, serverName, grow_offset);
    ns.exec('weakenonce.js', home, weakenThreadsByGrow, serverName, weaken_grow_offset);
    i++;
  }

  function getWeakenThreads(targetLevel, cores, attemt = (Math.ceil(targetLevel / 0.05))) {
    if (attemt <= 10 || targetLevel === 0) {
      return attemt || 1;
    }

    const predict = ns.weakenAnalyze(attemt, cores);
    if (predict >= targetLevel) {
      return getWeakenThreads(targetLevel, cores, attemt - 1);
    }

    return attemt + 1;
  }

}