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:
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,4 @@
|
||||
export var RuleDataTypeEnum;
|
||||
(function (RuleDataTypeEnum) {
|
||||
RuleDataTypeEnum["VEHICLE"] = "vehicle";
|
||||
})(RuleDataTypeEnum || (RuleDataTypeEnum = {}));
|
||||
@@ -0,0 +1,51 @@
|
||||
import { getDamageAdjustments, getDiceValues, getLevelProficiencyBonuses, getStatModifiers, getStats, } from './accessors';
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function deriveStatKeyLookup(ruleData) {
|
||||
return getStats(ruleData).reduce((acc, stat) => {
|
||||
acc[stat.id] = stat.key === null ? '' : stat.key.toLowerCase();
|
||||
return acc;
|
||||
}, {});
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param adjustmentType
|
||||
* @param ruleData
|
||||
*/
|
||||
export function deriveDamageAdjustmentsByType(adjustmentType, ruleData) {
|
||||
return getDamageAdjustments(ruleData).filter((adjustment) => adjustment.type === adjustmentType);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function deriveLevelProficiencyBonusesLookup(ruleData) {
|
||||
return getLevelProficiencyBonuses(ruleData).reduce((acc, item) => {
|
||||
acc[item.level] = item.bonus;
|
||||
return acc;
|
||||
}, {});
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function deriveStatModifiersLookup(ruleData) {
|
||||
return getStatModifiers(ruleData).reduce((acc, item) => {
|
||||
acc[item.value] = item.modifier;
|
||||
return acc;
|
||||
}, {});
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function deriveVersatileDieLookup(ruleData) {
|
||||
return getDiceValues(ruleData).reduce((acc, dieValue) => {
|
||||
const diceValues = getDiceValues(ruleData);
|
||||
const versatileIdx = Math.min(diceValues.length - 1, diceValues.indexOf(dieValue) + 1);
|
||||
acc[dieValue] = diceValues[versatileIdx];
|
||||
return acc;
|
||||
}, {});
|
||||
}
|
||||
@@ -0,0 +1,328 @@
|
||||
import { has, keyBy, orderBy, sortBy } from 'lodash';
|
||||
import { AttackSubtypeEnum } from '../Action';
|
||||
import { ConditionAccessors } from '../Condition';
|
||||
import { DamageAdjustmentTypeEnum, ProficiencyLevelEnum, SourceTypeEnum, } from '../Core';
|
||||
import { FormatUtils } from '../Format';
|
||||
import { RuleDataPoolAccessors } from '../RuleDataPool';
|
||||
import { SourceUtils } from '../Source';
|
||||
import { getAbilitySkills, getActivationTypes, getAdjustmentDataTypes, getAdjustmentTypes, getAlignments, getAoeTypes, getArmor, getArmorTypes, getBasicActions, getChallengeRatings, getComponentTypes, getConditions, getCoverTypes, getCreatureGroupCategories, getCreatureGroupFlags, getCreatureGroups, getCreatureSizes, getCurrencyData, getDamageAdjustments, getDamageTypes, getDiceValues, getEnvironments, getLanguages, getLifestyles, getLimitedUseResetTypes, getMonsterSubTypes, getMonsterTypes, getMovements, getObjectTypes, getRangeTypes, getRules, getSenses, getSourceCategories, getSources, getSpellComponents, getSpellRangeTypes, getStats, getStealthCheckTypes, getTools, getVehicleMovementTypes, getWeaponCategories, getWeaponProperties, getWeapons, } from './accessors';
|
||||
import { RuleDataTypeEnum } from './constants';
|
||||
import { deriveDamageAdjustmentsByType, deriveLevelProficiencyBonusesLookup, deriveStatKeyLookup, deriveStatModifiersLookup, deriveVersatileDieLookup, } from './derivers';
|
||||
import { getCreatureGroupInfo, getProficiencyLevelName, getWeaponCategoryName } from './utils';
|
||||
/**
|
||||
*
|
||||
* @param ruleDataContract
|
||||
* @param ruleDataPool
|
||||
*/
|
||||
export function generateRuleData(ruleDataContract, ruleDataPool) {
|
||||
const ruleDataStageOne = Object.assign(Object.assign({}, ruleDataContract), { vehicleRuleData: RuleDataPoolAccessors.getRuleData(RuleDataTypeEnum.VEHICLE, ruleDataPool) });
|
||||
let sourceData = generateSourceData(ruleDataContract);
|
||||
let sourceCategories = getSourceCategories(ruleDataContract);
|
||||
return Object.assign(Object.assign({}, ruleDataStageOne), { abilitySkillLookup: keyBy(getAbilitySkills(ruleDataContract), 'id'), activationTypesLookup: keyBy(getActivationTypes(ruleDataContract), 'id'), adjustmentDataTypeLookup: keyBy(getAdjustmentDataTypes(ruleDataContract), 'id'), adjustmentTypeLookup: keyBy(getAdjustmentTypes(ruleDataContract), 'id'), alignmentLookup: keyBy(getAlignments(ruleDataContract), 'id'), aoeTypeLookup: keyBy(getAoeTypes(ruleDataContract), 'id'), armorTypeLookup: keyBy(getArmorTypes(ruleDataContract), (armorType) => armorType.id), basicActionLookup: keyBy(getBasicActions(ruleDataContract), 'id'), challengeRatingLookup: keyBy(getChallengeRatings(ruleDataContract), 'id'), componentTypeLookup: keyBy(getComponentTypes(ruleDataStageOne), 'type'), conditionLookup: keyBy(getConditions(ruleDataContract), (condition) => ConditionAccessors.getId(condition)), coverTypeLookup: keyBy(getCoverTypes(ruleDataContract), 'type'), creatureGroupCategoryLookup: keyBy(getCreatureGroupCategories(ruleDataContract), 'id'), creatureGroupFlagLookup: keyBy(getCreatureGroupFlags(ruleDataContract), 'key'), creatureGroupLookup: keyBy(getCreatureGroups(ruleDataContract), 'id'), creatureSizeLookup: keyBy(getCreatureSizes(ruleDataContract), 'id'), currencyDataLookup: keyBy(getCurrencyData(ruleDataContract), 'name'), damageAdjustmentsLookup: keyBy(getDamageAdjustments(ruleDataContract), 'id'), damageTypeLookup: keyBy(getDamageTypes(ruleDataContract), 'id'), environmentLookup: keyBy(getEnvironments(ruleDataContract), 'id'), immunityDamageAdjustments: deriveDamageAdjustmentsByType(DamageAdjustmentTypeEnum.IMMUNITY, ruleDataContract), languageLookup: keyBy(getLanguages(ruleDataContract), 'id'), levelProficiencyBonusesLookup: deriveLevelProficiencyBonusesLookup(ruleDataContract), lifestyleLookup: keyBy(getLifestyles(ruleDataContract), 'id'), limitedUseResetTypeLookup: keyBy(getLimitedUseResetTypes(ruleDataContract), 'id'), monsterSubTypeLookup: keyBy(getMonsterSubTypes(ruleDataContract), 'id'), monsterTypeLookup: keyBy(getMonsterTypes(ruleDataContract), 'id'), movementLookup: keyBy(getMovements(ruleDataContract), 'id'), objectTypeLookup: keyBy(getObjectTypes(ruleDataStageOne), 'type'), rangeTypeLookup: keyBy(getRangeTypes(ruleDataContract), 'id'), resistanceDamageAdjustments: deriveDamageAdjustmentsByType(DamageAdjustmentTypeEnum.RESISTANCE, ruleDataContract), ruleLookup: keyBy(getRules(ruleDataContract), 'name'), senseLookup: keyBy(getSenses(ruleDataContract), 'id'), sourceData, sourceDataLookup: generateSourceDataLookup(sourceData), sourceCategoryLookup: generateSourceCategoryLookup(sourceCategories), spellComponentsLookup: keyBy(getSpellComponents(ruleDataContract), 'id'), spellRangeTypeLookup: keyBy(getSpellRangeTypes(ruleDataContract), 'id'), statModifiersLookup: deriveStatModifiersLookup(ruleDataContract), statsLookup: keyBy(getStats(ruleDataContract), 'id'), statKeyLookup: deriveStatKeyLookup(ruleDataContract), stealthCheckTypeLookup: keyBy(getStealthCheckTypes(ruleDataContract), 'id'), vulnerabilityDamageAdjustments: deriveDamageAdjustmentsByType(DamageAdjustmentTypeEnum.VULNERABILITY, ruleDataContract), vehicleMovementLookup: keyBy(getVehicleMovementTypes(ruleDataStageOne), 'type'), versatileDieLookup: deriveVersatileDieLookup(ruleDataContract), weaponCategoryLookup: keyBy(getWeaponCategories(ruleDataContract), 'id'), weaponLookupByEntityId: keyBy(getWeapons(ruleDataContract), (weapon) => `${weapon.entityTypeId}-${weapon.id}`), weaponPropertyLookup: keyBy(getWeaponProperties(ruleDataContract), (weaponProperty) => weaponProperty.id) });
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function generateSourceData(ruleData) {
|
||||
const sources = getSources(ruleData);
|
||||
const sourceCategories = getSourceCategories(ruleData);
|
||||
return sources.map((data) => {
|
||||
const sourceCategory = sourceCategories.find((cat) => cat.id === data.sourceCategoryId);
|
||||
return Object.assign(Object.assign({}, data), { sourceCategory: sourceCategory ? sourceCategory : null });
|
||||
});
|
||||
}
|
||||
/**
|
||||
* @param sourceData
|
||||
*/
|
||||
export function generateSourceDataLookup(sourceData) {
|
||||
return keyBy(sourceData, 'id');
|
||||
}
|
||||
/**
|
||||
* @param sourceData
|
||||
*/
|
||||
export function generateSourceCategoryLookup(sourceCategories) {
|
||||
return keyBy(sourceCategories, 'id');
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getDamageTypeOptions(ruleData) {
|
||||
return sortBy(getDamageTypes(ruleData), 'name').map((type) => ({
|
||||
label: type.name,
|
||||
value: type.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
* @param useFullname
|
||||
*/
|
||||
export function getStatOptions(ruleData, useFullname = false) {
|
||||
return getStats(ruleData).map((stat) => ({
|
||||
label: useFullname ? stat.name : stat.key,
|
||||
value: stat.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getChallengeOptions(ruleData) {
|
||||
return getChallengeRatings(ruleData).map((challengeRating) => ({
|
||||
label: FormatUtils.renderChallengeRating(challengeRating.value),
|
||||
value: challengeRating.value,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureGroupGroupedOptions(ruleData) {
|
||||
const primaryGroups = [];
|
||||
const otherGroups = [];
|
||||
getCreatureGroups(ruleData).forEach((group) => {
|
||||
const groupInfo = getCreatureGroupInfo(group.id, ruleData);
|
||||
if (groupInfo) {
|
||||
if (groupInfo.isPrimary) {
|
||||
primaryGroups.push(group);
|
||||
}
|
||||
else {
|
||||
otherGroups.push(group);
|
||||
}
|
||||
}
|
||||
});
|
||||
const options = [
|
||||
...orderBy(primaryGroups.map((group) => ({
|
||||
label: group.name,
|
||||
value: group.id,
|
||||
})), 'label'),
|
||||
...otherGroups.map((group) => ({
|
||||
label: group.name,
|
||||
value: group.id,
|
||||
})),
|
||||
];
|
||||
return options;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getMonsterTypeOptions(ruleData) {
|
||||
return getMonsterTypes(ruleData).map((monsterType) => ({
|
||||
label: monsterType.name,
|
||||
value: monsterType.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureSizeOptions(ruleData) {
|
||||
return getCreatureSizes(ruleData).map((size) => ({
|
||||
label: size.name,
|
||||
value: size.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
* @param includeNonCharacterAlignments
|
||||
*/
|
||||
export function getAlignmentOptions(ruleData, includeNonCharacterAlignments = false) {
|
||||
const options = getAlignments(ruleData)
|
||||
.filter((alignment) => {
|
||||
if (includeNonCharacterAlignments && !alignment.availableToCharacter) {
|
||||
return true;
|
||||
}
|
||||
return alignment.availableToCharacter;
|
||||
})
|
||||
.map((alignment) => ({
|
||||
label: alignment.name,
|
||||
value: alignment.id,
|
||||
}));
|
||||
return orderBy(options, 'label');
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureGroupOptions(ruleData) {
|
||||
const options = getCreatureGroups(ruleData).map((group) => ({
|
||||
label: group.name,
|
||||
value: group.id,
|
||||
}));
|
||||
return orderBy(options, 'label');
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAttackRangeTypeOptions(ruleData) {
|
||||
return getRangeTypes(ruleData).map((type) => ({
|
||||
label: type.name,
|
||||
value: type.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getDieTypeOptions(ruleData) {
|
||||
return getDiceValues(ruleData).map((dieValue) => ({
|
||||
label: FormatUtils.renderLocaleNumber(dieValue),
|
||||
value: dieValue,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getActivationTypeOptions(ruleData) {
|
||||
return getActivationTypes(ruleData).map((activationType) => ({
|
||||
label: activationType.name,
|
||||
value: activationType.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSpellRangeTypeOptions(ruleData) {
|
||||
return getSpellRangeTypes(ruleData).map((spellRangeType) => ({
|
||||
label: spellRangeType.name,
|
||||
value: spellRangeType.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAoeTypeOptions(ruleData) {
|
||||
return getAoeTypes(ruleData).map((aoeType) => ({
|
||||
label: aoeType.name,
|
||||
value: aoeType.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAttackSubtypeOptions(ruleData) {
|
||||
return [
|
||||
{
|
||||
label: 'Natural',
|
||||
value: AttackSubtypeEnum.NATURAL,
|
||||
},
|
||||
{
|
||||
label: 'Unarmed Strike',
|
||||
value: AttackSubtypeEnum.UNARMED,
|
||||
},
|
||||
];
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getProficiencyLevelOptions(ruleData) {
|
||||
const levels = [
|
||||
ProficiencyLevelEnum.NONE,
|
||||
ProficiencyLevelEnum.HALF,
|
||||
ProficiencyLevelEnum.FULL,
|
||||
ProficiencyLevelEnum.EXPERT,
|
||||
];
|
||||
return levels.map((level) => ({
|
||||
label: getProficiencyLevelName(level),
|
||||
value: level,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
* @param excludeIds
|
||||
*/
|
||||
export function getArmorOptions(ruleData, excludeIds = []) {
|
||||
const filteredArmor = getArmor(ruleData).filter((item) => !excludeIds.includes(item.id));
|
||||
const sortedArmor = orderBy(filteredArmor, 'name');
|
||||
return sortedArmor.map((item) => ({
|
||||
label: item.name,
|
||||
value: item.id,
|
||||
}));
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
* @param excludeIds
|
||||
*/
|
||||
export function getWeaponOptions(ruleData, excludeIds = []) {
|
||||
const filteredWeapons = getWeapons(ruleData).filter((item) => !excludeIds.includes(item.id));
|
||||
return getWeaponCategories(ruleData).map((category) => {
|
||||
const categoryWeapons = filteredWeapons.filter((weapon) => weapon.categoryId === category.id);
|
||||
const orderedWeapons = orderBy(categoryWeapons, 'name');
|
||||
return {
|
||||
optGroupLabel: getWeaponCategoryName(category.id, ruleData),
|
||||
options: orderedWeapons.map((weapon) => ({
|
||||
label: weapon.name,
|
||||
value: weapon.id,
|
||||
})),
|
||||
};
|
||||
});
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
* @param excludeIds
|
||||
*/
|
||||
export function getLanguageOptions(ruleData, excludeIds = [], entityRestrictionData) {
|
||||
const filtered = getLanguages(ruleData).filter((item) => {
|
||||
// If restriction data is provided, filter out sources not in the activeSourceLookup
|
||||
if ((entityRestrictionData === null || entityRestrictionData === void 0 ? void 0 : entityRestrictionData.activeSourceLookup) && item.rpgSourceId) {
|
||||
return !excludeIds.includes(item.id) && has(entityRestrictionData.activeSourceLookup, item.rpgSourceId);
|
||||
}
|
||||
return !excludeIds.includes(item.id);
|
||||
});
|
||||
const sorted = orderBy(filtered, 'name');
|
||||
return sorted.map((item) => ({
|
||||
label: item.name,
|
||||
value: item.id,
|
||||
}));
|
||||
}
|
||||
export function getLanguageOptionsGroupedBySourceCategory(ruleData, excludeIds = [], entityRestrictionData) {
|
||||
const filtered = getLanguages(ruleData).filter((item) => {
|
||||
// If restriction data is provided, filter out sources not in the activeSourceLookup
|
||||
if ((entityRestrictionData === null || entityRestrictionData === void 0 ? void 0 : entityRestrictionData.activeSourceLookup) && item.rpgSourceId) {
|
||||
return !excludeIds.includes(item.id) && has(entityRestrictionData.activeSourceLookup, item.rpgSourceId);
|
||||
}
|
||||
return !excludeIds.includes(item.id);
|
||||
});
|
||||
const simpleContracts = filtered.map((language) => {
|
||||
return {
|
||||
id: language.id,
|
||||
name: language.name,
|
||||
sources: language.rpgSourceId
|
||||
? [
|
||||
{
|
||||
sourceId: language.rpgSourceId,
|
||||
pageNumber: null,
|
||||
sourceType: SourceTypeEnum.PRIMARY,
|
||||
},
|
||||
]
|
||||
: null,
|
||||
};
|
||||
});
|
||||
return SourceUtils.getGroupedOptionsBySourceCategory(simpleContracts, ruleData, null, undefined, 'Other');
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
* @param excludeIds
|
||||
*/
|
||||
export function getToolOptions(ruleData, excludeIds = []) {
|
||||
const filtered = getTools(ruleData).filter((item) => !excludeIds.includes(item.id));
|
||||
const sorted = orderBy(filtered, 'name');
|
||||
return sorted.map((item) => ({
|
||||
label: item.name,
|
||||
value: item.id,
|
||||
}));
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
import * as RuleDataAccessors from './accessors';
|
||||
import * as RuleDataConstants from './constants';
|
||||
import * as RuleDataDerivers from './derivers';
|
||||
import * as RuleDataGenerators from './generators';
|
||||
import * as RuleDataTypings from './typings';
|
||||
import * as RuleDataUtils from './utils';
|
||||
export * from './typings';
|
||||
export * from './constants';
|
||||
export { RuleDataAccessors, RuleDataDerivers, RuleDataGenerators, RuleDataUtils };
|
||||
export default Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, RuleDataAccessors), RuleDataConstants), RuleDataDerivers), RuleDataGenerators), RuleDataTypings), RuleDataUtils);
|
||||
@@ -0,0 +1,806 @@
|
||||
import { has, keyBy, orderBy, sortBy, uniqBy } from 'lodash';
|
||||
import { TypeScriptUtils } from '../../utils';
|
||||
import { ActivationAccessors } from '../Activation';
|
||||
import { ConditionAccessors } from '../Condition';
|
||||
import { AttackTypeRangeEnum, CoreUtils, CustomProficiencyTypeEnum, DisplayConfigurationValueEnum, MovementTypeEnum, NoteKeyEnum, ProficiencyLevelEnum, SenseTypeEnum, SpeedMovementKeyEnum, TraitTypeEnum, WeightSpeedTypeEnum, } from '../Core';
|
||||
import { HelperUtils } from '../Helper';
|
||||
import { ModifierSubTypeEnum } from '../Modifier';
|
||||
import { getAdjustmentTypesLookup, getAoeTypeLookup, getArmor, getBasicActions, getBasicActionsLookup, getBuilderHelperText, getComponentTypeLookup, getConditionLookup, getConditions, getCreatureGroupLookup, getDamageAdjustments, getDamageTypeLookup, getLanguageLookup, getLanguages, getLevelProficiencyBonusesLookup, getLimitedUseResetTypeLookup, getMovementLookup, getObjectTypeLookup, getRangeTypeLookup, getRuleLookup, getSenseLookup, getSourceDataLookup, getSpellComponentsLookup, getSpellRangeTypeLookup, getStatKeyLookup, getStatsLookup, getTools, getVehicleMovementLookup, getWeaponCategoryLookup, getWeaponLookupByEntityId, getWeaponProperties, getWeapons, } from './accessors';
|
||||
/**
|
||||
*
|
||||
* @param abilityId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getStatInfo(abilityId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.statsLookup, abilityId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param activationType
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getActivationTypeInfo(activationType, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.activationTypesLookup, activationType, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param conditionId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getConditionInfo(conditionId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.conditionLookup, conditionId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param monsterTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getMonsterTypeInfo(monsterTypeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.monsterTypeLookup, monsterTypeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param monsterTypeId
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
* @param pluralize
|
||||
*/
|
||||
export function getMonsterTypeName(monsterTypeId, ruleData, fallback = '', pluralize = false) {
|
||||
const typeInfo = getMonsterTypeInfo(monsterTypeId, ruleData);
|
||||
let name = fallback;
|
||||
if (typeInfo) {
|
||||
name = pluralize ? typeInfo.pluralizedName : typeInfo.name;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param monsterSubTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getMonsterSubTypeInfo(monsterSubTypeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.monsterSubTypeLookup, monsterSubTypeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param creatureSizeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureSizeInfo(creatureSizeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.creatureSizeLookup, creatureSizeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param creatureGroupCategoryId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureGroupCategoryInfo(creatureGroupCategoryId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.creatureGroupCategoryLookup, creatureGroupCategoryId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param creatureGroupFlagKey
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureGroupFlagInfo(creatureGroupFlagKey, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.creatureGroupFlagLookup, creatureGroupFlagKey, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param alignmentId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAlignmentInfo(alignmentId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.alignmentLookup, alignmentId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param skillId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSkillInfo(skillId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.abilitySkillLookup, skillId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param creatureGroupId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCreatureGroupInfo(creatureGroupId, ruleData) {
|
||||
const definitionInfo = HelperUtils.lookupDataOrFallback(getCreatureGroupLookup(ruleData), creatureGroupId, null);
|
||||
if (definitionInfo !== null && definitionInfo.flags !== null) {
|
||||
const flagInfos = definitionInfo.flags
|
||||
.map((flagKey) => getCreatureGroupFlagInfo(flagKey, ruleData))
|
||||
.filter(TypeScriptUtils.isNotNullOrUndefined);
|
||||
return Object.assign(Object.assign({}, definitionInfo), { categoryInfo: getCreatureGroupCategoryInfo(definitionInfo.categoryId, ruleData), flagInfos, flagInfoLookup: keyBy(flagInfos, 'key') });
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param challengeRatingId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getChallengeInfo(challengeRatingId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.challengeRatingLookup, challengeRatingId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param damageAdjustmentId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getDamageAdjustmentInfo(damageAdjustmentId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.damageAdjustmentsLookup, damageAdjustmentId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param environmentId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getEnvironmentInfo(environmentId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(ruleData.environmentLookup, environmentId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param environmentId
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
*/
|
||||
export function getEnvironmentName(environmentId, ruleData, fallback = '') {
|
||||
const info = getEnvironmentInfo(environmentId, ruleData);
|
||||
let name = fallback;
|
||||
if (info && info.name !== null) {
|
||||
name = info.name;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param categoryId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getWeaponCategoryInfo(categoryId, ruleData) {
|
||||
if (categoryId !== null) {
|
||||
return HelperUtils.lookupDataOrFallback(getWeaponCategoryLookup(ruleData), categoryId, null);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param propertyId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getWeaponPropertyInfo(propertyId, ruleData) {
|
||||
const propertyInfo = getWeaponProperties(ruleData).find((propertyItem) => propertyItem.id === propertyId);
|
||||
return propertyInfo ? propertyInfo : null;
|
||||
}
|
||||
/**
|
||||
* @deprecated Use getAbilityShortName
|
||||
* @param abilityId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAbilityKey(abilityId, ruleData) {
|
||||
if (abilityId === null) {
|
||||
return null;
|
||||
}
|
||||
return HelperUtils.lookupDataOrFallback(getStatKeyLookup(ruleData), abilityId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param abilityId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAbilityShortName(abilityId, ruleData) {
|
||||
if (abilityId === null) {
|
||||
return null;
|
||||
}
|
||||
const key = HelperUtils.lookupDataOrFallback(getStatKeyLookup(ruleData), abilityId, null);
|
||||
if (!key) {
|
||||
return null;
|
||||
}
|
||||
return key.toUpperCase();
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param damageTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getDamageType(damageTypeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getDamageTypeLookup(ruleData), damageTypeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param abilityId
|
||||
* @param ruleData
|
||||
* @param useFullname
|
||||
*/
|
||||
export function getStatNameById(abilityId, ruleData, useFullname = false) {
|
||||
const stat = HelperUtils.lookupDataOrFallback(getStatsLookup(ruleData), abilityId, null);
|
||||
if (!stat) {
|
||||
return null;
|
||||
}
|
||||
return useFullname ? stat.name : stat.key;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param rangeTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAttackRangeType(rangeTypeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getRangeTypeLookup(ruleData), rangeTypeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param id
|
||||
*/
|
||||
export function getSpeedMovementKeyById(id) {
|
||||
switch (id) {
|
||||
case MovementTypeEnum.WALK:
|
||||
return SpeedMovementKeyEnum.WALK;
|
||||
case MovementTypeEnum.FLY:
|
||||
return SpeedMovementKeyEnum.FLY;
|
||||
case MovementTypeEnum.SWIM:
|
||||
return SpeedMovementKeyEnum.SWIM;
|
||||
case MovementTypeEnum.CLIMB:
|
||||
return SpeedMovementKeyEnum.CLIMB;
|
||||
case MovementTypeEnum.BURROW:
|
||||
return SpeedMovementKeyEnum.BURROW;
|
||||
default:
|
||||
return '';
|
||||
}
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param key
|
||||
*/
|
||||
export function getMovementTypeBySpeedMovementKey(key) {
|
||||
switch (key) {
|
||||
case SpeedMovementKeyEnum.WALK:
|
||||
return MovementTypeEnum.WALK;
|
||||
case SpeedMovementKeyEnum.FLY:
|
||||
return MovementTypeEnum.FLY;
|
||||
case SpeedMovementKeyEnum.SWIM:
|
||||
return MovementTypeEnum.SWIM;
|
||||
case SpeedMovementKeyEnum.CLIMB:
|
||||
return MovementTypeEnum.CLIMB;
|
||||
case SpeedMovementKeyEnum.BURROW:
|
||||
return MovementTypeEnum.BURROW;
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param key
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSpeedMovementKeyLabel(key, ruleData) {
|
||||
const movementTypeId = getMovementTypeBySpeedMovementKey(key);
|
||||
return getMovementDescription(movementTypeId, ruleData);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param movementId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getMovementName(movementId, ruleData) {
|
||||
const movementInfo = getMovementInfo(movementId, ruleData);
|
||||
if (movementInfo !== null && movementInfo.name !== null) {
|
||||
return movementInfo.name;
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param movementId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getMovementInfo(movementId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getMovementLookup(ruleData), movementId);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param movementId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getMovementDescription(movementId, ruleData) {
|
||||
if (movementId === null) {
|
||||
return '';
|
||||
}
|
||||
const movementInfo = getMovementInfo(movementId, ruleData);
|
||||
if (movementInfo !== null && movementInfo.description !== null) {
|
||||
return movementInfo.description;
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
* @deprecated use getSenseInfo()
|
||||
* @param key
|
||||
*/
|
||||
export function getSenseTypeLabel(key) {
|
||||
switch (key) {
|
||||
case SenseTypeEnum.BLINDSIGHT:
|
||||
return 'Blindsight';
|
||||
case SenseTypeEnum.DARKVISION:
|
||||
return 'Darkvision';
|
||||
case SenseTypeEnum.TREMORSENSE:
|
||||
return 'Tremorsense';
|
||||
case SenseTypeEnum.TRUESIGHT:
|
||||
return 'Truesight';
|
||||
case SenseTypeEnum.PASSIVE_PERCEPTION:
|
||||
default:
|
||||
return 'Passive Perception';
|
||||
}
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param senseId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSenseInfo(senseId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getSenseLookup(ruleData), senseId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param key
|
||||
*/
|
||||
export function getSenseTypeModifierKey(key) {
|
||||
switch (key) {
|
||||
case SenseTypeEnum.BLINDSIGHT:
|
||||
return ModifierSubTypeEnum.BLINDSIGHT;
|
||||
case SenseTypeEnum.DARKVISION:
|
||||
return ModifierSubTypeEnum.DARKVISION;
|
||||
case SenseTypeEnum.TREMORSENSE:
|
||||
return ModifierSubTypeEnum.TREMORSENSE;
|
||||
case SenseTypeEnum.TRUESIGHT:
|
||||
return ModifierSubTypeEnum.TRUESIGHT;
|
||||
case SenseTypeEnum.PASSIVE_PERCEPTION:
|
||||
return ModifierSubTypeEnum.PASSIVE_PERCEPTION;
|
||||
default:
|
||||
return '';
|
||||
}
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param noteKey
|
||||
*/
|
||||
export function getNoteKeyName(noteKey) {
|
||||
switch (noteKey) {
|
||||
case NoteKeyEnum.ORGANIZATIONS:
|
||||
return 'Organizations';
|
||||
case NoteKeyEnum.ALLIES:
|
||||
return 'Allies';
|
||||
case NoteKeyEnum.BACKSTORY:
|
||||
return 'Backstory';
|
||||
case NoteKeyEnum.ENEMIES:
|
||||
return 'Enemies';
|
||||
case NoteKeyEnum.OTHER:
|
||||
return 'Other';
|
||||
case NoteKeyEnum.OTHER_HOLDINGS:
|
||||
return 'Other Holdings';
|
||||
case NoteKeyEnum.PERSONAL_POSSESSIONS:
|
||||
return 'Other Possessions';
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param type
|
||||
*/
|
||||
export function getTraitTypeName(type) {
|
||||
switch (type) {
|
||||
case TraitTypeEnum.APPEARANCE:
|
||||
return 'Appearance';
|
||||
case TraitTypeEnum.BONDS:
|
||||
return 'Bonds';
|
||||
case TraitTypeEnum.FLAWS:
|
||||
return 'Flaws';
|
||||
case TraitTypeEnum.IDEALS:
|
||||
return 'Ideals';
|
||||
case TraitTypeEnum.PERSONALITY_TRAITS:
|
||||
return 'Personality Traits';
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param weightSpeedType
|
||||
*/
|
||||
export function getWeightSpeedTypeLabel(weightSpeedType) {
|
||||
switch (weightSpeedType) {
|
||||
case WeightSpeedTypeEnum.NORMAL:
|
||||
return 'Unencumbered';
|
||||
case WeightSpeedTypeEnum.ENCUMBERED:
|
||||
return 'Encumbered';
|
||||
case WeightSpeedTypeEnum.HEAVILY_ENCUMBERED:
|
||||
return 'Heavily Encumbered';
|
||||
case WeightSpeedTypeEnum.PUSH_DRAG_LIFT:
|
||||
return 'Push, Drag, Lift';
|
||||
case WeightSpeedTypeEnum.OVER_CARRYING_CAPACITY:
|
||||
return 'Over Carrying Capacity';
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param type
|
||||
*/
|
||||
export function getProficiencyTypeLabel(type) {
|
||||
switch (type) {
|
||||
case CustomProficiencyTypeEnum.SKILL:
|
||||
return 'Skill';
|
||||
case CustomProficiencyTypeEnum.TOOL:
|
||||
return 'Tool';
|
||||
case CustomProficiencyTypeEnum.LANGUAGE:
|
||||
return 'Language';
|
||||
case CustomProficiencyTypeEnum.ARMOR:
|
||||
return 'Armor';
|
||||
case CustomProficiencyTypeEnum.WEAPON:
|
||||
return 'Weapon';
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param actionTypeRange
|
||||
*/
|
||||
export function getAttackTypeRangeName(actionTypeRange) {
|
||||
switch (actionTypeRange) {
|
||||
case AttackTypeRangeEnum.RANGED:
|
||||
return 'Ranged';
|
||||
case AttackTypeRangeEnum.MELEE:
|
||||
return 'Melee';
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param componentId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSpellComponentInfo(componentId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getSpellComponentsLookup(ruleData), componentId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleKey
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getRule(ruleKey, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getRuleLookup(ruleData), ruleKey, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param aoeTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAoeType(aoeTypeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getAoeTypeLookup(ruleData), aoeTypeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param spellRangeTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSpellRangeType(spellRangeTypeId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getSpellRangeTypeLookup(ruleData), spellRangeTypeId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param conditionId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getCondition(conditionId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getConditionLookup(ruleData), conditionId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param proficiencyLevel
|
||||
*/
|
||||
export function getProficiencyLevelName(proficiencyLevel) {
|
||||
switch (proficiencyLevel) {
|
||||
case ProficiencyLevelEnum.NONE:
|
||||
return 'Not Proficient';
|
||||
case ProficiencyLevelEnum.HALF:
|
||||
return 'Half Proficient';
|
||||
case ProficiencyLevelEnum.FULL:
|
||||
return 'Proficient';
|
||||
case ProficiencyLevelEnum.EXPERT:
|
||||
return 'Expertise';
|
||||
default:
|
||||
// not implemented
|
||||
}
|
||||
return '';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param id
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAdjustmentDataType(id, ruleData) {
|
||||
const adjustmentType = HelperUtils.lookupDataOrFallback(getAdjustmentTypesLookup(ruleData), id, null);
|
||||
if (adjustmentType) {
|
||||
return adjustmentType.dataType;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param id
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAdjustmentName(id, ruleData) {
|
||||
const adjustmentType = HelperUtils.lookupDataOrFallback(getAdjustmentTypesLookup(ruleData), id, null);
|
||||
if (adjustmentType) {
|
||||
return adjustmentType.name;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param id
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getAdjustmentConstraintLookup(id, ruleData) {
|
||||
const adjustmentType = HelperUtils.lookupDataOrFallback(getAdjustmentTypesLookup(ruleData), id, null);
|
||||
if (adjustmentType) {
|
||||
return keyBy(adjustmentType.constraints, 'id');
|
||||
}
|
||||
return {};
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getArmorNameLookup(ruleData) {
|
||||
const sortedArmor = orderBy(getArmor(ruleData), 'name');
|
||||
const lookup = {};
|
||||
sortedArmor.forEach((item) => {
|
||||
if (item.id !== null) {
|
||||
lookup[item.id] = item.name === null ? '' : item.name;
|
||||
}
|
||||
});
|
||||
return lookup;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param categoryId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getWeaponCategory(categoryId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getWeaponCategoryLookup(ruleData), categoryId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param categoryId
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
*/
|
||||
export function getWeaponCategoryName(categoryId, ruleData, fallback = '') {
|
||||
const weaponCategory = getWeaponCategory(categoryId, ruleData);
|
||||
if (weaponCategory !== null && weaponCategory.name !== null) {
|
||||
return weaponCategory.name;
|
||||
}
|
||||
return fallback;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getWeaponNameLookup(ruleData) {
|
||||
const sortedWeapons = orderBy(getWeapons(ruleData), 'name');
|
||||
const lookup = {};
|
||||
sortedWeapons.forEach((item) => {
|
||||
if (item.id !== null) {
|
||||
lookup[item.id] = item.name === null ? '' : item.name;
|
||||
}
|
||||
});
|
||||
return lookup;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getLanguageNameLookup(ruleData) {
|
||||
const lookup = {};
|
||||
getLanguages(ruleData).forEach((language) => {
|
||||
if (language.id !== null) {
|
||||
lookup[language.id] = language.name === null ? '' : language.name;
|
||||
}
|
||||
});
|
||||
return lookup;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param languageId
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
*/
|
||||
export function getLanguageName(languageId, ruleData, fallback = '') {
|
||||
const language = HelperUtils.lookupDataOrFallback(getLanguageLookup(ruleData), languageId, null);
|
||||
if (language !== null && language.name !== null) {
|
||||
return language.name;
|
||||
}
|
||||
return fallback;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getToolNameLookup(ruleData) {
|
||||
const sorted = orderBy(getTools(ruleData), 'name');
|
||||
const lookup = {};
|
||||
sorted.forEach((item) => {
|
||||
if (item.id !== null) {
|
||||
lookup[item.id] = item.name === null ? '' : item.name;
|
||||
}
|
||||
});
|
||||
return lookup;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param id
|
||||
* @param entityTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getWeaponByEntityId(id, entityTypeId, ruleData) {
|
||||
if (id === null || entityTypeId === null) {
|
||||
return null;
|
||||
}
|
||||
return HelperUtils.lookupDataOrFallback(getWeaponLookupByEntityId(ruleData), `${entityTypeId}-${id}`, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param basicActionId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getBasicAction(basicActionId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getBasicActionsLookup(ruleData), basicActionId, null);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param resetTypeId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getLimitedUseResetTypeName(resetTypeId, ruleData) {
|
||||
const resetType = HelperUtils.lookupDataOrFallback(getLimitedUseResetTypeLookup(ruleData), resetTypeId);
|
||||
if (resetType !== null && resetType.name !== null) {
|
||||
return resetType.name;
|
||||
}
|
||||
return 'Special';
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param activationType
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getActivationTypeBasicActions(activationType, ruleData) {
|
||||
const basicActions = getBasicActions(ruleData);
|
||||
return basicActions.filter((basicAction) => ActivationAccessors.getType(basicAction.activation) === activationType);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param level
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getLevelProficiencyBonus(level, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getLevelProficiencyBonusesLookup(ruleData), level, 0);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param slug
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getConditionBySlug(slug, ruleData) {
|
||||
if (slug === null) {
|
||||
return null;
|
||||
}
|
||||
const conditionData = getConditions(ruleData);
|
||||
const condition = conditionData.find((condition) => ConditionAccessors.getSlug(condition) === slug);
|
||||
if (condition) {
|
||||
return condition;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param slug
|
||||
* @param damageAdjustmentType
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getDamageAdjustmentBySlug(slug, damageAdjustmentType, ruleData) {
|
||||
if (slug === null) {
|
||||
return slug;
|
||||
}
|
||||
const damageAdjustmentData = getDamageAdjustments(ruleData);
|
||||
const damageAdjustment = damageAdjustmentData.find((adjustment) => adjustment.type === damageAdjustmentType && adjustment.slug === slug);
|
||||
if (damageAdjustment) {
|
||||
return damageAdjustment;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param movementType
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
*/
|
||||
export function getVehicleMovementName(movementType, ruleData, fallback = null) {
|
||||
const movementInfo = HelperUtils.lookupDataOrFallback(getVehicleMovementLookup(ruleData), movementType, null);
|
||||
if (movementInfo) {
|
||||
return movementInfo.name;
|
||||
}
|
||||
return fallback;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param type
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getObjectTypeInfo(type, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getObjectTypeLookup(ruleData), type);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param type
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
*/
|
||||
export function getObjectTypeName(type, ruleData, fallback = null) {
|
||||
const objectType = getObjectTypeInfo(type, ruleData);
|
||||
if (objectType) {
|
||||
return objectType.name;
|
||||
}
|
||||
return fallback;
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param sourceId
|
||||
* @param ruleData
|
||||
*/
|
||||
export function getSourceDataInfo(sourceId, ruleData) {
|
||||
return HelperUtils.lookupDataOrFallback(getSourceDataLookup(ruleData), sourceId);
|
||||
}
|
||||
/**
|
||||
*
|
||||
* @param type
|
||||
* @param ruleData
|
||||
* @param fallback
|
||||
*/
|
||||
export function getComponentTypeName(type, ruleData, fallback = null) {
|
||||
const componentTypeInfo = HelperUtils.lookupDataOrFallback(getComponentTypeLookup(ruleData), type);
|
||||
if (componentTypeInfo) {
|
||||
return componentTypeInfo.name;
|
||||
}
|
||||
return fallback;
|
||||
}
|
||||
export function getBuilderHelperTextByDefinitionKey(definitionKey, ruleData, displayConfigurationType) {
|
||||
const builderHelperText = getBuilderHelperText(ruleData);
|
||||
return builderHelperText
|
||||
.filter((builderText) => {
|
||||
if ((has(builderText, 'isInclusive') && builderText.isInclusive) || !has(builderText, 'isInclusive')) {
|
||||
return builderText.definitionKeys.includes(definitionKey);
|
||||
}
|
||||
return !builderText.definitionKeys.includes(definitionKey);
|
||||
})
|
||||
.filter((builderText) => CoreUtils.getDisplayConfigurationValue(displayConfigurationType, builderText.displayConfiguration) ===
|
||||
DisplayConfigurationValueEnum.ON);
|
||||
}
|
||||
export function getBuilderHelperTextByDefinitionKeys(definitionKeys, ruleData, displayConfigurationType) {
|
||||
let builderTexts = [];
|
||||
definitionKeys.forEach((definitionKey) => {
|
||||
builderTexts = builderTexts.concat(getBuilderHelperTextByDefinitionKey(definitionKey, ruleData, displayConfigurationType));
|
||||
});
|
||||
return sortBy(uniqBy(builderTexts, 'id'), 'displayOrder');
|
||||
}
|
||||
Reference in New Issue
Block a user