optolith-database-schema 0.39.0 → 0.41.0

package/lib/types/DerivedCharacteristic.d.ts

@@ -1,7 +1,27 @@
 import * as DB from "tsondb/schema/dsl";
+import type { DerivedCharacteristicBase } from "../../gen/types.js";
 import { MathOperation } from "./_MathExpression.ts";
 export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
     position: DB.MemberDecl<DB.Integer, true>;
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicType", {
+        Energy: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"EnergyType", DB.Object<{
+            purchase: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPurchase", DB.Object<{
+                improvementCost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+                    A: DB.EnumCase<null>;
+                    B: DB.EnumCase<null>;
+                    C: DB.EnumCase<null>;
+                    D: DB.EnumCase<null>;
+                }, []>>, true>;
+                maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+            }>, []>>, false>;
+            permanentLoss: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPermanentLoss", DB.Object<{
+                canBeBoughtBack: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBuyBack", DB.Object<{
+                    cost: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>, false>;
+            }>, []>>, false>;
+        }>, []>>>;
+        Resistance: DB.EnumCase<null>;
+    }, []>>, false>;
     calculation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicCalculation", DB.Object<{
         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
         modifiers: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicModifier", DB.Object<{
@@ -165,20 +185,6 @@ export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
             }, []>>, true>;
             value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, false>;
-        purchasable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPurchase", DB.Object<{
-            improvementCost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
-                A: DB.EnumCase<null>;
-                B: DB.EnumCase<null>;
-                C: DB.EnumCase<null>;
-                D: DB.EnumCase<null>;
-            }, []>>, true>;
-            maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
-        }>, []>>, false>;
-        permanentLoss: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPermanentLoss", DB.Object<{
-            canBeBoughtBack: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBuyBack", DB.Object<{
-                cost: DB.MemberDecl<DB.Integer, true>;
-            }>, []>>, false>;
-        }>, []>>, false>;
     }>, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
         Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
@@ -256,3 +262,6 @@ export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
         }>, []>>, false>;
     }>, true>;
 }, undefined>;
+declare const DerivedCharacteristicBase: DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>;
+export declare const calculationContainsRaceBase: (base: DerivedCharacteristicBase) => boolean;
+export {};

package/lib/types/DerivedCharacteristic.js

@@ -1,4 +1,6 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import * as DB from "tsondb/schema/dsl";
+import { fromUniformCase } from "tsondb/schema/gen";
 import { NestedTranslationMap } from "./Locale.js";
 import { AttributeIdentifier } from "./_Identifier.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
@@ -14,6 +16,10 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
             comment: "The position of the derived characteristic in lists. This has to be a unique value.",
             type: DB.Integer({ minimum: 0 }),
         }),
+        type: DB.Optional({
+            comment: "The derived characteristic may have a specific use in the game.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicType),
+        }),
         calculation: DB.Required({
             comment: "Instructions for calculating the derived characteristic’s value.",
             type: DB.IncludeIdentifier(DerivedCharacteristicCalculation),
@@ -59,6 +65,34 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
         },
     ],
 });
+const DerivedCharacteristicType = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicType",
+    comment: "The type of the derived characteristic, which determines how it can be used in the game.",
+    values: () => ({
+        Energy: DB.EnumCase({
+            comment: "The derived characteristic works like an energy in that it can be spent on various actions and abilities, and also be refilled based on certain conditions.",
+            type: DB.IncludeIdentifier(EnergyType),
+        }),
+        Resistance: DB.EnumCase({
+            comment: "The derived characteristic represents a resistance against certain effects.",
+            type: null,
+        }),
+    }),
+});
+const EnergyType = DB.TypeAlias(import.meta.url, {
+    name: "EnergyType",
+    comment: "Additional values that can be defined for an energy.",
+    type: () => DB.Object({
+        purchase: DB.Optional({
+            comment: "If set, the energy’s maximum value can be improved by spending AP.\n\nIf the energy’s permanent losses can be bought back, points will not be able to be purchased unless all permanent losses have been bought back.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPurchase),
+        }),
+        permanentLoss: DB.Optional({
+            comment: "If set, the energy can suffer permanent losses that reduce its maximum value. It may also be possible to buy back these permanent losses.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPermanentLoss),
+        }),
+    }),
+});
 const DerivedCharacteristicCalculation = DB.TypeAlias(import.meta.url, {
     name: "DerivedCharacteristicCalculation",
     type: () => DB.Object({
@@ -70,23 +104,6 @@ const DerivedCharacteristicCalculation = DB.TypeAlias(import.meta.url, {
             comment: "A list of modifiers that are applied to the base value. The modifiers are applied in the order they appear in the list.",
             type: DB.Array(DB.IncludeIdentifier(DerivedCharacteristicModifier), { minItems: 1 }),
         }),
-        purchasable: DB.Optional({
-            comment: "If set, the derived characteristic can be improved by spending AP.\n\nIf the derived characteristic’s permanent losses can be bought back, points will not be able to be purchased unless all permanent losses have been bought back.",
-            type: DB.IncludeIdentifier(DerivedCharacteristicPurchase),
-        }),
-        permanentLoss: DB.Optional({
-            comment: "If set, the derived characteristic can suffer permanent losses that reduce its maximum value. It may also be possible to buy back these permanent losses.",
-            type: DB.IncludeIdentifier(DerivedCharacteristicPermanentLoss),
-        }),
-    }),
-});
-const DerivedCharacteristicRaceBaseValue = DB.Enum(import.meta.url, {
-    name: "DerivedCharacteristicRaceBaseValue",
-    values: () => ({
-        LifePoints: DB.EnumCase({ type: null }),
-        Spirit: DB.EnumCase({ type: null }),
-        Toughness: DB.EnumCase({ type: null }),
-        Movement: DB.EnumCase({ type: null }),
     }),
 });
 const DerivedCharacteristicPrimaryAttributeValue = DB.Enum(import.meta.url, {
@@ -101,10 +118,7 @@ const DerivedCharacteristicBaseValue = DB.Enum(import.meta.url, {
     values: () => ({
         Constant: DB.EnumCase({ type: DB.Integer() }),
         Attribute: DB.EnumCase({ type: AttributeIdentifier() }),
-        RaceBaseValue: DB.EnumCase({
-            displayName: "Base Value from Race",
-            type: DB.IncludeIdentifier(DerivedCharacteristicRaceBaseValue),
-        }),
+        RaceBaseValue: DB.EnumCase({ displayName: "Base Value from Race", type: null }),
         PrimaryAttribute: DB.EnumCase({
             type: DB.IncludeIdentifier(DerivedCharacteristicPrimaryAttributeValue),
         }),
@@ -114,6 +128,29 @@ const DerivedCharacteristicBase = DB.TypeAlias(import.meta.url, {
     name: "DerivedCharacteristicBase",
     type: () => DB.GenIncludeIdentifier(MathOperation, [DB.IncludeIdentifier(DerivedCharacteristicBaseValue)]),
 });
+export const calculationContainsRaceBase = (base) => {
+    switch (base.kind) {
+        case "Value":
+            switch (base.Value.kind) {
+                case "RaceBaseValue":
+                    return true;
+                case "Constant":
+                case "Attribute":
+                case "PrimaryAttribute":
+                    return false;
+                default:
+                    return assertExhaustive(base.Value);
+            }
+        case "Addition":
+        case "Subtraction":
+        case "Multiplication":
+        case "Division":
+        case "Exponentiation": {
+            const [left, right] = fromUniformCase(base);
+            return calculationContainsRaceBase(left) || calculationContainsRaceBase(right);
+        }
+    }
+};
 const DerivedCharacteristicModifierOperation = DB.Enum(import.meta.url, {
     name: "DerivedCharacteristicModifierOperation",
     values: () => ({

package/lib/types/Disease.d.ts

@@ -41,6 +41,8 @@ export declare const Disease: DB.Entity<"Disease", {
             }>, [T: DB.Param<"T", DB.Type>]>>>;
         }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     }>, []>>, false>;
+    isChildhoodDisease: DB.MemberDecl<DB.Boolean, true>;
+    isMagicalDisease: DB.MemberDecl<DB.Boolean, true>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/Disease.js

@@ -14,6 +14,14 @@ export const Disease = DB.Entity(import.meta.url, {
             comment: "AP value and prerequisites of the disease’s trade secret.",
             type: DB.IncludeIdentifier(RecipeTradeSecret),
         }),
+        isChildhoodDisease: DB.Required({
+            comment: "Whether the disease is a childhood disease.",
+            type: DB.Boolean(),
+        }),
+        isMagicalDisease: DB.Required({
+            comment: "Whether the disease is a magical disease.",
+            type: DB.Boolean(),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Disease", DiseaseTranslation),
     }),

package/lib/types/Locale.d.ts

@@ -1327,6 +1327,13 @@ export declare const Locale: DB.Entity<"Locale", {
         Volume: null;
         Penalty: null;
         "Binding Cost": null;
+        "one or two of these special abilities can alternatively be replaced by advanced special abilities {$first} and/or {$second}": null;
+        ".input {$count :number} {{{$count} more by primary patron}}": null;
+        Patron: null;
+        "corresponding combat style special ability": null;
+        "corresponding liturgical style special ability": null;
+        "corresponding magic style special ability": null;
+        "corresponding skill style special ability": null;
         All: null;
         "All Close Combat Techniques": null;
         "All Ranged Combat Techniques": null;

package/lib/types/Locale.js

@@ -1361,6 +1361,13 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Volume": null,
                 "Penalty": null,
                 "Binding Cost": null,
+                "one or two of these special abilities can alternatively be replaced by advanced special abilities {$first} and/or {$second}": null,
+                ".input {$count :number} {{{$count} more by primary patron}}": null,
+                "Patron": null,
+                "corresponding combat style special ability": null,
+                "corresponding liturgical style special ability": null,
+                "corresponding magic style special ability": null,
+                "corresponding skill style special ability": null,
                 // combat special ability -- applicable combat techniques
                 "All": null,
                 "All Close Combat Techniques": null,

package/lib/types/Profession.d.ts

@@ -71,6 +71,7 @@ export declare const Profession: DB.Entity<"Profession", {
                 }>, []>>, false>;
                 skills: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillsOptions", DB.Object<{
                     group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                     ap_value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
                 liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
@@ -79,7 +80,8 @@ export declare const Profession: DB.Entity<"Profession", {
             }>, []>>, false>;
             special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                 Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -156,7 +158,8 @@ export declare const Profession: DB.Entity<"Profession", {
                 }>, []>>>;
                 Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                     options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                            Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -342,7 +345,8 @@ export declare const Profession: DB.Entity<"Profession", {
                     }, []>>, true>;
                     value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                         Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                                Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -419,7 +423,8 @@ export declare const Profession: DB.Entity<"Profession", {
                         }>, []>>>;
                         Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -704,6 +709,7 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
             }>, []>>, false>;
             skills: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillsOptions", DB.Object<{
                 group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 ap_value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, false>;
             liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
@@ -712,7 +718,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
         }>, []>>, false>;
         special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
             Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -789,7 +796,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
             }>, []>>>;
             Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                 options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -975,7 +983,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                 }, []>>, true>;
                 value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                     Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                            Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1052,7 +1061,8 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
                     }>, []>>>;
                     Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                         options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                                Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1329,6 +1339,7 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
         }>, []>>, false>;
         skills: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillsOptions", DB.Object<{
             group: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             ap_value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, false>;
         liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
@@ -1337,7 +1348,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
     }>, []>>, false>;
     special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
         Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1414,7 +1426,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
         }>, []>>>;
         Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1600,7 +1613,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
             }, []>>, true>;
             value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                 Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1677,7 +1691,8 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
                 }>, []>>>;
                 Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                     options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                            Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1874,7 +1889,8 @@ export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
         }, []>>, true>;
         value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
             Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1951,7 +1967,8 @@ export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
             }>, []>>>;
             Selection: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionSpecialAbilitySelection", DB.Object<{
                 options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantProfessionSpecialAbility", DB.Object<{
-                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityIdentifier", {
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+                        Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                         AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/Profession.js

@@ -1,7 +1,8 @@
+import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { AdvantageIdentifier, CantripIdentifier, CurriculumIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionPackageIdentifier, ProfessionVersionIdentifier, SkillGroupIdentifier, SkillIdentifier, } from "./_Identifier.js";
-import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, RequirableSelectOptionIdentifier, SpecialAbilityIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
+import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RequirableSelectOptionIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
 import { ProfessionPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
@@ -305,7 +306,7 @@ const ConstantProfessionSpecialAbility = DB.TypeAlias(import.meta.url, {
     type: () => DB.Object({
         id: DB.Required({
             comment: "The identifier of the special ability to grant.",
-            type: DB.IncludeIdentifier(SpecialAbilityIdentifier),
+            type: DB.IncludeIdentifier(ProfessionSpecialAbilityIdentifier),
         }),
         level: DB.Optional({
             comment: "The level of the received special ability. If not specified and the special ability has levels, level 1 is used automatically.",
@@ -585,11 +586,20 @@ const SkillsOptions = DB.TypeAlias(import.meta.url, {
             comment: "If specified, you may only choose from skills of the specified group.",
             type: SkillGroupIdentifier(),
         }),
+        specific: DB.Optional({
+            comment: "The list of specific skills to distribute AP to.",
+            type: DB.Array(SkillIdentifier(), { minItems: 2 }),
+        }),
         ap_value: DB.Required({
             comment: "The AP value you can buy skills for.",
             type: DB.Integer({ minimum: 1 }),
         }),
     }),
+    customConstraints: ({ instanceContent, getInstanceById }) => [
+        (instanceContent.specific?.some(skillId => getInstanceById("Skill", skillId)?.group !== instanceContent.group) ?? false)
+            ? "All selected skills must be from the selected group."
+            : undefined,
+    ].filter(isNotNullish),
 });
 const LiturgiesOptions = DB.TypeAlias(import.meta.url, {
     name: "LiturgiesOptions",

package/lib/types/Race.d.ts

@@ -1,21 +1,8 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const Race: DB.Entity<"Race", {
     ap_value: DB.MemberDecl<DB.Integer, true>;
-    base_values: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BaseValues", DB.Object<{
-        life_points: DB.MemberDecl<DB.Integer, true>;
-        spirit: DB.MemberDecl<DB.Integer, true>;
-        toughness: DB.MemberDecl<DB.Integer, true>;
-        movement: DB.MemberDecl<DB.Integer, true>;
-    }>, []>>, true>;
-    attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{
-        fixed: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAttributeAdjustment", DB.Object<{
-            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
-            value: DB.MemberDecl<DB.Integer, true>;
-        }>, []>>>, false>;
-        selectable: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectableAttributeAdjustment", DB.Object<{
-            list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
-            value: DB.MemberDecl<DB.Integer, true>;
-        }>, []>>>, false>;
+    base_values: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BaseValues", DB.NestedEntityMap<string, {
+        value: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
     automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
@@ -56,6 +43,16 @@ export declare const Race: DB.Entity<"Race", {
     }>, true>;
     variants: DB.MemberDecl<DB.ChildEntities<DB.Entity<"RaceVariant", {
         race: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{
+            fixed: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAttributeAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>, false>;
+            selectable: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectableAttributeAdjustment", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>, false>;
+        }>, []>>, true>;
         common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
@@ -154,6 +151,16 @@ export declare const Race: DB.Entity<"Race", {
 }, undefined>;
 export declare const RaceVariant: DB.Entity<"RaceVariant", {
     race: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{
+        fixed: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAttributeAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, false>;
+        selectable: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectableAttributeAdjustment", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, false>;
+    }>, []>>, true>;
     common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;

package/lib/types/Race.js

@@ -1,7 +1,9 @@
+import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { Dice, DieType } from "./_Dice.js";
 import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, EyeColorIdentifier, HairColorIdentifier, RaceIdentifier, } from "./_Identifier.js";
+import { calculationContainsRaceBase, DerivedCharacteristic } from "./DerivedCharacteristic.js";
 import { ExperienceLevel } from "./ExperienceLevel.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
@@ -18,10 +20,6 @@ export const Race = DB.Entity(import.meta.url, {
             comment: "The race’s base values.",
             type: DB.IncludeIdentifier(BaseValues),
         }),
-        attribute_adjustments: DB.Required({
-            comment: "Describes how to raise or lower maximum attribute values during character creation.",
-            type: DB.IncludeIdentifier(AttributeAdjustments),
-        }),
         automatic_advantages: DB.Optional({
             comment: "A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.",
             type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]), {
@@ -105,25 +103,29 @@ export const Race = DB.Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, getAllInstanceContainers, getDisplayNameAndId }) => {
+        const expectedBaseValues = getAllInstanceContainers("DerivedCharacteristic").filter(dc => calculationContainsRaceBase(dc.content.calculation.base));
+        const actualBaseValues = Object.keys(instanceContent.base_values);
+        return [
+            expectedBaseValues.length !== actualBaseValues.length ||
+                actualBaseValues.some(actual => !expectedBaseValues.some(expected => actual === expected.id))
+                ? `The race needs to define base values for ${expectedBaseValues.map(dc => getDisplayNameAndId("DerivedCharacteristic", dc.id)).join(", ")}, but defines ${actualBaseValues.map(dcId => getDisplayNameAndId("DerivedCharacteristic", dcId)).join(", ")}.`
+                : null,
+        ].filter(isNotNullish);
+    },
 });
 const BaseValues = DB.TypeAlias(import.meta.url, {
     name: "BaseValues",
-    type: () => DB.Object({
-        life_points: DB.Required({
-            comment: "The race’s life point base value.",
-            type: DB.Integer(),
-        }),
-        spirit: DB.Required({
-            comment: "The race’s Spirit base value.",
-            type: DB.Integer(),
-        }),
-        toughness: DB.Required({
-            comment: "The race’s Toughness base value.",
-            type: DB.Integer(),
-        }),
-        movement: DB.Required({
-            comment: "The race’s tactical movement rate.",
-            type: DB.Integer(),
+    type: () => DB.NestedEntityMap({
+        name: "RaceBaseValue",
+        namePlural: "RaceBaseValues",
+        comment: "The base value for a derived characteristic that is granted by the race.",
+        secondaryEntity: DerivedCharacteristic,
+        type: DB.Object({
+            value: DB.Required({
+                comment: "The base value for the derived characteristic that is granted by the race.",
+                type: DB.Integer(),
+            }),
         }),
     }),
 });
@@ -233,6 +235,10 @@ export const RaceVariant = DB.Entity(import.meta.url, {
             comment: "The associated race.",
             type: RaceIdentifier(),
         }),
+        attribute_adjustments: DB.Required({
+            comment: "Describes how to raise or lower maximum attribute values during character creation.",
+            type: DB.IncludeIdentifier(AttributeAdjustments),
+        }),
         common_cultures: DB.Optional({
             comment: "The list of common cultures.",
             type: DB.Array(CultureIdentifier(), { minItems: 1 }),