Tavla Royale

Backgammon is played by hundreds of millions of people who call it different names and play it by different house rules. Every major app today serves exactly one of those audiences — or serves all of them badly with aggressive ads and dice nobody trusts. Tavla Royale serves them all, properly.

Elevator pitch

A beautifully crafted board — walnut, brass and cream — that opens in two seconds, plays offline anywhere, and knows your rules: the doubling cube for London, no cube for Istanbul, Plakoto for Athens, Long Nardi for Yerevan. Dice are cryptographically fair and the game proves it. Ads never interrupt a match.

"Global" for backgammon doesn't mean one audience — it means a federation of regional audiences, each reachable with its own store listing, name and rule set.

Audience segments

Launch ships six variants against AI, all driven by one rules engine with variant descriptors. Online PvP, tournaments and friend tables arrive in Phase 2.

Mode wrapper features (all variants)

• Quick Match — one tap from home, resumes last variant + stakes; the "tea break" loop.
• Match Play — first to 1 / 3 / 5 / 7 / 11 points, Crawford handled automatically in classic.
• Pass & Play — local 2-player on one device; free, no coins, no ads mid-match (living-room mode).
• Daily Gauntlet — one curated AI ladder per day (3 opponents, rising difficulty, coin jackpot). The retention anchor.
• Tutorial & Rules Codex — interactive first-match tutorial per variant + illustrated rules reference with regional terminology.

The engine is a pure C# library (no UnityEngine references) — deterministic, unit-testable, and reusable verbatim inside a Nakama match handler in Phase 2.

Board model

• State struct: int[26] points (signed: +n = n white checkers, −n = black; [0] and [25] = bars), int[2] borneOff, CubeState, turn, dice[2], movesRemaining.
• Immutable transitions: Apply(state, Move) → state'. Enables undo, AI search, replay, and server verification with zero extra code.
• Zobrist-style hash per state for AI transposition table and desync checks later.

Legal move generation (the hard 20%)

• Doubles expand to four moves; non-doubles generate both orders (die A→B and B→A) since they can produce different legal sets.
• Maximum-dice rule: if any sequence plays both dice, sequences playing only one are illegal; if only one die can play, it must be the higher when both are individually playable but not together.
• Bar priority: with checkers on the bar, only bar re-entry moves generate; blocked re-entry on both dice = forfeited turn (auto-pass with clear UI messaging).
• Bearing off: legal only with all checkers home; exact rolls bear off; higher rolls bear off the rearmost checker only if no checker sits on a higher point.
• Variant hooks: hit → send to bar (classic/Tavla/Portes); pin → trap opponent checker under yours (Plakoto/Mahbusa); block → single checker owns the point (Fevga); Long Nardi adds the head rule (one checker off the head per turn, doubles exception on first roll) and the six-prime restriction (may not build a 6-prime unless an opponent checker is ahead of it).

Doubling cube state machine (classic only)

Scoring

Classic: single ×1, gammon ×2 (opponent bore off none), backgammon ×3 (none borne off + checker on bar/opponent home), all × cube value; Jacoby rule optional in money games. Tavla: win 1, Mars 2 (opponent bore off none). Plakoto: pinning the opponent's mother checker (their last checker on their start point) scores a double win immediately. Long Nardi: Oyn 1 / Mars 2, optional Koks 3. All values live in the variant descriptor.

Fair dice — the trust system

• RNG: cryptographic RNG (System.Security.Cryptography) with rejection sampling — never Random.Range % 6.
• Commit-reveal: at match start the app commits SHA-256(seed‖salt); the full roll sequence derives from the seed; match end reveals seed + salt so anyone can verify rolls were fixed before the first move. Surfaced as a "Dice Fairness ✓ Verified" stamp on the result screen with an expandable ledger.
• Stats panel: personal roll-distribution histogram vs expected — transparency converts skeptics, and skeptics write reviews.
• Phase 2: identical scheme runs server-side in Nakama; the client verifier code doesn't change.

Launch AI is a tuned heuristic evaluator — cheap, instant on low-end devices, and adjustable to four believable difficulty tiers. A neural evaluator is a v1.2 upgrade, not a launch dependency.

Evaluation function (weighted linear)

Search & difficulty tiers

Blunder review (the improver hook)

Post-match, replay any move; the evaluator marks moves losing >0.08 equity as blunders and shows the better play with a one-line reason ("leaves 2 blots under direct shots"). Three free reviews daily; unlimited via Royale Pass. This is the feature the hobbyist segment pays for and reviews well.

Portrait-first is a deliberate bet: the heritage and commuter segments play one-handed. The board rotates 90° — points run horizontally from the left and right rails, the bar becomes a horizontal beam. Landscape remains supported on tablets.

Screen mockups

Interaction design

• Move input: tap checker → legal destinations glow (dashed brass ring + tinted point); tap destination to move. Drag & drop also supported. Auto-play forced moves after 600 ms with a subtle toast.
• Confirm model: moves stage locally; Undo reverts within the turn, Confirm commits. Optional "fast mode" auto-confirms in settings.
• Dice: physical 3D-feel roll rendered as a 2D sprite flipbook + haptic tick on land; result always mirrored as large flat pips on the bar for readability (accessibility: never rely on the animation).
• Pip counts always visible — heritage players count pips; hiding them reads as amateur.
• One-hand reach: all interactive chrome lives in the bottom 40% or on the bar; the top HUD is display-only.
• Feedback: hits get a short shake + wood "clack"; bear-off gets an ascending chime; Mars/Gammon gets the full banner. Haptics via light impact only — this is a calm game.
• Accessibility: color-blind safe point palette toggle (rust/slate chosen to differ in luminance), checker patterns option, min touch target 48 dp, full RTL mirroring for Arabic UI.

Screen flow

Splash → Home ─┬→ Quick Match → Match → Result ─┬→ Rematch ↺
                 ├→ Variant Select → Stake Select → Match    └→ Blunder Review → Home
                 ├→ Daily Gauntlet (3-match ladder)
                 ├→ Bazaar · Codex · Profile/Settings
                 └→ Pass & Play

The fantasy is a beautiful physical board in a warm, dim tea house — wood, brass and felt, not neon and confetti. Deliberately distinct from Baloot's navy/gold so the studio portfolio reads as two brands.

Palette

Type & iconography

• Display: Marcellus (Latin) — engraved, classical, reads "heirloom"; pair with GE Dinar One / Noto Naskh for Arabic display, Noto Sans for fallback coverage.
• UI body: Karla — warm humanist sans, excellent at small sizes; numerals tabular for pip counts and coins.
• Icons: thin brass line icons with rounded terminals; no glossy casino chrome anywhere.

Cosmetic content matrix (shop inventory)

All board/checker/dice sets ship through the same equippable-cosmetic pipeline as Baloot's inventory system — atlas per theme, addressable bundles, one ThemeDef ScriptableObject each.

Dual currency, stake-loop coins, and ads that never touch the board. The economy borrows Baloot's proven structure and softens the social-casino edges the genre is hated for.

Currencies

IAP catalog

Ad placements (AdMob, Next Gen SDK)

Session design targets

• Core loop (3–5 min): open → quick match → result (+coins, +XP) → one more.
• Daily loop (10–12 min): streak claim → gauntlet → missions check → maybe a bazaar look.
• Weekly loop: weekly mission, new featured board rotation, achievement pushes.

Project structure

Testing the rules engine

• Golden tests: encode published positions per variant (bear-off edge cases, forced-max-die traps, Crawford sequences, Long Nardi head-rule doubles) as fixtures.
• Fuzz: million-game random self-play per variant asserting invariants (checker count = 15, no negative points, game always terminates).
• AI regression: tier N must beat tier N−1 ≥ 65% over 2,000 games in CI.

Solo-dev calibrated: ~15 weeks to global v1.0. M1 is deliberately front-loaded — every later system stands on a provably correct engine.

Top risks