Merge branch 'main' into feature/books-rework

This commit is contained in:
Lector
2026-06-26 01:42:09 +02:00
committed by GitHub
61 changed files with 865 additions and 787 deletions
+112
View File
@@ -2,6 +2,118 @@
All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
## [0.53.0](https://github.com/Optolith/database-schema/compare/v0.52.2...v0.53.0) (2026-06-21)
### ⚠ BREAKING CHANGES
* add bannzeichen cost map
### Features
* add bannzeichen cost map ([0e25dbf](https://github.com/Optolith/database-schema/commit/0e25dbf4a70275b9ba87f1d6b50f8e0c5ac806c1))
* separate tradition artifact enhancement identifiers ([7e97792](https://github.com/Optolith/database-schema/commit/7e977925b52135859dc4335dcf4238c1271c1a02))
## [0.52.2](https://github.com/Optolith/database-schema/compare/v0.52.1...v0.52.2) (2026-06-21)
### Bug Fixes
* combined unique constraint for botanic regions ([249af59](https://github.com/Optolith/database-schema/commit/249af59f6ac7549fa91ad756f8f12d4802593a3a))
## [0.52.1](https://github.com/Optolith/database-schema/compare/v0.52.0...v0.52.1) (2026-06-20)
### Features
* optional translation for combat technique restrictions ([1e30f55](https://github.com/Optolith/database-schema/commit/1e30f55407cae829aae2d1a1097c30eff4c68f3a)), closes [#169](https://github.com/Optolith/database-schema/issues/169) [#168](https://github.com/Optolith/database-schema/issues/168)
## [0.52.0](https://github.com/Optolith/database-schema/compare/v0.51.0...v0.52.0) (2026-06-19)
### ⚠ BREAKING CHANGES
* enchantment cost map
### Features
* botanic region uniqueness per parent ([3b522aa](https://github.com/Optolith/database-schema/commit/3b522aa9d7a76b1d8dafa3a89b1712ecba4b0c85)), closes [#166](https://github.com/Optolith/database-schema/issues/166) [#165](https://github.com/Optolith/database-schema/issues/165)
* enchantment cost map ([894fe21](https://github.com/Optolith/database-schema/commit/894fe21536d21c2bbc618ec77279da96f5303f06)), closes [#167](https://github.com/Optolith/database-schema/issues/167) [#164](https://github.com/Optolith/database-schema/issues/164)
## [0.51.0](https://github.com/Optolith/database-schema/compare/v0.50.1...v0.51.0) (2026-06-18)
### ⚠ BREAKING CHANGES
* rework plants schema
### Features
* add schemas for goblin tradition artifact enchantments ([da1d245](https://github.com/Optolith/database-schema/commit/da1d2459db003a624cce4d84c2695b927d7476f0)), closes [#163](https://github.com/Optolith/database-schema/issues/163) [#162](https://github.com/Optolith/database-schema/issues/162)
* rework plants schema ([6c62616](https://github.com/Optolith/database-schema/commit/6c6261628583cda5a27d34c194e5aae69c38a079)), closes [#161](https://github.com/Optolith/database-schema/issues/161) [#160](https://github.com/Optolith/database-schema/issues/160)
## [0.50.1](https://github.com/Optolith/database-schema/compare/v0.50.0...v0.50.1) (2026-06-14)
### Features
* primary blessing for tradition ([9d97dd4](https://github.com/Optolith/database-schema/commit/9d97dd4ec95c8dd42cb6e31873a4702684a941de))
* trade secrets for herbal aids ([27236a7](https://github.com/Optolith/database-schema/commit/27236a75884fdb891a60a0105ebb5ff82147cbc1)), closes [#159](https://github.com/Optolith/database-schema/issues/159) [#158](https://github.com/Optolith/database-schema/issues/158)
## [0.50.0](https://github.com/Optolith/database-schema/compare/v0.49.0...v0.50.0) (2026-06-14)
### ⚠ BREAKING CHANGES
* allow arbitrary AP values for enhancements
### Features
* allow arbitrary AP values for enhancements ([1d06407](https://github.com/Optolith/database-schema/commit/1d06407eb4dee8fec24bc9f8d0d6e31833e4f995))
* allow arbitrary text input for enhancements ([3a3af6e](https://github.com/Optolith/database-schema/commit/3a3af6e574c1a7d05113ebc75d5d6fa1b92c8dce))
## [0.49.0](https://github.com/Optolith/database-schema/compare/v0.48.0...v0.49.0) (2026-06-13)
### ⚠ BREAKING CHANGES
* add missing skill rating case to parameter expression
### Bug Fixes
* add missing skill rating case to parameter expression ([64ee1cc](https://github.com/Optolith/database-schema/commit/64ee1cce6adccc2027bb890289b31e2cea653645))
## [0.48.0](https://github.com/Optolith/database-schema/compare/v0.47.4...v0.48.0) (2026-06-13)
### ⚠ BREAKING CHANGES
* unify some skill durations and ranges with expressions
### Features
* unify some skill durations and ranges with expressions ([31798ca](https://github.com/Optolith/database-schema/commit/31798ca33fab12b1d1c0c6edec0c543173c8f4ac))
## [0.47.4](https://github.com/Optolith/database-schema/compare/v0.47.3...v0.47.4) (2026-06-13)
### Features
* culture language translations ([b5ece95](https://github.com/Optolith/database-schema/commit/b5ece951032138b19cb02dfc8172177bd337b37f))
## [0.47.3](https://github.com/Optolith/database-schema/compare/v0.47.2...v0.47.3) (2026-06-13)
### Features
* level and options for automatic and str. rec. dis/advantages in sub-races ([a7b8e7e](https://github.com/Optolith/database-schema/commit/a7b8e7ec0c6c1c90b8a656b9b19cd156d403382b)), closes [#150](https://github.com/Optolith/database-schema/issues/150)
* optional sources for skill applications ([cdb86e9](https://github.com/Optolith/database-schema/commit/cdb86e9aa6768601c9f017f01bde6d70108db083))
### Bug Fixes
* profession cantrips must be unique ([6c9f7a6](https://github.com/Optolith/database-schema/commit/6c9f7a6ec2bafb35c40680d1199739f1b435e6a9))
## [0.47.2](https://github.com/Optolith/database-schema/compare/v0.47.1...v0.47.2) (2026-06-08)
+6 -6
View File
@@ -1,15 +1,15 @@
{
"name": "@optolith/database-schema",
"version": "0.47.2",
"version": "0.53.0",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "@optolith/database-schema",
"version": "0.47.2",
"version": "0.53.0",
"license": "MPL-2.0",
"dependencies": {
"@elyukai/utils": "^0.3.4",
"@elyukai/utils": "^0.3.6",
"tsondb": "^0.20.3",
"yaml": "^2.9.0"
},
@@ -60,9 +60,9 @@
}
},
"node_modules/@elyukai/utils": {
"version": "0.3.4",
"resolved": "https://registry.npmjs.org/@elyukai/utils/-/utils-0.3.4.tgz",
"integrity": "sha512-zqBF3Nz7Pd5e35E2mZuImeAvCSRlAneIWb/gZKtaa9yX1oPTW/4uVKrK5k7QE9pR7xMPo7FTUs2jZ5ZDaZ75PA==",
"version": "0.3.6",
"resolved": "https://registry.npmjs.org/@elyukai/utils/-/utils-0.3.6.tgz",
"integrity": "sha512-SFij3T0baqFu+G5NGjlHPVpLtKEeVRKg59jiMr7wQwAYM7LLpgoArBLeM/UL98FM0ntmvaRDDEBCfyMcCnsxdA==",
"license": "MPL-2.0"
},
"node_modules/@eslint-community/eslint-utils": {
+2 -2
View File
@@ -1,6 +1,6 @@
{
"name": "@optolith/database-schema",
"version": "0.47.2",
"version": "0.53.0",
"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",
@@ -38,7 +38,7 @@
"author": "Lukas Obermann",
"license": "MPL-2.0",
"dependencies": {
"@elyukai/utils": "^0.3.4",
"@elyukai/utils": "^0.3.6",
"tsondb": "^0.20.3",
"yaml": "^2.9.0"
},
+3
View File
@@ -1118,8 +1118,10 @@ const cacheKeyBase: Record<ActivatableIdentifier["kind"], null> = {
FoolsHatEnchantment: null,
GeneralSpecialAbility: null,
Haubenzauber: null,
Hauerkettenzauber: null,
InstrumentEnchantment: null,
KarmaSpecialAbility: null,
Keulenzauber: null,
Krallenkettenzauber: null,
Kristallkugelzauber: null,
LiturgicalStyleSpecialAbility: null,
@@ -1132,6 +1134,7 @@ const cacheKeyBase: Record<ActivatableIdentifier["kind"], null> = {
PactGift: null,
ProtectiveWardingCircleSpecialAbility: null,
RingEnchantment: null,
Schweinetrommelzauber: null,
Sermon: null,
SexSpecialAbility: null,
SickleRitual: null,
+6
View File
@@ -51,6 +51,7 @@ export const schema = new Schema<TSONDBTypes>(
Types.BlessedTradition,
Types.Blessing,
Types.Book,
Types.BotanicRegion,
Types.BowlEnchantment,
Types.BrawlingSpecialAbility,
Types.Brew,
@@ -97,8 +98,10 @@ export const schema = new Schema<TSONDBTypes>(
Types.GoblinRitual,
Types.Guideline,
Types.HairColor,
Types.Hauerkettenzauber,
Types.Haubenzauber,
Types.HerbalAid,
Types.HerbalPreservation,
Types.HomunculusType,
Types.IlluminationLightSource,
Types.IlluminationRefillOrSupply,
@@ -106,6 +109,7 @@ export const schema = new Schema<TSONDBTypes>(
Types.JesterTrick,
Types.Jewelry,
Types.KarmaSpecialAbility,
Types.Keulenzauber,
Types.Krallenkettenzauber,
Types.Kristallkugelzauber,
Types.Laboratory,
@@ -148,6 +152,7 @@ export const schema = new Schema<TSONDBTypes>(
Types.RingEnchantment,
Types.Ritual,
Types.RopeOrChain,
Types.Schweinetrommelzauber,
Types.Script,
Types.Sermon,
Types.Service,
@@ -165,6 +170,7 @@ export const schema = new Schema<TSONDBTypes>(
Types.StaffEnchantment,
Types.State,
Types.Stationery,
Types.SubBiome,
Types.Subject,
Types.Talisman,
Types.TargetCategory,
+19
View File
@@ -146,6 +146,25 @@ const CultureLanguage = DB.TypeAlias(import.meta.url, {
comment: "The language specializations, if any.",
type: DB.Array(LanguageSpecializationIdentifier(), { minItems: 1, uniqueItems: true }),
}),
translations: NestedTranslationMap(
DB.Optional,
"CultureLanguage",
DB.Object(
{
specialization: DB.Optional({
comment:
"The concrete language specialization, if the language allows to specify arbitrary text.",
type: DB.String({ minLength: 1 }),
}),
specializationPrompt: DB.Optional({
comment:
"A different promt fro the language specialization, if the language allows to specify arbitrary text.",
type: DB.String({ minLength: 1 }),
}),
},
{ minProperties: 1 },
),
),
}),
})
+2 -2
View File
@@ -6,7 +6,7 @@ import {
} from "./_ActivatableSkillCost.js"
import {
DurationUnitValue,
FixedDuration,
ExpressionBasedDuration,
IndefiniteDuration,
} from "./_ActivatableSkillDuration.js"
import {
@@ -188,7 +188,7 @@ const FamiliarsTrickOneTimeDuration = DB.Enum(import.meta.url, {
name: "FamiliarsTrickOneTimeDuration",
values: () => ({
Immediate: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDuration) }),
}),
})
+6
View File
@@ -1042,6 +1042,12 @@ export const Locale = DB.Entity(import.meta.url, {
".input {$value :number} .input {$style :string} {{{$value} years}}": null,
"{$value} years": null,
"years": null,
".input {$value :number} .input {$style :string} {{{$value} dcs.}}": null,
"{$value} dcs.": null,
"dcs.": null,
".input {$value :number} .input {$style :string} {{{$value} decades}}": null,
"{$value} decades": null,
"decades": null,
".input {$value :number} .input {$style :string} {{{$value} cent.}}": null,
"{$value} cent.": null,
"cent.": null,
+2 -1
View File
@@ -8,7 +8,7 @@ import { ImprovementCost } from "./_ImprovementCost.js"
import { SkillCheck } from "./_SkillCheck.js"
import { NestedTranslationMap } from "./Locale.js"
import { Errata } from "./source/_Erratum.js"
import { src } from "./source/_PublicationRef.js"
import { optionalSrc, src } from "./source/_PublicationRef.js"
export const Skill = DB.Entity(import.meta.url, {
name: "Skill",
@@ -125,6 +125,7 @@ export const SkillApplication = DB.Entity(import.meta.url, {
comment: "The skill this application belongs to.",
type: SkillIdentifier(),
}),
src: optionalSrc,
translations: NestedTranslationMap(
DB.Required,
"SkillApplication",
+6
View File
@@ -15,6 +15,12 @@ export const name_in_library = DB.Optional({
type: DB.String({ minLength: 1 }),
})
export const additionalName = DB.Optional({
comment:
"A part of the name that is appended in parenthesis. This can be used to specify the group of people that typically uses this entry (e.g. the name of the witch circle for a magic style for witches).\n\nIf `name_in_library` is specified, this will be ignored for places where the `name_in_library` is used.",
type: DB.String({ minLength: 1 }),
})
export const levels = DB.Optional({
comment: "Number of available levels.",
type: DB.Integer({ minimum: 2 }),
+11
View File
@@ -9,6 +9,7 @@ import {
CombatRelatedSpecialAbilityIdentifier,
CombatTechniqueIdentifier,
} from "./_IdentifierGroup.js"
import { NestedTranslationMap } from "./Locale.js"
const CombatSpecialAbilityUsageType = DB.Enum(import.meta.url, {
name: "CombatSpecialAbilityUsageType",
@@ -323,6 +324,16 @@ const SpecificApplicableCombatTechnique = DB.TypeAlias(import.meta.url, {
restriction: DB.Optional({
type: DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestriction),
}),
translation: NestedTranslationMap(
DB.Optional,
"SpecificApplicableCombatTechnique",
DB.Object({
restriction: DB.Required({
comment: "The additional restriction of the combat technique.",
type: DB.String({ minLength: 1, markdown: "inline" }),
}),
}),
),
weapons: DB.Optional({
comment: "The specific weapons this combat special ability is only applicable to.",
type: DB.Array(WeaponIdentifier(), { minItems: 1 }),
+7
View File
@@ -4,6 +4,7 @@ import { DurationUnitValue } from "./_ActivatableSkillDuration.js"
import { AspectIdentifier, PropertyIdentifier } from "./_Identifier.js"
import { VolumePointsOptionReferenceIdentifier } from "./_IdentifierGroup.js"
import { ResponsiveText, ResponsiveTextOptional } from "./_ResponsiveText.js"
import { OneTimeCostMap } from "./_ActivatableSkillCost.js"
const EnchantmentCost = DB.Enum(import.meta.url, {
name: "EnchantmentCost",
@@ -13,6 +14,11 @@ const EnchantmentCost = DB.Enum(import.meta.url, {
}),
})
export const cost_note = DB.Optional({
comment: "A note, appended to the generated cost string in parenthesis.",
type: DB.IncludeIdentifier(ResponsiveTextOptional),
})
export const cost = DB.Optional({
comment: "The cost when casting the entry.",
type: DB.IncludeIdentifier(EnchantmentCost),
@@ -32,6 +38,7 @@ export const ArcaneEnergyCost = DB.Enum(import.meta.url, {
Disjunction: DB.EnumCase({ type: DB.IncludeIdentifier(ArcaneEnergyCostDisjunction) }),
Variable: DB.EnumCase({ type: null }),
ByLevel: DB.EnumCase({ type: DB.IncludeIdentifier(ArcaneEnergyCostByLevel) }),
Map: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeCostMap) }),
}),
})
+19
View File
@@ -7,6 +7,7 @@ import { FastCastingTime, SlowCastingTime } from "./_ActivatableSkillCastingTime
import { OneTimeCost, SustainedCost } from "./_ActivatableSkillCost.js"
import { DurationForOneTime, DurationForSustained } from "./_ActivatableSkillDuration.js"
import { Range } from "./_ActivatableSkillRange.js"
import { MathOperation } from "./_MathExpression.ts"
export const OneTimePerformanceParameters = DB.GenTypeAlias(import.meta.url, {
name: "OneTimePerformanceParameters",
@@ -104,3 +105,21 @@ export const OldParameter = DB.TypeAlias(import.meta.url, {
}),
}),
})
export const ExpressionBasedParameterValue = DB.TypeAlias(import.meta.url, {
name: "ExpressionBasedParameterValue",
type: () =>
DB.GenIncludeIdentifier(MathOperation, [
DB.IncludeIdentifier(ExpressionBasedParameterExpressionValue),
]),
})
const ExpressionBasedParameterExpressionValue = DB.Enum(import.meta.url, {
name: "ExpressionBasedParameterExpressionValue",
values: () => ({
Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
QualityLevels: DB.EnumCase({ type: null }),
SkillPoints: DB.EnumCase({ type: null }),
SkillRating: DB.EnumCase({ type: null }),
}),
})
@@ -1,15 +1,5 @@
import * as DB from "tsondb/schema/dsl"
export const CheckResultValue = DB.Enum(import.meta.url, {
name: "CheckResultValue",
comment: "Defines the derived (unitless) value.",
values: () => ({
QualityLevels: DB.EnumCase({ type: null }),
SkillPoints: DB.EnumCase({ type: null }),
SkillRating: DB.EnumCase({ type: null }),
}),
})
const CheckResultArithmetic = DB.Enum(import.meta.url, {
name: "CheckResultArithmetic",
comment: "Defines how the the `value` is set off against the check result.",
@@ -33,19 +23,3 @@ export const CheckResultBasedModifier = DB.TypeAlias(import.meta.url, {
}),
}),
})
export const CheckResultBased = DB.TypeAlias(import.meta.url, {
name: "CheckResultBased",
comment: "Defines a parameter being based on a check result.",
type: () =>
DB.Object({
base: DB.Required({
comment: "The base value that is derived from the check result.",
type: DB.IncludeIdentifier(CheckResultValue),
}),
modifier: DB.Optional({
comment: "If defined, it modifies the base value.",
type: DB.IncludeIdentifier(CheckResultBasedModifier),
}),
}),
})
+9 -13
View File
@@ -1,5 +1,5 @@
import * as DB from "tsondb/schema/dsl"
import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js"
import { ExpressionBasedParameterValue } from "./_ActivatableSkill.ts"
import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js"
import { NestedTranslationMap } from "./Locale.js"
@@ -8,8 +8,7 @@ export const DurationForOneTime = DB.Enum(import.meta.url, {
values: () => ({
Immediate: DB.EnumCase({ type: DB.IncludeIdentifier(Immediate) }),
Permanent: DB.EnumCase({ type: DB.IncludeIdentifier(PermanentDuration) }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDuration) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDuration) }),
}),
})
@@ -84,21 +83,17 @@ export const FixedDuration = DB.TypeAlias(import.meta.url, {
}),
})
export const CheckResultBasedDuration = DB.TypeAlias(import.meta.url, {
name: "CheckResultBasedDuration",
export const ExpressionBasedDuration = DB.TypeAlias(import.meta.url, {
name: "ExpressionBasedDuration",
type: () =>
DB.Object({
is_maximum: DB.Optional({
comment: "If the duration is the maximum duration, so it may end earlier.",
type: DB.Boolean(),
}),
base: DB.Required({
comment: "The base value that is derived from the check result.",
type: DB.IncludeIdentifier(CheckResultValue),
}),
modifier: DB.Optional({
comment: "If defined, it modifies the base value.",
type: DB.IncludeIdentifier(CheckResultBasedModifier),
value: DB.Required({
comment: "An expression that evaluates to the duration.",
type: DB.IncludeIdentifier(ExpressionBasedParameterValue),
}),
unit: DB.Required({
comment: "The duration unit.",
@@ -106,7 +101,7 @@ export const CheckResultBasedDuration = DB.TypeAlias(import.meta.url, {
}),
translations: NestedTranslationMap(
DB.Optional,
"CheckResultBasedDuration",
"ExpressionBasedDuration",
DB.Object({
replacement: DB.Optional({
comment: "A replacement string.",
@@ -155,6 +150,7 @@ export const DurationUnit = DB.Enum(import.meta.url, {
Weeks: DB.EnumCase({ type: null }),
Months: DB.EnumCase({ type: null }),
Years: DB.EnumCase({ type: null }),
Decades: DB.EnumCase({ type: null }),
Centuries: DB.EnumCase({ type: null }),
Actions: DB.EnumCase({ type: null }),
CombatRounds: DB.EnumCase({ type: null }),
+7 -12
View File
@@ -1,5 +1,5 @@
import * as DB from "tsondb/schema/dsl"
import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js"
import { ExpressionBasedParameterValue } from "./_ActivatableSkill.ts"
import { SkillModificationLevelIdentifier } from "./_Identifier.js"
import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js"
import { NestedTranslationMap } from "./Locale.js"
@@ -42,8 +42,7 @@ const RangeValue = DB.Enum(import.meta.url, {
Self: DB.EnumCase({ type: null }),
Global: DB.EnumCase({ comment: "German: *dereumfassend*", type: null }),
Touch: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedRange) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedRange) }),
}),
})
@@ -89,21 +88,17 @@ export const FixedRange = DB.TypeAlias(import.meta.url, {
}),
})
const CheckResultBasedRange = DB.TypeAlias(import.meta.url, {
name: "CheckResultBasedRange",
export const ExpressionBasedRange = DB.TypeAlias(import.meta.url, {
name: "ExpressionBasedRange",
type: () =>
DB.Object({
is_maximum: DB.Optional({
comment: "If the range is the maximum range.",
type: DB.Boolean(),
}),
base: DB.Required({
comment: "The base value that is derived from the check result.",
type: DB.IncludeIdentifier(CheckResultValue),
}),
modifier: DB.Optional({
comment: "If defined, it modifies the base value.",
type: DB.IncludeIdentifier(CheckResultBasedModifier),
value: DB.Required({
comment: "An expression that evaluates to the range.",
type: DB.IncludeIdentifier(ExpressionBasedParameterValue),
}),
unit: DB.Required({
comment: "The duration unit.",
+38 -6
View File
@@ -3,6 +3,7 @@
*/
import * as DB from "tsondb/schema/dsl"
import { input } from "./_Activatable.ts"
import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js"
import { EnhancementPrerequisites } from "./_Prerequisite.js"
import { NestedTranslationMap } from "./Locale.js"
@@ -32,12 +33,9 @@ export const Enhancement = DB.Entity(import.meta.url, {
multipleOf: 2,
}),
}),
adventure_points_modifier: DB.Required({
comment:
"The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
type: DB.Integer({
minimum: 1,
}),
adventurePoints: DB.Required({
comment: "Defines how to determine the AP cost of an enhancement.",
type: DB.IncludeIdentifier(EnhancementAdventurePoints),
}),
prerequisites: DB.Optional({
type: DB.IncludeIdentifier(EnhancementPrerequisites),
@@ -63,6 +61,7 @@ export const Enhancement = DB.Entity(import.meta.url, {
markdown: "block",
}),
}),
input,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
@@ -92,3 +91,36 @@ export const Enhancement = DB.Entity(import.meta.url, {
],
],
})
const EnhancementAdventurePoints = DB.Enum(import.meta.url, {
name: "EnhancementAdventurePoints",
comment: "Defines how to determine the AP cost of an enhancement.",
values: () => ({
DerivedFromImprovementCost: DB.EnumCase({
comment:
"Use the numeric representation of the associated skill's improvement cost as the AP cost of this enhancement.",
type: DB.IncludeIdentifier(DerivedEnhancementAdventurePoints),
}),
Constant: DB.EnumCase({
comment: "Use the specified constant value as the AP cost of this enhancement.",
type: DB.Integer({
minimum: 1,
}),
}),
}),
})
const DerivedEnhancementAdventurePoints = DB.TypeAlias(import.meta.url, {
name: "DerivedEnhancementAdventurePoints",
type: () =>
DB.Object({
multiplier: DB.Required({
comment:
"The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
type: DB.Integer({
minimum: 1,
maximum: 3,
}),
}),
}),
})
+12
View File
@@ -33,6 +33,7 @@ import { Elixir } from "./equipment/item/Elixir.js"
import { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js"
import { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js"
import { HerbalAid } from "./equipment/item/HerbalAid.js"
import { HerbalPreservation } from "./equipment/item/HerbalPreservation.js"
import { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js"
import { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js"
import { Jewelry } from "./equipment/item/Jewelry.js"
@@ -49,7 +50,9 @@ import { RopeOrChain } from "./equipment/item/RopeOrChain.js"
import { Stationery } from "./equipment/item/Stationery.js"
import { ArmorType } from "./equipment/item/sub/ArmorType.js"
import { Biome } from "./equipment/item/sub/Biome.js"
import { SubBiome } from "./equipment/item/sub/SubBiome.js"
import { Reach } from "./equipment/item/sub/Reach.js"
import { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js"
import { ThievesTool } from "./equipment/item/ThievesTool.js"
import { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js"
import { TravelGearOrTool } from "./equipment/item/TravelGearOrTool.js"
@@ -145,12 +148,15 @@ import { CauldronEnchantment } from "./traditionArtifacts/CauldronEnchantment.js
import { ChronicleEnchantment } from "./traditionArtifacts/ChronicleEnchantment.js"
import { DaggerRitual } from "./traditionArtifacts/DaggerRitual.js"
import { FoolsHatEnchantment } from "./traditionArtifacts/FoolsHatEnchantment.js"
import { Hauerkettenzauber } from "./traditionArtifacts/Hauerkettenzauber.js"
import { Haubenzauber } from "./traditionArtifacts/Haubenzauber.js"
import { InstrumentEnchantment } from "./traditionArtifacts/InstrumentEnchantment.js"
import { Keulenzauber } from "./traditionArtifacts/Keulenzauber.js"
import { Krallenkettenzauber } from "./traditionArtifacts/Krallenkettenzauber.js"
import { Kristallkugelzauber } from "./traditionArtifacts/Kristallkugelzauber.js"
import { OrbEnchantment } from "./traditionArtifacts/OrbEnchantment.js"
import { RingEnchantment } from "./traditionArtifacts/RingEnchantment.js"
import { Schweinetrommelzauber } from "./traditionArtifacts/Schweinetrommelzauber.js"
import { SickleRitual } from "./traditionArtifacts/SickleRitual.js"
import { SpellSwordEnchantment } from "./traditionArtifacts/SpellSwordEnchantment.js"
import { StaffEnchantment } from "./traditionArtifacts/StaffEnchantment.js"
@@ -242,7 +248,9 @@ export const GoblinRitualIdentifier: () => R = () => R(GoblinRitual)
export const GuidelineIdentifier: () => R = () => R(Guideline)
export const HairColorIdentifier: () => R = () => R(HairColor)
export const HaubenzauberIdentifier: () => R = () => R(Haubenzauber)
export const HauerkettenZauberIdentifier: () => R = () => R(Hauerkettenzauber)
export const HerbalAidIdentifier: () => R = () => R(HerbalAid)
export const HerbalPreservationIdentifier: () => R = () => R(HerbalPreservation)
export const IlluminationLightSourceIdentifier: () => R = () => R(IlluminationLightSource)
export const IlluminationRefillOrSupplyIdentifier: () => R = () => R(IlluminationRefillOrSupply)
export const InfluenceIdentifier: () => R = () => R(Influence)
@@ -250,6 +258,7 @@ export const InstrumentEnchantmentIdentifier: () => R = () => R(InstrumentEnchan
export const JesterTrickIdentifier: () => R = () => R(JesterTrick)
export const JewelryIdentifier: () => R = () => R(Jewelry)
export const KarmaSpecialAbilityIdentifier: () => R = () => R(KarmaSpecialAbility)
export const KeulenzauberIdentifier: () => R = () => R(Keulenzauber)
export const KrallenkettenzauberIdentifier: () => R = () => R(Krallenkettenzauber)
export const KristallkugelzauberIdentifier: () => R = () => R(Kristallkugelzauber)
export const LaboratoryIdentifier: () => R = () => R(Laboratory)
@@ -297,9 +306,11 @@ export const RaceIdentifier: () => R = () => R(Race)
export const RaceVariantIdentifier: () => R = () => R(RaceVariant)
export const RangedCombatTechniqueIdentifier: () => R = () => R(RangedCombatTechnique)
export const ReachIdentifier: () => R = () => R(Reach)
export const BotanicRegionIdentifier: () => R = () => R(BotanicRegion)
export const RingEnchantmentIdentifier: () => R = () => R(RingEnchantment)
export const RitualIdentifier: () => R = () => R(Ritual)
export const RopeOrChainIdentifier: () => R = () => R(RopeOrChain)
export const SchweinetrommelzauberIdentifier: () => R = () => R(Schweinetrommelzauber)
export const ScriptIdentifier: () => R = () => R(Script)
export const SermonIdentifier: () => R = () => R(Sermon)
export const SexPracticeIdentifier: () => R = () => R(SexPractice)
@@ -319,6 +330,7 @@ export const SpellSwordEnchantmentIdentifier: () => R = () => R(SpellSwordEnchan
export const StaffEnchantmentIdentifier: () => R = () => R(StaffEnchantment)
export const StateIdentifier: () => R = () => R(State)
export const StationeryIdentifier: () => R = () => R(Stationery)
export const SubBiomeIdentifier: () => R = () => R(SubBiome)
export const SubjectIdentifier: () => R = () => R(Subject)
export const TargetCategoryIdentifier: () => R = () => R(TargetCategory)
export const ThievesToolIdentifier: () => R = () => R(ThievesTool)
+54 -35
View File
@@ -1,3 +1,4 @@
import { sortObjectKeys } from "@elyukai/utils/object"
import * as DB from "tsondb/schema/dsl"
import {
AdvancedCombatSpecialAbilityIdentifier,
@@ -62,12 +63,14 @@ import {
GeodeRitualIdentifier,
GoblinRitualIdentifier,
HaubenzauberIdentifier,
HauerkettenZauberIdentifier,
IlluminationLightSourceIdentifier,
IlluminationRefillOrSupplyIdentifier,
InstrumentEnchantmentIdentifier,
JesterTrickIdentifier,
JewelryIdentifier,
KarmaSpecialAbilityIdentifier,
KeulenzauberIdentifier,
KrallenkettenzauberIdentifier,
KristallkugelzauberIdentifier,
LaboratoryIdentifier,
@@ -100,6 +103,7 @@ import {
RingEnchantmentIdentifier,
RitualIdentifier,
RopeOrChainIdentifier,
SchweinetrommelzauberIdentifier,
ScriptIdentifier,
SermonIdentifier,
SexPracticeIdentifier,
@@ -164,65 +168,80 @@ export const NewSkillApplicationOrUseParentIdentifier = DB.Enum(import.meta.url,
}),
})
export const SpecialAbilityIdentifier = DB.Enum(import.meta.url, {
name: "SpecialAbilityIdentifier",
export const TraditionArtifactEnchantmentIdentifier = DB.Enum(import.meta.url, {
name: "TraditionArtifactEnchantmentIdentifier",
values: () => ({
AdvancedCombatSpecialAbility: DB.EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
AdvancedKarmaSpecialAbility: DB.EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
AdvancedMagicalSpecialAbility: DB.EnumCase({ type: AdvancedMagicalSpecialAbilityIdentifier() }),
AdvancedSkillSpecialAbility: DB.EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
AncestorGlyph: DB.EnumCase({ type: AncestorGlyphIdentifier() }),
ArcaneOrbEnchantment: DB.EnumCase({ type: ArcaneOrbEnchantmentIdentifier() }),
AttireEnchantment: DB.EnumCase({ type: AttireEnchantmentIdentifier() }),
Beutelzauber: DB.EnumCase({ type: BeutelzauberIdentifier() }),
BlessedTradition: DB.EnumCase({ type: BlessedTraditionIdentifier() }),
BowlEnchantment: DB.EnumCase({ type: BowlEnchantmentIdentifier() }),
BrawlingSpecialAbility: DB.EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
CauldronEnchantment: DB.EnumCase({ type: CauldronEnchantmentIdentifier() }),
CeremonialItemSpecialAbility: DB.EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
ChronicleEnchantment: DB.EnumCase({ type: ChronicleEnchantmentIdentifier() }),
CombatSpecialAbility: DB.EnumCase({ type: CombatSpecialAbilityIdentifier() }),
CombatStyleSpecialAbility: DB.EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
CommandSpecialAbility: DB.EnumCase({ type: CommandSpecialAbilityIdentifier() }),
DaggerRitual: DB.EnumCase({ type: DaggerRitualIdentifier() }),
FamiliarSpecialAbility: DB.EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
FatePointSexSpecialAbility: DB.EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
FatePointSpecialAbility: DB.EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
FoolsHatEnchantment: DB.EnumCase({ type: FoolsHatEnchantmentIdentifier() }),
GeneralSpecialAbility: DB.EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
Haubenzauber: DB.EnumCase({ type: HaubenzauberIdentifier() }),
Hauerkettenzauber: DB.EnumCase({ type: HauerkettenZauberIdentifier() }),
InstrumentEnchantment: DB.EnumCase({ type: InstrumentEnchantmentIdentifier() }),
KarmaSpecialAbility: DB.EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
Keulenzauber: DB.EnumCase({ type: KeulenzauberIdentifier() }),
Krallenkettenzauber: DB.EnumCase({ type: KrallenkettenzauberIdentifier() }),
Kristallkugelzauber: DB.EnumCase({ type: KristallkugelzauberIdentifier() }),
LiturgicalStyleSpecialAbility: DB.EnumCase({ type: LiturgicalStyleSpecialAbilityIdentifier() }),
LycantropicGift: DB.EnumCase({ type: LycantropicGiftIdentifier() }),
MagicalSign: DB.EnumCase({ type: MagicalSignIdentifier() }),
MagicalSpecialAbility: DB.EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
MagicalTradition: DB.EnumCase({ type: MagicalTraditionIdentifier() }),
MagicStyleSpecialAbility: DB.EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
OrbEnchantment: DB.EnumCase({ type: OrbEnchantmentIdentifier() }),
PactGift: DB.EnumCase({ type: PactGiftIdentifier() }),
ProtectiveWardingCircleSpecialAbility: DB.EnumCase({
type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
}),
RingEnchantment: DB.EnumCase({ type: RingEnchantmentIdentifier() }),
Sermon: DB.EnumCase({ type: SermonIdentifier() }),
SexSpecialAbility: DB.EnumCase({ type: SexSpecialAbilityIdentifier() }),
Schweinetrommelzauber: DB.EnumCase({ type: SchweinetrommelzauberIdentifier() }),
SickleRitual: DB.EnumCase({ type: SickleRitualIdentifier() }),
SikaryanDrainSpecialAbility: DB.EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
SkillStyleSpecialAbility: DB.EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
SpellSwordEnchantment: DB.EnumCase({ type: SpellSwordEnchantmentIdentifier() }),
StaffEnchantment: DB.EnumCase({ type: StaffEnchantmentIdentifier() }),
ToyEnchantment: DB.EnumCase({ type: ToyEnchantmentIdentifier() }),
Trinkhornzauber: DB.EnumCase({ type: TrinkhornzauberIdentifier() }),
VampiricGift: DB.EnumCase({ type: VampiricGiftIdentifier() }),
Vision: DB.EnumCase({ type: VisionIdentifier() }),
WandEnchantment: DB.EnumCase({ type: WandEnchantmentIdentifier() }),
WeaponEnchantment: DB.EnumCase({ type: WeaponEnchantmentIdentifier() }),
}),
})
export const SpecialAbilityIdentifier = DB.Enum(import.meta.url, {
name: "SpecialAbilityIdentifier",
values: () =>
sortObjectKeys({
AdvancedCombatSpecialAbility: DB.EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
AdvancedKarmaSpecialAbility: DB.EnumCase({ type: AdvancedKarmaSpecialAbilityIdentifier() }),
AdvancedMagicalSpecialAbility: DB.EnumCase({
type: AdvancedMagicalSpecialAbilityIdentifier(),
}),
AdvancedSkillSpecialAbility: DB.EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
AncestorGlyph: DB.EnumCase({ type: AncestorGlyphIdentifier() }),
BlessedTradition: DB.EnumCase({ type: BlessedTraditionIdentifier() }),
BrawlingSpecialAbility: DB.EnumCase({ type: BrawlingSpecialAbilityIdentifier() }),
CeremonialItemSpecialAbility: DB.EnumCase({ type: CeremonialItemSpecialAbilityIdentifier() }),
ChronicleEnchantment: DB.EnumCase({ type: ChronicleEnchantmentIdentifier() }),
CombatSpecialAbility: DB.EnumCase({ type: CombatSpecialAbilityIdentifier() }),
CombatStyleSpecialAbility: DB.EnumCase({ type: CombatStyleSpecialAbilityIdentifier() }),
CommandSpecialAbility: DB.EnumCase({ type: CommandSpecialAbilityIdentifier() }),
FamiliarSpecialAbility: DB.EnumCase({ type: FamiliarSpecialAbilityIdentifier() }),
FatePointSexSpecialAbility: DB.EnumCase({ type: FatePointSexSpecialAbilityIdentifier() }),
FatePointSpecialAbility: DB.EnumCase({ type: FatePointSpecialAbilityIdentifier() }),
GeneralSpecialAbility: DB.EnumCase({ type: GeneralSpecialAbilityIdentifier() }),
KarmaSpecialAbility: DB.EnumCase({ type: KarmaSpecialAbilityIdentifier() }),
LiturgicalStyleSpecialAbility: DB.EnumCase({
type: LiturgicalStyleSpecialAbilityIdentifier(),
}),
LycantropicGift: DB.EnumCase({ type: LycantropicGiftIdentifier() }),
MagicalSign: DB.EnumCase({ type: MagicalSignIdentifier() }),
MagicalSpecialAbility: DB.EnumCase({ type: MagicalSpecialAbilityIdentifier() }),
MagicalTradition: DB.EnumCase({ type: MagicalTraditionIdentifier() }),
MagicStyleSpecialAbility: DB.EnumCase({ type: MagicStyleSpecialAbilityIdentifier() }),
PactGift: DB.EnumCase({ type: PactGiftIdentifier() }),
ProtectiveWardingCircleSpecialAbility: DB.EnumCase({
type: ProtectiveWardingCircleSpecialAbilityIdentifier(),
}),
Sermon: DB.EnumCase({ type: SermonIdentifier() }),
SexSpecialAbility: DB.EnumCase({ type: SexSpecialAbilityIdentifier() }),
SikaryanDrainSpecialAbility: DB.EnumCase({ type: SikaryanDrainSpecialAbilityIdentifier() }),
SkillStyleSpecialAbility: DB.EnumCase({ type: SkillStyleSpecialAbilityIdentifier() }),
VampiricGift: DB.EnumCase({ type: VampiricGiftIdentifier() }),
Vision: DB.EnumCase({ type: VisionIdentifier() }),
...TraditionArtifactEnchantmentIdentifier.type.value.values,
}),
})
export const CombatRelatedSpecialAbilityIdentifier = DB.Enum(import.meta.url, {
name: "CombatRelatedSpecialAbilityIdentifier",
values: () => ({
+5 -1
View File
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
import { src } from "../../source/_PublicationRef.js"
import { NestedTranslationMap } from "../../Locale.js"
import { WeaponIdentifier, ArmorIdentifier } from "../../_Identifier.js"
import { EffectType } from "./_Herbary.js"
import { EffectType, RecipeTradeSecret } from "./_Herbary.js"
export const HerbalAid = DB.Entity(import.meta.url, {
name: "HerbalAid",
@@ -17,6 +17,10 @@ export const HerbalAid = DB.Entity(import.meta.url, {
comment: "The difficulty for this aid to craft.",
type: DB.Integer(),
}),
trade_secret: DB.Optional({
comment: "AP value and prerequisites of the herbal aids trade secret.",
type: DB.IncludeIdentifier(RecipeTradeSecret),
}),
combatUse: DB.Optional({
comment: "The armor or weapon this herbal aid represents.",
type: DB.IncludeIdentifier(HerbalAidCombatUse),
@@ -0,0 +1,93 @@
import * as DB from "tsondb/schema/dsl"
import { NestedTranslationMap } from "../../Locale.js"
import { DurationUnit } from "../../_ActivatableSkillDuration.js"
import { ResponsiveTextReplace } from "../../_ResponsiveText.js"
import { Dice } from "../../_Dice.js"
import { MathOperation } from "../../_MathExpression.js"
import { EffectType } from "./_Herbary.js"
import { src } from "../../source/_PublicationRef.js"
export const HerbalPreservation = DB.Entity(import.meta.url, {
name: "HerbalPreservation",
namePlural: "HerbalPreservations",
type: () =>
DB.Object({
types: DB.Required({
comment: "The types of this preservation.",
type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
}),
longevity: DB.Required({
comment: "How long this preservation lasts.",
type: DB.IncludeIdentifier(HerbalPreservationLongevity),
}),
src,
translations: NestedTranslationMap(
DB.Required,
"HerbalPreservation",
DB.Object({
name: DB.Required({
comment: "The herbal preservation's name.",
type: DB.String({ minLength: 1 }),
}),
preparation: DB.Required({
comment: "How to prepare this preservation.",
type: DB.String({ minLength: 1, markdown: "inline" }),
}),
alternative_effect: DB.Required({
comment: "The herbal preservation's alternative effect.",
type: DB.String({ minLength: 1, markdown: "block" }),
}),
}),
),
}),
instanceDisplayName: {},
uniqueConstraints: [
{
entityMapKeyPath: "translations",
keyPathInEntityMap: "name",
},
],
})
export const HerbalPreservationLongevity = DB.TypeAlias(import.meta.url, {
name: "HerbalPreservationLongevity",
type: () =>
DB.Object({
value: DB.Required({
comment: "An expression that evaluates to the duration.",
type: DB.IncludeIdentifier(HerbalPreservationLongevityExpression),
}),
unit: DB.Required({
comment: "The duration unit.",
type: DB.IncludeIdentifier(DurationUnit),
}),
translations: NestedTranslationMap(
DB.Optional,
"HerbalPreservationLongevity",
DB.Object({
replacement: DB.Required({
comment: "A replacement string.",
type: DB.IncludeIdentifier(ResponsiveTextReplace),
}),
}),
),
}),
})
export const HerbalPreservationLongevityExpression = DB.TypeAlias(import.meta.url, {
name: "HerbalPreservationLongevityExpression",
type: () =>
DB.GenIncludeIdentifier(MathOperation, [
DB.IncludeIdentifier(HerbalPreservationLongevityValue),
]),
})
export const HerbalPreservationLongevityValue = DB.Enum(import.meta.url, {
name: "HerbalPreservationLongevityValue",
values: () => ({
Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
Dice: DB.EnumCase({
type: DB.IncludeIdentifier(Dice),
}),
}),
})
+86 -6
View File
@@ -4,7 +4,10 @@ import { NestedTranslationMap } from "../../Locale.js"
import { AlternativeName } from "../../_AlternativeNames.js"
import {
BiomeIdentifier,
SubBiomeIdentifier,
BotanicRegionIdentifier,
HerbalAidIdentifier,
HerbalPreservationIdentifier,
ElixirIdentifier,
PoisonIdentifier,
} from "../../_Identifier.js"
@@ -26,15 +29,15 @@ export const Plant = DB.Entity(import.meta.url, {
}),
search_difficulty: DB.Required({
comment: "The search difficulty for this plant.",
type: DB.Integer(),
type: DB.IncludeIdentifier(PlantDifficulty),
}),
identification_difficulty: DB.Required({
comment: "The identification difficulty for this plant.",
type: DB.Integer(),
type: DB.IncludeIdentifier(PlantDifficulty),
}),
applications: DB.Required({
comment: "The applications of this plant per quality level.",
type: DB.Array(DB.Integer(), { minItems: 6, maxItems: 6 }),
type: DB.IncludeIdentifier(PlantApplications),
}),
touch: DB.Optional({
comment: "The plant's touch effect.",
@@ -56,6 +59,10 @@ export const Plant = DB.Entity(import.meta.url, {
comment: "The herbal aids and elixirs that can be crafted with this plant.",
type: DB.Array(DB.IncludeIdentifier(PlantRecipe), { minItems: 1 }),
}),
longevity: DB.Optional({
comment: "The longevity of the plant.",
type: DB.IncludeIdentifier(PlantLongevity),
}),
src,
translations: NestedTranslationMap(
DB.Required,
@@ -123,9 +130,9 @@ const PlantOccurrence = DB.TypeAlias(import.meta.url, {
name: "PlantOccurrence",
type: () =>
DB.Object({
biome: DB.Required({
comment: "The biome this plant occurs in.",
type: BiomeIdentifier(),
regions: DB.Required({
comment: "Where this plant occurs in.",
type: DB.IncludeIdentifier(PlantOccurrenceTier),
}),
rarity: DB.Required({
comment: "The rarity of this plant in the biome.",
@@ -144,6 +151,54 @@ const PlantOccurrence = DB.TypeAlias(import.meta.url, {
}),
})
const PlantOccurrenceTier = DB.Enum(import.meta.url, {
name: "PlantOccurrenceTier",
values: () => ({
Biomes: DB.EnumCase({
type: DB.Array(BiomeIdentifier(), { minItems: 1 }),
}),
SubBiomes: DB.EnumCase({
type: DB.Array(SubBiomeIdentifier(), { minItems: 1 }),
}),
BotanicRegions: DB.EnumCase({
type: DB.Array(BotanicRegionIdentifier(), { minItems: 1 }),
}),
}),
})
const PlantDifficulty = DB.Enum(import.meta.url, {
name: "PlantDifficulty",
values: () => ({
Constant: DB.EnumCase({ type: DB.Integer() }),
Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePlantDescription) }),
}),
})
const IndefinitePlantDescription = DB.TypeAlias(import.meta.url, {
name: "IndefinitePlantDescription",
type: () =>
DB.Object({
translations: NestedTranslationMap(
DB.Required,
"IndefinitePlantDescription",
DB.Object({
description: DB.Required({
comment: "A description of whatever is indefinite of this plant.",
type: DB.String({ minLength: 1, markdown: "block" }),
}),
}),
),
}),
})
const PlantApplications = DB.Enum(import.meta.url, {
name: "PlantApplications",
values: () => ({
Constant: DB.EnumCase({ type: DB.Array(DB.Integer(), { minItems: 6, maxItems: 6 }) }),
Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePlantDescription) }),
}),
})
const PlantEffect = DB.TypeAlias(import.meta.url, {
name: "PlantEffect",
type: () =>
@@ -279,3 +334,28 @@ const IndefiniteRecipe = DB.TypeAlias(import.meta.url, {
),
}),
})
const PlantLongevity = DB.TypeAlias(import.meta.url, {
name: "PlantLongevity",
type: () =>
DB.Object({
preservations: DB.Optional({
comment: "The preservations with alternative effect of this preserved plant",
type: DB.Array(HerbalPreservationIdentifier(), { minItems: 1, uniqueItems: true }),
}),
translations: NestedTranslationMap(
DB.Required,
"PlantLongevity",
DB.Object({
raw: DB.Required({
comment: "The longevity of the raw plant",
type: DB.String({ minLength: 1, markdown: "block" }),
}),
preserved: DB.Optional({
comment: "The longevity of the preserved plant",
type: DB.String({ minLength: 1, markdown: "block" }),
}),
}),
),
}),
})
+4
View File
@@ -1,5 +1,6 @@
import * as DB from "tsondb/schema/dsl"
import { NestedTranslationMap } from "../../../Locale.js"
import { SubBiome } from "./SubBiome.js"
export const Biome = DB.Entity(import.meta.url, {
name: "Biome",
@@ -16,6 +17,9 @@ export const Biome = DB.Entity(import.meta.url, {
}),
}),
),
sub_biomes: DB.Required({
type: DB.ChildEntitiesType(SubBiome),
}),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -0,0 +1,38 @@
import * as DB from "tsondb/schema/dsl"
import { NestedTranslationMap } from "../../../Locale.js"
import { SubBiomeIdentifier } from "../../../_Identifier.js"
export const BotanicRegion = DB.Entity(import.meta.url, {
name: "BotanicRegion",
namePlural: "BotanicRegions",
type: () =>
DB.Object({
parent: DB.Required({
comment: "The subbiome this region belongs to.",
type: SubBiomeIdentifier(),
}),
translations: NestedTranslationMap(
DB.Required,
"BotanicRegion",
DB.Object({
name: DB.Required({
comment: "The region's name.",
type: DB.String({ minLength: 1 }),
}),
}),
),
}),
parentReferenceKey: "parent",
instanceDisplayName: {},
uniqueConstraints: [
[
{
entityMapKeyPath: "translations",
keyPathInEntityMap: "name",
},
{
keyPath: "parent",
},
],
],
})
+37
View File
@@ -0,0 +1,37 @@
import * as DB from "tsondb/schema/dsl"
import { NestedTranslationMap } from "../../../Locale.js"
import { BiomeIdentifier } from "../../../_Identifier.js"
import { BotanicRegion } from "./BotanicRegion.js"
export const SubBiome = DB.Entity(import.meta.url, {
name: "SubBiome",
namePlural: "SubBiomes",
type: () =>
DB.Object({
parent: DB.Required({
comment: "The biome this sub-biome belongs to.",
type: BiomeIdentifier(),
}),
translations: NestedTranslationMap(
DB.Required,
"SubBiome",
DB.Object({
name: DB.Required({
comment: "The subbiome's name.",
type: DB.String({ minLength: 1 }),
}),
}),
),
regions: DB.Required({
type: DB.ChildEntities(BotanicRegion),
}),
}),
parentReferenceKey: "parent",
instanceDisplayName: {},
uniqueConstraints: [
{
entityMapKeyPath: "translations",
keyPathInEntityMap: "name",
},
],
})
+6
View File
@@ -31,6 +31,7 @@ export { Elixir } from "./equipment/item/Elixir.js"
export { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js"
export { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js"
export { HerbalAid } from "./equipment/item/HerbalAid.js"
export { HerbalPreservation } from "./equipment/item/HerbalPreservation.js"
export { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js"
export { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js"
export { Jewelry } from "./equipment/item/Jewelry.js"
@@ -47,7 +48,9 @@ export { RopeOrChain } from "./equipment/item/RopeOrChain.js"
export { Stationery } from "./equipment/item/Stationery.js"
export { ArmorType } from "./equipment/item/sub/ArmorType.js"
export { Biome } from "./equipment/item/sub/Biome.js"
export { SubBiome } from "./equipment/item/sub/SubBiome.js"
export { Reach } from "./equipment/item/sub/Reach.js"
export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js"
export { ThievesTool } from "./equipment/item/ThievesTool.js"
export { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js"
export { TravelGearOrTool } from "./equipment/item/TravelGearOrTool.js"
@@ -145,11 +148,14 @@ export { ChronicleEnchantment } from "./traditionArtifacts/ChronicleEnchantment.
export { DaggerRitual } from "./traditionArtifacts/DaggerRitual.js"
export { FoolsHatEnchantment } from "./traditionArtifacts/FoolsHatEnchantment.js"
export { Haubenzauber } from "./traditionArtifacts/Haubenzauber.js"
export { Hauerkettenzauber } from "./traditionArtifacts/Hauerkettenzauber.js"
export { InstrumentEnchantment } from "./traditionArtifacts/InstrumentEnchantment.js"
export { Keulenzauber } from "./traditionArtifacts/Keulenzauber.js"
export { Krallenkettenzauber } from "./traditionArtifacts/Krallenkettenzauber.js"
export { Kristallkugelzauber } from "./traditionArtifacts/Kristallkugelzauber.js"
export { OrbEnchantment } from "./traditionArtifacts/OrbEnchantment.js"
export { RingEnchantment } from "./traditionArtifacts/RingEnchantment.js"
export { Schweinetrommelzauber } from "./traditionArtifacts/Schweinetrommelzauber.js"
export { SickleRitual } from "./traditionArtifacts/SickleRitual.js"
export { SpellSwordEnchantment } from "./traditionArtifacts/SpellSwordEnchantment.js"
export { StaffEnchantment } from "./traditionArtifacts/StaffEnchantment.js"
+2 -3
View File
@@ -1,7 +1,7 @@
import * as DB from "tsondb/schema/dsl"
import { name_in_library } from "../_Activatable.js"
import { OldParameter } from "../_ActivatableSkill.js"
import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
import { DurationUnitValue, ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.ts"
import { PropertyIdentifier, TribeIdentifier } from "../_Identifier.js"
@@ -199,8 +199,7 @@ const OneTimeAnimistPowerDuration = DB.Enum(import.meta.url, {
name: "OneTimeAnimistPowerDuration",
values: () => ({
Immediate: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
}),
})
+6 -8
View File
@@ -1,8 +1,9 @@
import * as DB from "tsondb/schema/dsl"
import { name_in_library } from "../_Activatable.js"
import { CheckResultBasedDuration } from "../_ActivatableSkillDuration.js"
import { OneTimeCostMap } from "../_ActivatableSkillCost.ts"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { PropertyIdentifier, BannzeichenIdentifier } from "../_Identifier.js"
import { BannzeichenIdentifier, PropertyIdentifier } from "../_Identifier.js"
import { ImprovementCost } from "../_ImprovementCost.js"
import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js"
import { SkillCheck } from "../_SkillCheck.js"
@@ -111,6 +112,7 @@ const BannzeichenCost = DB.Enum(import.meta.url, {
values: () => ({
Single: DB.EnumCase({ type: DB.IncludeIdentifier(SingleBannzeichenCost) }),
Disjunction: DB.EnumCase({ type: DB.IncludeIdentifier(BannzeichenCostDisjunction) }),
Map: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeCostMap) }),
DerivedFromOption: DB.EnumCase({ type: null }),
}),
})
@@ -189,11 +191,11 @@ const BannzeichenDuration = DB.TypeAlias(import.meta.url, {
DB.Object({
slow: DB.Required({
comment: "The duration on slow Bannzeichen application.",
type: DB.IncludeIdentifier(CheckResultBasedDuration),
type: DB.IncludeIdentifier(ExpressionBasedDuration),
}),
fast: DB.Required({
comment: "The duration on fast Bannzeichen application.",
type: DB.IncludeIdentifier(CheckResultBasedDuration),
type: DB.IncludeIdentifier(ExpressionBasedDuration),
}),
}),
})
@@ -236,10 +238,6 @@ export const BannzeichenOption = DB.Entity(import.meta.url, {
The surrounding parenthesis will/should not be included, they will/should be generated.`,
type: DB.String({ minLength: 1 }),
}),
native_name: DB.Required({
comment: "The native name of the Bannzeichen option.",
type: DB.String({ minLength: 1 }),
}),
}),
),
}),
+3 -5
View File
@@ -1,7 +1,7 @@
import * as DB from "tsondb/schema/dsl"
import { OldParameter } from "../_ActivatableSkill.js"
import { IndefiniteOneTimeCost } from "../_ActivatableSkillCost.js"
import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { PropertyIdentifier } from "../_Identifier.js"
import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js"
@@ -125,8 +125,7 @@ const CurseDuration = DB.Enum(import.meta.url, {
name: "CurseDuration",
values: () => ({
Immediate: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteCurseDuration) }),
}),
})
@@ -155,7 +154,6 @@ const IndefiniteCurseDuration = DB.TypeAlias(import.meta.url, {
const MaximumIndefiniteCurseDuration = DB.Enum(import.meta.url, {
name: "MaximumIndefiniteCurseDuration",
values: () => ({
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
}),
})
+3 -20
View File
@@ -1,6 +1,6 @@
import * as DB from "tsondb/schema/dsl"
import { OldParameter } from "../_ActivatableSkill.js"
import { CheckResultBasedDuration, DurationUnit } from "../_ActivatableSkillDuration.js"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { PropertyIdentifier, SkillModificationLevelIdentifier } from "../_Identifier.js"
import { ResponsiveText } from "../_ResponsiveText.js"
@@ -107,27 +107,11 @@ const DominationRitualCost = DB.TypeAlias(import.meta.url, {
const DominationRitualDuration = DB.Enum(import.meta.url, {
name: "DominationRitualDuration",
values: () => ({
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDominationRitualDuration) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDominationRitualDuration) }),
}),
})
const FixedDominationRitualDuration = DB.TypeAlias(import.meta.url, {
name: "FixedDominationRitualDuration",
type: () =>
DB.Object({
value: DB.Required({
comment: "The (unitless) duration.",
type: DB.Integer({ minimum: 1 }),
}),
unit: DB.Required({
comment: "The duration unit.",
type: DB.IncludeIdentifier(DurationUnit),
}),
}),
})
const IndefiniteDominationRitualDuration = DB.TypeAlias(import.meta.url, {
name: "IndefiniteDominationRitualDuration",
type: () =>
@@ -152,7 +136,6 @@ const IndefiniteDominationRitualDuration = DB.TypeAlias(import.meta.url, {
const MaximumIndefiniteDominationRitualDuration = DB.Enum(import.meta.url, {
name: "MaximumIndefiniteDominationRitualDuration",
values: () => ({
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDominationRitualDuration) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
}),
})
+2 -3
View File
@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl"
import { OldParameter } from "../_ActivatableSkill.js"
import { SlowSkillNonModifiableCastingTime } from "../_ActivatableSkillCastingTime.js"
import { OneTimeCostMap } from "../_ActivatableSkillCost.js"
import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
import { PropertyIdentifier } from "../_Identifier.js"
@@ -152,7 +152,6 @@ const GeodeRitualDuration = DB.Enum(import.meta.url, {
name: "GeodeRitualDuration",
values: () => ({
Immediate: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
}),
})
+7 -8
View File
@@ -1,17 +1,17 @@
import * as DB from "tsondb/schema/dsl"
import { OldParameter } from "../_ActivatableSkill.js"
import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { NonModifiableOneTimeCost, NonModifiableSustainedCost } from "../_ActivatableSkillCost.js"
import { ResponsiveTextOptional, ResponsiveTextReplace } from "../_ResponsiveText.js"
import { FixedRange } from "../_ActivatableSkillRange.js"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { ExpressionBasedRange } from "../_ActivatableSkillRange.js"
import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
import { PropertyIdentifier } from "../_Identifier.js"
import { ImprovementCost } from "../_ImprovementCost.js"
import { ResponsiveTextOptional, ResponsiveTextReplace } from "../_ResponsiveText.js"
import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { ImprovementCost } from "../_ImprovementCost.js"
export const GoblinRitual = DB.Entity(import.meta.url, {
name: "GoblinRitual",
@@ -212,7 +212,7 @@ const GoblinRitualRangeValue = DB.Enum(import.meta.url, {
Sight: DB.EnumCase({ type: null }),
Self: DB.EnumCase({ type: null }),
Touch: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedRange) }),
}),
})
@@ -220,7 +220,6 @@ const GoblinRitualDuration = DB.Enum(import.meta.url, {
name: "GoblinRitualDuration",
values: () => ({
Immediate: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
}),
})
+2 -18
View File
@@ -1,6 +1,6 @@
import * as DB from "tsondb/schema/dsl"
import { OldParameter } from "../_ActivatableSkill.js"
import { CheckResultBasedDuration, DurationUnit } from "../_ActivatableSkillDuration.js"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.js"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
import { PropertyIdentifier } from "../_Identifier.js"
@@ -158,22 +158,6 @@ export const JesterTrickDuration = DB.Enum(import.meta.url, {
name: "JesterTrickDuration",
values: () => ({
Immediate: DB.EnumCase({ type: null }),
Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedJesterTrickDuration) }),
CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
Expression: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedDuration) }),
}),
})
const FixedJesterTrickDuration = DB.TypeAlias(import.meta.url, {
name: "FixedJesterTrickDuration",
type: () =>
DB.Object({
value: DB.Required({
comment: "The (unitless) duration.",
type: DB.Integer({ minimum: 2 }),
}),
unit: DB.Required({
comment: "The duration unit.",
type: DB.IncludeIdentifier(DurationUnit),
}),
}),
})
+3 -3
View File
@@ -1,7 +1,7 @@
import * as DB from "tsondb/schema/dsl"
import { name_in_library } from "../_Activatable.js"
import { OldParameter } from "../_ActivatableSkill.js"
import { CheckResultBasedDuration } from "../_ActivatableSkillDuration.js"
import { ExpressionBasedDuration } from "../_ActivatableSkillDuration.ts"
import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js"
import { MagicalRuneIdentifier, PropertyIdentifier } from "../_Identifier.js"
import { CombatTechniqueIdentifier } from "../_IdentifierGroup.js"
@@ -259,11 +259,11 @@ const MagicalRuneDuration = DB.TypeAlias(import.meta.url, {
DB.Object({
slow: DB.Required({
comment: "The duration on slow rune application.",
type: DB.IncludeIdentifier(CheckResultBasedDuration),
type: DB.IncludeIdentifier(ExpressionBasedDuration),
}),
fast: DB.Required({
comment: "The duration on fast rune application.",
type: DB.IncludeIdentifier(CheckResultBasedDuration),
type: DB.IncludeIdentifier(ExpressionBasedDuration),
}),
}),
})
@@ -36,6 +36,11 @@ export const BlessedTradition = DB.Entity(import.meta.url, {
comment: "The traditions aspects, if any.",
type: DB.Array(AspectIdentifier(), { minItems: 2, maxItems: 2 }),
}),
primaryBlessing: DB.Optional({
comment:
"The traditions primary blessing. Leave empty if the tradition does not have one.",
type: BlessingIdentifier(),
}),
restricted_blessings: DB.Optional({
comment:
"If a tradition restricts the possible blessings, the blessings that are **not** allowed.",
@@ -1,5 +1,5 @@
import * as DB from "tsondb/schema/dsl"
import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
import { additionalName, levels, maximum, name, name_in_library, rules } from "../_Activatable.js"
import { advanced } from "../_ActivatableAdvanced.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.ts"
@@ -34,6 +34,7 @@ export const MagicStyleSpecialAbility = DB.Entity(import.meta.url, {
"MagicStyleSpecialAbility",
DB.Object({
name,
additionalName,
name_in_library,
rules,
ap_value_append,
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const ArcaneOrbEnchantment = DB.Entity(import.meta.url, {
name: "ArcaneOrbEnchantment",
@@ -34,23 +26,7 @@ export const ArcaneOrbEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"ArcaneOrbEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("ArcaneOrbEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const AttireEnchantment = DB.Entity(import.meta.url, {
name: "AttireEnchantment",
@@ -34,23 +26,7 @@ export const AttireEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"AttireEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("AttireEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
+5 -29
View File
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const Beutelzauber = DB.Entity(import.meta.url, {
name: "Beutelzauber",
@@ -34,23 +26,7 @@ export const Beutelzauber = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"Beutelzauber",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("Beutelzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const BowlEnchantment = DB.Entity(import.meta.url, {
name: "BowlEnchantment",
@@ -34,23 +26,7 @@ export const BowlEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"BowlEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("BowlEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,21 +1,13 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { BrewIdentifier } from "../_Identifier.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const CauldronEnchantment = DB.Entity(import.meta.url, {
name: "CauldronEnchantment",
@@ -40,23 +32,7 @@ export const CauldronEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"CauldronEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("CauldronEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const ChronicleEnchantment = DB.Entity(import.meta.url, {
name: "ChronicleEnchantment",
@@ -34,23 +26,7 @@ export const ChronicleEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"ChronicleEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("ChronicleEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
+5 -30
View File
@@ -1,21 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
ArcaneEnergyCost,
BindingCost,
bindingCost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { ArcaneEnergyCost, BindingCost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const DaggerRitual = DB.Entity(import.meta.url, {
name: "DaggerRitual",
@@ -37,23 +28,7 @@ export const DaggerRitual = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"DaggerRitual",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("DaggerRitual"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const FoolsHatEnchantment = DB.Entity(import.meta.url, {
name: "FoolsHatEnchantment",
@@ -36,23 +28,7 @@ export const FoolsHatEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"FoolsHatEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("FoolsHatEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
+5 -29
View File
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const Haubenzauber = DB.Entity(import.meta.url, {
name: "Haubenzauber",
@@ -34,23 +26,7 @@ export const Haubenzauber = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"Haubenzauber",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("Haubenzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -0,0 +1,36 @@
import * as DB from "tsondb/schema/dsl"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.js"
export const Hauerkettenzauber = DB.Entity(import.meta.url, {
name: "Hauerkettenzauber",
namePlural: "Hauerkettenzauber",
type: () =>
DB.Object({
levels,
nameBuilderRules,
maximum,
prerequisites: DB.Optional({
type: DB.IncludeIdentifier(GeneralPrerequisites),
}),
volume,
cost,
property: property(),
ap_value,
src,
translations: translations("Hauerkettenzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
{
entityMapKeyPath: "translations",
keyPathInEntityMap: "name_in_library",
keyPathInEntityMapFallback: "name",
},
],
})
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const InstrumentEnchantment = DB.Entity(import.meta.url, {
name: "InstrumentEnchantment",
@@ -34,23 +26,7 @@ export const InstrumentEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"InstrumentEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("InstrumentEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -0,0 +1,37 @@
import * as DB from "tsondb/schema/dsl"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.js"
//Keulenzauber für Goblinzauberinnen
export const Keulenzauber = DB.Entity(import.meta.url, {
name: "Keulenzauber",
namePlural: "Keulenzauber",
type: () =>
DB.Object({
levels,
nameBuilderRules,
maximum,
prerequisites: DB.Optional({
type: DB.IncludeIdentifier(GeneralPrerequisites),
}),
volume,
cost,
property: property(),
ap_value,
src,
translations: translations("Keulenzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
{
entityMapKeyPath: "translations",
keyPathInEntityMap: "name_in_library",
keyPathInEntityMapFallback: "name",
},
],
})
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const Krallenkettenzauber = DB.Entity(import.meta.url, {
name: "Krallenkettenzauber",
@@ -34,23 +26,7 @@ export const Krallenkettenzauber = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"Krallenkettenzauber",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("Krallenkettenzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const Kristallkugelzauber = DB.Entity(import.meta.url, {
name: "Kristallkugelzauber",
@@ -34,23 +26,7 @@ export const Kristallkugelzauber = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"Kristallkugelzauber",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("Kristallkugelzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
+5 -29
View File
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const OrbEnchantment = DB.Entity(import.meta.url, {
name: "OrbEnchantment",
@@ -34,23 +26,7 @@ export const OrbEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"OrbEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("OrbEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const RingEnchantment = DB.Entity(import.meta.url, {
name: "RingEnchantment",
@@ -34,23 +26,7 @@ export const RingEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"RingEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("RingEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -0,0 +1,36 @@
import * as DB from "tsondb/schema/dsl"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.js"
export const Schweinetrommelzauber = DB.Entity(import.meta.url, {
name: "Schweinetrommelzauber",
namePlural: "Schweinetrommelzauber",
type: () =>
DB.Object({
levels,
nameBuilderRules,
maximum,
prerequisites: DB.Optional({
type: DB.IncludeIdentifier(GeneralPrerequisites),
}),
volume,
cost,
property: property(),
ap_value,
src,
translations: translations("Schweinetrommelzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
{
entityMapKeyPath: "translations",
keyPathInEntityMap: "name_in_library",
keyPathInEntityMapFallback: "name",
},
],
})
+5 -29
View File
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const SickleRitual = DB.Entity(import.meta.url, {
name: "SickleRitual",
@@ -34,23 +26,7 @@ export const SickleRitual = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"SickleRitual",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("SickleRitual"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const SpellSwordEnchantment = DB.Entity(import.meta.url, {
name: "SpellSwordEnchantment",
@@ -34,23 +26,7 @@ export const SpellSwordEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"SpellSwordEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("SpellSwordEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,21 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { ResponsiveTextOptional } from "../_ResponsiveText.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const StaffEnchantment = DB.Entity(import.meta.url, {
name: "StaffEnchantment",
@@ -35,27 +26,7 @@ export const StaffEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"StaffEnchantment",
DB.Object({
name,
name_in_library,
effect,
cost_note: DB.Optional({
comment: "A note, appended to the generated cost string in parenthesis.",
type: DB.IncludeIdentifier(ResponsiveTextOptional),
}),
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("StaffEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
+5 -29
View File
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const ToyEnchantment = DB.Entity(import.meta.url, {
name: "ToyEnchantment",
@@ -34,23 +26,7 @@ export const ToyEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"ToyEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("ToyEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const Trinkhornzauber = DB.Entity(import.meta.url, {
name: "Trinkhornzauber",
@@ -34,23 +26,7 @@ export const Trinkhornzauber = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"Trinkhornzauber",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("Trinkhornzauber"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,13 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import { aeCost, bindingCost, cost, property, volume_l10n } from "../_ActivatableNonMundane.js"
import { cost, property } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const WandEnchantment = DB.Entity(import.meta.url, {
name: "WandEnchantment",
@@ -26,23 +25,7 @@ export const WandEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"WandEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("WandEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
@@ -1,20 +1,12 @@
import * as DB from "tsondb/schema/dsl"
import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js"
import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js"
import { levels, maximum } from "../_Activatable.js"
import { ap_value } from "../_ActivatableAdventurePointsValue.js"
import { nameBuilderRules } from "../_ActivatableNames.ts"
import {
aeCost,
bindingCost,
cost,
property,
volume,
volume_l10n,
} from "../_ActivatableNonMundane.js"
import { cost, property, volume } from "../_ActivatableNonMundane.js"
import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js"
import { GeneralPrerequisites } from "../_Prerequisite.js"
import { NestedTranslationMap } from "../Locale.js"
import { Errata } from "../source/_Erratum.js"
import { src } from "../source/_PublicationRef.js"
import { translations } from "./_shared.ts"
export const WeaponEnchantment = DB.Entity(import.meta.url, {
name: "WeaponEnchantment",
@@ -34,23 +26,7 @@ export const WeaponEnchantment = DB.Entity(import.meta.url, {
property: property(),
ap_value,
src,
translations: NestedTranslationMap(
DB.Required,
"WeaponEnchantment",
DB.Object({
name,
name_in_library,
effect,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
),
translations: translations("WeaponEnchantment"),
}),
instanceDisplayName: {},
uniqueConstraints: [
+26
View File
@@ -0,0 +1,26 @@
import * as DB from "tsondb/schema/dsl"
import { NestedTranslationMap } from "../Locale.ts"
import { effect, name, name_in_library } from "../_Activatable.ts"
import { ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.ts"
import { aeCost, bindingCost, cost_note, volume_l10n } from "../_ActivatableNonMundane.ts"
import { Errata } from "../source/_Erratum.ts"
export const translations = <T extends string>(entity: T) =>
NestedTranslationMap(
DB.Required,
entity,
DB.Object({
name,
name_in_library,
effect,
cost_note,
bindingCost,
aeCost,
volume: volume_l10n,
ap_value_append,
ap_value: ap_value_l10n,
errata: DB.Optional({
type: DB.IncludeIdentifier(Errata),
}),
}),
)