fix mc

src/NetscriptFunctions/Extra.ts

@@ -0,0 +1,39 @@
+import { INetscriptHelper } from "./INetscriptHelper";
+import { WorkerScript } from "../Netscript/WorkerScript";
+import { IPlayer } from "../PersonObjects/IPlayer";
+import { Exploit } from "../Exploits/Exploit";
+
+export interface INetscriptExtra {
+  heart: {
+    break(): number;
+  };
+  exploit(): void;
+  bypass(doc: Document): void;
+}
+
+export function NetscriptExtra(player: IPlayer, workerScript: WorkerScript, helper: INetscriptHelper): INetscriptExtra {
+  return {
+    heart: {
+      // Easter egg function
+      break: function (): number {
+        return player.karma;
+      },
+    },
+    exploit: function (): void {
+      player.giveExploit(Exploit.UndocumentedFunctionCall);
+    },
+    bypass: function (doc: any): void {
+      // reset both fields first
+      doc.completely_unused_field = undefined;
+      const real_document: any = document;
+      real_document.completely_unused_field = undefined;
+      // set one to true and check that it affected the other.
+      real_document.completely_unused_field = true;
+      if (doc.completely_unused_field && workerScript.ramUsage === 1.6) {
+        player.giveExploit(Exploit.Bypass);
+      }
+      doc.completely_unused_field = undefined;
+      real_document.completely_unused_field = undefined;
+    },
+  };
+}

src/NetscriptFunctions/Gang.ts

@@ -0,0 +1,314 @@
+import { INetscriptHelper } from "./INetscriptHelper";
+import { IPlayer } from "../PersonObjects/IPlayer";
+import { getRamCost } from "../Netscript/RamCostGenerator";
+import { Gang } from "../Gang/Gang";
+import { AllGangs } from "../Gang/AllGangs";
+import { GangMemberTasks } from "../Gang/GangMemberTasks";
+import { GangMemberUpgrades } from "../Gang/GangMemberUpgrades";
+import { WorkerScript } from "../Netscript/WorkerScript";
+import { GangMember } from "../Gang/GangMember";
+import { GangMemberTask } from "../Gang/GangMemberTask";
+
+export interface INetscriptGang {
+  createGang(faction: string): boolean;
+  inGang(): boolean;
+  getMemberNames(): string[];
+  getGangInformation(): any;
+  getOtherGangInformation(): any;
+  getMemberInformation(name: string): any;
+  canRecruitMember(): boolean;
+  recruitMember(name: string): boolean;
+  getTaskNames(): string[];
+  setMemberTask(memberName: string, taskName: string): boolean;
+  getTaskStats(taskName: string): any;
+  getEquipmentNames(): string[];
+  getEquipmentCost(equipName: string): number;
+  getEquipmentType(equipName: string): string;
+  getEquipmentStats(equipName: string): any;
+  purchaseEquipment(memberName: string, equipName: string): any;
+  ascendMember(name: string): any;
+  setTerritoryWarfare(engage: boolean): void;
+  getChanceToWinClash(otherGang: string): number;
+  getBonusTime(): number;
+}
+
+export function NetscriptGang(player: IPlayer, workerScript: WorkerScript, helper: INetscriptHelper): INetscriptGang {
+  const checkGangApiAccess = function (func: string): void {
+    const gang = player.gang;
+    if (gang === null) throw new Error("Must have joined gang");
+    const hasAccess = gang instanceof Gang;
+    if (!hasAccess) {
+      throw helper.makeRuntimeErrorMsg(`gang.${func}`, `You do not currently have a Gang`);
+    }
+  };
+
+  const getGangMember = function (func: string, name: string): GangMember {
+    const gang = player.gang;
+    if (gang === null) throw new Error("Must have joined gang");
+    for (const member of gang.members) if (member.name === name) return member;
+    throw helper.makeRuntimeErrorMsg(`gang.${func}`, `Invalid gang member: '${name}'`);
+  };
+
+  const getGangTask = function (func: string, name: string): GangMemberTask {
+    const task = GangMemberTasks[name];
+    if (!task) {
+      throw helper.makeRuntimeErrorMsg(`gang.${func}`, `Invalid task: '${name}'`);
+    }
+
+    return task;
+  };
+
+  return {
+    createGang: function (faction: string): boolean {
+      helper.updateDynamicRam("createGang", getRamCost("gang", "createGang"));
+      // this list is copied from Faction/ui/Root.tsx
+      const GangNames = [
+        "Slum Snakes",
+        "Tetrads",
+        "The Syndicate",
+        "The Dark Army",
+        "Speakers for the Dead",
+        "NiteSec",
+        "The Black Hand",
+      ];
+      if (!player.canAccessGang() || !GangNames.includes(faction)) return false;
+      if (player.inGang()) return false;
+      if (!player.factions.includes(faction)) return false;
+
+      const isHacking = faction === "NiteSec" || faction === "The Black Hand";
+      player.startGang(faction, isHacking);
+      return true;
+    },
+    inGang: function (): any {
+      helper.updateDynamicRam("inGang", getRamCost("gang", "inGang"));
+      return player.inGang();
+    },
+    getMemberNames: function (): any {
+      helper.updateDynamicRam("getMemberNames", getRamCost("gang", "getMemberNames"));
+      checkGangApiAccess("getMemberNames");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      return gang.members.map((member) => member.name);
+    },
+    getGangInformation: function (): any {
+      helper.updateDynamicRam("getGangInformation", getRamCost("gang", "getGangInformation"));
+      checkGangApiAccess("getGangInformation");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      return {
+        faction: gang.facName,
+        isHacking: gang.isHackingGang,
+        moneyGainRate: gang.moneyGainRate,
+        power: gang.getPower(),
+        respect: gang.respect,
+        respectGainRate: gang.respectGainRate,
+        territory: gang.getTerritory(),
+        territoryClashChance: gang.territoryClashChance,
+        territoryWarfareEngaged: gang.territoryWarfareEngaged,
+        wantedLevel: gang.wanted,
+        wantedLevelGainRate: gang.wantedGainRate,
+      };
+    },
+    getOtherGangInformation: function (): any {
+      helper.updateDynamicRam("getOtherGangInformation", getRamCost("gang", "getOtherGangInformation"));
+      checkGangApiAccess("getOtherGangInformation");
+      const cpy: any = {};
+      for (const gang in AllGangs) {
+        cpy[gang] = Object.assign({}, AllGangs[gang]);
+      }
+
+      return cpy;
+    },
+    getMemberInformation: function (name: any): any {
+      helper.updateDynamicRam("getMemberInformation", getRamCost("gang", "getMemberInformation"));
+      checkGangApiAccess("getMemberInformation");
+      const member = getGangMember("getMemberInformation", name);
+      return {
+        name: member.name,
+        task: member.task,
+        earnedRespect: member.earnedRespect,
+        hack: member.hack,
+        str: member.str,
+        def: member.def,
+        dex: member.dex,
+        agi: member.agi,
+        cha: member.cha,
+
+        hack_exp: member.hack_exp,
+        str_exp: member.str_exp,
+        def_exp: member.def_exp,
+        dex_exp: member.dex_exp,
+        agi_exp: member.agi_exp,
+        cha_exp: member.cha_exp,
+
+        hack_mult: member.hack_mult,
+        str_mult: member.str_mult,
+        def_mult: member.def_mult,
+        dex_mult: member.dex_mult,
+        agi_mult: member.agi_mult,
+        cha_mult: member.cha_mult,
+
+        hack_asc_mult: member.calculateAscensionMult(member.hack_asc_points),
+        str_asc_mult: member.calculateAscensionMult(member.str_asc_points),
+        def_asc_mult: member.calculateAscensionMult(member.def_asc_points),
+        dex_asc_mult: member.calculateAscensionMult(member.dex_asc_points),
+        agi_asc_mult: member.calculateAscensionMult(member.agi_asc_points),
+        cha_asc_mult: member.calculateAscensionMult(member.cha_asc_points),
+
+        hack_asc_points: member.hack_asc_points,
+        str_asc_points: member.str_asc_points,
+        def_asc_points: member.def_asc_points,
+        dex_asc_points: member.dex_asc_points,
+        agi_asc_points: member.agi_asc_points,
+        cha_asc_points: member.cha_asc_points,
+
+        upgrades: member.upgrades.slice(),
+        augmentations: member.augmentations.slice(),
+      };
+    },
+    canRecruitMember: function (): any {
+      helper.updateDynamicRam("canRecruitMember", getRamCost("gang", "canRecruitMember"));
+      checkGangApiAccess("canRecruitMember");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      return gang.canRecruitMember();
+    },
+    recruitMember: function (name: any): any {
+      helper.updateDynamicRam("recruitMember", getRamCost("gang", "recruitMember"));
+      checkGangApiAccess("recruitMember");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      const recruited = gang.recruitMember(name);
+      if (recruited) {
+        workerScript.log("recruitMember", `Successfully recruited Gang Member '${name}'`);
+      } else {
+        workerScript.log("recruitMember", `Failed to recruit Gang Member '${name}'`);
+      }
+
+      return recruited;
+    },
+    getTaskNames: function (): any {
+      helper.updateDynamicRam("getTaskNames", getRamCost("gang", "getTaskNames"));
+      checkGangApiAccess("getTaskNames");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      const tasks = gang.getAllTaskNames();
+      tasks.unshift("Unassigned");
+      return tasks;
+    },
+    setMemberTask: function (memberName: any, taskName: any): any {
+      helper.updateDynamicRam("setMemberTask", getRamCost("gang", "setMemberTask"));
+      checkGangApiAccess("setMemberTask");
+      const member = getGangMember("setMemberTask", memberName);
+      const success = member.assignToTask(taskName);
+      if (success) {
+        workerScript.log("setMemberTask", `Successfully assigned Gang Member '${memberName}' to '${taskName}' task`);
+      } else {
+        workerScript.log(
+          "setMemberTask",
+          `Failed to assign Gang Member '${memberName}' to '${taskName}' task. '${memberName}' is now Unassigned`,
+        );
+      }
+
+      return success;
+    },
+    getTaskStats: function (taskName: any): any {
+      helper.updateDynamicRam("getTaskStats", getRamCost("gang", "getTaskStats"));
+      checkGangApiAccess("getTaskStats");
+      const task = getGangTask("getTaskStats", taskName);
+      const copy = Object.assign({}, task);
+      copy.territory = Object.assign({}, task.territory);
+      return copy;
+    },
+    getEquipmentNames: function (): any {
+      helper.updateDynamicRam("getEquipmentNames", getRamCost("gang", "getEquipmentNames"));
+      checkGangApiAccess("getEquipmentNames");
+      return Object.keys(GangMemberUpgrades);
+    },
+    getEquipmentCost: function (equipName: any): any {
+      helper.updateDynamicRam("getEquipmentCost", getRamCost("gang", "getEquipmentCost"));
+      checkGangApiAccess("getEquipmentCost");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      const upg = GangMemberUpgrades[equipName];
+      if (upg === null) return Infinity;
+      return gang.getUpgradeCost(upg);
+    },
+    getEquipmentType: function (equipName: any): any {
+      helper.updateDynamicRam("getEquipmentType", getRamCost("gang", "getEquipmentType"));
+      checkGangApiAccess("getEquipmentType");
+      const upg = GangMemberUpgrades[equipName];
+      if (upg == null) return "";
+      return upg.getType();
+    },
+    getEquipmentStats: function (equipName: any): any {
+      helper.updateDynamicRam("getEquipmentStats", getRamCost("gang", "getEquipmentStats"));
+      checkGangApiAccess("getEquipmentStats");
+      const equipment = GangMemberUpgrades[equipName];
+      if (!equipment) {
+        throw helper.makeRuntimeErrorMsg("getEquipmentStats", `Invalid equipment: ${equipName}`);
+      }
+      return Object.assign({}, equipment.mults);
+    },
+    purchaseEquipment: function (memberName: any, equipName: any): any {
+      helper.updateDynamicRam("purchaseEquipment", getRamCost("gang", "purchaseEquipment"));
+      checkGangApiAccess("purchaseEquipment");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      const member = getGangMember("purchaseEquipment", memberName);
+      const equipment = GangMemberUpgrades[equipName];
+      if (!equipment) return false;
+      const res = member.buyUpgrade(equipment, player, gang);
+      if (res) {
+        workerScript.log("purchaseEquipment", `Purchased '${equipName}' for Gang member '${memberName}'`);
+      } else {
+        workerScript.log("purchaseEquipment", `Failed to purchase '${equipName}' for Gang member '${memberName}'`);
+      }
+
+      return res;
+    },
+    ascendMember: function (name: any): any {
+      helper.updateDynamicRam("ascendMember", getRamCost("gang", "ascendMember"));
+      checkGangApiAccess("ascendMember");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      const member = getGangMember("ascendMember", name);
+      if (!member.canAscend()) return;
+      return gang.ascendMember(member, workerScript);
+    },
+    setTerritoryWarfare: function (engage: any): void {
+      helper.updateDynamicRam("setTerritoryWarfare", getRamCost("gang", "setTerritoryWarfare"));
+      checkGangApiAccess("setTerritoryWarfare");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      if (engage) {
+        gang.territoryWarfareEngaged = true;
+        workerScript.log("setTerritoryWarfare", "Engaging in Gang Territory Warfare");
+      } else {
+        gang.territoryWarfareEngaged = false;
+        workerScript.log("setTerritoryWarfare", "Disengaging in Gang Territory Warfare");
+      }
+    },
+    getChanceToWinClash: function (otherGang: any): any {
+      helper.updateDynamicRam("getChanceToWinClash", getRamCost("gang", "getChanceToWinClash"));
+      checkGangApiAccess("getChanceToWinClash");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      if (AllGangs[otherGang] == null) {
+        throw helper.makeRuntimeErrorMsg(`gang.getChanceToWinClash`, `Invalid gang: ${otherGang}`);
+      }
+
+      const playerPower = AllGangs[gang.facName].power;
+      const otherPower = AllGangs[otherGang].power;
+
+      return playerPower / (otherPower + playerPower);
+    },
+    getBonusTime: function (): any {
+      helper.updateDynamicRam("getBonusTime", getRamCost("gang", "getBonusTime"));
+      checkGangApiAccess("getBonusTime");
+      const gang = player.gang;
+      if (gang === null) throw new Error("Should not be called without Gang");
+      return Math.round(gang.storedCycles / 5);
+    },
+  };
+}

src/NetscriptFunctions/Hacknet.ts

@@ -0,0 +1,213 @@
+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";
+import { AllServers } from "../Server/AllServers";
+
+export interface INetscriptHacknet {
+  numNodes(): number;
+  maxNumNodes(): number;
+  purchaseNode(): any;
+  getPurchaseNodeCost(): number;
+  getNodeStats(i: number): any;
+  upgradeLevel(i: number, n: number): boolean;
+  upgradeRam(i: number, n: number): boolean;
+  upgradeCore(i: number, n: number): boolean;
+  upgradeCache(i: number, n: number): boolean;
+  getLevelUpgradeCost(i: number, n: number): number;
+  getRamUpgradeCost(i: number, n: number): number;
+  getCoreUpgradeCost(i: number, n: number): number;
+  getCacheUpgradeCost(i: number, n: number): number;
+  numHashes(): number;
+  hashCapacity(): number;
+  hashCost(upgName: string): number;
+  spendHashes(upgName: string, upgTarget: string): any;
+  getHashUpgradeLevel(upgName: string): number;
+  getStudyMult(): number;
+  getTrainingMult(): number;
+}
+
+export function NetscriptHacknet(
+  player: IPlayer,
+  workerScript: WorkerScript,
+  helper: INetscriptHelper,
+): INetscriptHacknet {
+  // Utility function to get Hacknet Node object
+  const getHacknetNode = function (i: any, callingFn = ""): HacknetNode | HacknetServer {
+    if (isNaN(i)) {
+      throw helper.makeRuntimeErrorMsg(callingFn, "Invalid index specified for Hacknet Node: " + i);
+    }
+    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");
+      const hserver = AllServers[hi];
+      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 {
+    numNodes: function (): any {
+      return player.hacknetNodes.length;
+    },
+    maxNumNodes: function (): any {
+      if (hasHacknetServers(player)) {
+        return HacknetServerConstants.MaxServers;
+      }
+      return Infinity;
+    },
+    purchaseNode: function (): any {
+      return purchaseHacknet(player);
+    },
+    getPurchaseNodeCost: function (): any {
+      if (hasHacknetServers(player)) {
+        return getCostOfNextHacknetServer(player);
+      } else {
+        return getCostOfNextHacknetNode(player);
+      }
+    },
+    getNodeStats: function (i: any): any {
+      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,
+        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;
+    },
+    upgradeLevel: function (i: any, n: any): any {
+      const node = getHacknetNode(i, "upgradeLevel");
+      return purchaseLevelUpgrade(player, node, n);
+    },
+    upgradeRam: function (i: any, n: any): any {
+      const node = getHacknetNode(i, "upgradeRam");
+      return purchaseRamUpgrade(player, node, n);
+    },
+    upgradeCore: function (i: any, n: any): any {
+      const node = getHacknetNode(i, "upgradeCore");
+      return purchaseCoreUpgrade(player, node, n);
+    },
+    upgradeCache: function (i: any, n: any): any {
+      if (!hasHacknetServers(player)) {
+        return false;
+      }
+      const node = getHacknetNode(i, "upgradeCache");
+      if (!(node instanceof HacknetServer)) {
+        workerScript.log("upgradeCache", "Can only be called on hacknet servers");
+        return false;
+      }
+      const res = purchaseCacheUpgrade(player, node, n);
+      if (res) {
+        updateHashManagerCapacity(player);
+      }
+      return res;
+    },
+    getLevelUpgradeCost: function (i: any, n: any): any {
+      const node = getHacknetNode(i, "upgradeLevel");
+      return node.calculateLevelUpgradeCost(n, player.hacknet_node_level_cost_mult);
+    },
+    getRamUpgradeCost: function (i: any, n: any): any {
+      const node = getHacknetNode(i, "upgradeRam");
+      return node.calculateRamUpgradeCost(n, player.hacknet_node_ram_cost_mult);
+    },
+    getCoreUpgradeCost: function (i: any, n: any): any {
+      const node = getHacknetNode(i, "upgradeCore");
+      return node.calculateCoreUpgradeCost(n, player.hacknet_node_core_cost_mult);
+    },
+    getCacheUpgradeCost: function (i: any, n: any): any {
+      if (!hasHacknetServers(player)) {
+        return Infinity;
+      }
+      const node = getHacknetNode(i, "upgradeCache");
+      if (!(node instanceof HacknetServer)) {
+        workerScript.log("getCacheUpgradeCost", "Can only be called on hacknet servers");
+        return -1;
+      }
+      return node.calculateCacheUpgradeCost(n);
+    },
+    numHashes: function (): any {
+      if (!hasHacknetServers(player)) {
+        return 0;
+      }
+      return player.hashManager.hashes;
+    },
+    hashCapacity: function (): any {
+      if (!hasHacknetServers(player)) {
+        return 0;
+      }
+      return player.hashManager.capacity;
+    },
+    hashCost: function (upgName: any): any {
+      if (!hasHacknetServers(player)) {
+        return Infinity;
+      }
+
+      return player.hashManager.getUpgradeCost(upgName);
+    },
+    spendHashes: function (upgName: any, upgTarget: any): any {
+      if (!hasHacknetServers(player)) {
+        return false;
+      }
+      return purchaseHashUpgrade(player, upgName, upgTarget);
+    },
+    getHashUpgradeLevel: function (upgName: any): any {
+      const level = player.hashManager.upgrades[upgName];
+      if (level === undefined) {
+        throw helper.makeRuntimeErrorMsg("hacknet.hashUpgradeLevel", `Invalid Hash Upgrade: ${upgName}`);
+      }
+      return level;
+    },
+    getStudyMult: function (): any {
+      if (!hasHacknetServers(player)) {
+        return false;
+      }
+      return player.hashManager.getStudyMult();
+    },
+    getTrainingMult: function (): any {
+      if (!hasHacknetServers(player)) {
+        return false;
+      }
+      return player.hashManager.getTrainingMult();
+    },
+  };
+}

src/NetscriptFunctions/INetscriptHelper.ts

@@ -0,0 +1,7 @@
+export interface INetscriptHelper {
+  updateDynamicRam(functionName: string, ram: number): void;
+  makeRuntimeErrorMsg(functionName: string, message: string): void;
+  string(funcName: string, argName: string, v: any): string;
+  number(funcName: string, argName: string, v: any): number;
+  boolean(v: any): boolean;
+}

src/NetscriptFunctions/Sleeve.ts

@@ -0,0 +1,333 @@
+import { INetscriptHelper } from "./INetscriptHelper";
+import { IPlayer } from "../PersonObjects/IPlayer";
+import { getRamCost } from "../Netscript/RamCostGenerator";
+import { FactionWorkType } from "../Faction/FactionWorkTypeEnum";
+import { SourceFileFlags } from "../SourceFile/SourceFileFlags";
+import { SleeveTaskType } from "../PersonObjects/Sleeve/SleeveTaskTypesEnum";
+import { SpecialServerIps } from "../Server/SpecialServerIps";
+import { WorkerScript } from "../Netscript/WorkerScript";
+import { findSleevePurchasableAugs } from "../PersonObjects/Sleeve/SleeveHelpers";
+import { Augmentations } from "../Augmentation/Augmentations";
+import { CityName } from "../Locations/data/CityNames";
+
+export interface INetscriptSleeve {
+  getNumSleeves(): number;
+  setToShockRecovery(sleeveNumber?: number): boolean;
+  setToSynchronize(sleeveNumber?: number): boolean;
+  setToCommitCrime(sleeveNumber?: number, crimeName?: string): boolean;
+  setToUniversityCourse(sleeveNumber?: number, universityName?: string, className?: string): boolean;
+  travel(sleeveNumber?: number, cityName?: string): boolean;
+  setToCompanyWork(sleeveNumber?: number, companyName?: string): boolean;
+  setToFactionWork(sleeveNumber?: number, factionName?: string, workType?: string): boolean;
+  setToGymWorkout(sleeveNumber?: number, gymName?: string, stat?: string): boolean;
+  getSleeveStats(sleeveNumber?: number): {
+    shock: number;
+    sync: number;
+    hacking_skill: number;
+    strength: number;
+    defense: number;
+    dexterity: number;
+    agility: number;
+    charisma: number;
+  };
+  getTask(sleeveNumber?: number): {
+    task: string;
+    crime: string;
+    location: string;
+    gymStatType: string;
+    factionWorkType: string;
+  };
+  getInformation(sleeveNumber?: number): any;
+  getSleeveAugmentations(sleeveNumber?: number): string[];
+  getSleevePurchasableAugs(sleeveNumber?: number): {
+    name: string;
+    cost: number;
+  }[];
+  purchaseSleeveAug(sleeveNumber?: number, augName?: string): boolean;
+}
+
+export function NetscriptSleeve(
+  player: IPlayer,
+  workerScript: WorkerScript,
+  helper: INetscriptHelper,
+): INetscriptSleeve {
+  const checkSleeveAPIAccess = function (func: any): void {
+    if (player.bitNodeN !== 10 && !SourceFileFlags[10]) {
+      throw helper.makeRuntimeErrorMsg(
+        `sleeve.${func}`,
+        "You do not currently have access to the Sleeve API. This is either because you are not in BitNode-10 or because you do not have Source-File 10",
+      );
+    }
+  };
+
+  const checkSleeveNumber = function (func: any, sleeveNumber: any): void {
+    if (sleeveNumber >= player.sleeves.length || sleeveNumber < 0) {
+      const msg = `Invalid sleeve number: ${sleeveNumber}`;
+      workerScript.log(func, msg);
+      throw helper.makeRuntimeErrorMsg(`sleeve.${func}`, msg);
+    }
+  };
+
+  return {
+    getNumSleeves: function (): number {
+      helper.updateDynamicRam("getNumSleeves", getRamCost("sleeve", "getNumSleeves"));
+      checkSleeveAPIAccess("getNumSleeves");
+      return player.sleeves.length;
+    },
+    setToShockRecovery: function (asleeveNumber: any = 0): boolean {
+      const sleeveNumber = helper.number("setToShockRecovery", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("setToShockRecovery", getRamCost("sleeve", "setToShockRecovery"));
+      checkSleeveAPIAccess("setToShockRecovery");
+      checkSleeveNumber("setToShockRecovery", sleeveNumber);
+      return player.sleeves[sleeveNumber].shockRecovery(player);
+    },
+    setToSynchronize: function (asleeveNumber: any = 0): boolean {
+      const sleeveNumber = helper.number("setToSynchronize", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("setToSynchronize", getRamCost("sleeve", "setToSynchronize"));
+      checkSleeveAPIAccess("setToSynchronize");
+      checkSleeveNumber("setToSynchronize", sleeveNumber);
+      return player.sleeves[sleeveNumber].synchronize(player);
+    },
+    setToCommitCrime: function (asleeveNumber: any = 0, acrimeName: any = ""): boolean {
+      const sleeveNumber = helper.number("setToCommitCrime", "sleeveNumber", asleeveNumber);
+      const crimeName = helper.string("setToUniversityCourse", "crimeName", acrimeName);
+      helper.updateDynamicRam("setToCommitCrime", getRamCost("sleeve", "setToCommitCrime"));
+      checkSleeveAPIAccess("setToCommitCrime");
+      checkSleeveNumber("setToCommitCrime", sleeveNumber);
+      return player.sleeves[sleeveNumber].commitCrime(player, crimeName);
+    },
+    setToUniversityCourse: function (asleeveNumber: any = 0, auniversityName: any = "", aclassName: any = ""): boolean {
+      const sleeveNumber = helper.number("setToUniversityCourse", "sleeveNumber", asleeveNumber);
+      const universityName = helper.string("setToUniversityCourse", "universityName", auniversityName);
+      const className = helper.string("setToUniversityCourse", "className", aclassName);
+      helper.updateDynamicRam("setToUniversityCourse", getRamCost("sleeve", "setToUniversityCourse"));
+      checkSleeveAPIAccess("setToUniversityCourse");
+      checkSleeveNumber("setToUniversityCourse", sleeveNumber);
+      return player.sleeves[sleeveNumber].takeUniversityCourse(player, universityName, className);
+    },
+    travel: function (asleeveNumber: any = 0, acityName: any = ""): boolean {
+      const sleeveNumber = helper.number("travel", "sleeveNumber", asleeveNumber);
+      const cityName = helper.string("setToUniversityCourse", "cityName", acityName);
+      helper.updateDynamicRam("travel", getRamCost("sleeve", "travel"));
+      checkSleeveAPIAccess("travel");
+      checkSleeveNumber("travel", sleeveNumber);
+      return player.sleeves[sleeveNumber].travel(player, cityName as CityName);
+    },
+    setToCompanyWork: function (asleeveNumber: any = 0, acompanyName: any = ""): boolean {
+      const sleeveNumber = helper.number("setToCompanyWork", "sleeveNumber", asleeveNumber);
+      const companyName = helper.string("setToUniversityCourse", "companyName", acompanyName);
+      helper.updateDynamicRam("setToCompanyWork", getRamCost("sleeve", "setToCompanyWork"));
+      checkSleeveAPIAccess("setToCompanyWork");
+      checkSleeveNumber("setToCompanyWork", sleeveNumber);
+
+      // Cannot work at the same company that another sleeve is working at
+      for (let i = 0; i < player.sleeves.length; ++i) {
+        if (i === sleeveNumber) {
+          continue;
+        }
+        const other = player.sleeves[i];
+        if (other.currentTask === SleeveTaskType.Company && other.currentTaskLocation === companyName) {
+          throw helper.makeRuntimeErrorMsg(
+            "sleeve.setToFactionWork",
+            `Sleeve ${sleeveNumber} cannot work for company ${companyName} because Sleeve ${i} is already working for them.`,
+          );
+        }
+      }
+
+      return player.sleeves[sleeveNumber].workForCompany(player, companyName);
+    },
+    setToFactionWork: function (asleeveNumber: any = 0, afactionName: any = "", aworkType: any = ""): boolean {
+      const sleeveNumber = helper.number("setToFactionWork", "sleeveNumber", asleeveNumber);
+      const factionName = helper.string("setToUniversityCourse", "factionName", afactionName);
+      const workType = helper.string("setToUniversityCourse", "workType", aworkType);
+      helper.updateDynamicRam("setToFactionWork", getRamCost("sleeve", "setToFactionWork"));
+      checkSleeveAPIAccess("setToFactionWork");
+      checkSleeveNumber("setToFactionWork", sleeveNumber);
+
+      // Cannot work at the same faction that another sleeve is working at
+      for (let i = 0; i < player.sleeves.length; ++i) {
+        if (i === sleeveNumber) {
+          continue;
+        }
+        const other = player.sleeves[i];
+        if (other.currentTask === SleeveTaskType.Faction && other.currentTaskLocation === factionName) {
+          throw helper.makeRuntimeErrorMsg(
+            "sleeve.setToFactionWork",
+            `Sleeve ${sleeveNumber} cannot work for faction ${factionName} because Sleeve ${i} is already working for them.`,
+          );
+        }
+      }
+
+      return player.sleeves[sleeveNumber].workForFaction(player, factionName, workType);
+    },
+    setToGymWorkout: function (asleeveNumber: any = 0, agymName: any = "", astat: any = ""): boolean {
+      const sleeveNumber = helper.number("setToGymWorkout", "sleeveNumber", asleeveNumber);
+      const gymName = helper.string("setToUniversityCourse", "gymName", agymName);
+      const stat = helper.string("setToUniversityCourse", "stat", astat);
+      helper.updateDynamicRam("setToGymWorkout", getRamCost("sleeve", "setToGymWorkout"));
+      checkSleeveAPIAccess("setToGymWorkout");
+      checkSleeveNumber("setToGymWorkout", sleeveNumber);
+
+      return player.sleeves[sleeveNumber].workoutAtGym(player, gymName, stat);
+    },
+    getSleeveStats: function (asleeveNumber: any = 0): {
+      shock: number;
+      sync: number;
+      hacking_skill: number;
+      strength: number;
+      defense: number;
+      dexterity: number;
+      agility: number;
+      charisma: number;
+    } {
+      const sleeveNumber = helper.number("getSleeveStats", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("getSleeveStats", getRamCost("sleeve", "getSleeveStats"));
+      checkSleeveAPIAccess("getSleeveStats");
+      checkSleeveNumber("getSleeveStats", sleeveNumber);
+
+      const sl = player.sleeves[sleeveNumber];
+      return {
+        shock: 100 - sl.shock,
+        sync: sl.sync,
+        hacking_skill: sl.hacking_skill,
+        strength: sl.strength,
+        defense: sl.defense,
+        dexterity: sl.dexterity,
+        agility: sl.agility,
+        charisma: sl.charisma,
+      };
+    },
+    getTask: function (asleeveNumber: any = 0): {
+      task: string;
+      crime: string;
+      location: string;
+      gymStatType: string;
+      factionWorkType: string;
+    } {
+      const sleeveNumber = helper.number("getTask", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("getTask", getRamCost("sleeve", "getTask"));
+      checkSleeveAPIAccess("getTask");
+      checkSleeveNumber("getTask", sleeveNumber);
+
+      const sl = player.sleeves[sleeveNumber];
+      return {
+        task: SleeveTaskType[sl.currentTask],
+        crime: sl.crimeType,
+        location: sl.currentTaskLocation,
+        gymStatType: sl.gymStatType,
+        factionWorkType: FactionWorkType[sl.factionWorkType],
+      };
+    },
+    getInformation: function (asleeveNumber: any = 0): any {
+      const sleeveNumber = helper.number("getInformation", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("getInformation", getRamCost("sleeve", "getInformation"));
+      checkSleeveAPIAccess("getInformation");
+      checkSleeveNumber("getInformation", sleeveNumber);
+
+      const sl = player.sleeves[sleeveNumber];
+      return {
+        city: sl.city,
+        hp: sl.hp,
+        jobs: Object.keys(player.jobs), // technically sleeves have the same jobs as the player.
+        jobTitle: Object.values(player.jobs),
+        maxHp: sl.max_hp,
+        tor: SpecialServerIps.hasOwnProperty("Darkweb Server"), // There's no reason not to give that infomation here as well. Worst case scenario it isn't used.
+
+        mult: {
+          agility: sl.agility_mult,
+          agilityExp: sl.agility_exp_mult,
+          companyRep: sl.company_rep_mult,
+          crimeMoney: sl.crime_money_mult,
+          crimeSuccess: sl.crime_success_mult,
+          defense: sl.defense_mult,
+          defenseExp: sl.defense_exp_mult,
+          dexterity: sl.dexterity_mult,
+          dexterityExp: sl.dexterity_exp_mult,
+          factionRep: sl.faction_rep_mult,
+          hacking: sl.hacking_mult,
+          hackingExp: sl.hacking_exp_mult,
+          strength: sl.strength_mult,
+          strengthExp: sl.strength_exp_mult,
+          workMoney: sl.work_money_mult,
+        },
+
+        timeWorked: sl.currentTaskTime,
+        earningsForSleeves: {
+          workHackExpGain: sl.earningsForSleeves.hack,
+          workStrExpGain: sl.earningsForSleeves.str,
+          workDefExpGain: sl.earningsForSleeves.def,
+          workDexExpGain: sl.earningsForSleeves.dex,
+          workAgiExpGain: sl.earningsForSleeves.agi,
+          workChaExpGain: sl.earningsForSleeves.cha,
+          workMoneyGain: sl.earningsForSleeves.money,
+        },
+        earningsForPlayer: {
+          workHackExpGain: sl.earningsForPlayer.hack,
+          workStrExpGain: sl.earningsForPlayer.str,
+          workDefExpGain: sl.earningsForPlayer.def,
+          workDexExpGain: sl.earningsForPlayer.dex,
+          workAgiExpGain: sl.earningsForPlayer.agi,
+          workChaExpGain: sl.earningsForPlayer.cha,
+          workMoneyGain: sl.earningsForPlayer.money,
+        },
+        earningsForTask: {
+          workHackExpGain: sl.earningsForTask.hack,
+          workStrExpGain: sl.earningsForTask.str,
+          workDefExpGain: sl.earningsForTask.def,
+          workDexExpGain: sl.earningsForTask.dex,
+          workAgiExpGain: sl.earningsForTask.agi,
+          workChaExpGain: sl.earningsForTask.cha,
+          workMoneyGain: sl.earningsForTask.money,
+        },
+        workRepGain: sl.getRepGain(player),
+      };
+    },
+    getSleeveAugmentations: function (asleeveNumber: any = 0): string[] {
+      const sleeveNumber = helper.number("getSleeveAugmentations", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("getSleeveAugmentations", getRamCost("sleeve", "getSleeveAugmentations"));
+      checkSleeveAPIAccess("getSleeveAugmentations");
+      checkSleeveNumber("getSleeveAugmentations", sleeveNumber);
+
+      const augs = [];
+      for (let i = 0; i < player.sleeves[sleeveNumber].augmentations.length; i++) {
+        augs.push(player.sleeves[sleeveNumber].augmentations[i].name);
+      }
+      return augs;
+    },
+    getSleevePurchasableAugs: function (asleeveNumber: any = 0): {
+      name: string;
+      cost: number;
+    }[] {
+      const sleeveNumber = helper.number("getSleevePurchasableAugs", "sleeveNumber", asleeveNumber);
+      helper.updateDynamicRam("getSleevePurchasableAugs", getRamCost("sleeve", "getSleevePurchasableAugs"));
+      checkSleeveAPIAccess("getSleevePurchasableAugs");
+      checkSleeveNumber("getSleevePurchasableAugs", sleeveNumber);
+
+      const purchasableAugs = findSleevePurchasableAugs(player.sleeves[sleeveNumber], player);
+      const augs = [];
+      for (let i = 0; i < purchasableAugs.length; i++) {
+        const aug = purchasableAugs[i];
+        augs.push({
+          name: aug.name,
+          cost: aug.startingCost,
+        });
+      }
+
+      return augs;
+    },
+    purchaseSleeveAug: function (asleeveNumber: any = 0, aaugName: any = ""): boolean {
+      const sleeveNumber = helper.number("purchaseSleeveAug", "sleeveNumber", asleeveNumber);
+      const augName = helper.string("setToUniversityCourse", "augName", aaugName);
+      helper.updateDynamicRam("purchaseSleeveAug", getRamCost("sleeve", "purchaseSleeveAug"));
+      checkSleeveAPIAccess("purchaseSleeveAug");
+      checkSleeveNumber("purchaseSleeveAug", sleeveNumber);
+
+      const aug = Augmentations[augName];
+      if (!aug) {
+        throw helper.makeRuntimeErrorMsg("sleeve.purchaseSleeveAug", `Invalid aug: ${augName}`);
+      }
+
+      return player.sleeves[sleeveNumber].tryBuyAugmentation(player, aug);
+    },
+  };
+}

src/NetscriptFunctions/Stanek.ts

@@ -0,0 +1,84 @@
+import { INetscriptHelper } from "./INetscriptHelper";
+import { IPlayer } from "../PersonObjects/IPlayer";
+import { WorkerScript } from "../Netscript/WorkerScript";
+import { netscriptDelay } from "../NetscriptEvaluator";
+import { getRamCost } from "../Netscript/RamCostGenerator";
+
+import { staneksGift } from "../CotMG/Helper";
+import { Fragments, FragmentById } from "../CotMG/Fragment";
+
+export interface INetscriptStanek {
+  charge(worldX: any, worldY: any): any;
+  fragmentDefinitions(): any;
+  placedFragments(): any;
+  clear(): any;
+  canPlace(worldX: any, worldY: any, fragmentId: any): any;
+  place(worldX: any, worldY: any, fragmentId: any): any;
+  fragmentAt(worldX: any, worldY: any): any;
+  deleteAt(worldX: any, worldY: any): any;
+}
+
+export function NetscriptStanek(
+  player: IPlayer,
+  workerScript: WorkerScript,
+  helper: INetscriptHelper,
+): INetscriptStanek {
+  return {
+    charge: function (worldX: any, worldY: any): any {
+      helper.updateDynamicRam("charge", getRamCost("stanek", "charge"));
+      //checkStanekAPIAccess("charge");
+      const fragment = staneksGift.fragmentAt(worldX, worldY);
+      if (!fragment) throw helper.makeRuntimeErrorMsg("stanek.charge", `No fragment at (${worldX}, ${worldY})`);
+      return netscriptDelay(1000, workerScript).then(function () {
+        if (workerScript.env.stopFlag) {
+          return Promise.reject(workerScript);
+        }
+        const ram = workerScript.scriptRef.ramUsage * workerScript.scriptRef.threads;
+        return Promise.resolve(staneksGift.charge(worldX, worldY, ram));
+      });
+    },
+    fragmentDefinitions: function () {
+      helper.updateDynamicRam("fragmentDefinitions", getRamCost("stanek", "fragmentDefinitions"));
+      //checkStanekAPIAccess("fragmentDefinitions");
+      return Fragments.map((f) => f.copy());
+    },
+    placedFragments: function () {
+      helper.updateDynamicRam("placedFragments", getRamCost("stanek", "placedFragments"));
+      //checkStanekAPIAccess("placedFragments");
+      return staneksGift.fragments.map((af) => {
+        return { ...af.copy(), ...af.fragment().copy() };
+      });
+    },
+    clear: function () {
+      helper.updateDynamicRam("clear", getRamCost("stanek", "clear"));
+      //checkStanekAPIAccess("clear");
+      staneksGift.clear();
+    },
+    canPlace: function (worldX: any, worldY: any, fragmentId: any): any {
+      helper.updateDynamicRam("canPlace", getRamCost("stanek", "canPlace"));
+      //checkStanekAPIAccess("canPlace");
+      const fragment = FragmentById(fragmentId);
+      if (!fragment) throw helper.makeRuntimeErrorMsg("stanek.canPlace", `Invalid fragment id: ${fragmentId}`);
+      return staneksGift.canPlace(worldX, worldY, fragment);
+    },
+    place: function (worldX: any, worldY: any, fragmentId: any): any {
+      helper.updateDynamicRam("place", getRamCost("stanek", "place"));
+      //checkStanekAPIAccess("place");
+      const fragment = FragmentById(fragmentId);
+      if (!fragment) throw helper.makeRuntimeErrorMsg("stanek.place", `Invalid fragment id: ${fragmentId}`);
+      return staneksGift.place(worldX, worldY, fragment);
+    },
+    fragmentAt: function (worldX: any, worldY: any): any {
+      helper.updateDynamicRam("fragmentAt", getRamCost("stanek", "fragmentAt"));
+      //checkStanekAPIAccess("fragmentAt");
+      const fragment = staneksGift.fragmentAt(worldX, worldY);
+      if (fragment !== null) return fragment.copy();
+      return null;
+    },
+    deleteAt: function (worldX: any, worldY: any): any {
+      helper.updateDynamicRam("deleteAt", getRamCost("stanek", "deleteAt"));
+      //checkStanekAPIAccess("deleteAt");
+      return staneksGift.deleteAt(worldX, worldY);
+    },
+  };
+}