2023-06-12 06:34:20 +02:00
|
|
|
import type { Bladeburner as INetscriptBladeburner } from "@nsdefs";
|
2024-03-29 02:52:37 +01:00
|
|
|
import type { Action, LevelableAction } from "../Bladeburner/Types";
|
2023-06-12 06:34:20 +02:00
|
|
|
import type { InternalAPI, NetscriptContext } from "../Netscript/APIWrapper";
|
|
|
|
|
2022-10-10 00:42:14 +02:00
|
|
|
import { Player } from "@player";
|
2024-03-29 02:52:37 +01:00
|
|
|
import { BladeActionType, BladeContractName, BladeGeneralActionName, BladeOperationName, BladeSkillName } from "@enums";
|
2024-02-10 12:27:47 +01:00
|
|
|
import { Bladeburner, BladeburnerPromise } from "../Bladeburner/Bladeburner";
|
2023-06-16 23:52:42 +02:00
|
|
|
import { currentNodeMults } from "../BitNode/BitNodeMultipliers";
|
2022-08-08 19:43:41 +02:00
|
|
|
import { helpers } from "../Netscript/NetscriptHelpers";
|
2023-06-12 06:34:20 +02:00
|
|
|
import { getEnumHelper } from "../utils/EnumHelper";
|
2024-03-29 02:52:37 +01:00
|
|
|
import { Skills } from "../Bladeburner/data/Skills";
|
|
|
|
import { assertString } from "../Netscript/TypeAssertion";
|
|
|
|
import { BlackOperations, blackOpsArray } from "../Bladeburner/data/BlackOperations";
|
2021-10-14 09:22:02 +02:00
|
|
|
|
2022-08-09 21:41:47 +02:00
|
|
|
export function NetscriptBladeburner(): InternalAPI<INetscriptBladeburner> {
|
2022-09-06 15:07:12 +02:00
|
|
|
const checkBladeburnerAccess = function (ctx: NetscriptContext): void {
|
|
|
|
getBladeburner(ctx);
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
const getBladeburner = function (ctx: NetscriptContext): Bladeburner {
|
2023-04-18 09:19:45 +02:00
|
|
|
const apiAccess = Player.bitNodeN === 7 || Player.sourceFileLvl(7) > 0;
|
2021-10-14 09:22:02 +02:00
|
|
|
if (!apiAccess) {
|
2024-02-26 14:05:10 +01:00
|
|
|
throw helpers.errorMessage(ctx, "You have not unlocked the bladeburner API.", "API ACCESS");
|
2021-10-14 09:22:02 +02:00
|
|
|
}
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = Player.bladeburner;
|
|
|
|
if (!bladeburner)
|
2024-02-26 14:05:10 +01:00
|
|
|
throw helpers.errorMessage(ctx, "You must be a member of the Bladeburner division to use this API.");
|
2022-09-06 15:07:12 +02:00
|
|
|
return bladeburner;
|
2021-10-14 09:22:02 +02:00
|
|
|
};
|
|
|
|
|
2024-03-29 02:52:37 +01:00
|
|
|
function getAction(ctx: NetscriptContext, type: unknown, name: unknown): Action {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = Player.bladeburner;
|
2024-03-29 02:52:37 +01:00
|
|
|
assertString(ctx, "type", type);
|
|
|
|
assertString(ctx, "name", name);
|
2021-10-14 09:22:02 +02:00
|
|
|
if (bladeburner === null) throw new Error("Must have joined bladeburner");
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = bladeburner.getActionFromTypeAndName(type, name);
|
|
|
|
if (!action) throw helpers.errorMessage(ctx, `Invalid action type='${type}', name='${name}'`);
|
|
|
|
return action;
|
|
|
|
}
|
2021-10-14 09:22:02 +02:00
|
|
|
|
2024-03-29 02:52:37 +01:00
|
|
|
function isLevelableAction(action: Action): action is LevelableAction {
|
|
|
|
return action.type === BladeActionType.contract || action.type === BladeActionType.operation;
|
|
|
|
}
|
|
|
|
|
|
|
|
function getLevelableAction(ctx: NetscriptContext, type: unknown, name: unknown): LevelableAction {
|
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
if (!isLevelableAction(action)) {
|
|
|
|
throw helpers.errorMessage(
|
|
|
|
ctx,
|
|
|
|
`Actions of type ${action.type} are not levelable, ${ctx.functionPath} requires a levelable action`,
|
|
|
|
);
|
|
|
|
}
|
|
|
|
return action;
|
|
|
|
}
|
2021-10-14 09:22:02 +02:00
|
|
|
|
|
|
|
return {
|
2022-11-09 13:26:26 +01:00
|
|
|
inBladeburner: () => () => !!Player.bladeburner,
|
2022-10-12 14:49:27 +02:00
|
|
|
getContractNames: (ctx) => () => {
|
2024-03-29 02:52:37 +01:00
|
|
|
getBladeburner(ctx);
|
|
|
|
return Object.values(BladeContractName);
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getOperationNames: (ctx) => () => {
|
2024-03-29 02:52:37 +01:00
|
|
|
getBladeburner(ctx);
|
|
|
|
return Object.values(BladeOperationName);
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getBlackOpNames: (ctx) => () => {
|
2024-03-29 02:52:37 +01:00
|
|
|
getBladeburner(ctx);
|
|
|
|
// Ensures they are sent in the correct order
|
|
|
|
return blackOpsArray.map((blackOp) => blackOp.name);
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2023-10-17 08:18:54 +02:00
|
|
|
getNextBlackOp: (ctx) => () => {
|
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
if (bladeburner.numBlackOpsComplete >= blackOpsArray.length) return null;
|
|
|
|
const blackOp = blackOpsArray[bladeburner.numBlackOpsComplete];
|
|
|
|
return { name: blackOp.name, rank: blackOp.reqdRank };
|
2023-10-17 08:18:54 +02:00
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getBlackOpRank: (ctx) => (_blackOpName) => {
|
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const blackOpName = getEnumHelper("BladeBlackOpName").nsGetMember(ctx, _blackOpName);
|
|
|
|
return BlackOperations[blackOpName].reqdRank;
|
2022-10-12 14:49:27 +02:00
|
|
|
},
|
|
|
|
getGeneralActionNames: (ctx) => () => {
|
2024-03-29 02:52:37 +01:00
|
|
|
getBladeburner(ctx);
|
|
|
|
return Object.values(BladeGeneralActionName);
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getSkillNames: (ctx) => () => {
|
2024-03-29 02:52:37 +01:00
|
|
|
getBladeburner(ctx);
|
|
|
|
return Object.values(BladeSkillName);
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
startAction: (ctx) => (type, name) => {
|
2022-10-12 14:49:27 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
const attempt = bladeburner.startAction(action.id);
|
|
|
|
helpers.log(ctx, () => attempt.message);
|
|
|
|
return !!attempt.success;
|
2022-10-12 14:49:27 +02:00
|
|
|
},
|
|
|
|
stopBladeburnerAction: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
helpers.log(ctx, () => `Stopping current Bladeburner action.`);
|
2021-10-14 09:22:02 +02:00
|
|
|
return bladeburner.resetAction();
|
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getCurrentAction: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
// Temporary bad return type to not be an API break (idle should just return null)
|
|
|
|
if (!bladeburner.action) return { type: "Idle", name: "Idle" };
|
|
|
|
return { ...bladeburner.action };
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionTime: (ctx) => (type, name) => {
|
2022-10-12 14:49:27 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
// return ms instead of seconds
|
|
|
|
return action.getActionTime(bladeburner, Player) * 1000;
|
2022-10-12 14:49:27 +02:00
|
|
|
},
|
|
|
|
getActionCurrentTime: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2022-05-22 06:40:08 +02:00
|
|
|
try {
|
2022-05-22 06:40:32 +02:00
|
|
|
const timecomputed =
|
|
|
|
Math.min(bladeburner.actionTimeCurrent + bladeburner.actionTimeOverflow, bladeburner.actionTimeToComplete) *
|
|
|
|
1000;
|
2022-05-22 06:40:08 +02:00
|
|
|
return timecomputed;
|
2022-07-15 07:51:30 +02:00
|
|
|
} catch (e: unknown) {
|
2024-02-26 14:05:10 +01:00
|
|
|
throw helpers.errorMessage(ctx, String(e));
|
2022-05-22 06:40:08 +02:00
|
|
|
}
|
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionEstimatedSuccessChance: (ctx) => (type, name) => {
|
2023-01-02 19:28:31 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
return action.getSuccessRange(bladeburner, Player);
|
2022-10-12 14:49:27 +02:00
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionRepGain: (ctx) => (type, name, _level) => {
|
2023-01-02 19:28:31 +01:00
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
const level = isLevelableAction(action) ? helpers.number(ctx, "level", _level ?? action.level) : 1;
|
|
|
|
const rewardMultiplier = isLevelableAction(action) ? Math.pow(action.rewardFac, level - 1) : 1;
|
2023-06-16 23:52:42 +02:00
|
|
|
return action.rankGain * rewardMultiplier * currentNodeMults.BladeburnerRank;
|
2022-10-12 14:49:27 +02:00
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionCountRemaining: (ctx) => (type, name) => {
|
2023-01-02 19:28:31 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
switch (action.type) {
|
|
|
|
case BladeActionType.general:
|
|
|
|
return Infinity;
|
|
|
|
case BladeActionType.blackOp:
|
|
|
|
return bladeburner.numBlackOpsComplete > action.n ? 0 : 1;
|
|
|
|
case BladeActionType.contract:
|
|
|
|
case BladeActionType.operation:
|
|
|
|
return action.count;
|
2022-10-12 14:49:27 +02:00
|
|
|
}
|
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionMaxLevel: (ctx) => (type, name) => {
|
2022-10-12 14:49:27 +02:00
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getLevelableAction(ctx, type, name);
|
2022-10-12 14:49:27 +02:00
|
|
|
return action.maxLevel;
|
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionCurrentLevel: (ctx) => (type, name) => {
|
2022-10-12 14:49:27 +02:00
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getLevelableAction(ctx, type, name);
|
2022-10-12 14:49:27 +02:00
|
|
|
return action.level;
|
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionAutolevel: (ctx) => (type, name) => {
|
2022-10-12 14:49:27 +02:00
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getLevelableAction(ctx, type, name);
|
2022-10-12 14:49:27 +02:00
|
|
|
return action.autoLevel;
|
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getActionSuccesses: (ctx) => (type, name) => {
|
2023-01-16 05:50:54 +01:00
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getLevelableAction(ctx, type, name);
|
2023-01-16 05:50:54 +01:00
|
|
|
return action.successes;
|
|
|
|
},
|
2022-05-08 01:08:07 +02:00
|
|
|
setActionAutolevel:
|
2022-10-12 14:49:27 +02:00
|
|
|
(ctx) =>
|
2024-03-29 02:52:37 +01:00
|
|
|
(type, name, _autoLevel = true) => {
|
2022-08-08 19:43:41 +02:00
|
|
|
const autoLevel = !!_autoLevel;
|
2022-05-08 01:08:07 +02:00
|
|
|
checkBladeburnerAccess(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getLevelableAction(ctx, type, name);
|
2022-05-08 01:08:07 +02:00
|
|
|
action.autoLevel = autoLevel;
|
2024-03-29 02:52:37 +01:00
|
|
|
helpers.log(ctx, () => `Autolevel for ${action.name} has been ${autoLevel ? "enabled" : "disabled"}`);
|
2022-05-08 01:08:07 +02:00
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
setActionLevel: (ctx) => (type, name, _level) => {
|
|
|
|
const level = helpers.positiveInteger(ctx, "level", _level ?? 1);
|
|
|
|
checkBladeburnerAccess(ctx);
|
|
|
|
const action = getLevelableAction(ctx, type, name);
|
|
|
|
if (level < 1 || level > action.maxLevel) {
|
|
|
|
throw helpers.errorMessage(ctx, `Level must be between 1 and ${action.maxLevel}, is ${level}`);
|
|
|
|
}
|
|
|
|
action.level = level;
|
|
|
|
helpers.log(ctx, () => `Set level for ${action.name} to ${level}`);
|
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getRank: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2021-10-14 09:22:02 +02:00
|
|
|
return bladeburner.rank;
|
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getSkillPoints: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2021-10-14 09:22:02 +02:00
|
|
|
return bladeburner.skillPoints;
|
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getSkillLevel: (ctx) => (_skillName) => {
|
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const skillName = getEnumHelper("BladeSkillName").nsGetMember(ctx, _skillName, "skillName");
|
|
|
|
return bladeburner.getSkillLevel(skillName);
|
2022-10-12 14:49:27 +02:00
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
getSkillUpgradeCost: (ctx) => (_skillName, _count) => {
|
2022-12-30 02:28:53 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const skillName = getEnumHelper("BladeSkillName").nsGetMember(ctx, _skillName, "skillName");
|
|
|
|
const count = helpers.positiveSafeInteger(ctx, "count", _count ?? 1);
|
|
|
|
const currentLevel = bladeburner.getSkillLevel(skillName);
|
|
|
|
return Skills[skillName].calculateCost(currentLevel, count);
|
|
|
|
},
|
|
|
|
upgradeSkill: (ctx) => (_skillName, _count) => {
|
|
|
|
const bladeburner = getBladeburner(ctx);
|
|
|
|
const skillName = getEnumHelper("BladeSkillName").nsGetMember(ctx, _skillName, "skillName");
|
|
|
|
const count = helpers.positiveSafeInteger(ctx, "count", _count ?? 1);
|
|
|
|
const attempt = bladeburner.upgradeSkill(skillName, count);
|
|
|
|
helpers.log(ctx, () => attempt.message);
|
|
|
|
return !!attempt.success;
|
|
|
|
},
|
|
|
|
getTeamSize: (ctx) => (type, name) => {
|
|
|
|
const bladeburner = getBladeburner(ctx);
|
|
|
|
if (!type && !name) return bladeburner.teamSize;
|
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
switch (action.type) {
|
|
|
|
case BladeActionType.general:
|
|
|
|
case BladeActionType.contract:
|
|
|
|
return 0;
|
|
|
|
case BladeActionType.blackOp:
|
|
|
|
case BladeActionType.operation:
|
|
|
|
return action.teamCount;
|
2022-10-12 14:49:27 +02:00
|
|
|
}
|
|
|
|
},
|
2024-03-29 02:52:37 +01:00
|
|
|
setTeamSize: (ctx) => (type, name, _size) => {
|
2022-12-30 02:28:53 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const action = getAction(ctx, type, name);
|
|
|
|
const size = helpers.positiveInteger(ctx, "size", _size);
|
|
|
|
if (size > bladeburner.teamSize) {
|
|
|
|
helpers.log(ctx, () => `Failed to set team size due to not enough team members.`);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
switch (action.type) {
|
|
|
|
case BladeActionType.contract:
|
|
|
|
case BladeActionType.general:
|
|
|
|
helpers.log(ctx, () => "Only valid for Operations and Black Operations");
|
|
|
|
return -1;
|
|
|
|
case BladeActionType.blackOp:
|
|
|
|
case BladeActionType.operation: {
|
|
|
|
action.teamCount = size;
|
|
|
|
helpers.log(ctx, () => `Set team size for ${action.name} to ${size}`);
|
|
|
|
return size;
|
|
|
|
}
|
2022-10-12 14:49:27 +02:00
|
|
|
}
|
|
|
|
},
|
|
|
|
getCityEstimatedPopulation: (ctx) => (_cityName) => {
|
2022-12-30 02:28:53 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2023-06-12 06:34:20 +02:00
|
|
|
const cityName = getEnumHelper("CityName").nsGetMember(ctx, _cityName);
|
2022-10-12 14:49:27 +02:00
|
|
|
return bladeburner.cities[cityName].popEst;
|
|
|
|
},
|
|
|
|
getCityCommunities: (ctx) => (_cityName) => {
|
2022-12-30 02:28:53 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2023-06-12 06:34:20 +02:00
|
|
|
const cityName = getEnumHelper("CityName").nsGetMember(ctx, _cityName);
|
2022-10-12 14:49:27 +02:00
|
|
|
return bladeburner.cities[cityName].comms;
|
|
|
|
},
|
|
|
|
getCityChaos: (ctx) => (_cityName) => {
|
2022-12-30 02:28:53 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2023-06-12 06:34:20 +02:00
|
|
|
const cityName = getEnumHelper("CityName").nsGetMember(ctx, _cityName);
|
2022-10-12 14:49:27 +02:00
|
|
|
return bladeburner.cities[cityName].chaos;
|
|
|
|
},
|
|
|
|
getCity: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2021-10-14 09:22:02 +02:00
|
|
|
return bladeburner.city;
|
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
switchCity: (ctx) => (_cityName) => {
|
2022-12-30 02:28:53 +01:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2023-06-12 06:34:20 +02:00
|
|
|
const cityName = getEnumHelper("CityName").nsGetMember(ctx, _cityName);
|
2022-10-12 14:49:27 +02:00
|
|
|
bladeburner.city = cityName;
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
getStamina: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2021-10-14 09:22:02 +02:00
|
|
|
return [bladeburner.stamina, bladeburner.maxStamina];
|
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
joinBladeburnerFaction: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2024-03-29 02:52:37 +01:00
|
|
|
const attempt = bladeburner.joinFaction();
|
|
|
|
helpers.log(ctx, () => attempt.message);
|
|
|
|
return !!attempt.success;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
joinBladeburnerDivision: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
if (Player.bitNodeN === 7 || Player.sourceFileLvl(7) > 0) {
|
2023-06-16 23:52:42 +02:00
|
|
|
if (currentNodeMults.BladeburnerRank === 0) {
|
2022-09-12 16:46:16 +02:00
|
|
|
return false; // Disabled in this bitnode
|
2021-10-14 09:22:02 +02:00
|
|
|
}
|
2022-09-27 21:14:34 +02:00
|
|
|
if (Player.bladeburner) {
|
2021-10-14 09:22:02 +02:00
|
|
|
return true; // Already member
|
|
|
|
} else if (
|
2022-09-06 15:07:12 +02:00
|
|
|
Player.skills.strength >= 100 &&
|
|
|
|
Player.skills.defense >= 100 &&
|
|
|
|
Player.skills.dexterity >= 100 &&
|
|
|
|
Player.skills.agility >= 100
|
2021-10-14 09:22:02 +02:00
|
|
|
) {
|
2024-03-29 02:52:37 +01:00
|
|
|
Player.startBladeburner();
|
2022-08-08 21:51:50 +02:00
|
|
|
helpers.log(ctx, () => "You have been accepted into the Bladeburner division");
|
2021-10-14 09:22:02 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
} else {
|
2022-08-08 21:51:50 +02:00
|
|
|
helpers.log(ctx, () => "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
|
|
|
},
|
2022-10-12 14:49:27 +02:00
|
|
|
getBonusTime: (ctx) => () => {
|
2022-09-06 15:07:12 +02:00
|
|
|
const bladeburner = getBladeburner(ctx);
|
2022-03-30 02:44:27 +02:00
|
|
|
return Math.round(bladeburner.storedCycles / 5) * 1000;
|
2021-10-14 09:22:02 +02:00
|
|
|
},
|
2024-02-10 12:27:47 +01:00
|
|
|
nextUpdate: (ctx) => () => {
|
|
|
|
checkBladeburnerAccess(ctx);
|
|
|
|
if (!BladeburnerPromise.promise)
|
|
|
|
BladeburnerPromise.promise = new Promise<number>((res) => (BladeburnerPromise.resolve = res));
|
|
|
|
return BladeburnerPromise.promise;
|
2023-10-23 10:24:30 +02:00
|
|
|
},
|
2021-10-14 09:22:02 +02:00
|
|
|
};
|
|
|
|
}
|