Dice & Rolls

Rolling is the one mechanic every product in the family shares, and it works the same way in two senses everywhere it happens: it's streamlined (you almost never type a raw formula — the system knows your modifiers and the target's defenses) and it's audited (the number you see is the number that was computed and logged on the server, not in your browser). This page covers both surfaces — the DND.chat tavern and the DNDWar board — and exactly how a roll is built, resolved, and recorded.

What "audited" means

Dice are never rolled in your browser and trusted. Every roll is computed server-side and written to a roll_events row with the formula, the total, and a full per-die breakdown — each face, the modifier, advantage handling, and natural-20 / natural-1 flags. The chat message (or combat-log line) and the audit row share one rollEventId, and the server re-reads that event when the message is posted to confirm it belongs to this table and player. A client can't fabricate a result and submit it as real.

One honest clarification the docs make everywhere: the randomness is ordinary Math.random(). "Audited" means fully logged and reproducible in the record — not a cryptographic commit-reveal scheme. What it buys you is a campaign-scoped, tamper-resistant history: a dice tray in the tavern sidebar shows recent rolls and lets you re-roll a past formula with one click, and a campaign's whole roll log is queryable.

What "streamlined" means

You rarely type 1d20+5. The system fills the formula from context:

• Your character's modifiers. Add a skill or save to a roll and it reads your active character sheet — ability score, proficiency bonus, and whether you're proficient — and substitutes the right modifier.
• The target's defenses. An attack reads the target card's AC server-side; you never have to know it, and players never see it.
• The weapon. An attack finds your equipped weapon's to-hit and damage automatically.
• The consequences. A hit auto-rolls damage; a crit doubles the dice; damage syncs to the target's HP.

The rest of this page is the detail behind each of those.

Rolling in the DND.chat tavern

/roll — the base case

Type a standard formula in any channel; it resolves the moment you send and posts as a dice message.

/roll 1d20+5
/r 2d6+3

Two layers stack on top of a plain formula:

• Advantage / disadvantage — prefix a lone 1d20 with adv or disadv to roll twice and keep the higher or lower. It applies only to a single 1d20 and is ignored on any other formula.

  /r adv 1d20
  /r disadv 1d20

• Character-bound skill — add a trailing skill name and the roll picks up your active character's modifier for it, read straight from your sheet.

  /r 1d20 athletics

  Recognized skills span the usual 5e set — athletics, acrobatics, stealth, perception, investigation, insight, persuasion, deception, intimidation, arcana, survival, and the rest. Saving throws resolve the same way against your proficient saves.

If the engine can't parse a formula it doesn't fail silently — it falls back to a single 1d20 with a warning (Unsupported formula; rolled 1d20 fallback.), and that fallback is audited like any other roll. Safety caps bound the dice per group, total dice, sides, and modifier range so a runaway formula can't take down the table.

A dice message reads like this:

🎲 1d20+5 → 15
🎲 Kira · athletics +3 → 18 (1d20+3)
💥 Damage → 8 (2d6+2)

There's also a quick-roll menu in the composer (die icons, a modifier stepper, a pool accumulator, and one-tap advantage/disadvantage) for when you'd rather click than type — it runs through the exact same audited path.

Attacks in chat

/attack resolves a hit against a named target's AC, end to end:

/attack goblin longsword

The server reads the target's AC from its full stats (never shown to players), rolls the attack, and reports hit, miss, or crit. On a hit it auto-rolls damage as a follow-up message and syncs that damage to the target's HP. A crit doubles the damage dice, not the flat modifier. The attack and the damage are each their own audited entry.

You usually won't type /attack at all. When you write an attack in plain language — "I swing at the goblin with my longsword" — an attack prompt appears above the composer offering the resolved roll (longsword vs goblin · Roll 1d20+5 · +5 to hit). Confirm it and the attack fires; the system deduced the formula from what you wrote. This is deterministic intent-parsing, not AI — see the AI Features library. It's also the heart of the end-of-turn flow.

Skill checks the Autopilot calls for

When the Autopilot DM wants a check, it posts the ask in the narration:

🎯 STR (Athletics) check — DC 15. Roll with the dice menu or /roll 1d20+mod.

You roll it yourself (so the modifier is yours and the result is audited), and the DM reads your result on its next turn to narrate the outcome against the DC. The AI sets the stakes; your dice decide them.

Rolling on the DNDWar board

The board doesn't use a chat composer — it uses click-to-attack. The streamlining is even tighter here because every token already carries its derived actions.

Actions are derived for you

When a token is invoked onto the board, its rollable actions are built automatically (see the DNDWar product page):

• Monster and NPC actions are parsed from the stat block (e.g. +4 to hit … Hit: 5 (1d6 + 2) slashing), with save-effect actions parsed too.
• Player characters get a weapon attack from the better of their STR/DEX modifier plus proficiency.
• Every token also gets Custom attack, Request save, Ability check, and the movement utilities Move / Dash / Dodge / Disengage.

If a stat block won't parse, a sensible weapon fallback is equipped so the token is never un-actionable.

The resolution flow

1. Arm an action by clicking its chip in the action bar. The bar reads "Armed: Longsword — click an enemy token to target."

2. Click the target on the map. A ResolutionPanel opens above the board showing the attacker → target, the roll mode (advantage/disadvantage carried over from conditions), and any rider like a Shield reaction.

3. Roll. A single button rolls the d20. Attacks compare d20 + to-hit vs AC; a natural 20 is a crit (the damage dice double), a natural 1 misses. It produces a readable line:

   Brunhild → Goblin Archer · Longsword · +5 vs AC 15 · rolled 14 (19) → HIT · 6 slashing · 7→1

4. The result writes through to the target's HP and the combat log, plays SFX and a hit/projectile effect, and checks concentration if the target was concentrating.

Every field — to-hit, AC, damage formula, damage type, DC — sits behind a Show math toggle that exposes them as editable inputs, all pre-filled from the derived data. Anywhere the engine rolls, the DM can override the value before committing. The streamlining is a default, not a cage.

Saves and ability checks

The same panel handles saves and checks. Arm Request save or Ability check, click the target, and roll their d20 + the relevant bonus vs the DC. Saves support half-on-success, and forced auto-fails are handled (a paralyzed creature auto-fails DEX saves). Advantage and disadvantage are derived from the target's active conditions, not entered by hand.

Crits, concentration, and bookkeeping

The board tracks the fiddly 5e math so you don't:

• Crits double the damage dice (1d8+3 → 2d8+3), never the flat bonus.
• Concentration triggers a CON save at DC max(10, damage/2) whenever a concentrating creature takes damage.
• Conditions drive advantage/disadvantage and auto-fail saves with durations that tick down.
• Reactions include opportunity attacks detected along a token's actual routed path, plus the Shield reaction (+5 AC).
• Death saves run for a PC at 0 HP with the standard nat-1 / nat-20 rules.

Let the engine roll the monsters

On a monster turn the DM can hand the dice to the engine entirely with Auto-resolve — it targets, paths, attacks, rolls, and logs through this same audited path. The planner that picks the move is deterministic, not AI; details in Running a Battle on the VTT and the AI Features library.

One shared library, one shared log

Because all three apps read the same shared spine, a character's modifiers are the same whether they roll in chat or on the board, and a creature's AC is the same card stat in both places. The dice you roll in the tavern and the dice the board resolves are written to the same kind of audited record — so a roll is a roll, wherever the party happens to be sitting.

Where to go next

• Slash Command Reference — /roll, /attack, and the rest, with exact syntax.
• DND.chat — Auditable dice — the tavern's audit log in product context.
• DNDWar — Assisted combat — the board's combat engine in product context.
• The AI Features Library — where the AI is, and where it deliberately isn't.