2022-08-09 21:41:47 +02:00
|
|
|
import { Player as player } from "../Player";
|
2021-10-14 09:22:02 +02:00
|
|
|
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";
|
2022-07-19 22:46:03 +02:00
|
|
|
import {
|
|
|
|
Formulas as IFormulas,
|
|
|
|
HacknetNodeConstants as DefHacknetNodeConstants,
|
|
|
|
HacknetServerConstants as DefHacknetServerConstants,
|
|
|
|
} 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:52:03 +02:00
|
|
|
import { favorToRep as calculateFavorToRep, repToFavor as calculateRepToFavor } from "../Faction/formulas/favor";
|
2022-04-14 20:01:31 +02:00
|
|
|
import { repFromDonation } from "../Faction/formulas/donation";
|
2022-05-24 23:29:44 +02:00
|
|
|
import { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
|
2022-08-08 19:43:41 +02:00
|
|
|
import { helpers } from "../Netscript/NetscriptHelpers";
|
2022-08-17 20:32:52 +02:00
|
|
|
import { WorkStats } from "../Work/WorkStats";
|
|
|
|
import { calculateCrimeWorkStats } from "../Work/formulas/Crime";
|
|
|
|
import { Crimes } from "../Crime/Crimes";
|
|
|
|
import { calculateClassEarnings } from "../Work/formulas/Class";
|
|
|
|
import { ClassType } from "../Work/ClassWork";
|
|
|
|
import { LocationName } from "../Locations/data/LocationNames";
|
|
|
|
import { calculateFactionExp, calculateFactionRep } from "../Work/formulas/Faction";
|
|
|
|
import { FactionWorkType } from "../Work/data/FactionWorkType";
|
2021-10-14 09:22:02 +02:00
|
|
|
|
2022-08-23 22:01:34 +02:00
|
|
|
import { Player as INetscriptPlayer, Server as IServerDef } from "../ScriptEditor/NetscriptDefinitions";
|
|
|
|
import { defaultMultipliers } from "../PersonObjects/Multipliers";
|
|
|
|
|
2022-08-09 21:41:47 +02:00
|
|
|
export function NetscriptFormulas(): InternalAPI<IFormulas> {
|
2022-05-24 23:29:44 +02:00
|
|
|
const checkFormulasAccess = function (ctx: NetscriptContext): void {
|
2021-10-28 05:41:47 +02:00
|
|
|
if (!player.hasProgram(Programs.Formulas.name)) {
|
2022-08-08 19:43:41 +02:00
|
|
|
throw helpers.makeRuntimeErrorMsg(ctx, `Requires Formulas.exe to run.`);
|
2021-10-14 09:22:02 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
return {
|
2022-08-23 22:01:34 +02:00
|
|
|
mockServer: () => (): IServerDef => ({
|
|
|
|
cpuCores: 0,
|
|
|
|
ftpPortOpen: false,
|
|
|
|
hasAdminRights: false,
|
|
|
|
hostname: "",
|
|
|
|
httpPortOpen: false,
|
|
|
|
ip: "",
|
|
|
|
isConnectedTo: false,
|
|
|
|
maxRam: 0,
|
|
|
|
organizationName: "",
|
|
|
|
ramUsed: 0,
|
|
|
|
smtpPortOpen: false,
|
|
|
|
sqlPortOpen: false,
|
|
|
|
sshPortOpen: false,
|
|
|
|
purchasedByPlayer: false,
|
|
|
|
backdoorInstalled: false,
|
|
|
|
baseDifficulty: 0,
|
|
|
|
hackDifficulty: 0,
|
|
|
|
minDifficulty: 0,
|
|
|
|
moneyAvailable: 0,
|
|
|
|
moneyMax: 0,
|
|
|
|
numOpenPortsRequired: 0,
|
|
|
|
openPortCount: 0,
|
|
|
|
requiredHackingSkill: 0,
|
|
|
|
serverGrowth: 0,
|
|
|
|
}),
|
|
|
|
mockPlayer: () => (): INetscriptPlayer => ({
|
|
|
|
hp: { current: 0, max: 0 },
|
|
|
|
skills: {
|
|
|
|
hacking: 0,
|
|
|
|
strength: 0,
|
|
|
|
defense: 0,
|
|
|
|
dexterity: 0,
|
|
|
|
agility: 0,
|
|
|
|
charisma: 0,
|
|
|
|
intelligence: 0,
|
|
|
|
},
|
|
|
|
exp: {
|
|
|
|
hacking: 0,
|
|
|
|
strength: 0,
|
|
|
|
defense: 0,
|
|
|
|
dexterity: 0,
|
|
|
|
agility: 0,
|
|
|
|
charisma: 0,
|
|
|
|
intelligence: 0,
|
|
|
|
},
|
|
|
|
mults: defaultMultipliers(),
|
|
|
|
numPeopleKilled: 0,
|
|
|
|
money: 0,
|
|
|
|
city: "",
|
|
|
|
location: "",
|
|
|
|
bitNodeN: 0,
|
|
|
|
totalPlaytime: 0,
|
|
|
|
playtimeSinceLastAug: 0,
|
|
|
|
playtimeSinceLastBitnode: 0,
|
|
|
|
jobs: {},
|
|
|
|
factions: [],
|
|
|
|
tor: false,
|
|
|
|
hasCorporation: false,
|
|
|
|
inBladeburner: false,
|
|
|
|
entropy: 0,
|
|
|
|
}),
|
2022-03-31 21:52:03 +02:00
|
|
|
reputation: {
|
2022-05-24 23:29:44 +02:00
|
|
|
calculateFavorToRep:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_favor: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const favor = helpers.number(ctx, "favor", _favor);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateFavorToRep(favor);
|
|
|
|
},
|
|
|
|
calculateRepToFavor:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_rep: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const rep = helpers.number(ctx, "rep", _rep);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateRepToFavor(rep);
|
|
|
|
},
|
|
|
|
repFromDonation:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_amount: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const amount = helpers.number(ctx, "amount", _amount);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return repFromDonation(amount, player);
|
|
|
|
},
|
2022-03-31 21:27:02 +02:00
|
|
|
},
|
2021-11-03 03:58:40 +01:00
|
|
|
skills: {
|
2022-05-24 23:29:44 +02:00
|
|
|
calculateSkill:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_exp: unknown, _mult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const exp = helpers.number(ctx, "exp", _exp);
|
|
|
|
const mult = helpers.number(ctx, "mult", _mult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateSkill(exp, mult);
|
|
|
|
},
|
|
|
|
calculateExp:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_skill: unknown, _mult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const skill = helpers.number(ctx, "skill", _skill);
|
|
|
|
const mult = helpers.number(ctx, "mult", _mult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateExp(skill, mult);
|
|
|
|
},
|
2021-11-03 03:58:40 +01:00
|
|
|
},
|
|
|
|
hacking: {
|
2022-05-24 23:29:44 +02:00
|
|
|
hackChance:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateHackingChance(server, player);
|
|
|
|
},
|
|
|
|
hackExp:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateHackingExpGain(server, player);
|
|
|
|
},
|
|
|
|
hackPercent:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculatePercentMoneyHacked(server, player);
|
|
|
|
},
|
|
|
|
growPercent:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _threads: unknown, _player: unknown, _cores: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
|
|
|
const threads = helpers.number(ctx, "threads", _threads);
|
|
|
|
const cores = helpers.number(ctx, "cores", _cores);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateServerGrowth(server, threads, player, cores);
|
|
|
|
},
|
|
|
|
hackTime:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateHackingTime(server, player) * 1000;
|
|
|
|
},
|
|
|
|
growTime:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateGrowTime(server, player) * 1000;
|
|
|
|
},
|
|
|
|
weakenTime:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_server: unknown, _player: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const server = helpers.server(ctx, _server);
|
|
|
|
const player = helpers.player(ctx, _player);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateWeakenTime(server, player) * 1000;
|
|
|
|
},
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
|
|
|
hacknetNodes: {
|
2022-05-24 23:29:44 +02:00
|
|
|
moneyGainRate:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_level: unknown, _ram: unknown, _cores: unknown, _mult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const level = helpers.number(ctx, "level", _level);
|
|
|
|
const ram = helpers.number(ctx, "ram", _ram);
|
|
|
|
const cores = helpers.number(ctx, "cores", _cores);
|
|
|
|
const mult = helpers.number(ctx, "mult", _mult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateMoneyGainRate(level, ram, cores, mult);
|
|
|
|
},
|
|
|
|
levelUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingLevel = helpers.number(ctx, "startingLevel", _startingLevel);
|
|
|
|
const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
|
|
|
|
const costMult = helpers.number(ctx, "costMult", _costMult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
|
|
|
|
},
|
|
|
|
ramUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingRam = helpers.number(ctx, "startingRam", _startingRam);
|
|
|
|
const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
|
|
|
|
const costMult = helpers.number(ctx, "costMult", _costMult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateRamUpgradeCost(startingRam, extraLevels, costMult);
|
|
|
|
},
|
|
|
|
coreUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingCore = helpers.number(ctx, "startingCore", _startingCore);
|
|
|
|
const extraCores = helpers.number(ctx, "extraCores", _extraCores);
|
|
|
|
const costMult = helpers.number(ctx, "costMult", _costMult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateCoreUpgradeCost(startingCore, extraCores, costMult);
|
|
|
|
},
|
|
|
|
hacknetNodeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_n: unknown, _mult: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const n = helpers.number(ctx, "n", _n);
|
|
|
|
const mult = helpers.number(ctx, "mult", _mult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateNodeCost(n, mult);
|
|
|
|
},
|
2022-07-19 22:46:03 +02:00
|
|
|
constants: (ctx: NetscriptContext) => (): DefHacknetNodeConstants => {
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
2021-10-14 09:22:02 +02:00
|
|
|
return Object.assign({}, HacknetNodeConstants);
|
|
|
|
},
|
|
|
|
},
|
|
|
|
hacknetServers: {
|
2022-05-24 23:29:44 +02:00
|
|
|
hashGainRate:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_level: unknown, _ramUsed: unknown, _maxRam: unknown, _cores: unknown, _mult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const level = helpers.number(ctx, "level", _level);
|
|
|
|
const ramUsed = helpers.number(ctx, "ramUsed", _ramUsed);
|
|
|
|
const maxRam = helpers.number(ctx, "maxRam", _maxRam);
|
|
|
|
const cores = helpers.number(ctx, "cores", _cores);
|
|
|
|
const mult = helpers.number(ctx, "mult", _mult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return HScalculateHashGainRate(level, ramUsed, maxRam, cores, mult);
|
|
|
|
},
|
|
|
|
levelUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingLevel: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingLevel = helpers.number(ctx, "startingLevel", _startingLevel);
|
|
|
|
const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
|
|
|
|
const costMult = helpers.number(ctx, "costMult", _costMult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return HScalculateLevelUpgradeCost(startingLevel, extraLevels, costMult);
|
|
|
|
},
|
|
|
|
ramUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingRam: unknown, _extraLevels: unknown = 1, _costMult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingRam = helpers.number(ctx, "startingRam", _startingRam);
|
|
|
|
const extraLevels = helpers.number(ctx, "extraLevels", _extraLevels);
|
|
|
|
const costMult = helpers.number(ctx, "costMult", _costMult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return HScalculateRamUpgradeCost(startingRam, extraLevels, costMult);
|
|
|
|
},
|
|
|
|
coreUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingCore: unknown, _extraCores: unknown = 1, _costMult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingCore = helpers.number(ctx, "startingCore", _startingCore);
|
|
|
|
const extraCores = helpers.number(ctx, "extraCores", _extraCores);
|
|
|
|
const costMult = helpers.number(ctx, "costMult", _costMult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return HScalculateCoreUpgradeCost(startingCore, extraCores, costMult);
|
|
|
|
},
|
|
|
|
cacheUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_startingCache: unknown, _extraCache: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const startingCache = helpers.number(ctx, "startingCache", _startingCache);
|
|
|
|
const extraCache = helpers.number(ctx, "extraCache", _extraCache);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return HScalculateCacheUpgradeCost(startingCache, extraCache);
|
|
|
|
},
|
|
|
|
hashUpgradeCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_upgName: unknown, _level: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const upgName = helpers.string(ctx, "upgName", _upgName);
|
|
|
|
const level = helpers.number(ctx, "level", _level);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
const upg = player.hashManager.getUpgrade(upgName);
|
|
|
|
if (!upg) {
|
2022-08-08 19:43:41 +02:00
|
|
|
throw helpers.makeRuntimeErrorMsg(ctx, `Invalid Hash Upgrade: ${upgName}`);
|
2022-05-24 23:29:44 +02:00
|
|
|
}
|
|
|
|
return upg.getCost(level);
|
|
|
|
},
|
|
|
|
hacknetServerCost:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_n: unknown, _mult: unknown = 1): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const n = helpers.number(ctx, "n", _n);
|
|
|
|
const mult = helpers.number(ctx, "mult", _mult);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return HScalculateServerCost(n, mult);
|
|
|
|
},
|
2022-07-19 22:46:03 +02:00
|
|
|
constants: (ctx: NetscriptContext) => (): DefHacknetServerConstants => {
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
2021-10-14 09:22:02 +02:00
|
|
|
return Object.assign({}, HacknetServerConstants);
|
|
|
|
},
|
|
|
|
},
|
2021-12-09 00:19:30 +01:00
|
|
|
gang: {
|
2022-05-24 23:29:44 +02:00
|
|
|
wantedPenalty:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_gang: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const gang = helpers.gang(ctx, _gang);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateWantedPenalty(gang);
|
|
|
|
},
|
|
|
|
respectGain:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_gang: unknown, _member: unknown, _task: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const gang = helpers.gang(ctx, _gang);
|
|
|
|
const member = helpers.gangMember(ctx, _member);
|
|
|
|
const task = helpers.gangTask(ctx, _task);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateRespectGain(gang, member, task);
|
|
|
|
},
|
|
|
|
wantedLevelGain:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_gang: unknown, _member: unknown, _task: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const gang = helpers.gang(ctx, _gang);
|
|
|
|
const member = helpers.gangMember(ctx, _member);
|
|
|
|
const task = helpers.gangTask(ctx, _task);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateWantedLevelGain(gang, member, task);
|
|
|
|
},
|
|
|
|
moneyGain:
|
|
|
|
(ctx: NetscriptContext) =>
|
2022-07-19 22:46:03 +02:00
|
|
|
(_gang: unknown, _member: unknown, _task: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const gang = helpers.gang(ctx, _gang);
|
|
|
|
const member = helpers.gangMember(ctx, _member);
|
|
|
|
const task = helpers.gangTask(ctx, _task);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateMoneyGain(gang, member, task);
|
|
|
|
},
|
|
|
|
ascensionPointsGain:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_exp: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const exp = helpers.number(ctx, "exp", _exp);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateAscensionPointsGain(exp);
|
|
|
|
},
|
|
|
|
ascensionMultiplier:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_points: unknown): number => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const points = helpers.number(ctx, "points", _points);
|
2022-05-24 23:29:44 +02:00
|
|
|
checkFormulasAccess(ctx);
|
|
|
|
return calculateAscensionMult(points);
|
|
|
|
},
|
2021-12-09 00:19:30 +01:00
|
|
|
},
|
2022-08-17 20:32:52 +02:00
|
|
|
work: {
|
|
|
|
crimeGains:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_crimeType: unknown): WorkStats => {
|
|
|
|
const crimeType = helpers.string(ctx, "crimeType", _crimeType);
|
|
|
|
const crime = Object.values(Crimes).find((c) => String(c.type) === crimeType);
|
|
|
|
if (!crime) throw new Error(`Invalid crime type: ${crimeType}`);
|
|
|
|
return calculateCrimeWorkStats(crime);
|
|
|
|
},
|
|
|
|
classGains:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_player: unknown, _classType: unknown, _locationName: unknown): WorkStats => {
|
|
|
|
const target = helpers.player(ctx, _player);
|
|
|
|
const classType = helpers.string(ctx, "classType", _classType);
|
|
|
|
const locationName = helpers.string(ctx, "locationName", _locationName);
|
|
|
|
return calculateClassEarnings(player, target, classType as ClassType, locationName as LocationName);
|
|
|
|
},
|
|
|
|
factionGains:
|
|
|
|
(ctx: NetscriptContext) =>
|
|
|
|
(_player: unknown, _workType: unknown, _favor: unknown): WorkStats => {
|
|
|
|
const player = helpers.player(ctx, _player);
|
|
|
|
const workType = helpers.string(ctx, "_workType", _workType) as FactionWorkType;
|
|
|
|
const favor = helpers.number(ctx, "favor", _favor);
|
|
|
|
const exp = calculateFactionExp(player, workType);
|
|
|
|
const rep = calculateFactionRep(player, workType, favor);
|
|
|
|
exp.reputation = rep;
|
|
|
|
return exp;
|
|
|
|
},
|
|
|
|
// companyGains: (ctx: NetscriptContext) =>_player: unknown (): WorkStats {
|
|
|
|
// const player = helpers.player(ctx, _player);
|
|
|
|
|
|
|
|
// },
|
|
|
|
},
|
2021-10-14 09:22:02 +02:00
|
|
|
};
|
|
|
|
}
|