Grabbed dndbeyond's source code
``` ~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js ```
This commit is contained in:
@@ -0,0 +1,256 @@
|
||||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
import { characterActions, serviceDataActions } from "../actions";
|
||||
import { ApiRequestHelpers } from "../api";
|
||||
import { ApiAdapterUtils } from "../apiAdapter";
|
||||
import { ClassAccessors } from "../engine/Class";
|
||||
import { HelperUtils } from "../engine/Helper";
|
||||
import { SourceUtils } from "../engine/Source";
|
||||
import { SpellDerivers, SpellSimulators } from "../engine/Spell";
|
||||
import { apiCreatorSelectors, rulesEngineSelectors } from "../selectors";
|
||||
import { getOverallSpellInfo } from "../selectors/composite/engine";
|
||||
import { TypeScriptUtils } from "../utils";
|
||||
import { getLeveledSpellManager, LeveledSpellManager } from './LeveledSpellManager';
|
||||
import { MessageManager } from './MessageManager';
|
||||
import { getSpellManager, SpellManager } from './SpellManager';
|
||||
let spellShoppe = null;
|
||||
let apiResponses = {};
|
||||
let spellsManager = null;
|
||||
// TODO: this seems like a good pattern might want to implement else where
|
||||
export function getSpellsManager(params) {
|
||||
if (spellsManager) {
|
||||
return spellsManager;
|
||||
}
|
||||
spellsManager = new SpellsManager(params);
|
||||
return spellsManager;
|
||||
}
|
||||
export class SpellsManager extends MessageManager {
|
||||
constructor(params) {
|
||||
super(params);
|
||||
this.handleSpellSlotSet = (used, castLevel) => {
|
||||
const spellLevelSpellSlotRequestsDataKey = ApiRequestHelpers.getSpellLevelSpellSlotRequestsDataKey(castLevel);
|
||||
if (spellLevelSpellSlotRequestsDataKey !== null) {
|
||||
this.dispatch(characterActions.spellLevelSpellSlotsSet({
|
||||
[spellLevelSpellSlotRequestsDataKey]: used,
|
||||
}));
|
||||
}
|
||||
};
|
||||
this.handleSpellSlotChange = (changeAmount, castLevel) => {
|
||||
const spellSlots = rulesEngineSelectors.getSpellSlots(this.state);
|
||||
const usedAmount = this.getUsedSpellSlotLevelAmount(changeAmount, spellSlots, castLevel);
|
||||
if (usedAmount !== null) {
|
||||
this.handleSpellSlotSet(usedAmount, castLevel);
|
||||
}
|
||||
};
|
||||
this.handlePactSlotSet = (used, castLevel) => {
|
||||
const spellLevelPactMagicRequestsDataKey = ApiRequestHelpers.getSpellLevelPactMagicRequestsDataKey(castLevel);
|
||||
if (spellLevelPactMagicRequestsDataKey !== null) {
|
||||
this.dispatch(characterActions.spellLevelPactMagicSlotsSet({
|
||||
[spellLevelPactMagicRequestsDataKey]: used,
|
||||
}));
|
||||
}
|
||||
};
|
||||
this.handlePactSlotChange = (changeAmount, castLevel) => {
|
||||
const pactMagicSlots = rulesEngineSelectors.getPactMagicSlots(this.state);
|
||||
const usedAmount = this.getUsedSpellSlotLevelAmount(changeAmount, pactMagicSlots, castLevel);
|
||||
if (usedAmount !== null) {
|
||||
this.handlePactSlotSet(usedAmount, castLevel);
|
||||
}
|
||||
};
|
||||
this.getUsedSpellSlotLevelAmount = (changeAmount, spellSlots, castLevel) => {
|
||||
const foundSlotLevel = spellSlots.find((spellSlot) => spellSlot.level === castLevel);
|
||||
if (!foundSlotLevel) {
|
||||
return null;
|
||||
}
|
||||
const usedAmount = foundSlotLevel.used + changeAmount;
|
||||
const maxAmount = foundSlotLevel.available;
|
||||
return HelperUtils.clampInt(usedAmount, 0, maxAmount);
|
||||
};
|
||||
this.handleAlwaysKnownLoad = (spells, classId) => {
|
||||
this.dispatch(serviceDataActions.classAlwaysKnownSpellsSet(spells, classId));
|
||||
};
|
||||
this.transformLoadedSpells = (data) => {
|
||||
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
||||
const overallSpellInfo = getOverallSpellInfo(this.state);
|
||||
return data.map((definition) => SpellSimulators.simulateSpell(definition, overallSpellInfo, ruleData, null, null));
|
||||
};
|
||||
this.params = params;
|
||||
this.name = 'SpellsManager';
|
||||
}
|
||||
bustCache() {
|
||||
spellShoppe = null;
|
||||
}
|
||||
getLevelSpells() {
|
||||
const levelSpells = rulesEngineSelectors.getLevelSpells(this.state);
|
||||
return levelSpells.map((spells) => {
|
||||
return spells.map((spell) => getLeveledSpellManager(Object.assign(Object.assign({}, this.params), { spell })));
|
||||
});
|
||||
}
|
||||
getSpellCasterInfo() {
|
||||
return rulesEngineSelectors.getSpellCasterInfo(this.state);
|
||||
}
|
||||
getClassName(charClass) {
|
||||
const name = ClassAccessors.getName(charClass);
|
||||
return name ? name : '';
|
||||
}
|
||||
getCharacterClassId(classId) {
|
||||
const charClasses = rulesEngineSelectors.getClasses(this.state);
|
||||
const charClassFound = charClasses.find((clazz) => {
|
||||
return ClassAccessors.getActiveId(clazz) === classId;
|
||||
});
|
||||
if (charClassFound) {
|
||||
return ClassAccessors.getMappingId(charClassFound);
|
||||
}
|
||||
else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
getLeveledSpell(knownLevelKey) {
|
||||
const leveledSpellManager = LeveledSpellManager.getLeveledSpellManager(knownLevelKey);
|
||||
if (!leveledSpellManager) {
|
||||
throw new Error(`leveledSpellManager for spell ${knownLevelKey} is null`);
|
||||
}
|
||||
return leveledSpellManager;
|
||||
}
|
||||
getLeveledSpellManagerBySpell(spell) {
|
||||
const spellCasterInfo = rulesEngineSelectors.getSpellCasterInfo(this.state);
|
||||
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
||||
const minCastLevel = SpellDerivers.getMinCastLevel(spell, spellCasterInfo, ruleData);
|
||||
const leveledKnownKey = SpellDerivers.deriveLeveledKnownKey(spell, minCastLevel);
|
||||
let result = null;
|
||||
try {
|
||||
result = this.getLeveledSpell(leveledKnownKey);
|
||||
}
|
||||
catch (error) {
|
||||
// noop
|
||||
}
|
||||
return result;
|
||||
}
|
||||
getSpellManagers(spells, classId) {
|
||||
const managers = spells.map((spell) => getSpellManager(Object.assign(Object.assign({}, this.params), { spell, bustCache: this.bustCache, classId })));
|
||||
return managers.filter((manager, index) => managers.indexOf(manager) === index);
|
||||
}
|
||||
getSpell(knownKey) {
|
||||
const spellManager = SpellManager.getSpellManager(knownKey);
|
||||
if (!spellManager) {
|
||||
throw new Error(`spellManager for spell ${knownKey} is null`);
|
||||
}
|
||||
return spellManager;
|
||||
}
|
||||
getSpellShoppe(shouldBustCache) {
|
||||
return __awaiter(this, void 0, void 0, function* () {
|
||||
if (!spellShoppe || shouldBustCache) {
|
||||
const classKnownSpells = apiCreatorSelectors.makeLoadClassAlwaysKnownSpells(this.state);
|
||||
const classRemainingSpells = apiCreatorSelectors.makeLoadClassRemainingSpells(this.state);
|
||||
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
||||
let classSpellLists = rulesEngineSelectors.getClassSpellLists(this.state);
|
||||
const classSpells = {};
|
||||
const availableSpellRequests = classSpellLists.map((classSpellList, i) => {
|
||||
var _a;
|
||||
const classId = ClassAccessors.getActiveId(classSpellList.charClass);
|
||||
if (!shouldBustCache && ((_a = apiResponses === null || apiResponses === void 0 ? void 0 : apiResponses[classId]) === null || _a === void 0 ? void 0 : _a.availableSpells)) {
|
||||
return Promise.resolve(apiResponses[classId].availableSpells);
|
||||
}
|
||||
const availableRequest = classRemainingSpells(classSpellList.charClass);
|
||||
if (availableRequest) {
|
||||
return availableRequest();
|
||||
}
|
||||
return Promise.resolve(null);
|
||||
});
|
||||
const knownSpellRequests = classSpellLists.map((classSpellList, i) => {
|
||||
var _a;
|
||||
const classId = ClassAccessors.getActiveId(classSpellList.charClass);
|
||||
if (!shouldBustCache && ((_a = apiResponses === null || apiResponses === void 0 ? void 0 : apiResponses[classId]) === null || _a === void 0 ? void 0 : _a.knownSpells)) {
|
||||
return Promise.resolve(apiResponses[classId].knownSpells);
|
||||
}
|
||||
const knownRequest = classKnownSpells(classSpellList.charClass);
|
||||
if (knownRequest) {
|
||||
return knownRequest();
|
||||
}
|
||||
return Promise.resolve(null);
|
||||
});
|
||||
const availableSpellResponses = yield Promise.all(availableSpellRequests);
|
||||
const knownSpellResponses = yield Promise.all(knownSpellRequests);
|
||||
classSpellLists.forEach((classSpellList, index) => {
|
||||
// Dispatch any known spells into the store first
|
||||
const classId = ClassAccessors.getActiveId(classSpellList.charClass);
|
||||
apiResponses[classId] = (apiResponses === null || apiResponses === void 0 ? void 0 : apiResponses[classId]) ? apiResponses === null || apiResponses === void 0 ? void 0 : apiResponses[classId] : {};
|
||||
const knownSpellResponse = knownSpellResponses[index];
|
||||
if (knownSpellResponse) {
|
||||
apiResponses[classId].knownSpells = knownSpellResponse;
|
||||
const spellData = ApiAdapterUtils.getResponseData(knownSpellResponse);
|
||||
if (spellData) {
|
||||
this.dispatch(serviceDataActions.classAlwaysKnownSpellsSet(spellData, classId));
|
||||
}
|
||||
}
|
||||
});
|
||||
// Get new spelllists with properly generated spells
|
||||
classSpellLists = rulesEngineSelectors.getClassSpellLists(this.state);
|
||||
classSpellLists.forEach((classSpellList, index) => {
|
||||
const knownSpellIds = classSpellList.knownSpellIds;
|
||||
const availableSpellResponse = availableSpellResponses[index];
|
||||
const classId = ClassAccessors.getActiveId(classSpellList.charClass);
|
||||
apiResponses[classId] = (apiResponses === null || apiResponses === void 0 ? void 0 : apiResponses[classId]) ? apiResponses === null || apiResponses === void 0 ? void 0 : apiResponses[classId] : {};
|
||||
let availableSpells = [];
|
||||
if (availableSpellResponse) {
|
||||
apiResponses[classId].availableSpells = availableSpellResponse;
|
||||
const spellData = ApiAdapterUtils.getResponseData(availableSpellResponse);
|
||||
const transformed = this.transformLoadedSpells(spellData || []);
|
||||
const filtered = transformed.filter((spell) => !knownSpellIds.includes(SpellDerivers.deriveKnownKey(spell)));
|
||||
availableSpells = this.getSpellManagers(filtered, classId);
|
||||
}
|
||||
const knownSpells = this.getSpellManagers(classSpellList.spells, classId);
|
||||
const activeSpells = this.getSpellManagers(classSpellList.activeSpells, classId);
|
||||
const availableSpellDefinitions = [...availableSpells, ...knownSpells, ...activeSpells]
|
||||
.map((spellManager) => spellManager.getDefinition())
|
||||
.filter(TypeScriptUtils.isNotNullOrUndefined);
|
||||
const activeSourceCategories = rulesEngineSelectors.getActiveSourceCategories(this.state);
|
||||
const sourceCategories = SourceUtils.getSimpleSourceCategoriesData(availableSpellDefinitions, ruleData, activeSourceCategories);
|
||||
classSpells[classId] = {
|
||||
availableSpells,
|
||||
knownSpells,
|
||||
activeSpells,
|
||||
sourceCategories,
|
||||
};
|
||||
});
|
||||
spellShoppe = classSpells;
|
||||
return spellShoppe;
|
||||
}
|
||||
else {
|
||||
return spellShoppe;
|
||||
}
|
||||
});
|
||||
}
|
||||
getSpellClasses() {
|
||||
return rulesEngineSelectors.getSpellClasses(this.state);
|
||||
}
|
||||
getClassSpellLists() {
|
||||
return rulesEngineSelectors.getClassSpellLists(this.state);
|
||||
}
|
||||
getCharClassByActiveId(activeId) {
|
||||
var _a;
|
||||
const spellClasses = this.getSpellClasses();
|
||||
return (_a = spellClasses.find((charClass) => charClass.activeId === activeId)) !== null && _a !== void 0 ? _a : null;
|
||||
}
|
||||
getClassSpellInfoByActiveId(activeId) {
|
||||
var _a;
|
||||
const spellClasses = this.getClassSpellLists();
|
||||
return (_a = spellClasses.find((classSpellInfo) => classSpellInfo.charClass.activeId === activeId)) !== null && _a !== void 0 ? _a : null;
|
||||
}
|
||||
}
|
||||
SpellsManager.getUsedSpellSlotLevelAmount = (changeAmount, spellSlots, castLevel) => {
|
||||
const foundSlotLevel = spellSlots.find((spellSlot) => spellSlot.level === castLevel);
|
||||
if (!foundSlotLevel) {
|
||||
return null;
|
||||
}
|
||||
const usedAmount = foundSlotLevel.used + changeAmount;
|
||||
const maxAmount = foundSlotLevel.available;
|
||||
return HelperUtils.clampInt(usedAmount, 0, maxAmount);
|
||||
};
|
||||
Reference in New Issue
Block a user