💰 Teachable Panels¶

Interactive Editor Tools for Learning the Real Currency API¶

Teachable Panels are a core feature of RevFramework.

They let you drive the real runtime Currency APIs directly inside the Unity Editor —
without writing UI, without wiring events, and without relying on mock logic.

They are: - Not mockups
- Not simulations
- Not sample-only logic

They are the actual currency runtime systems running live in your scene.

⚠️ 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.

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

🎯 Why Currency Teachable Panels Exist¶

Currency systems are deceptively complex.

Caps, policies, escrow, idempotency, batching, persistence, and rollback are hard to reason about by reading code alone.

Instead of: - guessing why a debit failed
- mis‑ordering decorators
- debugging UI instead of logic
- scattering test code across scenes

You can open a panel and watch the real currency system respond to real transactions.

Currency Teachable Panels are ideal for:

onboarding new developers
validating economic rules before UI exists
debugging transactions and edge cases
teaching result‑first reasoning
verifying rollback‑safe behaviour
confirming decorator stacks behave correctly

They act as living documentation for the Currency system.

🔍 What Makes These Panels Different¶

✔ Real Currency API Calls¶

Every action triggers the same runtime methods your game code will use:

Credit / Debit / Set
Clamp vs Fail policies
Batch transactions
Escrow holds / commits / releases
Idempotent requests
Exchange rates and fees
Persistence save / load
Awaiters and predicates

No mock paths.
No shortcuts.

✔ Human‑Readable Feedback¶

Operations surface clear, toast‑style messages:

“Credited 100 Gold”
“Debit failed — cap exceeded”
“Escrow committed successfully”
“Duplicate request ignored (idempotent)”

You learn why something happened, not just that it happened.

✔ No UI Required¶

You can test:

wallet behaviour
caps and policies
exchange logic
escrow flows
atomic batch operations
persistence and rollback
async awaiters

…before writing any production UI.

This avoids debugging UI and economic logic at the same time.

✔ Works in Any Scene¶

Currency Teachable Panels work with:

your scenes
your service instances
your economy bootstrap
your inventory adapters

They bind at runtime and degrade gracefully if something is missing.

✔ Matches Docs and Videos Exactly¶

Currency Teachable Panels mirror:

folder‑level READMEs
MkDocs documentation
tutorial videos

Same names.
Same concepts.
Same flows.

🧩 Panels Included in This SKU¶

💰 Currency¶

Credit / Debit / Set
Wallet events
Caps and policies
Exchange tables
Escrow flows
Idempotency
Batch transactions
Awaiters and predicates
Persistence and audit trails

Each panel maps directly to a public Currency API surface.

🧠 Benefits for Your Team¶

Faster onboarding
Fewer support questions
Safer prototyping
Clearer mental models
Deterministic debugging
Confidence economic rules work before UI exists

Currency Teachable Panels drastically reduce integration mistakes.

🚀 How to Use¶

Add or bootstrap an ICurrencyService
Open a panel from the RevFramework menu
Drive the system live
Observe results, policies, and rollback behaviour
Copy the same calls into your gameplay or shop UI

No special setup required.

🏁 Summary¶

Currency Teachable Panels are a defining feature of the Currency SKU.

They give you: - real economic behaviour
- instant, readable feedback
- safe experimentation
- clear insight into complex flows

They are not demos.
They are not toys.

They are the fastest, safest way to understand and integrate
RevFramework’s Currency system into your project.