nicoty/bitburner_scripts - Change 4ACCU75NFJ4ZD5CMHBBYCFLBWL2XQH4RS65FTR4JDJPBHTABYJZAC

improve and refactor scheduling logic.

Created by jesse <nicoty@tuta.io> on April 20, 2020

4ACCU75NFJ4ZD5CMHBBYCFLBWL2XQH4RS65FTR4JDJPBHTABYJZAC

Dependencies

In channels

main

Change contents

Replacement in lib/lib.js at line 702 [3.3734883]

B:BD[3.3771697] → [4.1710:1829]

const string_job_decide = function(ns, string_server_target, float_server_target_security, float_server_target_cash) {

[3.3771697]

[3.3771878]

const string_job_decider_prepare = function(ns, string_server_target, float_server_target_security, float_server_target_cash) {
  if (float_server_target_security > ns.getServerMinSecurityLevel(string_server_target)) {
    return "weaken";
  }
  if (float_server_target_cash < ns.getServerMaxMoney(string_server_target)) {
    return "grow";
  }
  return "";
};
const string_job_decider = function(ns, string_server_target, float_server_target_security, float_server_target_cash) {

Deletion in lib/lib.js at line 768 [3.3734883]

B:BD[5.7945] → [6.1576:1787]

B:BD[6.1853] → [6.1853:3730]

B:BD[6.3730] → [7.2874:2996]

∅:D[7.2996] → [6.3849:5277]

B:BD[6.3849] → [6.3849:5277]

};
// weakens the target server. should be finished running before running main schedule
const array_make_schedule_weaken = function(ns, integer_job_cap, float_padding_seconds, string_server_target_argument) {
  const object_scripts = object_get_constants(ns).object_scripts;
  const array_servers_rooted_sorted_by_ram = array_get_servers_rooted_sorted_by_ram(ns);
  let string_server_target = string_server_target_argument;
  if (string_server_target_argument === null) {
    string_server_target = string_get_server_rooted_hackable_with_score_biggest(ns);
  }
  const float_server_target_security_minimum = ns.getServerMinSecurityLevel(string_server_target);
  const float_time_weaken = float_get_time_weaken(ns, string_server_target, ns.getServerSecurityLevel(string_server_target));
  let float_server_target_security_current = ns.getServerSecurityLevel(string_server_target);
  let array_schedule_weaken = [];
  let integer_array_schedule_weaken_length = 0;
  // assumes weaken takes longest
  let integer_time_job_finishes_seconds = float_time_weaken;
  // iterate through servers in reverse to use servers with the biggest rams first
  for (let integer_indices_0 = array_servers_rooted_sorted_by_ram.length - 1; integer_indices_0 >= 0; --integer_indices_0) {
    if (float_server_target_security_current <= float_server_target_security_minimum ||
      integer_array_schedule_weaken_length >= integer_job_cap) {
      break;
    }
    const string_server_used = array_servers_rooted_sorted_by_ram[integer_indices_0];
    let float_server_used_ram_free_current = float_get_server_ram_free(ns, string_server_used);
    while (
      float_server_target_security_current > float_server_target_security_minimum &&
      float_server_used_ram_free_current > 0 &&
      integer_array_schedule_weaken_length < integer_job_cap
    ) {
      let schedule_item = {
        string_job: "weaken",
        string_server_used: string_server_used,
        string_server_target: string_server_target,
        float_server_target_security_before: float_server_target_security_current
      };
      if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.weaken.ram, 1)) {
        // ram of the currently used server isn't actually 0, we're just doing this to skip it and start using a server with more ram
        float_server_used_ram_free_current = 0;
        break;
      }
      const integer_threads_weaken = integer_get_threads_weaken(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current);
      float_server_used_ram_free_current -= integer_threads_weaken * object_scripts.weaken.ram;
      
      const float_server_target_security_uncorrected = float_server_target_security_current - float_get_security_decrease_from_weaken(ns, integer_threads_weaken);
      if (float_server_target_security_uncorrected < float_server_target_security_minimum) {
        float_server_target_security_current = float_server_target_security_minimum;
      }
      else {
        float_server_target_security_current = float_server_target_security_uncorrected;
      }
      schedule_item.float_delay_seconds = integer_time_job_finishes_seconds - float_time_weaken + float_padding_seconds;
      integer_time_job_finishes_seconds += float_padding_seconds;
      schedule_item.integer_time_job_finishes_seconds = integer_time_job_finishes_seconds;
      schedule_item.integer_threads = integer_threads_weaken;
      array_schedule_weaken.push(schedule_item);
      ++integer_array_schedule_weaken_length;
      break;
    }
  }
  return array_schedule_weaken;

Replacement in lib/lib.js at line 770 [3.3734883]

B:BD[3.3774474] → [6.5278:5338]

∅:D[6.5338] → [4.1886:2034]

B:BD[3.3774474] → [4.1886:2034]

// makes the actual weakening, growing and hacking schedule
const array_make_schedule = function(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target_argument) {

[3.3774474]

[3.3774634]

// makes a schedule
const array_make_schedule = function(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target_argument, string_decider) {

Insertion in lib/lib.js at line 785 [3.3734883]

[3.3775472]

  // tripwires
  let boolean_end_loop_array_servers = false;
  let boolean_end_loop_server = false;

Replacement in lib/lib.js at line 799 [3.3734883]

B:BD[5.8317] → [4.2097:2157]

    if (integer_array_schedule_length >= integer_job_cap) {

[5.8317]

[5.8380]

    if (integer_array_schedule_length >= integer_job_cap ||
      boolean_end_loop_array_servers) {

Replacement in lib/lib.js at line 808 [3.3734883]

B:BD[5.8460] → [4.2158:2212]

      integer_array_schedule_length < integer_job_cap

[5.8460]

[5.8517]

      integer_array_schedule_length < integer_job_cap &&
      !boolean_end_loop_array_servers &&
      !boolean_end_loop_server

Replacement in lib/lib.js at line 812 [3.3734883]

B:BD[5.8525] → [4.2213:2355]

∅:D[4.2355] → [3.3776288:3776316]

B:BD[3.3776288] → [3.3776288:3776316]

      const string_job = string_job_decide(ns, string_server_target, float_server_target_security_current, float_server_target_cash_current);
      let schedule_item = {

[5.8525]

[4.2356]

      const string_job = string_decider(ns, string_server_target, float_server_target_security_current, float_server_target_cash_current);
      const schedule_item = {

Insertion in lib/lib.js at line 821 [3.3734883]

[4.2417]

[3.3776730]

        case "": {
          boolean_end_loop_array_servers = true;
          break;
        }

Replacement in lib/lib.js at line 828 [3.3734883]

∅:D[7.3123] → [3.3776878:3777068]

B:BD[3.3776878] → [3.3776878:3777068]

            // ram of the currently used server isn't actually 0, we're just doing this to skip it and start using a server with more ram
            float_server_used_ram_free_current = 0;

[7.3123]

[3.3777068]

            // start using a server with more ram
            boolean_end_loop_server = true;

Insertion in lib/lib.js at line 844 [3.3734883]

[3.3777861]


          schedule_item.float_server_target_security_current = float_server_target_security_current;

Replacement in lib/lib.js at line 861 [3.3734883]

∅:D[7.3248] → [3.3778961:3779151]

B:BD[3.3778961] → [3.3778961:3779151]

            // ram of the currently used server isn't actually 0, we're just doing this to skip it and start using a server with more ram
            float_server_used_ram_free_current = 0;

[7.3248]

[3.3779151]

            // start using a server with more ram
            boolean_end_loop_server = true;

Insertion in lib/lib.js at line 881 [3.3734883]

[3.3780240]

[4.2711]

          schedule_item.float_server_target_security_current = float_server_target_security_current;

Replacement in lib/lib.js at line 897 [3.3734883]

∅:D[7.3373] → [3.3781559:3781749]

B:BD[3.3781559] → [3.3781559:3781749]

            // ram of the currently used server isn't actually 0, we're just doing this to skip it and start using a server with more ram
            float_server_used_ram_free_current = 0;

[7.3373]

[3.3781749]

            // start using a server with more ram
            boolean_end_loop_server = true;

Insertion in lib/lib.js at line 918 [3.3734883]

[5.10917]

[3.3783068]


          schedule_item.float_server_target_security_current = float_server_target_security_current;

Replacement in lib/lib.js at line 940 [3.3734883]

∅:D[7.3900] → [6.5983:6055]

B:BD[6.5983] → [6.5983:6055]

      if (boolean_have_not_seen_item_with_security_minimum === false) {

[7.3900]

[6.6055]

      if (!boolean_have_not_seen_item_with_security_minimum) {

Replacement in lib/lib.js at line 944 [3.3734883]

∅:D[7.3968] → [6.6138:6239]

B:BD[6.6138] → [6.6138:6239]

      if (object_job.float_server_target_security_before === float_server_target_security_minimum) {

[7.3968]

[6.6239]

      if (object_job.float_server_target_security_current === float_server_target_security_minimum) {

Deletion in lib/lib.js at line 946 [3.3734883]
B:BD[6.6305] → [7.3969:4029]
```
        array_schedule_edited.splice(integer_indices_1, 1);
```

Insertion in lib/lib.js at line 979 [3.3734883]

[3.3785513]

const void_schedule_runner = async function(ns, array_schedule) {
  for (let integer_indices_0 = 0; integer_indices_0 < array_schedule.length; ++integer_indices_0) {
    switch (array_schedule[integer_indices_0].string_job) {
      case "weaken": {
        await void_exec_script_weaken(ns, array_schedule[integer_indices_0].string_server_used, array_schedule[integer_indices_0].string_server_target, array_schedule[integer_indices_0].integer_threads, array_schedule[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
        break;
      }
      case "grow": {
        await void_exec_script_grow(ns, array_schedule[integer_indices_0].string_server_used, array_schedule[integer_indices_0].string_server_target, array_schedule[integer_indices_0].integer_threads, array_schedule[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
        break;
      }
      case "hack": {
        await void_exec_script_hack(ns, array_schedule[integer_indices_0].string_server_used, array_schedule[integer_indices_0].string_server_target, array_schedule[integer_indices_0].integer_threads, array_schedule[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
        break;
      }
    }
  }
};

Replacement in lib/lib.js at line 998 [3.3734883]

B:BD[3.3785514] → [3.3785514:3785593]

B:BD[3.3785593] → [4.3293:3474]

// schedule runner. returns the the time it'll take to finish in milliseconds.
export const void_schedule_runner = async function(ns, string_servers_bought_name, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target) {

[3.3785514]

[3.3785788]

// returns the the time it'll take to finish in milliseconds.
export const void_runner = async function(ns, string_servers_bought_name, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target) {

Replacement in lib/lib.js at line 1013 [3.3734883]

B:BD[8.2824] → [6.6466:7136]

  // weaken target if necessary to reduce the time it takes to finish later jobs
  const array_schedule_weaken = array_make_schedule_weaken(ns, integer_job_cap, float_padding_seconds, string_server_target);
  if (array_schedule_weaken.length >= 1) {
    for (let integer_indices_0 = 0; integer_indices_0 < array_schedule_weaken.length; ++integer_indices_0) {
      await void_exec_script_weaken(ns, array_schedule_weaken[integer_indices_0].string_server_used, array_schedule_weaken[integer_indices_0].string_server_target, array_schedule_weaken[integer_indices_0].integer_threads, array_schedule_weaken[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);

[8.2824]

[6.7136]

  // prepare the target if necessary
  while (true) {
    if (
      ns.getServerSecurityLevel(string_server_target) === ns.getServerMinSecurityLevel(string_server_target) &&
      ns.getServerMoneyAvailable(string_server_target) === ns.getServerMaxMoney(string_server_target)
    ) {

Replacement in lib/lib.js at line 1021 [3.3734883]

B:BD[6.7155] → [6.7155:7311]

∅:D[6.7311] → [4.3475:3621]

B:BD[8.2824] → [4.3475:3621]

∅:D[9.2260] → [3.3786731:3786831]

∅:D[4.3621] → [3.3786731:3786831]

∅:D[5.11279] → [3.3786731:3786831]

B:BD[3.3786731] → [3.3786731:3786831]

B:BD[3.3786831] → [4.3622:3682]

∅:D[4.3682] → [3.3786894:3787879]

B:BD[3.3786894] → [3.3786894:3787879]

    await ns.sleep(array_schedule_weaken[array_schedule_weaken.length - 1].integer_time_job_finishes_seconds * 1000);
  }
  // make and run actual schedule
  const array_schedule = array_make_schedule(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target);
  for (let integer_indices_0 = 0; integer_indices_0 < array_schedule.length; ++integer_indices_0) {
    switch (array_schedule[integer_indices_0].string_job) {
      case "weaken": {
        await void_exec_script_weaken(ns, array_schedule[integer_indices_0].string_server_used, array_schedule[integer_indices_0].string_server_target, array_schedule[integer_indices_0].integer_threads, array_schedule[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
        break;
      }
      case "grow": {
        await void_exec_script_grow(ns, array_schedule[integer_indices_0].string_server_used, array_schedule[integer_indices_0].string_server_target, array_schedule[integer_indices_0].integer_threads, array_schedule[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
        break;
      }
      case "hack": {
        await void_exec_script_hack(ns, array_schedule[integer_indices_0].string_server_used, array_schedule[integer_indices_0].string_server_target, array_schedule[integer_indices_0].integer_threads, array_schedule[integer_indices_0].float_delay_seconds * 1000, integer_indices_0);
        break;
      }

[6.7155]

[3.3787879]

    const array_schedule_prepare = array_make_schedule(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target, string_job_decider_prepare);
    if (array_schedule_prepare.length > 0) {
      await void_schedule_runner(ns, array_schedule_prepare);
      await ns.sleep(array_schedule_prepare[array_schedule_prepare.length - 1].integer_time_job_finishes_seconds * 1000);

Insertion in lib/lib.js at line 1027 [3.3734883]

[3.3787889]

[4.3683]

  // make and run actual hacking schedule
  const array_schedule = array_make_schedule(ns, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target, string_job_decider);
  await void_schedule_runner(ns, array_schedule);

Replacement in bin/main.js at line 5 [3.3793719]
B:BD[3.3793740] → [3.3793740:3793763]
```
  void_schedule_runner
```
[3.3793740]
[3.3793763]
```
  void_runner
```

Replacement in bin/main.js at line 79 [3.3793719]

B:BD[3.3794595] → [4.4012:4211]

      integer_time_finishes = await void_schedule_runner(ns, string_servers_bought_name, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target) + Date.now();

[3.3794595]

[3.3794956]

      integer_time_finishes = await void_runner(ns, string_servers_bought_name, integer_job_cap, float_precision, float_steal_cap, float_padding_seconds, string_server_target) + Date.now();

Replacement in README.md at line 32 [3.3873298]

B:BD[2.3750] → [2.3750:4035]

  * SERVER = The server that should be targetted by the `weaken`, `grow` and `hack` functions. Should be a string. Defaults to choosing an optimal target using a scroing system based on the server's maximum cash, growth, required hacking level, and the player's current hacking level.

[2.3750]

[2.4035]

  * SERVER = The server that should be targetted by the `weaken`, `grow` and `hack` functions. Should be a string. Defaults to choosing an optimal target using a scoring system based on the server's maximum cash, growth, required hacking level, and the player's current hacking level.

Replacement in README.md at line 57 [3.3873298]

B:BD[2.4989] → [2.4989:5163]

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

[2.4989]

[2.5163]

  * 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.

Replacement in README.md at line 73 [3.3873298]

B:BD[2.5443] → [2.5443:5546]

  * Kills all scripts named `grow.js` and `hack.js` on any servers that they are currently running on.

[2.5443]

[2.5546]

  * Kills all scripts named "grow.js" and "hack.js" on any servers that they are currently running on.