2021-10-14 09:22:02 +02:00
|
|
|
import { INetscriptHelper } from "./INetscriptHelper";
|
|
|
|
import { WorkerScript } from "../Netscript/WorkerScript";
|
|
|
|
import { IPlayer } from "../PersonObjects/IPlayer";
|
|
|
|
import { Bladeburner } from "../Bladeburner/Bladeburner";
|
|
|
|
import { getRamCost } from "../Netscript/RamCostGenerator";
|
|
|
|
import { BitNodeMultipliers } from "../BitNode/BitNodeMultipliers";
|
2021-11-04 01:19:52 +01:00
|
|
|
import { Bladeburner as INetscriptBladeburner, BladeburnerCurAction } from "../ScriptEditor/NetscriptDefinitions";
|
2022-03-30 02:44:27 +02:00
|
|
|
import { IAction } from "src/Bladeburner/IAction";
|
2021-10-14 09:22:02 +02:00
|
|
|
|
|
|
|
export function NetscriptBladeburner(
|
|
|
|
player: IPlayer,
|
|
|
|
workerScript: WorkerScript,
|
|
|
|
helper: INetscriptHelper,
|
|
|
|
): INetscriptBladeburner {
|
2022-03-30 02:44:27 +02:00
|
|
|
const checkBladeburnerAccess = function (func: string, skipjoined = false): void {
|
2021-10-14 09:22:02 +02:00
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Must have joined bladeburner");
|
|
|
|
const apiAccess =
|
|
|
|
player.bitNodeN === 7 ||
|
|
|
|
player.sourceFiles.some((a) => {
|
|
|
|
return a.n === 7;
|
|
|
|
});
|
|
|
|
if (!apiAccess) {
|
|
|
|
const apiDenied = `You do not currently have access to the Bladeburner API. You must either be in BitNode-7 or have Source-File 7.`;
|
|
|
|
throw helper.makeRuntimeErrorMsg(`bladeburner.${func}`, apiDenied);
|
|
|
|
}
|
|
|
|
if (!skipjoined) {
|
|
|
|
const bladeburnerAccess = bladeburner instanceof Bladeburner;
|
|
|
|
if (!bladeburnerAccess) {
|
|
|
|
const bladeburnerDenied = `You must be a member of the Bladeburner division to use this API.`;
|
|
|
|
throw helper.makeRuntimeErrorMsg(`bladeburner.${func}`, bladeburnerDenied);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-03-30 02:44:27 +02:00
|
|
|
const checkBladeburnerCity = function (func: string, city: string): void {
|
2021-10-14 09:22:02 +02:00
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Must have joined bladeburner");
|
|
|
|
if (!bladeburner.cities.hasOwnProperty(city)) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(`bladeburner.${func}`, `Invalid city: ${city}`);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-03-30 02:44:27 +02:00
|
|
|
const getBladeburnerActionObject = function (func: string, type: string, name: string): IAction {
|
2021-10-14 09:22:02 +02:00
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Must have joined bladeburner");
|
|
|
|
const actionId = bladeburner.getActionIdFromTypeAndName(type, name);
|
|
|
|
if (!actionId) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(`bladeburner.${func}`, `Invalid action type='${type}', name='${name}'`);
|
|
|
|
}
|
|
|
|
const actionObj = bladeburner.getActionObject(actionId);
|
|
|
|
if (!actionObj) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(`bladeburner.${func}`, `Invalid action type='${type}', name='${name}'`);
|
|
|
|
}
|
|
|
|
|
|
|
|
return actionObj;
|
|
|
|
};
|
|
|
|
|
|
|
|
return {
|
2021-11-04 01:19:52 +01:00
|
|
|
getContractNames: function (): string[] {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getContractNames", getRamCost(player, "bladeburner", "getContractNames"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getContractNames");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.getContractNamesNetscriptFn();
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getOperationNames: function (): string[] {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getOperationNames", getRamCost(player, "bladeburner", "getOperationNames"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getOperationNames");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.getOperationNamesNetscriptFn();
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getBlackOpNames: function (): string[] {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getBlackOpNames", getRamCost(player, "bladeburner", "getBlackOpNames"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getBlackOpNames");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.getBlackOpNamesNetscriptFn();
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getBlackOpRank: function (_blackOpName: unknown): number {
|
|
|
|
const blackOpName = helper.string("getBlackOpRank", "blackOpName", _blackOpName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getBlackOpRank", getRamCost(player, "bladeburner", "getBlackOpRank"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getBlackOpRank");
|
2022-03-30 02:44:27 +02:00
|
|
|
const action: any = getBladeburnerActionObject("getBlackOpRank", "blackops", blackOpName);
|
2021-10-14 09:22:02 +02:00
|
|
|
return action.reqdRank;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getGeneralActionNames: function (): string[] {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getGeneralActionNames", getRamCost(player, "bladeburner", "getGeneralActionNames"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getGeneralActionNames");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.getGeneralActionNamesNetscriptFn();
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getSkillNames: function (): string[] {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getSkillNames", getRamCost(player, "bladeburner", "getSkillNames"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getSkillNames");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.getSkillNamesNetscriptFn();
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
startAction: function (_type: unknown, _name: unknown): boolean {
|
|
|
|
const type = helper.string("startAction", "type", _type);
|
|
|
|
const name = helper.string("startAction", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("startAction", getRamCost(player, "bladeburner", "startAction"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("startAction");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.startActionNetscriptFn(player, type, name, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.startAction", e);
|
|
|
|
}
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
stopBladeburnerAction: function (): void {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("stopBladeburnerAction", getRamCost(player, "bladeburner", "stopBladeburnerAction"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("stopBladeburnerAction");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.resetAction();
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getCurrentAction: function (): BladeburnerCurAction {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getCurrentAction", getRamCost(player, "bladeburner", "getCurrentAction"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getCurrentAction");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.getTypeAndNameFromActionId(bladeburner.action);
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionTime: function (_type: unknown, _name: unknown): number {
|
|
|
|
const type = helper.string("getActionTime", "type", _type);
|
|
|
|
const name = helper.string("getActionTime", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getActionTime", getRamCost(player, "bladeburner", "getActionTime"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getActionTime");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.getActionTimeNetscriptFn(player, type, name, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.getActionTime", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionEstimatedSuccessChance: function (_type: unknown, _name: unknown): [number, number] {
|
|
|
|
const type = helper.string("getActionEstimatedSuccessChance", "type", _type);
|
|
|
|
const name = helper.string("getActionEstimatedSuccessChance", "name", _name);
|
2021-10-14 09:22:02 +02:00
|
|
|
helper.updateDynamicRam(
|
|
|
|
"getActionEstimatedSuccessChance",
|
2022-01-05 01:09:34 +01:00
|
|
|
getRamCost(player, "bladeburner", "getActionEstimatedSuccessChance"),
|
2021-10-14 09:22:02 +02:00
|
|
|
);
|
|
|
|
checkBladeburnerAccess("getActionEstimatedSuccessChance");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.getActionEstimatedSuccessChanceNetscriptFn(player, type, name, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.getActionEstimatedSuccessChance", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionRepGain: function (_type: unknown, _name: unknown, _level: unknown): number {
|
|
|
|
const type = helper.string("getActionRepGain", "type", _type);
|
|
|
|
const name = helper.string("getActionRepGain", "name", _name);
|
|
|
|
const level = helper.number("getActionRepGain", "level", _level);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getActionRepGain", getRamCost(player, "bladeburner", "getActionRepGain"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getActionRepGain");
|
|
|
|
const action = getBladeburnerActionObject("getActionRepGain", type, name);
|
|
|
|
let rewardMultiplier;
|
|
|
|
if (level == null || isNaN(level)) {
|
|
|
|
rewardMultiplier = Math.pow(action.rewardFac, action.level - 1);
|
|
|
|
} else {
|
|
|
|
rewardMultiplier = Math.pow(action.rewardFac, level - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return action.rankGain * rewardMultiplier * BitNodeMultipliers.BladeburnerRank;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionCountRemaining: function (_type: unknown, _name: unknown): number {
|
|
|
|
const type = helper.string("getActionCountRemaining", "type", _type);
|
|
|
|
const name = helper.string("getActionCountRemaining", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getActionCountRemaining", getRamCost(player, "bladeburner", "getActionCountRemaining"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getActionCountRemaining");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.getActionCountRemainingNetscriptFn(type, name, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.getActionCountRemaining", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionMaxLevel: function (_type: unknown, _name: unknown): number {
|
|
|
|
const type = helper.string("getActionMaxLevel", "type", _type);
|
|
|
|
const name = helper.string("getActionMaxLevel", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getActionMaxLevel", getRamCost(player, "bladeburner", "getActionMaxLevel"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getActionMaxLevel");
|
|
|
|
const action = getBladeburnerActionObject("getActionMaxLevel", type, name);
|
|
|
|
return action.maxLevel;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionCurrentLevel: function (_type: unknown, _name: unknown): number {
|
|
|
|
const type = helper.string("getActionCurrentLevel", "type", _type);
|
|
|
|
const name = helper.string("getActionCurrentLevel", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getActionCurrentLevel", getRamCost(player, "bladeburner", "getActionCurrentLevel"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getActionCurrentLevel");
|
|
|
|
const action = getBladeburnerActionObject("getActionCurrentLevel", type, name);
|
|
|
|
return action.level;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getActionAutolevel: function (_type: unknown, _name: unknown): boolean {
|
|
|
|
const type = helper.string("getActionAutolevel", "type", _type);
|
|
|
|
const name = helper.string("getActionAutolevel", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getActionAutolevel", getRamCost(player, "bladeburner", "getActionAutolevel"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getActionAutolevel");
|
|
|
|
const action = getBladeburnerActionObject("getActionCurrentLevel", type, name);
|
|
|
|
return action.autoLevel;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
setActionAutolevel: function (_type: unknown, _name: unknown, _autoLevel: unknown = true): void {
|
|
|
|
const type = helper.string("setActionAutolevel", "type", _type);
|
|
|
|
const name = helper.string("setActionAutolevel", "name", _name);
|
|
|
|
const autoLevel = helper.boolean(_autoLevel);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("setActionAutolevel", getRamCost(player, "bladeburner", "setActionAutolevel"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("setActionAutolevel");
|
|
|
|
const action = getBladeburnerActionObject("setActionAutolevel", type, name);
|
|
|
|
action.autoLevel = autoLevel;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
setActionLevel: function (_type: unknown, _name: unknown, _level: unknown = 1): void {
|
|
|
|
const type = helper.string("setActionLevel", "type", _type);
|
|
|
|
const name = helper.string("setActionLevel", "name", _name);
|
|
|
|
const level = helper.number("setActionLevel", "level", _level);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("setActionLevel", getRamCost(player, "bladeburner", "setActionLevel"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("setActionLevel");
|
|
|
|
const action = getBladeburnerActionObject("setActionLevel", type, name);
|
|
|
|
if (level < 1 || level > action.maxLevel) {
|
|
|
|
throw helper.makeRuntimeErrorMsg(
|
|
|
|
"bladeburner.setActionLevel",
|
|
|
|
`Level must be between 1 and ${action.maxLevel}, is ${level}`,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
action.level = level;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getRank: function (): number {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getRank", getRamCost(player, "bladeburner", "getRank"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getRank");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.rank;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getSkillPoints: function (): number {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getSkillPoints", getRamCost(player, "bladeburner", "getSkillPoints"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getSkillPoints");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.skillPoints;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getSkillLevel: function (_skillName: unknown): number {
|
|
|
|
const skillName = helper.string("getSkillLevel", "skillName", _skillName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getSkillLevel", getRamCost(player, "bladeburner", "getSkillLevel"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getSkillLevel");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.getSkillLevelNetscriptFn(skillName, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.getSkillLevel", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getSkillUpgradeCost: function (_skillName: unknown): number {
|
|
|
|
const skillName = helper.string("getSkillUpgradeCost", "skillName", _skillName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getSkillUpgradeCost", getRamCost(player, "bladeburner", "getSkillUpgradeCost"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getSkillUpgradeCost");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.getSkillUpgradeCostNetscriptFn(skillName, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.getSkillUpgradeCost", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
upgradeSkill: function (_skillName: unknown): boolean {
|
|
|
|
const skillName = helper.string("upgradeSkill", "skillName", _skillName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("upgradeSkill", getRamCost(player, "bladeburner", "upgradeSkill"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("upgradeSkill");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.upgradeSkillNetscriptFn(skillName, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.upgradeSkill", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getTeamSize: function (_type: unknown, _name: unknown): number {
|
|
|
|
const type = helper.string("getTeamSize", "type", _type);
|
|
|
|
const name = helper.string("getTeamSize", "name", _name);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getTeamSize", getRamCost(player, "bladeburner", "getTeamSize"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getTeamSize");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.getTeamSizeNetscriptFn(type, name, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.getTeamSize", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
setTeamSize: function (_type: unknown, _name: unknown, _size: unknown): number {
|
|
|
|
const type = helper.string("setTeamSize", "type", _type);
|
|
|
|
const name = helper.string("setTeamSize", "name", _name);
|
|
|
|
const size = helper.number("setTeamSize", "size", _size);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("setTeamSize", getRamCost(player, "bladeburner", "setTeamSize"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("setTeamSize");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
try {
|
|
|
|
return bladeburner.setTeamSizeNetscriptFn(type, name, size, workerScript);
|
|
|
|
} catch (e: any) {
|
|
|
|
throw helper.makeRuntimeErrorMsg("bladeburner.setTeamSize", e);
|
|
|
|
}
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getCityEstimatedPopulation: function (_cityName: unknown): number {
|
|
|
|
const cityName = helper.string("getCityEstimatedPopulation", "cityName", _cityName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam(
|
|
|
|
"getCityEstimatedPopulation",
|
|
|
|
getRamCost(player, "bladeburner", "getCityEstimatedPopulation"),
|
|
|
|
);
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getCityEstimatedPopulation");
|
|
|
|
checkBladeburnerCity("getCityEstimatedPopulation", cityName);
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.cities[cityName].popEst;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getCityCommunities: function (_cityName: unknown): number {
|
|
|
|
const cityName = helper.string("getCityCommunities", "cityName", _cityName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getCityCommunities", getRamCost(player, "bladeburner", "getCityCommunities"));
|
2021-10-17 05:47:11 +02:00
|
|
|
checkBladeburnerAccess("getCityCommunities");
|
|
|
|
checkBladeburnerCity("getCityCommunities", cityName);
|
2021-10-14 09:22:02 +02:00
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
2021-10-15 23:26:26 +02:00
|
|
|
return bladeburner.cities[cityName].comms;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
getCityChaos: function (_cityName: unknown): number {
|
|
|
|
const cityName = helper.string("getCityChaos", "cityName", _cityName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getCityChaos", getRamCost(player, "bladeburner", "getCityChaos"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getCityChaos");
|
|
|
|
checkBladeburnerCity("getCityChaos", cityName);
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.cities[cityName].chaos;
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getCity: function (): string {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getCity", getRamCost(player, "bladeburner", "getCity"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getCityChaos");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.city;
|
|
|
|
},
|
2022-03-30 02:44:27 +02:00
|
|
|
switchCity: function (_cityName: unknown): boolean {
|
|
|
|
const cityName = helper.string("switchCity", "cityName", _cityName);
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("switchCity", getRamCost(player, "bladeburner", "switchCity"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("switchCity");
|
|
|
|
checkBladeburnerCity("switchCity", cityName);
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
2022-03-31 16:52:24 +02:00
|
|
|
bladeburner.city = cityName;
|
|
|
|
return true;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getStamina: function (): [number, number] {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getStamina", getRamCost(player, "bladeburner", "getStamina"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getStamina");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return [bladeburner.stamina, bladeburner.maxStamina];
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
joinBladeburnerFaction: function (): boolean {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("joinBladeburnerFaction", getRamCost(player, "bladeburner", "joinBladeburnerFaction"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("joinBladeburnerFaction", true);
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
|
|
|
return bladeburner.joinBladeburnerFactionNetscriptFn(workerScript);
|
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
joinBladeburnerDivision: function (): boolean {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("joinBladeburnerDivision", getRamCost(player, "bladeburner", "joinBladeburnerDivision"));
|
2021-10-14 09:22:02 +02:00
|
|
|
if (player.bitNodeN === 7 || player.sourceFileLvl(7) > 0) {
|
|
|
|
if (player.bitNodeN === 8) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (player.bladeburner instanceof Bladeburner) {
|
|
|
|
return true; // Already member
|
|
|
|
} else if (
|
|
|
|
player.strength >= 100 &&
|
|
|
|
player.defense >= 100 &&
|
|
|
|
player.dexterity >= 100 &&
|
|
|
|
player.agility >= 100
|
|
|
|
) {
|
|
|
|
player.bladeburner = new Bladeburner(player);
|
2021-11-27 00:30:58 +01:00
|
|
|
workerScript.log("joinBladeburnerDivision", () => "You have been accepted into the Bladeburner division");
|
2021-10-14 09:22:02 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
workerScript.log(
|
|
|
|
"joinBladeburnerDivision",
|
2021-11-27 00:30:58 +01:00
|
|
|
() => "You do not meet the requirements for joining the Bladeburner division",
|
2021-10-14 09:22:02 +02:00
|
|
|
);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2021-11-04 01:19:52 +01:00
|
|
|
return false;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2021-11-04 01:19:52 +01:00
|
|
|
getBonusTime: function (): number {
|
2022-01-05 01:09:34 +01:00
|
|
|
helper.updateDynamicRam("getBonusTime", getRamCost(player, "bladeburner", "getBonusTime"));
|
2021-10-14 09:22:02 +02:00
|
|
|
checkBladeburnerAccess("getBonusTime");
|
|
|
|
const bladeburner = player.bladeburner;
|
|
|
|
if (bladeburner === null) throw new Error("Should not be called without Bladeburner");
|
2022-03-30 02:44:27 +02:00
|
|
|
return Math.round(bladeburner.storedCycles / 5) * 1000;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
|
|
|
};
|
|
|
|
}
|