A type of RollTerm used to enclose a parenthetical expression to be recursively evaluated.

Hierarchy (view full)

Properties

term: string

The original provided string term used to construct the parenthetical

roll: Roll

An already-evaluated Roll instance used instead of the string term.

isIntermediate: boolean = true

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

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.

OPEN_REGEXP: RegExp = ...

The regular expression pattern used to identify the opening of a parenthetical expression. This could also identify the opening of a math function.

CLOSE_REGEXP: RegExp = ...

A regular expression pattern used to identify the closing of a parenthetical expression.

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

REGEXP: RegExp = undefined

A regular expression used to match a term of this type

Accessors

  • get dice(): DiceTerm[]
  • An array of evaluated DiceTerm instances that should be bubbled up to the parent Roll

    Returns DiceTerm[]

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

    Returns any

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

    Returns string

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

    Returns any

  • 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

  • Evaluate the term.

    Parameters

    • options: {} = {}

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

      Returns RollTerm | Promise<RollTerm>

      Returns a Promise if the term is non-deterministic.

    • 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.

    • 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

    • Protected

      Evaluate this parenthetical when it contains any non-deterministic sub-terms.

      Parameters

      • roll: Roll

        The inner Roll instance to evaluate.

      • Optional options: object = {}

      Returns Promise<RollTerm>

    • Protected

      Evaluate this parenthetical when it contains only deterministic sub-terms.

      Parameters

      • roll: Roll

        The inner Roll instance to evaluate.

      • Optional options: object = {}

      Returns RollTerm

    • Construct a ParentheticalTerm from an Array of component terms which should be wrapped inside the parentheses.

      Parameters

      • terms: RollTerm[]

        The array of terms to use as internal parts of the parenthetical

      • Optional options: object

        Additional options passed to the ParentheticalTerm constructor

      Returns ParentheticalTerm

      The constructed ParentheticalTerm instance

      Example: Create a Parenthetical Term from an array of component RollTerm instances

      const d6 = new Die({number: 4, faces: 6});
      const plus = new OperatorTerm({operator: "+"});
      const bonus = new NumericTerm({number: 4});
      t = ParentheticalTerm.fromTerms([d6, plus, bonus]);
      t.formula; // (4d6 + 4)
    • 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

    • Protected

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

      Parameters

      • data: object

        The de-serialized term data

      Returns RollTerm

      The re-constructed RollTerm object