Added Property-Parameter to SkillSelectOptionCategoryPrerequisite

src/cache/activatableSelectOptions.ts

@@ -17,7 +17,9 @@
   ImprovementCost,
   Poison,
   PrerequisiteForLevel,
+  Property_ID,
   RequirableSelectOptionIdentifier,
+  Ritual_ID,
   SelectOptionCategory,
   SelectOptions,
   SelectOptionsAdventurePointsValue,
@@ -28,9 +30,10 @@
   SkillSelectOptionCategoryPrerequisite,
   SpecificFromSkillSelectOptionCategoryCategory,
   SpecificTargetCategory,
+  Spell_ID,
   TargetCategory,
   TradeSecretAdventurePointsValue,
 } from "../../gen/types.js"
 import type { TSONDBTypes } from "../main.js"
 import type { IdMap } from "./index.ts"
 import type { CacheBuilder } from "./internal.ts"
@@ -67,17 +70,19 @@
 ): TradeSecretAdventurePointsValue | undefined =>
   apValue === undefined ? undefined : Case("Fixed", apValue)
 
-const matchesSpecificSkillishIdList = (
-  id: string,
-  config: SpecificFromSkillSelectOptionCategoryCategory<string>,
+const matchesSpecificSkillishIdList = <Ref>(
+  config: SpecificFromSkillSelectOptionCategoryCategory<Ref>,
+  matches: (required: Ref) => boolean,
 ): boolean => {
+  const isInList = config.list.some(matches)
+
   switch (config.operation.kind) {
     case "Intersection":
-      return config.list.includes(id)
+      return isInList
     case "Difference":
-      return !config.list.includes(id)
+      return !isInList
     default:
       return assertExhaustive(config.operation)
   }
 }
 
@@ -116,7 +121,7 @@
           ),
         }
       default:
         return assertExhaustive(p)
     }
   })
 }
@@ -132,7 +137,7 @@
   }
 
   return (
     bindingCost.Fixed.map.find(mapping => equalsSkillishIdGroup(mapping.id, id))?.bindingCost ??
     bindingCost.Fixed.default
   )
 }
@@ -159,7 +164,7 @@
         b.kind === "RangedCombatTechnique" && a.RangedCombatTechnique === b.RangedCombatTechnique
       )
     default:
       return assertExhaustive(a)
   }
 }
 
@@ -188,7 +193,7 @@
             case "D":
               return 4
             default:
               assertExhaustive(ic)
           }
         })() *
           (config.DerivedFromImprovementCost.multiplier ?? 1) +
@@ -196,11 +201,11 @@
       )
     case "Fixed":
       return (
         config.Fixed.map.find(mapping => equalsSkillishIdGroup(mapping.id, id))?.ap_value ??
         config.Fixed.default
       )
     default:
       return assertExhaustive(config)
   }
 }
 
@@ -233,22 +238,43 @@
   const { specific } = category
   return specific === undefined
     ? undefined
-    : ({ id }) => matchesSpecificSkillishIdList(id, specific)
+    : ({ id }) => matchesSpecificSkillishIdList(specific, required => required === id)
+}
+
+const getSpellworkFilter = <E extends "Spell" | "Ritual">(
+  category: GenericSkillsSelectOptionCategoryCategory<
+    Case<"Single", Spell_ID | Ritual_ID> | Case<"Property", Property_ID>
+  >,
+): ((instance: { id: string; content: Entity<TSONDBTypes, E> }) => boolean) | undefined => {
+  const { specific } = category
+  return specific === undefined
+    ? undefined
+    : ({ id, content: { property } }) =>
+        matchesSpecificSkillishIdList(specific, required => {
+          switch (required.kind) {
+            case "Single":
+              return required.Single === id
+            case "Property":
+              return property === required.Property
+            default:
+              return assertExhaustive(required)
+          }
+        })
 }
 
-const getDerivedSkillishSelectOptions = <E extends SkillishEntityName>(
+const getDerivedSkillishSelectOptions = <E extends SkillishEntityName, ID>(
   database: TSONDB<TSONDBTypes>,
   entryId: ActivatableIdentifier,
   entity: E,
-  category: GenericSkillsSelectOptionCategoryCategory<string> & {
+  category: GenericSkillsSelectOptionCategoryCategory<ID> & {
     skill_applications?: SkillApplicationOrUse[] | undefined
     skill_uses?: SkillApplicationOrUse[] | undefined
   },
   options: {
     bindingCost?: SelectOptionsBindingCostValue<SkillishIdentifier | CombatTechniqueIdentifier>
     ap_value?: SelectOptionsAdventurePointsValue<SkillishIdentifier | CombatTechniqueIdentifier>
   },
-  filter = getDefaultSkillishFilter<E>(category),
+  filter: ((instance: { id: string; content: Entity<TSONDBTypes, E> }) => boolean) | undefined,
 ) => {
   const { prerequisites } = category
   const { bindingCost, ap_value } = options
@@ -928,7 +954,10 @@
 
                 const matchesIdRequirement =
                   category.Skills.specific === undefined ||
-                  matchesSpecificSkillishIdList(id, category.Skills.specific)
+                  matchesSpecificSkillishIdList(
+                    category.Skills.specific,
+                    required => required === id,
+                  )
 
                 return matchesGroupRequirement && matchesIdRequirement
               },
@@ -940,6 +969,7 @@
               "Spell",
               category.Spells,
               selectOptionCategory.Skills,
+              getSpellworkFilter(category.Spells),
             )
           case "Rituals":
             return getDerivedSkillishSelectOptions(
@@ -948,6 +978,7 @@
               "Ritual",
               category.Rituals,
               selectOptionCategory.Skills,
+              getSpellworkFilter(category.Rituals),
             )
           case "LiturgicalChants":
             return getDerivedSkillishSelectOptions(
@@ -956,6 +987,7 @@
               "LiturgicalChant",
               category.LiturgicalChants,
               selectOptionCategory.Skills,
+              getDefaultSkillishFilter(category.LiturgicalChants),
             )
           case "Ceremonies":
             return getDerivedSkillishSelectOptions(
@@ -964,6 +996,7 @@
               "Ceremony",
               category.Ceremonies,
               selectOptionCategory.Skills,
+              getDefaultSkillishFilter(category.Ceremonies),
             )
           default:
             return assertExhaustive(category)
@@ -980,6 +1013,7 @@
               "CloseCombatTechnique",
               category.CloseCombatTechniques,
               selectOptionCategory.CombatTechniques,
+              getDefaultSkillishFilter(category.CloseCombatTechniques),
             )
           case "RangedCombatTechniques":
             return getDerivedSkillishSelectOptions(
@@ -988,6 +1022,7 @@
               "RangedCombatTechnique",
               category.RangedCombatTechniques,
               selectOptionCategory.CombatTechniques,
+              getDefaultSkillishFilter(category.RangedCombatTechniques),
             )
           default:
             return assertExhaustive(category)

src/types/_ActivatableSelectOptionCategory.ts

@@ -11,6 +11,7 @@ import {
   SkillIdentifier,
   SpellIdentifier,
   TargetCategoryIdentifier,
+  PropertyIdentifier,
 } from "./_Identifier.js"
 import {
   ActivatableIdentifier,
@@ -211,16 +212,34 @@ const SkillsSelectOptionCategory = DB.TypeAlias(import.meta.url, {
     }),
 })
 
+const SpellFilter = DB.Enum(import.meta.url, {
+  name: "SpellFilter",
+  values: () => ({
+    Single: DB.EnumCase({ type: SpellIdentifier() }),
+    Property: DB.EnumCase({ type: PropertyIdentifier() }),
+  }),
+})
+
+const RitualFilter = DB.Enum(import.meta.url, {
+  name: "RitualFilter",
+  values: () => ({
+    Single: DB.EnumCase({ type: RitualIdentifier() }),
+    Property: DB.EnumCase({ type: PropertyIdentifier() }),
+  }),
+})
+
 const SkillsSelectOptionCategoryCategory = DB.Enum(import.meta.url, {
   name: "SkillsSelectOptionCategoryCategory",
   values: () => ({
     Skills: DB.EnumCase({ type: DB.IncludeIdentifier(SkillSelectOptionCategoryCategory) }),
     Spells: DB.EnumCase({
-      type: DB.GenIncludeIdentifier(GenericSkillsSelectOptionCategoryCategory, [SpellIdentifier()]),
+      type: DB.GenIncludeIdentifier(GenericSkillsSelectOptionCategoryCategory, [
+        DB.IncludeIdentifierType(SpellFilter),
+      ]),
     }),
     Rituals: DB.EnumCase({
       type: DB.GenIncludeIdentifier(GenericSkillsSelectOptionCategoryCategory, [
-        RitualIdentifier(),
+        DB.IncludeIdentifierType(RitualFilter),
       ]),
     }),
     LiturgicalChants: DB.EnumCase({

src/types/prerequisites/single/PropertyPrerequisite.ts

@@ -0,0 +1,18 @@
+import * as DB from "tsondb/schema/dsl"
+import { PropertyIdentifier } from "../../_Identifier.js"
+import { DisplayOption } from "../DisplayOption.js"
+
+export const PropertyPrerequisite = DB.TypeAlias(import.meta.url, {
+  name: "PropertyPrerequisite",
+  comment: "Requires a specific property or one of a specific set of properties.",
+  type: () =>
+    DB.Object({
+      id: DB.Required({
+        comment: "The property�s identifier.",
+        type: PropertyIdentifier(),
+      }),
+      display_option: DB.Optional({
+        type: DB.IncludeIdentifier(DisplayOption),
+      }),
+    }),
+})