dice-typescript

This fork of dice-typescript changes how conditional rolls are handled.

A TypeScript library for parsing dice rolling expressions, most commonly used in tabletop RPGs.

Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

Installing

npm install dice-typescript

Usage

Basic Usage

At its simplest, the dice roller is very simple to use. Take the following example:

import { Dice } from "@scio/dice-typescript";
// Or `import Dice from 'https://esm.sh/@scio/dice-typescript';` for Deno

const dice = new Dice();
const result = dice.roll("1d20").total;
console.log(result); // Outputs a random number between 1 and 20.

The roll(expression: string) method returns a DiceResult object that, aside from the total of the roll, also includes the number of passes/fails that were rolled (if pass and fail conditions were specified). Finally, it also provides an expanded model of the results for each die roll, for any required breakdown.

Modifying Behavior

The Dice class has several methods that can be overridden in order to modify the construction of the lexer/parser/interpreter/generator:

// Used to control the breaking down of a string into tokens: (4d10) = LPAREN, NUMBER, DICE, NUMBER, RPAREN, etc.
protected createLexer(input: string | CharacterStream): Lexer;

// Used to control the construction of a stream of tokens into an abstract syntax tree.
protected createParser(lexer: Lexer): Parser;

// Used to actually process an abstract syntax tree, perform the appropriate dice rolls and figure out successes/failures.
protected createInterpreter(): DiceInterpreter;

// Used to control how an expression is 'rendered', that is, how an abstract syntax tree is converted back into a string.
protected createGenerator(): DiceGenerator;

Overriding any of the above methods will allow you to control the exact instance that is created for each part of the interpreting process.

Custom Functions

In addition to the abs, ceil, floor, round and sqrt functions, the Dice library also supports adding definitions for custom functions, such as the example below:

const customFunctions = new FunctionDefinitionList();
customFunctions["floor"] = (
  interpreter: DiceInterpreter,
  functionNode: ExpressionNode,
  errors: ErrorMessage[],
): number => {
  return Math.floor(interpreter.evaluate(functionNode.getChild(0), errors));
};

const dice = new Dice(customFunctions);
const result = dice.roll("floor(1d20 / 2)").total;
console.log(result); // Outputs a random number between 1 and 20, divided by 2, then rounded down.

Random Provider

By default, the Dice library uses random-js to generate random numbers. In some instances, this may not be suitable, so this can be enhanced by a custom implementation of the RandomProvider interface as in the example below:

export class CustomRandom implements RandomProvider {
  numberBetween(min: number, max: number) {
    return 4; // chosen by fair dice roll.
    // guaranteed to be random.
  }
}

const dice = new Dice(null, new CustomRandom());
const result = dice.roll("1d20").total;
console.log(result); // Outputs 4.

Limiting the number of rolls or sides

Limit the number of rolls or dice sides by providing a configuration object to the Dice constructor:

const dice = new Dice(null, null, {
  maxRollTimes: 20, // limit to 20 rolls
  maxDiceSides: 100, // limit to 100 dice faces
});
const result1 = dice.roll("50d10");
console.log(result1.errors); // Outputs ["Invalid number of rolls: 50. Maximum allowed: 20."]
const result2 = dice.roll("10d500");
console.log(result2.errors); // Outputs ["Invalid number of dice sides: 500. Maximum allowed: 100."]

Adding decorators to rolls in rendered expression

When viewing individual roll results, its useful to know what was considered in the final result. The renderExpressionDecorators option inserts aditional information to roll results. The following symbols are added, depending on the executed rules:

• reroll: ↻
• explode: !
• drop: ↓
• critical: *
• success: ✓
• failure: ✗

const dice = new Dice(null, null, {
  renderExpressionDecorators: true, // will render roll decorators
});
const result = dice.roll("4d10!");
console.log(result.renderedExpression); // Outputs "[3, 10!, 6, 7, 6 ]!" (note the exclamation mark added to the exploded roll)

Using custom roll decorators

You can also add your own roll decorators. Use the option decorators to specify, for each rule type, a string that will be added after the result or an array with strings that will be added before and after the roll value.

const dice = new Dice(null, null, {
  renderExpressionDecorators: true, // will render roll decorators
  decorators: {
    reroll: ["<r>", "</r>"], // example output: <r>1</r>
    explode: ["<e>", "</e>"], // example output: <e>10</e>
    drop: "d", // example output: 2d
    critical: "c", // example output: 10c
    success: "s", // example output: 9s
  },
});

Dice Expression Syntax

The dice rolling syntax is based on the system used by Roll20, a detailed explanation of which can be found on the Roll20 Wiki.

In addition to the above syntax rules, some slightly more complicated variations are available. For example, you can roll a variable number of dice using an expression similar to the following:

(4d4)d20

Conditional Operators

As per the Roll20 syntax, you can use conditional operators, such as in 4d20>10, but in this library, the semantics of those operators is slightly different. In the Roll20 engine, >10 actually means >=10, but in this library, you would need to actually use the >= operator. I feel needing to use the correct mathematical operators makes for a more intuitive library.

In this fork, the number of successes in conditional dice-pools are returned as the total, so that they can be used to form more complex expressions.

{4d10 >= 5} + 1

The above will roll a World of Darkness like dice-pool of four dice, and a bonus free success.

Group Repeaters

Sometimes it is necessary to roll complex groups of dice that aren't supported by the basic syntax. For example, rolling a saving throw at disadvantage for 10 creatures. For this, you can use the group repeater modifier, which works like this:

{2d20kl...10}>=14

The above will roll 10 disadvantaged saving throws, reporting the number of successes for those that break DC14.

Fractional Dice Rolls

Using the allowed syntax, it is possible to request a fractional number of dice to be rolled. Take the following example:

(2 / 5)d6

In this instance, the number of dice to be rolled will be rounded to the nearest integer (2.5 gets rounded up to 3).

This will first roll 4d4 dice, and use the outcome of that to determine how many d20 dice will be rolled.

Installing Dependencies

Installing the dependencies is done using a standard npm i.

Running the Tests

npm run test

Building the project

npm run build

Versioning

We use SemVer for versioning. For the versions available, see the tags on this repository.

Authors

• Tom Wolfe - Initial work - trwolfe13

See also the list of contributors who participated in this project.

License

This project is licensed under the MIT License - see the LICENSE file for details