felixfoertsch/bitburner-src
1
0
Fork 0
mirror of https://github.com/bitburner-official/bitburner-src.git synced 2026-04-17 14:59:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

commit1

Browse Source
This commit is contained in:
Snarling
2022-09-06 09:07:12 -04:00
parent cc2246213f
commit 83d357e758
203 changed files with 2263 additions and 3018 deletions
Download Patch File Download Diff File Expand all files Collapse all files

229
src/Hacknet/HacknetHelpers.tsx
View File

@@ -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;
}

39
src/Hacknet/ui/HacknetNodeElem.tsx
View File

@@ -14,7 +14,7 @@ import {
purchaseCoreUpgrade,
} from "../HacknetHelpers";
import { IPlayer } from "../../PersonObjects/IPlayer";
import { Player } from "../../Player";
import { HacknetNode } from "../HacknetNode";
import { Money } from "../../ui/React/Money";
@@ -36,7 +36,6 @@ interface IProps {
node: HacknetNode;
purchaseMultiplier: number | "MAX";
rerender: () => void;
player: IPlayer;
}
export function HacknetNodeElem(props: IProps): React.ReactElement {
@@ -51,16 +50,16 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberLevelUpgrades(props.player, node, HacknetNodeConstants.MaxLevel);
multiplier = getMaxNumberLevelUpgrades(node, HacknetNodeConstants.MaxLevel);
} else {
const levelsToMax = HacknetNodeConstants.MaxLevel - node.level;
multiplier = Math.min(levelsToMax, purchaseMult);
}
const increase =
calculateMoneyGainRate(node.level + multiplier, node.ram, node.cores, props.player.mults.hacknet_node_money) -
calculateMoneyGainRate(node.level + multiplier, node.ram, node.cores, Player.mults.hacknet_node_money) -
node.moneyGainRatePerSecond;
const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, props.player.mults.hacknet_node_level_cost);
const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, Player.mults.hacknet_node_level_cost);
upgradeLevelButton = (
<Tooltip
title={
@@ -71,7 +70,7 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeLevelOnClick}>
+{multiplier} -&nbsp;
<Money money={upgradeLevelCost} player={props.player} />
<Money money={upgradeLevelCost} forPurchase={true} />
</Button>
</Tooltip>
);
@@ -79,9 +78,9 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
function upgradeLevelOnClick(): void {
const numUpgrades =
purchaseMult === "MAX"
? getMaxNumberLevelUpgrades(props.player, node, HacknetNodeConstants.MaxLevel)
? getMaxNumberLevelUpgrades(node, HacknetNodeConstants.MaxLevel)
: purchaseMult;
purchaseLevelUpgrade(props.player, node, numUpgrades);
purchaseLevelUpgrade(node, numUpgrades);
rerender();
}
@@ -91,7 +90,7 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberRamUpgrades(props.player, node, HacknetNodeConstants.MaxRam);
multiplier = getMaxNumberRamUpgrades(node, HacknetNodeConstants.MaxRam);
} else {
const levelsToMax = Math.round(Math.log2(HacknetNodeConstants.MaxRam / node.ram));
multiplier = Math.min(levelsToMax, purchaseMult);
@@ -102,9 +101,9 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
node.level,
node.ram * Math.pow(2, multiplier),
node.cores,
props.player.mults.hacknet_node_money,
Player.mults.hacknet_node_money,
) - node.moneyGainRatePerSecond;
const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, props.player.mults.hacknet_node_ram_cost);
const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, Player.mults.hacknet_node_ram_cost);
upgradeRAMButton = (
<Tooltip
title={
@@ -115,24 +114,24 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeRamOnClick}>
+{multiplier} -&nbsp;
<Money money={upgradeRamCost} player={props.player} />
<Money money={upgradeRamCost} forPurchase={true} />
</Button>
</Tooltip>
);
}
function upgradeRamOnClick(): void {
const numUpgrades =
purchaseMult === "MAX" ? getMaxNumberRamUpgrades(props.player, node, HacknetNodeConstants.MaxRam) : purchaseMult;
purchaseRamUpgrade(props.player, node, numUpgrades);
purchaseMult === "MAX" ? getMaxNumberRamUpgrades(node, HacknetNodeConstants.MaxRam) : purchaseMult;
purchaseRamUpgrade(node, numUpgrades);
rerender();
}
function upgradeCoresOnClick(): void {
const numUpgrades =
purchaseMult === "MAX"
? getMaxNumberCoreUpgrades(props.player, node, HacknetNodeConstants.MaxCores)
? getMaxNumberCoreUpgrades(node, HacknetNodeConstants.MaxCores)
: purchaseMult;
purchaseCoreUpgrade(props.player, node, numUpgrades);
purchaseCoreUpgrade(node, numUpgrades);
rerender();
}
let upgradeCoresButton;
@@ -141,16 +140,16 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberCoreUpgrades(props.player, node, HacknetNodeConstants.MaxCores);
multiplier = getMaxNumberCoreUpgrades(node, HacknetNodeConstants.MaxCores);
} else {
const levelsToMax = HacknetNodeConstants.MaxCores - node.cores;
multiplier = Math.min(levelsToMax, purchaseMult);
}
const increase =
calculateMoneyGainRate(node.level, node.ram, node.cores + multiplier, props.player.mults.hacknet_node_money) -
calculateMoneyGainRate(node.level, node.ram, node.cores + multiplier, Player.mults.hacknet_node_money) -
node.moneyGainRatePerSecond;
const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, props.player.mults.hacknet_node_core_cost);
const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, Player.mults.hacknet_node_core_cost);
upgradeCoresButton = (
<Tooltip
title={
@@ -161,7 +160,7 @@ export function HacknetNodeElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeCoresOnClick}>
+{multiplier} -&nbsp;
<Money money={upgradeCoreCost} player={props.player} />
<Money money={upgradeCoreCost} forPurchase={true} />
</Button>
</Tooltip>
);

43
src/Hacknet/ui/HacknetRoot.tsx
View File

@@ -21,7 +21,7 @@ import {
purchaseHacknet,
} from "../HacknetHelpers";
import { IPlayer } from "../../PersonObjects/IPlayer";
import { Player } from "../../Player";
import { GetServer } from "../../Server/AllServers";
import Typography from "@mui/material/Typography";
@@ -29,11 +29,7 @@ import Grid from "@mui/material/Grid";
import Button from "@mui/material/Button";
import { Box } from "@mui/material";
interface IProps {
player: IPlayer;
}
export function HacknetRoot(props: IProps): React.ReactElement {
export function HacknetRoot(): React.ReactElement {
const [open, setOpen] = useState(false);
const setRerender = useState(false)[1];
function rerender(): void {
@@ -47,9 +43,9 @@ export function HacknetRoot(props: IProps): React.ReactElement {
}, []);
let totalProduction = 0;
for (let i = 0; i < props.player.hacknetNodes.length; ++i) {
const node = props.player.hacknetNodes[i];
if (hasHacknetServers(props.player)) {
for (let i = 0; i < Player.hacknetNodes.length; ++i) {
const node = Player.hacknetNodes[i];
if (hasHacknetServers()) {
if (node instanceof HacknetNode) throw new Error("node was hacknet node"); // should never happen
const hserver = GetServer(node);
if (!(hserver instanceof HacknetServer)) throw new Error("node was not hacknet server"); // should never happen
@@ -65,16 +61,16 @@ export function HacknetRoot(props: IProps): React.ReactElement {
}
function handlePurchaseButtonClick(): void {
purchaseHacknet(props.player);
purchaseHacknet();
rerender();
}
// Cost to purchase a new Hacknet Node
let purchaseCost;
if (hasHacknetServers(props.player)) {
purchaseCost = getCostOfNextHacknetServer(props.player);
if (hasHacknetServers()) {
purchaseCost = getCostOfNextHacknetServer();
} else {
purchaseCost = getCostOfNextHacknetNode(props.player);
purchaseCost = getCostOfNextHacknetNode();
}
// onClick event handlers for purchase multiplier buttons
@@ -86,8 +82,8 @@ export function HacknetRoot(props: IProps): React.ReactElement {
];
// HacknetNode components
const nodes = props.player.hacknetNodes.map((node: string | HacknetNode) => {
if (hasHacknetServers(props.player)) {
const nodes = Player.hacknetNodes.map((node: string | HacknetNode) => {
if (hasHacknetServers()) {
if (node instanceof HacknetNode) throw new Error("node was hacknet node"); // should never happen
const hserver = GetServer(node);
if (hserver == null) {
@@ -96,7 +92,6 @@ export function HacknetRoot(props: IProps): React.ReactElement {
if (!(hserver instanceof HacknetServer)) throw new Error("node was not hacknet server"); // should never happen
return (
<HacknetServerElem
player={props.player}
key={hserver.hostname}
node={hserver}
purchaseMultiplier={purchaseMultiplier}
@@ -106,21 +101,15 @@ export function HacknetRoot(props: IProps): React.ReactElement {
} else {
if (typeof node === "string") throw new Error("node was ip string"); // should never happen
return (
<HacknetNodeElem
player={props.player}
key={node.name}
node={node}
purchaseMultiplier={purchaseMultiplier}
rerender={rerender}
/>
<HacknetNodeElem key={node.name} node={node} purchaseMultiplier={purchaseMultiplier} rerender={rerender} />
);
}
});
return (
<>
<Typography variant="h4">Hacknet {hasHacknetServers(props.player) ? "Servers" : "Nodes"}</Typography>
<GeneralInfo hasHacknetServers={hasHacknetServers(props.player)} />
<Typography variant="h4">Hacknet {hasHacknetServers() ? "Servers" : "Nodes"}</Typography>
<GeneralInfo hasHacknetServers={hasHacknetServers()} />
<PurchaseButton cost={purchaseCost} multiplier={purchaseMultiplier} onClick={handlePurchaseButtonClick} />
@@ -128,14 +117,14 @@ export function HacknetRoot(props: IProps): React.ReactElement {
<Grid container spacing={2}>
<Grid item xs={6}>
<PlayerInfo totalProduction={totalProduction} player={props.player} />
<PlayerInfo totalProduction={totalProduction} />
</Grid>
<Grid item xs={6}>
<MultiplierButtons onClicks={purchaseMultiplierOnClicks} purchaseMultiplier={purchaseMultiplier} />
</Grid>
</Grid>
{hasHacknetServers(props.player) && <Button onClick={() => setOpen(true)}>Spend Hashes on Upgrades</Button>}
{hasHacknetServers() && <Button onClick={() => setOpen(true)}>Spend Hashes on Upgrades</Button>}
<Box sx={{ display: "grid", width: "fit-content", gridTemplateColumns: "repeat(3, 1fr)" }}>{nodes}</Box>
<HashUpgradeModal open={open} onClose={() => setOpen(false)} />

61
src/Hacknet/ui/HacknetServerElem.tsx
View File

@@ -17,7 +17,7 @@ import {
updateHashManagerCapacity,
} from "../HacknetHelpers";
import { IPlayer } from "../../PersonObjects/IPlayer";
import { Player } from "../../Player";
import { HacknetServer } from "../HacknetServer";
import { Money } from "../../ui/React/Money";
@@ -39,7 +39,6 @@ interface IProps {
node: HacknetServer;
purchaseMultiplier: number | string;
rerender: () => void;
player: IPlayer;
}
export function HacknetServerElem(props: IProps): React.ReactElement {
@@ -54,7 +53,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberLevelUpgrades(props.player, node, HacknetServerConstants.MaxLevel);
multiplier = getMaxNumberLevelUpgrades(node, HacknetServerConstants.MaxLevel);
} else {
const levelsToMax = HacknetServerConstants.MaxLevel - node.level;
multiplier = Math.min(levelsToMax, purchaseMult as number);
@@ -66,11 +65,11 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
0,
node.maxRam,
node.cores,
props.player.mults.hacknet_node_money,
) - calculateHashGainRate(node.level, 0, node.maxRam, node.cores, props.player.mults.hacknet_node_money);
Player.mults.hacknet_node_money,
) - calculateHashGainRate(node.level, 0, node.maxRam, node.cores, Player.mults.hacknet_node_money);
const modded_increase = (base_increase * (node.maxRam - node.ramUsed)) / node.maxRam;
const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, props.player.mults.hacknet_node_level_cost);
const upgradeLevelCost = node.calculateLevelUpgradeCost(multiplier, Player.mults.hacknet_node_level_cost);
upgradeLevelButton = (
<Tooltip
title={
@@ -86,7 +85,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeLevelOnClick}>
+{multiplier}&nbsp;-&nbsp;
<Money money={upgradeLevelCost} player={props.player} />
<Money money={upgradeLevelCost} forPurchase={true} />
</Button>
</Tooltip>
);
@@ -94,18 +93,18 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
function upgradeLevelOnClick(): void {
let numUpgrades = purchaseMult;
if (purchaseMult === "MAX") {
numUpgrades = getMaxNumberLevelUpgrades(props.player, node, HacknetServerConstants.MaxLevel);
numUpgrades = getMaxNumberLevelUpgrades(node, HacknetServerConstants.MaxLevel);
}
purchaseLevelUpgrade(props.player, node, numUpgrades as number);
purchaseLevelUpgrade(node, numUpgrades as number);
rerender();
}
function upgradeRamOnClick(): void {
let numUpgrades = purchaseMult;
if (purchaseMult === "MAX") {
numUpgrades = getMaxNumberRamUpgrades(props.player, node, HacknetServerConstants.MaxRam);
numUpgrades = getMaxNumberRamUpgrades(node, HacknetServerConstants.MaxRam);
}
purchaseRamUpgrade(props.player, node, numUpgrades as number);
purchaseRamUpgrade(node, numUpgrades as number);
rerender();
}
// Upgrade RAM Button
@@ -115,7 +114,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberRamUpgrades(props.player, node, HacknetServerConstants.MaxRam);
multiplier = getMaxNumberRamUpgrades(node, HacknetServerConstants.MaxRam);
} else {
const levelsToMax = Math.round(Math.log2(HacknetServerConstants.MaxRam / node.maxRam));
multiplier = Math.min(levelsToMax, purchaseMult as number);
@@ -127,8 +126,8 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
0,
node.maxRam * Math.pow(2, multiplier),
node.cores,
props.player.mults.hacknet_node_money,
) - calculateHashGainRate(node.level, 0, node.maxRam, node.cores, props.player.mults.hacknet_node_money);
Player.mults.hacknet_node_money,
) - calculateHashGainRate(node.level, 0, node.maxRam, node.cores, Player.mults.hacknet_node_money);
const modded_increase =
calculateHashGainRate(
@@ -136,11 +135,11 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
node.ramUsed,
node.maxRam * Math.pow(2, multiplier),
node.cores,
props.player.mults.hacknet_node_money,
Player.mults.hacknet_node_money,
) -
calculateHashGainRate(node.level, node.ramUsed, node.maxRam, node.cores, props.player.mults.hacknet_node_money);
calculateHashGainRate(node.level, node.ramUsed, node.maxRam, node.cores, Player.mults.hacknet_node_money);
const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, props.player.mults.hacknet_node_ram_cost);
const upgradeRamCost = node.calculateRamUpgradeCost(multiplier, Player.mults.hacknet_node_ram_cost);
upgradeRamButton = (
<Tooltip
title={
@@ -156,7 +155,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeRamOnClick}>
+{multiplier}&nbsp;-&nbsp;
<Money money={upgradeRamCost} player={props.player} />
<Money money={upgradeRamCost} forPurchase={true} />
</Button>
</Tooltip>
);
@@ -165,9 +164,9 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
function upgradeCoresOnClick(): void {
let numUpgrades = purchaseMult;
if (purchaseMult === "MAX") {
numUpgrades = getMaxNumberCoreUpgrades(props.player, node, HacknetServerConstants.MaxCores);
numUpgrades = getMaxNumberCoreUpgrades(node, HacknetServerConstants.MaxCores);
}
purchaseCoreUpgrade(props.player, node, numUpgrades as number);
purchaseCoreUpgrade(node, numUpgrades as number);
rerender();
}
// Upgrade Cores Button
@@ -177,7 +176,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberCoreUpgrades(props.player, node, HacknetServerConstants.MaxCores);
multiplier = getMaxNumberCoreUpgrades(node, HacknetServerConstants.MaxCores);
} else {
const levelsToMax = HacknetServerConstants.MaxCores - node.cores;
multiplier = Math.min(levelsToMax, purchaseMult as number);
@@ -189,11 +188,11 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
0,
node.maxRam,
node.cores + multiplier,
props.player.mults.hacknet_node_money,
) - calculateHashGainRate(node.level, 0, node.maxRam, node.cores, props.player.mults.hacknet_node_money);
Player.mults.hacknet_node_money,
) - calculateHashGainRate(node.level, 0, node.maxRam, node.cores, Player.mults.hacknet_node_money);
const modded_increase = (base_increase * (node.maxRam - node.ramUsed)) / node.maxRam;
const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, props.player.mults.hacknet_node_core_cost);
const upgradeCoreCost = node.calculateCoreUpgradeCost(multiplier, Player.mults.hacknet_node_core_cost);
upgradeCoresButton = (
<Tooltip
title={
@@ -209,7 +208,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeCoresOnClick}>
+{multiplier}&nbsp;-&nbsp;
<Money money={upgradeCoreCost} player={props.player} />
<Money money={upgradeCoreCost} forPurchase={true} />
</Button>
</Tooltip>
);
@@ -222,7 +221,7 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
} else {
let multiplier = 0;
if (purchaseMult === "MAX") {
multiplier = getMaxNumberCacheUpgrades(props.player, node, HacknetServerConstants.MaxCache);
multiplier = getMaxNumberCacheUpgrades(node, HacknetServerConstants.MaxCache);
} else {
const levelsToMax = HacknetServerConstants.MaxCache - node.cache;
multiplier = Math.min(levelsToMax, purchaseMult as number);
@@ -240,22 +239,22 @@ export function HacknetServerElem(props: IProps): React.ReactElement {
>
<Button onClick={upgradeCacheOnClick}>
+{multiplier}&nbsp;-&nbsp;
<Money money={upgradeCacheCost} player={props.player} />
<Money money={upgradeCacheCost} forPurchase={true} />
</Button>
</Tooltip>
);
if (props.player.money < upgradeCacheCost) {
if (Player.money < upgradeCacheCost) {
} else {
}
}
function upgradeCacheOnClick(): void {
let numUpgrades = purchaseMult;
if (purchaseMult === "MAX") {
numUpgrades = getMaxNumberCacheUpgrades(props.player, node, HacknetServerConstants.MaxCache);
numUpgrades = getMaxNumberCacheUpgrades(node, HacknetServerConstants.MaxCache);
}
purchaseCacheUpgrade(props.player, node, numUpgrades as number);
purchaseCacheUpgrade(node, numUpgrades as number);
rerender();
updateHashManagerCapacity(props.player);
updateHashManagerCapacity();
}
return (

5
src/Hacknet/ui/HacknetUpgradeElem.tsx
View File

@@ -4,8 +4,6 @@ import { purchaseHashUpgrade } from "../HacknetHelpers";
import { HashManager } from "../HashManager";
import { HashUpgrade } from "../HashUpgrade";
import { IPlayer } from "../../PersonObjects/IPlayer";
import { ServerDropdown, ServerType } from "../../ui/React/ServerDropdown";
import { dialogBoxCreate } from "../../ui/React/DialogBox";
@@ -19,7 +17,6 @@ import { SelectChangeEvent } from "@mui/material/Select";
import { FactionNames } from "../../Faction/data/FactionNames";
interface IProps {
player: IPlayer;
hashManager: HashManager;
upg: HashUpgrade;
rerender: () => void;
@@ -39,7 +36,7 @@ export function HacknetUpgradeElem(props: IProps): React.ReactElement {
function purchase(): void {
const canPurchase = props.hashManager.hashes >= props.hashManager.getUpgradeCost(props.upg.name);
if (canPurchase) {
const res = purchaseHashUpgrade(props.player, props.upg.name, selectedServer);
const res = purchaseHashUpgrade(props.upg.name, selectedServer);
if (!res) {
dialogBoxCreate(
"Failed to purchase upgrade. This may be because you do not have enough hashes, " +

17
src/Hacknet/ui/HashUpgradeModal.tsx
View File

@@ -9,7 +9,7 @@ import { HashUpgrades } from "../HashUpgrades";
import { Hashes } from "../../ui/React/Hashes";
import { HacknetUpgradeElem } from "./HacknetUpgradeElem";
import { Modal } from "../../ui/React/Modal";
import { use } from "../../ui/Context";
import { Player } from "../../Player";
import Typography from "@mui/material/Typography";
interface IProps {
@@ -18,7 +18,6 @@ interface IProps {
}
export function HashUpgradeModal(props: IProps): React.ReactElement {
const player = use.Player();
const setRerender = useState(false)[1];
function rerender(): void {
setRerender((old) => !old);
@@ -29,7 +28,7 @@ export function HashUpgradeModal(props: IProps): React.ReactElement {
return () => clearInterval(id);
}, []);
const hashManager = player.hashManager;
const hashManager = Player.hashManager;
if (!(hashManager instanceof HashManager)) {
throw new Error(`Player does not have a HashManager)`);
}
@@ -39,19 +38,11 @@ export function HashUpgradeModal(props: IProps): React.ReactElement {
<>
<Typography>Spend your hashes on a variety of different upgrades</Typography>
<Typography>
Hashes: <Hashes hashes={player.hashManager.hashes} />
Hashes: <Hashes hashes={Player.hashManager.hashes} />
</Typography>
{Object.keys(HashUpgrades).map((upgName) => {
const upg = HashUpgrades[upgName];
return (
<HacknetUpgradeElem
player={player}
upg={upg}
hashManager={hashManager}
key={upg.name}
rerender={rerender}
/>
);
return <HacknetUpgradeElem upg={upg} hashManager={hashManager} key={upg.name} rerender={rerender} />;
})}
</>
</Modal>

10
src/Hacknet/ui/PlayerInfo.tsx
View File

@@ -7,7 +7,7 @@
import React from "react";
import { hasHacknetServers } from "../HacknetHelpers";
import { IPlayer } from "../../PersonObjects/IPlayer";
import { Player } from "../../Player";
import { Money } from "../../ui/React/Money";
import { MoneyRate } from "../../ui/React/MoneyRate";
import { HashRate } from "../../ui/React/HashRate";
@@ -16,11 +16,10 @@ import Typography from "@mui/material/Typography";
interface IProps {
totalProduction: number;
player: IPlayer;
}
export function PlayerInfo(props: IProps): React.ReactElement {
const hasServers = hasHacknetServers(props.player);
const hasServers = hasHacknetServers();
let prod;
if (hasServers) {
@@ -33,14 +32,13 @@ export function PlayerInfo(props: IProps): React.ReactElement {
<>
<Typography>
Money:
<Money money={props.player.money} />
<Money money={Player.money} />
</Typography>
{hasServers && (
<>
<Typography>
Hashes: <Hashes hashes={props.player.hashManager.hashes} /> /{" "}
<Hashes hashes={props.player.hashManager.capacity} />
Hashes: <Hashes hashes={Player.hashManager.hashes} /> / <Hashes hashes={Player.hashManager.capacity} />
</Typography>
</>
)}

8
src/Hacknet/ui/PurchaseButton.tsx
View File

@@ -18,14 +18,14 @@ interface IProps {
export function PurchaseButton(props: IProps): React.ReactElement {
const cost = props.cost;
let text;
if (hasHacknetServers(Player)) {
if (hasMaxNumberHacknetServers(Player)) {
if (hasHacknetServers()) {
if (hasMaxNumberHacknetServers()) {
text = <>Hacknet Server limit reached</>;
} else {
text = (
<>
Purchase Hacknet Server -&nbsp;
<Money money={cost} player={Player} />
<Money money={cost} forPurchase={true} />
</>
);
}
@@ -33,7 +33,7 @@ export function PurchaseButton(props: IProps): React.ReactElement {
text = (
<>
Purchase Hacknet Node -&nbsp;
<Money money={cost} player={Player} />
<Money money={cost} forPurchase={true} />
</>
);
}