IsaacShoebottom/Bitburner-Scripts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: IsaacShoebottom:22ddbbde5df5646f30f8e51d41e89467464ebce9
Branches Tags
IsaacShoebottom:master
..
compare: IsaacShoebottom:b40c4d07e8afabcc7dc7bf027324eda18f1f1fec
Branches Tags
IsaacShoebottom:master

No commits in common. "22ddbbde5df5646f30f8e51d41e89467464ebce9" and "b40c4d07e8afabcc7dc7bf027324eda18f1f1fec" have entirely different histories.
22ddbbde5d ... b40c4d07e8

10 changed files with 308 additions and 519 deletions
Show Stats Expand all files Collapse all files

10
.editorconfig
View File

@ -1,10 +0,0 @@
# All files
[*]
end_of_line = lf
insert_final_newline = true
indent_style = tab
indent_size = 2
# Markup files
[*.{json,yml}]
indent_style = space

215
.gitattributes vendored
View File

@ -1,215 +0,0 @@
## GITATTRIBUTES FOR WEB PROJECTS
#
# These settings are for any web project.
#
# Details per file setting:
# text These files should be normalized (i.e. convert CRLF to LF).
# binary These files are binary and should be left untouched.
#
# Note that binary is a macro for -text -diff.
######################################################################
# Auto detect
## Handle line endings automatically for files detected as
## text and leave all files detected as binary untouched.
## This will handle all files NOT defined below.
* text=auto
# Source code
*.bash text eol=lf
*.bat text eol=crlf
*.cmd text eol=crlf
*.coffee text
*.css text diff=css
*.htm text diff=html
*.html text diff=html
*.inc text
*.ini text
*.js text
*.json text
*.jsx text
*.less text
*.ls text
*.map text -diff
*.od text
*.onlydata text
*.php text diff=php
*.pl text
*.ps1 text eol=crlf
*.py text diff=python
*.rb text diff=ruby
*.sass text
*.scm text
*.scss text diff=css
*.sh text eol=lf
.husky/* text eol=lf
*.sql text
*.styl text
*.tag text
*.ts text
*.tsx text
*.xml text
*.xhtml text diff=html
# Docker
Dockerfile text
# Documentation
*.ipynb text eol=lf
*.markdown text diff=markdown
*.md text diff=markdown
*.mdwn text diff=markdown
*.mdown text diff=markdown
*.mkd text diff=markdown
*.mkdn text diff=markdown
*.mdtxt text
*.mdtext text
*.txt text
AUTHORS text
CHANGELOG text
CHANGES text
CONTRIBUTING text
COPYING text
copyright text
*COPYRIGHT* text
INSTALL text
license text
LICENSE text
NEWS text
readme text
*README* text
TODO text
# Templates
*.dot text
*.ejs text
*.erb text
*.haml text
*.handlebars text
*.hbs text
*.hbt text
*.jade text
*.latte text
*.mustache text
*.njk text
*.phtml text
*.svelte text
*.tmpl text
*.tpl text
*.twig text
*.vue text
# Configs
*.cnf text
*.conf text
*.config text
.editorconfig text
.env text
.gitattributes text
.gitconfig text
.htaccess text
*.lock text -diff
package.json text eol=lf
package-lock.json text eol=lf -diff
pnpm-lock.yaml text eol=lf -diff
.prettierrc text
yarn.lock text -diff
*.toml text
*.yaml text
*.yml text
browserslist text
Makefile text
makefile text
# Fixes syntax highlighting on GitHub to allow comments
tsconfig.json linguist-language=JSON-with-Comments
# Heroku
Procfile text
# Graphics
*.ai binary
*.bmp binary
*.eps binary
*.gif binary
*.gifv binary
*.ico binary
*.jng binary
*.jp2 binary
*.jpg binary
*.jpeg binary
*.jpx binary
*.jxr binary
*.pdf binary
*.png binary
*.psb binary
*.psd binary
# SVG treated as an asset (binary) by default.
*.svg text
# If you want to treat it as binary,
# use the following line instead.
# *.svg binary
*.svgz binary
*.tif binary
*.tiff binary
*.wbmp binary
*.webp binary
# Audio
*.kar binary
*.m4a binary
*.mid binary
*.midi binary
*.mp3 binary
*.ogg binary
*.ra binary
# Video
*.3gpp binary
*.3gp binary
*.as binary
*.asf binary
*.asx binary
*.avi binary
*.fla binary
*.flv binary
*.m4v binary
*.mng binary
*.mov binary
*.mp4 binary
*.mpeg binary
*.mpg binary
*.ogv binary
*.swc binary
*.swf binary
*.webm binary
# Archives
*.7z binary
*.gz binary
*.jar binary
*.rar binary
*.tar binary
*.zip binary
# Fonts
*.ttf binary
*.eot binary
*.otf binary
*.woff binary
*.woff2 binary
# Executables
*.exe binary
*.pyc binary
# Prevents massive diffs caused by vendored, minified files
**/.yarn/releases/** binary
**/.yarn/plugins/** binary
# RC files (like .babelrc or .eslintrc)
*.*rc text
# Ignore files (like .npmignore or .gitignore)
*.*ignore text
# Prevents massive diffs from built files
dist/* binary

5
.idea/codeStyles/codeStyleConfig.xml generated
View File

@ -1,5 +0,0 @@
<component name="ProjectCodeStyleConfiguration">
<state>
<option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
</state>
</component>

8
servers/home/autoexec.ts
View File

@ -1,4 +1,4 @@
export async function main(ns: NS) { export async function main(ns: NS) {
ns.run('watcher.js') ns.run("watcher.js")
ns.run('hacknet.js') ns.run("hacknet.js")
} }

33
servers/home/hack.ts
View File

@ -1,10 +1,23 @@
export async function main(ns: NS) { export async function main(ns: NS) {
const server: string = <string> ns.args[0] const server: string = <string>ns.args[0];
while (true) { while (true) {
// Guide https://darktechnomancer.github.io/#glossary-of-terms /* This code checks conditions that are not needed with smart scheduling
await ns.weaken(server) const moneyThresh: number = <number>ns.args[1];
await ns.grow(server) const securityThresh: number = <number>ns.args[2];
await ns.weaken(server) if (ns.getServerSecurityLevel(server) > securityThresh) {
await ns.hack(server) await ns.weaken(server);
} } else if (ns.getServerMoneyAvailable(server) < moneyThresh) {
} await ns.grow(server);
} else {
await ns.hack(server);
}
*/
// Guide
// https://darktechnomancer.github.io/#glossary-of-terms
await ns.weaken(server);
await ns.grow(server);
await ns.weaken(server);
await ns.hack(server);
}
}

26
servers/home/hackallservers.ts
View File

@ -1,11 +1,15 @@
import { executeScriptOnServerFromAnother, recursiveScan } from './utils' import {recursiveScan} from "./utils";
import {executeScriptOnServerFromAnother} from "./utils";
export async function main(ns: NS) { export async function main(ns: NS) {
let servers: string[] = recursiveScan(ns) let servers: string[] = recursiveScan(ns);
for (const server of servers) { for (const server of servers) {
let numThreads = ns.getServerMaxRam(server) / ns.getScriptRam('hack.js') // Commented out code is not needed with smart scheduling
numThreads = Math.floor(numThreads) //let moneyThresh = ns.getServerMaxMoney(server) * 0.75;
executeScriptOnServerFromAnother(ns, server, 'hack.js', numThreads, [server]) //let securityThresh = ns.getServerMinSecurityLevel(server) + 5;
} let numThreads = ns.getServerMaxRam(server) / ns.getScriptRam("hack.js")
} numThreads = Math.floor(numThreads);
//executeScriptOnServerFromAnother(ns, server, "hack.js", numThreads, [server, moneyThresh, securityThresh])
executeScriptOnServerFromAnother(ns, server, "hack.js", numThreads, [server])
}
}

203
servers/home/hacknet.ts
View File

@ -1,100 +1,103 @@
/* /*
* TODO: * TODO:
* The current solution is not optimal, as it's preferable to buy new nodes, even if upgrading is cheaper. * The current solution is not optimal, as it's preferable to buy new nodes, even if upgrading is cheaper.
* TODO: * TODO:
* It may be helpful to calculate the money per second of each node on average, (total mps / total nodes) and compare * It may be helpful to calculate the money per second of each node on average, (total mps / total nodes) and compare
* it to the time it would take to purchase the next cheapest upgrade, and if the average mps is greater than the * it to the time it would take to purchase the next cheapest upgrade, and if the average mps is greater than the
* negative mps of the upgrade cost, then buy a new node. * negative mps of the upgrade cost, then buy a new node.
* TODO: * TODO:
* Potential Ideas: * Potential Ideas:
* Find a way to calculate how much mps an individual upgrade would give, and compare it to the average mps of the node. * Find a way to calculate how much mps an individual upgrade would give, and compare it to the average mps of the node.
* ns.hacknet.getNodeStats(0).production * ns.hacknet.getNodeStats(0).production
* If the upgrade mps is greater than the average mps, then buy the upgrade. * If the upgrade mps is greater than the average mps, then buy the upgrade.
* If the upgrade mps is less than the average mps, then buy a new node. * If the upgrade mps is less than the average mps, then buy a new node.
*/ */
enum Type { enum Type {
newNode = 'node', level = 'level', ram = 'ram', core = 'code', newNode = "node",
} level = "level",
ram = "ram",
export async function main(ns: NS) { core = "code"
let timeout: number = <number> ns.args[0] }
let nodes = ns.hacknet.numNodes() export async function main(ns: NS) {
let costs: { type: Type, cost: number }[] = [] let timeout: number = <number>ns.args[0]
while (true) {
costs = [] let nodes = ns.hacknet.numNodes()
// Go through each node and get the cheapest upgrade let costs: {type: Type, cost: number}[] = []
for (let i = 0; i < nodes; i++) { while (true) {
costs.push(getCheapestCost(ns, i)) costs = []
} // Go through each node and get the cheapest upgrade
// Buy the cheapest upgrade from all nodes for (let i = 0; i < nodes; i++) {
let cheapest = Math.min(...costs.map(c => c.cost)) costs.push(getCheapestCost(ns, i))
// Find the index of the cheapest cost in the list }
let index = costs.findIndex(c => c.cost === cheapest) // Buy the cheapest upgrade from all nodes
// Wait to buy the cheapest upgrade let cheapest = Math.min(...costs.map(c => c.cost))
try { // Find the index of the cheapest cost in the list
await buy(ns, costs[index].type, costs[index].cost, index, timeout) let index = costs.findIndex(c => c.cost === cheapest)
} catch (e) { // Wait to buy the cheapest upgrade
ns.tprint(e) try {
ns.exit() await buy(ns, costs[index].type, costs[index].cost, index, timeout)
} } catch (e) {
// Make sure that the number of nodes is up-to-date ns.tprint(e)
nodes = ns.hacknet.numNodes() ns.exit()
} }
} // Make sure that the number of nodes is up-to-date
nodes = ns.hacknet.numNodes()
/** }
* Wait until the player has enough money to buy something }
* @param ns Global NS object
* @param money Amount of money to wait for /**
* @param timeout=-1 Number of seconds to wait before timing out. * Wait until the player has enough money to buy something
* @throws Error if the timeout is reached * @param ns Global NS object
* @note This function will wait forever by default * @param money Amount of money to wait for
*/ * @param timeout=-1 Number of seconds to wait before timing out.
async function waitUntilMoney(ns: NS, money: number, timeout: number = -1) { * @throws Error if the timeout is reached
while (ns.getServerMoneyAvailable('home') < money) { * @note This function will wait forever by default
await ns.sleep(1000) */
if (timeout == 0) { async function waitUntilMoney(ns: NS, money: number, timeout: number = -1) {
throw new Error('Timed out waiting for money') while (ns.getServerMoneyAvailable("home") < money) {
} else if (timeout > -1) { await ns.sleep(1000)
timeout-- if (timeout == 0) {
} throw new Error("Timed out waiting for money")
} } else if (timeout > -1) {
} timeout--;
}
async function buy(ns: NS, type: Type, cost: number, node: number, timeout: number) { }
await waitUntilMoney(ns, cost, timeout) }
switch (type) {
case Type.newNode: async function buy(ns: NS, type: Type, cost: number, node: number, timeout: number) {
ns.hacknet.purchaseNode() await waitUntilMoney(ns, cost, timeout)
break switch (type) {
case Type.level: case Type.newNode:
ns.hacknet.upgradeLevel(node) ns.hacknet.purchaseNode()
break break
case Type.ram: case Type.level:
ns.hacknet.upgradeRam(node) ns.hacknet.upgradeLevel(node)
break break
case Type.core: case Type.ram:
ns.hacknet.upgradeCore(node) ns.hacknet.upgradeRam(node)
break break
} case Type.core:
} ns.hacknet.upgradeCore(node)
break
function getCheapestCost(ns: NS, node: number) { }
let nodeCost = ns.hacknet.getPurchaseNodeCost() }
let levelCost = ns.hacknet.getLevelUpgradeCost(node)
let ramCost = ns.hacknet.getRamUpgradeCost(node) function getCheapestCost(ns: NS, node: number) {
let coreCost = ns.hacknet.getCoreUpgradeCost(node) let nodeCost = ns.hacknet.getPurchaseNodeCost()
let cheapest = Math.min(nodeCost, levelCost, ramCost, coreCost) let levelCost = ns.hacknet.getLevelUpgradeCost(node)
switch (cheapest) { let ramCost = ns.hacknet.getRamUpgradeCost(node)
case nodeCost: let coreCost = ns.hacknet.getCoreUpgradeCost(node)
return { type: Type.newNode, cost: nodeCost } let cheapest = Math.min(nodeCost, levelCost, ramCost, coreCost)
case levelCost: switch (cheapest) {
return { type: Type.level, cost: levelCost } case nodeCost:
case ramCost: return {type: Type.newNode, cost: nodeCost}
return { type: Type.ram, cost: ramCost } case levelCost:
case coreCost: return {type: Type.level, cost: levelCost}
return { type: Type.core, cost: coreCost } case ramCost:
} return {type: Type.ram, cost: ramCost}
} case coreCost:
return {type: Type.core, cost: coreCost}
}
}

15
servers/home/killall.ts
View File

@ -1,8 +1,7 @@
import { recursiveScan } from './utils' import {recursiveScan} from "./utils";
export async function main(ns: NS) {
export async function main(ns: NS) { let servers: string[] = recursiveScan(ns)
let servers: string[] = recursiveScan(ns) for (const server of servers) {
for (const server of servers) { ns.killall(server)
ns.killall(server) }
} }
}

281
servers/home/utils.ts
View File

@ -1,140 +1,141 @@
// noinspection JSUnusedGlobalSymbols // noinspection JSUnusedGlobalSymbols
/**
/** * Recursively scans all servers connected to the current server, excluding home
* Recursively scans all servers connected to the current server, excluding home * @param ns global NS object
* @param ns global NS object * @returns A list of all servers connected to the current server
* @returns A list of all servers connected to the current server */
*/ export function recursiveScan(ns: NS) {
export function recursiveScan(ns: NS) { // Starting case
// Starting case let servers = ns.scan("home");
let servers = ns.scan('home') // Add all servers to the list
// Add all servers to the list let allServers: string[] = [];
let allServers: string[] = [] while (servers.length > 0) {
while (servers.length > 0) { let server = servers.shift();
let server = servers.shift() if(server) {
if (server) { let newServers = ns.scan(server);
let newServers = ns.scan(server) for (let newServer of newServers) {
for (let newServer of newServers) { if (!allServers.includes(newServer)) {
if (!allServers.includes(newServer)) { allServers.push(newServer);
allServers.push(newServer) servers.push(newServer);
servers.push(newServer) }
} }
} }
} }
} // Remove the current server
// Remove the current server allServers.splice(allServers.indexOf("home"), 1);
allServers.splice(allServers.indexOf('home'), 1) // Print all servers
// Print all servers return allServers;
return allServers }
}
/**
/** * Removes files passed in from all servers
* Removes files passed in from all servers * @param ns Global NS object
* @param ns Global NS object * @param files The files to remove
* @param files The files to remove * @returns void
* @returns void * @example Removes all files from the folder "no-ports" from all servers.
* @example Removes all files from the folder "no-ports" from all servers. * removeFilesOnAllServers(ns, ns.ls("home", "no-ports"));
* removeFilesOnAllServers(ns, ns.ls("home", "no-ports")); * @note ns.ls() returns the full path of every file, so if the file is not in the same place in every server,
* @note ns.ls() returns the full path of every file, so if the file is not in the same place in every server, * you will need to modify each file path to match the server you are removing it from.
* you will need to modify each file path to match the server you are removing it from. */
*/ export function removeFilesOnAllServers(ns: NS, files: string[]) {
export function removeFilesOnAllServers(ns: NS, files: string[]) { let hosts = recursiveScan(ns);
let hosts = recursiveScan(ns) for(const host of hosts) {
for (const host of hosts) { for (const file of files) {
for (const file of files) { ns.rm(file, host)
ns.rm(file, host) }
} }
} }
}
/**
/** * Tries to gain root access to a server
* Tries to gain root access to a server * @param ns Global NS object
* @param ns Global NS object * @param server The server to gain root access to
* @param server The server to gain root access to * @returns The number of programs used to gain root access
* @returns The number of programs used to gain root access */
*/ export function rootServer(ns: NS, server: string) {
export function rootServer(ns: NS, server: string) { let counter = 0;
let counter = 0 if (ns.fileExists("BruteSSH.exe", "home")) {
if (ns.fileExists('BruteSSH.exe', 'home')) { ns.brutessh(server);
ns.brutessh(server) counter++;
counter++ }
} if (ns.fileExists("FTPCrack.exe", "home")) {
if (ns.fileExists('FTPCrack.exe', 'home')) { ns.ftpcrack(server);
ns.ftpcrack(server) counter++;
counter++ }
} if (ns.fileExists("SMTPCrack.exe", "home")) {
if (ns.fileExists('SMTPCrack.exe', 'home')) { ns.relaysmtp(server);
ns.relaysmtp(server) counter++;
counter++ }
} if (ns.fileExists("HTTPWorm.exe", "home")) {
if (ns.fileExists('HTTPWorm.exe', 'home')) { ns.httpworm(server);
ns.httpworm(server) counter++;
counter++ }
} if (ns.fileExists("SQLInject.exe", "home")) {
if (ns.fileExists('SQLInject.exe', 'home')) { ns.sqlinject(server);
ns.sqlinject(server) counter++;
counter++ }
} ns.nuke(server)
ns.nuke(server) return counter;
return counter }
}
/**
/** * Performs a function on a server if the player is capable of doing so, otherwise returns false
* Performs a function on a server if the player is capable of doing so, otherwise returns false * @param ns Global NS object
* @param ns Global NS object * @param server The server to perform the function on
* @param server The server to perform the function on * @param func The function to perform
* @param func The function to perform * @param args The arguments to pass to the function
* @param args The arguments to pass to the function * @returns The result of the function if it is performed or true if the function does not return anything, otherwise false
* @returns The result of the function if it is performed or true if the function does not return anything, otherwise false */
*/ export function performFunctionIfCapable(ns: NS, server: string, func: CallableFunction, args: any[]) {
export function performFunctionIfCapable(ns: NS, server: string, func: CallableFunction, args: any[]) { if (ns.getHackingLevel() < ns.getServerRequiredHackingLevel(server)) {
if (ns.getHackingLevel() < ns.getServerRequiredHackingLevel(server)) { return false;
return false }
} if (ns.getServerNumPortsRequired(server) < ns.getServer(server).openPortCount) {
if (ns.getServerNumPortsRequired(server) < ns.getServer(server).openPortCount) { if (rootServer(ns, server) < ns.getServerNumPortsRequired(server)) {
if (rootServer(ns, server) < ns.getServerNumPortsRequired(server)) { return false;
return false }
} }
} if (!ns.hasRootAccess(server)) {
if (!ns.hasRootAccess(server)) { return false;
return false
}
} let result = func(...args);
let result = func(...args) if (result === undefined) {
if (result === undefined) { return true;
return true } else {
} else { return result;
return result }
} }
}
/**
/** * Executes a script on a server from another server
* Executes a script on a server from another server * @param ns Global NS object
* @param ns Global NS object * @param server The server to execute the script on
* @param server The server to execute the script on * @param script The file path of the script to execute
* @param script The file path of the script to execute * @param threads The number of threads to use
* @param threads The number of threads to use * @param args The arguments to pass to the script
* @param args The arguments to pass to the script */
*/ export function executeScriptOnServerFromAnother(ns: NS, server: string, script: string, threads: number = 1, args: any[]) {
export function executeScriptOnServerFromAnother(ns: NS, server: string, script: string, threads: number = 1, args: any[]) { ns.scp(script, server);
ns.scp(script, server) performFunctionIfCapable(ns, server, ns.exec, [script, server, threads, ...args])
performFunctionIfCapable(ns, server, ns.exec, [script, server, threads, ...args]) ns.atExit(
ns.atExit(() => { () => {
ns.rm(script, server) ns.rm(script, server);
}) }
} )
}
/**
* Calculates the money per second the player is making /**
* @param ns Global NS object * Calculates the money per second the player is making
* @param time=5 The number of seconds to calculate the MPS over * @param ns Global NS object
*/ * @param time=5 The number of seconds to calculate the MPS over
export async function calculateMPS(ns: NS, time: number = 5) { */
let start = ns.getServerMoneyAvailable('home') export async function calculateMPS(ns: NS, time: number = 5) {
let data: number[] = [] let start = ns.getServerMoneyAvailable("home");
for (let i = 0; i < time; i++) { let data: number[] = [];
await ns.sleep(1000) for (let i = 0; i < time; i++) {
data.push(ns.getServerMoneyAvailable('home') - start) await ns.sleep(1000);
} data.push(ns.getServerMoneyAvailable("home") - start);
return data.reduce((a, b) => a + b, 0) / time }
} return data.reduce((a, b) => a + b, 0) / time;
}

31
servers/home/watcher.ts
View File

@ -1,16 +1,15 @@
export async function main(ns: NS) { export async function main(ns: NS) {
ns.run('hackallservers.js') let hackingLevel = ns.getHackingLevel();
let hackingLevel = ns.getHackingLevel() while (hackingLevel < 9999) {
while (hackingLevel < 9999) { let oldHackingLevel = hackingLevel;
let oldHackingLevel = hackingLevel hackingLevel = ns.getHackingLevel();
hackingLevel = ns.getHackingLevel() if(oldHackingLevel !== hackingLevel) {
if (oldHackingLevel !== hackingLevel) { ns.tprint(`Hacking level increased from ${oldHackingLevel} to ${hackingLevel}`);
ns.tprint(`Hacking level increased from ${oldHackingLevel} to ${hackingLevel}`) ns.run("killall.js");
ns.run('killall.js') await ns.sleep(1000) // 1 second
await ns.sleep(1000) // 1 second ns.run("hackallservers.js");
ns.run('hackallservers.js') }
} // Wait 1 second before checking again
// Wait 1 second before checking again await ns.sleep(1000)
await ns.sleep(1000) }
} }
}