David Kruger
8df9031d27
``` ~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js ```
338 lines
16 KiB
JavaScript
338 lines
16 KiB
JavaScript
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 { groupBy } from 'lodash';
|
|
import * as ApiAdapterUtils from "../apiAdapter/utils";
|
|
import { CreatureRuleUtils } from "../engine/CreatureRule";
|
|
import { DefinitionTypeEnum } from "../engine/Definition";
|
|
import { DefinitionPoolUtils } from "../engine/DefinitionPool";
|
|
import { TypeScriptUtils } from "../utils";
|
|
import { characterActions, serviceDataActions } from '../actions';
|
|
import { CreatureAccessors, CreatureGroupFlagEnum, CreatureSimulators, DB_STRING_GROUP_SIDEKICK, DB_STRING_TAG_SIDEKICK, } from '../engine/Creature';
|
|
import { ExtraAccessors, ExtraGenerators, ExtraUtils, HACK_VEHICLE_GROUP_ID, } from '../engine/Extra';
|
|
import { RuleDataGenerators, RuleDataUtils } from '../engine/RuleData';
|
|
import { VehicleSimulators } from '../engine/Vehicle';
|
|
import { apiCreatorSelectors, rulesEngineSelectors, serviceDataSelectors } from '../selectors';
|
|
import { getExtraManager } from './ExtraManager';
|
|
import { MessageManager } from './MessageManager';
|
|
export class ExtrasManager extends MessageManager {
|
|
constructor(params) {
|
|
super(params);
|
|
//Shoppe
|
|
//TODO optimize to not make api calls when updates are called (see FeatShoppe)
|
|
this.getExtrasShoppe = ({ groupId, onSuccess, additionalConfig, }) => __awaiter(this, void 0, void 0, function* () {
|
|
var _a;
|
|
const loadAvailableMonsters = apiCreatorSelectors.makeLoadAvailableMonsters(this.state);
|
|
const loadAvailableVehicles = apiCreatorSelectors.makeLoadAvailableVehicles(this.state);
|
|
const monsterResponse = (yield loadAvailableMonsters(additionalConfig));
|
|
const vehicleResponse = yield loadAvailableVehicles(additionalConfig);
|
|
// forced to do any because of stupid typings - pulled from ExtraManagePane - fix it eventually?
|
|
const monsterResponseDefinitions = (_a = ApiAdapterUtils.getResponseData(monsterResponse)) !== null && _a !== void 0 ? _a : [];
|
|
const vehicleResponseDefinitions = ApiAdapterUtils.getResponseData(vehicleResponse);
|
|
const transformedCreatures = groupId !== null ? this.transformLoadedCreatures(monsterResponseDefinitions, groupId) : [];
|
|
if (vehicleResponseDefinitions !== null && vehicleResponseDefinitions.definitionData.length > 0) {
|
|
this.dispatch(serviceDataActions.definitionPoolAdd(vehicleResponseDefinitions.definitionData, vehicleResponseDefinitions.accessTypes));
|
|
}
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
const definitionPool = serviceDataSelectors.getDefinitionPool(this.state);
|
|
const vehicleDefinitions = DefinitionPoolUtils.getTypedDefinitionList(DefinitionTypeEnum.VEHICLE, definitionPool);
|
|
let vehicles = vehicleDefinitions
|
|
.map((vehicleDef) => VehicleSimulators.simulateVehicle(vehicleDef, definitionPool, ruleData))
|
|
.filter(TypeScriptUtils.isNotNullOrUndefined)
|
|
.map((vehicle) => this.generateVehicleExtraManager(vehicle));
|
|
//TODO should this be something we store somehwere other than the shoppe?
|
|
const creatureDefinitionLookup = monsterResponseDefinitions.reduce((lookup, definition) => {
|
|
const id = definition.id;
|
|
lookup[id] = definition;
|
|
return lookup;
|
|
}, {});
|
|
const shoppeState = {
|
|
creatureDefinitionLookup,
|
|
creatureDefinitions: monsterResponseDefinitions,
|
|
creatures: transformedCreatures.map((creature) => this.generateCreatureExtraManager(creature)),
|
|
vehicles,
|
|
};
|
|
onSuccess(shoppeState);
|
|
return shoppeState;
|
|
});
|
|
//Update Shoppe with a selected group
|
|
this.updateExtrasShoppe = ({ currentShoppe, groupId, onSuccess, }) => {
|
|
const transformedCreatures = groupId !== null ? this.transformLoadedCreatures(currentShoppe.creatureDefinitions, groupId) : [];
|
|
const newShoppeState = Object.assign(Object.assign({}, currentShoppe), { creatures: transformedCreatures.map((creature) => this.generateCreatureExtraManager(creature)) });
|
|
onSuccess(newShoppeState);
|
|
return newShoppeState;
|
|
};
|
|
this.transformLoadedCreatures = (creatureDefinitions, groupId) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
if (groupId === null) {
|
|
return [];
|
|
}
|
|
return creatureDefinitions.map((definition) => CreatureSimulators.simulateCreature(definition, groupId, ruleData));
|
|
};
|
|
//TODO this could use some cleanup?
|
|
this.getCreaturesFilteredByRules = (creatures, creatureDefinitionLookup, groupId) => {
|
|
const creatureRules = rulesEngineSelectors.getCreatureRules(this.state);
|
|
const creatureDatas = creatures.map((manager) => manager.simulateExtraData(groupId, creatureDefinitionLookup));
|
|
let groupCreatures = this.getCreaturesFilteredByGroupFlags(creatureDatas, groupId);
|
|
let filteredCreatures = [];
|
|
let unmatchedCreatures = [...groupCreatures];
|
|
let hasRules = false;
|
|
creatureRules.forEach((rule) => {
|
|
if (groupId === null || !CreatureRuleUtils.isRuleGroup(rule, groupId)) {
|
|
return;
|
|
}
|
|
let testableCreatures = [...unmatchedCreatures];
|
|
unmatchedCreatures = [];
|
|
testableCreatures.forEach((creature) => {
|
|
if (CreatureRuleUtils.isValidCreature(creature, rule)) {
|
|
filteredCreatures.push(creature);
|
|
}
|
|
else {
|
|
unmatchedCreatures.push(creature);
|
|
}
|
|
});
|
|
hasRules = true;
|
|
});
|
|
return hasRules
|
|
? filteredCreatures.map((creature) => this.generateCreatureExtraManager(creature))
|
|
: groupCreatures.map((creature) => this.generateCreatureExtraManager(creature));
|
|
};
|
|
//Handlers
|
|
this.handleAcceptOnSuccess = (onSuccess) => {
|
|
return () => {
|
|
typeof onSuccess === 'function' && onSuccess();
|
|
};
|
|
};
|
|
this.handleRejectOnError = (onError) => {
|
|
return () => {
|
|
typeof onError === 'function' && onError();
|
|
};
|
|
};
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.handleAdd = ({ extra, quantity, selectedGroup }, onSuccess, onError) => {
|
|
var _a;
|
|
const extraId = ExtraAccessors.getId(extra);
|
|
if (ExtraUtils.isCreature(extra)) {
|
|
if (selectedGroup && typeof extraId === 'number') {
|
|
let names = [];
|
|
if (quantity > 1) {
|
|
for (let i = 1; i <= quantity; i++) {
|
|
names.push(`${ExtraAccessors.getName(extra)} ${i}`);
|
|
}
|
|
}
|
|
else {
|
|
names.push(null);
|
|
}
|
|
this.dispatch(characterActions.creatureCreate(selectedGroup, extraId, names, this.handleAcceptOnSuccess(onSuccess)));
|
|
}
|
|
}
|
|
else if (ExtraUtils.isVehicle(extra)) {
|
|
if (typeof extraId === 'string') {
|
|
this.dispatch(serviceDataActions.vehicleMappingCreate(extraId, (_a = ExtraAccessors.getName(extra)) !== null && _a !== void 0 ? _a : 'Vehicle', this.handleAcceptOnSuccess(onSuccess)));
|
|
}
|
|
}
|
|
};
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.handleRemove = ({ extra }, onSuccess, onError) => {
|
|
const mappingId = ExtraAccessors.getMappingId(extra);
|
|
if (ExtraUtils.isCreature(extra)) {
|
|
this.dispatch(characterActions.creatureRemove(mappingId));
|
|
}
|
|
else if (ExtraUtils.isVehicle(extra)) {
|
|
this.dispatch(serviceDataActions.vehicleMappingRemove(mappingId));
|
|
}
|
|
};
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.handleSetActive = ({ extra, isActive }, onSuccess, onError) => {
|
|
this.dispatch(characterActions.creatureActiveSet(ExtraAccessors.getMappingId(extra), isActive));
|
|
};
|
|
//Getters?
|
|
this.getCharacterExtras = () => {
|
|
return rulesEngineSelectors.getExtras(this.state);
|
|
};
|
|
this.getCharacterExtraManagers = () => {
|
|
return this.getCharacterExtras().map((extra) => getExtraManager(Object.assign(Object.assign({}, this.params), { extra })));
|
|
};
|
|
//START HERE!!!!!!!!!!!! Extras.tsx - manager :)
|
|
// getCharacterVehicles = () => {
|
|
// }
|
|
// getAllVehicles = () => {
|
|
// }
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.getExtraData = (extra) => {
|
|
if (ExtraUtils.isCreature(extra)) {
|
|
const creatureLookup = rulesEngineSelectors.getCreatureLookup(this.state);
|
|
return ExtraUtils.getTypedExtra(extra, creatureLookup);
|
|
}
|
|
else if (ExtraUtils.isVehicle(extra)) {
|
|
const vehicleLookup = rulesEngineSelectors.getVehicleLookup(this.state);
|
|
return ExtraUtils.getTypedExtra(extra, vehicleLookup);
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
};
|
|
//UTILS
|
|
//should this be in generators?
|
|
this.generateExtrasGroupsManagers = (extraManagers) => {
|
|
return groupBy(extraManagers, (extra) => extra.getGroupId());
|
|
};
|
|
//TODO these are probably managers - or use other filter utils
|
|
this.getExtrasGroups = (filteredExtras) => {
|
|
const extras = filteredExtras !== null && filteredExtras !== void 0 ? filteredExtras : this.getCharacterExtraManagers();
|
|
return this.generateExtrasGroupsManagers(extras);
|
|
};
|
|
this.getGroupInfosForExtras = (filteredExtras) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
const extraManagers = filteredExtras !== null && filteredExtras !== void 0 ? filteredExtras : this.getCharacterExtraManagers();
|
|
const extras = extraManagers.map((manager) => manager.extra);
|
|
return ExtraGenerators.generateCurrentExtraGroupInfos(extras, ruleData);
|
|
};
|
|
/**
|
|
*
|
|
* @deprecated for getGroupInfosForExtras
|
|
*/
|
|
this.getCurrentGroupInfos = (filteredExtras) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
const extras = filteredExtras !== null && filteredExtras !== void 0 ? filteredExtras : this.getCharacterExtras();
|
|
return ExtraGenerators.generateCurrentExtraGroupInfos(extras, ruleData);
|
|
};
|
|
this.getGroupOptions = () => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
let creatureGroupOptions = RuleDataGenerators.getCreatureGroupGroupedOptions(ruleData);
|
|
return [
|
|
{
|
|
optGroupLabel: 'Creature',
|
|
options: creatureGroupOptions,
|
|
},
|
|
{
|
|
optGroupLabel: 'Object',
|
|
options: [
|
|
{
|
|
label: 'Vehicle',
|
|
value: HACK_VEHICLE_GROUP_ID,
|
|
},
|
|
],
|
|
},
|
|
];
|
|
};
|
|
this.hack__isSidekickGroup = (groupId) => {
|
|
const creatureGroupInfo = this.getCreatureGroupInfo(groupId);
|
|
return !!creatureGroupInfo && creatureGroupInfo.name === DB_STRING_GROUP_SIDEKICK;
|
|
};
|
|
//TODO move to CreatureManager or ExtraManager
|
|
this.getCreatureGroupInfo = (groupId) => {
|
|
if (groupId === null) {
|
|
return null;
|
|
}
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
return RuleDataUtils.getCreatureGroupInfo(groupId, ruleData);
|
|
};
|
|
//TODO move to CreatureManager or ExtraManager
|
|
this.getCreaturesFilteredByGroupFlags = (creatures, groupId) => {
|
|
if (groupId === null) {
|
|
return creatures;
|
|
}
|
|
let groupInfo = this.getCreatureGroupInfo(groupId);
|
|
if (groupInfo && groupInfo.flagInfoLookup[CreatureGroupFlagEnum.CANNOT_BE_SWARM]) {
|
|
creatures = creatures.filter((creature) => !CreatureAccessors.isSwarm(creature));
|
|
}
|
|
if (this.hack__isSidekickGroup(groupId)) {
|
|
creatures = creatures.filter((creature) => CreatureAccessors.getTags(creature).includes(DB_STRING_TAG_SIDEKICK));
|
|
}
|
|
return creatures;
|
|
};
|
|
this.getChallengeOptions = () => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
return RuleDataGenerators.getChallengeOptions(ruleData);
|
|
};
|
|
this.generateVehicleExtraManager = (vehicle) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
return getExtraManager(Object.assign(Object.assign({}, this.params), { extra: ExtraGenerators.generateVehicleExtra(vehicle, ruleData) }));
|
|
};
|
|
this.generateCreatureExtraManager = (creature) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
return getExtraManager(Object.assign(Object.assign({}, this.params), { extra: ExtraGenerators.generateCreatureExtra(creature, ruleData) }));
|
|
};
|
|
/**
|
|
* @deprecated - for VehicleManager
|
|
*/
|
|
this.generateVehicleMeta = (vehicle) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
return ExtraGenerators.generateVehicleMeta(vehicle, ruleData);
|
|
};
|
|
this.generateCreatureMeta = (creature) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
return ExtraGenerators.generateCreatureMeta(creature, ruleData);
|
|
};
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.getSourceNames = (extra) => {
|
|
const ruleData = rulesEngineSelectors.getRuleData(this.state);
|
|
const sources = this.getSources(extra);
|
|
return sources
|
|
.map((sourceMapping) => RuleDataUtils.getSourceDataInfo(sourceMapping.sourceId, ruleData))
|
|
.filter(TypeScriptUtils.isNotNullOrUndefined)
|
|
.map((sourceDataInfo) => sourceDataInfo.description)
|
|
.filter(TypeScriptUtils.isNotNullOrUndefined);
|
|
};
|
|
//Accessors
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.isCreature = (extra) => ExtraUtils.isCreature(extra);
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.isVehicle = (extra) => ExtraUtils.isVehicle(extra);
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.getName = (extra) => ExtraAccessors.getName(extra);
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.getSources = (extra) => ExtraAccessors.getSources(extra);
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.isHomebrew = (extra) => ExtraAccessors.isHomebrew(extra);
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.getMetaText = (extra) => ExtraAccessors.getMetaText(extra);
|
|
/**
|
|
* @deprecated
|
|
* should use ExtraManager
|
|
*/
|
|
this.getUniqueKey = (extra) => ExtraAccessors.getUniqueKey(extra);
|
|
this.params = params;
|
|
}
|
|
}
|