krugd/dndbeyond_src
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Grabbed dndbeyond's source code

Browse Source 
```
~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js
```
This commit is contained in:
David Kruger
2025-05-28 11:50:03 -07:00
commit 8df9031d27
3592 changed files with 319051 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ddb_main/packages/rules-engine/es/engine/Prerequisite/accessors.js
+87
View File
@@ -0,0 +1,87 @@
/**
*
* @param prerequisite
*/
export function getType(prerequisite) {
return prerequisite.type;
}
/**
*
* @param prerequisite
*/
export function getValue(prerequisite) {
return prerequisite.value;
}
/**
*
* @param prerequisite
*/
export function getEntityId(prerequisite) {
return prerequisite.entityId;
}
/**
*
* @param prerequisite
*/
export function getEntityTypeId(prerequisite) {
return prerequisite.entityTypeId;
}
/**
*
* @param prerequisite
*/
export function getEntityKey(prerequisite) {
return `${getEntityId(prerequisite)}-${getEntityTypeId(prerequisite)}`;
}
/**
*
* @param prerequisite
*/
export function getFriendlySubtypeName(prerequisite) {
return prerequisite.friendlySubTypeName;
}
/**
*
* @param prerequisite
*/
export function getFriendlyTypeName(prerequisite) {
return prerequisite.friendlyTypeName;
}
/**
*
* @param prerequisiteGroup
*/
export function getPrerequisites(prerequisiteGroup) {
var _a;
return (_a = prerequisiteGroup.prerequisiteMappings) !== null && _a !== void 0 ? _a : [];
}
/**
*
* @param prerequisiteGroup
*/
export function getGroupDescription(prerequisiteGroup) {
return prerequisiteGroup.description;
}
/**
*
* @param prerequisiteGrouping
*/
export function getDescription(prerequisiteGrouping) {
return prerequisiteGrouping
.filter((prerequisiteGroup) => !getHidePrerequisite(prerequisiteGroup))
.map((prerequisiteGroup) => getGroupDescription(prerequisiteGroup))
.join(' ');
}
/**
*
* @param prerequisite
*/
export function getSubType(prerequisite) {
return prerequisite.subType;
}
/**
* @param prerequisite
*/
export function getHidePrerequisite(prerequisite) {
return prerequisite.hidePrerequisite;
}
ddb_main/packages/rules-engine/es/engine/Prerequisite/constants.js
+17
View File
@@ -0,0 +1,17 @@
export var PrerequisiteTypeEnum;
(function (PrerequisiteTypeEnum) {
PrerequisiteTypeEnum["ABILITY_SCORE"] = "ability-score";
PrerequisiteTypeEnum["CUSTOM_VALUE"] = "custom-value";
PrerequisiteTypeEnum["PROFICIENCY"] = "proficiency";
PrerequisiteTypeEnum["SPECIES"] = "species";
PrerequisiteTypeEnum["SIZE"] = "size";
PrerequisiteTypeEnum["SPECIES_OPTION"] = "species-option";
PrerequisiteTypeEnum["LEVEL"] = "level";
PrerequisiteTypeEnum["CLASS"] = "class";
PrerequisiteTypeEnum["FEAT"] = "feat";
PrerequisiteTypeEnum["CLASS_FEATURE"] = "class-feature";
})(PrerequisiteTypeEnum || (PrerequisiteTypeEnum = {}));
export var PrerequisiteSubTypeEnum;
(function (PrerequisiteSubTypeEnum) {
PrerequisiteSubTypeEnum["CHARACTER_LEVEL"] = "character-level";
})(PrerequisiteSubTypeEnum || (PrerequisiteSubTypeEnum = {}));
ddb_main/packages/rules-engine/es/engine/Prerequisite/generators.js
+11
View File
@@ -0,0 +1,11 @@
export function generatePrerequisiteData(race, proficiencyLookup, abilityLookup, characterLevel, baseClassLookup, featLookup, classFeatureLookup) {
return {
race,
proficiencyLookup,
abilityLookup,
characterLevel,
baseClassLookup,
featLookup,
classFeatureLookup,
};
}
ddb_main/packages/rules-engine/es/engine/Prerequisite/index.js
+10
View File
@@ -0,0 +1,10 @@
import * as PrerequisiteAccessors from './accessors';
import * as PrerequisiteConstants from './constants';
import * as PrerequisiteGenerators from './generators';
import * as PrerequisiteTypings from './typings';
import * as PrerequisiteUtils from './utils';
import * as PrerequisiteValidators from './validators';
export * from './constants';
export * from './typings';
export { PrerequisiteAccessors, PrerequisiteGenerators, PrerequisiteUtils, PrerequisiteValidators };
export default Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, PrerequisiteAccessors), PrerequisiteConstants), PrerequisiteGenerators), PrerequisiteTypings), PrerequisiteUtils), PrerequisiteValidators);
ddb_main/packages/rules-engine/es/engine/Prerequisite/utils.js
+211
View File
@@ -0,0 +1,211 @@
import { AbilityAccessors } from '../Ability';
import { FormatUtils } from '../Format';
import { getEntityId, getFriendlySubtypeName, getPrerequisites, getSubType, getType, getValue } from './accessors';
import { PrerequisiteSubTypeEnum, PrerequisiteTypeEnum } from './constants';
import { validatePrerequisite } from './validators';
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailure(prerequisite, prerequisiteData) {
switch (getType(prerequisite)) {
case PrerequisiteTypeEnum.ABILITY_SCORE:
return getPrerequisiteFailureAbilityScore(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.PROFICIENCY:
return getPrerequisiteFailureProficiency(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.SPECIES:
return getPrerequisiteFailureRace(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.SIZE:
return getPrerequisiteFailureSize(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.SPECIES_OPTION:
return getPrerequisiteFailureSubrace(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.LEVEL:
return getPrerequisiteFailureLevel(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.CLASS:
return getPrerequisiteFailureClass(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.FEAT:
return getPrerequisiteFailureFeat(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.CLASS_FEATURE:
return getPrerequisiteFailureClassFeature(prerequisite);
case PrerequisiteTypeEnum.CUSTOM_VALUE:
default:
// not defined
}
return null;
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureLevel(prerequisite, prerequisiteData) {
let requiredDescription = '';
switch (getSubType(prerequisite)) {
case PrerequisiteSubTypeEnum.CHARACTER_LEVEL:
let value = getValue(prerequisite);
value = value ? value : 1;
requiredDescription = `${FormatUtils.ordinalize(value)} Level`;
break;
default:
// not implemented
}
return {
type: PrerequisiteTypeEnum.LEVEL,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription,
},
};
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureAbilityScore(prerequisite, prerequisiteData) {
let statKey = '';
let currentAmount = null;
const entityId = getEntityId(prerequisite);
if (entityId !== null) {
const ability = prerequisiteData.abilityLookup[entityId];
statKey = AbilityAccessors.getStatKey(ability);
currentAmount = AbilityAccessors.getScore(ability);
}
return {
type: PrerequisiteTypeEnum.ABILITY_SCORE,
data: {
statKey,
currentAmount,
requiredValue: getValue(prerequisite),
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: `${getFriendlySubtypeName(prerequisite)} ${getValue(prerequisite)}+`,
},
};
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureProficiency(prerequisite, prerequisiteData) {
return {
type: PrerequisiteTypeEnum.PROFICIENCY,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: `${getFriendlySubtypeName(prerequisite)} Proficiency`,
},
};
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureRace(prerequisite, prerequisiteData) {
return {
type: PrerequisiteTypeEnum.SPECIES,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: getFriendlySubtypeName(prerequisite),
},
};
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureSubrace(prerequisite, prerequisiteData) {
return {
type: PrerequisiteTypeEnum.SPECIES_OPTION,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: getFriendlySubtypeName(prerequisite),
},
};
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureSize(prerequisite, prerequisiteData) {
return {
type: PrerequisiteTypeEnum.SIZE,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: `${getFriendlySubtypeName(prerequisite)} Size`,
},
};
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureClass(prerequisite, prerequisiteData) {
return {
type: PrerequisiteTypeEnum.CLASS,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: `${getFriendlySubtypeName(prerequisite)}`,
},
};
}
export const getPrerequisiteFailureClassFeature = (prerequisite) => ({
type: PrerequisiteTypeEnum.CLASS_FEATURE,
data: {
requiredChoice: prerequisite.friendlySubTypeName,
requiredDescription: prerequisite.friendlySubTypeName,
},
});
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function getPrerequisiteFailureFeat(prerequisite, prerequisiteData) {
return {
type: PrerequisiteTypeEnum.FEAT,
data: {
requiredChoice: getFriendlySubtypeName(prerequisite),
requiredDescription: `${getFriendlySubtypeName(prerequisite)}`,
},
};
}
/**
*
* @param prerequisiteGrouping
* @param prerequisiteData
*/
export function getPrerequisiteGroupingFailures(prerequisiteGrouping, prerequisiteData) {
const groupingFailures = [];
if (prerequisiteGrouping !== null) {
prerequisiteGrouping.forEach((prerequisiteGroup) => {
const groupFailures = [];
const prerequisites = getPrerequisites(prerequisiteGroup);
prerequisites.forEach((prerequisite) => {
if (!validatePrerequisite(prerequisite, prerequisiteData)) {
const prereqFailure = getPrerequisiteFailure(prerequisite, prerequisiteData);
if (prereqFailure) {
groupFailures.push(prereqFailure);
}
}
});
groupingFailures.push(groupFailures);
});
}
return groupingFailures.filter((group) => group.length);
}
/**
* Get all prerequisites of a specific type
* @param type
* @param prereqGroups
*/
export function getPrereqsByType(type, prereqGroups) {
return prereqGroups.reduce((acc, prereq) => {
const featMappings = getPrerequisites(prereq).filter((mapping) => getType(mapping) === type);
return acc.concat(featMappings);
}, []);
}
ddb_main/packages/rules-engine/es/engine/Prerequisite/validators.js
+210
View File
@@ -0,0 +1,210 @@
import { AbilityAccessors } from '../Ability';
import { ClassAccessors } from '../Class';
import { HelperUtils } from '../Helper';
import { RaceAccessors } from '../Race';
import { getEntityId, getEntityKey, getEntityTypeId, getPrerequisites, getSubType, getType, getValue, } from './accessors';
import { PrerequisiteSubTypeEnum, PrerequisiteTypeEnum } from './constants';
import { getPrereqsByType } from './utils';
/**
*
* @param prerequisiteGrouping
* @param prerequisiteData
*/
export function validatePrerequisiteGrouping(prerequisiteGrouping, prerequisiteData) {
if (prerequisiteGrouping === null) {
return true;
}
let isValid = !prerequisiteGrouping.length;
prerequisiteGrouping.forEach((prerequisiteGroup) => {
if (isValid) {
return;
}
let meetsGroupPrereqs = true;
const prerequisites = getPrerequisites(prerequisiteGroup);
prerequisites.forEach((prerequisite) => {
if (!meetsGroupPrereqs) {
return;
}
meetsGroupPrereqs = validatePrerequisite(prerequisite, prerequisiteData);
});
isValid = isValid || meetsGroupPrereqs;
});
return isValid;
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisite(prerequisite, prerequisiteData) {
switch (getType(prerequisite)) {
case PrerequisiteTypeEnum.ABILITY_SCORE:
return validatePrerequisiteAbilityScore(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.PROFICIENCY:
return validatePrerequisiteProficiency(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.SPECIES:
return validatePrerequisiteRace(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.SPECIES_OPTION:
return validatePrerequisiteSubrace(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.SIZE:
return validatePrerequisiteSize(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.LEVEL:
return validatePrerequisiteLevel(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.CLASS:
return validatePrerequisiteClass(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.FEAT:
return validatePrerequisiteFeat(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.CLASS_FEATURE:
return validatePrerequisiteClassFeature(prerequisite, prerequisiteData);
case PrerequisiteTypeEnum.CUSTOM_VALUE:
default:
// not defined
}
return true;
}
export function validatePrerequisiteClassFeature(prerequisite, prerequisiteData) {
if (!prerequisite.entityId)
return true;
return Object.prototype.hasOwnProperty.call(prerequisiteData.classFeatureLookup, prerequisite.entityId);
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteLevel(prerequisite, prerequisiteData) {
switch (getSubType(prerequisite)) {
case PrerequisiteSubTypeEnum.CHARACTER_LEVEL:
const value = getValue(prerequisite);
return prerequisiteData.characterLevel >= (value ? value : 0);
default:
// not implemented
}
return true;
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteAbilityScore(prerequisite, prerequisiteData) {
const entityId = getEntityId(prerequisite);
if (entityId === null) {
return true;
}
const ability = prerequisiteData.abilityLookup[entityId];
const abilityScore = AbilityAccessors.getScore(ability);
if (abilityScore === null) {
return true;
}
const value = getValue(prerequisite);
if (value === null) {
return true;
}
return abilityScore >= value;
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteProficiency(prerequisite, prerequisiteData) {
return prerequisiteData.proficiencyLookup.hasOwnProperty(getEntityKey(prerequisite));
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteRace(prerequisite, prerequisiteData) {
if (!prerequisiteData.race) {
return true;
}
// check if race is a base race
if (RaceAccessors.getBaseRaceId(prerequisiteData.race) === getEntityId(prerequisite) &&
RaceAccessors.getBaseRaceTypeId(prerequisiteData.race) === getEntityTypeId(prerequisite)) {
return true;
}
// check if race is specific race
return validatePrerequisiteEntityRace(prerequisite, prerequisiteData);
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteSubrace(prerequisite, prerequisiteData) {
if (!prerequisiteData.race) {
return true;
}
// check if race is specific race
return validatePrerequisiteEntityRace(prerequisite, prerequisiteData);
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
function validatePrerequisiteEntityRace(prerequisite, prerequisiteData) {
if (!prerequisiteData.race) {
return true;
}
return (RaceAccessors.getEntityRaceId(prerequisiteData.race) === getEntityId(prerequisite) &&
RaceAccessors.getEntityRaceTypeId(prerequisiteData.race) === getEntityTypeId(prerequisite));
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteSize(prerequisite, prerequisiteData) {
if (!prerequisiteData.race) {
return true;
}
const sizeInfo = RaceAccessors.getSizeInfo(prerequisiteData.race);
if (!sizeInfo) {
return true;
}
return sizeInfo.id === getEntityId(prerequisite) && sizeInfo.entityTypeId === getEntityTypeId(prerequisite);
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteClass(prerequisite, prerequisiteData) {
const entityId = getEntityId(prerequisite);
if (entityId === null) {
return true;
}
return Object.values(prerequisiteData.baseClassLookup).some((charClass) => ClassAccessors.getId(charClass) === entityId);
}
/**
* @param prerequisiteGrouping
* @param prerequisiteData
*/
export function validatePrerequisiteGroupingFeat(prerequisiteGrouping, prerequisiteData) {
if (prerequisiteGrouping === null) {
return true;
}
const mappings = getPrereqsByType(PrerequisiteTypeEnum.FEAT, prerequisiteGrouping);
let isValid = true;
mappings.forEach((prerequisite) => {
if (!validatePrerequisiteFeat(prerequisite, prerequisiteData)) {
isValid = false;
}
});
return isValid;
}
/**
*
* @param prerequisite
* @param prerequisiteData
*/
export function validatePrerequisiteFeat(prerequisite, prerequisiteData) {
const entityId = getEntityId(prerequisite);
if (entityId === null) {
return true;
}
return !!HelperUtils.lookupDataOrFallback(prerequisiteData.featLookup, entityId);
}