commit1

src/Hacknet/HacknetHelpers.tsx

@@ -18,17 +18,17 @@ import { HashUpgrades } from "./HashUpgrades";
 
 import { generateRandomContract } from "../CodingContractGenerator";
 import { iTutorialSteps, iTutorialNextStep, ITutorial } from "../InteractiveTutorial";
-import { IPlayer } from "../PersonObjects/IPlayer";
+import { Player } from "../Player";
 import { GetServer } from "../Server/AllServers";
 import { Server } from "../Server/Server";
 
 // Returns a boolean indicating whether the player has Hacknet Servers
 // (the upgraded form of Hacknet Nodes)
-export function hasHacknetServers(player: IPlayer): boolean {
-  return player.bitNodeN === 9 || player.sourceFileLvl(9) > 0;
+export function hasHacknetServers(): boolean {
+  return Player.bitNodeN === 9 || Player.sourceFileLvl(9) > 0;
 }
 
-export function purchaseHacknet(player: IPlayer): number {
+export function purchaseHacknet(): number {
   /* INTERACTIVE TUTORIAL */
   if (ITutorial.isRunning) {
     if (ITutorial.currStep === iTutorialSteps.HacknetNodesIntroduction) {
@@ -39,72 +39,68 @@ export function purchaseHacknet(player: IPlayer): number {
   }
   /* END INTERACTIVE TUTORIAL */
 
-  const numOwned = player.hacknetNodes.length;
-  if (hasHacknetServers(player)) {
-    const cost = getCostOfNextHacknetServer(player);
+  const numOwned = Player.hacknetNodes.length;
+  if (hasHacknetServers()) {
+    const cost = getCostOfNextHacknetServer();
     if (isNaN(cost)) {
       throw new Error(`Calculated cost of purchasing HacknetServer is NaN`);
     }
 
-    if (!player.canAfford(cost) || numOwned >= HacknetServerConstants.MaxServers) {
+    if (!Player.canAfford(cost) || numOwned >= HacknetServerConstants.MaxServers) {
       return -1;
     }
-    player.loseMoney(cost, "hacknet_expenses");
-    player.createHacknetServer();
-    updateHashManagerCapacity(player);
+    Player.loseMoney(cost, "hacknet_expenses");
+    Player.createHacknetServer();
+    updateHashManagerCapacity();
 
     return numOwned;
   } else {
-    const cost = getCostOfNextHacknetNode(player);
+    const cost = getCostOfNextHacknetNode();
     if (isNaN(cost)) {
       throw new Error(`Calculated cost of purchasing HacknetNode is NaN`);
     }
 
-    if (!player.canAfford(cost)) {
+    if (!Player.canAfford(cost)) {
       return -1;
     }
 
     // Auto generate a name for the Node
     const name = "hacknet-node-" + numOwned;
-    const node = new HacknetNode(name, player.mults.hacknet_node_money);
+    const node = new HacknetNode(name, Player.mults.hacknet_node_money);
 
-    player.loseMoney(cost, "hacknet_expenses");
-    player.hacknetNodes.push(node);
+    Player.loseMoney(cost, "hacknet_expenses");
+    Player.hacknetNodes.push(node);
 
     return numOwned;
   }
 }
 
-export function hasMaxNumberHacknetServers(player: IPlayer): boolean {
-  return hasHacknetServers(player) && player.hacknetNodes.length >= HacknetServerConstants.MaxServers;
+export function hasMaxNumberHacknetServers(): boolean {
+  return hasHacknetServers() && Player.hacknetNodes.length >= HacknetServerConstants.MaxServers;
 }
 
-export function getCostOfNextHacknetNode(player: IPlayer): number {
-  return calculateNodeCost(player.hacknetNodes.length + 1, player.mults.hacknet_node_purchase_cost);
+export function getCostOfNextHacknetNode(): number {
+  return calculateNodeCost(Player.hacknetNodes.length + 1, Player.mults.hacknet_node_purchase_cost);
 }
 
-export function getCostOfNextHacknetServer(player: IPlayer): number {
-  return calculateServerCost(player.hacknetNodes.length + 1, player.mults.hacknet_node_purchase_cost);
+export function getCostOfNextHacknetServer(): number {
+  return calculateServerCost(Player.hacknetNodes.length + 1, Player.mults.hacknet_node_purchase_cost);
 }
 
 // Calculate the maximum number of times the Player can afford to upgrade a Hacknet Node's level
-export function getMaxNumberLevelUpgrades(
-  player: IPlayer,
-  nodeObj: HacknetNode | HacknetServer,
-  maxLevel: number,
-): number {
+export function getMaxNumberLevelUpgrades(nodeObj: HacknetNode | HacknetServer, maxLevel: number): number {
   if (maxLevel == null) {
     throw new Error(`getMaxNumberLevelUpgrades() called without maxLevel arg`);
   }
 
-  if (player.money < nodeObj.calculateLevelUpgradeCost(1, player.mults.hacknet_node_level_cost)) {
+  if (Player.money < nodeObj.calculateLevelUpgradeCost(1, Player.mults.hacknet_node_level_cost)) {
     return 0;
   }
 
   let min = 1;
   let max = maxLevel - 1;
   const levelsToMax = maxLevel - nodeObj.level;
-  if (player.money > nodeObj.calculateLevelUpgradeCost(levelsToMax, player.mults.hacknet_node_level_cost)) {
+  if (Player.money > nodeObj.calculateLevelUpgradeCost(levelsToMax, Player.mults.hacknet_node_level_cost)) {
     return levelsToMax;
   }
 
@@ -112,13 +108,13 @@ export function getMaxNumberLevelUpgrades(
     const curr = ((min + max) / 2) | 0;
     if (
       curr !== maxLevel &&
-      player.money > nodeObj.calculateLevelUpgradeCost(curr, player.mults.hacknet_node_level_cost) &&
-      player.money < nodeObj.calculateLevelUpgradeCost(curr + 1, player.mults.hacknet_node_level_cost)
+      Player.money > nodeObj.calculateLevelUpgradeCost(curr, Player.mults.hacknet_node_level_cost) &&
+      Player.money < nodeObj.calculateLevelUpgradeCost(curr + 1, Player.mults.hacknet_node_level_cost)
     ) {
       return Math.min(levelsToMax, curr);
-    } else if (player.money < nodeObj.calculateLevelUpgradeCost(curr, player.mults.hacknet_node_level_cost)) {
+    } else if (Player.money < nodeObj.calculateLevelUpgradeCost(curr, Player.mults.hacknet_node_level_cost)) {
       max = curr - 1;
-    } else if (player.money > nodeObj.calculateLevelUpgradeCost(curr, player.mults.hacknet_node_level_cost)) {
+    } else if (Player.money > nodeObj.calculateLevelUpgradeCost(curr, Player.mults.hacknet_node_level_cost)) {
       min = curr + 1;
     } else {
       return Math.min(levelsToMax, curr);
@@ -128,16 +124,12 @@ export function getMaxNumberLevelUpgrades(
 }
 
 // Calculate the maximum number of times the Player can afford to upgrade a Hacknet Node's RAM
-export function getMaxNumberRamUpgrades(
-  player: IPlayer,
-  nodeObj: HacknetNode | HacknetServer,
-  maxLevel: number,
-): number {
+export function getMaxNumberRamUpgrades(nodeObj: HacknetNode | HacknetServer, maxLevel: number): number {
   if (maxLevel == null) {
     throw new Error(`getMaxNumberRamUpgrades() called without maxLevel arg`);
   }
 
-  if (player.money < nodeObj.calculateRamUpgradeCost(1, player.mults.hacknet_node_ram_cost)) {
+  if (Player.money < nodeObj.calculateRamUpgradeCost(1, Player.mults.hacknet_node_ram_cost)) {
     return 0;
   }
 
@@ -147,13 +139,13 @@ export function getMaxNumberRamUpgrades(
   } else {
     levelsToMax = Math.round(Math.log2(maxLevel / nodeObj.ram));
   }
-  if (player.money > nodeObj.calculateRamUpgradeCost(levelsToMax, player.mults.hacknet_node_ram_cost)) {
+  if (Player.money > nodeObj.calculateRamUpgradeCost(levelsToMax, Player.mults.hacknet_node_ram_cost)) {
     return levelsToMax;
   }
 
   //We'll just loop until we find the max
   for (let i = levelsToMax - 1; i >= 0; --i) {
-    if (player.money > nodeObj.calculateRamUpgradeCost(i, player.mults.hacknet_node_ram_cost)) {
+    if (Player.money > nodeObj.calculateRamUpgradeCost(i, Player.mults.hacknet_node_ram_cost)) {
       return i;
     }
   }
@@ -162,7 +154,6 @@ export function getMaxNumberRamUpgrades(
 
 // Calculate the maximum number of times the Player can afford to upgrade a Hacknet Node's cores
 export function getMaxNumberCoreUpgrades(
-  player: IPlayer,
   nodeObj: HacknetNode | HacknetServer,
   maxLevel: number,
 ): number {
@@ -170,14 +161,14 @@ export function getMaxNumberCoreUpgrades(
     throw new Error(`getMaxNumberCoreUpgrades() called without maxLevel arg`);
   }
 
-  if (player.money < nodeObj.calculateCoreUpgradeCost(1, player.mults.hacknet_node_core_cost)) {
+  if (Player.money < nodeObj.calculateCoreUpgradeCost(1, Player.mults.hacknet_node_core_cost)) {
     return 0;
   }
 
   let min = 1;
   let max = maxLevel - 1;
   const levelsToMax = maxLevel - nodeObj.cores;
-  if (player.money > nodeObj.calculateCoreUpgradeCost(levelsToMax, player.mults.hacknet_node_core_cost)) {
+  if (Player.money > nodeObj.calculateCoreUpgradeCost(levelsToMax, Player.mults.hacknet_node_core_cost)) {
     return levelsToMax;
   }
 
@@ -186,13 +177,13 @@ export function getMaxNumberCoreUpgrades(
     const curr = ((min + max) / 2) | 0;
     if (
       curr != maxLevel &&
-      player.money > nodeObj.calculateCoreUpgradeCost(curr, player.mults.hacknet_node_core_cost) &&
-      player.money < nodeObj.calculateCoreUpgradeCost(curr + 1, player.mults.hacknet_node_core_cost)
+      Player.money > nodeObj.calculateCoreUpgradeCost(curr, Player.mults.hacknet_node_core_cost) &&
+      Player.money < nodeObj.calculateCoreUpgradeCost(curr + 1, Player.mults.hacknet_node_core_cost)
     ) {
       return Math.min(levelsToMax, curr);
-    } else if (player.money < nodeObj.calculateCoreUpgradeCost(curr, player.mults.hacknet_node_core_cost)) {
+    } else if (Player.money < nodeObj.calculateCoreUpgradeCost(curr, Player.mults.hacknet_node_core_cost)) {
       max = curr - 1;
-    } else if (player.money > nodeObj.calculateCoreUpgradeCost(curr, player.mults.hacknet_node_core_cost)) {
+    } else if (Player.money > nodeObj.calculateCoreUpgradeCost(curr, Player.mults.hacknet_node_core_cost)) {
       min = curr + 1;
     } else {
       return Math.min(levelsToMax, curr);
@@ -203,19 +194,19 @@ export function getMaxNumberCoreUpgrades(
 }
 
 // Calculate the maximum number of times the Player can afford to upgrade a Hacknet Node's cache
-export function getMaxNumberCacheUpgrades(player: IPlayer, nodeObj: HacknetServer, maxLevel: number): number {
+export function getMaxNumberCacheUpgrades(nodeObj: HacknetServer, maxLevel: number): number {
   if (maxLevel == null) {
     throw new Error(`getMaxNumberCacheUpgrades() called without maxLevel arg`);
   }
 
-  if (!player.canAfford(nodeObj.calculateCacheUpgradeCost(1))) {
+  if (!Player.canAfford(nodeObj.calculateCacheUpgradeCost(1))) {
     return 0;
   }
 
   let min = 1;
   let max = maxLevel - 1;
   const levelsToMax = maxLevel - nodeObj.cache;
-  if (player.canAfford(nodeObj.calculateCacheUpgradeCost(levelsToMax))) {
+  if (Player.canAfford(nodeObj.calculateCacheUpgradeCost(levelsToMax))) {
     return levelsToMax;
   }
 
@@ -224,13 +215,13 @@ export function getMaxNumberCacheUpgrades(player: IPlayer, nodeObj: HacknetServe
     const curr = ((min + max) / 2) | 0;
     if (
       curr != maxLevel &&
-      player.canAfford(nodeObj.calculateCacheUpgradeCost(curr)) &&
-      !player.canAfford(nodeObj.calculateCacheUpgradeCost(curr + 1))
+      Player.canAfford(nodeObj.calculateCacheUpgradeCost(curr)) &&
+      !Player.canAfford(nodeObj.calculateCacheUpgradeCost(curr + 1))
     ) {
       return Math.min(levelsToMax, curr);
-    } else if (!player.canAfford(nodeObj.calculateCacheUpgradeCost(curr))) {
+    } else if (!Player.canAfford(nodeObj.calculateCacheUpgradeCost(curr))) {
       max = curr - 1;
-    } else if (player.canAfford(nodeObj.calculateCacheUpgradeCost(curr))) {
+    } else if (Player.canAfford(nodeObj.calculateCacheUpgradeCost(curr))) {
       min = curr + 1;
     } else {
       return Math.min(levelsToMax, curr);
@@ -240,9 +231,9 @@ export function getMaxNumberCacheUpgrades(player: IPlayer, nodeObj: HacknetServe
   return 0;
 }
 
-export function purchaseLevelUpgrade(player: IPlayer, node: HacknetNode | HacknetServer, levels = 1): boolean {
+export function purchaseLevelUpgrade(node: HacknetNode | HacknetServer, levels = 1): boolean {
   const sanitizedLevels = Math.round(levels);
-  const cost = node.calculateLevelUpgradeCost(sanitizedLevels, player.mults.hacknet_node_level_cost);
+  const cost = node.calculateLevelUpgradeCost(sanitizedLevels, Player.mults.hacknet_node_level_cost);
   if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
     return false;
   }
@@ -258,22 +249,22 @@ export function purchaseLevelUpgrade(player: IPlayer, node: HacknetNode | Hackne
   // the maximum number of upgrades and use that
   if (node.level + sanitizedLevels > (isServer ? HacknetServerConstants.MaxLevel : HacknetNodeConstants.MaxLevel)) {
     const diff = Math.max(0, (isServer ? HacknetServerConstants.MaxLevel : HacknetNodeConstants.MaxLevel) - node.level);
-    return purchaseLevelUpgrade(player, node, diff);
+    return purchaseLevelUpgrade(node, diff);
   }
 
-  if (!player.canAfford(cost)) {
+  if (!Player.canAfford(cost)) {
     return false;
   }
 
-  player.loseMoney(cost, "hacknet_expenses");
-  node.upgradeLevel(sanitizedLevels, player.mults.hacknet_node_money);
+  Player.loseMoney(cost, "hacknet_expenses");
+  node.upgradeLevel(sanitizedLevels, Player.mults.hacknet_node_money);
 
   return true;
 }
 
-export function purchaseRamUpgrade(player: IPlayer, node: HacknetNode | HacknetServer, levels = 1): boolean {
+export function purchaseRamUpgrade(node: HacknetNode | HacknetServer, levels = 1): boolean {
   const sanitizedLevels = Math.round(levels);
-  const cost = node.calculateRamUpgradeCost(sanitizedLevels, player.mults.hacknet_node_ram_cost);
+  const cost = node.calculateRamUpgradeCost(sanitizedLevels, Player.mults.hacknet_node_ram_cost);
   if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
     return false;
   }
@@ -291,28 +282,28 @@ export function purchaseRamUpgrade(player: IPlayer, node: HacknetNode | HacknetS
   if (node instanceof HacknetServer) {
     if (node.maxRam * Math.pow(2, sanitizedLevels) > HacknetServerConstants.MaxRam) {
       const diff = Math.max(0, Math.log2(Math.round(HacknetServerConstants.MaxRam / node.maxRam)));
-      return purchaseRamUpgrade(player, node, diff);
+      return purchaseRamUpgrade(node, diff);
     }
   } else if (node instanceof HacknetNode) {
     if (node.ram * Math.pow(2, sanitizedLevels) > HacknetNodeConstants.MaxRam) {
       const diff = Math.max(0, Math.log2(Math.round(HacknetNodeConstants.MaxRam / node.ram)));
-      return purchaseRamUpgrade(player, node, diff);
+      return purchaseRamUpgrade(node, diff);
     }
   }
 
-  if (!player.canAfford(cost)) {
+  if (!Player.canAfford(cost)) {
     return false;
   }
 
-  player.loseMoney(cost, "hacknet_expenses");
-  node.upgradeRam(sanitizedLevels, player.mults.hacknet_node_money);
+  Player.loseMoney(cost, "hacknet_expenses");
+  node.upgradeRam(sanitizedLevels, Player.mults.hacknet_node_money);
 
   return true;
 }
 
-export function purchaseCoreUpgrade(player: IPlayer, node: HacknetNode | HacknetServer, levels = 1): boolean {
+export function purchaseCoreUpgrade(node: HacknetNode | HacknetServer, levels = 1): boolean {
   const sanitizedLevels = Math.round(levels);
-  const cost = node.calculateCoreUpgradeCost(sanitizedLevels, player.mults.hacknet_node_core_cost);
+  const cost = node.calculateCoreUpgradeCost(sanitizedLevels, Player.mults.hacknet_node_core_cost);
   if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
     return false;
   }
@@ -328,20 +319,20 @@ export function purchaseCoreUpgrade(player: IPlayer, node: HacknetNode | Hacknet
   // the max possible number of upgrades and use that
   if (node.cores + sanitizedLevels > (isServer ? HacknetServerConstants.MaxCores : HacknetNodeConstants.MaxCores)) {
     const diff = Math.max(0, (isServer ? HacknetServerConstants.MaxCores : HacknetNodeConstants.MaxCores) - node.cores);
-    return purchaseCoreUpgrade(player, node, diff);
+    return purchaseCoreUpgrade(node, diff);
   }
 
-  if (!player.canAfford(cost)) {
+  if (!Player.canAfford(cost)) {
     return false;
   }
 
-  player.loseMoney(cost, "hacknet_expenses");
-  node.upgradeCore(sanitizedLevels, player.mults.hacknet_node_money);
+  Player.loseMoney(cost, "hacknet_expenses");
+  node.upgradeCore(sanitizedLevels, Player.mults.hacknet_node_money);
 
   return true;
 }
 
-export function purchaseCacheUpgrade(player: IPlayer, node: HacknetServer, levels = 1): boolean {
+export function purchaseCacheUpgrade(node: HacknetServer, levels = 1): boolean {
   const sanitizedLevels = Math.round(levels);
   const cost = node.calculateCacheUpgradeCost(sanitizedLevels);
   if (isNaN(cost) || cost <= 0 || sanitizedLevels < 0) {
@@ -356,71 +347,71 @@ export function purchaseCacheUpgrade(player: IPlayer, node: HacknetServer, level
   // Fail if we're already at max
   if (node.cache + sanitizedLevels > HacknetServerConstants.MaxCache) {
     const diff = Math.max(0, HacknetServerConstants.MaxCache - node.cache);
-    return purchaseCacheUpgrade(player, node, diff);
+    return purchaseCacheUpgrade(node, diff);
   }
 
-  if (!player.canAfford(cost)) {
+  if (!Player.canAfford(cost)) {
     return false;
   }
 
-  player.loseMoney(cost, "hacknet_expenses");
+  Player.loseMoney(cost, "hacknet_expenses");
   node.upgradeCache(sanitizedLevels);
 
   return true;
 }
 
-export function processHacknetEarnings(player: IPlayer, numCycles: number): number {
+export function processHacknetEarnings(numCycles: number): number {
   // Determine if player has Hacknet Nodes or Hacknet Servers, then
   // call the appropriate function
-  if (player.hacknetNodes.length === 0) {
+  if (Player.hacknetNodes.length === 0) {
     return 0;
   }
-  if (hasHacknetServers(player)) {
-    return processAllHacknetServerEarnings(player, numCycles);
-  } else if (player.hacknetNodes[0] instanceof HacknetNode) {
-    return processAllHacknetNodeEarnings(player, numCycles);
+  if (hasHacknetServers()) {
+    return processAllHacknetServerEarnings(numCycles);
+  } else if (Player.hacknetNodes[0] instanceof HacknetNode) {
+    return processAllHacknetNodeEarnings(numCycles);
   } else {
     return 0;
   }
 }
 
-function processAllHacknetNodeEarnings(player: IPlayer, numCycles: number): number {
+function processAllHacknetNodeEarnings(numCycles: number): number {
   let total = 0;
-  for (let i = 0; i < player.hacknetNodes.length; ++i) {
-    const node = player.hacknetNodes[i];
+  for (let i = 0; i < Player.hacknetNodes.length; ++i) {
+    const node = Player.hacknetNodes[i];
     if (typeof node === "string") throw new Error("player node should not be ip string");
-    total += processSingleHacknetNodeEarnings(player, numCycles, node);
+    total += processSingleHacknetNodeEarnings(numCycles, node);
   }
 
   return total;
 }
 
-function processSingleHacknetNodeEarnings(player: IPlayer, numCycles: number, nodeObj: HacknetNode): number {
+function processSingleHacknetNodeEarnings(numCycles: number, nodeObj: HacknetNode): number {
   const totalEarnings = nodeObj.process(numCycles);
-  player.gainMoney(totalEarnings, "hacknet");
+  Player.gainMoney(totalEarnings, "hacknet");
 
   return totalEarnings;
 }
 
-function processAllHacknetServerEarnings(player: IPlayer, numCycles: number): number {
-  if (!(player.hashManager instanceof HashManager)) {
+function processAllHacknetServerEarnings(numCycles: number): number {
+  if (!(Player.hashManager instanceof HashManager)) {
     throw new Error(`Player does not have a HashManager (should be in 'hashManager' prop)`);
   }
 
   let hashes = 0;
-  for (let i = 0; i < player.hacknetNodes.length; ++i) {
+  for (let i = 0; i < Player.hacknetNodes.length; ++i) {
     // hacknetNodes array only contains the IP addresses of the servers.
     // Also, update the hash rate before processing
-    const ip = player.hacknetNodes[i];
+    const ip = Player.hacknetNodes[i];
     if (ip instanceof HacknetNode) throw new Error(`player nodes should not be HacketNode`);
     const hserver = GetServer(ip);
     if (!(hserver instanceof HacknetServer)) throw new Error(`player nodes shoud not be Server`);
-    hserver.updateHashRate(player.mults.hacknet_node_money);
+    hserver.updateHashRate(Player.mults.hacknet_node_money);
     const h = hserver.process(numCycles);
     hashes += h;
   }
 
-  const wastedHashes = player.hashManager.storeHashes(hashes);
+  const wastedHashes = Player.hashManager.storeHashes(hashes);
   if (wastedHashes > 0) {
     const upgrade = HashUpgrades["Sell for Money"];
     if (upgrade === null) throw new Error("Could not get the hash upgrade");
@@ -428,65 +419,65 @@ function processAllHacknetServerEarnings(player: IPlayer, numCycles: number): nu
 
     const multiplier = wastedHashes / upgrade.cost;
     if (multiplier > 0) {
-      player.gainMoney(upgrade.value * multiplier, "hacknet");
+      Player.gainMoney(upgrade.value * multiplier, "hacknet");
     }
   }
 
   return hashes;
 }
 
-export function updateHashManagerCapacity(player: IPlayer): void {
-  if (!(player.hashManager instanceof HashManager)) {
+export function updateHashManagerCapacity(): void {
+  if (!(Player.hashManager instanceof HashManager)) {
     console.error(`Player does not have a HashManager`);
     return;
   }
 
-  const nodes = player.hacknetNodes;
+  const nodes = Player.hacknetNodes;
   if (nodes.length === 0) {
-    player.hashManager.updateCapacity(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);
+      Player.hashManager.updateCapacity(0);
       return;
     }
     const ip = nodes[i];
     if (ip instanceof HacknetNode) throw new Error(`player nodes should be string but isn't`);
     const h = GetServer(ip);
     if (!(h instanceof HacknetServer)) {
-      player.hashManager.updateCapacity(0);
+      Player.hashManager.updateCapacity(0);
       return;
     }
 
     total += h.hashCapacity;
   }
 
-  player.hashManager.updateCapacity(total);
+  Player.hashManager.updateCapacity(total);
 }
 
-export function purchaseHashUpgrade(player: IPlayer, upgName: string, upgTarget: string, count = 1): boolean {
-  if (!(player.hashManager instanceof HashManager)) {
+export function purchaseHashUpgrade(upgName: string, upgTarget: string, count = 1): boolean {
+  if (!(Player.hashManager instanceof HashManager)) {
     console.error(`Player does not have a HashManager`);
     return false;
   }
 
   // HashManager handles the transaction. This just needs to actually implement
   // the effects of the upgrade
-  if (player.hashManager.upgrade(upgName, count)) {
+  if (Player.hashManager.upgrade(upgName, count)) {
     const upg = HashUpgrades[upgName];
 
     switch (upgName) {
       case "Sell for Money": {
-        player.gainMoney(upg.value * count, "hacknet");
+        Player.gainMoney(upg.value * count, "hacknet");
         break;
       }
       case "Sell for Corporation Funds": {
-        const corp = player.corporation;
+        const corp = Player.corporation;
         if (corp === null) {
-          player.hashManager.refundUpgrade(upgName, count);
+          Player.hashManager.refundUpgrade(upgName, count);
           return false;
         }
         corp.funds = corp.funds + upg.value * count;
@@ -503,7 +494,7 @@ export function purchaseHashUpgrade(player: IPlayer, upgName: string, upgTarget:
 
           target.changeMinimumSecurity(upg.value ** count, true);
         } catch (e) {
-          player.hashManager.refundUpgrade(upgName, count);
+          Player.hashManager.refundUpgrade(upgName, count);
           return false;
         }
         break;
@@ -522,7 +513,7 @@ export function purchaseHashUpgrade(player: IPlayer, upgName: string, upgTarget:
             target.changeMaximumMoney(upg.value);
           }
         } catch (e) {
-          player.hashManager.refundUpgrade(upgName, count);
+          Player.hashManager.refundUpgrade(upgName, count);
           return false;
         }
         break;
@@ -537,9 +528,9 @@ export function purchaseHashUpgrade(player: IPlayer, upgName: string, upgTarget:
       }
       case "Exchange for Corporation Research": {
         // This will throw if player doesn't have a corporation
-        const corp = player.corporation;
+        const corp = Player.corporation;
         if (corp === null) {
-          player.hashManager.refundUpgrade(upgName, count);
+          Player.hashManager.refundUpgrade(upgName, count);
           return false;
         }
         for (const division of corp.divisions) {
@@ -549,19 +540,19 @@ export function purchaseHashUpgrade(player: IPlayer, upgName: string, upgTarget:
       }
       case "Exchange for Bladeburner Rank": {
         // This will throw if player isnt in Bladeburner
-        const bladeburner = player.bladeburner;
+        const bladeburner = Player.bladeburner;
         if (bladeburner === null) {
-          player.hashManager.refundUpgrade(upgName, count);
+          Player.hashManager.refundUpgrade(upgName, count);
           return false;
         }
-        bladeburner.changeRank(player, upg.value * count);
+        bladeburner.changeRank(Player, upg.value * count);
         break;
       }
       case "Exchange for Bladeburner SP": {
         // This will throw if player isnt in Bladeburner
-        const bladeburner = player.bladeburner;
+        const bladeburner = Player.bladeburner;
         if (bladeburner === null) {
-          player.hashManager.refundUpgrade(upgName, count);
+          Player.hashManager.refundUpgrade(upgName, count);
           return false;
         }