View on Asset Store (opens in new tab)
Package details
- Latest version
- 2.0
- Last updated
- First released
- Unity version
- 6000.1.1 or later
- Package size
- 611 KB
- Files
- 141
- Favorites
- 10
- Views in the past week
- 18
Price tracking
- Last checked
- Tracked since
- Lowest recorded
- $12.49 on
Keywords
Ultimate Dice Toolkit - Advanced Dice Rolling & Rule API Systems w/JSON support
Ultimate Dice Toolkit — complete RPG dice mechanics for Unity. 10 roll types, dice notation parser, 77 rule combos, editor wizards, JSON import/export, and Monte Carlo probability analysis.
Affiliate link · Purchases support this site
Price history
Last 6 months
USDAsset preview
1 / 24
Ultimate Dice Toolkit - Advanced Dice Rolling & Rule API Systems w/JSON support screenshot 1
About this asset
From Simple Rolls to Full RPG Combat Engines — One Toolkit to Roll Them All.
IMPORTANT: THIS IS NOT A DICE ROLLING ANIMATION FRAMEWORK.
IT IS A FULLY FLEDGED DICE ROLL ENGINE WITH DEEP CUSTOMIZATION OPTIONS.
OVERVIEW
The Ultimate Dice Roll Toolkit is a complete, production-ready dice framework
for Unity. It provides everything from simple random rolls to complex RPG
combat systems, built on a fully documented and customizable API.
With 10 core roll types, 77 conditional rule combinations, and 4 opposed-roll
resolution modes, you can design mechanics ranging from quick skill checks to
full-blown contested encounters — and a built-in dice notation parser
(`DiceAPI.Roll("4d6kh3+2")`) lets you express any of them in a single line.
The toolkit ships with eight professional editor tools — custom inspectors,
three guided wizards, and five live-exploration windows — that integrate
seamlessly with the Unity Editor. They eliminate guesswork, surface real-time
validation, and let you rapidly prototype and balance your systems.
A built-in JSON import/export system (Schema 2.0, with conflict resolution)
makes your dice configurations portable, shareable, and version-control
friendly — perfect for collaborative teams or AI-assisted workflows.
Four playable demo scenes are included so you can see every major feature
running in a real Unity scene before you write a line of your own code.
WHAT'S NEW IN v2.0
- Dice notation parser — type "8d10>=7f1" or "2d6!p" or "4dF+2"
- Four new roll types — Fate / Custom Face / Step Dice / Count Modes
- Penetrating exploding + pool botch / cancel tracking
- Super Advantage (N-die advantage / disadvantage) baked into the core API
- Roll History — runtime ring buffer with one-line production opt-out
- Animation event hooks — DiceEvents.OnRollComplete and friends
- Probability Calculator gains a Compare mode (overlaid distributions)
- Three new editor windows — Notation Roller, Roll History, Seed Explorer
- Demo Hub launcher + four bundled vertical-slice demos
- JSON Schema 2.0 — conflict resolution, light/full/markdown export
- Every known V1 bug fixed across a 29-bug sweep
CUSTOMIZABILITY
Every configuration is fully customizable through both the editor and API.
You can define:
Roll Types
Normal, Advantage, Disadvantage, Exploding, Pool, Drop, Fate, Custom Face,
Step Dice, Count Modes.
Conditional Rules
11 trigger types (OnMax / OnMin / OnValue / OnRange / OnDoubles /
OnTriples / OnSequence / OnSuccess / OnFailure / OnMargin / OnSum) and
7 actions (RollBonus / AddValue / MultiplyResult / Cascade / RerollDie /
SetFlag / ModifyNext) — 77 combinations, priority-ordered, with cascade
limits and tuple-return modifier carry-forward.
Opposed Rolls
Simple, Margin, Contested, or Blackjack resolution — multi-dice per side,
tie-break policies, and full margin-of-victory data.
Probability Analysis
Monte Carlo simulations (1K–100K iterations) with mean / median /
percentile breakdowns and side-by-side Compare mode for tuning.
Sessions
Up to 20 labeled dice per session, session-level modifiers, per-die
enable/disable, full SessionResult with per-die breakdown.
================================================================================
SUITABLE GENRES
================================================================================
The toolkit is designed for:
- RPGs & Tabletop Adaptations — combat rolls, skill challenges, spellcasting
- Strategy & Tactics — opposed rolls, margin-based success
- Roguelikes & Procedural Games — probability-driven mechanics
- Narrative & Symbol-Dice Games — Custom Face dice with cancellation rules
- Card / Board Game Companions — pattern detection via Count Modes
- Any dice-driven system that needs reliability, flexibility, and balance
validation
…and more.
In the end, the ultimate roll is yours — this toolkit gives you every side of
the dice, but what you choose to build with it is entirely up to your
imagination.
From simple chance to complex RPG systems, every possibility is in your hands
to create.
DOCUMENTATION
Offline documentation ships with the package — nine HTML pages covering
Getting Started, the User Guide, full API reference, system architecture,
editor tools, advanced features, code examples, and an About page.
Accessible in-editor under Window → Living Failure → Ultimate Dice Toolkit
→ Documentation.
From the publisher's Asset Store listing.
Technical details
Ultimate Dice Roll Toolkit — Technical Specs (v2.0)
CORE MECHANICS
Roll Types (10):
Normal, Advantage, Disadvantage (with Super Advantage / N-die),
Exploding (with optional Penetrating variant), Pool (with botch /
cancel-on-low tracking), Drop, Fate / Fudge, Custom Face (symbol dice
with cancellation rules), Step Dice (d4 → d6 → d8 → d10 → d12 ladder
+ optional companion die), Count Modes (Pairs / Triples / FourOfAKind
/ FullHouse / Straight / Evens / Odds / ValueMatches).
Opposed Rolls (4 modes):
Simple, Margin, Contested, Blackjack — multi-dice per side, tie-break
policies, full margin-of-victory data.
Conditional Rule System (77 combinations):
11 triggers (OnMax / OnMin / OnValue / OnRange / OnDoubles / OnTriples
/ OnSequence / OnSuccess / OnFailure / OnMargin / OnSum) × 7 actions
(RollBonus / AddValue / MultiplyResult / Cascade / RerollDie / SetFlag
/ ModifyNext) with priority ordering, chaining, recursion limits, and
tuple-return modifier carry-forward.
Dice Notation Parser:
DiceAPI.Roll("4d6kh3+2") works out of the box. Supports modifiers,
keep/drop, exploding (!) with penetrating (!p), pool comparisons
(>=, >, <=, <, =) with botch-on-fail (fN), Fudge dice (NdF), and
roll-and-keep (NkM).
EDITOR TOOLS (12 SURFACES)
4 Custom Inspectors:
DiceConfiguration, ConditionalRule, DiceSession, OpposedRollConfig —
inline test rolls, real-time validation, quick-preset libraries,
collapsible foldout groups, ENABLED badges.
3 Guided Wizards:
Session Creation Wizard (7 templates), Probability Calculator (with
Compare mode), Import / Export Wizard (three-tab: Templates / Export
/ Import).
5 V2 Editor Windows:
Demo Hub, Notation Roller, Roll History, Seed Explorer, Probability
Compare mode (tab in ProbabilityCalculatorWizard).
All accessible under Window → Living Failure → Ultimate Dice Toolkit.
SYSTEMS
Probability Engine:
Monte Carlo simulations (1K–100K iterations). Mean / median / percentile
breakdowns, range and threshold queries, full distribution data on
demand for histogram rendering. Compare mode runs 2–4 configs
side-by-side with overlaid distributions.
Roll History (V2):
In-memory ring buffer (default capacity 100, max 10K). Filter / replay
/ export to JSON. RollHistory.Enabled = false disables recording for
shipping builds. Animation events fire regardless.
Animation Event Hooks (V2):
DiceEvents.OnRollComplete / OnSessionComplete / OnOpposedComplete fire
UnityEvents from the public API surface. Drag-and-drop listener wiring
via [Serializable] event wrappers.
JSON System (Schema 2.0):
Import / export with validation, metadata, AI-ready templates, and
conflict resolution (Suffix / Skip / Cancel). Light, full, and
markdown export modes. Per-asset inspector buttons + three-tab wizard.
Deterministic Seeds:
InitializeSeed / DisableSeed / IsSeedActive on the public API.
Save-state aware via RandomProvider.SaveState / RestoreState — seeded
runs don't pollute live RNG. Seed Explorer window for debug workflows.
API & ARCHITECTURE
Public API: 50+ documented methods on the static DiceAPI class for
scripting, runtime integration, and custom workflows.
Architecture: Four-layer design (API facade → Engines → Data → Core)
spread across 75+ C# scripts. Five processing engines: DiceRollEngine,
RuleEngine, SessionEngine, OpposedEngine, ProbabilityEngine. Strategy
pattern for roll types, command pattern for conditional rules.
Performance: Sub-millisecond for simple rolls, zero allocations on hot
paths, optimized session handling (up to 20 labeled dice per session),
optional retainDistribution flag keeps Monte Carlo allocation-free
unless histogram data is requested.
Unity Integration: Inspector-driven workflow, ScriptableObject assets,
asset path management, real-time previews, undo/redo support, and
comprehensive validation.
Scalable & Flexible: Use as a quick dice roller, or integrate deeply
into combat systems, skill checks, narrative branching, or procedural
mechanics. The toolkit provides endless possibilities and probabilities
— all technically possible.
INCLUDED CONTENT
4 Playable Demo Scenes:
Combat Encounter, Character Generator, Narrative Skill Check, Pattern
Dice Mini-Game — each a complete, reviewable usage of the API.
9 HTML Documentation Pages:
Overview, Getting Started, User Guide, API Reference, System
Architecture, Editor Tools, Advanced Features, Code Examples, About.
AI-Ready JSON Templates:
Master, Dice, Conditional Rule, Opposed, Session, and Light variants
for AI-assisted workflows and configuration sharing.
HOW TO USE IT
All core functionality is accessible through the static DiceAPI class.
Use it as you please — every feature is opt-in.
Quick start:
1. Test the included demo scenes via the Demo Hub window
(Window → Living Failure → Ultimate Dice Toolkit → Demo Hub).
2. Try the editor wizards (Session Creation, Probability Calculator,
Import / Export) under the same submenu.
3. Review the comprehensive offline documentation under
Window → Living Failure → Ultimate Dice Toolkit → Documentation.
4. Create your own ScriptableObjects from the Ultimate Dice Toolkit
submenu in the Project view (right-click → Create →
Ultimate Dice Toolkit).
COMPATIBILITY
- Unity 6000+
- No third-party dependencies
- All V1 integrations continue to work — v2.0 introduces three
intentional semantic changes (see PatchNotes_v2.0.txt → DESIGN-CALL
CHANGES) that may affect existing rule-based code.
Compatibility
| Unity version | Built-in | URP | HDRP | Custom |
|---|---|---|---|---|
| 6000.3.8f1 | Compatible | Compatible | Compatible | Compatible |
| 6000.1.1f1 | Compatible | Compatible | Compatible | Compatible |
v 2.0
As listed on the Asset Store.