Skip to content

Currency & Economy — Teachable Panels

Interactive Editor Tools for Real API Learning

They function as living documentation, debuggers, onboarding tools, and integration tests

Teachable Panels let you drive the real runtime Currency & Economy API inside the Unity Editor — without UI, without setup, without guesswork.

Important — Read This First

Teachable Panels are development and learning tools.

They are not shipping UI

If a Teachable Panel component is present on a GameObject in a shipped scene, it will be visible and interactive at runtime — and the Currency panels drive real credit, debit and set-balance calls.

Shipping with Teachable Panels attached is a developer error, not a framework bug.

Before building your game:

  • Remove Teaching panels from scenes, or
  • Ensure REV_TEACHABLES is not enabled

Purpose

Complex financial systems need clear, visual, low-friction learning tools.

No mocks. No simulations. Just real code, running live.

Instead of reading long docs or guessing behaviour, teachables let you:

  • run real operations
  • inspect balances, deltas, and rollbacks
  • validate preflight behaviour
  • test policy caps, escrow, idempotency
  • simulate shop/craft/reward flows
  • understand sourceId + RID propagation
  • interactively explore how the economy behaves

What Makes These Panels Special

Real API Calls

Every button calls the actual runtime systems:

  • Currency credit/debit/set/transfer
  • Escrow holds, commits, releases
  • Policy cap evaluations
  • Idempotent operations (RID)
  • Exchange quotes + execution
  • Batch transactions
  • Craft/Buy/Sell/Reward (with rollback)
  • Persistence & audit
  • Async awaiters

Nothing is faked — this is production code in action.

Human-Readable Feedback

Clear, friendly messages:

  • "OK — debited 50 gold"
  • "Blocked — insufficient funds"
  • "Escrow hold expired"
  • "SetBalance clamped by policy"
  • "Craft rolled back — ingredients refunded"
  • "Buy rolled back — payout failed"

You learn the system like a human, not a debugger.

Zero UI Required

Panels let you validate:

  • currency flows
  • policy rules
  • item-store behaviour
  • crafting costs
  • shop purchase/sale flows
  • rollback correctness
  • exchange rates and fees
  • idempotent retries
  • persistence (save/load by StableId)

…before building UI.

Drop Into Any Scene

No setup required:

  • uses your actual SceneCurrencyService
  • optional inventory service
  • optional policy
  • optional bootstrap decorators
  • works with your prefabs and your data

Instant integration testing.

Included Panels

Currency Panels

  • Basics — credit/debit/set
  • Policy Caps — clamp/fail preview
  • Escrow — hold/commit/release + TTL
  • Idempotency — RID replay demo
  • Exchange — quote + execute
  • Awaiters — async/coroutines
  • Batch Events & Txn — atomic staging
  • UI Bars + Nudger
  • Persistence + Audit

Economy Panels

  • Economy Quickstart (currency-only: Buy/Craft/Reward)
  • Economy + Inventory (Buy/Sell/Craft/Reward with rollback visualiser)

These show the preflight → execution → rollback cycle cleanly.

Benefits for Your Team

  • Faster onboarding
  • Clear mental model of money flows
  • Less debugging time
  • Safer integration
  • Confident rollback and policy behaviour
  • No UI dependency
  • Perfect for onboarding juniors

Teachable Panels are one of the defining features of RevFramework.

How To Use

  1. Open a scene from Samples/Systems/Currency/Scenes/ or Samples/Systems/Economy/Scenes/
  2. Press Play — the panel is already in the scene and its overlay draws itself
  3. Trigger real operations
  4. Observe behaviour, deltas, and rollbacks
  5. Integrate the same calls into your gameplay code

There is no menu to open a panel from

Panels are scene components, not editor windows. To retune one, select its GameObject in the Hierarchy; to use one in a scene of your own, add the panel component to a GameObject alongside the required scene services.

Summary

Teachable Panels turn Currency & Economy into a transparent, understandable, debuggable system.

They give you:

  • Real API behaviour
  • Policy-aware previews
  • Safe rollback demos
  • Human-readable messages
  • Live financial introspection
  • Zero-UI testing

They’re not demos

They’re development tools — and one of the biggest reasons RevFramework is developer-first.