import { ITerminal, Output, Link, RawOutput, TTimer } from "./ITerminal"; import { IRouter } from "../ui/Router"; import { IPlayer } from "../PersonObjects/IPlayer"; import { HacknetServer } from "../Hacknet/HacknetServer"; import { BaseServer } from "../Server/BaseServer"; import { Server } from "../Server/Server"; import { Programs } from "../Programs/Programs"; import { CodingContractResult } from "../CodingContracts"; import { TerminalEvents, TerminalClearEvents } from "./TerminalEvents"; import { TextFile } from "../TextFile"; import { Script } from "../Script/Script"; import { isScriptFilename } from "../Script/isScriptFilename"; import { CONSTANTS } from "../Constants"; import { GetServer, GetAllServers } from "../Server/AllServers"; import { removeLeadingSlash, isInRootDirectory, evaluateFilePath } from "./DirectoryHelpers"; import { checkIfConnectedToDarkweb } from "../DarkWeb/DarkWeb"; import { iTutorialNextStep, iTutorialSteps, ITutorial } from "../InteractiveTutorial"; import { getServerOnNetwork, processSingleServerGrowth } from "../Server/ServerHelpers"; import { ParseCommand, ParseCommands } from "./Parser"; import { SpecialServers } from "../Server/data/SpecialServers"; import { Settings } from "../Settings/Settings"; import { createProgressBarText } from "../utils/helpers/createProgressBarText"; import { calculateHackingChance, calculateHackingExpGain, calculatePercentMoneyHacked, calculateHackingTime, calculateGrowTime, calculateWeakenTime, } from "../Hacking"; import { numeralWrapper } from "../ui/numeralFormat"; import { convertTimeMsToTimeElapsedString } from "../utils/StringHelperFunctions"; import { alias } from "./commands/alias"; import { analyze } from "./commands/analyze"; import { backdoor } from "./commands/backdoor"; import { buy } from "./commands/buy"; import { cat } from "./commands/cat"; import { cd } from "./commands/cd"; import { check } from "./commands/check"; import { connect } from "./commands/connect"; import { cp } from "./commands/cp"; import { download } from "./commands/download"; import { expr } from "./commands/expr"; import { free } from "./commands/free"; import { grow } from "./commands/grow"; import { hack } from "./commands/hack"; import { help } from "./commands/help"; import { history } from "./commands/history"; import { home } from "./commands/home"; import { hostname } from "./commands/hostname"; import { kill } from "./commands/kill"; import { killall } from "./commands/killall"; import { ls } from "./commands/ls"; import { lscpu } from "./commands/lscpu"; import { mem } from "./commands/mem"; import { mv } from "./commands/mv"; import { nano } from "./commands/nano"; import { ps } from "./commands/ps"; import { rm } from "./commands/rm"; import { run } from "./commands/run"; import { scan } from "./commands/scan"; import { scananalyze } from "./commands/scananalyze"; import { scp } from "./commands/scp"; import { sudov } from "./commands/sudov"; import { tail } from "./commands/tail"; import { top } from "./commands/top"; import { unalias } from "./commands/unalias"; import { vim } from "./commands/vim"; import { weaken } from "./commands/weaken"; import { wget } from "./commands/wget"; import { hash } from "../hash/hash"; import { apr1 } from "./commands/apr1"; export class Terminal implements ITerminal { // Flags to determine whether the player is currently running a hack or an analyze action: TTimer | null = null; commandHistory: string[] = []; commandHistoryIndex = 0; outputHistory: (Output | Link | RawOutput)[] = [ new Output(`Bitburner v${CONSTANTS.VersionString} (${hash()})`, "primary"), ]; // True if a Coding Contract prompt is opened contractOpen = false; // Full Path of current directory // Excludes the trailing forward slash currDir = "/"; process(router: IRouter, player: IPlayer, cycles: number): void { if (this.action === null) return; this.action.timeLeft -= (CONSTANTS._idleSpeed * cycles) / 1000; if (this.action.timeLeft < 0.01) this.finishAction(router, player, false); TerminalEvents.emit(); } append(item: Output | Link | RawOutput): void { this.outputHistory.push(item); if (this.outputHistory.length > Settings.MaxTerminalCapacity) { this.outputHistory.splice(0, this.outputHistory.length - Settings.MaxTerminalCapacity); } TerminalEvents.emit(); } print(s: string): void { this.append(new Output(s, "primary")); } printRaw(node: React.ReactNode): void { this.append(new RawOutput(node)); } error(s: string): void { this.append(new Output(s, "error")); } success(s: string): void { this.append(new Output(s, "success")); } info(s: string): void { this.append(new Output(s, "info")); } warn(s: string): void { this.append(new Output(s, "warn")); } startHack(player: IPlayer): void { // Hacking through Terminal should be faster than hacking through a script const server = player.getCurrentServer(); if (server instanceof HacknetServer) { this.error("Cannot hack this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); this.startAction(calculateHackingTime(server, player) / 4, "h", server); } startGrow(player: IPlayer): void { const server = player.getCurrentServer(); if (server instanceof HacknetServer) { this.error("Cannot grow this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); this.startAction(calculateGrowTime(server, player) / 16, "g", server); } startWeaken(player: IPlayer): void { const server = player.getCurrentServer(); if (server instanceof HacknetServer) { this.error("Cannot weaken this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); this.startAction(calculateWeakenTime(server, player) / 16, "w", server); } startBackdoor(player: IPlayer): void { // Backdoor should take the same amount of time as hack const server = player.getCurrentServer(); if (server instanceof HacknetServer) { this.error("Cannot backdoor this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); this.startAction(calculateHackingTime(server, player) / 4, "b", server); } startAnalyze(player: IPlayer): void { this.print("Analyzing system..."); const server = player.getCurrentServer(); this.startAction(1, "a", server); } startAction(n: number, action: "h" | "b" | "a" | "g" | "w", server?: BaseServer): void { this.action = new TTimer(n, action, server); } // Complete the hack/analyze command finishHack(router: IRouter, player: IPlayer, server: BaseServer, cancelled = false): void { if (cancelled) return; if (server instanceof HacknetServer) { this.error("Cannot hack this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); // Calculate whether hack was successful const hackChance = calculateHackingChance(server, player); const rand = Math.random(); const expGainedOnSuccess = calculateHackingExpGain(server, player); const expGainedOnFailure = expGainedOnSuccess / 4; if (rand < hackChance) { // Success! server.backdoorInstalled = true; if (SpecialServers.WorldDaemon === server.hostname) { router.toBitVerse(false, false); return; } let moneyGained = calculatePercentMoneyHacked(server, player); moneyGained = Math.floor(server.moneyAvailable * moneyGained); if (moneyGained <= 0) { moneyGained = 0; } // Safety check server.moneyAvailable -= moneyGained; player.gainMoney(moneyGained, "hacking"); player.gainHackingExp(expGainedOnSuccess); player.gainIntelligenceExp(expGainedOnSuccess / CONSTANTS.IntelligenceTerminalHackBaseExpGain); const oldSec = server.hackDifficulty; server.fortify(CONSTANTS.ServerFortifyAmount); const newSec = server.hackDifficulty; this.print( `Hack successful on '${server.hostname}'! Gained ${numeralWrapper.formatMoney( moneyGained, )} and ${numeralWrapper.formatExp(expGainedOnSuccess)} hacking exp`, ); this.print( `Security increased on '${server.hostname}' from ${numeralWrapper.formatSecurity( oldSec, )} to ${numeralWrapper.formatSecurity(newSec)}`, ); } else { // Failure player.gainHackingExp(expGainedOnFailure); this.print( `Failed to hack '${server.hostname}'. Gained ${numeralWrapper.formatExp(expGainedOnFailure)} hacking exp`, ); } } finishGrow(player: IPlayer, server: BaseServer, cancelled = false): void { if (cancelled) return; if (server instanceof HacknetServer) { this.error("Cannot grow this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); const expGain = calculateHackingExpGain(server, player); const oldSec = server.hackDifficulty; const growth = processSingleServerGrowth(server, 25, player, server.cpuCores) - 1; const newSec = server.hackDifficulty; player.gainHackingExp(expGain); this.print( `Available money on '${server.hostname}' grown by ${numeralWrapper.formatPercentage( growth, 6, )}. Gained ${numeralWrapper.formatExp(expGain)} hacking exp.`, ); this.print( `Security increased on '${server.hostname}' from ${numeralWrapper.formatSecurity( oldSec, )} to ${numeralWrapper.formatSecurity(newSec)}`, ); } finishWeaken(player: IPlayer, server: BaseServer, cancelled = false): void { if (cancelled) return; if (server instanceof HacknetServer) { this.error("Cannot weaken this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); const expGain = calculateHackingExpGain(server, player); const oldSec = server.hackDifficulty; server.weaken(CONSTANTS.ServerWeakenAmount); const newSec = server.hackDifficulty; player.gainHackingExp(expGain); this.print( `Security decreased on '${server.hostname}' from ${numeralWrapper.formatSecurity( oldSec, )} to ${numeralWrapper.formatSecurity(newSec)} (min: ${numeralWrapper.formatSecurity(server.minDifficulty)})` + ` and Gained ${numeralWrapper.formatExp(expGain)} hacking exp.`, ); } finishBackdoor(router: IRouter, player: IPlayer, server: BaseServer, cancelled = false): void { if (!cancelled) { if (server instanceof HacknetServer) { this.error("Cannot hack this kind of server"); return; } if (!(server instanceof Server)) throw new Error("server should be normal server"); server.backdoorInstalled = true; if (SpecialServers.WorldDaemon === server.hostname) { if (player.bitNodeN == null) { player.bitNodeN = 1; } router.toBitVerse(false, false); return; } this.print(`Backdoor on '${server.hostname}' successful!`); } } finishAnalyze(player: IPlayer, currServ: BaseServer, cancelled = false): void { if (!cancelled) { const isHacknet = currServ instanceof HacknetServer; this.print(currServ.hostname + ": "); const org = currServ.organizationName; this.print("Organization name: " + (!isHacknet ? org : "player")); const hasAdminRights = (!isHacknet && currServ.hasAdminRights) || isHacknet; this.print("Root Access: " + (hasAdminRights ? "YES" : "NO")); const canRunScripts = hasAdminRights && currServ.maxRam > 0; this.print("Can run scripts on this host: " + (canRunScripts ? "YES" : "NO")); this.print("RAM: " + numeralWrapper.formatRAM(currServ.maxRam)); if (currServ instanceof Server) { this.print("Backdoor: " + (currServ.backdoorInstalled ? "YES" : "NO")); const hackingSkill = currServ.requiredHackingSkill; this.print("Required hacking skill for hack() and backdoor: " + (!isHacknet ? hackingSkill : "N/A")); const security = currServ.hackDifficulty; this.print("Server security level: " + (!isHacknet ? numeralWrapper.formatServerSecurity(security) : "N/A")); const hackingChance = calculateHackingChance(currServ, player); this.print("Chance to hack: " + (!isHacknet ? numeralWrapper.formatPercentage(hackingChance) : "N/A")); const hackingTime = calculateHackingTime(currServ, player) * 1000; this.print("Time to hack: " + (!isHacknet ? convertTimeMsToTimeElapsedString(hackingTime, true) : "N/A")); } this.print( `Total money available on server: ${ currServ instanceof Server ? numeralWrapper.formatMoney(currServ.moneyAvailable) : "N/A" }`, ); if (currServ instanceof Server) { const numPort = currServ.numOpenPortsRequired; this.print("Required number of open ports for NUKE: " + (!isHacknet ? numPort : "N/A")); this.print("SSH port: " + (currServ.sshPortOpen ? "Open" : "Closed")); this.print("FTP port: " + (currServ.ftpPortOpen ? "Open" : "Closed")); this.print("SMTP port: " + (currServ.smtpPortOpen ? "Open" : "Closed")); this.print("HTTP port: " + (currServ.httpPortOpen ? "Open" : "Closed")); this.print("SQL port: " + (currServ.sqlPortOpen ? "Open" : "Closed")); } } } finishAction(router: IRouter, player: IPlayer, cancelled = false): void { if (this.action === null) { if (!cancelled) throw new Error("Finish action called when there was no action"); return; } if (!this.action.server) throw new Error("Missing action target server"); this.print(this.getProgressText()); if (this.action.action === "h") { this.finishHack(router, player, this.action.server, cancelled); } else if (this.action.action === "g") { this.finishGrow(player, this.action.server, cancelled); } else if (this.action.action === "w") { this.finishWeaken(player, this.action.server, cancelled); } else if (this.action.action === "b") { this.finishBackdoor(router, player, this.action.server, cancelled); } else if (this.action.action === "a") { this.finishAnalyze(player, this.action.server, cancelled); } if (cancelled) { this.print("Cancelled"); } this.action = null; TerminalEvents.emit(); } getFile(player: IPlayer, filename: string): Script | TextFile | string | null { if (isScriptFilename(filename)) { return this.getScript(player, filename); } if (filename.endsWith(".lit")) { return this.getLitFile(player, filename); } if (filename.endsWith(".txt")) { return this.getTextFile(player, filename); } return null; } getFilepath(filename: string): string { const path = evaluateFilePath(filename, this.cwd()); if (path == null) { throw new Error(`Invalid file path specified: ${filename}`); } if (isInRootDirectory(path)) { return removeLeadingSlash(path); } return path; } getScript(player: IPlayer, filename: string): Script | null { const s = player.getCurrentServer(); const filepath = this.getFilepath(filename); for (const script of s.scripts) { if (filepath === script.filename) { return script; } } return null; } getTextFile(player: IPlayer, filename: string): TextFile | null { const s = player.getCurrentServer(); const filepath = this.getFilepath(filename); for (const txt of s.textFiles) { if (filepath === txt.fn) { return txt; } } return null; } getLitFile(player: IPlayer, filename: string): string | null { const s = player.getCurrentServer(); const filepath = this.getFilepath(filename); for (const lit of s.messages) { if (typeof lit === "string" && filepath === lit) { return lit; } } return null; } cwd(): string { return this.currDir; } setcwd(dir: string): void { this.currDir = dir; TerminalEvents.emit(); } async runContract(player: IPlayer, contractName: string): Promise { // There's already an opened contract if (this.contractOpen) { return this.error("There's already a Coding Contract in Progress"); } const serv = player.getCurrentServer(); const contract = serv.getContract(contractName); if (contract == null) { return this.error("No such contract"); } this.contractOpen = true; const res = await contract.prompt(); switch (res) { case CodingContractResult.Success: if (contract.reward !== null) { const reward = player.gainCodingContractReward(contract.reward, contract.getDifficulty()); this.print(`Contract SUCCESS - ${reward}`); } serv.removeContract(contract); break; case CodingContractResult.Failure: ++contract.tries; if (contract.tries >= contract.getMaxNumTries()) { this.error("Contract FAILED - Contract is now self-destructing"); serv.removeContract(contract); } else { this.error(`Contract FAILED - ${contract.getMaxNumTries() - contract.tries} tries remaining`); } break; case CodingContractResult.Cancelled: default: this.print("Contract cancelled"); break; } this.contractOpen = false; } executeScanAnalyzeCommand(player: IPlayer, depth = 1, all = false): void { // TODO Using array as stack for now, can make more efficient this.print("~~~~~~~~~~ Beginning scan-analyze ~~~~~~~~~~"); this.print(" "); // Map of all servers to keep track of which have been visited const visited: { [key: string]: number | undefined; } = {}; for (const server of GetAllServers()) { visited[server.hostname] = 0; } const stack: BaseServer[] = []; const depthQueue: number[] = [0]; const currServ = player.getCurrentServer(); stack.push(currServ); while (stack.length != 0) { const s = stack.pop(); if (!s) continue; const d = depthQueue.pop(); if (d === undefined) continue; const isHacknet = s instanceof HacknetServer; if (!all && (s as any).purchasedByPlayer && s.hostname != "home") { continue; // Purchased server } else if (visited[s.hostname] || d > depth) { continue; // Already visited or out-of-depth } else if (!all && isHacknet) { continue; // Hacknet Server } else { visited[s.hostname] = 1; } for (let i = s.serversOnNetwork.length - 1; i >= 0; --i) { const newS = getServerOnNetwork(s, i); if (newS === null) continue; stack.push(newS); depthQueue.push(d + 1); } if (d == 0) { continue; } // Don't print current server const titleDashes = Array((d - 1) * 4 + 1).join("-"); if (player.hasProgram(Programs.AutoLink.name)) { this.append(new Link(titleDashes, s.hostname)); } else { this.print(titleDashes + s.hostname); } const dashes = titleDashes + "--"; let c = "NO"; if (s.hasAdminRights) { c = "YES"; } this.print( `${dashes}Root Access: ${c}${!isHacknet ? ", Required hacking skill: " + (s as any).requiredHackingSkill : ""}`, ); if (s.hasOwnProperty("numOpenPortsRequired")) { this.print(dashes + "Number of open ports required to NUKE: " + (s as any).numOpenPortsRequired); } this.print(dashes + "RAM: " + numeralWrapper.formatRAM(s.maxRam)); this.print(" "); } } connectToServer(player: IPlayer, server: string): void { const serv = GetServer(server); if (serv == null) { this.error("Invalid server. Connection failed."); return; } player.getCurrentServer().isConnectedTo = false; player.currentServer = serv.hostname; player.getCurrentServer().isConnectedTo = true; this.print("Connected to " + serv.hostname); this.setcwd("/"); if (player.getCurrentServer().hostname == "darkweb") { checkIfConnectedToDarkweb(); // Posts a 'help' message if connecting to dark web } } executeCommands(router: IRouter, player: IPlayer, commands: string): void { // Sanitize input commands = commands.trim(); commands = commands.replace(/\s\s+/g, " "); // Replace all extra whitespace in command with a single space // Handle Terminal History - multiple commands should be saved as one if (this.commandHistory[this.commandHistory.length - 1] != commands) { this.commandHistory.push(commands); if (this.commandHistory.length > 50) { this.commandHistory.splice(0, 1); } player.terminalCommandHistory = this.commandHistory; } this.commandHistoryIndex = this.commandHistory.length; const allCommands = ParseCommands(commands); for (let i = 0; i < allCommands.length; i++) { this.executeCommand(router, player, allCommands[i]); } } clear(): void { this.outputHistory = [new Output(`Bitburner v${CONSTANTS.VersionString} (${hash()})`, "primary")]; TerminalEvents.emit(); TerminalClearEvents.emit(); } prestige(): void { this.action = null; this.clear(); } executeCommand(router: IRouter, player: IPlayer, command: string): void { if (this.action !== null) { this.error(`Cannot execute command (${command}) while an action is in progress`); return; } // Allow usage of ./ if (command.startsWith("./")) { command = "run " + command.slice(2); } // Only split the first space const commandArray = ParseCommand(command); if (commandArray.length == 0) { return; } const s = player.getCurrentServer(); /****************** Interactive Tutorial Terminal Commands ******************/ if (ITutorial.isRunning) { const n00dlesServ = GetServer("n00dles"); if (n00dlesServ == null) { throw new Error("Could not get n00dles server"); } switch (ITutorial.currStep) { case iTutorialSteps.TerminalHelp: if (commandArray.length === 1 && commandArray[0] == "help") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalLs: if (commandArray.length === 1 && commandArray[0] == "ls") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalScan: if (commandArray.length === 1 && commandArray[0] == "scan") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalScanAnalyze1: if (commandArray.length == 1 && commandArray[0] == "scan-analyze") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalScanAnalyze2: if (commandArray.length == 2 && commandArray[0] == "scan-analyze" && commandArray[1] === 2) { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalConnect: if (commandArray.length == 2) { if ( commandArray[0] == "connect" && (commandArray[1] == "n00dles" || commandArray[1] == n00dlesServ.hostname) ) { iTutorialNextStep(); } else { this.error("Wrong command! Try again!"); return; } } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalAnalyze: if (commandArray.length === 1 && commandArray[0] === "analyze") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalNuke: if (commandArray.length == 2 && commandArray[0] == "run" && commandArray[1] == "NUKE.exe") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalManualHack: if (commandArray.length == 1 && commandArray[0] == "hack") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalHackingMechanics: if (commandArray.length !== 1 || !["grow", "weaken", "hack"].includes(commandArray[0] + "")) { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalGoHome: if (commandArray.length == 1 && commandArray[0] == "home") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalCreateScript: if (commandArray.length == 2 && commandArray[0] == "nano" && commandArray[1] == "n00dles.script") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalFree: if (commandArray.length == 1 && commandArray[0] == "free") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.TerminalRunScript: if (commandArray.length == 2 && commandArray[0] == "run" && commandArray[1] == "n00dles.script") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; case iTutorialSteps.ActiveScriptsToTerminal: if (commandArray.length == 2 && commandArray[0] == "tail" && commandArray[1] == "n00dles.script") { iTutorialNextStep(); } else { this.error("Bad command. Please follow the tutorial"); return; } break; default: this.error("Please follow the tutorial, or click 'EXIT' if you'd like to skip it"); return; } } /****************** END INTERACTIVE TUTORIAL ******************/ /* Command parser */ const commandName = commandArray[0]; if (typeof commandName === "number" || typeof commandName === "boolean") { this.error(`Command ${commandArray[0]} not found`); return; } const commands: { [key: string]: ( terminal: ITerminal, router: IRouter, player: IPlayer, server: BaseServer, args: (string | number | boolean)[], ) => void; } = { "scan-analyze": scananalyze, alias: alias, analyze: analyze, backdoor: backdoor, buy: buy, cat: cat, cd: cd, check: check, clear: () => this.clear(), cls: () => this.clear(), connect: connect, cp: cp, download: download, expr: expr, free: free, grow: grow, hack: hack, help: help, history: history, home: home, hostname: hostname, kill: kill, killall: killall, ls: ls, lscpu: lscpu, mem: mem, mv: mv, nano: nano, ps: ps, rm: rm, run: run, scan: scan, scp: scp, sudov: sudov, tail: tail, apr1: apr1, top: top, unalias: unalias, vim: vim, weaken: weaken, wget: wget, }; const f = commands[commandName.toLowerCase()]; if (!f) { this.error(`Command ${commandArray[0]} not found`); return; } f(this, router, player, s, commandArray.slice(1)); } getProgressText(): string { if (this.action === null) throw new Error("trying to get the progress text when there's no action"); return createProgressBarText({ progress: (this.action.time - this.action.timeLeft) / this.action.time, totalTicks: 50, }); } }