Dice Roller Pro Unity Asset

Parse any dice notation. Roll anything. Ship faster.

Dice Roller Pro is a high-performance Unity library that brings the full power of tabletop dice notation to your game with a single line of C#. From 3d6+2 to {4d6kh3}!, every expression you need for a tabletop RPG, roguelike, or board game is supported out of the box.

Why Dice Roller Pro?

Most dice solutions in Unity handle the simple cases: roll a d6, roll a d20. They break down the moment your game needs advantage/disadvantage rolls, exploding dice, Fate dice for PBTA games, or custom polyhedral faces. Dice Roller Pro solves all of these with one unified, expression-based API that your designers can read and your code can trust.

Key Features

• One-Line Static API
  The Dice static class gives you throwing and non-throwing entry points – Dice.Roll(), Dice.TryRoll(), Dice.Parse(), Dice.TryParse() – backed by a thread-safe parser and a warm expression cache. No setup, no instantiation.
• Full Dice Notation Parser
  Parses standard and extended dice notation with full arithmetic. Operator precedence follows PEMDAS, so 3d6*2+1 evaluates exactly as you expect. Unary minus, modulo, and nested parentheses all work.
• Exploding Dice
  Three explosion modes: basic (!), compound (!!), and penetrating (!p). A built-in chain cap (100 rolls) prevents infinite loops on pathological inputs like 1d1!.
• Keep / Drop Modifiers
  Keep highest, keep lowest, drop highest, drop lowest – all combinable. 4d6kh3 for D&D ability scores. 2d20kh1 for advantage. Any combination you can express, the parser understands.
• Custom and Fate Dice
  Define any set of face values with 3d[2,4,6,8]. Supports weighted faces (repeated values) and negative faces. Four Fate/Fudge dice? Just write 4dF.
• ScriptableObject Assets
  Create dice configurations as .asset files via Assets → Create → Dice Roller Pro. Assign them in the Inspector, version-control them alongside your scenes, and swap them without touching code.
• Unity Editor Tooling
  • Live Expression Validator window (Window → Dice Roller Pro → Expression Validator)
  • Roll Preview panel on every dice asset (min / max / average / last breakdown)
  • Reorderable child editor for Group and Sequence assets
  • Guided Modifiers drawer that enforces mutual exclusivity
• Validation Framework
  DiceValidator returns rich results with severity levels (Critical, Error, Warning, Info), categories (Syntax, Logic, Performance, Configuration), and fix suggestions – without throwing exceptions.
• High Performance
  Span-based allocation-free parsing, thread-local StringBuilder pooling, expression caching, and O(1) keep/drop sorting keep hot paths lean even at scale.

Purchase the Dice Roller Pro from the Unity Asset Store here >>

Supported Dice Notation

Basic Rolls

Keep / Drop Modifiers

Exploding Dice

Special Dice Types

Groups and Advanced Expressions

Arithmetic

Operator precedence: *, /, and % bind tighter than + and -. Parentheses override everything. A leading +, -, *, or / is treated as a unary prefix.

Getting Started

1. Import the Package

Download from the Unity Asset Store and import into your project. Requires Unity 2022.3 LTS or newer (.NET Standard 2.1, C# 9.0).

2. Roll with the Static API

The fastest path: call Dice.Roll() anywhere in your MonoBehaviour. No instantiation needed.

using DiceRollerPro;

// Throwing overload — use when you control the expression
int total = Dice.Roll("3d6+2");

// Non-throwing — ideal for user-supplied input
if (Dice.TryRoll("4d6kh3", out int stat, out string error))
    Debug.Log($"Stat: {stat}");

// Full result tree with per-die breakdown
if (Dice.TryRoll("3d6", new System.Random(), out IResult result, out _))
    Debug.Log(RollExplainer.Explain(result)); // e.g. "(4 + 3 + 5)"

// Parse once, roll many — cache-backed
var advantage = Dice.Parse("2d20kh1");
var rng = new System.Random();
for (int i = 0; i < 5; i++)
    Debug.Log(advantage.GenerateValue(rng).Value);

3. Optionally Create Dice Assets

Right-click in the Project window → Create → Dice Roller Pro → Normal Dice to build a reusable ScriptableObject asset. Drag it onto any MonoBehaviour field in the Inspector.

public class CharacterSheet : MonoBehaviour
{
    [SerializeField] private BaseRoll attackRoll;   // Assign in Inspector
    [SerializeField] private BaseRoll damageRoll;   // e.g. 2d6+3 asset

    private readonly System.Random random = new System.Random();

    public void Attack()
    {
        var attackResult = attackRoll.GenerateValue(random);
        var damageResult = damageRoll.GenerateValue(random);
        Debug.Log($"Attack: {attackResult.Value} — {RollExplainer.Explain(attackResult)}");
        Debug.Log($"Damage: {damageResult.Value} — {RollExplainer.Explain(damageResult)}");
    }
}

4. Validate Expressions

Open Window → Dice Roller Pro → Expression Validator to test any expression live – parser preview, sample roll, and validation issues with severity levels.

Dice Types

Normal Dice (NormalDice)

Standard polyhedral dice – d4, d6, d8, d10, d12, d20, d100. Supports all modifiers: keep/drop, exploding, and compound combinations.

Percentile Dice (PercentileDice)

Rolls values from 1 to 100. Use 1d% or 1d100 in notation. Supports exploding mechanics: a roll of 100 triggers another roll.

Fate / Fudge Dice (FateDice)

Each die produces −1, 0, or +1 with equal probability. Four Fate dice (4dF) give a result between −4 and +4, perfect for PBTA and FATE system games.

Custom Dice (CustomDice)

User-defined face values instead of sequential numbers. Supports weighted faces (repeated values in the array), negative faces, and all standard modifiers. Create via Inspector or parser: 3d[2,4,6,8].

Groups (Group)

Pool multiple dice types under shared modifiers. {2d6, 1d8}kh2 rolls all three dice and keeps the two highest individual results.

Sequences (Sequence)

Mathematical combinations of rolls: addition, subtraction, multiplication, division, and modulo. Parsed from standard arithmetic expressions like 1d20+5 or (2d6+3)/2.

Unity Editor Integration

Expression Validator Window

Window → Dice Roller Pro → Expression Validator

Type any expression to see the parsed structure, a sample roll value, and all validation issues annotated with severity and fix suggestions. The fastest way to test notation during development.

Roll Preview Panel

Every dice asset shows a Roll Preview block at the bottom of its Inspector. Set an iteration count, hit Roll, and see live min / max / average / last-value readouts plus the full explanation of the last roll. Exceptions surface inline — no editor crashes.

Reorderable Child Editor

Group and Sequence assets render their child rolls as a reorderable list. The + button opens a menu of all concrete BaseRoll types. Removing a child destroys the nested sub-asset cleanly.

Modifiers Drawer

The raw Modifiers struct is replaced by a guided UI: keep/drop collapses to a single kind + value row (Keep Highest / Keep Lowest / Drop Highest / Drop Lowest), and the three explode flavours collapse into a single dropdown (None / Explode / Compound / Penetrating). Mutual exclusivity is enforced automatically.

Validation Framework

DiceValidator provides non-throwing validation for expressions, parameters, and ScriptableObject configurations.

using DiceRollerPro.Validation;

// Validate a user-typed expression before rolling
var result = DiceValidator.ValidateExpression(userInput);
if (!result.IsValid)
{
    foreach (var issue in result.Issues)
        Debug.LogError($"[{issue.Severity}] {issue.Category}: {issue.Message}");
    return;
}

Severity Levels

Validation Categories

Syntax · Parameters · Logic · Performance · Configuration · Convention

Parser Safety Limits

Built-in caps prevent pathological inputs from consuming unbounded CPU or stack space.

Technical Specifications

Purchase the Dice Roller Pro from the Unity Asset Store here >>

Frequently Asked Questions