sleepy time update

Mizzajl/home/GPTGang.js

@@ -0,0 +1,172 @@
+const TASK_TRAIN = "Train Combat";
+const TASK_VIGI = "Vigilante Justice";
+const TASK_NOOB = String.fromCharCode(77) + "ug People";
+const TASK_RESPECT = String.fromCharCode(84) + "errorism";
+const TASK_MONEY = "Human " + String.fromCharCode(84) + "rafficking";
+const TASK_WARFARE = "Territory Warfare";
+const TASK_NULL = "Unassigned";
+const TASK_MANUAL = "Manual/NotReallyTaskName";
+
+const ASCEND_ON_MPL = 10;
+const EQUIP_AFFORD_COEFF = 100;
+
+const STATS_TRESHOLD = 0.7;
+const STATS_MIN = 4000;
+const STATS_HARD_MIN = 200;
+const TRAIN_CHANCE = 0.2;
+const RESPECT_MIN = 2e+6;
+
+const WANTED_PENALTY_TRESHOLD = 0.99;
+const WARFARE_TRESHOLD = 2;
+
+const MEMBERS_MIN = 6;
+const MEMBERS_MAX = 12;
+
+const SLEEP_TIME = 10000;
+
+/** @param {NS} ns **/
+export async function main(ns) {
+  ns.tail();
+  const gang = ns.gang;
+  // Get weighted stats sum (at this moment, sum of combat stats in eq proportions) 
+  function getStatsSum(member) {
+    const info = gang.getMemberInformation(member);
+    return info.str + info.def + info.dex + info.agi;
+  }
+  // Find the best gang power except our gang
+  function maxEnemyPower(myGang) {
+    const others = ns.gang.getOtherGangInformation();
+    let maxPower = 0;
+    for (let name in others) {
+      if (name === myGang.faction) continue;
+      maxPower = Math.max(maxPower, others[name].power);
+    }
+    return maxPower;
+  }
+  // Set a task or not to set (if manually overridden)
+  const autoTasks = {}
+  function setAutoTask(member, task) {
+    const info = gang.getMemberInformation(member);
+    const lastTask = info.task;
+    // Manual task: stored task mismatches real task and not unassigned
+    if (lastTask !== TASK_NULL && autoTasks.hasOwnProperty(member) && autoTasks[member] !== lastTask) {
+      autoTasks[member] = TASK_MANUAL;
+      return;
+    }
+    // Automatic task: set it if differs from real one
+    autoTasks[member] = task;
+    if (lastTask !== task) {
+      gang.setMemberTask(member, task);
+    }
+  }
+  // The script accepts argument for default task override (optional)
+  let defaultTask = null;
+  if (ns.args[0] && gang.getTaskNames().includes(ns.args[0])) {
+    defaultTask = ns.args[0];
+  }
+  // Main loop
+  for (; ;) {
+    // Recruit any member possible 
+    while (gang.canRecruitMember()) {
+      gang.recruitMember('member' + Math.random().toString().substr(2, 3));
+    }
+    let bestStats = STATS_MIN / STATS_TRESHOLD; // minimum
+    const members = gang.getMemberNames();
+    const info = gang.getGangInformation();
+    // Ascend if good enough
+    for (let member of members) {
+      const r = gang.getAscensionResult(member);
+      if (!r) continue;
+      const mpl = r.agi * r.def * r.dex * r.str;
+      if (mpl > ASCEND_ON_MPL) {
+        gang.ascendMember(member);
+        ns.tprint(`Member ${member} ascended!`);
+      }
+    }
+    // Purchase equipment 
+    const allEquip = gang.getEquipmentNames();
+    let money = ns.getServerMoneyAvailable('home');
+    // Prioritize equipment for warfare members
+    for (let equip of allEquip) {
+      const cost = gang.getEquipmentCost(equip);
+      const amount = money / cost;
+      if (amount < EQUIP_AFFORD_COEFF) continue;
+
+      for (let member of members) {
+        const info = gang.getMemberInformation(member);
+        if (info.upgrades.includes(equip) || info.augmentations.includes(equip)) continue;
+
+        // Prioritize members assigned to warfare for combat equipment
+        if (info.task === TASK_WARFARE || info.task === TASK_TRAIN) {
+          if (gang.purchaseEquipment(member, equip)) {
+            money -= cost;
+          }
+        }
+      }
+    }
+    // Find best stats
+    for (let member of members) {
+      let sum = getStatsSum(member);
+      ns.print("sum = " + sum);
+      if (sum > bestStats) bestStats = sum;
+    }
+    // Check if we are powerful enough
+    let powerfulEnough = info.power >= maxEnemyPower(info) * WARFARE_TRESHOLD;
+    gang.setTerritoryWarfare(powerfulEnough);
+    // Choose the default task for members
+    let task = defaultTask;
+    if (!defaultTask) {
+      // If gang isn't full - gain respect
+      if (members.length < MEMBERS_MAX) {
+        task = (members.length < MEMBERS_MIN) ? TASK_NOOB : TASK_RESPECT;
+      } else {
+        // if respect too low - gain it first, power second, money last
+        if (info.respect < RESPECT_MIN) {
+          task = TASK_RESPECT;
+        } else if (!powerfulEnough) {
+          task = TASK_WARFARE;
+        } else {
+          task = TASK_MONEY;
+        }
+      }
+    }
+    // Assign tasks
+    // Ensure at least one member is always assigned to gain money and respect
+    let assignedMoney = false;
+    let assignedRespect = false;
+
+    // Assign tasks
+    for (let member of members) {
+      let sum = getStatsSum(member);
+
+      // Train members if stats are too low
+      if (sum < STATS_HARD_MIN || (members.length >= MEMBERS_MIN && sum < bestStats * STATS_TRESHOLD)) {
+        setAutoTask(member, TASK_TRAIN);
+        continue;
+      }
+
+      // Vigilante if wanted penalty too large
+      if (info.wantedLevel > 2 && info.wantedPenalty < WANTED_PENALTY_TRESHOLD) {
+        setAutoTask(member, TASK_VIGI);
+        continue;
+      }
+
+      // Ensure at least one member is gaining money and respect
+      if (!assignedMoney) {
+        setAutoTask(member, TASK_MONEY);
+        assignedMoney = true;
+        continue;
+      }
+
+      if (!assignedRespect) {
+        setAutoTask(member, TASK_RESPECT);
+        assignedRespect = true;
+        continue;
+      }
+
+      // Default task assignment (based on previous logic)
+      setAutoTask(member, Math.random() < TRAIN_CHANCE ? TASK_TRAIN : task);
+    }
+    await ns.sleep(SLEEP_TIME);
+  }
+}

Mizzajl/home/GPTPserver.js

@@ -0,0 +1,161 @@
+/** @param {NS} ns */
+export async function main(ns) {
+    ns.tail();
+
+    const maxRAM = Math.pow(2, 20);  // Maximum server size: 2^20 GB
+    const minRAM = Math.pow(2, 3);  // Minimum required size (8 GB) - FIXED
+    const serverSizes = [maxRAM, ...Array.from({ length: 17 }, (_, i) => Math.pow(2, 19 - i))]; // 2^20 to 2^3 sizes
+
+    // Fetch the list of purchased servers and sort them from largest to smallest
+    let aPserv = ns.getPurchasedServers();
+    aPserv.sort((a, b) => ns.getServerMaxRam(b) - ns.getServerMaxRam(a));
+
+    // Step 1: Purchase missing servers
+    await purchaseMissingServers(ns, aPserv, serverSizes, maxRAM, minRAM);  // PASSED minRAM
+
+    // Object to hold designated servers for each power-of-two size
+    let designatedServers = initializeDesignatedServers(serverSizes);
+
+    // Step 2: Assign servers to their respective power-of-two sizes and upgrade them if necessary
+    assignServers(ns, aPserv, designatedServers, serverSizes);
+
+    // Step 3: Upgrade remaining servers to max RAM
+    await upgradeServersToMaxRAM(ns, designatedServers, aPserv, maxRAM);
+
+    // Step 4: Write the designatedServers object to a file
+    await writeServerListToFile(ns, designatedServers);
+
+    ns.tprint("UpgradedServers.txt has been written.");
+}
+
+/**
+ * Step 1: Purchase missing servers.
+ * Ensures we have one server of each size 2^3 through 2^20, and if there are more servers needed, they are purchased at max RAM (2^20).
+ * @param {NS} ns - Netscript API.
+ * @param {Array} aPserv - Array of purchased server names.
+ * @param {Array} serverSizes - Array of power-of-two server sizes.
+ * @param {Number} maxRAM - Maximum server size (2^20).
+ * @param {Number} minRAM - Minimum required server size (2^3 or 8 GB).
+ */
+async function purchaseMissingServers(ns, aPserv, serverSizes, maxRAM, minRAM) {
+    const serverLimit = ns.getPurchasedServerLimit();
+    let nPserv = aPserv.length; // Current number of purchased servers
+
+    for (let i = nPserv; i < serverLimit; i++) {
+        let nMoney = ns.getServerMoneyAvailable("home");
+
+        // If we have fewer than 17 servers, follow the doubling pattern
+        if (i < serverSizes.length) {
+            let targetSize = serverSizes[serverSizes.length - i - 1]; // Start at the smallest size (2^3, then 2^4, etc.)
+            let serverCost = ns.getPurchasedServerCost(targetSize);
+
+            if (nMoney >= serverCost) {
+                const sServer = ns.purchaseServer(`pserv-${i.toString().padStart(2, "0")}`, targetSize);
+                ns.print(`Purchased ${sServer} with ${targetSize} GB RAM for ${serverCost}`);
+                aPserv.push(sServer);  // Add the new server to the list
+            } else {
+                ns.print(`Insufficient funds for pserv-${i.toString().padStart(2, "0")} (${nMoney} / ${serverCost}). Waiting...`);
+                await ns.sleep(5000);  // Wait and retry
+                i--; // Retry this iteration once funds are available
+            }
+        } else {  // Once we have the first 17 servers, purchase additional servers at max RAM
+            let serverCost = ns.getPurchasedServerCost(maxRAM);
+
+            if (nMoney >= serverCost) {
+                const sServer = ns.purchaseServer(`pserv-${i.toString().padStart(2, "0")}`, maxRAM);
+                ns.print(`Purchased ${sServer} with ${maxRAM} GB RAM for ${serverCost}`);
+                aPserv.push(sServer);
+            } else {
+                ns.print(`Insufficient funds for pserv-${i.toString().padStart(2, "0")} (${nMoney} / ${serverCost}). Waiting...`);
+                await ns.sleep(5000);  // Wait and retry
+                i--; // Retry this iteration once funds are available
+            }
+        }
+    }
+}
+
+/**
+ * Initializes the designatedServers object with null values for each power-of-two size.
+ * @param {Array} serverSizes - Array of power-of-two server sizes (2^20, 2^19, etc.).
+ * @returns {Object} - Object with each size as a key and null as the initial value.
+ */
+function initializeDesignatedServers(serverSizes) {
+    let designatedServers = {};
+    serverSizes.forEach(size => designatedServers[size] = null);
+    return designatedServers;
+}
+
+/**
+ * Step 2: Assigns servers to their respective power-of-two sizes, starting from the largest.
+ * Each server is only used once and is placed in the largest available size it can fit.
+ * @param {NS} ns - Netscript API.
+ * @param {Array} aPserv - Array of purchased server names, sorted by size.
+ * @param {Object} designatedServers - Object holding the server assignments.
+ * @param {Array} serverSizes - Array of power-of-two server sizes.
+ */
+function assignServers(ns, aPserv, designatedServers, serverSizes) {
+    for (let size of serverSizes) {
+        for (let i = 0; i < aPserv.length; i++) {
+            let server = aPserv[i];
+            let serverRAM = ns.getServerMaxRam(server);
+
+            // If this server can fill the current slot and has not already been assigned
+            if (serverRAM >= size && !Object.values(designatedServers).includes(server)) {
+                designatedServers[size] = server;  // Assign the server to the current power-of-two size
+                ns.print(`Assigned server ${server} with ${serverRAM} GB to ${size} GB spot.`);
+                break;  // Stop searching for this size and move to the next smaller size
+            }
+        }
+    }
+}
+
+/**
+ * Step 3: Upgrade remaining servers to max RAM (2^20).
+ * @param {NS} ns - Netscript API.
+ * @param {Object} designatedServers - Object holding the server assignments.
+ * @param {Array} aPserv - Array of purchased servers.
+ * @param {Number} maxRAM - Maximum server size (2^20 GB).
+ */
+async function upgradeServersToMaxRAM(ns, designatedServers, aPserv, maxRAM) {
+    while (true) {
+        let nMoney = ns.getServerMoneyAvailable("home");
+        let lowestRAMServer = null;
+        let lowestRAM = maxRAM;
+
+        // Find the server with the lowest RAM that isn't already maxed out
+        for (let i = 0; i < aPserv.length; i++) {
+            let serverRAM = ns.getServerMaxRam(aPserv[i]);
+            if (serverRAM < maxRAM && !Object.values(designatedServers).includes(aPserv[i])) {
+                lowestRAM = serverRAM;
+                lowestRAMServer = aPserv[i];
+            }
+        }
+
+        // If all servers are at maxRAM, we are done
+        if (!lowestRAMServer) {
+            ns.tprint("All servers are fully upgraded to 2^20 GB RAM.");
+            break;  // Exit the while loop
+        }
+
+        // Upgrade the lowest RAM server to maxRAM
+        let upgradeCost = ns.getPurchasedServerUpgradeCost(lowestRAMServer, maxRAM);
+
+        if (nMoney >= upgradeCost) {
+            ns.upgradePurchasedServer(lowestRAMServer, maxRAM);
+            ns.print(`Upgraded ${lowestRAMServer} to ${maxRAM} GB RAM.`);
+        } else {
+            ns.print(`Insufficient funds to upgrade ${lowestRAMServer} to ${maxRAM}: ${nMoney} / ${upgradeCost}`);
+            await ns.sleep(5000);  // Wait and check again
+        }
+    }
+}
+
+/**
+ * Writes the designatedServers object to a file in JSON format.
+ * @param {NS} ns - Netscript API.
+ * @param {Object} designatedServers - Object holding the server assignments.
+ */
+async function writeServerListToFile(ns, designatedServers) {
+    await ns.write("UpgradedServers.txt", JSON.stringify(designatedServers, null, 2), "w");
+    ns.print("UpgradedServers.txt has been written with the server assignments.");
+}

Mizzajl/home/ManagePserv.js

@@ -0,0 +1,70 @@
+/** @param {NS} ns */
+export async function main(ns) {
+  ns.tail();
+  let aPserv = ns.getPurchasedServers();  //array of purchased servers
+  let nPserv = aPserv.length; //amount of purchased servers we have
+  let nMoney = ns.getServerMoneyAvailable("home");  //player money
+  let nPrevSize = 4; //nPrevSize is 4 so the first server we will buy is 8
+
+
+  //Purchase Servers
+  //idea is to purchase the first server at 8 gb, next one at 16, next at 32 and so on
+
+  for (let i = 0; nPserv < i; i++) {
+    nMoney = ns.getServerMoneyAvailable("home");  //check money for each iteration
+    if (nMoney >= ns.getPurchasedServerCost(nPrevSize * 2)) { //can we afford next server?
+      const sServer = ns.purchaseServer(`pserv-${toString(i).padStart(2, "0")}`, nPrevSize * 2); //purchase server with name pserv- + 0i
+      ns.print(`Purchased ${sServer} for ${nPrevSize * 2}`);  //print tail message that we purchased server
+      nPrevSize *= 2; //increase nPrevSize for next iteration
+      nPserv++  //increase number of purchased servers
+    }
+    else {
+      ns.print(`Insufficient funds for pserv-${toString(i).padStart(2, "0")} ${nMoney} / ${ns.getPurchasedServerCost(nPrevSize * 2)}`);
+      await ns.sleep(5000);
+    }
+  }
+  ns.tprint("for loop purchase complete");
+
+
+  //upgrade servers
+  //idea is to upgrade the lowest server to match the highest (which should be 2^20 in size)
+
+  let nCurrentRAM;
+  let nLowestRAM = 2 ** 21;
+  let nHighestRAM = 0;
+  let sLowestPserv;
+  let sHighestPserv;
+  let nTotalPServRAM = 0;
+
+  for (let i = 0; i < nPserv; i++) {
+    nCurrentRAM = ns.getServerMaxRam(aPserv[i]);
+
+    nTotalPServRAM += nCurrentRAM;
+
+    if (nCurrentRAM < nLowestRAM) {
+      nLowestRAM = nCurrentRAM
+      sLowestPserv = aPservers[i];
+    }
+
+    if (nCurrentRAM > nHighestRAM) {
+      nHighestRAM = nCurrentRAM
+      sHighestPserv = aPserv[i];
+    }
+  }
+
+  //sLowestPserv should now be the lowest server
+  //sHighestPserv should now be the highest server
+
+  for (let i = 0; sLowestPserv < sHighestPserv ; i++) {
+    if (nMoney >= ns.getPurchasedServerUpgradeCost(sLowestPserv, 2^20)){
+      ns.upgradePurchasedServer(sLowestPserv, 2^20);
+
+
+    }
+
+
+
+
+  }
+
+}

Mizzajl/home/corp/BuyWarehouseAPI.js

@@ -4,4 +4,5 @@ export async function main(ns) {
         ns.corporation.purchaseUnlock("Warehouse API");
         ns.writePort(ns.pid, true)
     }
+    ns.writePort(ns.pid, true)
 }

Mizzajl/home/corp/HireWorkers.js

@@ -0,0 +1,10 @@
+/** @param {NS} ns */
+export async function main(ns) {
+  let [sDivName, sCity, oCurrentOffice] = ns.args;
+  oCurrentOffice = JSON.parse(oCurrentOffice);
+  if (oCurrentOffice.numEmployees < oCurrentOffice.size) {
+    ns.corporation.hireEmployee(sDivName, sCity, "Research & Development");
+    await ns.sleep(1000)
+  };
+  ns.writePort(ns.pid, true);
+}

Mizzajl/home/testgang.js

@@ -0,0 +1,27 @@
+export async function main(ns) {
+  ns.tail();
+  // Get the list of all task names
+  let aTasks = ns.gang.getTaskNames();
+  // Create an array to store task stats
+  let oTasks = [];
+
+  // Loop through each task and get the stats
+  for (let i = 0; i < aTasks.length; i++) {
+    let taskName = aTasks[i];
+    let taskStats = ns.gang.getTaskStats(taskName);
+
+    // Store task name and stats in an object and push to array
+    oTasks.push({
+      name: taskName,
+      stats: taskStats
+    });
+  }
+
+  // Convert the object to a JSON string for easy storage
+  let taskStatsString = JSON.stringify(oTasks, null, 2);
+
+  // Write the task stats to a file
+  await ns.write("GangTaskStats.txt", taskStatsString, "w");
+
+  ns.tprint("Gang task stats have been written to GangTaskStats.txt.");
+}

Mizzajl/home/wip/pserv.js

@@ -13,20 +13,6 @@ export async function main(ns) {
   let sHighestPserv;
   let nTotalPServRAM = 0;
 
-
-  const oPservers = new Object();
-
-
-/*
-    const oPservers = {
-      pserv-01 : { name: "pserv-01" , ram: nRAM}
-
-    };
-*/
-
-
-
-
   for (let i = 0; i < nPservers; i++) {
     nCurrentRAM = ns.getServerMaxRam(aPservers[i]);
     //ns.tprint("nTotalPServRAM = " + nTotalPServRAM + " + " + "nCurrentRAM = " + nCurrentRAM);