optolith-database-schema 0.16.2 → 0.16.4

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.16.4](https://github.com/elyukai/optolith-database-schema/compare/v0.16.3...v0.16.4) (2024-01-21)
+
+
+### Features
+
+* magical and blessed advantages and disadvantages identifier cache ([4dc6e3d](https://github.com/elyukai/optolith-database-schema/commit/4dc6e3dec721019af728db6b68138498da4b1775))
+
+### [0.16.3](https://github.com/elyukai/optolith-database-schema/compare/v0.16.2...v0.16.3) (2024-01-18)
+
+
+### Bug Fixes
+
+* resolve intersection types ([829da00](https://github.com/elyukai/optolith-database-schema/commit/829da0079a60693dbeec94cbfb02b447c5105da5))
+
 ### [0.16.2](https://github.com/elyukai/optolith-database-schema/compare/v0.16.1...v0.16.2) (2024-01-18)
 
 

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.d.ts

@@ -0,0 +1,20 @@
+import type { CacheConfig } from "../cacheConfig.js";
+export type MagicalAndBlessedAdvantagesAndDisadvantagesCache = {
+    advantages: {
+        magical: {
+            ids: number[];
+        };
+        blessed: {
+            ids: number[];
+        };
+    };
+    disadvantages: {
+        magical: {
+            ids: number[];
+        };
+        blessed: {
+            ids: number[];
+        };
+    };
+};
+export declare const config: CacheConfig<MagicalAndBlessedAdvantagesAndDisadvantagesCache>;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -0,0 +1,163 @@
+import { assertExhaustive } from "../helpers/typeSafety.js";
+const BLESSED_ID = 12;
+const SPELLCASTER_ID = 47;
+const getAdvantageId = (type) => {
+    switch (type) {
+        case "Magical":
+            return SPELLCASTER_ID;
+        case "Blessed":
+            return BLESSED_ID;
+        default:
+            return assertExhaustive(type);
+    }
+};
+const isRatedFor = (type, ratedId) => {
+    switch (ratedId.tag) {
+        case "Spell":
+        case "Ritual":
+            return type === "Magical";
+        case "LiturgicalChant":
+        case "Ceremony":
+            return type === "Blessed";
+        case "Attribute":
+        case "Skill":
+        case "CloseCombatTechnique":
+        case "RangedCombatTechnique":
+            return false;
+        default:
+            return assertExhaustive(ratedId);
+    }
+};
+const isPrerequisiteFor = (type, prerequisite, getById, traversedIds) => {
+    switch (prerequisite.tag) {
+        case "Activatable": {
+            if (prerequisite.activatable.id.tag === "Advantage" &&
+                prerequisite.activatable.id.advantage === getAdvantageId(type) &&
+                prerequisite.activatable.active) {
+                return true;
+            }
+            const entry = getById(prerequisite.activatable.id);
+            return entry !== undefined && is(type, entry, getById, traversedIds);
+        }
+        case "Rated":
+            return isRatedFor(type, prerequisite.rated.id);
+        case "CommonSuggestedByRCP":
+        case "Sex":
+        case "Race":
+        case "Culture":
+        case "Pact":
+        case "SocialStatus":
+        case "State":
+        case "Rule":
+        case "PrimaryAttribute":
+        case "BlessedTradition":
+        case "MagicalTradition":
+        case "RatedMinimumNumber":
+        case "RatedSum":
+        case "ExternalEnhancement":
+        case "Text":
+        case "NoOtherAncestorBloodAdvantage":
+        case "SexualCharacteristic":
+            return false;
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+const is = (type, entry, getById, traversedIds) => {
+    if (!entry.prerequisites || traversedIds.includes(entry.id)) {
+        return false;
+    }
+    const newTraversedIds = [...traversedIds, entry.id];
+    return (entry.prerequisites !== undefined &&
+        entry.prerequisites.some(prerequisite => {
+            switch (prerequisite.prerequisite.tag) {
+                case "Single":
+                    return isPrerequisiteFor(type, prerequisite.prerequisite.single, getById, newTraversedIds);
+                case "Disjunction":
+                    return prerequisite.prerequisite.disjunction.list.some(p => isPrerequisiteFor(type, p, getById, newTraversedIds));
+                case "Group":
+                    return prerequisite.prerequisite.group.list.some(p => isPrerequisiteFor(type, p, getById, newTraversedIds));
+                default:
+                    return assertExhaustive(prerequisite.prerequisite);
+            }
+        }));
+};
+export const config = {
+    builder(database) {
+        const getActivatableById = (id) => {
+            // prettier-ignore
+            switch (id.tag) {
+                case "AdvancedCombatSpecialAbility": return database.advancedCombatSpecialAbilities.find(([entryId]) => entryId === id.advanced_combat_special_ability)?.[1];
+                case "AdvancedKarmaSpecialAbility": return database.advancedKarmaSpecialAbilities.find(([entryId]) => entryId === id.advanced_karma_special_ability)?.[1];
+                case "AdvancedMagicalSpecialAbility": return database.advancedMagicalSpecialAbilities.find(([entryId]) => entryId === id.advanced_magical_special_ability)?.[1];
+                case "AdvancedSkillSpecialAbility": return database.advancedSkillSpecialAbilities.find(([entryId]) => entryId === id.advanced_skill_special_ability)?.[1];
+                case "Advantage": return database.advantages.find(([entryId]) => entryId === id.advantage)?.[1];
+                case "AncestorGlyph": return database.ancestorGlyphs.find(([entryId]) => entryId === id.ancestor_glyph)?.[1];
+                case "ArcaneOrbEnchantment": return database.arcaneOrbEnchantments.find(([entryId]) => entryId === id.arcane_orb_enchantment)?.[1];
+                case "AttireEnchantment": return database.attireEnchantments.find(([entryId]) => entryId === id.attire_enchantment)?.[1];
+                case "BlessedTradition": return database.blessedTraditions.find(([entryId]) => entryId === id.blessed_tradition)?.[1];
+                case "BowlEnchantment": return database.bowlEnchantments.find(([entryId]) => entryId === id.bowl_enchantment)?.[1];
+                case "BrawlingSpecialAbility": return database.brawlingSpecialAbilities.find(([entryId]) => entryId === id.brawling_special_ability)?.[1];
+                case "CauldronEnchantment": return database.cauldronEnchantments.find(([entryId]) => entryId === id.cauldron_enchantment)?.[1];
+                case "CeremonialItemSpecialAbility": return database.ceremonialItemSpecialAbilities.find(([entryId]) => entryId === id.ceremonial_item_special_ability)?.[1];
+                case "ChronicleEnchantment": return database.chronicleEnchantments.find(([entryId]) => entryId === id.chronicle_enchantment)?.[1];
+                case "CombatSpecialAbility": return database.combatSpecialAbilities.find(([entryId]) => entryId === id.combat_special_ability)?.[1];
+                case "CombatStyleSpecialAbility": return database.combatStyleSpecialAbilities.find(([entryId]) => entryId === id.combat_style_special_ability)?.[1];
+                case "CommandSpecialAbility": return database.commandSpecialAbilities.find(([entryId]) => entryId === id.command_special_ability)?.[1];
+                case "DaggerRitual": return database.daggerRituals.find(([entryId]) => entryId === id.dagger_ritual)?.[1];
+                case "Disadvantage": return database.disadvantages.find(([entryId]) => entryId === id.disadvantage)?.[1];
+                case "FamiliarSpecialAbility": return database.familiarSpecialAbilities.find(([entryId]) => entryId === id.familiar_special_ability)?.[1];
+                case "FatePointSexSpecialAbility": return database.fatePointSexSpecialAbilities.find(([entryId]) => entryId === id.fate_point_sex_special_ability)?.[1];
+                case "FatePointSpecialAbility": return database.fatePointSpecialAbilities.find(([entryId]) => entryId === id.fate_point_special_ability)?.[1];
+                case "FoolsHatEnchantment": return database.foolsHatEnchantments.find(([entryId]) => entryId === id.fools_hat_enchantment)?.[1];
+                case "GeneralSpecialAbility": return database.generalSpecialAbilities.find(([entryId]) => entryId === id.general_special_ability)?.[1];
+                case "InstrumentEnchantment": return database.instrumentEnchantments.find(([entryId]) => entryId === id.instrument_enchantment)?.[1];
+                case "KarmaSpecialAbility": return database.karmaSpecialAbilities.find(([entryId]) => entryId === id.karma_special_ability)?.[1];
+                case "Krallenkettenzauber": return database.krallenkettenzauber.find(([entryId]) => entryId === id.krallenkettenzauber)?.[1];
+                case "LiturgicalStyleSpecialAbility": return database.liturgicalStyleSpecialAbilities.find(([entryId]) => entryId === id.liturgical_style_special_ability)?.[1];
+                case "LycantropicGift": return database.lycantropicGifts.find(([entryId]) => entryId === id.lycantropic_gift)?.[1];
+                case "MagicalSpecialAbility": return database.magicalSpecialAbilities.find(([entryId]) => entryId === id.magical_special_ability)?.[1];
+                case "MagicalTradition": return database.magicalTraditions.find(([entryId]) => entryId === id.magical_tradition)?.[1];
+                case "MagicStyleSpecialAbility": return database.magicStyleSpecialAbilities.find(([entryId]) => entryId === id.magic_style_special_ability)?.[1];
+                case "OrbEnchantment": return database.orbEnchantments.find(([entryId]) => entryId === id.orb_enchantment)?.[1];
+                case "PactGift": return database.pactGifts.find(([entryId]) => entryId === id.pact_gift)?.[1];
+                case "ProtectiveWardingCircleSpecialAbility": return database.protectiveWardingCircleSpecialAbilities.find(([entryId]) => entryId === id.protective_warding_circle_special_ability)?.[1];
+                case "RingEnchantment": return database.ringEnchantments.find(([entryId]) => entryId === id.ring_enchantment)?.[1];
+                case "Sermon": return database.sermons.find(([entryId]) => entryId === id.sermon)?.[1];
+                case "SexSpecialAbility": return database.sexSpecialAbilities.find(([entryId]) => entryId === id.sex_special_ability)?.[1];
+                case "SickleRitual": return database.sickleRituals.find(([entryId]) => entryId === id.sickle_ritual)?.[1];
+                case "SikaryanDrainSpecialAbility": return database.sikaryanDrainSpecialAbilities.find(([entryId]) => entryId === id.sikaryan_drain_special_ability)?.[1];
+                case "SkillStyleSpecialAbility": return database.skillStyleSpecialAbilities.find(([entryId]) => entryId === id.skill_style_special_ability)?.[1];
+                case "SpellSwordEnchantment": return database.spellSwordEnchantments.find(([entryId]) => entryId === id.spell_sword_enchantment)?.[1];
+                case "StaffEnchantment": return database.staffEnchantments.find(([entryId]) => entryId === id.staff_enchantment)?.[1];
+                case "ToyEnchantment": return database.toyEnchantments.find(([entryId]) => entryId === id.toy_enchantment)?.[1];
+                case "Trinkhornzauber": return database.trinkhornzauber.find(([entryId]) => entryId === id.trinkhornzauber)?.[1];
+                case "VampiricGift": return database.vampiricGifts.find(([entryId]) => entryId === id.vampiric_gift)?.[1];
+                case "Vision": return database.visions.find(([entryId]) => entryId === id.vision)?.[1];
+                case "WandEnchantment": return database.wandEnchantments.find(([entryId]) => entryId === id.wand_enchantment)?.[1];
+                case "WeaponEnchantment": return database.weaponEnchantments.find(([entryId]) => entryId === id.weapon_enchantment)?.[1];
+                default:
+                    return assertExhaustive(id);
+            }
+        };
+        // prettier-ignore
+        return {
+            advantages: {
+                magical: {
+                    ids: database.advantages.filter(([_, entry]) => is("Magical", entry, getActivatableById, [])).map(([id]) => id),
+                },
+                blessed: {
+                    ids: database.advantages.filter(([_, entry]) => is("Blessed", entry, getActivatableById, [])).map(([id]) => id),
+                },
+            },
+            disadvantages: {
+                magical: {
+                    ids: database.disadvantages.filter(([_, entry]) => is("Magical", entry, getActivatableById, [])).map(([id]) => id),
+                },
+                blessed: {
+                    ids: database.disadvantages.filter(([_, entry]) => is("Blessed", entry, getActivatableById, [])).map(([id]) => id),
+                },
+            },
+        };
+    },
+};

package/lib/config/cache.d.ts

@@ -1,13 +1,16 @@
 import * as ActivatableSelectOptions from "../cache/activatableSelectOptions.js";
 import * as AncestorBloodAdvantages from "../cache/ancestorBloodAdvantages.js";
+import * as MagicalAndBlessedAdvantagesAndDisadvantages from "../cache/magicalAndBlessedAdvantagesAndDisadvantages.js";
 import * as NewApplicationsAndUses from "../cache/newApplicationsAndUses.js";
 export type CacheMap = {
     activatableSelectOptions: ActivatableSelectOptions.ActivatableSelectOptionsCache;
     ancestorBloodAdvantages: AncestorBloodAdvantages.AncestorBloodAdvantagesCache;
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantages.MagicalAndBlessedAdvantagesAndDisadvantagesCache;
     newApplicationsAndUses: NewApplicationsAndUses.NewApplicationsAndUsesCache;
 };
 export declare const cacheMap: {
     activatableSelectOptions: import("../cacheConfig.js").CacheConfig<ActivatableSelectOptions.ActivatableSelectOptionsCache>;
     ancestorBloodAdvantages: import("../cacheConfig.js").CacheConfig<AncestorBloodAdvantages.AncestorBloodAdvantagesCache>;
+    magicalAndBlessedAdvantagesAndDisadvantages: import("../cacheConfig.js").CacheConfig<MagicalAndBlessedAdvantagesAndDisadvantages.MagicalAndBlessedAdvantagesAndDisadvantagesCache>;
     newApplicationsAndUses: import("../cacheConfig.js").CacheConfig<NewApplicationsAndUses.NewApplicationsAndUsesCache, [generatedSelectOptions: ActivatableSelectOptions.ActivatableSelectOptionsCache]>;
 };

package/lib/config/cache.js

@@ -1,8 +1,10 @@
 import * as ActivatableSelectOptions from "../cache/activatableSelectOptions.js";
 import * as AncestorBloodAdvantages from "../cache/ancestorBloodAdvantages.js";
+import * as MagicalAndBlessedAdvantagesAndDisadvantages from "../cache/magicalAndBlessedAdvantagesAndDisadvantages.js";
 import * as NewApplicationsAndUses from "../cache/newApplicationsAndUses.js";
 export const cacheMap = {
     activatableSelectOptions: ActivatableSelectOptions.config,
     ancestorBloodAdvantages: AncestorBloodAdvantages.config,
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantages.config,
     newApplicationsAndUses: NewApplicationsAndUses.config,
 };

package/lib/main.js

@@ -78,10 +78,12 @@ export const buildCache = async (cachePaths, validResults, options = {}) => {
     const { pretty = false } = options;
     const activatableSelectOptionsCache = cacheMap.activatableSelectOptions.builder(validResults);
     const ancestorBloodAdvantagesCache = cacheMap.ancestorBloodAdvantages.builder(validResults);
+    const magicalAndBlessedAdvantagesAndDisadvantagesCache = cacheMap.magicalAndBlessedAdvantagesAndDisadvantages.builder(validResults);
     const newApplicationsAndUsesCache = cacheMap.newApplicationsAndUses.builder(validResults, activatableSelectOptionsCache);
     const cacheData = {
         activatableSelectOptions: activatableSelectOptionsCache,
         ancestorBloodAdvantages: ancestorBloodAdvantagesCache,
+        magicalAndBlessedAdvantagesAndDisadvantages: magicalAndBlessedAdvantagesAndDisadvantagesCache,
         newApplicationsAndUses: newApplicationsAndUsesCache,
     };
     for (const [cacheName, cachePath] of Object.entries(cachePaths)) {

package/lib/types/Profession.d.ts

@@ -341,12 +341,28 @@ export type VariantSpecialAbility = {
     tag: "Selection";
     selection: VariantSpecialAbilitySelection;
 };
-export type FixedVariantSpecialAbility = SpecialAbilityDefinition & {
+export type FixedVariantSpecialAbility = {
+    /**
+     * The identifier of the combat technique to provide the rating for.
+     */
+    id: SpecialAbilityIdentifier;
     /**
      * if set to `false`, if the selection is granted by the basic package, it
      * is removed.
      */
     active?: false;
+    /**
+     * The level of the received special ability.
+     * @integer
+     * @minimum 1
+     */
+    level?: number;
+    /**
+     * Received select options. Order is important. Typically, you only need the
+     * first array index, though.
+     * @minItems 1
+     */
+    options?: RequirableSelectOptionIdentifier[];
 };
 export type VariantSpecialAbilitySelection = {
     /**

package/lib/types/Race.d.ts

@@ -3,7 +3,7 @@
  */
 import { TypeConfig } from "../typeConfig.js";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
-import { Dice } from "./_Dice.js";
+import { Dice, DieType } from "./_Dice.js";
 import { AdvantageIdentifier, AttributeIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier } from "./_Identifier.js";
 import { LocaleMap } from "./_LocaleMap.js";
 import { NonEmptyString } from "./_NonEmptyString.js";
@@ -176,7 +176,17 @@ export type Weight = {
      */
     random: WeightDice[];
 };
-export type WeightDice = Dice & {
+export type WeightDice = {
+    /**
+     * Number of dice of the same type. Example: 2 in 2D6.
+     * @integer
+     * @minimum 1
+     */
+    number: number;
+    /**
+     * Number of sides on every die. Example: 6 in 2D6.
+     */
+    sides: DieType;
     /**
      * The strategy how to offset the randomly generated values against the
      * base value. Either they are all added or subtracted or even results are

package/lib/types/_ActivatableSkillDuration.d.ts

@@ -1,4 +1,4 @@
-import { CheckResultBased } from "./_ActivatableSkillCheckResultBased.js";
+import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
 import { LocaleMap } from "./_LocaleMap.js";
 import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js";
 export type DurationForOneTime = {
@@ -74,11 +74,19 @@ export type FixedDurationTranslation = {
 /**
  * Defines the duration being based on a check result.
  */
-export type CheckResultBasedDuration = CheckResultBased & {
+export type CheckResultBasedDuration = {
     /**
      * If the duration is the maximum duration, so it may end earlier.
      */
     is_maximum?: true;
+    /**
+     * The base value that is derived from the check result.
+     */
+    base: CheckResultValue;
+    /**
+     * If defined, it modifies the base value.
+     */
+    modifier?: CheckResultBasedModifier;
     /**
      * The duration unit.
      */

package/lib/types/_ActivatableSkillRange.d.ts

@@ -1,4 +1,4 @@
-import { CheckResultBased } from "./_ActivatableSkillCheckResultBased.js";
+import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
 import { LocaleMap } from "./_LocaleMap.js";
 import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
 export type Range = {
@@ -74,11 +74,19 @@ export type FixedRange = {
 /**
  * Defines the range being based on a check result.
  */
-export type CheckResultBasedRange = CheckResultBased & {
+export type CheckResultBasedRange = {
     /**
      * If the range is the maximum range.
      */
     is_maximum?: true;
+    /**
+     * The base value that is derived from the check result.
+     */
+    base: CheckResultValue;
+    /**
+     * If defined, it modifies the base value.
+     */
+    modifier?: CheckResultBasedModifier;
     /**
      * The duration unit.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.16.2",
+  "version": "0.16.4",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",

package/schema/Profession.schema.json

@@ -648,23 +648,34 @@
       ]
     },
     "FixedVariantSpecialAbility": {
-      "allOf": [
-        {
-          "$ref": "#/$defs/SpecialAbilityDefinition"
+      "type": "object",
+      "properties": {
+        "id": {
+          "description": "The identifier of the combat technique to provide the rating for.",
+          "$ref": "./_IdentifierGroup.schema.json#/$defs/SpecialAbilityIdentifier"
         },
-        {
-          "type": "object",
-          "properties": {
-            "active": {
-              "description": "if set to `false`, if the selection is granted by the basic package, it\nis removed.",
-              "const": false
-            }
+        "active": {
+          "description": "if set to `false`, if the selection is granted by the basic package, it\nis removed.",
+          "const": false
+        },
+        "level": {
+          "description": "The level of the received special ability.",
+          "type": "integer",
+          "minimum": 1
+        },
+        "options": {
+          "description": "Received select options. Order is important. Typically, you only need the\nfirst array index, though.",
+          "type": "array",
+          "items": {
+            "$ref": "./_IdentifierGroup.schema.json#/$defs/RequirableSelectOptionIdentifier"
           },
-          "required": []
+          "minItems": 1
         }
+      },
+      "required": [
+        "id"
       ],
-      "type": "object",
-      "unevaluatedProperties": false
+      "additionalProperties": false
     },
     "VariantSpecialAbilitySelection": {
       "type": "object",

package/schema/Race.schema.json

@@ -240,25 +240,28 @@
       "additionalProperties": false
     },
     "WeightDice": {
-      "allOf": [
-        {
-          "$ref": "./_Dice.schema.json#/$defs/Dice"
+      "type": "object",
+      "properties": {
+        "number": {
+          "description": "Number of dice of the same type. Example: 2 in 2D6.",
+          "type": "integer",
+          "minimum": 1
         },
-        {
-          "type": "object",
-          "properties": {
-            "offset_strategy": {
-              "description": "The strategy how to offset the randomly generated values against the\nbase value. Either they are all added or subtracted or even results are\nadded and odd results are subtracted.",
-              "$ref": "#/$defs/WeightDiceOffsetStrategy"
-            }
-          },
-          "required": [
-            "offset_strategy"
-          ]
+        "sides": {
+          "description": "Number of sides on every die. Example: 6 in 2D6.",
+          "$ref": "./_Dice.schema.json#/$defs/DieType"
+        },
+        "offset_strategy": {
+          "description": "The strategy how to offset the randomly generated values against the\nbase value. Either they are all added or subtracted or even results are\nadded and odd results are subtracted.",
+          "$ref": "#/$defs/WeightDiceOffsetStrategy"
         }
+      },
+      "required": [
+        "number",
+        "sides",
+        "offset_strategy"
       ],
-      "type": "object",
-      "unevaluatedProperties": false
+      "additionalProperties": false
     },
     "WeightDiceOffsetStrategy": {
       "description": "The strategy how to offset the randomly generated values against the\nbase value. Either they are all added or subtracted or even results are\nadded and odd results are subtracted.",

package/schema/_ActivatableSkillDuration.schema.json

@@ -201,40 +201,41 @@
     },
     "CheckResultBasedDuration": {
       "description": "Defines the duration being based on a check result.",
-      "allOf": [
-        {
-          "$ref": "./_ActivatableSkillCheckResultBased.schema.json#/$defs/CheckResultBased"
+      "type": "object",
+      "properties": {
+        "is_maximum": {
+          "description": "If the duration is the maximum duration, so it may end earlier.",
+          "const": true
         },
-        {
+        "base": {
+          "description": "The base value that is derived from the check result.",
+          "$ref": "./_ActivatableSkillCheckResultBased.schema.json#/$defs/CheckResultValue"
+        },
+        "modifier": {
+          "description": "If defined, it modifies the base value.",
+          "$ref": "./_ActivatableSkillCheckResultBased.schema.json#/$defs/CheckResultBasedModifier"
+        },
+        "unit": {
+          "description": "The duration unit.",
+          "$ref": "#/$defs/DurationUnit"
+        },
+        "translations": {
+          "description": "All translations for the entry, identified by IETF language tag (BCP47).",
           "type": "object",
-          "properties": {
-            "is_maximum": {
-              "description": "If the duration is the maximum duration, so it may end earlier.",
-              "const": true
-            },
-            "unit": {
-              "description": "The duration unit.",
-              "$ref": "#/$defs/DurationUnit"
-            },
-            "translations": {
-              "description": "All translations for the entry, identified by IETF language tag (BCP47).",
-              "type": "object",
-              "patternProperties": {
-                "^[a-z]{2}-[A-Z]{2}$": {
-                  "$ref": "#/$defs/CheckResultBasedDurationTranslation"
-                }
-              },
-              "minProperties": 1,
-              "additionalProperties": false
+          "patternProperties": {
+            "^[a-z]{2}-[A-Z]{2}$": {
+              "$ref": "#/$defs/CheckResultBasedDurationTranslation"
             }
           },
-          "required": [
-            "unit"
-          ]
+          "minProperties": 1,
+          "additionalProperties": false
         }
+      },
+      "required": [
+        "base",
+        "unit"
       ],
-      "type": "object",
-      "unevaluatedProperties": false
+      "additionalProperties": false
     },
     "CheckResultBasedDurationTranslation": {
       "type": "object",

package/schema/_ActivatableSkillRange.schema.json

@@ -205,33 +205,34 @@
     },
     "CheckResultBasedRange": {
       "description": "Defines the range being based on a check result.",
-      "allOf": [
-        {
-          "$ref": "./_ActivatableSkillCheckResultBased.schema.json#/$defs/CheckResultBased"
+      "type": "object",
+      "properties": {
+        "is_maximum": {
+          "description": "If the range is the maximum range.",
+          "const": true
         },
-        {
-          "type": "object",
-          "properties": {
-            "is_maximum": {
-              "description": "If the range is the maximum range.",
-              "const": true
-            },
-            "unit": {
-              "description": "The duration unit.",
-              "$ref": "#/$defs/RangeUnit"
-            },
-            "is_radius": {
-              "description": "If `true`, the range is a radius.",
-              "const": true
-            }
-          },
-          "required": [
-            "unit"
-          ]
+        "base": {
+          "description": "The base value that is derived from the check result.",
+          "$ref": "./_ActivatableSkillCheckResultBased.schema.json#/$defs/CheckResultValue"
+        },
+        "modifier": {
+          "description": "If defined, it modifies the base value.",
+          "$ref": "./_ActivatableSkillCheckResultBased.schema.json#/$defs/CheckResultBasedModifier"
+        },
+        "unit": {
+          "description": "The duration unit.",
+          "$ref": "#/$defs/RangeUnit"
+        },
+        "is_radius": {
+          "description": "If `true`, the range is a radius.",
+          "const": true
         }
+      },
+      "required": [
+        "base",
+        "unit"
       ],
-      "type": "object",
-      "unevaluatedProperties": false
+      "additionalProperties": false
     },
     "RangeTranslation": {
       "type": "object",