dutlist
abaddeb544
sotries needs more data(currently all worldstate data is taken from wfcd worldstate data package)
620 lines
26 KiB
TypeScript
620 lines
26 KiB
TypeScript
import { WorldState } from "@/src/models/worldStateModel";
|
|
import { unixTimesInMs } from "@/src/constants/timeConstants";
|
|
import {
|
|
IActiveMission,
|
|
ILiteSortie,
|
|
ISortie,
|
|
ISyndicateMission,
|
|
IVoidStorm,
|
|
IWorldState
|
|
} from "@/src/types/worldStateTypes";
|
|
import { getRandomNumber, getRandomKey } from "@/src/helpers/general";
|
|
import { getRandomNodes, getCurrentRotation } from "@/src/helpers/worldstateHelpers";
|
|
import { ExportRailjack, ExportRegions } from "warframe-public-export-plus";
|
|
import { logger } from "@/src/utils/logger";
|
|
import {
|
|
factionSyndicates,
|
|
neutralJobsSyndicates,
|
|
neutralSyndicates,
|
|
restSyndicates,
|
|
CertusNormalJobs,
|
|
CertusNarmerJobs,
|
|
ZarimanNormalJobs,
|
|
voidFisuresMissionTypes,
|
|
validFisureMissionIndex,
|
|
omniaNodes,
|
|
liteSortiesBoss,
|
|
endStates,
|
|
modifierTypes,
|
|
SortiesMissionTypes,
|
|
voidTiers,
|
|
FortunaNarmerJobs,
|
|
FortunaNormalJobs
|
|
} from "@/src/constants/worldStateConstants";
|
|
|
|
export const createWorldState = async () => {
|
|
const worldState = new WorldState();
|
|
await worldState.save();
|
|
await updateSyndicateMissions();
|
|
await updateVoidFisures();
|
|
await updateSorties();
|
|
return worldState;
|
|
};
|
|
|
|
export const getWorldState = async () => {
|
|
let ws = await WorldState.findOne();
|
|
if (!ws) {
|
|
ws = await createWorldState();
|
|
}
|
|
return ws.toJSON();
|
|
};
|
|
|
|
export const worldStateRunner = async () => {
|
|
await getWorldState();
|
|
setInterval(async () => {
|
|
logger.info("Update worldState");
|
|
await updateSyndicateMissions();
|
|
await updateVoidFisures();
|
|
await updateSorties();
|
|
}, unixTimesInMs.minute);
|
|
};
|
|
|
|
const updateSyndicateMissions = async (): Promise<IWorldState> => {
|
|
const currentDate = Date.now();
|
|
const oneDayIntervalStart =
|
|
Math.floor(currentDate / unixTimesInMs.day) * unixTimesInMs.day + 16 * unixTimesInMs.hour;
|
|
const oneDayIntervalEnd = oneDayIntervalStart + unixTimesInMs.day;
|
|
|
|
const neutralJobsIntervalStart = Math.floor(currentDate / (2.5 * unixTimesInMs.hour)) * (2.5 * unixTimesInMs.hour);
|
|
const neutralJobsIntervalEnd = neutralJobsIntervalStart + 2.5 * unixTimesInMs.hour;
|
|
|
|
const neutralSeed = getRandomNumber(1, 99999);
|
|
|
|
try {
|
|
const ws = await WorldState.findOne();
|
|
if (!ws) throw new Error("Missing worldState");
|
|
|
|
const syndicateArray = ws.SyndicateMissions || [];
|
|
|
|
const existingTags = syndicateArray.map(syndicate => syndicate.Tag);
|
|
|
|
const createNewSyndicateEntry = (tag: string): ISyndicateMission => {
|
|
switch (true) {
|
|
case factionSyndicates.includes(tag):
|
|
return {
|
|
Tag: tag,
|
|
Seed: getRandomNumber(1, 99999),
|
|
Nodes: getRandomNodes(7),
|
|
Activation: oneDayIntervalStart,
|
|
Expiry: oneDayIntervalEnd
|
|
};
|
|
case neutralJobsSyndicates.includes(tag):
|
|
return {
|
|
Tag: tag,
|
|
Seed: neutralSeed,
|
|
Nodes: [],
|
|
Activation: neutralJobsIntervalStart,
|
|
Expiry: neutralJobsIntervalEnd,
|
|
Jobs: getJobs(tag)
|
|
};
|
|
case neutralSyndicates.includes(tag):
|
|
return {
|
|
Tag: tag,
|
|
Seed: neutralSeed,
|
|
Nodes: [],
|
|
Activation: neutralJobsIntervalStart,
|
|
Expiry: neutralJobsIntervalEnd
|
|
};
|
|
case restSyndicates.includes(tag):
|
|
return {
|
|
Tag: tag,
|
|
Seed: getRandomNumber(1, 99999),
|
|
Nodes: [],
|
|
Activation: oneDayIntervalStart,
|
|
Expiry: oneDayIntervalEnd
|
|
};
|
|
default:
|
|
throw new Error(`Unhandled syndicate tag: ${tag}`);
|
|
}
|
|
};
|
|
|
|
[...factionSyndicates, ...neutralJobsSyndicates, ...neutralSyndicates, ...restSyndicates].forEach(tag => {
|
|
if (!existingTags.includes(tag)) {
|
|
syndicateArray.push(createNewSyndicateEntry(tag));
|
|
} else {
|
|
const syndicateIndex = existingTags.indexOf(tag);
|
|
const shouldUpdate = currentDate >= syndicateArray[syndicateIndex].Expiry;
|
|
|
|
if (shouldUpdate) {
|
|
syndicateArray[syndicateIndex] = {
|
|
...syndicateArray[syndicateIndex],
|
|
Tag: tag,
|
|
Seed:
|
|
neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
|
|
? neutralSeed
|
|
: getRandomNumber(1, 99999),
|
|
Nodes:
|
|
neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
|
|
? []
|
|
: getRandomNodes(7),
|
|
Activation:
|
|
neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
|
|
? neutralJobsIntervalStart
|
|
: oneDayIntervalStart,
|
|
Expiry:
|
|
neutralJobsSyndicates.includes(tag) || neutralSyndicates.includes(tag)
|
|
? neutralJobsIntervalEnd
|
|
: oneDayIntervalEnd,
|
|
Jobs: neutralJobsSyndicates.includes(tag) ? getJobs(tag) : undefined
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
ws.SyndicateMissions = syndicateArray;
|
|
|
|
await ws.save();
|
|
return ws;
|
|
} catch (error) {
|
|
throw new Error(`Error while updating Syndicates ${error}`);
|
|
}
|
|
};
|
|
|
|
const getJobs = (tag: string) => {
|
|
const rotration = getCurrentRotation();
|
|
switch (tag) {
|
|
case "CetusSyndicate":
|
|
const Certusjobs = [
|
|
{
|
|
jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierATable${rotration}Rewards`,
|
|
masteryReq: 0,
|
|
minEnemyLevel: 5,
|
|
maxEnemyLevel: 15,
|
|
xpAmounts: [410, 410, 410]
|
|
},
|
|
{
|
|
jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierBTable${rotration}Rewards`,
|
|
masteryReq: 1,
|
|
minEnemyLevel: 10,
|
|
maxEnemyLevel: 30,
|
|
xpAmounts: [750, 750, 750]
|
|
},
|
|
{
|
|
jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierCTable${rotration}Rewards`,
|
|
masteryReq: 2,
|
|
minEnemyLevel: 20,
|
|
maxEnemyLevel: 40,
|
|
xpAmounts: [580, 580, 580, 850]
|
|
},
|
|
{
|
|
jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierDTable${rotration}Rewards`,
|
|
masteryReq: 3,
|
|
minEnemyLevel: 30,
|
|
maxEnemyLevel: 50,
|
|
xpAmounts: [580, 580, 580, 580, 1130]
|
|
},
|
|
{
|
|
jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierETable${rotration}Rewards`,
|
|
masteryReq: 5,
|
|
minEnemyLevel: 40,
|
|
maxEnemyLevel: 60,
|
|
xpAmounts: [710, 710, 710, 710, 1390]
|
|
},
|
|
{
|
|
jobType: CertusNormalJobs[Math.floor(Math.random() * CertusNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/TierETable${rotration}Rewards`,
|
|
masteryReq: 10,
|
|
minEnemyLevel: 100,
|
|
maxEnemyLevel: 100,
|
|
xpAmounts: [840, 840, 840, 840, 1660]
|
|
},
|
|
{
|
|
jobType: CertusNarmerJobs[Math.floor(Math.random() * CertusNarmerJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/EidolonJobMissionRewards/NarmerTable${rotration}Rewards`,
|
|
masteryReq: 0,
|
|
minEnemyLevel: 50,
|
|
maxEnemyLevel: 70,
|
|
xpAmounts: [820, 820, 820, 820, 1610]
|
|
}
|
|
];
|
|
return Certusjobs;
|
|
|
|
case "SolarisSyndicate":
|
|
const FortunaJobs = [
|
|
{
|
|
jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierATable${rotration}Rewards`,
|
|
masteryReq: 0,
|
|
minEnemyLevel: 5,
|
|
maxEnemyLevel: 15,
|
|
xpAmounts: [410, 410, 410]
|
|
},
|
|
{
|
|
jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierBTable${rotration}Rewards`,
|
|
masteryReq: 1,
|
|
minEnemyLevel: 10,
|
|
maxEnemyLevel: 30,
|
|
xpAmounts: [750, 750, 750]
|
|
},
|
|
{
|
|
jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierCTable${rotration}Rewards`,
|
|
masteryReq: 2,
|
|
minEnemyLevel: 20,
|
|
maxEnemyLevel: 40,
|
|
xpAmounts: [580, 580, 580, 850]
|
|
},
|
|
{
|
|
jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierDTable${rotration}Rewards`,
|
|
masteryReq: 3,
|
|
minEnemyLevel: 30,
|
|
maxEnemyLevel: 50,
|
|
xpAmounts: [580, 580, 580, 580, 1130]
|
|
},
|
|
{
|
|
jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierETable${rotration}Rewards`,
|
|
masteryReq: 5,
|
|
minEnemyLevel: 40,
|
|
maxEnemyLevel: 60,
|
|
xpAmounts: [710, 710, 710, 710, 1390]
|
|
},
|
|
{
|
|
jobType: FortunaNormalJobs[Math.floor(Math.random() * FortunaNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusTierETable${rotration}Rewards`,
|
|
masteryReq: 10,
|
|
minEnemyLevel: 100,
|
|
maxEnemyLevel: 100,
|
|
xpAmounts: [840, 840, 840, 840, 1660]
|
|
},
|
|
{
|
|
jobType: FortunaNarmerJobs[Math.floor(Math.random() * FortunaNarmerJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/VenusJobMissionRewards/VenusNarmerTable${rotration}Rewards`,
|
|
masteryReq: 0,
|
|
minEnemyLevel: 50,
|
|
maxEnemyLevel: 70,
|
|
xpAmounts: [820, 820, 820, 820, 1610]
|
|
}
|
|
];
|
|
return FortunaJobs;
|
|
|
|
case "EntratiSyndicate":
|
|
const ZarimanJobs = [
|
|
{
|
|
jobType: ZarimanNormalJobs[Math.floor(Math.random() * ZarimanNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierATable${getRandomKey(["A", "B", "C"])}Rewards`,
|
|
masteryReq: 0,
|
|
minEnemyLevel: 5,
|
|
maxEnemyLevel: 15,
|
|
xpAmounts: [5, 5, 5]
|
|
},
|
|
{
|
|
jobType: ZarimanNormalJobs[Math.floor(Math.random() * ZarimanNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierCTable${getRandomKey(["A", "B", "C"])}Rewards`,
|
|
masteryReq: 1,
|
|
minEnemyLevel: 15,
|
|
maxEnemyLevel: 25,
|
|
xpAmounts: [9, 9, 9]
|
|
},
|
|
{
|
|
jobType: ZarimanNormalJobs[Math.floor(Math.random() * ZarimanNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierBTable${getRandomKey(["A", "B", "C"])}Rewards`,
|
|
masteryReq: 5,
|
|
minEnemyLevel: 25,
|
|
maxEnemyLevel: 30,
|
|
endless: true,
|
|
xpAmounts: [14, 14, 14]
|
|
},
|
|
{
|
|
jobType: ZarimanNormalJobs[Math.floor(Math.random() * ZarimanNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierDTable${getRandomKey(["A", "B", "C"])}Rewards`,
|
|
masteryReq: 2,
|
|
minEnemyLevel: 30,
|
|
maxEnemyLevel: 40,
|
|
xpAmounts: [19, 19, 19, 29]
|
|
},
|
|
{
|
|
jobType: ZarimanNormalJobs[Math.floor(Math.random() * ZarimanNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierETable${getRandomKey(["A", "B", "C"])}Rewards`,
|
|
masteryReq: 3,
|
|
minEnemyLevel: 40,
|
|
maxEnemyLevel: 60,
|
|
xpAmounts: [21, 21, 21, 21, 41]
|
|
},
|
|
{
|
|
jobType: ZarimanNormalJobs[Math.floor(Math.random() * ZarimanNormalJobs.length)],
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/TierETable${getRandomKey(["A", "B", "C"])}Rewards`,
|
|
masteryReq: 10,
|
|
minEnemyLevel: 100,
|
|
maxEnemyLevel: 100,
|
|
xpAmounts: [25, 25, 25, 25, 50]
|
|
},
|
|
{
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/VaultBountyTierATable${getCurrentRotation()}Rewards`,
|
|
masteryReq: 5,
|
|
minEnemyLevel: 30,
|
|
maxEnemyLevel: 40,
|
|
xpAmounts: [2, 2, 2, 4],
|
|
locationTag: "ChamberB",
|
|
isVault: true
|
|
},
|
|
{
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/VaultBountyTierBTable${getCurrentRotation()}Rewards`,
|
|
masteryReq: 5,
|
|
minEnemyLevel: 40,
|
|
maxEnemyLevel: 50,
|
|
xpAmounts: [4, 4, 4, 5],
|
|
locationTag: "ChamberA",
|
|
isVault: true
|
|
},
|
|
{
|
|
rewards: `/Lotus/Types/Game/MissionDecks/DeimosMissionRewards/VaultBountyTierCTable${getCurrentRotation()}Rewards`,
|
|
masteryReq: 5,
|
|
minEnemyLevel: 50,
|
|
maxEnemyLevel: 60,
|
|
xpAmounts: [5, 5, 5, 7],
|
|
locationTag: "ChamberC",
|
|
isVault: true
|
|
}
|
|
];
|
|
return ZarimanJobs;
|
|
|
|
default:
|
|
throw new Error(`Error while updating Syndicates: Unknown Jobs syndicate ${tag}`);
|
|
}
|
|
};
|
|
|
|
const updateVoidFisures = async () => {
|
|
const curDate = Date.now();
|
|
try {
|
|
const ws = await WorldState.findOne();
|
|
if (!ws) throw new Error("Missing worldState");
|
|
const voidFisures = ws.ActiveMissions;
|
|
const voidStorms = ws.VoidStorms;
|
|
const voidFisuresByTier: { [key: string]: IActiveMission[] } = {
|
|
VoidT1: [],
|
|
VoidT2: [],
|
|
VoidT3: [],
|
|
VoidT4: [],
|
|
VoidT5: [],
|
|
VoidT6: []
|
|
};
|
|
const voidStormsByTier: { [key: string]: IVoidStorm[] } = {
|
|
VoidT1: [],
|
|
VoidT2: [],
|
|
VoidT3: [],
|
|
VoidT4: [],
|
|
VoidT5: [],
|
|
VoidT6: []
|
|
};
|
|
|
|
if (voidFisures) {
|
|
voidFisures.forEach(mission => {
|
|
const tier = mission.Modifier;
|
|
if (tier) {
|
|
if (!voidFisuresByTier[tier]) {
|
|
voidFisuresByTier[tier] = [];
|
|
}
|
|
voidFisuresByTier[tier].push(mission);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (voidStorms) {
|
|
voidStorms.forEach(mission => {
|
|
const tier = mission.ActiveMissionTier;
|
|
if (tier) {
|
|
if (!voidStormsByTier[tier]) {
|
|
voidStormsByTier[tier] = [];
|
|
}
|
|
voidStormsByTier[tier].push(mission);
|
|
}
|
|
});
|
|
}
|
|
|
|
voidTiers.forEach(voidTier => {
|
|
if (voidFisuresByTier[voidTier].length < 3) {
|
|
const nodeData = getRandomFisureNode(false, voidTier == "VoidT6");
|
|
logger.debug(voidTier);
|
|
if (!nodeData.missionIndex) nodeData.missionIndex = 1;
|
|
const node = {
|
|
Region: nodeData.systemIndex,
|
|
Seed: getRandomNumber(1, 99999),
|
|
Activation: curDate,
|
|
Expiry: curDate + Math.floor(Math.random() * unixTimesInMs.hour),
|
|
Node: nodeData.nodeKey,
|
|
MissionType: voidFisuresMissionTypes[nodeData.missionIndex],
|
|
Modifier: voidTier,
|
|
Hard: Math.random() < 0.1
|
|
} as IActiveMission;
|
|
voidFisures?.push(node);
|
|
}
|
|
|
|
if (voidStormsByTier[voidTier].length < 2) {
|
|
const nodeData = getRandomFisureNode(true, voidTier == "VoidT6");
|
|
logger.debug(voidTier);
|
|
const node = {
|
|
Activation: curDate,
|
|
Expiry: curDate + Math.floor(Math.random() * unixTimesInMs.hour),
|
|
Node: nodeData.nodeKey,
|
|
ActiveMissionTier: voidTier
|
|
} as IVoidStorm;
|
|
voidStorms?.push(node);
|
|
}
|
|
});
|
|
await ws.save();
|
|
return ws;
|
|
} catch (error) {
|
|
throw new Error(`Error while updating VoidFisures: ${error}`);
|
|
}
|
|
};
|
|
|
|
const getRandomFisureNode = (isRailJack: boolean, isOmnia: boolean) => {
|
|
const validNodes = Object.entries(ExportRegions)
|
|
.map(([key, node]) => {
|
|
return {
|
|
...node,
|
|
nodeKey: key
|
|
};
|
|
})
|
|
.filter(node => {
|
|
return validFisureMissionIndex.includes(node.missionIndex) && !node.missionName.includes("Archwing");
|
|
});
|
|
|
|
if (isRailJack) {
|
|
const railJackNodes = Object.keys(ExportRailjack.nodes);
|
|
const randomKey = railJackNodes[Math.floor(Math.random() * railJackNodes.length)];
|
|
return {
|
|
nodeKey: randomKey
|
|
};
|
|
} else if (isOmnia) {
|
|
const validOmniaNodes = validNodes.filter(node => {
|
|
return omniaNodes.includes(node.nodeKey);
|
|
});
|
|
const randomNode = validOmniaNodes[Math.floor(Math.random() * validOmniaNodes.length)];
|
|
return {
|
|
nodeKey: randomNode.nodeKey,
|
|
systemIndex: randomNode.systemIndex,
|
|
missionIndex: randomNode.missionIndex
|
|
};
|
|
} else {
|
|
const randomNode = validNodes[Math.floor(Math.random() * validNodes.length)];
|
|
return {
|
|
nodeKey: randomNode.nodeKey,
|
|
systemIndex: randomNode.systemIndex,
|
|
missionIndex: randomNode.missionIndex
|
|
};
|
|
}
|
|
};
|
|
|
|
const updateSorties = async () => {
|
|
const currentDate = Date.now();
|
|
const oneDayIntervalStart =
|
|
Math.floor(currentDate / unixTimesInMs.day) * unixTimesInMs.day + 16 * unixTimesInMs.hour;
|
|
const oneDayIntervalEnd = oneDayIntervalStart + unixTimesInMs.day;
|
|
const oneWeekIntervalStart =
|
|
Math.floor(currentDate / (unixTimesInMs.day * 7)) * unixTimesInMs.day * 7 + 16 * unixTimesInMs.hour;
|
|
const oneWeekIntervalEnd = oneDayIntervalStart + unixTimesInMs.day * 7;
|
|
const nodes = Object.entries(ExportRegions).map(([key, node]) => {
|
|
return {
|
|
nodeSystemIndex: node.systemIndex,
|
|
nodeKey: key
|
|
};
|
|
});
|
|
|
|
try {
|
|
const ws = await WorldState.findOne();
|
|
if (!ws) throw new Error("Missing worldState");
|
|
const liteSorties: ILiteSortie[] = ws?.LiteSorties;
|
|
const sorties: ISortie[] = ws?.Sorties;
|
|
|
|
[...liteSorties, ...sorties].forEach((sortie, index, array) => {
|
|
if (currentDate >= sortie.Expiry) array.splice(index, 1);
|
|
});
|
|
|
|
if (liteSorties.length < 1) {
|
|
const sortie: ILiteSortie = {
|
|
Activation: oneWeekIntervalStart,
|
|
Expiry: oneWeekIntervalEnd,
|
|
Reward: "/Lotus/Types/Game/MissionDecks/ArchonSortieRewards",
|
|
Seed: getRandomNumber(1, 99999),
|
|
Boss: liteSortiesBoss[Math.floor(Math.random() * liteSortiesBoss.length)],
|
|
Missions: [
|
|
{
|
|
missionType: SortiesMissionTypes[Math.floor(Math.random() * SortiesMissionTypes.length)],
|
|
node: nodes[Math.floor(Math.random() * nodes.length)].nodeKey
|
|
},
|
|
{
|
|
missionType: SortiesMissionTypes[Math.floor(Math.random() * SortiesMissionTypes.length)],
|
|
node: nodes[Math.floor(Math.random() * nodes.length)].nodeKey
|
|
},
|
|
{
|
|
missionType: SortiesMissionTypes[Math.floor(Math.random() * SortiesMissionTypes.length)],
|
|
node: nodes[Math.floor(Math.random() * nodes.length)].nodeKey
|
|
}
|
|
]
|
|
};
|
|
liteSorties.push(sortie);
|
|
}
|
|
|
|
if (sorties.length < 1) {
|
|
const randomBoss = endStates[Math.floor(Math.random() * endStates.length)];
|
|
const randomRegionIndex = [
|
|
Math.floor(Math.random() * randomBoss.regions.length),
|
|
Math.floor(Math.random() * randomBoss.regions.length),
|
|
Math.floor(Math.random() * randomBoss.regions.length)
|
|
];
|
|
const randomRegionIndexFake = randomRegionIndex;
|
|
randomRegionIndexFake.forEach((element, index, array) => {
|
|
if (element == 13) {
|
|
array[index] = element + 2;
|
|
} else if (element == 14) {
|
|
array[index] = element + 1;
|
|
}
|
|
});
|
|
const filteredNodes = [
|
|
nodes.filter(node => {
|
|
return randomRegionIndexFake[0] === node.nodeSystemIndex;
|
|
}),
|
|
nodes.filter(node => {
|
|
return randomRegionIndexFake[1] === node.nodeSystemIndex;
|
|
}),
|
|
nodes.filter(node => {
|
|
return randomRegionIndexFake[2] === node.nodeSystemIndex;
|
|
})
|
|
];
|
|
const sortie: ISortie = {
|
|
Activation: oneDayIntervalStart,
|
|
Expiry: oneDayIntervalEnd,
|
|
ExtraDrops: [],
|
|
Reward: "/Lotus/Types/Game/MissionDecks/SortieRewards",
|
|
Seed: getRandomNumber(1, 99999),
|
|
Boss: randomBoss.bossName,
|
|
Variants: [
|
|
{
|
|
missionType:
|
|
randomBoss.regions[randomRegionIndex[0]].missions[
|
|
Math.floor(Math.random() * randomBoss.regions[randomRegionIndex[0]].missions.length)
|
|
],
|
|
modifierType: modifierTypes[Math.floor(Math.random() * modifierTypes.length)],
|
|
node: filteredNodes[0][Math.floor(Math.random() * filteredNodes[0].length)].nodeKey,
|
|
tileset: "CorpusShipTileset"
|
|
},
|
|
{
|
|
missionType:
|
|
randomBoss.regions[randomRegionIndex[1]].missions[
|
|
Math.floor(Math.random() * randomBoss.regions[randomRegionIndex[1]].missions.length)
|
|
],
|
|
modifierType: modifierTypes[Math.floor(Math.random() * modifierTypes.length)],
|
|
node: filteredNodes[1][Math.floor(Math.random() * filteredNodes[1].length)].nodeKey,
|
|
tileset: "OrokinMoonTilesetCorpus"
|
|
},
|
|
{
|
|
missionType:
|
|
randomBoss.regions[randomRegionIndex[2]].missions[
|
|
Math.floor(Math.random() * randomBoss.regions[randomRegionIndex[2]].missions.length)
|
|
],
|
|
modifierType: modifierTypes[Math.floor(Math.random() * modifierTypes.length)],
|
|
node: filteredNodes[2][Math.floor(Math.random() * filteredNodes[2].length)].nodeKey,
|
|
tileset: "CorpusShipTileset"
|
|
}
|
|
],
|
|
Twitter: true
|
|
};
|
|
sorties.push(sortie);
|
|
}
|
|
|
|
await ws.save();
|
|
return ws;
|
|
} catch (error) {
|
|
throw new Error(`Error while updating Sorties ${error}`);
|
|
}
|
|
};
|