A type of DiceTerm used to represent rolling a fair n-sided die.

Implements

Example: Roll four six-sided dice

let die = new Die({faces: 6, number: 4}).evaluate();

Hierarchy (view full)

Constructors

  • Parameters

    • termData: {
          number: any;
          faces: any;
          modifiers: string[];
          results: object[];
          options: object;
      }

      Data used to create the Dice Term, including the following:

      • number: any

        The number of dice of this term to roll, before modifiers are applied, or a Roll instance that will be evaluated to a number.

      • faces: any

        The number of faces on each die of this type, or a Roll instance that will be evaluated to a number.

      • modifiers: string[]

        An array of modifiers applied to the results

      • results: object[]

        An optional array of pre-cast results for the term

      • options: object

        Additional options that modify the term

    Returns Die

Properties

modifiers: string[]

An Array of dice term modifiers which are applied

results: DiceTermResult[]

The array of dice term results which have been rolled

options: object

An object of additional options which describes and modifies the term.

_root: Roll

A reference to the Roll at the root of the evaluation tree.

isIntermediate: boolean = false

Is this term intermediate, and should be evaluated first as part of the simplification process?

_number: any

The number of dice of this term to roll, before modifiers are applied, or a Roll instance that will be evaluated to a number.

_faces: any

The number of faces on the die, or a Roll instance that will be evaluated to a number.

DENOMINATION: string = "d"

Define the denomination string used to register this DiceTerm type in CONFIG.Dice.terms

MODIFIERS: {
    r: string;
    rr: string;
    x: string;
    xo: string;
    k: string;
    kh: string;
    kl: string;
    d: string;
    dh: string;
    dl: string;
    min: string;
    max: string;
    even: string;
    odd: string;
    cs: string;
    cf: string;
    df: string;
    sf: string;
    ms: string;
} = ...

Define the named modifiers that can be applied for this particular DiceTerm type.

Type declaration

  • r: string
  • rr: string
  • x: string
  • xo: string
  • k: string
  • kh: string
  • kl: string
  • d: string
  • dh: string
  • dl: string
  • min: string
  • max: string
  • even: string
  • odd: string
  • cs: string
  • cf: string
  • df: string
  • sf: string
  • ms: string
MODIFIERS_REGEXP_STRING: string = "([^ (){}[\\]+\\-*/]+)"

A regular expression pattern which captures the full set of term modifiers Anything until a space, group symbol, or arithmetic operator

MODIFIER_REGEXP: RegExp = ...

A regular expression used to separate individual modifiers

REGEXP: RegExp = ...

A regular expression used to match a term of this type

SERIALIZE_ATTRIBUTES: string[] = ...

An array of additional attributes which should be retained when the term is serialized

FLAVOR_REGEXP_STRING: string = "(?:\\[([^\\]]+)\\])"

A regular expression pattern which identifies optional term-level flavor text

FLAVOR_REGEXP: RegExp = ...

A regular expression which identifies term-level flavor text

Accessors

  • get total(): number
  • A string or numeric representation of the final output for this term, after evaluation.

    Returns number

  • get denomination(): string
  • The denomination of this DiceTerm instance.

    Returns string

  • get method(): string
  • The resolution method used to resolve this DiceTerm.

    Returns string

  • get number(): number | void
  • The number of dice of this term to roll. Returns undefined if the number is a complex term that has not yet been evaluated.

    Returns number | void

  • get faces(): number | void
  • The number of faces on the die. Returns undefined if the faces are represented as a complex term that has not yet been evaluated.

    Returns number | void

  • get expression(): string
  • A string representation of the formula expression for this RollTerm, prior to evaluation.

    Returns string

  • get dice(): DiceTerm[]
  • An array of additional DiceTerm instances involved in resolving this DiceTerm.

    Returns DiceTerm[]

  • get values(): number[]
  • Return an array of rolled values which are still active within this term

    Returns number[]

  • get isDeterministic(): boolean
  • Whether this term is entirely deterministic or contains some randomness.

    Returns boolean

  • get formula(): string
  • A string representation of the formula, including optional flavor text.

    Returns string

  • get flavor(): string
  • Optional flavor text which modifies and describes this term.

    Returns string

  • get resolver(): RollResolver
  • A reference to the RollResolver app being used to externally resolve this term.

    Returns RollResolver

Methods

  • Re-roll the Die, rolling additional results for any values which fall within a target set. If no target number is specified, re-roll the lowest possible result.

    20d20r reroll all 1s 20d20r1 reroll all 1s 20d20r=1 reroll all 1s 20d20r1=1 reroll a single 1

    Parameters

    • modifier: string

      The matched modifier query

    • recursive: boolean = {}

      Reroll recursively, continuing to reroll until the condition is no longer met

    Returns Promise<false | void>

    False if the modifier was unmatched

  • Parameters

    • modifier: any

    Returns Promise<false | void>

  • Explode the Die, rolling additional results for any values which match the target set. If no target number is specified, explode the highest possible result. Explosion can be a "small explode" using a lower-case x or a "big explode" using an upper-case "X"

    Parameters

    • modifier: string

      The matched modifier query

    • recursive: boolean = {}

      Explode recursively, such that new rolls can also explode?

    Returns Promise<false | void>

    False if the modifier was unmatched.

  • Parameters

    • modifier: any

    Returns Promise<false | void>

  • Keep a certain number of highest or lowest dice rolls from the result set.

    20d20k Keep the 1 highest die 20d20kh Keep the 1 highest die 20d20kh10 Keep the 10 highest die 20d20kl Keep the 1 lowest die 20d20kl10 Keep the 10 lowest die

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Drop a certain number of highest or lowest dice rolls from the result set.

    20d20d Drop the 1 lowest die 20d20dh Drop the 1 highest die 20d20dl Drop the 1 lowest die 20d20dh10 Drop the 10 highest die 20d20dl10 Drop the 10 lowest die

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Count the number of successful results which occurred in a given result set. Successes are counted relative to some target, or relative to the maximum possible value if no target is given. Applying a count-success modifier to the results re-casts all results to 1 (success) or 0 (failure)

    20d20cs Count the number of dice which rolled a 20 20d20cs>10 Count the number of dice which rolled higher than 10 20d20cs<10 Count the number of dice which rolled less than 10

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Count the number of failed results which occurred in a given result set. Failures are counted relative to some target, or relative to the lowest possible value if no target is given. Applying a count-failures modifier to the results re-casts all results to 1 (failure) or 0 (non-failure)

    6d6cf Count the number of dice which rolled a 1 as failures 6d6cf<=3 Count the number of dice which rolled less than 3 as failures 6d6cf>4 Count the number of dice which rolled greater than 4 as failures

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Count the number of even results which occurred in a given result set. Even numbers are marked as a success and counted as 1 Odd numbers are marked as a non-success and counted as 0.

    6d6even Count the number of even numbers rolled

    Parameters

    • modifier: string

      The matched modifier query

    Returns void

  • Count the number of odd results which occurred in a given result set. Odd numbers are marked as a success and counted as 1 Even numbers are marked as a non-success and counted as 0.

    6d6odd Count the number of odd numbers rolled

    Parameters

    • modifier: string

      The matched modifier query

    Returns void

  • Deduct the number of failures from the dice result, counting each failure as -1 Failures are identified relative to some target, or relative to the lowest possible value if no target is given. Applying a deduct-failures modifier to the results counts all failed results as -1.

    6d6df Subtract the number of dice which rolled a 1 from the non-failed total. 6d6cs>3df Subtract the number of dice which rolled a 3 or less from the non-failed count. 6d6cf<3df Subtract the number of dice which rolled less than 3 from the non-failed count.

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Subtract the value of failed dice from the non-failed total, where each failure counts as its negative value. Failures are identified relative to some target, or relative to the lowest possible value if no target is given. Applying a deduct-failures modifier to the results counts all failed results as -1.

    6d6df<3 Subtract the value of results which rolled less than 3 from the non-failed total.

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Subtract the total value of the DiceTerm from a target value, treating the difference as the final total. Example: 6d6ms>12 Roll 6d6 and subtract 12 from the resulting total.

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Constrain each rolled result to be at least some minimum value. Example: 6d6min2 Roll 6d6, each result must be at least 2

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Constrain each rolled result to be at most some maximum value. Example: 6d6max5 Roll 6d6, each result must be at most 5

    Parameters

    • modifier: string

      The matched modifier query

    Returns boolean

  • Alter the DiceTerm by adding or multiplying the number of dice which are rolled

    Parameters

    • multiply: number

      A factor to multiply. Dice are multiplied before any additions.

    • add: number

      A number of dice to add. Dice are added after multiplication.

    Returns DiceTerm

    The altered term

  • Evaluate the term.

    Parameters

    • options: {} = {}

      Options which modify how the RollTerm is evaluated, see RollTerm#evaluate

      Returns DiceTerm | Promise<DiceTerm>

      Returns a Promise if the term is non-deterministic.

    • Roll the DiceTerm by mapping a random uniform draw against the faces of the dice term.

      Parameters

      • Optional options: {
            minimize: boolean;
            maximize: boolean;
        } = {}

        Options which modify how a random result is produced

        • minimize: boolean

          Minimize the result, obtaining the smallest possible value.

        • maximize: boolean

          Maximize the result, obtaining the largest possible value.

      Returns Promise<DiceTermResult>

      The produced result

    • Maps a randomly-generated value in the interval [0, 1) to a face value on the die.

      Parameters

      • randomUniform: number

        A value to map. Must be in the interval [0, 1).

      Returns number

      The face value.

    • Generate a random face value for this die using the configured PRNG.

      Returns number

    • Return a string used as the label for each rolled result

      Parameters

      Returns string

      The result label

    • Get the CSS classes that should be used to display each rolled result

      Parameters

      Returns string[]

      The desired classes

    • Render the tooltip HTML for a Roll instance

      Returns object

      The data object used to render the default tooltip template for this DiceTerm

    • Internal

      Sequentially evaluate each dice roll modifier by passing the term to its evaluation function Augment or modify the results array.

      Returns Promise<void>

    • Internal

      Asynchronously evaluate a single modifier command, recording it in the array of evaluated modifiers

      Parameters

      • command: string

        The parsed modifier command

      • modifier: string

        The full modifier request

      Returns Promise<void>

    • Serialize the RollTerm to a JSON string which allows it to be saved in the database or embedded in text. This method should return an object suitable for passing to the JSON.stringify function.

      Returns object

    • Evaluate the term, processing its inputs and finalizing its total.

      Parameters

      • Optional options: {
            minimize: boolean;
            maximize: boolean;
            allowStrings: boolean;
        } = {}

        Options which modify how the RollTerm is evaluated

        • minimize: boolean

          Minimize the result, obtaining the smallest possible value.

        • maximize: boolean

          Maximize the result, obtaining the largest possible value.

        • allowStrings: boolean

          If true, string terms will not throw an error when evaluated.

      Returns RollTerm | Promise<RollTerm>

      Returns a Promise if the term is non-deterministic.

    • Protected

      Evaluate this dice term asynchronously.

      Parameters

      • Optional options: object = {}

        Options forwarded to inner Roll evaluation.

      Returns Promise<DiceTerm>

    • Protected

      Evaluate deterministic values of this term synchronously.

      Parameters

      • Optional options: {
            maximize: boolean;
            minimize: boolean;
            strict: boolean;
        } = {}
        • maximize: boolean

          Force the result to be maximized.

        • minimize: boolean

          Force the result to be minimized.

        • strict: boolean

          Throw an error if attempting to evaluate a die term in a way that cannot be done synchronously.

      Returns DiceTerm

    • Protected

      Generate a roll result value for this DiceTerm based on its fulfillment method.

      Parameters

      • Optional options: object = {}

        Options forwarded to the fulfillment method handler.

      Returns Promise<number | void>

      Returns a Promise that resolves to the fulfilled number, or undefined if it could not be fulfilled.

    • Invoke the configured fulfillment handler for this term to produce a result value.

      Parameters

      • Optional options: object = {}

        Options forwarded to the fulfillment method handler.

      Returns Promise<number | void>

      Returns a Promise that resolves to the fulfilled number, or undefined if it could not be fulfilled.

    • A helper comparison function. Returns a boolean depending on whether the result compares favorably against the target.

      Parameters

      • result: number

        The result being compared

      • comparison: string

        The comparison operator in [=,<,<=,>,>=]

      • target: number

        The target value

      Returns boolean

      Is the comparison true?

    • A helper method to modify the results array of a dice term by flagging certain results are kept or dropped.

      Parameters

      • results: object[]

        The results array

      • number: number

        The number to keep or drop

      • Optional __namedParameters: boolean = {}

      Returns object[]

      The modified results array

    • A reusable helper function to handle the identification and deduction of failures

      Parameters

      • results: any
      • comparison: any
      • target: any
      • __namedParameters: {
            flagSuccess: boolean;
            flagFailure: boolean;
        } = {}
        • flagSuccess: boolean
        • flagFailure: boolean

      Returns void

    • A reusable helper function to handle the identification and deduction of failures

      Parameters

      • results: any
      • comparison: any
      • target: any
      • __namedParameters: {
            deductFailure: boolean;
            invertFailure: boolean;
        } = {}
        • deductFailure: boolean
        • invertFailure: boolean

      Returns void

    • Determine whether a string expression matches this type of term

      Parameters

      • expression: string

        The expression to parse

      • Optional options: {
            imputeNumber: boolean;
        } = {}

        Additional options which customize the match

        • imputeNumber: boolean

          Allow the number of dice to be optional, i.e. "d6"

      Returns RegExpMatchArray

    • Construct a term of this type given a matched regular expression array.

      Parameters

      • match: RegExpMatchArray

        The matched regular expression array

      Returns DiceTerm

      The constructed term

    • Define term-specific logic for how a de-serialized data object is restored as a functional RollTerm

      Parameters

      • data: any

        The de-serialized term data

      Returns RollTerm

      The re-constructed RollTerm object

    • Determine if evaluating a given RollTerm with certain evaluation options can be done so deterministically.

      Parameters

      • term: RollTerm

        The term.

      • Optional options: {
            maximize: boolean;
            minimize: boolean;
        } = {}

        Options for evaluating the term.

        • maximize: boolean

          Force the result to be maximized.

        • minimize: boolean

          Force the result to be minimized.

      Returns boolean

    • Construct a RollTerm from a provided data object

      Parameters

      • data: object

        Provided data from an un-serialized term

      Returns RollTerm

      The constructed RollTerm

    • Reconstruct a RollTerm instance from a provided JSON string

      Parameters

      • json: string

        A serialized JSON representation of a DiceTerm

      Returns RollTerm

      A reconstructed RollTerm from the provided JSON