@datasworn-community/build-tools 0.2.0

package/schema-source/schema/common/RollableValues.ts

@@ -0,0 +1,152 @@
+import {
+	type ObjectOptions,
+	type Static,
+	type TObject,
+	Type
+} from '@sinclair/typebox'
+import * as Utils from '../Utils.js'
+import { Assign } from '../utils/FlatIntersect.js'
+import Id from './Id.js'
+import * as Player from './Player.js'
+import * as Text from './Text.js'
+
+const RollableValueType = Utils.UnionEnumFromRecord(
+	{
+		stat: 'A reference to the value of a standard player character stat.',
+		condition_meter:
+			'A reference to the value of a standard player condition meter.',
+		asset_control: 'A reference to the value of an asset control.',
+		asset_option: 'A reference to the value of an asset option.',
+		custom: 'An arbitrary static integer value with a label.',
+		attached_asset_control:
+			'A reference to the value of an attached asset control. For example, a Module asset could use this to roll using the `integrity` control of an attached Vehicle.',
+		attached_asset_option:
+			'A reference to the value of an attached asset option.'
+	},
+	{ $id: 'RollableValueType' }
+)
+type RollableValueType = Static<typeof RollableValueType>
+
+function RollableValueBase<
+	Using extends RollableValueType,
+	Props extends TObject
+>(using: Using, props: Props, options: ObjectOptions = {}) {
+	const constant = Utils.ExtractLiteralFromEnum(RollableValueType, using)
+	return Assign(
+		props,
+		Type.Object({
+			using: constant
+		}),
+		{
+			description: constant.description,
+			...options
+		}
+	)
+}
+
+export const AssetControlValueRef = RollableValueBase(
+	'asset_control',
+	Type.Object({
+		assets: Utils.Nullable(
+			Type.Array(Type.Ref(Id.AssetIdWildcard), { default: null }),
+			{
+				default: null,
+				description:
+					"Asset IDs (which may be wildcarded) that may provide the control field. For asset ability enhancements, `null` is used to represent the asset's own control fields."
+			}
+		),
+		control: Type.Ref(Id.DictKey, {
+			description: 'The dictionary key of the asset control field.',
+			examples: ['health', 'integrity']
+		})
+	}),
+	{ $id: 'AssetControlValueRef' }
+)
+
+export type AssetControlValueRef = Static<typeof AssetControlValueRef>
+
+export const AttachedAssetControlValueRef = RollableValueBase(
+	'attached_asset_control',
+	Type.Pick(AssetControlValueRef, ['control']),
+	{ $id: 'AttachedAssetControlValueRef' }
+)
+
+export type AttachedAssetControlValueRef = Static<
+	typeof AttachedAssetControlValueRef
+>
+
+export const AssetOptionValueRef = RollableValueBase(
+	'asset_option',
+	Type.Object({
+		assets: Utils.Nullable(Type.Array(Type.Ref(Id.AssetIdWildcard)), {
+			default: null,
+			description:
+				"Asset IDs (which may be wildcarded) that may provide the option field. For asset ability enhancements, `null` is used to represent the asset's own option fields."
+		}),
+		option: Type.Ref(Id.DictKey, {
+			description: 'The dictionary key of the asset option field.'
+		})
+	}),
+	{ $id: 'AssetOptionValueRef' }
+)
+
+export type AssetOptionValueRef = Static<typeof AssetOptionValueRef>
+
+export const AttachedAssetOptionValueRef = RollableValueBase(
+	'attached_asset_option',
+	Type.Pick(AssetOptionValueRef, ['option']),
+	{ $id: 'AttachedAssetOptionValueRef' }
+)
+
+export type AttachedAssetOptionValueRef = Static<
+	typeof AttachedAssetOptionValueRef
+>
+
+export const StatValueRef = RollableValueBase(
+	'stat',
+	Type.Object({
+		stat: Type.Ref(Player.StatKey)
+	}),
+	{ $id: 'StatValueRef' }
+)
+
+export type StatValueRef = Static<typeof StatValueRef>
+
+export const ConditionMeterValueRef = RollableValueBase(
+	'condition_meter',
+	Type.Object({
+		condition_meter: Type.Ref(Player.ConditionMeterKey)
+	}),
+	{ $id: 'ConditionMeterValueRef' }
+)
+export type ConditionMeterValueRef = Static<typeof ConditionMeterValueRef>
+
+export const CustomValue = RollableValueBase(
+	'custom',
+	Type.Object({
+		label: Type.Ref(Text.Label),
+		value: Type.Integer()
+	}),
+	{ $id: 'CustomValue' }
+)
+export type CustomValue = Static<typeof CustomValue>
+
+export const RollableValue = Utils.DiscriminatedUnion(
+	{
+		stat: StatValueRef,
+		condition_meter: ConditionMeterValueRef,
+		asset_control: AssetControlValueRef,
+		asset_option: AssetOptionValueRef,
+		attached_asset_control: AttachedAssetControlValueRef,
+		attached_asset_option: AttachedAssetOptionValueRef,
+		custom: CustomValue
+	},
+	'using',
+	{
+		$id: 'RollableValue',
+		description:
+			'Provides a value like a stat, condition meter, or other number (usually for use in an action roll). The expected value is an integer, or null.'
+	}
+)
+
+export type RollableValue = Static<typeof RollableValue>

package/schema-source/schema/common/Rolls.ts

@@ -0,0 +1,108 @@
+import { type Static, type TString, Type } from '@sinclair/typebox'
+import * as Utils from '../Utils.js'
+import Id from './Id.js'
+import * as Text from './Text.js'
+
+export const DiceExpression = Type.String({
+	pattern: /([1-9][0-9]*)d([1-9][0-9]*)([+-]([1-9][0-9]*))?/.source,
+	$id: 'DiceExpression',
+	description:
+		'A simple dice roll expression with an optional (positive or negative) modifer.',
+	examples: ['1d100', '1d6+2', '2d10']
+}) as TString & { pattern: string; static: DiceExpression }
+
+export type DiceExpression =
+	| `${number}d${number}`
+	| `${number}d${number}${'+' | '-'}${number}`
+
+export const OracleDuplicateBehavior = Utils.UnionEnumFromRecord(
+	{
+		reroll: 'Duplicate results should be re-rolled.',
+		keep: 'Duplicates results should be kept.',
+		make_it_worse:
+			'Duplicate results should be kept, and they compound to make things worse.'
+	},
+	{
+		$id: 'OracleDuplicateBehavior',
+		description:
+			'Special roll instructions to use when rolling multiple times on a single oracle.'
+	}
+)
+export type OracleDuplicateBehavior = Static<typeof OracleDuplicateBehavior>
+
+export const OracleRoll = Type.Object(
+	{
+		oracle: Utils.Nullable(Type.Ref(Id.OracleRollableId), {
+			default: null,
+			description:
+				"The ID of the oracle to be rolled. A `null` value indicates that it's a roll on the same table."
+		}),
+		auto: Type.Boolean({
+			default: false,
+			description:
+				'Both Ironsworn and Starforged explicitly recommend *against* rolling all details at once. That said, some oracle results only provide useful information once a secondary roll occurs, such as "Action + Theme" or "Roll twice".'
+		}),
+		duplicates: Type.Ref(OracleDuplicateBehavior, {
+			description:
+				'Special rules on how to handle duplicate results, when rolling multiple times.',
+			default: 'reroll'
+		}),
+		dice: Utils.Nullable(Type.Ref(DiceExpression), {
+			default: null,
+			description:
+				"The dice roll to make on the oracle table. Set it to `null` if you just want the table's default."
+		}),
+		// TODO: replace with the recommended_rolls?
+		number_of_rolls: Type.Integer({
+			minimum: 1,
+			default: 1,
+			description: 'The number of times to roll.'
+		})
+		// TODO: some way to handle e.g. 1d6 rolls?
+	},
+	{ $id: 'OracleRoll' }
+)
+export type OracleRoll = Static<typeof OracleRoll>
+export type TOracleRoll = typeof OracleRoll
+
+export const OracleRollTemplate = Type.Object(
+	{
+		text: Type.Optional(
+			Type.Ref(Text.MarkdownTemplateString, {
+				description:
+					'A string template that may be used in place of OracleRollableRow#text.',
+				examples: [
+					'{{text>oracle_rollable:starforged/faction/name/affiliation}} of the {{text>oracle_rollable:starforged/faction/name/legacy}} {{text>oracle_rollable:starforged/faction/name/identity}}'
+				]
+			})
+		),
+		text2: Type.Optional(
+			Type.Ref(Text.MarkdownTemplateString, {
+				description:
+					'A string template that may be used in place of OracleRollableRow#text2.'
+			})
+		),
+		text3: Type.Optional(
+			Type.Ref(Text.MarkdownTemplateString, {
+				description:
+					'A string template that may be used in place of OracleRollableRow#text3.'
+			})
+		)
+	},
+	{
+		$id: 'OracleRollTemplate',
+		releaseStage: 'experimental',
+		description: `Provides string templates that may be used in place of the static row text from \`OracleRollableRow#text\`, \`OracleRollableRow#text2\`, and \`OracleRollableRow#text3\`.
+
+  These strings are formatted in Markdown, but use a special syntax for their placeholders: \`{{text>some_oracle_rollable_id}}\`. The placeholder should be replaced with the value of a rolled (or selected) \`OracleRollableRow#text\` from the target oracle rollable ID.`
+	}
+)
+export type OracleRollTemplate = Static<typeof OracleRollTemplate>
+
+export const OracleMatchBehavior = Type.Object(
+	{
+		text: Type.Ref(Text.MarkdownString)
+	},
+	{ $id: 'OracleMatchBehavior' }
+)
+export type OracleMatchBehavior = Static<typeof OracleMatchBehavior>

package/schema-source/schema/common/Text.ts

@@ -0,0 +1,95 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { UnionEnumFromRecord } from '../utils/UnionEnumFromRecord.js'
+
+export const Documentation = Type.String({
+	$id: 'Documentation',
+	description:
+		'Implementation hints or other developer-facing comments on this node. These should be omitted when representing an object for gameplay.'
+})
+
+export const Label = Type.String({
+	$id: 'Label',
+	description:
+		'A localized, player-facing name or label, formatted as plain text. In some contexts it may be undesirable to render this text, but it should always be exposed to assistive technology (e.g. with `aria-label` in HTML).',
+	i18n: true
+})
+export type Label = Static<typeof Label>
+
+export const MarkdownString = Type.String({
+	$id: 'MarkdownString',
+	description: `Localized, player-facing text, formatted in Markdown. It is *not* formatted for use "out of the box"; it uses some custom syntax, intended to be replaced in whatever way is most appropriate for your implementation.
+
+* \`[Link text](datasworn:move:starforged/suffer/pay_the_price)\`: A link to the identified object. The ID must conform to the \`AnyId\` type; no wildcards allowed.
+* \`{{table>oracle_rollable:starforged/core/action}}\`: the referenced oracle is rendered here in the source material. The ID must conform to the \`AnyOracleRollableId\` type; no wildcards allowed.
+* \`{{table_columns>move:delve/delve/delve_the_depths}}\`: Render *all* direct OracleRollable children of the identified node. This can be an OracleCollectionId, or the ID of anything that can have EmbeddedOracleRollables (such as a Move or TruthOption).
+`,
+	format: 'markdown',
+	i18n: true
+})
+export type MarkdownString = Static<typeof Label>
+
+export const MarkdownTemplateString = Type.String({
+	$id: 'MarkdownTemplateString',
+	i18n: true,
+	description: `A rich text string in Markdown with replaced values from oracle roll results.
+
+The custom syntax \`{{some_row_key>some_oracle_table_id}}\` should be replaced by the \`some_row_key\` string of a rolled oracle table. This is usually the \`text\` key, for example \`{{text>oracle_rollable:starforged/core/action}}\`
+`,
+	format: 'markdown',
+	releaseStage: 'experimental'
+})
+export type MarkdownTemplateString = Static<typeof MarkdownTemplateString>
+
+export const PartOfSpeech = UnionEnumFromRecord(
+	{
+		common_noun: 'A common noun.',
+		proper_noun: 'A proper noun.',
+		adjunct_common_noun:
+			'A common noun used as an adjective, to modify another noun.',
+		adjunct_proper_noun:
+			'A proper noun used as an adjective, to modify another noun.',
+		verb: 'A verb in present tense',
+		gerund:
+			'Gerund or present participle of a verb, e.g. "going", "seeing", "waving". Can function as a noun, an adjective, or a progressive verb.',
+		adjective: 'An adjective.',
+		attributive_verb: 'A verb used as an adjective, to modify a noun.',
+		adjective_as_proper_noun: 'An adjective used as a proper noun.',
+		common_noun_as_proper_noun: 'An common noun used as a proper noun.'
+	},
+	{ $id: 'PartOfSpeech', releaseStage: 'experimental' }
+)
+export type PartOfSpeech = Static<typeof PartOfSpeech>
+
+export const I18nHint = Type.Object(
+	{
+		part_of_speech: Type.Optional(
+			Type.Ref(PartOfSpeech, {
+				description: 'The part of speech for this string.'
+			})
+		)
+	},
+	{ $id: 'I18nHint', releaseStage: 'experimental' }
+)
+export type I18nHint = Static<typeof I18nHint>
+
+export const I18nHints = Type.Object(
+	{
+		text: Type.Optional(Type.Ref(I18nHint)),
+		text2: Type.Optional(Type.Ref(I18nHint)),
+		text3: Type.Optional(Type.Ref(I18nHint)),
+		template: Type.Optional(
+			Type.Object({
+				text: Type.Optional(Type.Ref(I18nHint)),
+				text2: Type.Optional(Type.Ref(I18nHint)),
+				text3: Type.Optional(Type.Ref(I18nHint))
+			})
+		)
+	},
+	{
+		$id: 'I18nHints',
+		description:
+			'Internationalization/localization hints for the text content of this object.',
+		releaseStage: 'experimental'
+	}
+)
+export type I18nHints = Static<typeof I18nHints>

package/schema-source/schema/common/index.ts

@@ -0,0 +1,16 @@
+// no dependencies
+
+// depends on Generic
+export * as Fields from './Fields.js'
+export { default as Id } from './Id.js'
+// depends on Fields
+export * as Inputs from './Inputs.js'
+export * as Metadata from './Metadata.js'
+export * as Player from './Player.js'
+export * as Progress from './Progress.js'
+export * as Range from './Range.js'
+// depends on Id, Text, Player
+export * as RollableValues from './RollableValues.js'
+// depends on Id or Text
+export * as Rolls from './Rolls.js'
+export * as Text from './Text.js'

package/schema-source/schema/delve/DelveSite.ts

@@ -0,0 +1,121 @@
+import { type Static, Type } from '@sinclair/typebox'
+import JtdType from '../../scripts/json-typedef/typedef.js'
+import { toJtdElements } from '../../scripts/json-typedef/utils.js'
+import Id from '../common/Id.js'
+import * as Progress from '../common/Progress.js'
+import { DiceRange, StaticDiceRange } from '../common/Range.js'
+import * as Text from '../common/Text.js'
+import { NonCollectableNode } from '../generic/NonCollectableNode.js'
+import { JsonTypeDef } from '../Symbols.js'
+import * as Utils from '../Utils.js'
+import { EmbeddedType } from './common.js'
+
+export const DelveSiteDenizenFrequency = Utils.UnionEnum(
+	['very_common', 'common', 'uncommon', 'rare', 'unforeseen'],
+	{ $id: 'DelveSiteDenizenFrequency' }
+)
+export type DelveSiteDenizenFrequency = Static<typeof DelveSiteDenizenFrequency>
+
+export const DelveSiteDenizen = EmbeddedType(
+	Type.Object({
+		name: Type.Optional(
+			Type.Ref(Text.Label, {
+				description:
+					"A name for the denizen, if it's different than the `name` property of the NPC."
+			})
+		),
+		npc: Type.Optional(
+			Type.Ref(Id.NpcId, {
+				description: 'The ID of the relevant NPC entry, if one is specified.'
+			})
+		),
+		frequency: Type.Ref(DelveSiteDenizenFrequency),
+		roll: Type.Ref(DiceRange)
+	}),
+	'delve_site',
+	'denizen',
+	{
+		description:
+			'Represents an entry in a delve site denizen matrix. Denizen matrices are described in Ironsworn: Delve.'
+	}
+)
+
+export type DelveSiteDenizen = Static<typeof DelveSiteDenizen>
+function StaticDenizenRowStub<
+	Min extends number,
+	Max extends number,
+	Frequency extends DelveSiteDenizenFrequency
+>(min: Min, max: Max, frequency: Frequency) {
+	return Type.Object(
+		{
+			frequency: Type.Literal(frequency),
+			roll: StaticDiceRange(min, max)
+		},
+		{ additionalProperties: true, title: 'DelveSiteDenizenStatic' }
+	)
+}
+const DelveSiteDenizens = Type.Array(Type.Ref(DelveSiteDenizen))
+
+export const DelveSite = NonCollectableNode(
+	Type.Object({
+		rank: Type.Ref(Progress.ChallengeRank),
+		region: Type.Optional(
+			Type.Ref(Id.AtlasEntryId, {
+				description:
+					'The ID of an atlas entry representing the region in which this delve site is located.'
+			})
+		),
+		theme: Type.Ref(Id.DelveSiteThemeId, {
+			description: "The ID of the site's DelveSiteTheme card."
+		}),
+		domain: Type.Ref(Id.DelveSiteDomainId, {
+			description: "The ID of the site's DelveSiteDomain card."
+		}),
+		extra_card: Type.Optional(
+			Type.Union(
+				[Type.Ref(Id.DelveSiteThemeId), Type.Ref(Id.DelveSiteDomainId)],
+				{
+					description:
+						'An additional theme or domain card ID, for use with optional rules in Ironsworn: Delve.',
+					[JsonTypeDef]: { schema: JtdType.String() }
+				}
+			)
+		),
+		description: Type.Ref(Text.MarkdownString),
+		denizens: Type.Intersect(
+			[
+				DelveSiteDenizens,
+				Type.Tuple([
+					StaticDenizenRowStub(1, 27, 'very_common'),
+					StaticDenizenRowStub(28, 41, 'common'),
+					StaticDenizenRowStub(42, 55, 'common'),
+					StaticDenizenRowStub(56, 69, 'common'),
+					StaticDenizenRowStub(70, 75, 'uncommon'),
+					StaticDenizenRowStub(76, 81, 'uncommon'),
+					StaticDenizenRowStub(82, 87, 'uncommon'),
+					StaticDenizenRowStub(88, 93, 'uncommon'),
+					StaticDenizenRowStub(94, 95, 'rare'),
+					StaticDenizenRowStub(96, 97, 'rare'),
+					StaticDenizenRowStub(98, 99, 'rare'),
+					StaticDenizenRowStub(100, 100, 'unforeseen')
+				])
+			],
+			{
+				[JsonTypeDef]: {
+					schema: toJtdElements(DelveSiteDenizens)
+				},
+				rollable: '1d100',
+				description:
+					"Represents the delve site's denizen matrix as an array of objects."
+			}
+		)
+	}),
+	'delve_site',
+	{
+		$id: 'DelveSite',
+		description: 'A delve site with a theme, domain, and denizens.'
+	}
+)
+
+export type DelveSite = Static<typeof DelveSite>
+export type TDelveSite = typeof DelveSite

package/schema-source/schema/delve/DelveSiteDomain.ts

@@ -0,0 +1,136 @@
+import { type Static, Type } from '@sinclair/typebox'
+import { toJtdElements } from '../../scripts/json-typedef/utils.js'
+import Id from '../common/Id.js'
+import { MarkdownString } from '../common/Text.js'
+import { NonCollectableNode } from '../generic/NonCollectableNode.js'
+import { OracleRollableRowText, StaticRowPartial } from '../oracles/TableRow.js'
+import { JsonTypeDef } from '../Symbols.js'
+import { setSourceDataSchema } from '../Utils.js'
+import { EmbeddedType } from './common.js'
+
+export const DelveSiteDomainFeature = EmbeddedType(
+	OracleRollableRowText,
+	'delve_site_domain',
+	'feature',
+	{
+		description:
+			'Represents a single Feature entry from a delve site Domain card.'
+	}
+)
+export const DelveSiteDomainDanger = EmbeddedType(
+	OracleRollableRowText,
+	'delve_site_domain',
+	'danger',
+	{
+		description:
+			'Represents a single Danger entry from a delve site Domain card.'
+	}
+)
+
+const DelveSiteDomainFeatures = Type.Array(Type.Ref(DelveSiteDomainFeature))
+
+// const DelveSiteDomainDangers = Type.Array(Type.Ref(DelveSiteDomainDangerRow))
+const DelveSiteDomainDangers = Type.Array(Type.Ref(DelveSiteDomainDanger))
+
+export const DelveSiteDomain = setSourceDataSchema(
+	NonCollectableNode(
+		Type.Object({
+			summary: Type.Ref(MarkdownString, {
+				description: 'The text that appears below the title on the card.'
+			}),
+			descriptipn: Type.Optional(
+				Type.Ref(MarkdownString, {
+					description: 'Optional extended description text.'
+				})
+			),
+			name_oracle: Type.Optional(
+				Type.Ref(Id.OracleRollableId, {
+					description:
+						'An oracle table ID containing place name elements. For examples, see oracle ID `oracle_rollable:delve/site_name/place/barrow`, and its siblings in oracle collection ID `oracle_collection:delve/site_name/place`. These oracles are used by the site name oracle from Ironsworn: Delve (`oracle_rollable:delve/site_name/format`) to create random names for delve sites.'
+				})
+			),
+			features: Type.Intersect(
+				[
+					DelveSiteDomainFeatures,
+					Type.Tuple([
+						StaticRowPartial(21, 43),
+						StaticRowPartial(44, 56),
+						StaticRowPartial(57, 64),
+						StaticRowPartial(65, 68),
+						StaticRowPartial(69, 72),
+						StaticRowPartial(73, 76),
+						StaticRowPartial(77, 80),
+						StaticRowPartial(81, 84),
+						StaticRowPartial(85, 88),
+						StaticRowPartial(
+							// FIXME: disabled for now because the defaults make TypeCompiler upset
+							89,
+							98
+
+							// {
+							// 	result: 'Something unusual or unexpected',
+							// 	suggestions: {
+							// 		oracles: [
+							// 			'delve/oracles/feature/aspect',
+							// 			'delve/oracles/feature/focus'
+							// 		]
+							// 	}
+							// }
+						),
+						StaticRowPartial(
+							99,
+							99
+							// {
+							// result: 'You transition into a new theme'
+							// suggestions: {
+							// 	oracles: ['delve/oracles/site_nature/theme']
+							// }
+							// }
+						),
+						StaticRowPartial(
+							100,
+							100
+							// {
+							// 	result: 'You transition into a new domain',
+							// 	suggestions: {
+							// 		oracles: ['delve/oracles/site_nature/domain']
+							// 	}
+							// }
+						)
+					])
+				],
+				{
+					[JsonTypeDef]: {
+						schema: toJtdElements(DelveSiteDomainFeatures)
+					}
+				}
+			),
+			dangers: Type.Intersect(
+				[
+					DelveSiteDomainDangers,
+					Type.Tuple([
+						StaticRowPartial(31, 33),
+						StaticRowPartial(34, 36),
+						StaticRowPartial(37, 39),
+						StaticRowPartial(40, 42),
+						StaticRowPartial(43, 45)
+					])
+				],
+				{
+					[JsonTypeDef]: {
+						schema: toJtdElements(DelveSiteDomainDangers)
+					}
+				}
+			)
+		}),
+		'delve_site_domain',
+		{
+			$id: 'DelveSiteDomain',
+			description: 'A delve site Domain card.'
+		}
+	),
+	(schema) => ({ ...schema, additionalProperties: false })
+)
+
+export type DelveSiteDomain = Static<typeof DelveSiteDomain>
+export type TDelveSiteDomain = typeof DelveSiteDomain