2021-10-05 04:25:21 +02:00
|
|
|
import { INetscriptHelper } from "./INetscriptHelper";
|
|
|
|
import { IPlayer } from "../PersonObjects/IPlayer";
|
|
|
|
import { WorkerScript } from "../Netscript/WorkerScript";
|
|
|
|
import { HacknetServerConstants } from "../Hacknet/data/Constants";
|
|
|
|
import {
|
|
|
|
getCostOfNextHacknetNode,
|
|
|
|
getCostOfNextHacknetServer,
|
|
|
|
hasHacknetServers,
|
|
|
|
purchaseHacknet,
|
|
|
|
purchaseLevelUpgrade,
|
|
|
|
purchaseRamUpgrade,
|
|
|
|
purchaseCoreUpgrade,
|
|
|
|
purchaseCacheUpgrade,
|
|
|
|
purchaseHashUpgrade,
|
|
|
|
updateHashManagerCapacity,
|
|
|
|
} from "../Hacknet/HacknetHelpers";
|
|
|
|
import { HacknetServer } from "../Hacknet/HacknetServer";
|
|
|
|
import { HacknetNode } from "../Hacknet/HacknetNode";
|
2021-12-17 11:35:17 +01:00
|
|
|
import { HashUpgrades } from "../Hacknet/HashUpgrades";
|
|
|
|
import { HashUpgrade } from "../Hacknet/HashUpgrade";
|
2021-10-07 22:56:01 +02:00
|
|
|
import { GetServer } from "../Server/AllServers";
|
2021-10-05 04:25:21 +02:00
|
|
|
|
2021-11-04 01:19:52 +01:00
|
|
|
import { Hacknet as IHacknet, NodeStats } from "../ScriptEditor/NetscriptDefinitions";
|
2021-10-05 04:25:21 +02:00
|
|
|
|
2021-11-03 23:16:10 +01:00
|
|
|
export function NetscriptHacknet(player: IPlayer, workerScript: WorkerScript, helper: INetscriptHelper): IHacknet {
|
2021-10-05 04:25:21 +02:00
|
|
|
// Utility function to get Hacknet Node object
|
2022-03-17 00:50:56 +01:00
|
|
|
const getHacknetNode = function (i: number, callingFn = ""): HacknetNode | HacknetServer {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (i < 0 || i >= player.hacknetNodes.length) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(callingFn, "Index specified for Hacknet Node is out-of-bounds: " + i);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hasHacknetServers(player)) {
|
|
|
|
const hi = player.hacknetNodes[i];
|
|
|
|
if (typeof hi !== "string") throw new Error("hacknet node was not a string");
|
2021-10-07 22:56:01 +02:00
|
|
|
const hserver = GetServer(hi);
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!(hserver instanceof HacknetServer)) throw new Error("hacknet server was not actually hacknet server");
|
|
|
|
if (hserver == null) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(
|
|
|
|
callingFn,
|
|
|
|
`Could not get Hacknet Server for index ${i}. This is probably a bug, please report to game dev`,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return hserver;
|
|
|
|
} else {
|
|
|
|
const node = player.hacknetNodes[i];
|
|
|
|
if (!(node instanceof HacknetNode)) throw new Error("hacknet node was not node.");
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
return {
|
2021-11-04 01:19:52 +01:00
|
|
|
numNodes: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
return player.hacknetNodes.length;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
maxNumNodes: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (hasHacknetServers(player)) {
|
|
|
|
return HacknetServerConstants.MaxServers;
|
|
|
|
}
|
|
|
|
return Infinity;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
purchaseNode: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
return purchaseHacknet(player);
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getPurchaseNodeCost: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (hasHacknetServers(player)) {
|
|
|
|
return getCostOfNextHacknetServer(player);
|
|
|
|
} else {
|
|
|
|
return getCostOfNextHacknetNode(player);
|
|
|
|
}
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getNodeStats: function (_i: unknown): NodeStats {
|
|
|
|
const i = helper.number("getNodeStats", "i", _i);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "getNodeStats");
|
|
|
|
const hasUpgraded = hasHacknetServers(player);
|
|
|
|
const res: any = {
|
|
|
|
name: node instanceof HacknetServer ? node.hostname : node.name,
|
|
|
|
level: node.level,
|
|
|
|
ram: node instanceof HacknetServer ? node.maxRam : node.ram,
|
2021-11-12 16:10:33 +01:00
|
|
|
ramUsed: node instanceof HacknetServer ? node.ramUsed : undefined,
|
2021-10-05 04:25:21 +02:00
|
|
|
cores: node.cores,
|
|
|
|
production: node instanceof HacknetServer ? node.hashRate : node.moneyGainRatePerSecond,
|
|
|
|
timeOnline: node.onlineTimeSeconds,
|
|
|
|
totalProduction: node instanceof HacknetServer ? node.totalHashesGenerated : node.totalMoneyGenerated,
|
|
|
|
};
|
|
|
|
|
|
|
|
if (hasUpgraded && node instanceof HacknetServer) {
|
|
|
|
res.cache = node.cache;
|
|
|
|
res.hashCapacity = node.hashCapacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
upgradeLevel: function (_i: unknown, _n: unknown): boolean {
|
|
|
|
const i = helper.number("upgradeLevel", "i", _i);
|
|
|
|
const n = helper.number("upgradeLevel", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "upgradeLevel");
|
|
|
|
return purchaseLevelUpgrade(player, node, n);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
upgradeRam: function (_i: unknown, _n: unknown): boolean {
|
|
|
|
const i = helper.number("upgradeRam", "i", _i);
|
|
|
|
const n = helper.number("upgradeRam", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "upgradeRam");
|
|
|
|
return purchaseRamUpgrade(player, node, n);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
upgradeCore: function (_i: unknown, _n: unknown): boolean {
|
|
|
|
const i = helper.number("upgradeCore", "i", _i);
|
|
|
|
const n = helper.number("upgradeCore", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "upgradeCore");
|
|
|
|
return purchaseCoreUpgrade(player, node, n);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
upgradeCache: function (_i: unknown, _n: unknown): boolean {
|
|
|
|
const i = helper.number("upgradeCache", "i", _i);
|
|
|
|
const n = helper.number("upgradeCache", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
const node = getHacknetNode(i, "upgradeCache");
|
|
|
|
if (!(node instanceof HacknetServer)) {
|
2022-01-13 01:55:45 +01:00
|
|
|
workerScript.log("hacknet.upgradeCache", () => "Can only be called on hacknet servers");
|
2021-10-05 04:25:21 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
const res = purchaseCacheUpgrade(player, node, n);
|
|
|
|
if (res) {
|
|
|
|
updateHashManagerCapacity(player);
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getLevelUpgradeCost: function (_i: unknown, _n: unknown): number {
|
|
|
|
const i = helper.number("getLevelUpgradeCost", "i", _i);
|
|
|
|
const n = helper.number("getLevelUpgradeCost", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "upgradeLevel");
|
|
|
|
return node.calculateLevelUpgradeCost(n, player.hacknet_node_level_cost_mult);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getRamUpgradeCost: function (_i: unknown, _n: unknown): number {
|
|
|
|
const i = helper.number("getRamUpgradeCost", "i", _i);
|
|
|
|
const n = helper.number("getRamUpgradeCost", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "upgradeRam");
|
|
|
|
return node.calculateRamUpgradeCost(n, player.hacknet_node_ram_cost_mult);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getCoreUpgradeCost: function (_i: unknown, _n: unknown): number {
|
|
|
|
const i = helper.number("getCoreUpgradeCost", "i", _i);
|
|
|
|
const n = helper.number("getCoreUpgradeCost", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
const node = getHacknetNode(i, "upgradeCore");
|
|
|
|
return node.calculateCoreUpgradeCost(n, player.hacknet_node_core_cost_mult);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getCacheUpgradeCost: function (_i: unknown, _n: unknown): number {
|
|
|
|
const i = helper.number("getCacheUpgradeCost", "i", _i);
|
|
|
|
const n = helper.number("getCacheUpgradeCost", "n", _n);
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return Infinity;
|
|
|
|
}
|
|
|
|
const node = getHacknetNode(i, "upgradeCache");
|
|
|
|
if (!(node instanceof HacknetServer)) {
|
2022-01-13 01:55:45 +01:00
|
|
|
workerScript.log("hacknet.getCacheUpgradeCost", () => "Can only be called on hacknet servers");
|
2021-10-05 04:25:21 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return node.calculateCacheUpgradeCost(n);
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
numHashes: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return player.hashManager.hashes;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
hashCapacity: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return player.hashManager.capacity;
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
hashCost: function (_upgName: unknown): number {
|
|
|
|
const upgName = helper.string("hashCost", "upgName", _upgName);
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return Infinity;
|
|
|
|
}
|
|
|
|
|
|
|
|
return player.hashManager.getUpgradeCost(upgName);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
spendHashes: function (_upgName: unknown, _upgTarget: unknown): boolean {
|
|
|
|
const upgName = helper.string("spendHashes", "upgName", _upgName);
|
2022-03-17 22:52:58 +01:00
|
|
|
let upgTarget = "";
|
|
|
|
if (_upgTarget !== undefined) upgTarget = helper.string("spendHashes", "upgTarget", _upgTarget);
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return purchaseHashUpgrade(player, upgName, upgTarget);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getHashUpgrades: function (): string[] {
|
2021-12-17 11:35:17 +01:00
|
|
|
if (!hasHacknetServers(player)) {
|
|
|
|
return [];
|
|
|
|
}
|
|
|
|
return Object.values(HashUpgrades).map((upgrade: HashUpgrade) => upgrade.name);
|
|
|
|
},
|
2022-03-17 00:50:56 +01:00
|
|
|
getHashUpgradeLevel: function (_upgName: unknown): number {
|
|
|
|
const upgName = helper.string("getHashUpgradeLevel", "upgName", _upgName);
|
2021-10-05 04:25:21 +02:00
|
|
|
const level = player.hashManager.upgrades[upgName];
|
|
|
|
if (level === undefined) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("hacknet.hashUpgradeLevel", `Invalid Hash Upgrade: ${upgName}`);
|
|
|
|
}
|
|
|
|
return level;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getStudyMult: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
2021-11-04 01:19:52 +01:00
|
|
|
return 1;
|
2021-10-05 04:25:21 +02:00
|
|
|
}
|
|
|
|
return player.hashManager.getStudyMult();
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getTrainingMult: function (): number {
|
2021-10-05 04:25:21 +02:00
|
|
|
if (!hasHacknetServers(player)) {
|
2021-11-04 01:19:52 +01:00
|
|
|
return 1;
|
2021-10-05 04:25:21 +02:00
|
|
|
}
|
|
|
|
return player.hashManager.getTrainingMult();
|
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|