2022-03-20 09:32:29 +01:00
|
|
|
import { getRamCost } from "./RamCostGenerator";
|
|
|
|
import type { IPort } from "../NetscriptPort";
|
|
|
|
import type { BaseServer } from "../Server/BaseServer";
|
|
|
|
import type { WorkerScript } from "./WorkerScript";
|
|
|
|
import { makeRuntimeRejectMsg } from "../NetscriptEvaluator";
|
|
|
|
import { Player } from "../Player";
|
2022-07-15 07:51:30 +02:00
|
|
|
import { CityName } from "../Locations/data/CityNames";
|
|
|
|
import { BasicHGWOptions } from "../ScriptEditor/NetscriptDefinitions";
|
2022-07-19 22:46:03 +02:00
|
|
|
import { IPlayer } from "../PersonObjects/IPlayer";
|
|
|
|
import { Server } from "../Server/Server";
|
|
|
|
import { FormulaGang } from "../Gang/formulas/formulas";
|
2022-07-20 00:25:06 +02:00
|
|
|
import { INetscriptHelper, ScriptIdentifier } from "../NetscriptFunctions/INetscriptHelper";
|
2022-07-19 22:46:03 +02:00
|
|
|
import { GangMember } from "../Gang/GangMember";
|
|
|
|
import { GangMemberTask } from "../Gang/GangMemberTask";
|
2022-07-20 01:04:06 +02:00
|
|
|
import { ScriptArg } from "./ScriptArg";
|
2022-08-06 23:53:09 +02:00
|
|
|
import { ScriptDeath } from "./ScriptDeath";
|
|
|
|
import { sprintf } from "sprintf-js";
|
2022-03-20 09:32:29 +01:00
|
|
|
|
2022-07-15 07:51:30 +02:00
|
|
|
type ExternalFunction = (...args: unknown[]) => unknown;
|
2022-05-24 23:51:48 +02:00
|
|
|
export type ExternalAPI = {
|
2022-03-30 01:11:13 +02:00
|
|
|
[string: string]: ExternalAPI | ExternalFunction;
|
2022-04-07 02:00:54 +02:00
|
|
|
};
|
2022-03-30 01:11:13 +02:00
|
|
|
|
2022-04-09 07:15:45 +02:00
|
|
|
type InternalFunction<F extends (...args: unknown[]) => unknown> = (ctx: NetscriptContext) => F;
|
2022-05-24 23:51:48 +02:00
|
|
|
|
2022-03-30 01:11:13 +02:00
|
|
|
export type InternalAPI<API> = {
|
2022-04-07 02:00:54 +02:00
|
|
|
[Property in keyof API]: API[Property] extends ExternalFunction
|
|
|
|
? InternalFunction<API[Property]>
|
2022-05-25 00:34:00 +02:00
|
|
|
: API[Property] extends object
|
2022-04-07 02:00:54 +02:00
|
|
|
? InternalAPI<API[Property]>
|
|
|
|
: never;
|
|
|
|
};
|
2022-03-30 01:11:13 +02:00
|
|
|
|
|
|
|
type WrappedNetscriptFunction = (...args: unknown[]) => unknown;
|
|
|
|
type WrappedNetscriptAPI = {
|
2022-04-09 07:15:45 +02:00
|
|
|
readonly [string: string]: WrappedNetscriptAPI | WrappedNetscriptFunction;
|
2022-04-07 02:00:54 +02:00
|
|
|
};
|
2022-03-20 09:32:29 +01:00
|
|
|
|
|
|
|
export type NetscriptContext = {
|
|
|
|
makeRuntimeErrorMsg: (message: string) => string;
|
|
|
|
log: (message: () => string) => void;
|
2022-03-29 23:57:17 +02:00
|
|
|
workerScript: WorkerScript;
|
|
|
|
function: string;
|
|
|
|
helper: WrappedNetscriptHelpers;
|
2022-03-20 09:32:29 +01:00
|
|
|
};
|
|
|
|
|
2022-03-29 23:57:17 +02:00
|
|
|
type WrappedNetscriptHelpers = {
|
|
|
|
makeRuntimeErrorMsg: (msg: string) => string;
|
|
|
|
string: (argName: string, v: unknown) => string;
|
|
|
|
number: (argName: string, v: unknown) => number;
|
2022-07-20 00:25:06 +02:00
|
|
|
ustring: (argName: string, v: unknown) => string | undefined;
|
|
|
|
unumber: (argName: string, v: unknown) => number | undefined;
|
2022-07-20 01:04:06 +02:00
|
|
|
scriptArgs(args: unknown): ScriptArg[];
|
2022-07-20 00:25:06 +02:00
|
|
|
scriptIdentifier: (fn: unknown, hostname: unknown, args: unknown) => ScriptIdentifier;
|
2022-04-12 08:51:10 +02:00
|
|
|
city: (argName: string, v: unknown) => CityName;
|
2022-03-29 23:57:17 +02:00
|
|
|
boolean: (v: unknown) => boolean;
|
2022-04-07 02:00:54 +02:00
|
|
|
getServer: (hostname: string) => BaseServer;
|
2022-03-29 23:57:17 +02:00
|
|
|
checkSingularityAccess: () => void;
|
2022-07-15 07:51:30 +02:00
|
|
|
hack: (hostname: string, manual: boolean, { threads: requestedThreads, stock }?: BasicHGWOptions) => Promise<number>;
|
|
|
|
getValidPort: (port: number) => IPort;
|
2022-07-19 22:46:03 +02:00
|
|
|
player(p: unknown): IPlayer;
|
|
|
|
server(s: unknown): Server;
|
|
|
|
gang(g: unknown): FormulaGang;
|
2022-07-20 00:25:06 +02:00
|
|
|
gangMember: (m: unknown) => GangMember;
|
|
|
|
gangTask: (t: unknown) => GangMemberTask;
|
2022-04-07 02:00:54 +02:00
|
|
|
};
|
2022-03-29 23:57:17 +02:00
|
|
|
|
2022-08-06 23:53:09 +02:00
|
|
|
function checkEnv(ctx: NetscriptContext) {
|
|
|
|
if (ctx.workerScript.env.stopFlag) throw new ScriptDeath(ctx.workerScript);
|
|
|
|
if (ctx.workerScript.env.runningFn && ctx.function !== "asleep") {
|
|
|
|
if (ctx.workerScript.delayReject) ctx.workerScript.delayReject();
|
|
|
|
const msg =
|
|
|
|
"Concurrent calls to Netscript functions are not allowed!\n" +
|
|
|
|
"Did you forget to await hack(), grow(), or some other\n" +
|
|
|
|
"promise-returning function? (Currently running: %s tried to run: %s)";
|
|
|
|
ctx.workerScript.errorMessage = makeRuntimeRejectMsg(
|
|
|
|
ctx.workerScript,
|
|
|
|
sprintf(msg, ctx.workerScript.env.runningFn, ctx.function),
|
|
|
|
);
|
|
|
|
throw new ScriptDeath(ctx.workerScript);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-04-08 01:57:16 +02:00
|
|
|
function wrapFunction(
|
2022-07-19 22:46:03 +02:00
|
|
|
helpers: INetscriptHelper,
|
2022-07-15 07:51:30 +02:00
|
|
|
wrappedAPI: ExternalAPI,
|
2022-04-07 02:00:54 +02:00
|
|
|
workerScript: WorkerScript,
|
2022-04-08 01:57:16 +02:00
|
|
|
func: (_ctx: NetscriptContext) => (...args: unknown[]) => unknown,
|
2022-04-07 02:00:54 +02:00
|
|
|
...tree: string[]
|
|
|
|
): void {
|
2022-04-08 02:02:59 +02:00
|
|
|
const functionPath = tree.join(".");
|
2022-03-20 09:32:29 +01:00
|
|
|
const functionName = tree.pop();
|
2022-04-07 02:00:54 +02:00
|
|
|
if (typeof functionName !== "string") {
|
|
|
|
throw makeRuntimeRejectMsg(workerScript, "Failure occured while wrapping netscript api");
|
2022-03-20 09:32:29 +01:00
|
|
|
}
|
|
|
|
const ctx = {
|
2022-04-07 02:00:54 +02:00
|
|
|
makeRuntimeErrorMsg: (message: string) => {
|
2022-04-08 01:57:16 +02:00
|
|
|
return helpers.makeRuntimeErrorMsg(functionPath, message);
|
2022-04-07 02:00:54 +02:00
|
|
|
},
|
|
|
|
log: (message: () => string) => {
|
2022-04-08 01:57:16 +02:00
|
|
|
workerScript.log(functionPath, message);
|
2022-04-07 02:00:54 +02:00
|
|
|
},
|
2022-03-29 23:57:17 +02:00
|
|
|
workerScript,
|
|
|
|
function: functionName,
|
|
|
|
helper: {
|
2022-04-08 01:57:16 +02:00
|
|
|
makeRuntimeErrorMsg: (msg: string) => helpers.makeRuntimeErrorMsg(functionPath, msg),
|
|
|
|
string: (argName: string, v: unknown) => helpers.string(functionPath, argName, v),
|
|
|
|
number: (argName: string, v: unknown) => helpers.number(functionPath, argName, v),
|
2022-07-20 17:41:02 +02:00
|
|
|
ustring: (argName: string, v: unknown) => helpers.ustring(functionPath, argName, v),
|
|
|
|
unumber: (argName: string, v: unknown) => helpers.unumber(functionPath, argName, v),
|
2022-07-20 01:04:06 +02:00
|
|
|
scriptArgs: (v: unknown) => helpers.scriptArgs(functionPath, v),
|
2022-07-20 00:25:06 +02:00
|
|
|
scriptIdentifier: (fn: unknown, hostname: unknown, args: unknown) =>
|
|
|
|
helpers.scriptIdentifier(functionPath, fn, hostname, args),
|
2022-04-12 08:51:10 +02:00
|
|
|
city: (argName: string, v: unknown) => helpers.city(functionPath, argName, v),
|
2022-03-29 23:57:17 +02:00
|
|
|
boolean: helpers.boolean,
|
2022-05-25 02:16:39 +02:00
|
|
|
getServer: (hostname: string) => helpers.getServer(hostname, ctx),
|
2022-03-29 23:57:17 +02:00
|
|
|
checkSingularityAccess: () => helpers.checkSingularityAccess(functionName),
|
2022-07-15 07:51:30 +02:00
|
|
|
hack: (hostname: string, manual: boolean, extra?: BasicHGWOptions) => helpers.hack(ctx, hostname, manual, extra),
|
|
|
|
getValidPort: (port: number) => helpers.getValidPort(functionPath, port),
|
2022-07-19 22:46:03 +02:00
|
|
|
player: (p: unknown) => helpers.player(functionPath, p),
|
|
|
|
server: (s: unknown) => helpers.server(functionPath, s),
|
|
|
|
gang: (g: unknown) => helpers.gang(functionPath, g),
|
|
|
|
gangMember: (m: unknown) => helpers.gangMember(functionPath, m),
|
|
|
|
gangTask: (t: unknown) => helpers.gangTask(functionPath, t),
|
2022-04-07 02:00:54 +02:00
|
|
|
},
|
2022-03-20 09:32:29 +01:00
|
|
|
};
|
2022-04-08 01:57:16 +02:00
|
|
|
function wrappedFunction(...args: unknown[]): unknown {
|
2022-08-06 23:53:09 +02:00
|
|
|
checkEnv(ctx);
|
2022-03-29 23:57:17 +02:00
|
|
|
helpers.updateDynamicRam(ctx.function, getRamCost(Player, ...tree, ctx.function));
|
2022-04-08 01:57:16 +02:00
|
|
|
return func(ctx)(...args);
|
2022-03-20 09:32:29 +01:00
|
|
|
}
|
2022-08-06 23:53:09 +02:00
|
|
|
const parent = getNestedProperty(wrappedAPI, tree);
|
2022-03-20 09:32:29 +01:00
|
|
|
Object.defineProperty(parent, functionName, {
|
|
|
|
value: wrappedFunction,
|
2022-04-07 02:00:54 +02:00
|
|
|
writable: true,
|
2022-04-08 02:02:59 +02:00
|
|
|
enumerable: true,
|
2022-03-20 09:32:29 +01:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-04-07 02:00:54 +02:00
|
|
|
export function wrapAPI(
|
2022-07-19 22:46:03 +02:00
|
|
|
helpers: INetscriptHelper,
|
2022-04-07 02:00:54 +02:00
|
|
|
wrappedAPI: ExternalAPI,
|
|
|
|
workerScript: WorkerScript,
|
2022-07-20 07:37:41 +02:00
|
|
|
namespace: object,
|
2022-04-07 02:00:54 +02:00
|
|
|
...tree: string[]
|
|
|
|
): WrappedNetscriptAPI {
|
2022-07-20 07:37:41 +02:00
|
|
|
for (const [key, value] of Object.entries(namespace)) {
|
2022-07-20 17:34:49 +02:00
|
|
|
if (typeof value === "function") {
|
|
|
|
wrapFunction(helpers, wrappedAPI, workerScript, value, ...tree, key);
|
|
|
|
} else if (Array.isArray(value)) {
|
2022-08-06 23:53:09 +02:00
|
|
|
setNestedProperty(wrappedAPI, value.slice(), key);
|
2022-07-20 17:34:49 +02:00
|
|
|
} else if (typeof value === "object") {
|
|
|
|
wrapAPI(helpers, wrappedAPI, workerScript, value, ...tree, key);
|
|
|
|
} else {
|
|
|
|
setNestedProperty(wrappedAPI, value, ...tree, key);
|
2022-03-20 09:32:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return wrappedAPI;
|
|
|
|
}
|
|
|
|
|
2022-08-06 23:53:09 +02:00
|
|
|
function setNestedProperty(root: any, value: unknown, ...tree: string[]): void {
|
2022-03-20 09:32:29 +01:00
|
|
|
let target = root;
|
|
|
|
const key = tree.pop();
|
2022-08-06 23:53:09 +02:00
|
|
|
if (!key) throw new Error("Failure occured while wrapping netscript api (setNestedProperty)");
|
|
|
|
for (const branch of tree) {
|
|
|
|
target[branch] ??= {};
|
|
|
|
target = target[branch];
|
2022-03-20 09:32:29 +01:00
|
|
|
}
|
2022-08-06 23:53:09 +02:00
|
|
|
target[key] = value;
|
2022-03-20 09:32:29 +01:00
|
|
|
}
|
|
|
|
|
2022-08-06 23:53:09 +02:00
|
|
|
function getNestedProperty(root: any, tree: string[]): unknown {
|
2022-03-20 09:32:29 +01:00
|
|
|
let target = root;
|
|
|
|
for (const branch of tree) {
|
2022-08-06 23:53:09 +02:00
|
|
|
target[branch] ??= {};
|
2022-03-20 09:32:29 +01:00
|
|
|
target = target[branch];
|
|
|
|
}
|
|
|
|
return target;
|
|
|
|
}
|