From 6b5c5733c208ea22cb71b0b73edbbce7e30b8834 Mon Sep 17 00:00:00 2001 From: Mizzajl Date: Mon, 21 Oct 2024 03:32:32 +0200 Subject: [PATCH] sleepy time update --- Mizzajl/home/GPTGang.js | 172 +++++++++++++++++++ Mizzajl/home/GPTPserver.js | 161 +++++++++++++++++ Mizzajl/home/ManagePserv.js | 70 ++++++++ Mizzajl/home/{test3.js => UICrimeStats.js} | 0 Mizzajl/home/{stylishGraph.js => UIGraph.js} | 0 Mizzajl/home/corp/BuyWarehouseAPI.js | 1 + Mizzajl/home/corp/HireWorkers.js | 10 ++ Mizzajl/home/testgang.js | 27 +++ Mizzajl/home/wip/pserv.js | 14 -- 9 files changed, 441 insertions(+), 14 deletions(-) create mode 100644 Mizzajl/home/GPTGang.js create mode 100644 Mizzajl/home/GPTPserver.js create mode 100644 Mizzajl/home/ManagePserv.js rename Mizzajl/home/{test3.js => UICrimeStats.js} (100%) rename Mizzajl/home/{stylishGraph.js => UIGraph.js} (100%) create mode 100644 Mizzajl/home/corp/HireWorkers.js create mode 100644 Mizzajl/home/testgang.js diff --git a/Mizzajl/home/GPTGang.js b/Mizzajl/home/GPTGang.js new file mode 100644 index 0000000..757a5a8 --- /dev/null +++ b/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); + } +} \ No newline at end of file diff --git a/Mizzajl/home/GPTPserver.js b/Mizzajl/home/GPTPserver.js new file mode 100644 index 0000000..ee450cc --- /dev/null +++ b/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."); +} diff --git a/Mizzajl/home/ManagePserv.js b/Mizzajl/home/ManagePserv.js new file mode 100644 index 0000000..2b863d5 --- /dev/null +++ b/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); + + + } + + + + + } + +} \ No newline at end of file diff --git a/Mizzajl/home/test3.js b/Mizzajl/home/UICrimeStats.js similarity index 100% rename from Mizzajl/home/test3.js rename to Mizzajl/home/UICrimeStats.js diff --git a/Mizzajl/home/stylishGraph.js b/Mizzajl/home/UIGraph.js similarity index 100% rename from Mizzajl/home/stylishGraph.js rename to Mizzajl/home/UIGraph.js diff --git a/Mizzajl/home/corp/BuyWarehouseAPI.js b/Mizzajl/home/corp/BuyWarehouseAPI.js index 03e168c..961bb79 100644 --- a/Mizzajl/home/corp/BuyWarehouseAPI.js +++ b/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) } \ No newline at end of file diff --git a/Mizzajl/home/corp/HireWorkers.js b/Mizzajl/home/corp/HireWorkers.js new file mode 100644 index 0000000..3964f22 --- /dev/null +++ b/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); +} \ No newline at end of file diff --git a/Mizzajl/home/testgang.js b/Mizzajl/home/testgang.js new file mode 100644 index 0000000..7138448 --- /dev/null +++ b/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."); +} diff --git a/Mizzajl/home/wip/pserv.js b/Mizzajl/home/wip/pserv.js index cbe2626..4194eaa 100644 --- a/Mizzajl/home/wip/pserv.js +++ b/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);