2021-10-14 09:22:02 +02:00
|
|
|
import { INetscriptHelper } from "./INetscriptHelper";
|
|
|
|
import { WorkerScript } from "../Netscript/WorkerScript";
|
|
|
|
import { IPlayer } from "../PersonObjects/IPlayer";
|
|
|
|
import { calculateServerGrowth } from "../Server/formulas/grow";
|
|
|
|
import {
|
|
|
|
calculateMoneyGainRate,
|
|
|
|
calculateLevelUpgradeCost,
|
|
|
|
calculateRamUpgradeCost,
|
|
|
|
calculateCoreUpgradeCost,
|
|
|
|
calculateNodeCost,
|
|
|
|
} from "../Hacknet/formulas/HacknetNodes";
|
|
|
|
import {
|
|
|
|
calculateHashGainRate as HScalculateHashGainRate,
|
|
|
|
calculateLevelUpgradeCost as HScalculateLevelUpgradeCost,
|
|
|
|
calculateRamUpgradeCost as HScalculateRamUpgradeCost,
|
|
|
|
calculateCoreUpgradeCost as HScalculateCoreUpgradeCost,
|
|
|
|
calculateCacheUpgradeCost as HScalculateCacheUpgradeCost,
|
|
|
|
calculateServerCost as HScalculateServerCost,
|
|
|
|
} from "../Hacknet/formulas/HacknetServers";
|
|
|
|
import { HacknetNodeConstants, HacknetServerConstants } from "../Hacknet/data/Constants";
|
|
|
|
import { calculateSkill, calculateExp } from "../PersonObjects/formulas/skill";
|
|
|
|
import {
|
|
|
|
calculateHackingChance,
|
|
|
|
calculateHackingExpGain,
|
|
|
|
calculatePercentMoneyHacked,
|
|
|
|
calculateHackingTime,
|
|
|
|
calculateGrowTime,
|
|
|
|
calculateWeakenTime,
|
|
|
|
} from "../Hacking";
|
2021-10-28 05:41:47 +02:00
|
|
|
import { Programs } from "../Programs/Programs";
|
2021-11-03 23:16:10 +01:00
|
|
|
import { Formulas as IFormulas } from "../ScriptEditor/NetscriptDefinitions";
|
2021-12-09 00:19:30 +01:00
|
|
|
import {
|
|
|
|
calculateRespectGain,
|
|
|
|
calculateWantedLevelGain,
|
|
|
|
calculateMoneyGain,
|
|
|
|
calculateWantedPenalty,
|
2021-12-09 18:52:51 +01:00
|
|
|
calculateAscensionMult,
|
|
|
|
calculateAscensionPointsGain,
|
2021-12-09 00:19:30 +01:00
|
|
|
} from "../Gang/formulas/formulas";
|
2022-03-31 21:27:02 +02:00
|
|
|
import {
|
|
|
|
favorToRep as calculateFavorToRep,
|
|
|
|
repToFavor as calculateRepToFavor,
|
|
|
|
} from "../Faction/formulas/favor";
|
2021-10-14 09:22:02 +02:00
|
|
|
|
2021-11-03 23:16:10 +01:00
|
|
|
export function NetscriptFormulas(player: IPlayer, workerScript: WorkerScript, helper: INetscriptHelper): IFormulas {
|
2021-10-28 05:41:47 +02:00
|
|
|
const checkFormulasAccess = function (func: string): void {
|
|
|
|
if (!player.hasProgram(Programs.Formulas.name)) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(`formulas.${func}`, `Requires Formulas.exe to run.`);
|
2021-10-14 09:22:02 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
return {
|
2022-03-31 21:27:02 +02:00
|
|
|
factions: {
|
|
|
|
calculateFavorToRep: function (_favor: unknown): number {
|
|
|
|
const favor = helper.number("calculateFavorToRep", "favor", _favor);
|
|
|
|
checkFormulasAccess("factions.calculateFavorToRep");
|
|
|
|
return calculateFavorToRep(favor);
|
|
|
|
},
|
|
|
|
calculateRepToFavor: function (_rep: unknown): number {
|
|
|
|
const rep = helper.number("calculateRepToFavor", "rep", _rep);
|
|
|
|
checkFormulasAccess("factions.calculateRepToFavor");
|
|
|
|
return calculateRepToFavor(rep);
|
|
|
|
},
|
|
|
|
},
|
2021-11-03 03:58:40 +01:00
|
|
|
skills: {
|
2022-03-17 00:33:45 +01:00
|
|
|
calculateSkill: function (_exp: unknown, _mult: unknown = 1): number {
|
|
|
|
const exp = helper.number("calculateSkill", "exp", _exp);
|
|
|
|
const mult = helper.number("calculateSkill", "mult", _mult);
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("skills.calculateSkill");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateSkill(exp, mult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
calculateExp: function (_skill: unknown, _mult: unknown = 1): number {
|
|
|
|
const skill = helper.number("calculateExp", "skill", _skill);
|
|
|
|
const mult = helper.number("calculateExp", "mult", _mult);
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("skills.calculateExp");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateExp(skill, mult);
|
|
|
|
},
|
2021-11-03 03:58:40 +01:00
|
|
|
},
|
|
|
|
hacking: {
|
2022-03-17 00:33:45 +01:00
|
|
|
hackChance: function (server: any, player: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.hackChance");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateHackingChance(server, player);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
hackExp: function (server: any, player: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.hackExp");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateHackingExpGain(server, player);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
hackPercent: function (server: any, player: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.hackPercent");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculatePercentMoneyHacked(server, player);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
growPercent: function (server: any, _threads: unknown, player: any, _cores: unknown = 1): number {
|
|
|
|
const threads = helper.number("growPercent", "threads", _threads);
|
|
|
|
const cores = helper.number("growPercent", "cores", _cores);
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.growPercent");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateServerGrowth(server, threads, player, cores);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
hackTime: function (server: any, player: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.hackTime");
|
2021-11-10 13:52:26 +01:00
|
|
|
return calculateHackingTime(server, player) * 1000;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
growTime: function (server: any, player: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.growTime");
|
2021-11-10 13:52:26 +01:00
|
|
|
return calculateGrowTime(server, player) * 1000;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
weakenTime: function (server: any, player: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("hacking.weakenTime");
|
2021-11-10 13:52:26 +01:00
|
|
|
return calculateWeakenTime(server, player) * 1000;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
|
|
|
},
|
|
|
|
hacknetNodes: {
|
2022-03-17 00:33:45 +01:00
|
|
|
moneyGainRate: function (_level: unknown, _ram: unknown, _cores: unknown, _mult: unknown = 1): number {
|
|
|
|
const level = helper.number("moneyGainRate", "level", _level);
|
|
|
|
const ram = helper.number("moneyGainRate", "ram", _ram);
|
|
|
|
const cores = helper.number("moneyGainRate", "cores", _cores);
|
|
|
|
const mult = helper.number("moneyGainRate", "mult", _mult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetNodes.moneyGainRate");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateMoneyGainRate(level, ram, cores, mult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
levelUpgradeCost: function (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number {
|
|
|
|
const startingLevel = helper.number("levelUpgradeCost", "startingLevel", _startingLevel);
|
|
|
|
const extraLevels = helper.number("levelUpgradeCost", "extraLevels", _extraLevels);
|
|
|
|
const costMult = helper.number("levelUpgradeCost", "costMult", _costMult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetNodes.levelUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
ramUpgradeCost: function (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number {
|
|
|
|
const startingRam = helper.number("ramUpgradeCost", "startingRam", _startingRam);
|
|
|
|
const extraLevels = helper.number("ramUpgradeCost", "extraLevels", _extraLevels);
|
|
|
|
const costMult = helper.number("ramUpgradeCost", "costMult", _costMult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetNodes.ramUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateRamUpgradeCost(startingRam, extraLevels, costMult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
coreUpgradeCost: function (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number {
|
|
|
|
const startingCore = helper.number("coreUpgradeCost", "startingCore", _startingCore);
|
|
|
|
const extraCores = helper.number("coreUpgradeCost", "extraCores", _extraCores);
|
|
|
|
const costMult = helper.number("coreUpgradeCost", "costMult", _costMult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetNodes.coreUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateCoreUpgradeCost(startingCore, extraCores, costMult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
hacknetNodeCost: function (_n: unknown, _mult: unknown): number {
|
|
|
|
const n = helper.number("hacknetNodeCost", "n", _n);
|
|
|
|
const mult = helper.number("hacknetNodeCost", "mult", _mult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetNodes.hacknetNodeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return calculateNodeCost(n, mult);
|
|
|
|
},
|
|
|
|
constants: function (): any {
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetNodes.constants");
|
2021-10-14 09:22:02 +02:00
|
|
|
return Object.assign({}, HacknetNodeConstants);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
hacknetServers: {
|
2022-03-17 00:33:45 +01:00
|
|
|
hashGainRate: function (
|
|
|
|
_level: unknown,
|
|
|
|
_ramUsed: unknown,
|
|
|
|
_maxRam: unknown,
|
|
|
|
_cores: unknown,
|
|
|
|
_mult: unknown = 1,
|
|
|
|
): number {
|
|
|
|
const level = helper.number("hashGainRate", "level", _level);
|
|
|
|
const ramUsed = helper.number("hashGainRate", "ramUsed", _ramUsed);
|
|
|
|
const maxRam = helper.number("hashGainRate", "maxRam", _maxRam);
|
|
|
|
const cores = helper.number("hashGainRate", "cores", _cores);
|
|
|
|
const mult = helper.number("hashGainRate", "mult", _mult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.hashGainRate");
|
2021-10-14 09:22:02 +02:00
|
|
|
return HScalculateHashGainRate(level, ramUsed, maxRam, cores, mult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
levelUpgradeCost: function (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number {
|
|
|
|
const startingLevel = helper.number("levelUpgradeCost", "startingLevel", _startingLevel);
|
|
|
|
const extraLevels = helper.number("levelUpgradeCost", "extraLevels", _extraLevels);
|
|
|
|
const costMult = helper.number("levelUpgradeCost", "costMult", _costMult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.levelUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return HScalculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
ramUpgradeCost: function (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number {
|
|
|
|
const startingRam = helper.number("ramUpgradeCost", "startingRam", _startingRam);
|
|
|
|
const extraLevels = helper.number("ramUpgradeCost", "extraLevels", _extraLevels);
|
|
|
|
const costMult = helper.number("ramUpgradeCost", "costMult", _costMult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.ramUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return HScalculateRamUpgradeCost(startingRam, extraLevels, costMult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
coreUpgradeCost: function (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number {
|
|
|
|
const startingCore = helper.number("coreUpgradeCost", "startingCore", _startingCore);
|
|
|
|
const extraCores = helper.number("coreUpgradeCost", "extraCores", _extraCores);
|
|
|
|
const costMult = helper.number("coreUpgradeCost", "costMult", _costMult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.coreUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return HScalculateCoreUpgradeCost(startingCore, extraCores, costMult);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
cacheUpgradeCost: function (_startingCache: unknown, _extraCache: unknown = 1): number {
|
|
|
|
const startingCache = helper.number("cacheUpgradeCost", "startingCache", _startingCache);
|
|
|
|
const extraCache = helper.number("cacheUpgradeCost", "extraCache", _extraCache);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.cacheUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return HScalculateCacheUpgradeCost(startingCache, extraCache);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
hashUpgradeCost: function (_upgName: unknown, _level: unknown): number {
|
|
|
|
const upgName = helper.string("hashUpgradeCost", "upgName", _upgName);
|
|
|
|
const level = helper.number("hashUpgradeCost", "level", _level);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.hashUpgradeCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
const upg = player.hashManager.getUpgrade(upgName);
|
|
|
|
if (!upg) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(
|
|
|
|
"formulas.hacknetServers.calculateHashUpgradeCost",
|
|
|
|
`Invalid Hash Upgrade: ${upgName}`,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
return upg.getCost(level);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
hacknetServerCost: function (_n: unknown, _mult: unknown = 1): number {
|
|
|
|
const n = helper.number("hacknetServerCost", "n", _n);
|
|
|
|
const mult = helper.number("hacknetServerCost", "mult", _mult);
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.hacknetServerCost");
|
2021-10-14 09:22:02 +02:00
|
|
|
return HScalculateServerCost(n, mult);
|
|
|
|
},
|
|
|
|
constants: function (): any {
|
2021-10-28 05:41:47 +02:00
|
|
|
checkFormulasAccess("hacknetServers.constants");
|
2021-10-14 09:22:02 +02:00
|
|
|
return Object.assign({}, HacknetServerConstants);
|
|
|
|
},
|
|
|
|
},
|
2021-12-09 00:19:30 +01:00
|
|
|
gang: {
|
2021-12-09 00:41:49 +01:00
|
|
|
wantedPenalty(gang: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("gang.wantedPenalty");
|
2021-12-09 00:19:30 +01:00
|
|
|
return calculateWantedPenalty(gang);
|
|
|
|
},
|
2021-12-09 00:41:49 +01:00
|
|
|
respectGain: function (gang: any, member: any, task: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("gang.respectGain");
|
2021-12-09 00:19:30 +01:00
|
|
|
return calculateRespectGain(gang, member, task);
|
|
|
|
},
|
2021-12-09 00:41:49 +01:00
|
|
|
wantedLevelGain: function (gang: any, member: any, task: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("gang.wantedLevelGain");
|
2021-12-09 00:19:30 +01:00
|
|
|
return calculateWantedLevelGain(gang, member, task);
|
|
|
|
},
|
2021-12-09 00:41:49 +01:00
|
|
|
moneyGain: function (gang: any, member: any, task: any): number {
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("gang.moneyGain");
|
2021-12-09 00:19:30 +01:00
|
|
|
return calculateMoneyGain(gang, member, task);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
ascensionPointsGain: function (_exp: unknown): number {
|
|
|
|
const exp = helper.number("ascensionPointsGain", "exp", _exp);
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("gang.ascensionPointsGain");
|
2021-12-09 18:52:51 +01:00
|
|
|
return calculateAscensionPointsGain(exp);
|
|
|
|
},
|
2022-03-17 00:33:45 +01:00
|
|
|
ascensionMultiplier: function (_points: unknown): number {
|
|
|
|
const points = helper.number("ascensionMultiplier", "points", _points);
|
2022-01-22 23:31:59 +01:00
|
|
|
checkFormulasAccess("gang.ascensionMultiplier");
|
2021-12-09 18:52:51 +01:00
|
|
|
return calculateAscensionMult(points);
|
|
|
|
},
|
2021-12-09 00:19:30 +01:00
|
|
|
},
|
2021-10-14 09:22:02 +02:00
|
|
|
};
|
|
|
|
}
|