added ram utilisation logic to `ram.js` and `servers.js`. split and refactored redundant code into separate library files.

[?]

Apr 21, 2020, 12:41 PM

SLSWBNYTIFKBFLKXZTMONGDMEOHSOOCOSU4KVJCONZG2DK3BBIUQC

Dependencies

[2] YXH7ERRN fixed bug that prevented helper scripts running if the "home" server does not have RAM bigger than the rest of the rooted servers.
[3] RWMZ7DVL split and refactor various logics. update "README.md".
[4] BZ6FC2BT add `cp.js`.
[5] BCM3TZOS added `killall.js` option to kill only named scripts. fixed `void_server_buy_or_upgrade` regression that prevented it from working when you don't have servers.
[6] EYKBOK3O optimised the scheduling logic by ensuring that cycles start and finish at minimum security of target.
[7] NC66CZ5J rename certain variables that had the same names as ns functions to prevent the RAM checker from triggering.
[8] 2BKHJI2S init
[9] 6MBUKAG6 remove unneeded functions and comments. update readme.
[10] NQ22FUSW add more options to `main.js`. update `README.md`.
[11] 4ACCU75N improve and refactor scheduling logic.
[12] FA3U4WUJ more `README.md` changes.
[13] VMXI7PS4 added action cap. improved scoring system. fixed parts of security and cash predictors. made lshw loopable.
[*] CJBGAILA add optional `--target` parameter for `main.js`. update `README.md`.

Change contents

replacement in sbin/servers.js at line 1

[3.2445]→[3.2446:2650](∅→∅)

// servers.js - 8.55GB - continually buys the best server with cash available, unless there are 25 servers already, in which case deletes the worst server, unless all 25 have ram == PurchasedServerMaxRam

[3.2445]

[3.2650]

// servers.js - 8.85GB - continually buys the best server with cash available if ram utilisation of the network is over threshold, unless there are 25 servers already, in which case deletes the worst server, unless all 25 have RAM == PurchasedServerMaxRam.
import {
float_get_network_ram_utilisation,
float_get_server_ram_total
}
from "lib_ram.js";
replacement in sbin/servers.js at line 10

[3.2739]→[3.2739:3412](∅→∅)

const string_servers_bought_name = ns.args[0];
const object_get_constants = function(ns) {
const object_constants = {
// cost of server per 1 GB of RAM
BaseCostFor1GBOfRamServer: 55000,
// maximum amount of purchased servers allowed
PurchasedServerLimit: 25,
// minimum ram of purchased servers possible
integer_server_ram_min: 2,
// maximum ram of purchased servers possible. 2^20
PurchasedServerMaxRam: 1048576,
};
return object_constants;
};

// returns the total ram of a server
const integer_get_server_ram_total = function(ns, string_server) {
return (ns.getServerRam(string_server))[0];
};

[3.2739]

[3.3412]

const string_servers_bought_name = ns.args[1];
const float_ram_utilisation_threshold = ns.args[2];
replacement in sbin/servers.js at line 13

[3.3413]→[3.3413:3966](∅→∅)

// true if all bought servers have ram == PurchasedServerMaxRam
const boolean_servers_bought_all_max = function(ns) {
const array_servers_bought = ns.getPurchasedServers();
if (array_servers_bought.length > 0) {
let boolean_tripwire = true;
for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
if (integer_get_server_ram_total(ns, array_servers_bought[integer_indices_0]) < object_get_constants(ns).PurchasedServerMaxRam) {
boolean_tripwire = false;
}

[3.3413]

[3.3966]

while (!boolean_servers_bought_all_max(ns)) {
while (float_get_network_ram_utilisation(ns) > float_ram_utilisation_threshold) {
while (boolean_conditions_server_delete_purchase(ns)) {
ns.deleteServer(string_get_server_bought_smallest(ns));
ns.purchaseServer(string_servers_bought_name, integer_get_server_ram_biggest_afforded(ns));
replacement in sbin/servers.js at line 19

[3.3974]→[3.3974:4773](∅→∅)

return boolean_tripwire;
}
};

// returns bought server with smallest RAM
const string_get_server_bought_smallest = function(ns) {
const array_servers_bought = ns.getPurchasedServers();
if (array_servers_bought.length > 0) {
let string_server_smallest;
let integer_size_smallest = object_get_constants(ns).PurchasedServerMaxRam;
for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
let integer_server_ram_total = integer_get_server_ram_total(ns, array_servers_bought[integer_indices_0]);
if (integer_server_ram_total < integer_size_smallest) {
string_server_smallest = array_servers_bought[integer_indices_0];
integer_size_smallest = integer_server_ram_total;
}

[3.3974]

[3.4773]

while (
boolean_conditions_server_purchase_3(ns) ||
boolean_conditions_server_purchase_2(ns) ||
boolean_conditions_server_purchase_1(ns)
) {
ns.purchaseServer(string_servers_bought_name, integer_get_server_ram_biggest_afforded(ns));
edit in sbin/servers.js at line 27

[3.4781]→[3.4781:4818](∅→∅)

return string_server_smallest;
replacement in sbin/servers.js at line 28

[3.4824]→[3.4824:4829](∅→∅)

};

[3.4824]

[3.4829]

await ns.sleep(float_period_check);
}
};
replacement in sbin/servers.js at line 32

[3.4830]→[3.4830:5633](∅→∅)

// returns bought server with biggest RAM
const string_get_server_bought_biggest = function(ns) {
const array_servers_bought = ns.getPurchasedServers();
if (array_servers_bought.length > 0) {
let string_server_biggest;
let integer_size_biggest = object_get_constants(ns).integer_server_ram_min;
for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
let integer_server_ram_total = integer_get_server_ram_total(ns, array_servers_bought[integer_indices_0]);
if (integer_server_ram_total > integer_size_biggest) {
string_server_biggest = array_servers_bought[integer_indices_0];
integer_size_biggest = integer_server_ram_total;
}
}
return string_server_biggest;
}
};

[3.4830]

[3.5633]

// functions
replacement in sbin/servers.js at line 34

[3.5634]→[3.5634:6233](∅→∅)

// return the RAM of the server with the biggest RAM that you can afford
const integer_get_server_ram_biggest_afforded = function(ns) {
const object_constants = object_get_constants(ns);
let integer_server_ram_biggest_afforded = Math.pow(2, Math.trunc(Math.log2(ns.getServerMoneyAvailable("home") / object_constants.BaseCostFor1GBOfRamServer) / Math.log2(2)));
if (integer_server_ram_biggest_afforded > object_constants.PurchasedServerMaxRam) {
integer_server_ram_biggest_afforded = object_constants.PurchasedServerMaxRam;
}
return integer_server_ram_biggest_afforded;

[3.5634]

[3.6233]

const object_get_constants = function(ns) {
const object_constants = {
// cost of server per 1 GB of RAM
BaseCostFor1GBOfRamServer: 55000,
// maximum amount of purchased servers allowed
PurchasedServerLimit: 25,
// minimum RAM of purchased servers possible
integer_server_ram_min: 2,
// maximum RAM of purchased servers possible. 2^20
PurchasedServerMaxRam: 1048576,
edit in sbin/servers.js at line 45

[3.6238]

[3.6238]

return object_constants;
};
replacement in sbin/servers.js at line 48

[3.6239]→[3.6239:7075](∅→∅)

const boolean_conditions_server_purchase_1 = function(ns) {
const integer_server_ram_biggest_afforded = integer_get_server_ram_biggest_afforded(ns);
const object_constants = object_get_constants(ns);
if (// you have no bought servers yet
(ns.getPurchasedServers().length === 0) &&
// ram is at least equal to the minimum ram possible for purchased servers
(integer_server_ram_biggest_afforded >= object_constants.integer_server_ram_min) &&
// ram is at least equal to the ram of "home" (probably a bad idea to hardcode this since the string_name of "home" might change in the future) or max ram.
(integer_server_ram_biggest_afforded >= integer_get_server_ram_total(ns, "home") ||
integer_server_ram_biggest_afforded >= object_constants.PurchasedServerMaxRam)
) {
return true;

[3.6239]

[3.7075]

// true if all bought servers have RAM == PurchasedServerMaxRam
const boolean_servers_bought_all_max = function(ns) {
const array_servers_bought = ns.getPurchasedServers();
if (array_servers_bought.length > 0) {
let boolean_tripwire = true;
for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
if (float_get_server_ram_total(ns, array_servers_bought[integer_indices_0]) < object_get_constants(ns).PurchasedServerMaxRam) {
boolean_tripwire = false;
}
replacement in sbin/servers.js at line 58

[3.7081]→[3.7081:8013](∅→∅)

};

const boolean_conditions_server_purchase_2 = function(ns) {
const integer_servers_bought_amount = ns.getPurchasedServers().length;
const object_constants = object_get_constants(ns);
if (// you have one or more servers already
(integer_servers_bought_amount > 0) &&
// you currently own less than the maximum amount of purchased servers allowed
(integer_servers_bought_amount < object_constants.PurchasedServerLimit)

) {
const float_ram_server_bought_biggest = integer_get_server_ram_total(ns, string_get_server_bought_biggest(ns));
if (
// you dont own a server with max ram yet, buy a server with ram greater than the ram of your biggest bought server
(float_ram_server_bought_biggest != object_constants.PurchasedServerMaxRam) &&
(float_ram_server_bought_biggest < integer_get_server_ram_biggest_afforded(ns))
) {
return true;

[3.7081]

[3.8013]

return boolean_tripwire;
}
};

// returns bought server with smallest RAM
const string_get_server_bought_smallest = function(ns) {
const array_servers_bought = ns.getPurchasedServers();
if (array_servers_bought.length > 0) {
let string_server_smallest;
let integer_size_smallest = object_get_constants(ns).PurchasedServerMaxRam;
for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
let integer_server_ram_total = float_get_server_ram_total(ns, array_servers_bought[integer_indices_0]);
if (integer_server_ram_total < integer_size_smallest) {
string_server_smallest = array_servers_bought[integer_indices_0];
integer_size_smallest = integer_server_ram_total;
replacement in sbin/servers.js at line 75

[3.8027]→[3.8027:8909](∅→∅)

};

const boolean_conditions_server_purchase_3 = function(ns) {
const integer_servers_bought_amount = ns.getPurchasedServers().length;
const object_constants = object_get_constants(ns);
const float_ram_server_bought_maximum = object_constants.PurchasedServerMaxRam;
if (// you have one or more servers already
(integer_servers_bought_amount > 0) &&
// you currently own less than the maximum amount of purchased servers allowed
(integer_servers_bought_amount < object_constants.PurchasedServerLimit)
) {
if (// you already bought a server with max ram, buy another server the max possible ram
(integer_get_server_ram_total(ns, string_get_server_bought_biggest(ns)) == float_ram_server_bought_maximum) &&
(integer_get_server_ram_biggest_afforded(ns) >= float_ram_server_bought_maximum)
) {
return true;

[3.8027]

[3.8909]

return string_server_smallest;
}
};

// returns bought server with biggest RAM
const string_get_server_bought_biggest = function(ns) {
const array_servers_bought = ns.getPurchasedServers();
if (array_servers_bought.length > 0) {
let string_server_biggest;
let integer_size_biggest = object_get_constants(ns).integer_server_ram_min;
for (let integer_indices_0 = 0; integer_indices_0 < array_servers_bought.length; ++integer_indices_0) {
let integer_server_ram_total = float_get_server_ram_total(ns, array_servers_bought[integer_indices_0]);
if (integer_server_ram_total > integer_size_biggest) {
string_server_biggest = array_servers_bought[integer_indices_0];
integer_size_biggest = integer_server_ram_total;
replacement in sbin/servers.js at line 92

[3.8923]→[3.8923:9787](∅→∅)

};

const boolean_conditions_server_delete_purchase = function(ns) {
const object_constants = object_get_constants(ns);
if (// you currently own the maximum amount of purchased servers allowed
(ns.getPurchasedServers().length == object_constants.PurchasedServerLimit) &&
// your servers do not all have the maximum ram possible for purchased servers
!(boolean_servers_bought_all_max(ns, object_constants.PurchasedServerMaxRam)) &&
// is cash at least equal to the price of the cheapest server bought + the next highest server after that, which is twice the price of the former, thus 3. this check is so that a server with the same ram as before isn't bought.
(ns.getServerMoneyAvailable("home") >= 3 * object_constants.BaseCostFor1GBOfRamServer * integer_get_server_ram_total(ns, string_get_server_bought_smallest(ns)))

[3.8923]

[3.9787]

return string_server_biggest;
}
};

// return the RAM of the server with the biggest RAM that you can afford
const integer_get_server_ram_biggest_afforded = function(ns) {
const object_constants = object_get_constants(ns);
let integer_server_ram_biggest_afforded = Math.pow(2, Math.trunc(Math.log2(ns.getServerMoneyAvailable("home") / object_constants.BaseCostFor1GBOfRamServer) / Math.log2(2)));
if (integer_server_ram_biggest_afforded > object_constants.PurchasedServerMaxRam) {
integer_server_ram_biggest_afforded = object_constants.PurchasedServerMaxRam;
}
return integer_server_ram_biggest_afforded;
};

const boolean_conditions_server_purchase_1 = function(ns) {
const integer_server_ram_biggest_afforded = integer_get_server_ram_biggest_afforded(ns);
const object_constants = object_get_constants(ns);
if (// you have no bought servers yet
(ns.getPurchasedServers().length === 0) &&
// RAM is at least equal to the minimum RAM possible for purchased servers
(integer_server_ram_biggest_afforded >= object_constants.integer_server_ram_min) &&
// RAM is at least equal to the RAM of "home" (probably a bad idea to hardcode this since the string_name of "home" might change in the future) or max ram.
(integer_server_ram_biggest_afforded >= float_get_server_ram_total(ns, "home") ||
integer_server_ram_biggest_afforded >= object_constants.PurchasedServerMaxRam)
) {
return true;
}
};

const boolean_conditions_server_purchase_2 = function(ns) {
const integer_servers_bought_amount = ns.getPurchasedServers().length;
const object_constants = object_get_constants(ns);
if (// you have one or more servers already
(integer_servers_bought_amount > 0) &&
// you currently own less than the maximum amount of purchased servers allowed
(integer_servers_bought_amount < object_constants.PurchasedServerLimit)

) {
const float_ram_server_bought_biggest = float_get_server_ram_total(ns, string_get_server_bought_biggest(ns));
if (
// you dont own a server with max RAM yet, buy a server with RAM greater than the RAM of your biggest bought server
(float_ram_server_bought_biggest != object_constants.PurchasedServerMaxRam) &&
(float_ram_server_bought_biggest < integer_get_server_ram_biggest_afforded(ns))
edit in sbin/servers.js at line 137

[3.9814]→[3.9814:9851](∅→∅)

}
else {
return false;
replacement in sbin/servers.js at line 138

[3.9857]→[3.9857:9862](∅→∅)

};

[3.9857]

[3.9862]

}
};
replacement in sbin/servers.js at line 141

[3.9863]→[3.9863:10301](∅→∅)

while (!boolean_servers_bought_all_max(ns)) {
while (boolean_conditions_server_delete_purchase(ns)) {
ns.deleteServer(string_get_server_bought_smallest(ns));
ns.purchaseServer(string_servers_bought_name, integer_get_server_ram_biggest_afforded(ns));
}

while (
boolean_conditions_server_purchase_3(ns) ||
boolean_conditions_server_purchase_2(ns) ||
boolean_conditions_server_purchase_1(ns)

[3.9863]

[3.10301]

const boolean_conditions_server_purchase_3 = function(ns) {
const integer_servers_bought_amount = ns.getPurchasedServers().length;
const object_constants = object_get_constants(ns);
const float_ram_server_bought_maximum = object_constants.PurchasedServerMaxRam;
if (// you have one or more servers already
(integer_servers_bought_amount > 0) &&
// you currently own less than the maximum amount of purchased servers allowed
(integer_servers_bought_amount < object_constants.PurchasedServerLimit)
) {
if (// you already bought a server with max ram, buy another server the max possible ram
(float_get_server_ram_total(ns, string_get_server_bought_biggest(ns)) == float_ram_server_bought_maximum) &&
(integer_get_server_ram_biggest_afforded(ns) >= float_ram_server_bought_maximum)
replacement in sbin/servers.js at line 154

[3.10309]→[3.10309:10407](∅→∅)

ns.purchaseServer(string_servers_bought_name, integer_get_server_ram_biggest_afforded(ns));

[3.10309]

[3.10407]

return true;
edit in sbin/servers.js at line 156

[3.10413]

[3.10413]

}
};
replacement in sbin/servers.js at line 159

[3.10414]→[3.10414:10454](∅→∅)

await ns.sleep(float_period_check);

[3.10414]

[3.10454]

const boolean_conditions_server_delete_purchase = function(ns) {
const object_constants = object_get_constants(ns);
if (// you currently own the maximum amount of purchased servers allowed
(ns.getPurchasedServers().length == object_constants.PurchasedServerLimit) &&
// your servers do not all have the maximum RAM possible for purchased servers
!(boolean_servers_bought_all_max(ns, object_constants.PurchasedServerMaxRam)) &&
// is cash at least equal to the price of the cheapest server bought + the next highest server after that, which is twice the price of the former, thus 3. this check is so that a server with the same RAM as before isn't bought.
(ns.getServerMoneyAvailable("home") >= 3 * object_constants.BaseCostFor1GBOfRamServer * float_get_server_ram_total(ns, string_get_server_bought_smallest(ns)))
) {
return true;
}
else {
return false;
replacement in sbin/ram.js at line 1

[3.10497]→[3.10498:10583](∅→∅)

// ram.js - 6.2GB - tries to continually buy ram as long as you have sufficient cash

[3.10497]

[3.10583]

// ram.js - 6.6GB - tries to continually upgrade the RAM of "home" as long as the ram utilisation of your network is over threshold and you have sufficient cash.
import {
float_get_network_ram_utilisation
}
from "lib_ram.js";
edit in sbin/ram.js at line 9

[3.10672]

[3.10672]

const float_ram_utilisation_threshold = ns.args[1];
replacement in sbin/ram.js at line 11

[3.10688]→[3.10688:10808](∅→∅)

try {
while (ns.getServerMoneyAvailable("home") >= ns.getUpgradeHomeRamCost()) {
ns.upgradeHomeRam();

[3.10688]

[3.10808]

while(float_get_network_ram_utilisation(ns) > float_ram_utilisation_threshold) {
try {
while (ns.getServerMoneyAvailable("home") >= ns.getUpgradeHomeRamCost()) {
ns.upgradeHomeRam();
}
edit in sbin/ram.js at line 17

[3.10816]

[3.10816]

catch (error) {
ns.print(JSON.stringify(error));
}
edit in sbin/ram.js at line 21

[3.10822]→[3.10822:10887](∅→∅)

catch (error) {
ns.print(JSON.stringify(error));
}
replacement in sbin/botnet.js at line 1

[3.53534]→[3.53535:53714](∅→∅)

// botnet.js - 2.15GB - opens ports and nukes any unrooted servers if the player's hacking level is high enough to do so and the appropriate number of object_exploits are present

[3.53534]

[3.53714]

// botnet.js - 2.2GB - opens ports and nukes any unrooted servers if the player's hacking level is high enough to do so and the appropriate number of object_exploits are present
import {
array_get_servers_unrooted
}
from "lib_root.js";
replacement in sbin/botnet.js at line 10

[3.53804]→[3.53804:54259](∅→∅)

const object_get_constants = function(ns) {
// object_constants are from https://github.com/danielyxie/bitburner/blob/master/src/Constants.js
const object_constants = {
// filenames and related functions of exploits
array_exploits: [ns.brutessh, ns.ftpcrack, ns.relaysmtp, ns.httpworm, ns.sqlinject],
// name of current host (usually "home")
string_host: "home" // or ns.getHostname()
};
return object_constants;

[3.53804]

[3.54259]

const array_get_exploits = function(ns) {
return [
ns.brutessh,
ns.ftpcrack,
ns.relaysmtp,
ns.httpworm,
ns.sqlinject
];
edit in sbin/botnet.js at line 20

[3.54267]→[3.54267:55454](∅→∅)

// returns an array of all servers in the game
const array_get_servers = function(ns) {
const string_host = object_get_constants(ns).string_host;
const array_servers = [string_host];
for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
const array_scan_results = ns.scan(array_servers[integer_indices_0]);
for (let integer_indices_1 = 0; integer_indices_1 < array_scan_results.length; ++integer_indices_1) {
if (array_servers.indexOf(array_scan_results[integer_indices_1]) === -1) {
array_servers.push(array_scan_results[integer_indices_1]);
}
}
}
return array_servers;
};

// returns an array of all servers that are yet to be rooted
const array_get_servers_unrooted = function(ns) {
const array_servers = array_get_servers(ns);
const array_servers_unrooted = [];
for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
if (!ns.hasRootAccess(array_servers[integer_indices_0])) {
array_servers_unrooted.push(array_servers[integer_indices_0]);
}
}
return array_servers_unrooted;
};
replacement in sbin/botnet.js at line 22

[3.55556]→[3.55556:55624](∅→∅)

const array_exploits = object_get_constants(ns).array_exploits;

[3.55556]

[3.55624]

const array_exploits = array_get_exploits(ns);
edit in bin/main.js at line 2

[2.1988]

[3.3793780]

import {
array_get_servers
}
from "lib_servers.js";

import {
array_get_servers_rooted
}
from "lib_root.js";

import {
float_get_server_ram_total,
float_get_server_ram_free
}
from "lib_ram.js";
edit in bin/main.js at line 36

[3.2030]

[15.2359]

// ram utilisiation threshold. upgrade ram when reached.
let float_ram_utilisation_threshold = 0.9;
edit in bin/main.js at line 86

[2.3378]

[2.3378]

case "-r":
// fall-through
case "--ram-utilisation":
float_ram_utilisation_threshold = string_argument_value;
array_arguments.splice(0, 2);
break;
replacement in bin/main.js at line 108

[2.3733]→[2.3733:3752](∅→∅)

// ram: 6.2,

[2.3733]

[2.3752]

// ram: 6.6,
replacement in bin/main.js at line 110

[2.3773]→[2.3773:3822](∅→∅)

// arguments: [float_period_check_seconds]

[2.3773]

[2.3822]

// arguments: [float_period_check_seconds, float_ram_utilisation_threshold]
replacement in bin/main.js at line 114

[2.3864]→[2.3864:3881](∅→∅)

ram: 8.55,

[2.3864]

[2.3881]

ram: 8.85,
replacement in bin/main.js at line 116

[2.3899]→[2.3899:3973](∅→∅)

arguments: [float_period_check_seconds, string_servers_bought_name]

[2.3899]

[2.3973]

arguments: [float_period_check_seconds, string_servers_bought_name, float_ram_utilisation_threshold]
edit in bin/main.js at line 319

[3.7837]→[3.7837:7925](∅→∅),[3.7925]→[2.4323:4363](∅→∅),[2.4363]→[3.7985:9016](∅→∅),[3.7985]→[3.7985:9016](∅→∅),[3.9016]→[2.4364:4814](∅→∅)

// returns an array of all servers in the game
const array_get_servers = function(ns) {
const string_host = ns.getHostname();
const array_servers = [string_host];
for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
const array_scan_results = ns.scan(array_servers[integer_indices_0]);
for (let integer_indices_1 = 0; integer_indices_1 < array_scan_results.length; ++integer_indices_1) {
if (array_servers.indexOf(array_scan_results[integer_indices_1]) === -1) {
array_servers.push(array_scan_results[integer_indices_1]);
}
}
}
return array_servers;
};

// returns the total ram of a server
const integer_get_server_ram_total = function(ns, string_server) {
return (ns.getServerRam(string_server))[0];
};

// returns the used ram of a server
const float_get_server_ram_used = function(ns, string_server) {
return (ns.getServerRam(string_server))[1];
};

// returns the amount of free ram of a server
const float_get_server_ram_free = function(ns, string_server) {
return integer_get_server_ram_total(ns, string_server) - float_get_server_ram_used(ns, string_server);
};

// returns an array of all rooted servers
const array_get_servers_rooted = function(ns) {
const array_servers = array_get_servers(ns);
const array_servers_rooted = [];
for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
if (ns.hasRootAccess(array_servers[integer_indices_0])) {
array_servers_rooted.push(array_servers[integer_indices_0]);
}
}
return array_servers_rooted;
};
replacement in bin/main.js at line 381

[3.9173]→[3.9173:9349](∅→∅)

return array_servers.sort((string_element_0, string_element_1) => (integer_get_server_ram_total(ns, string_element_0) - integer_get_server_ram_total(ns, string_element_1)));

[3.9173]

[3.9349]

return array_servers.sort((string_element_0, string_element_1) => (float_get_server_ram_total(ns, string_element_0) - float_get_server_ram_total(ns, string_element_1)));
replacement in bin/killall.js at line 1

[3.3797120]→[3.1581:1683](∅→∅)

// TODO: implement a loop that repeats logic until all appropriate scripts have actually been killed.

[3.3797120]

[3.1683]

// killall.js - 3.05GB - TODO: implement a loop that repeats logic until all appropriate scripts have actually been killed.
replacement in bin/killall.js at line 3

[3.1684]→[3.3797121:3797253](∅→∅),[3.3797120]→[3.3797121:3797253](∅→∅),[3.3797253]→[3.2519:2946](∅→∅),[3.2946]→[3.3797680:3797725](∅→∅),[3.3387]→[3.3797680:3797725](∅→∅),[3.3797680]→[3.3797680:3797725](∅→∅)

// returns an array of all servers in the game
const array_get_servers = function(ns) {
const array_servers = [ns.getHostname()];
for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
const array_scan_results = ns.scan(array_servers[integer_indices_0]);
for (let integer_indices_1 = 0; integer_indices_1 < array_scan_results.length; ++integer_indices_1) {
if (array_servers.indexOf(array_scan_results[integer_indices_1]) === -1) {
array_servers.push(array_scan_results[integer_indices_1]);
}
}
}
return array_servers;
};

[3.1684]

[3.3797725]

import {
array_get_servers
}
from "lib_servers.js";
replacement in bin/cp.js at line 1

[3.3802495]→[3.3802496:3803100](∅→∅)

// returns an array of all servers in the game
const array_get_servers = function(ns) {
const array_servers = [ns.getHostname()];
for (let integer_indices_0 = 0; integer_indices_0 < array_servers.length; ++integer_indices_0) {
const array_scan_results = ns.scan(array_servers[integer_indices_0]);
for (let integer_indices_1 = 0; integer_indices_1 < array_scan_results.length; ++integer_indices_1) {
if (array_servers.indexOf(array_scan_results[integer_indices_1]) === -1) {
array_servers.push(array_scan_results[integer_indices_1]);
}
}
}
return array_servers;
};

[3.3802495]

[3.3803100]

// cp.js - 2.65GB
import {
array_get_servers
}
from "lib_servers.js";
replacement in README.md at line 10

[3.3289]→[2.8193:8240](∅→∅),[3.4255]→[3.44571:44607](∅→∅),[2.8240]→[3.44571:44607](∅→∅),[3.44571]→[3.44571:44607](∅→∅)

### "main.js" (8.75 [+6.2] [+8.55] [+2.15] GB)
* Run helper scripts that should:

[3.3289]

[3.44607]

### "main.js" (8.75 [+6.6] [+8.85] [+2.2] GB)
* Run the helper scripts "ram.js", "servers.js" and "botnet.js" that should, respectively:
edit in README.md at line 47

[3.4684]

[3.4684]

`-r, --ram-utilisation <THRESHOLD>`

* THRESHOLD = The botnet's ram utilisation threshold after which upgrades/replacements should be bought for servers and the RAM of "home". Should be a floating point number >= 0 <= 1. Values closer to 0 will result in attempting more frequent upgrades/replacements at the cost of less efficient RAM utilisation to cash spenditure ratios. Defaults to 0.9.
replacement in README.md at line 61

[3.4930]→[3.4930:4988](∅→∅)

`run main.js --job-cap 4000 -i "harakiri-sushi" -s 0.5`

[3.4930]

[3.4988]

`run main.js --job-cap 4000 -i "harakiri-sushi" -r 0.7 -s 0.5`
replacement in README.md at line 63

[3.4989]→[3.6527:6733](∅→∅)

* Runs the script with up to 4000 jobs, targetting "harakiri-sushi" and stealing only up to 50% of it's cash per "hack.js" job that finishes executing, whilst the remaining variables are set to defaults.

[3.4989]

[3.5163]

* Runs the script with up to 4000 jobs, targetting "harakiri-sushi", only upgrading/replacing RAM and servers when at least 0.7 of your network's total RAM is being used, and stealing only up to 50% of harakiri-sushi's cash per "hack.js" job that finishes executing, whilst the remaining variables are set to defaults.
replacement in README.md at line 125

[3.3873780]→[3.3873780:3873924](∅→∅)

This Work is distributed and dual-licensed under the terms of both the [MIT License](LICENSE-MIT) and the [Apache License 2.0](LICENSE-APACHE).

[3.3873779]

[3.3873924]

This Work is distributed and dual-licensed under the terms of both the [MIT License](https://nest.pijul.com/nicoty/bitburner_scripts:master/4bb17ded7a86f7decd) and the [Apache License 2.0](https://nest.pijul.com/nicoty/bitburner_scripts:master/4bb17ded7a86f7de02).