Rolls the impact on construction (the impact has occurred). A pre-rolled
data.roll may be supplied — by tests, or when reviving a serialized
snapshot — in which case it is reused rather than re-rolled.
Impact data; impactModifier is required.
Result options; options.parent is required (base
TestResult).
The impact (damage) formula used: dice + modifier + aspect.
A label for what caused the impact (weapon name, "fall", "spell", …).
The rolled impact dice.
The body part shortcode this impact aims at (empty when unaimed). Read-through to impactModifier — the single source of truth.
The damage aspect (blunt/edged/piercing/fire) of this impact.
Human-readable description shown on the result's chat card.
The serialization discriminator for this instance — the concrete class's static Kind. Written into the JSON by toJSON under the kind key and read back by sohl.utils.defaultFromJSON to select the constructor. Derived from the class, never stored per-instance.
Internal identifier for this result (distinct from the display title).
Speaker identity (actor/token/user) used when posting this result to chat.
Strike spread governing hit-location scatter from aimBodyPartCode. Read-through to impactModifier — the single source of truth.
Title shown at the top of the result's chat card.
Raw impact total (pre-armor), as rolled.
Deep-copy this entity, re-parenting the copy under parent with no other
changes. Shorthand for clone({}, { parent }).
The Logic to own the cloned entity.
The cloned entity.
Deep-copy this entity, optionally overriding fields and clone options.
Field overrides applied to the clone.
Clone options (e.g. a new parent).
The cloned entity.
Resolve the test outcome. The base implementation is a no-op that returns
true; subclasses override it to roll dice, compute success levels, and
apply mishaps.
true if the result should be displayed (e.g. posted to chat);
false if the test was cancelled or is not allowed to proceed.
Serialize to a plain object satisfying ImpactResult.Data: the inherited TestResult fields plus the impact modifier, rolled dice, aim, spread, and label.
The plain-object representation.
The result of computing an impact — a rolled quantum of damage to be applied to a body, independent of what caused it.
ImpactResultis deliberately source-agnostic: a melee/missile hit, a fall, a spell, a trap, etc. all produce anImpactResult, which then feeds the injury-resolution stage (armor → effective impact → injury level). It is not a success test — there is no roll-under-mastery outcome here; it simply carries the rolled impact dice, the damage aspect, where the blow is aimed (if anywhere), and a label for its source.In automated combat it is produced when a blow lands (see CombatResult); the same class is reused for any non-combat damage.
Position in the pipeline
<source>→ImpactResult(raw impact: roll, total, aspect, aim) → injury resolution (armor → effective impact → injury level) → injury.The total here is pre-armor; whether it actually wounds is decided downstream, where armor may reduce the effective impact to zero.