Refactored stock buying/selling code into its own file. Refactored WorkerScript & NetscriptEnvironment into their own Typescript classes. Refactored a ton of code to remove circular dependencies

src/Hacknet/HacknetHelpers.jsx

@@ -1,35 +1,41 @@
-import { HacknetNode,
-         BaseCostForHacknetNode,
-         HacknetNodePurchaseNextMult,
-         HacknetNodeMaxLevel,
-         HacknetNodeMaxRam,
-         HacknetNodeMaxCores }                  from "./HacknetNode";
-import { HacknetServer,
-         BaseCostForHacknetServer,
-         HacknetServerPurchaseMult,
-         HacknetServerMaxLevel,
-         HacknetServerMaxRam,
-         HacknetServerMaxCores,
-         HacknetServerMaxCache,
-         MaxNumberHacknetServers }              from "./HacknetServer";
-import { HashManager }                          from "./HashManager";
-import { HashUpgrades }                         from "./HashUpgrades";
+import {
+    HacknetNode,
+    BaseCostForHacknetNode,
+    HacknetNodePurchaseNextMult,
+    HacknetNodeMaxLevel,
+    HacknetNodeMaxRam,
+    HacknetNodeMaxCores
+} from "./HacknetNode";
+import {
+    HacknetServer,
+    BaseCostForHacknetServer,
+    HacknetServerPurchaseMult,
+    HacknetServerMaxLevel,
+    HacknetServerMaxRam,
+    HacknetServerMaxCores,
+    HacknetServerMaxCache,
+    MaxNumberHacknetServers
+} from "./HacknetServer";
+import { HashManager } from "./HashManager";
+import { HashUpgrades } from "./HashUpgrades";
 
-import { generateRandomContract }               from "../CodingContractGenerator";
-import { iTutorialSteps, iTutorialNextStep,
-         ITutorial}                             from "../InteractiveTutorial";
-import { Player }                               from "../Player";
-import { AddToAllServers,
-         AllServers }                           from "../Server/AllServers";
-import { GetServerByHostname }                  from "../Server/ServerHelpers";
-import { SourceFileFlags }                      from "../SourceFile/SourceFileFlags";
-import { Page, routing }                        from "../ui/navigationTracking";
+import { generateRandomContract } from "../CodingContractGenerator";
+import {
+    iTutorialSteps,
+    iTutorialNextStep,
+    ITutorial
+} from "../InteractiveTutorial";
+import { Player } from "../Player";
+import { AddToAllServers, AllServers } from "../Server/AllServers";
+import { GetServerByHostname } from "../Server/ServerHelpers";
+import { SourceFileFlags } from "../SourceFile/SourceFileFlags";
+import { Page, routing } from "../ui/navigationTracking";
 
-import {getElementById}                         from "../../utils/uiHelpers/getElementById";
+import { getElementById } from "../../utils/uiHelpers/getElementById";
 
-import React                                    from "react";
-import ReactDOM                                 from "react-dom";
-import { HacknetRoot }                          from "./ui/Root";
+import React from "react";
+import ReactDOM from "react-dom";
+import { HacknetRoot } from "./ui/Root";
 
 let hacknetNodesDiv;
 function hacknetNodesInit() {
@@ -66,7 +72,7 @@ export function purchaseHacknet() {
         if (!Player.canAfford(cost)) { return -1; }
         Player.loseMoney(cost);
         const server = Player.createHacknetServer();
-        Player.hashManager.updateCapacity(Player);
+        Player.hashManager.updateCapacity(Player.hacknetNodes);
 
         return numOwned;
     } else {
@@ -79,8 +85,7 @@ export function purchaseHacknet() {
 
         // Auto generate a name for the Node
         const name = "hacknet-node-" + numOwned;
-        const node = new HacknetNode(name);
-        node.updateMoneyGainRate(Player);
+        const node = new HacknetNode(name, Player.hacknet_node_money_mult);
 
         Player.loseMoney(cost);
         Player.hacknetNodes.push(node);
@@ -116,26 +121,26 @@ export function getMaxNumberLevelUpgrades(nodeObj, maxLevel) {
         throw new Error(`getMaxNumberLevelUpgrades() called without maxLevel arg`);
     }
 
-    if (Player.money.lt(nodeObj.calculateLevelUpgradeCost(1, Player))) {
+    if (Player.money.lt(nodeObj.calculateLevelUpgradeCost(1, Player.hacknet_node_level_cost_mult))) {
         return 0;
     }
 
     let min = 1;
     let max = maxLevel - 1;
     let levelsToMax = maxLevel - nodeObj.level;
-    if (Player.money.gt(nodeObj.calculateLevelUpgradeCost(levelsToMax, Player))) {
+    if (Player.money.gt(nodeObj.calculateLevelUpgradeCost(levelsToMax, Player.hacknet_node_level_cost_mult))) {
         return levelsToMax;
     }
 
     while (min <= max) {
         var curr = (min + max) / 2 | 0;
         if (curr !== maxLevel &&
-            Player.money.gt(nodeObj.calculateLevelUpgradeCost(curr, Player)) &&
-            Player.money.lt(nodeObj.calculateLevelUpgradeCost(curr + 1, Player))) {
+            Player.money.gt(nodeObj.calculateLevelUpgradeCost(curr, Player.hacknet_node_level_cost_mult)) &&
+            Player.money.lt(nodeObj.calculateLevelUpgradeCost(curr + 1, Player.hacknet_node_level_cost_mult))) {
             return Math.min(levelsToMax, curr);
-        } else if (Player.money.lt(nodeObj.calculateLevelUpgradeCost(curr, Player))) {
+        } else if (Player.money.lt(nodeObj.calculateLevelUpgradeCost(curr, Player.hacknet_node_level_cost_mult))) {
             max = curr - 1;
-        } else if (Player.money.gt(nodeObj.calculateLevelUpgradeCost(curr, Player))) {
+        } else if (Player.money.gt(nodeObj.calculateLevelUpgradeCost(curr, Player.hacknet_node_level_cost_mult))) {
             min = curr + 1;
         } else {
             return Math.min(levelsToMax, curr);
@@ -149,7 +154,7 @@ export function getMaxNumberRamUpgrades(nodeObj, maxLevel) {
         throw new Error(`getMaxNumberRamUpgrades() called without maxLevel arg`);
     }
 
-    if (Player.money.lt(nodeObj.calculateRamUpgradeCost(1, Player))) {
+    if (Player.money.lt(nodeObj.calculateRamUpgradeCost(1, Player.hacknet_node_ram_cost_mult))) {
         return 0;
     }
 
@@ -159,13 +164,13 @@ export function getMaxNumberRamUpgrades(nodeObj, maxLevel) {
     } else {
         levelsToMax = Math.round(Math.log2(maxLevel / nodeObj.ram));
     }
-    if (Player.money.gt(nodeObj.calculateRamUpgradeCost(levelsToMax, Player))) {
+    if (Player.money.gt(nodeObj.calculateRamUpgradeCost(levelsToMax, Player.hacknet_node_ram_cost_mult))) {
         return levelsToMax;
     }
 
     //We'll just loop until we find the max
     for (let i = levelsToMax-1; i >= 0; --i) {
-        if (Player.money.gt(nodeObj.calculateRamUpgradeCost(i, Player))) {
+        if (Player.money.gt(nodeObj.calculateRamUpgradeCost(i, Player.hacknet_node_ram_cost_mult))) {
             return i;
         }
     }
@@ -177,14 +182,14 @@ export function getMaxNumberCoreUpgrades(nodeObj, maxLevel) {
         throw new Error(`getMaxNumberCoreUpgrades() called without maxLevel arg`);
     }
 
-    if (Player.money.lt(nodeObj.calculateCoreUpgradeCost(1, Player))) {
+    if (Player.money.lt(nodeObj.calculateCoreUpgradeCost(1, Player.hacknet_node_core_cost_mult))) {
         return 0;
     }
 
     let min = 1;
     let max = maxLevel - 1;
     const levelsToMax = maxLevel - nodeObj.cores;
-    if (Player.money.gt(nodeObj.calculateCoreUpgradeCost(levelsToMax, Player))) {
+    if (Player.money.gt(nodeObj.calculateCoreUpgradeCost(levelsToMax, Player.hacknet_node_core_cost_mult))) {
         return levelsToMax;
     }
 
@@ -192,12 +197,12 @@ export function getMaxNumberCoreUpgrades(nodeObj, maxLevel) {
     while (min <= max) {
         let curr = (min + max) / 2 | 0;
         if (curr != maxLevel &&
-            Player.money.gt(nodeObj.calculateCoreUpgradeCost(curr, Player)) &&
-            Player.money.lt(nodeObj.calculateCoreUpgradeCost(curr + 1, Player))) {
+            Player.money.gt(nodeObj.calculateCoreUpgradeCost(curr, Player.hacknet_node_core_cost_mult)) &&
+            Player.money.lt(nodeObj.calculateCoreUpgradeCost(curr + 1, Player.hacknet_node_core_cost_mult))) {
             return Math.min(levelsToMax, curr);
-        } else if (Player.money.lt(nodeObj.calculateCoreUpgradeCost(curr, Player))) {
+        } else if (Player.money.lt(nodeObj.calculateCoreUpgradeCost(curr, Player.hacknet_node_core_cost_mult))) {
             max = curr - 1;
-        } else if (Player.money.gt(nodeObj.calculateCoreUpgradeCost(curr, Player))) {
+        } else if (Player.money.gt(nodeObj.calculateCoreUpgradeCost(curr, Player.hacknet_node_core_cost_mult))) {
             min = curr + 1;
         } else {
             return Math.min(levelsToMax, curr);
@@ -242,7 +247,134 @@ export function getMaxNumberCacheUpgrades(nodeObj, maxLevel) {
     return 0;
 }
 
-// Initial construction of Hacknet Nodes UI
+export function purchaseLevelUpgrade(node, levels=1) {
+    const sanitizedLevels = Math.round(levels);
+    const cost = node.calculateLevelUpgradeCost(sanitizedLevels, Player.hacknet_node_level_cost_mult);
+    if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
+        return false;
+    }
+
+    const isServer = (node instanceof HacknetServer);
+
+    // If we're at max level, return false
+    if (node.level >= (isServer ? HacknetServerMaxLevel : HacknetNodeMaxLevel)) {
+        return false;
+    }
+
+    // If the number of specified upgrades would exceed the max level, calculate
+    // the maximum number of upgrades and use that
+    if (node.level + sanitizedLevels > (isServer ? HacknetServerMaxLevel : HacknetNodeMaxLevel)) {
+        const diff = Math.max(0, (isServer ? HacknetServerMaxLevel : HacknetNodeMaxLevel) - node.level);
+        return purchaseLevelUpgrade(node, diff);
+    }
+
+    if (!Player.canAfford(cost)) {
+        return false;
+    }
+
+    Player.loseMoney(cost);
+    node.upgradeLevel(sanitizedLevels, Player.hacknet_node_money_mult);
+
+    return true;
+}
+
+export function purchaseRamUpgrade(node, levels=1) {
+    const sanitizedLevels = Math.round(levels);
+    const cost = node.calculateRamUpgradeCost(sanitizedLevels, Player.hacknet_node_ram_cost_mult);
+    if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
+        return false;
+    }
+
+    const isServer = (node instanceof HacknetServer);
+
+    // Fail if we're already at max
+    if (node.ram >= (isServer ? HacknetServerMaxRam : HacknetNodeMaxRam)) {
+        return false;
+    }
+
+    // If the number of specified upgrades would exceed the max RAM, calculate the
+    // max possible number of upgrades and use that
+    if (isServer) {
+        if (node.maxRam * Math.pow(2, sanitizedLevels) > HacknetServerMaxRam) {
+            const diff = Math.max(0, Math.log2(Math.round(HacknetServerMaxRam / node.maxRam)));
+            return purchaseRamUpgrade(node, diff);
+        }
+    } else {
+        if (node.ram * Math.pow(2, sanitizedLevels) > HacknetNodeMaxRam) {
+            const diff = Math.max(0, Math.log2(Math.round(HacknetNodeMaxRam / node.ram)));
+            return purchaseRamUpgrade(node, diff);
+        }
+    }
+
+
+    if (!Player.canAfford(cost)) {
+        return false;
+    }
+
+    Player.loseMoney(cost);
+    node.upgradeRam(sanitizedLevels, Player.hacknet_node_money_mult);
+
+    return true;
+}
+
+export function purchaseCoreUpgrade(node, levels=1) {
+    const sanitizedLevels = Math.round(levels);
+    const cost = node.calculateCoreUpgradeCost(sanitizedLevels, Player.hacknet_node_core_cost_mult);
+    if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
+        return false;
+    }
+
+    const isServer = (node instanceof HacknetServer);
+
+    // Fail if we're already at max
+    if (node.cores >= (isServer ? HacknetServerMaxCores : HacknetNodeMaxCores)) {
+        return false;
+    }
+
+    // If the specified number of upgrades would exceed the max Cores, calculate
+    // the max possible number of upgrades and use that
+    if (node.cores + sanitizedLevels > (isServer ? HacknetServerMaxCores : HacknetNodeMaxCores)) {
+        const diff = Math.max(0, (isServer ? HacknetServerMaxCores : HacknetNodeMaxCores) - node.cores);
+        return purchaseCoreUpgrade(node, diff);
+    }
+
+    if (!Player.canAfford(cost)) {
+        return false;
+    }
+
+    Player.loseMoney(cost);
+    node.upgradeCore(sanitizedLevels, Player.hacknet_node_money_mult);
+
+    return true;
+}
+
+export function purchaseCacheUpgrade(node, levels=1) {
+    const sanitizedLevels = Math.round(levels);
+    const cost = node.calculateCoreUpgradeCost(sanitizedLevels);
+    if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
+        return false;
+    }
+
+    if (!(node instanceof HacknetServer)) {
+        console.warn(`purchaseCacheUpgrade() called for a non-HacknetNode`);
+        return false;
+    }
+
+    // Fail if we're already at max
+    if (node.cache + sanitizedLevels > HacknetServerMaxCache) {
+        const diff = Math.max(0, HacknetServerMaxCache - node.cache);
+        return purchaseCacheUpgrade(node, diff);
+    }
+
+    if (!Player.canAfford(cost)) {
+        return false;
+    }
+
+    Player.loseMoney(cost);
+    node.upgradeCache(sanitizedLevels);
+}
+
+// Create/Refresh Hacknet Nodes UI
 export function renderHacknetNodesUI() {
     if (!routing.isOn(Page.HacknetNodes)) { return; }
 
@@ -303,6 +435,37 @@ function processAllHacknetServerEarnings(numCycles) {
     return hashes;
 }
 
+export function updateHashManagerCapacity() {
+    if (!(Player.hashManager instanceof HashManager)) {
+        console.error(`Player does not have a HashManager`);
+        return;
+    }
+
+    const nodes = Player.hacknetNodes;
+    if (nodes.length === 0) {
+        Player.hashManager.updateCapacity(0);
+        return;
+    }
+
+    let total = 0;
+    for (let i = 0; i < nodes.length; ++i) {
+        if (typeof nodes[i] !== "string") {
+            Player.hashManager.updateCapacity(0);
+            return;
+        }
+
+        const h = AllServers[nodes[i]];
+        if (!(h instanceof HacknetServer)) {
+            Player.hashManager.updateCapacity(0);
+            return;
+        }
+
+        total += h.hashCapacity;
+    }
+
+    Player.hashManager.updateCapacity(total);
+}
+
 export function purchaseHashUpgrade(upgName, upgTarget) {
     if (!(Player.hashManager instanceof HashManager)) {
         console.error(`Player does not have a HashManager`);

src/Hacknet/HacknetNode.ts

@@ -62,12 +62,14 @@ export class HacknetNode implements IHacknetNode {
     // Total money earned by this Node
     totalMoneyGenerated: number = 0;
 
-    constructor(name: string="") {
+    constructor(name: string="", prodMult: number=1) {
         this.name       = name;
+
+        this.updateMoneyGainRate(prodMult);
     }
 
     // Get the cost to upgrade this Node's number of cores
-    calculateCoreUpgradeCost(levels: number=1, p: IPlayer): number {
+    calculateCoreUpgradeCost(levels: number=1, costMult: number): number {
         const sanitizedLevels = Math.round(levels);
         if (isNaN(sanitizedLevels) || sanitizedLevels < 1) {
             return 0;
@@ -86,13 +88,13 @@ export class HacknetNode implements IHacknetNode {
             ++currentCores;
         }
 
-        totalCost *= p.hacknet_node_core_cost_mult;
+        totalCost *= costMult;
 
         return totalCost;
     }
 
     // Get the cost to upgrade this Node's level
-    calculateLevelUpgradeCost(levels: number=1, p: IPlayer): number {
+    calculateLevelUpgradeCost(levels: number=1, costMult: number): number {
         const sanitizedLevels = Math.round(levels);
         if (isNaN(sanitizedLevels) || sanitizedLevels < 1) {
             return 0;
@@ -110,11 +112,11 @@ export class HacknetNode implements IHacknetNode {
             ++currLevel;
         }
 
-        return BaseCostForHacknetNode / 2 * totalMultiplier * p.hacknet_node_level_cost_mult;
+        return BaseCostForHacknetNode / 2 * totalMultiplier * costMult;
     }
 
     // Get the cost to upgrade this Node's RAM
-    calculateRamUpgradeCost(levels: number=1, p: IPlayer): number {
+    calculateRamUpgradeCost(levels: number=1, costMult: number): number {
         const sanitizedLevels = Math.round(levels);
         if (isNaN(sanitizedLevels) || sanitizedLevels < 1) {
             return 0;
@@ -138,7 +140,7 @@ export class HacknetNode implements IHacknetNode {
             ++numUpgrades;
         }
 
-        totalCost *= p.hacknet_node_ram_cost_mult;
+        totalCost *= costMult;
 
         return totalCost;
     }
@@ -161,112 +163,37 @@ export class HacknetNode implements IHacknetNode {
 
     // Upgrade this Node's number of cores, if possible
     // Returns a boolean indicating whether new cores were successfully bought
-    purchaseCoreUpgrade(levels: number=1, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateCoreUpgradeCost(sanitizedLevels, p);
-        if (isNaN(cost) || sanitizedLevels < 0) {
-            return false;
-        }
-
-        // Fail if we're already at max
-        if (this.cores >= HacknetNodeMaxCores) {
-            return false;
-        }
-
-        // If the specified number of upgrades would exceed the max Cores, calculate
-        // the max possible number of upgrades and use that
-        if (this.cores + sanitizedLevels > HacknetNodeMaxCores) {
-            const diff = Math.max(0, HacknetNodeMaxCores - this.cores);
-            return this.purchaseCoreUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        this.cores = Math.round(this.cores + sanitizedLevels); // Just in case of floating point imprecision
-        this.updateMoneyGainRate(p);
-
-        return true;
+    upgradeCore(levels: number=1, prodMult: number): void {
+        this.cores = Math.min(HacknetNodeMaxCores, Math.round(this.cores + levels));
+        this.updateMoneyGainRate(prodMult);
     }
 
     // Upgrade this Node's level, if possible
     // Returns a boolean indicating whether the level was successfully updated
-    purchaseLevelUpgrade(levels: number=1, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateLevelUpgradeCost(sanitizedLevels, p);
-        if (isNaN(cost) || sanitizedLevels < 0) {
-            return false;
-        }
-
-        // If we're at max level, return false
-        if (this.level >= HacknetNodeMaxLevel) {
-            return false;
-        }
-
-        // If the number of specified upgrades would exceed the max level, calculate
-        // the maximum number of upgrades and use that
-        if (this.level + sanitizedLevels > HacknetNodeMaxLevel) {
-            var diff = Math.max(0, HacknetNodeMaxLevel - this.level);
-            return this.purchaseLevelUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        this.level = Math.round(this.level + sanitizedLevels); // Just in case of floating point imprecision
-        this.updateMoneyGainRate(p);
-
-        return true;
+    upgradeLevel(levels: number=1, prodMult: number): void {
+        this.level = Math.min(HacknetNodeMaxLevel, Math.round(this.level + levels));
+        this.updateMoneyGainRate(prodMult);
     }
 
     // Upgrade this Node's RAM, if possible
     // Returns a boolean indicating whether the RAM was successfully upgraded
-    purchaseRamUpgrade(levels: number=1, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateRamUpgradeCost(sanitizedLevels, p);
-        if (isNaN(cost) || sanitizedLevels < 0) {
-            return false;
-        }
-
-        // Fail if we're already at max
-        if (this.ram >= HacknetNodeMaxRam) {
-            return false;
-        }
-
-        // If the number of specified upgrades would exceed the max RAM, calculate the
-        // max possible number of upgrades and use that
-        if (this.ram * Math.pow(2, sanitizedLevels) > HacknetNodeMaxRam) {
-            var diff = Math.max(0, Math.log2(Math.round(HacknetNodeMaxRam / this.ram)));
-            return this.purchaseRamUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        for (let i = 0; i < sanitizedLevels; ++i) {
+    upgradeRam(levels: number=1, prodMult: number): void {
+        for (let i = 0; i < levels; ++i) {
             this.ram *= 2; // Ram is always doubled
         }
         this.ram = Math.round(this.ram); // Handle any floating point precision issues
-        this.updateMoneyGainRate(p);
-
-        return true;
+        this.updateMoneyGainRate(prodMult);
     }
 
     // Re-calculate this Node's production and update the moneyGainRatePerSecond prop
-    updateMoneyGainRate(p: IPlayer): void {
+    updateMoneyGainRate(prodMult: number): void {
         //How much extra $/s is gained per level
         var gainPerLevel = HacknetNodeMoneyGainPerLevel;
 
         this.moneyGainRatePerSecond = (this.level * gainPerLevel) *
                                       Math.pow(1.035, this.ram - 1) *
                                       ((this.cores + 5) / 6) *
-                                      p.hacknet_node_money_mult *
+                                      prodMult *
                                       BitNodeMultipliers.HacknetNodeMoney;
         if (isNaN(this.moneyGainRatePerSecond)) {
             this.moneyGainRatePerSecond = 0;

src/Hacknet/HacknetServer.ts

@@ -6,15 +6,16 @@ import { CONSTANTS } from "../Constants";
 import { IHacknetNode } from "./IHacknetNode";
 
 import { BitNodeMultipliers } from "../BitNode/BitNodeMultipliers";
-import { IPlayer } from "../PersonObjects/IPlayer";
 import { BaseServer } from "../Server/BaseServer";
 import { RunningScript } from "../Script/RunningScript";
 
 import { createRandomIp } from "../../utils/IPAddress";
 
-import { Generic_fromJSON,
-         Generic_toJSON,
-         Reviver } from "../../utils/JSONReviver";
+import {
+    Generic_fromJSON,
+    Generic_toJSON,
+    Reviver
+} from "../../utils/JSONReviver";
 
 // Constants for Hacknet Server stats/production
 export const HacknetServerHashesPerLevel: number = 0.001;
@@ -46,7 +47,6 @@ interface IConstructorParams {
     isConnectedTo?: boolean;
     maxRam?: number;
     organizationName?: string;
-    player?: IPlayer;
 }
 
 export class HacknetServer extends BaseServer implements IHacknetNode {
@@ -81,10 +81,6 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
 
         this.maxRam = 1;
         this.updateHashCapacity();
-
-        if (params.player) {
-            this.updateHashRate(params.player);
-        }
     }
 
     calculateCacheUpgradeCost(levels: number): number {
@@ -109,7 +105,7 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
         return totalCost;
     }
 
-    calculateCoreUpgradeCost(levels: number, p: IPlayer): number {
+    calculateCoreUpgradeCost(levels: number, costMult: number): number {
         const sanitizedLevels = Math.round(levels);
         if (isNaN(sanitizedLevels) || sanitizedLevels < 1) {
             return 0;
@@ -127,12 +123,12 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
             ++currentCores;
         }
         totalCost *= BaseCostForHacknetServerCore;
-        totalCost *= p.hacknet_node_core_cost_mult;
+        totalCost *= costMult;
 
         return totalCost;
     }
 
-    calculateLevelUpgradeCost(levels: number, p: IPlayer): number {
+    calculateLevelUpgradeCost(levels: number, costMult: number): number {
         const sanitizedLevels = Math.round(levels);
         if (isNaN(sanitizedLevels) || sanitizedLevels < 1) {
             return 0;
@@ -150,10 +146,10 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
             ++currLevel;
         }
 
-        return 10 * BaseCostForHacknetServer * totalMultiplier * p.hacknet_node_level_cost_mult;
+        return 10 * BaseCostForHacknetServer * totalMultiplier * costMult;
     }
 
-    calculateRamUpgradeCost(levels: number, p: IPlayer): number {
+    calculateRamUpgradeCost(levels: number, costMult: number): number {
         const sanitizedLevels = Math.round(levels);
         if (isNaN(sanitizedLevels) || sanitizedLevels < 1) {
             return 0;
@@ -175,7 +171,7 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
             currentRam *= 2;
             ++numUpgrades;
         }
-        totalCost *= p.hacknet_node_ram_cost_mult;
+        totalCost *= costMult;
 
         return totalCost;
     }
@@ -189,124 +185,30 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
     }
 
     // Returns a boolean indicating whether the cache was successfully upgraded
-    purchaseCacheUpgrade(levels: number, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateCacheUpgradeCost(levels);
-        if (isNaN(cost) || cost <= 0 || sanitizedLevels <= 0) {
-            return false;
-        }
-
-        if (this.cache >= HacknetServerMaxCache) {
-            return false;
-        }
-
-        // If the specified number of upgrades would exceed the max, try to purchase
-        // the maximum possible
-        if (this.cache + levels > HacknetServerMaxCache) {
-            const diff = Math.max(0, HacknetServerMaxCache - this.cache);
-            return this.purchaseCacheUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        this.cache = Math.round(this.cache + sanitizedLevels);
+    upgradeCache(levels: number): void {
+        this.cache = Math.min(HacknetServerMaxCache, Math.round(this.cache + levels));
         this.updateHashCapacity();
-
-        return true;
     }
 
     // Returns a boolean indicating whether the number of cores was successfully upgraded
-    purchaseCoreUpgrade(levels: number, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateCoreUpgradeCost(sanitizedLevels, p);
-        if (isNaN(cost) || cost <= 0 || sanitizedLevels <= 0) {
-            return false;
-        }
-
-        if (this.cores >= HacknetServerMaxCores) {
-            return false;
-        }
-
-        // If the specified number of upgrades would exceed the max, try to purchase
-        // the maximum possible
-        if (this.cores + sanitizedLevels > HacknetServerMaxCores) {
-            const diff = Math.max(0, HacknetServerMaxCores - this.cores);
-            return this.purchaseCoreUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        this.cores = Math.round(this.cores + sanitizedLevels);
-        this.updateHashRate(p);
-
-        return true;
+    upgradeCore(levels: number, prodMult: number): void {
+        this.cores = Math.min(HacknetServerMaxCores, Math.round(this.cores + levels));
+        this.updateHashRate(prodMult);
     }
 
     // Returns a boolean indicating whether the level was successfully upgraded
-    purchaseLevelUpgrade(levels: number, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateLevelUpgradeCost(sanitizedLevels, p);
-        if (isNaN(cost) || cost <= 0 || sanitizedLevels <= 0) {
-            return false;
-        }
-
-        if (this.level >= HacknetServerMaxLevel) {
-            return false;
-        }
-
-        // If the specified number of upgrades would exceed the max, try to purchase the
-        // maximum possible
-        if (this.level + sanitizedLevels > HacknetServerMaxLevel) {
-            const diff = Math.max(0, HacknetServerMaxLevel - this.level);
-            return this.purchaseLevelUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        this.level = Math.round(this.level + sanitizedLevels);
-        this.updateHashRate(p);
-
-        return true;
+    upgradeLevel(levels: number, prodMult: number): void {
+        this.level = Math.min(HacknetServerMaxLevel, Math.round(this.level + levels));
+        this.updateHashRate(prodMult);
     }
 
     // Returns a boolean indicating whether the RAM was successfully upgraded
-    purchaseRamUpgrade(levels: number, p: IPlayer): boolean {
-        const sanitizedLevels = Math.round(levels);
-        const cost = this.calculateRamUpgradeCost(sanitizedLevels, p);
-        if(isNaN(cost) || cost <= 0 || sanitizedLevels <= 0) {
-            return false;
-        }
-
-        if (this.maxRam >= HacknetServerMaxRam) {
-            return false;
-        }
-
-        // If the specified number of upgrades would exceed the max, try to purchase
-        // just the maximum possible
-        if (this.maxRam * Math.pow(2, sanitizedLevels) > HacknetServerMaxRam) {
-            const diff = Math.max(0, Math.log2(Math.round(HacknetServerMaxRam / this.maxRam)));
-            return this.purchaseRamUpgrade(diff, p);
-        }
-
-        if (!p.canAfford(cost)) {
-            return false;
-        }
-
-        p.loseMoney(cost);
-        for (let i = 0; i < sanitizedLevels; ++i) {
+    upgradeRam(levels: number, prodMult: number): boolean {
+        for (let i = 0; i < levels; ++i) {
             this.maxRam *= 2;
         }
-        this.maxRam = Math.round(this.maxRam);
-        this.updateHashRate(p);
+        this.maxRam = Math.min(HacknetServerMaxRam, Math.round(this.maxRam));
+        this.updateHashRate(prodMult);
 
         return true;
     }
@@ -314,10 +216,10 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
     /**
      * Whenever a script is run, we must update this server's hash rate
      */
-    runScript(script: RunningScript, p?: IPlayer): void {
+    runScript(script: RunningScript, prodMult?: number): void {
         super.runScript(script);
-        if (p) {
-            this.updateHashRate(p);
+        if (prodMult != null && typeof prodMult === "number") {
+            this.updateHashRate(prodMult);
         }
     }
 
@@ -325,7 +227,7 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
         this.hashCapacity = 32 * Math.pow(2, this.cache);
     }
 
-    updateHashRate(p: IPlayer): void {
+    updateHashRate(prodMult: number): void {
         const baseGain = HacknetServerHashesPerLevel * this.level;
         const ramMultiplier = Math.pow(1.07, Math.log2(this.maxRam));
         const coreMultiplier = 1 + (this.cores - 1) / 5;
@@ -333,7 +235,7 @@ export class HacknetServer extends BaseServer implements IHacknetNode {
 
         const hashRate = baseGain * ramMultiplier * coreMultiplier * ramRatio;
 
-        this.hashRate = hashRate * p.hacknet_node_money_mult * BitNodeMultipliers.HacknetNodeMoney;
+        this.hashRate = hashRate * prodMult * BitNodeMultipliers.HacknetNodeMoney;
 
         if (isNaN(this.hashRate)) {
             this.hashRate = 0;

src/Hacknet/HashManager.ts

@@ -6,12 +6,9 @@
  * his hashes, and contains method for grabbing the data/multipliers from
  * those upgrades
  */
-import { HacknetServer } from "./HacknetServer";
 import { HashUpgrades } from "./HashUpgrades";
 
 import { IMap } from "../types";
-import { IPlayer } from "../PersonObjects/IPlayer";
-import { AllServers } from "../Server/AllServers";
 import { Generic_fromJSON,
          Generic_toJSON,
          Reviver } from "../../utils/JSONReviver";
@@ -84,14 +81,14 @@ export class HashManager {
         return upg.getCost(currLevel);
     }
 
-    prestige(p: IPlayer): void {
+    prestige(): void {
         for (const name in HashUpgrades) {
             this.upgrades[name] = 0;
         }
         this.hashes = 0;
-        if (p != null) {
-            this.updateCapacity(p);
-        }
+
+        // When prestiging, player's hacknet nodes are always reset. So capacity = 0
+        this.updateCapacity(0);
     }
 
     /**
@@ -118,33 +115,11 @@ export class HashManager {
         this.hashes = Math.min(this.hashes, this.capacity);
     }
 
-    updateCapacity(p: IPlayer): void {
-        if (p.hacknetNodes.length <= 0) {
+    updateCapacity(newCap: number): void {
+        if (newCap < 0) {
             this.capacity = 0;
-            return;
         }
-
-        // Make sure the Player's `hacknetNodes` property actually holds Hacknet Servers
-        const ip: string = <string>p.hacknetNodes[0];
-        if (typeof ip !== "string") {
-            this.capacity = 0;
-            return;
-        }
-
-        const hserver = <HacknetServer>AllServers[ip];
-        if (!(hserver instanceof HacknetServer)) {
-            this.capacity = 0;
-            return;
-        }
-
-
-        let total: number = 0;
-        for (let i = 0; i < p.hacknetNodes.length; ++i) {
-            const h = <HacknetServer>AllServers[<string>p.hacknetNodes[i]];
-            total += h.hashCapacity;
-        }
-
-        this.capacity = total;
+        this.capacity = Math.max(newCap, 0);
     }
 
     /**

src/Hacknet/IHacknetNode.ts

@@ -1,16 +1,14 @@
 // Interface for a Hacknet Node. Implemented by both a basic Hacknet Node,
 // and the upgraded Hacknet Server in BitNode-9
-import { IPlayer } from "../PersonObjects/IPlayer";
-
 export interface IHacknetNode {
     cores: number;
     level: number;
     onlineTimeSeconds: number;
 
-    calculateCoreUpgradeCost: (levels: number, p: IPlayer) => number;
-    calculateLevelUpgradeCost: (levels: number, p: IPlayer) => number;
-    calculateRamUpgradeCost: (levels: number, p: IPlayer) => number;
-    purchaseCoreUpgrade: (levels: number, p: IPlayer) => boolean;
-    purchaseLevelUpgrade: (levels: number, p: IPlayer) => boolean;
-    purchaseRamUpgrade: (levels: number, p: IPlayer) => boolean;
+    calculateCoreUpgradeCost: (levels: number, costMult: number) => number;
+    calculateLevelUpgradeCost: (levels: number, costMult: number) => number;
+    calculateRamUpgradeCost: (levels: number, costMult: number) => number;
+    upgradeCore: (levels: number, prodMult: number) => void;
+    upgradeLevel: (levels: number, prodMult: number) => void;
+    upgradeRam: (levels: number, prodMult: number) => void;
 }

src/Hacknet/ui/HacknetNode.jsx

@@ -4,12 +4,19 @@
  */
 import React from "react";
 
-import { HacknetNodeMaxLevel,
-         HacknetNodeMaxRam,
-         HacknetNodeMaxCores } from "../HacknetNode";
-import { getMaxNumberLevelUpgrades,
-         getMaxNumberRamUpgrades,
-         getMaxNumberCoreUpgrades } from "../HacknetHelpers";
+import {
+    HacknetNodeMaxLevel,
+    HacknetNodeMaxRam,
+    HacknetNodeMaxCores
+} from "../HacknetNode";
+import {
+    getMaxNumberLevelUpgrades,
+    getMaxNumberRamUpgrades,
+    getMaxNumberCoreUpgrades,
+    purchaseLevelUpgrade,
+    purchaseRamUpgrade,
+    purchaseCoreUpgrade,
+} from "../HacknetHelpers";
 
 import { Player } from "../../Player";
 
@@ -35,7 +42,7 @@ export class HacknetNode extends React.Component {
                 multiplier = Math.min(levelsToMax, purchaseMult);
             }
 
-            const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, Player);
+            const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, Player.hacknet_node_level_cost_mult);
             upgradeLevelText = `Upgrade x${multiplier} - ${numeralWrapper.formatMoney(upgradeLevelCost)}`;
             if (Player.money.lt(upgradeLevelCost)) {
                 upgradeLevelClass = "std-button-disabled";
@@ -48,7 +55,7 @@ export class HacknetNode extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberLevelUpgrades(node, HacknetNodeMaxLevel);
             }
-            node.purchaseLevelUpgrade(numUpgrades, Player);
+            purchaseLevelUpgrade(node, numUpgrades);
             recalculate();
             return false;
         }
@@ -66,7 +73,7 @@ export class HacknetNode extends React.Component {
                 multiplier = Math.min(levelsToMax, purchaseMult);
             }
 
-            const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, Player);
+            const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, Player.hacknet_node_ram_cost_mult);
             upgradeRamText = `Upgrade x${multiplier} - ${numeralWrapper.formatMoney(upgradeRamCost)}`;
             if (Player.money.lt(upgradeRamCost)) {
                 upgradeRamClass = "std-button-disabled";
@@ -79,7 +86,7 @@ export class HacknetNode extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberRamUpgrades(node, HacknetNodeMaxRam);
             }
-            node.purchaseRamUpgrade(numUpgrades, Player);
+            purchaseRamUpgrade(node, numUpgrades);
             recalculate();
             return false;
         }
@@ -97,7 +104,7 @@ export class HacknetNode extends React.Component {
                 multiplier = Math.min(levelsToMax, purchaseMult);
             }
 
-            const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, Player);
+            const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, Player.hacknet_node_core_cost_mult);
             upgradeCoresText = `Upgrade x${multiplier} - ${numeralWrapper.formatMoney(upgradeCoreCost)}`;
             if (Player.money.lt(upgradeCoreCost)) {
                 upgradeCoresClass = "std-button-disabled";
@@ -110,7 +117,7 @@ export class HacknetNode extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberCoreUpgrades(node, HacknetNodeMaxCores);
             }
-            node.purchaseCoreUpgrade(numUpgrades, Player);
+            purchaseCoreUpgrade(node, numUpgrades);
             recalculate();
             return false;
         }

src/Hacknet/ui/HacknetServer.jsx

@@ -4,14 +4,23 @@
  */
 import React from "react";
 
-import { HacknetServerMaxLevel,
-         HacknetServerMaxRam,
-         HacknetServerMaxCores,
-         HacknetServerMaxCache } from "../HacknetServer";
-import { getMaxNumberLevelUpgrades,
-         getMaxNumberRamUpgrades,
-         getMaxNumberCoreUpgrades,
-         getMaxNumberCacheUpgrades } from "../HacknetHelpers";
+import {
+    HacknetServerMaxLevel,
+    HacknetServerMaxRam,
+    HacknetServerMaxCores,
+    HacknetServerMaxCache
+} from "../HacknetServer";
+import {
+    getMaxNumberLevelUpgrades,
+    getMaxNumberRamUpgrades,
+    getMaxNumberCoreUpgrades,
+    getMaxNumberCacheUpgrades,
+    purchaseLevelUpgrade,
+    purchaseRamUpgrade,
+    purchaseCoreUpgrade,
+    purchaseCacheUpgrade,
+    updateHashManagerCapacity,
+} from "../HacknetHelpers";
 
 import { Player } from "../../Player";
 
@@ -37,7 +46,7 @@ export class HacknetServer extends React.Component {
                 multiplier = Math.min(levelsToMax, purchaseMult);
             }
 
-            const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, Player);
+            const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, Player.hacknet_node_level_cost_mult);
             upgradeLevelText = `Upgrade x${multiplier} - ${numeralWrapper.formatMoney(upgradeLevelCost)}`;
             if (Player.money.lt(upgradeLevelCost)) {
                 upgradeLevelClass = "std-button-disabled";
@@ -50,7 +59,7 @@ export class HacknetServer extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberLevelUpgrades(node, HacknetServerMaxLevel);
             }
-            node.purchaseLevelUpgrade(numUpgrades, Player);
+            purchaseLevelUpgrade(node, numUpgrades);
             recalculate();
             return false;
         }
@@ -69,7 +78,7 @@ export class HacknetServer extends React.Component {
                 multiplier = Math.min(levelsToMax, purchaseMult);
             }
 
-            const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, Player);
+            const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, Player.hacknet_node_ram_cost_mult);
             upgradeRamText = `Upgrade x${multiplier} - ${numeralWrapper.formatMoney(upgradeRamCost)}`;
             if (Player.money.lt(upgradeRamCost)) {
                 upgradeRamClass = "std-button-disabled";
@@ -82,7 +91,7 @@ export class HacknetServer extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberRamUpgrades(node, HacknetServerMaxRam);
             }
-            node.purchaseRamUpgrade(numUpgrades, Player);
+            purchaseRamUpgrade(node, numUpgrades);
             recalculate();
             return false;
         }
@@ -101,7 +110,7 @@ export class HacknetServer extends React.Component {
                 multiplier = Math.min(levelsToMax, purchaseMult);
             }
 
-            const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, Player);
+            const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, Player.hacknet_node_core_cost_mult);
             upgradeCoresText = `Upgrade x${multiplier} - ${numeralWrapper.formatMoney(upgradeCoreCost)}`;
             if (Player.money.lt(upgradeCoreCost)) {
                 upgradeCoresClass = "std-button-disabled";
@@ -114,7 +123,7 @@ export class HacknetServer extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberCoreUpgrades(node, HacknetServerMaxCores);
             }
-            node.purchaseCoreUpgrade(numUpgrades, Player);
+            purchaseCoreUpgrade(node, numUpgrades);
             recalculate();
             return false;
         }
@@ -146,9 +155,9 @@ export class HacknetServer extends React.Component {
             if (purchaseMult === "MAX") {
                 numUpgrades = getMaxNumberCacheUpgrades(node, HacknetServerMaxCache);
             }
-            node.purchaseCacheUpgrade(numUpgrades, Player);
+            purchaseCacheUpgrade(node, numUpgrades);
             recalculate();
-            Player.hashManager.updateCapacity(Player);
+            updateHashManagerCapacity();
             return false;
         }