The Mystery data interface.
Binds this logic to its parent data model and builds the actions map from the parent's intrinsic and scripted action definitions, selecting a default action.
Reserved base data (unused by the base class).
Must provide options.parent, the data model this logic
is embedded in; the parent's actionDefs are used to build
actions.
Executable actions for this document, keyed by shortcode — context-menu entries, chat-card buttons, and lifecycle hooks. A script action shadows (wholly overrides) the intrinsic action of the same shortcode (see the constructor).
OptionalaffiliationThe faction/Affiliation (an AffiliationLogic) this mystery
draws its standing from, resolved during evaluate from
MysteryData.assocAffiliationCode, or undefined when the mystery
names no Affiliation, the item is not on an actor, or the shortcode
matches none. This is separate from the associated
skill: a religion, arcane or alchemical school, or
ancestor/totem/spirit whose membership confers the mystery (the source of
a Piety or Grace pool, say). Surfaced as the Being sheet's Affiliation
column; a subtype may consult its rank to
inform a capability derivation.
OptionalassocThe associated skill (a SkillLogic) resolved during
evaluate from MysteryData.assocSkillCode, or undefined
when the mystery names no skill.
The mystery's charge tracking. Both value and max are always
sohl.entity.modifier.ValueModifiers; a null source value leaves the corresponding
modifier disabled, which the sheet reads to pick the ×/∞ display:
max disabled (source max === null) → mystery does not use charges,
shown as "×".value disabled (source value === null) → infinite charges
remaining, shown as "∞".max.effective === 0 → infinite charges available, shown as
"value/∞".value/max".Maximum charges; disabled when the mystery does not use charges (max === null).
Current charges; disabled when charges are infinite (value === null).
The mystery's level as a sohl.entity.modifier.ValueModifier, seeded from
MysteryData.levelBase. Disabled when the mystery has no level
(levelBase === null).
The owning SohlActor — the document itself when it is an actor,
otherwise its owning actor (for an item, combatant, or effect), or null.
The logic of the owning actor — the Foundry-free way to reach the actor
layer from any logic. For an actor's own logic this is itself; for an
item's logic it is the owning actor's logic; otherwise null.
Resolved through the SohlLogicData port, so logic code
can navigate to the actor (and iterate items via allLogics /
logicTypes / getItemLogic) without touching the Foundry document.
This logic's typed data — its *Data interface (e.g. SkillData), the same
persisted object as document.system. Prefer document.logic.data when
reading a document's fields from a macro, Script Action, or module: it is the
typed, API-documented surface (autocomplete and reference links resolve),
whereas document.system is typed as the internal DataModel.
Convenience accessor for parent.
The owning document's id.
The owning SohlItem.
The owning document's kind (its actor or item type id).
Localized display label combining the typeLabel and the document's name.
The owning document's name.
A SohlSpeaker for the owning actor/item (a blank speaker if neither resolves).
Localized type (and sub-type, when present) label for the owning document.
The owning document's UUID — the opaque identity token from the data port.
Delete the owning document, after confirming with the user.
The action context; unused.
Open the sheet for the owning document.
The action context; unused.
Compute derived values that depend on sibling items being initialized.
Called on every item after ALL items have completed initialize.
Safe to access: sibling items' initialized state (e.g., reading trait attribute values for a skill base formula).
Not safe to access: sibling items' evaluated state — another item's
evaluate() may not have run yet. Dependencies on evaluated state
belong in finalize.
Example: a Skill reads trait attribute values to compute its skill
base; a gear item resolves its containerId to find its parent container.
Execute an action by shortcode, using the provided context or creating a new one.
The shortcode of the action to execute.
Optionalcontext: sohl.entity.action.SohlActionContextThe action context to use, if any.
The result of the action execution, or undefined if the action was not found or could not be executed.
Resolve cross-item dependencies that require all items to have been evaluated.
Called on every item after ALL items have completed evaluate.
Safe to access: all sibling items' initialized and evaluated state.
Example: fate mastery level (which depends on an already-evaluated Aura trait); encumbrance totals summed across all evaluated gear.
The context-menu options — the actions currently available — for this logic's document.
The available context-menu entries.
Set up base state from persisted data: create ValueModifiers, set base values.
Called on every item before any item's evaluate runs.
Safe to access: own persisted data fields (this.data.*).
Not safe to access: sibling items on the same actor — they may not have initialized yet. Cross-item reads belong in evaluate.
Example: a Skill creates its MasteryLevelModifier
from persisted fields; it does not yet read trait attribute values.
When this Boost names a skill the actor does not have, offer to add that
skill — resolved from the world/compendiums by its shortcode — as an
unlearned embedded skill (mastery level base 0). Once present, the
Boost opens it at its Skill Base and boosts it (see the boost-contribution
logic in contributeSkillEffect); should the Boost later lapse, the skill
simply sits at ML 0 (harmless) until its owner deletes it.
This is the only way an absent-skill Boost arises: an embedded mystery's
assocSkillCode is picked from the actor's own skills, so a code the actor
lacks can only come from a world/compendium Boost dropped onto the
actor — which is exactly the human-initiated moment this offer belongs to
(the consent model: offer at a behest, never act unbidden). Driven from
MysteryDataModel._onCreate, on the initiating client only.
No-op unless this is a boost naming a skill absent from the actor; a
shortcode resolving to no skill anywhere is reported, not offered. #981.
Resolves once the offer — and any resulting skill creation — settles.
Post this item's description to the chat log — a human-triggered, informational card (no follow-up buttons) built by buildItemDescCardData. Assist, never act: this only shows the item's own text; it takes no action on any character.
The action context; unused.
Intrinsic action performed after finalize lifecycle stage. This is intended for modules to hook into (or ActionItems to override) to perform additional logic after the main lifecycle stages have completed.
The action context for the post-finalize hook.
GM result-edit for a posted test card (#856) — the higher-fidelity
counterpart to Fate. Re-opens the standard test dialog pre-filled with the
result's current situational and success-level modifiers; on submit it
applies the new modifiers and re-evaluates on the SAME frozen roll
(never a re-roll, no Fate cost), then reposts the card. The prior result
rides in context.scope.priorTestResult (the reconstruction seam), so this
works for any standard test card — skill, attribute, or combat strike mode.
Changing the situational modifier changes the effective target, so the base success level re-derives from the frozen roll; the success-level modifier is a flat offset applied after. Clicking OK without a change is a no-op (nothing re-evaluated, nothing reposted).
GM-only. The pencil is render-hidden from non-GMs (sohl.document.chat.gateEditActionPencil); this is the click-time half of that gate — a synthesized click from a non-GM is refused here.
The action context; context.scope.priorTestResult is the
result being edited. When skipDialog is set, the new
situationalModifier / successLevelMod / rollMode are taken from
context.scope instead of the dialog.
The re-evaluated result, or undefined when refused (non-GM),
cancelled (dialog dismissed), or unchanged (no-op).
Serialize this logic to a plain reference.
A uuid-keyed reference to this logic.
A logic is a behavior wrapper over a live Foundry document; it is never
revived from its own JSON (its constructor needs that document). Wherever a
logic is persisted — a chat card, an action sohl.entity.action.SohlActionContext.scope
— it is re-resolved from its uuid (e.g. via fvttLogicFromUuidSync), not
rebuilt from a payload. So it serializes as a compact, resolvable reference
(name/kind are carried for display and debugging); the owning document
holds the actual persisted state.
StaticdefineIntrinsic actions shared by every item kind: the SohlLogic base pair (edit/delete) plus outputDescription, which posts the item's description to the chat log.
The intrinsic action definitions shared by every item kind.
A passive or charge-based mystical power associated with a character or object.
Mysteries represent supernatural gifts, blessings, and connections that influence a character's capabilities. Unlike Mystical Abilities (which are actively cast), mysteries are often passive or limited-use powers that enhance skills, grant re-rolls, or provide divine favor.
A Mystery models what a character is — a standing condition, pool, or blessing — so it carries no "use it" action of its own: there is no universal meaning to using a Mystery. Anything a character actively invokes is a Mystical Ability, which has its own action and roll; a subtype that should be spent down is driven by whatever consumes it.
Each mystery tracks a level and optional charges (value and max); a
nullcharge value denotes infinite uses. A mystery may name an associated Skill (e.g. the skill a boon or boost affects).Subtypes (MysterySubType):
±Nmodifier to an associated skill's mastery level, from any source.A Boon or Boost mystery names its target skill via MysteryData.assocSkillCode and, while active (a present, non-zero level), contributes a live delta onto that skill's mastery level in finalize. The mystery's level carries the effect's magnitude —
±Nfor a Boon, the boost countNfor a Boost.