nicoty/bitburner_scripts - Change 2LU5Y77OWHXI4FV3YKELPYQSUOQGRSO7CXWPKUCQZ2WM5YUBZBRQC

fixed optimum percentage to steal calculator.

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

2LU5Y77OWHXI4FV3YKELPYQSUOQGRSO7CXWPKUCQZ2WM5YUBZBRQC

Dependencies

In channels

main

Change contents

Replacement in lib/lib.js at line 670 [5.3734883]

B:BD[4.3535] → [4.3535:3732]

∅:D[4.3732] → [6.5672:5751]

B:BD[6.5672] → [6.5672:5751]

const bool_is_ram_enough_after_hack_percentage = function(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_percentage_to_steal) {
  void_debug(bool_is_ram_enough_after_hack_percentage, Array.from(arguments));

[4.3535]

[4.3733]

const boolean_is_ram_enough_after_hack_percentage = function(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_percentage_to_steal) {
  void_debug(boolean_is_ram_enough_after_hack_percentage, Array.from(arguments));

Replacement in lib/lib.js at line 686 [5.3734883]

B:BD[4.5184] → [4.5184:5499]

  const float_ram_required = (integer_threads_required_for_weaken_minimum_security_after_hack * object_scripts.grow.weaken) + (integer_threads_required_for_cash_grow_after_percentage_stolen * object_scripts.grow.ram) + (integer_threads_required_for_weaken_minimum_security_after_grow * object_scripts.grow.weaken);

[4.5184]

[4.5499]

  const float_ram_required = (integer_threads_required_for_weaken_minimum_security_after_hack * object_scripts.weaken.ram) + (integer_threads_required_for_cash_grow_after_percentage_stolen * object_scripts.grow.ram) + (integer_threads_required_for_weaken_minimum_security_after_grow * object_scripts.weaken.ram);

Insertion in lib/lib.js at line 705 [5.3734883]

[5.3768838]

  const integer_cycles_for_bisection_precision = integer_get_cycles_for_bisection_precision(ns, float_precision);

Replacement in lib/lib.js at line 709 [5.3734883]

B:BD[5.3768957] → [7.2185:2327]

B:BD[7.2327] → [4.6203:6392]

  for (let integer_indices_0 = 0; integer_indices_0 < integer_get_cycles_for_bisection_precision(ns, float_precision); ++integer_indices_0) {
    if (bool_is_ram_enough_after_hack_percentage(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_percentage_to_steal)) {

[5.3768957]

[5.3769268]

  for (let integer_indices_0 = 0; integer_indices_0 < integer_cycles_for_bisection_precision; ++integer_indices_0) {
    if (boolean_is_ram_enough_after_hack_percentage(ns, float_server_used_ram_free, string_server_target, float_server_target_cash, float_server_target_security, float_percentage_to_steal)) {

Insertion in lib/lib.js at line 717 [5.3734883]

[5.3769456]

    if (float_percentage_to_steal > float_steal_cap) {
      break;
    }

Replacement in lib/lib.js at line 785 [5.3734883]

B:BD[5.3772157] → [5.3772157:3772351]

const bool_can_server_run_script_threads = function(ns, float_server_used_ram_free, float_script_ram, integer_threads) {
  void_debug(bool_can_server_run_script_threads, Array.from(arguments));

[5.3772157]

[5.3772351]

const boolean_can_server_run_script_threads = function(ns, float_server_used_ram_free, float_script_ram, integer_threads) {
  void_debug(boolean_can_server_run_script_threads, Array.from(arguments));

Replacement in lib/lib.js at line 873 [5.3734883]

B:BD[3.3730] → [3.3730:3849]

      if (!bool_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.weaken.ram, 1)) {

[3.3730]

[3.3849]

      if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.weaken.ram, 1)) {

Replacement in lib/lib.js at line 953 [5.3734883]

B:BD[5.3776755] → [5.3776755:3776878]

          if (!bool_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.weaken.ram, 1)) {

[5.3776755]

[5.3776878]

          if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.weaken.ram, 1)) {

Replacement in lib/lib.js at line 984 [5.3734883]

B:BD[5.3778840] → [5.3778840:3778961]

          if (!bool_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.grow.ram, 1)) {

[5.3778840]

[5.3778961]

          if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.grow.ram, 1)) {

Replacement in lib/lib.js at line 1018 [5.3734883]

B:BD[5.3781438] → [5.3781438:3781559]

          if (!bool_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.hack.ram, 1)) {

[5.3781438]

[5.3781559]

          if (!boolean_can_server_run_script_threads(ns, float_server_used_ram_free_current, object_scripts.hack.ram, 1)) {

Deletion in lib/lib.js at line 1023 [5.3734883]

B:BD[5.3781780] → [5.3781780:3781781]

B:BD[5.3781781] → [4.6561:7263]


          // // this is supposed to be the section that uses the `float_get_percentage_to_steal` function to calculate and hack the optimum amount of cash, but it doesn't seem to work properly and I still haven't figured why or how to fix it, so for now I think it just hacks whatever `float_steal_cap` percent of cash the server has.
          // const integer_threads_hack = integer_get_threads_hack(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current, float_get_percentage_to_steal(ns, float_server_used_ram_free_current, string_server_target, float_server_target_cash_current, float_server_target_security_current, float_precision, float_steal_cap));

Replacement in lib/lib.js at line 1024 [5.3734883]

B:BD[5.3782107] → [6.9808:9990]

          const integer_threads_hack = integer_get_threads_hack(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current, float_steal_cap);

[5.3782107]

[5.3782203]

          const integer_threads_hack = integer_get_threads_hack(ns, float_server_used_ram_free_current, string_server_target, float_server_target_security_current, float_get_percentage_to_steal(ns, float_server_used_ram_free_current, string_server_target, float_server_target_cash_current, float_server_target_security_current, float_precision, float_steal_cap));

Insertion in lib/lib.js at line 1056 [5.3734883]
[3.5752]
[3.5752]
```
  let array_schedule_edited = array_schedule;
```

Replacement in lib/lib.js at line 1059 [5.3734883]

B:BD[3.5876] → [3.5876:5983]

    for (let integer_indices_1 = array_schedule.length - 1; integer_indices_1 >= 0; --integer_indices_1) {

[3.5876]

[3.5983]

    for (let integer_indices_1 = array_schedule_edited.length - 1; integer_indices_1 >= 0; --integer_indices_1) {

Replacement in lib/lib.js at line 1063 [5.3734883]

B:BD[3.6078] → [3.6078:6138]

      const object_job = array_schedule[integer_indices_1];

[3.6078]

[3.6138]

      const object_job = array_schedule_edited[integer_indices_1];

Replacement in lib/lib.js at line 1066 [5.3734883]

B:BD[3.6305] → [3.6305:6358]

        array_schedule.splice(integer_indices_1, 1);

[3.6305]

[3.6358]

        array_schedule_edited.splice(integer_indices_1, 1);

Replacement in lib/lib.js at line 1070 [5.3734883]

B:BD[3.6394] → [3.6394:6447]

        array_schedule.splice(integer_indices_1, 1);

[3.6394]

[3.6447]

        array_schedule_edited.splice(integer_indices_1, 1);

Replacement in lib/lib.js at line 1074 [5.3734883]

∅:D[3.6465] → [6.10963:10988]

B:BD[6.10963] → [6.10963:10988]

  return array_schedule;

[3.6465]

[5.3784354]

  if (boolean_have_not_seen_item_with_security_minimum) {
    return array_schedule;
  }
  else {
    return array_schedule_edited;
  }

Replacement in bin/main.js at line 1 [5.3793719]

B:BD[5.3793719] → [2.2030:2481]

// TODO: Separate logic that can finish running (e.g. server buying logic which becomes redundant after 25 fully upgraded servers have been bought) to other sbins so that RAM usage is more efficient. Also separate logic that requires source files so that they are only ran when you have the required source file. Maybe make a cache script that saves runtime constants like max money of servers to a cache file to potentially reduce RAM usage further.

[5.3793719]

[2.2481]

// TODO: Separate logic that can finish running (e.g. server buying logic which becomes redundant after 25 fully upgraded servers have been bought) to other sbins so that RAM usage is more efficient. Also separate logic that requires source files so that they are only ran when you have the required source file. Maybe make a cache script that saves runtime constants like max money of servers to a cache file to potentially reduce RAM usage further. Maybe add functionality that allows on-the-fly hot loading of settings from a file.

Replacement in bin/main.js at line 16 [5.3793719]
B:BD[8.3934] → [8.3934:3971]
```
  const float_padding_seconds = 0.1;
```
[8.3934]
[6.11493]
```
  const float_padding_seconds = 0.4;
```
Replacement in bin/main.js at line 18 [5.3793719]
∅:D[6.11546] → [5.3794026:3794060]
B:BD[5.3794026] → [5.3794026:3794060]
```
  const float_precision = 0.0001;
```
[6.11546]
[6.11547]
```
  const float_precision = 0.001;
```
Replacement in bin/main.js at line 20 [5.3793719]
B:BD[6.11619] → [6.11619:11651]
```
  const float_steal_cap = 0.98;
```
[6.11619]
[6.11651]
```
  const float_steal_cap = 0.96;
```