Class ParentheticalTerm

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

Hierarchy (View Summary)

Properties

_root isIntermediate options roll term CLOSE_REGEXP FLAVOR_REGEXP FLAVOR_REGEXP_STRING OPEN_REGEXP REGEXP SERIALIZE_ATTRIBUTES

Accessors

dice expression flavor formula isDeterministic resolver total

Methods

_evaluate evaluate toJSON _evaluateAsync _evaluateSync fromData fromJSON fromParseNode fromTerms isDeterministic _fromData

Properties

Internal_root

_root: Roll

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

isIntermediate

isIntermediate: boolean = true

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

options

options: object

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

roll

roll: Roll

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

term

term: string

The original provided string term used to construct the parenthetical

StaticCLOSE_REGEXP

CLOSE_REGEXP: RegExp = ...

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

StaticFLAVOR_REGEXP

FLAVOR_REGEXP: RegExp = ...

A regular expression which identifies term-level flavor text

StaticFLAVOR_REGEXP_STRING

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

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

StaticOPEN_REGEXP

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.

StaticREGEXP

REGEXP: RegExp = undefined

A regular expression used to match a term of this type

StaticSERIALIZE_ATTRIBUTES

SERIALIZE_ATTRIBUTES: string[] = ...

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

Accessors

dice

  • get dice(): DiceTerm[]

    An array of evaluated DiceTerm instances that should be bubbled up to the parent Roll

    Returns DiceTerm[]

expression

  • get expression(): string

    A string representation of the formula expression for this RollTerm, prior to evaluation.

    Returns string

flavor

  • get flavor(): string

    Optional flavor text which modifies and describes this term.

    Returns string

formula

  • get formula(): string

    A string representation of the formula, including optional flavor text.

    Returns string

isDeterministic

  • get isDeterministic(): boolean

    Whether this term is entirely deterministic or contains some randomness.

    Returns boolean

resolver

  • get resolver(): RollResolver

    A reference to the RollResolver app being used to externally resolve this term.

    Returns RollResolver

total

  • get total(): number

    A string or numeric representation of the final output for this term, after evaluation.

    Returns number

Methods

_evaluate

  • _evaluate(options?: {}): RollTerm | Promise<RollTerm>

    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

  • evaluate(
        options?: {
            allowStrings?: boolean;
            maximize?: boolean;
            minimize?: boolean;
        },
    ): RollTerm
    | Promise<RollTerm>

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

    Parameters

    • Optionaloptions: { allowStrings?: boolean; maximize?: boolean; minimize?: boolean } = {}

      Options which modify how the RollTerm is evaluated

      • OptionalallowStrings?: boolean

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

      • Optionalmaximize?: boolean

        Maximize the result, obtaining the largest possible value.

      • Optionalminimize?: boolean

        Minimize the result, obtaining the smallest possible value.

    Returns RollTerm | Promise<RollTerm>

    Returns a Promise if the term is non-deterministic.

toJSON

  • toJSON(): RollTermData

    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 RollTermData

Protected_evaluateAsync

  • _evaluateAsync(roll: Roll, options?: object): Promise<RollTerm>
    Protected

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

    Parameters

    • roll: Roll

      The inner Roll instance to evaluate.

    • Optionaloptions: object = {}

    Returns Promise<RollTerm>

Protected_evaluateSync

  • _evaluateSync(roll: Roll, options?: object): RollTerm
    Protected

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

    Parameters

    • roll: Roll

      The inner Roll instance to evaluate.

    • Optionaloptions: object = {}

    Returns RollTerm

StaticfromData

StaticfromJSON

  • fromJSON(json: string): 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

StaticfromParseNode

StaticfromTerms

  • fromTerms(terms: RollTerm[], options?: object): ParentheticalTerm

    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

    • Optionaloptions: 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)

StaticisDeterministic

  • isDeterministic(
        term: RollTerm,
        options?: { maximize?: boolean; minimize?: boolean },
    ): boolean

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

    Parameters

    • term: RollTerm

      The term.

    • Optionaloptions: { maximize?: boolean; minimize?: boolean } = {}

      Options for evaluating the term.

      • Optionalmaximize?: boolean

        Force the result to be maximized.

      • Optionalminimize?: boolean

        Force the result to be minimized.

    Returns boolean

Protected Static_fromData

  • _fromData(data: RollTermData): RollTerm
    Protected

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

    Parameters

    Returns RollTerm

    The re-constructed RollTerm object

Settings

Member Visibility

On This Page

Properties
Accessors
Methods