From 324f752d8a2bbb525ff0db648814150f28d4bda4 Mon Sep 17 00:00:00 2001 From: Olivier Gagnon Date: Tue, 24 May 2022 17:29:44 -0400 Subject: [PATCH] Wrap formulas but doesn't compile --- src/NetscriptFunctions/Formulas.ts | 431 ++++++++++++++++------------- 1 file changed, 245 insertions(+), 186 deletions(-) diff --git a/src/NetscriptFunctions/Formulas.ts b/src/NetscriptFunctions/Formulas.ts index fb6c4cd56..9b5156dc5 100644 --- a/src/NetscriptFunctions/Formulas.ts +++ b/src/NetscriptFunctions/Formulas.ts @@ -39,212 +39,271 @@ import { } from "../Gang/formulas/formulas"; import { favorToRep as calculateFavorToRep, repToFavor as calculateRepToFavor } from "../Faction/formulas/favor"; import { repFromDonation } from "../Faction/formulas/donation"; +import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper"; -export function NetscriptFormulas(player: IPlayer, workerScript: WorkerScript, helper: INetscriptHelper): IFormulas { - const checkFormulasAccess = function (func: string): void { +export function NetscriptFormulas( + player: IPlayer, + workerScript: WorkerScript, + helper: INetscriptHelper, +): InternalAPI { + const checkFormulasAccess = function (ctx: NetscriptContext): void { if (!player.hasProgram(Programs.Formulas.name)) { - throw helper.makeRuntimeErrorMsg(`formulas.${func}`, `Requires Formulas.exe to run.`); + throw helper.makeRuntimeErrorMsg(`formulas.${ctx.function}`, `Requires Formulas.exe to run.`); } }; return { reputation: { - calculateFavorToRep: function (_favor: unknown): number { - const favor = helper.number("calculateFavorToRep", "favor", _favor); - checkFormulasAccess("reputation.calculateFavorToRep"); - return calculateFavorToRep(favor); - }, - calculateRepToFavor: function (_rep: unknown): number { - const rep = helper.number("calculateRepToFavor", "rep", _rep); - checkFormulasAccess("reputation.calculateRepToFavor"); - return calculateRepToFavor(rep); - }, - repFromDonation: function (_amount: unknown, player: any): number { - const amount = helper.number("repFromDonation", "amount", _amount); - checkFormulasAccess("reputation.repFromDonation"); - return repFromDonation(amount, player); - }, + calculateFavorToRep: + (ctx: NetscriptContext) => + (_favor: unknown): number => { + const favor = ctx.helper.number("favor", _favor); + checkFormulasAccess(ctx); + return calculateFavorToRep(favor); + }, + calculateRepToFavor: + (ctx: NetscriptContext) => + (_rep: unknown): number => { + const rep = ctx.helper.number("rep", _rep); + checkFormulasAccess(ctx); + return calculateRepToFavor(rep); + }, + repFromDonation: + (ctx: NetscriptContext) => + (_amount: unknown, player: any): number => { + const amount = ctx.helper.number("amount", _amount); + checkFormulasAccess(ctx); + return repFromDonation(amount, player); + }, }, skills: { - calculateSkill: function (_exp: unknown, _mult: unknown = 1): number { - const exp = helper.number("calculateSkill", "exp", _exp); - const mult = helper.number("calculateSkill", "mult", _mult); - checkFormulasAccess("skills.calculateSkill"); - return calculateSkill(exp, mult); - }, - calculateExp: function (_skill: unknown, _mult: unknown = 1): number { - const skill = helper.number("calculateExp", "skill", _skill); - const mult = helper.number("calculateExp", "mult", _mult); - checkFormulasAccess("skills.calculateExp"); - return calculateExp(skill, mult); - }, + calculateSkill: + (ctx: NetscriptContext) => + (_exp: unknown, _mult: unknown = 1): number => { + const exp = ctx.helper.number("exp", _exp); + const mult = ctx.helper.number("mult", _mult); + checkFormulasAccess(ctx); + return calculateSkill(exp, mult); + }, + calculateExp: + (ctx: NetscriptContext) => + (_skill: unknown, _mult: unknown = 1): number => { + const skill = ctx.helper.number("skill", _skill); + const mult = ctx.helper.number("mult", _mult); + checkFormulasAccess(ctx); + return calculateExp(skill, mult); + }, }, hacking: { - hackChance: function (server: any, player: any): number { - checkFormulasAccess("hacking.hackChance"); - return calculateHackingChance(server, player); - }, - hackExp: function (server: any, player: any): number { - checkFormulasAccess("hacking.hackExp"); - return calculateHackingExpGain(server, player); - }, - hackPercent: function (server: any, player: any): number { - checkFormulasAccess("hacking.hackPercent"); - return calculatePercentMoneyHacked(server, player); - }, - 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); - checkFormulasAccess("hacking.growPercent"); - return calculateServerGrowth(server, threads, player, cores); - }, - hackTime: function (server: any, player: any): number { - checkFormulasAccess("hacking.hackTime"); - return calculateHackingTime(server, player) * 1000; - }, - growTime: function (server: any, player: any): number { - checkFormulasAccess("hacking.growTime"); - return calculateGrowTime(server, player) * 1000; - }, - weakenTime: function (server: any, player: any): number { - checkFormulasAccess("hacking.weakenTime"); - return calculateWeakenTime(server, player) * 1000; - }, + hackChance: + (ctx: NetscriptContext) => + (server: any, player: any): number => { + checkFormulasAccess(ctx); + return calculateHackingChance(server, player); + }, + hackExp: + (ctx: NetscriptContext) => + (server: any, player: any): number => { + checkFormulasAccess(ctx); + return calculateHackingExpGain(server, player); + }, + hackPercent: + (ctx: NetscriptContext) => + (server: any, player: any): number => { + checkFormulasAccess(ctx); + return calculatePercentMoneyHacked(server, player); + }, + growPercent: + (ctx: NetscriptContext) => + (server: any, _threads: unknown, player: any, _cores: unknown = 1): number => { + const threads = ctx.helper.number("threads", _threads); + const cores = ctx.helper.number("cores", _cores); + checkFormulasAccess(ctx); + return calculateServerGrowth(server, threads, player, cores); + }, + hackTime: + (ctx: NetscriptContext) => + (server: any, player: any): number => { + checkFormulasAccess(ctx); + return calculateHackingTime(server, player) * 1000; + }, + growTime: + (ctx: NetscriptContext) => + (server: any, player: any): number => { + checkFormulasAccess(ctx); + return calculateGrowTime(server, player) * 1000; + }, + weakenTime: + (ctx: NetscriptContext) => + (server: any, player: any): number => { + checkFormulasAccess(ctx); + return calculateWeakenTime(server, player) * 1000; + }, }, hacknetNodes: { - 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); - checkFormulasAccess("hacknetNodes.moneyGainRate"); - return calculateMoneyGainRate(level, ram, cores, mult); - }, - 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); - checkFormulasAccess("hacknetNodes.levelUpgradeCost"); - return calculateLevelUpgradeCost(startingLevel, extraLevels, costMult); - }, - 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); - checkFormulasAccess("hacknetNodes.ramUpgradeCost"); - return calculateRamUpgradeCost(startingRam, extraLevels, costMult); - }, - 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); - checkFormulasAccess("hacknetNodes.coreUpgradeCost"); - return calculateCoreUpgradeCost(startingCore, extraCores, costMult); - }, - hacknetNodeCost: function (_n: unknown, _mult: unknown): number { - const n = helper.number("hacknetNodeCost", "n", _n); - const mult = helper.number("hacknetNodeCost", "mult", _mult); - checkFormulasAccess("hacknetNodes.hacknetNodeCost"); - return calculateNodeCost(n, mult); - }, - constants: function (): any { - checkFormulasAccess("hacknetNodes.constants"); + moneyGainRate: + (ctx: NetscriptContext) => + (_level: unknown, _ram: unknown, _cores: unknown, _mult: unknown = 1): number => { + const level = ctx.helper.number("level", _level); + const ram = ctx.helper.number("ram", _ram); + const cores = ctx.helper.number("cores", _cores); + const mult = ctx.helper.number("mult", _mult); + checkFormulasAccess(ctx); + return calculateMoneyGainRate(level, ram, cores, mult); + }, + levelUpgradeCost: + (ctx: NetscriptContext) => + (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => { + const startingLevel = ctx.helper.number("startingLevel", _startingLevel); + const extraLevels = ctx.helper.number("extraLevels", _extraLevels); + const costMult = ctx.helper.number("costMult", _costMult); + checkFormulasAccess(ctx); + return calculateLevelUpgradeCost(startingLevel, extraLevels, costMult); + }, + ramUpgradeCost: + (ctx: NetscriptContext) => + (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => { + const startingRam = ctx.helper.number("startingRam", _startingRam); + const extraLevels = ctx.helper.number("extraLevels", _extraLevels); + const costMult = ctx.helper.number("costMult", _costMult); + checkFormulasAccess(ctx); + return calculateRamUpgradeCost(startingRam, extraLevels, costMult); + }, + coreUpgradeCost: + (ctx: NetscriptContext) => + (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => { + const startingCore = ctx.helper.number("startingCore", _startingCore); + const extraCores = ctx.helper.number("extraCores", _extraCores); + const costMult = ctx.helper.number("costMult", _costMult); + checkFormulasAccess(ctx); + return calculateCoreUpgradeCost(startingCore, extraCores, costMult); + }, + hacknetNodeCost: + (ctx: NetscriptContext) => + (_n: unknown, _mult: unknown): number => { + const n = ctx.helper.number("n", _n); + const mult = ctx.helper.number("mult", _mult); + checkFormulasAccess(ctx); + return calculateNodeCost(n, mult); + }, + constants: (ctx: NetscriptContext) => (): any => { + checkFormulasAccess(ctx); return Object.assign({}, HacknetNodeConstants); }, }, hacknetServers: { - 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); - checkFormulasAccess("hacknetServers.hashGainRate"); - return HScalculateHashGainRate(level, ramUsed, maxRam, cores, mult); - }, - 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); - checkFormulasAccess("hacknetServers.levelUpgradeCost"); - return HScalculateLevelUpgradeCost(startingLevel, extraLevels, costMult); - }, - 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); - checkFormulasAccess("hacknetServers.ramUpgradeCost"); - return HScalculateRamUpgradeCost(startingRam, extraLevels, costMult); - }, - 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); - checkFormulasAccess("hacknetServers.coreUpgradeCost"); - return HScalculateCoreUpgradeCost(startingCore, extraCores, costMult); - }, - cacheUpgradeCost: function (_startingCache: unknown, _extraCache: unknown = 1): number { - const startingCache = helper.number("cacheUpgradeCost", "startingCache", _startingCache); - const extraCache = helper.number("cacheUpgradeCost", "extraCache", _extraCache); - checkFormulasAccess("hacknetServers.cacheUpgradeCost"); - return HScalculateCacheUpgradeCost(startingCache, extraCache); - }, - hashUpgradeCost: function (_upgName: unknown, _level: unknown): number { - const upgName = helper.string("hashUpgradeCost", "upgName", _upgName); - const level = helper.number("hashUpgradeCost", "level", _level); - checkFormulasAccess("hacknetServers.hashUpgradeCost"); - const upg = player.hashManager.getUpgrade(upgName); - if (!upg) { - throw helper.makeRuntimeErrorMsg( - "formulas.hacknetServers.calculateHashUpgradeCost", - `Invalid Hash Upgrade: ${upgName}`, - ); - } - return upg.getCost(level); - }, - hacknetServerCost: function (_n: unknown, _mult: unknown = 1): number { - const n = helper.number("hacknetServerCost", "n", _n); - const mult = helper.number("hacknetServerCost", "mult", _mult); - checkFormulasAccess("hacknetServers.hacknetServerCost"); - return HScalculateServerCost(n, mult); - }, - constants: function (): any { - checkFormulasAccess("hacknetServers.constants"); + hashGainRate: + (ctx: NetscriptContext) => + (_level: unknown, _ramUsed: unknown, _maxRam: unknown, _cores: unknown, _mult: unknown = 1): number => { + const level = ctx.helper.number("level", _level); + const ramUsed = ctx.helper.number("ramUsed", _ramUsed); + const maxRam = ctx.helper.number("maxRam", _maxRam); + const cores = ctx.helper.number("cores", _cores); + const mult = ctx.helper.number("mult", _mult); + checkFormulasAccess(ctx); + return HScalculateHashGainRate(level, ramUsed, maxRam, cores, mult); + }, + levelUpgradeCost: + (ctx: NetscriptContext) => + (_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => { + const startingLevel = ctx.helper.number("startingLevel", _startingLevel); + const extraLevels = ctx.helper.number("extraLevels", _extraLevels); + const costMult = ctx.helper.number("costMult", _costMult); + checkFormulasAccess(ctx); + return HScalculateLevelUpgradeCost(startingLevel, extraLevels, costMult); + }, + ramUpgradeCost: + (ctx: NetscriptContext) => + (_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => { + const startingRam = ctx.helper.number("startingRam", _startingRam); + const extraLevels = ctx.helper.number("extraLevels", _extraLevels); + const costMult = ctx.helper.number("costMult", _costMult); + checkFormulasAccess(ctx); + return HScalculateRamUpgradeCost(startingRam, extraLevels, costMult); + }, + coreUpgradeCost: + (ctx: NetscriptContext) => + (_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => { + const startingCore = ctx.helper.number("startingCore", _startingCore); + const extraCores = ctx.helper.number("extraCores", _extraCores); + const costMult = ctx.helper.number("costMult", _costMult); + checkFormulasAccess(ctx); + return HScalculateCoreUpgradeCost(startingCore, extraCores, costMult); + }, + cacheUpgradeCost: + (ctx: NetscriptContext) => + (_startingCache: unknown, _extraCache: unknown = 1): number => { + const startingCache = ctx.helper.number("startingCache", _startingCache); + const extraCache = ctx.helper.number("extraCache", _extraCache); + checkFormulasAccess(ctx); + return HScalculateCacheUpgradeCost(startingCache, extraCache); + }, + hashUpgradeCost: + (ctx: NetscriptContext) => + (_upgName: unknown, _level: unknown): number => { + const upgName = helper.string("hashUpgradeCost", "upgName", _upgName); + const level = ctx.helper.number("level", _level); + checkFormulasAccess(ctx); + const upg = player.hashManager.getUpgrade(upgName); + if (!upg) { + throw helper.makeRuntimeErrorMsg( + "formulas.hacknetServers.calculateHashUpgradeCost", + `Invalid Hash Upgrade: ${upgName}`, + ); + } + return upg.getCost(level); + }, + hacknetServerCost: + (ctx: NetscriptContext) => + (_n: unknown, _mult: unknown = 1): number => { + const n = ctx.helper.number("n", _n); + const mult = ctx.helper.number("mult", _mult); + checkFormulasAccess(ctx); + return HScalculateServerCost(n, mult); + }, + constants: (ctx: NetscriptContext) => (): any => { + checkFormulasAccess(ctx); return Object.assign({}, HacknetServerConstants); }, }, gang: { - wantedPenalty(gang: any): number { - checkFormulasAccess("gang.wantedPenalty"); - return calculateWantedPenalty(gang); - }, - respectGain: function (gang: any, member: any, task: any): number { - checkFormulasAccess("gang.respectGain"); - return calculateRespectGain(gang, member, task); - }, - wantedLevelGain: function (gang: any, member: any, task: any): number { - checkFormulasAccess("gang.wantedLevelGain"); - return calculateWantedLevelGain(gang, member, task); - }, - moneyGain: function (gang: any, member: any, task: any): number { - checkFormulasAccess("gang.moneyGain"); - return calculateMoneyGain(gang, member, task); - }, - ascensionPointsGain: function (_exp: unknown): number { - const exp = helper.number("ascensionPointsGain", "exp", _exp); - checkFormulasAccess("gang.ascensionPointsGain"); - return calculateAscensionPointsGain(exp); - }, - ascensionMultiplier: function (_points: unknown): number { - const points = helper.number("ascensionMultiplier", "points", _points); - checkFormulasAccess("gang.ascensionMultiplier"); - return calculateAscensionMult(points); - }, + wantedPenalty: + (ctx: NetscriptContext) => + (gang: any): number => { + checkFormulasAccess(ctx); + return calculateWantedPenalty(gang); + }, + respectGain: + (ctx: NetscriptContext) => + (gang: any, member: any, task: any): number => { + checkFormulasAccess(ctx); + return calculateRespectGain(gang, member, task); + }, + wantedLevelGain: + (ctx: NetscriptContext) => + (gang: any, member: any, task: any): number => { + checkFormulasAccess(ctx); + return calculateWantedLevelGain(gang, member, task); + }, + moneyGain: + (ctx: NetscriptContext) => + (gang: any, member: any, task: any): number => { + checkFormulasAccess(ctx); + return calculateMoneyGain(gang, member, task); + }, + ascensionPointsGain: + (ctx: NetscriptContext) => + (_exp: unknown): number => { + const exp = ctx.helper.number("exp", _exp); + checkFormulasAccess(ctx); + return calculateAscensionPointsGain(exp); + }, + ascensionMultiplier: + (ctx: NetscriptContext) => + (_points: unknown): number => { + const points = ctx.helper.number("points", _points); + checkFormulasAccess(ctx); + return calculateAscensionMult(points); + }, }, }; }