Grabbed dndbeyond's source code

``` ~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js ```
2025-05-28 11:50:03 -07:00
commit 8df9031d27
3592 changed files with 319051 additions and 0 deletions
@@ -0,0 +1,51 @@
+/**
+ *
+ * @param preKey
+ */
+export function getPreferenceKey(preKey) {
+    switch (preKey) {
+        case 'abilityScoreDisplayType':
+            return preKey;
+        case 'enableDarkMode':
+            return preKey;
+        case 'enableContainerCurrency':
+            return preKey;
+        case 'enableOptionalClassFeatures':
+            return preKey;
+        case 'enableOptionalOrigins':
+            return preKey;
+        case 'encumbranceType':
+            return preKey;
+        case 'enforceFeatRules':
+            return preKey;
+        case 'enforceMulticlassRules':
+            return preKey;
+        case 'hitPointType':
+            return preKey;
+        case 'ignoreCoinWeight':
+            return preKey;
+        case 'primaryMovement':
+            return preKey;
+        case 'primarySense':
+            return preKey;
+        case 'privacyType':
+            return preKey;
+        case 'progressionType':
+            return preKey;
+        case 'sharingType':
+            return preKey;
+        case 'showCompanions':
+            return preKey;
+        case 'showScaledSpells':
+            return preKey;
+        case 'showUnarmedStrike':
+            return preKey;
+        case 'showWildShape':
+            return preKey;
+        case 'useHomebrewContent':
+            return preKey;
+        default:
+        //not implemented
+    }
+    return null;
+}
@@ -0,0 +1,24 @@
+import { groupBy } from 'lodash';
+import { EntityUtils } from '../../Entity';
+/**
+ *
+ * @param defenseAdjustments
+ */
+export function groupDefenseAdjustments(defenseAdjustments) {
+    const groupedDefenseAdjustments = [];
+    const keyedGroupDefenseAdjustments = groupBy(defenseAdjustments, 'name');
+    Object.keys(keyedGroupDefenseAdjustments).forEach((groupKey) => {
+        const damageAdjustments = keyedGroupDefenseAdjustments[groupKey];
+        groupedDefenseAdjustments.push({
+            name: groupKey,
+            sources: damageAdjustments
+                .map((adjustment) => {
+                return EntityUtils.getDataOriginName(adjustment.dataOrigin, undefined, true);
+            })
+                .sort(),
+            hasCustom: !!damageAdjustments.find((adjustment) => adjustment.isCustom),
+            damageAdjustments,
+        });
+    });
+    return groupedDefenseAdjustments;
+}
@@ -0,0 +1,31 @@
+/**
+ *
+ * @param hitPointInfo
+ * @param hpDiff
+ */
+export function calculateHitPoints(hitPointInfo, hpDiff) {
+    let newTemp;
+    let newHp;
+    const hpTemp = hitPointInfo.tempHp ? hitPointInfo.tempHp : 0;
+    if (hpDiff < 0) {
+        newTemp = Math.max(hpTemp + hpDiff, 0);
+        if (Math.abs(hpDiff) > hpTemp) {
+            newHp = hitPointInfo.remainingHp + (hpTemp + hpDiff);
+        }
+        else {
+            newHp = hitPointInfo.remainingHp;
+        }
+    }
+    else {
+        newTemp = hitPointInfo.tempHp;
+        newHp = Math.min(hitPointInfo.remainingHp + hpDiff, hitPointInfo.totalHp);
+    }
+    newHp = Math.max(0, newHp);
+    const newRemovedHp = hitPointInfo.totalHp - newHp;
+    return {
+        newTemp,
+        newHp,
+        newRemovedHp,
+        startHp: hitPointInfo.remainingHp,
+    };
+}
@@ -0,0 +1,118 @@
+import { CreatureSizeEnum } from '../../Core';
+import { ModifierAccessors, ModifierDerivers, ModifierSubTypeEnum, ModifierValidators } from '../../Modifier';
+/**
+ *
+ * @param sizeId
+ * @param modifiers
+ */
+export function getEncumbranceSize(sizeId, modifiers) {
+    let encumbranceSize = sizeId;
+    let isSmallerOverride = false;
+    let isLargerOverride = false;
+    const carryingCapacitySizeModifiers = modifiers.filter((modifier) => ModifierValidators.isCarryingCapacitySizeModifier(modifier));
+    carryingCapacitySizeModifiers.forEach((modifier) => {
+        switch (ModifierAccessors.getSubType(modifier)) {
+            case ModifierSubTypeEnum.TINY:
+                isSmallerOverride = true;
+                break;
+            case ModifierSubTypeEnum.LARGE:
+            case ModifierSubTypeEnum.HUGE:
+            case ModifierSubTypeEnum.GARGANTUAN:
+                isLargerOverride = true;
+                break;
+            default:
+            // not implemented
+        }
+    });
+    if (isSmallerOverride) {
+        encumbranceSize = CreatureSizeEnum.TINY;
+    }
+    if (isLargerOverride) {
+        encumbranceSize = CreatureSizeEnum.LARGE;
+    }
+    return encumbranceSize;
+}
+/**
+ *
+ * @param value
+ * @param encumbranceSizeId
+ */
+export function getEncumbranceSizeScaledValue(value, encumbranceSizeId) {
+    switch (encumbranceSizeId) {
+        case CreatureSizeEnum.TINY:
+            return value / 2;
+        case CreatureSizeEnum.LARGE:
+        case CreatureSizeEnum.HUGE:
+        case CreatureSizeEnum.GARGANTUAN:
+            return value * 2;
+        default:
+        // not implemented
+    }
+    return value;
+}
+/**
+ *
+ * @param value
+ * @param modifiers
+ */
+export function getCarryCapacityModifierScaledValue(value, modifiers) {
+    // get weight multiplied by any multipliers, positive is times, negative is division (ex: 2 is times two, -3 is divide by 3)
+    const carryingCapacityMultiplierModifiers = modifiers.filter((modifier) => ModifierValidators.isCarringCapacityMultiplierModifier(modifier));
+    const highestCarryingCapacityMultiplier = ModifierDerivers.deriveHighestModifierValue(carryingCapacityMultiplierModifiers);
+    if (highestCarryingCapacityMultiplier) {
+        if (highestCarryingCapacityMultiplier < 0) {
+            return (value /= Math.abs(highestCarryingCapacityMultiplier));
+        }
+        return (value *= highestCarryingCapacityMultiplier);
+    }
+    return value;
+}
+/**
+ *
+ * @param strengthScale
+ * @param strScore
+ * @param size
+ * @param modifiers
+ */
+export function getStrengthScaledCarryCapacity(strengthScale, strScore, size, modifiers) {
+    const sizeId = size ? size.id : null;
+    const baseWeight = strScore * strengthScale;
+    const encumbranceSize = getEncumbranceSize(sizeId, modifiers);
+    let weight = getEncumbranceSizeScaledValue(baseWeight, encumbranceSize);
+    weight = getCarryCapacityModifierScaledValue(weight, modifiers);
+    return weight;
+}
+/**
+ *
+ * @param strScore
+ * @param size
+ * @param modifiers
+ */
+export function getCarryCapacity(strScore, size, modifiers) {
+    return getStrengthScaledCarryCapacity(15, strScore, size, modifiers);
+}
+/**
+ *
+ * @param carryCapacity
+ */
+export function getPushDragLiftWeight(carryCapacity) {
+    return carryCapacity * 2;
+}
+/**
+ *
+ * @param strScore
+ * @param size
+ * @param modifiers
+ */
+export function getEncumberedWeight(strScore, size, modifiers) {
+    return getStrengthScaledCarryCapacity(5, strScore, size, modifiers);
+}
+/**
+ *
+ * @param strScore
+ * @param size
+ * @param modifiers
+ */
+export function getHeavilyEncumberedWeight(strScore, size, modifiers) {
+    return getStrengthScaledCarryCapacity(10, strScore, size, modifiers);
+}