Skip to content

🎓 RevFramework — Teaching Overview

The Teaching section contains the Teachable Panels and scene overlays that walk you through each system step-by-step inside Unity.

Note (SKUs): This package includes Teaching panels only for the systems you own.
For example, the Currency & Economy SKU ships only Currency/Economy teaching content.
The Complete package includes Teaching panels for every system.

These are not shipping UI — they’re: - Lightweight IMGUI panels - Focused on learning, debugging, and copying patterns - Safe to drop into any demo or sandbox scene

If you want to understand how a system actually behaves at runtime, this is where you start.

🧭 Table of Contents

📘 What Are Teachable Panels?

Teachable Panels are small, focused editor/runtime helpers that:

  • Expose the exact services and calls used by each system
  • Show live results (OpResults, reasons, state changes, balances, stacks…)
  • Provide toggleable options for edge cases (caps, authority, routing, cooldowns…)
  • Mirror the same concepts you’ll see in the docs and sample scenes

They’re designed so you can:

“Press a button, see what happens, then copy the pattern into real UI.”

🛠 How to Use This Section

For each system:

  1. Open the matching Teaching scene (if provided).
  2. Find the Teachable Panel under the Teaching menu or in the inspector.
  3. Follow the panel’s inline steps:
  4. Read the Goals / What this teaches
  5. Toggle options
  6. Press buttons
  7. Watch the live output change in the panel and scene
  8. When something makes sense, copy the pattern:
  9. Service calls
  10. Result handling
  11. Events
  12. Authority checks
  13. UI updates

You can freely experiment — the panels operate on live runtime state and will not modify project assets or persist changes unless you explicitly do so.

Note: Teaching scenes include pre-configured panels and bindings for clarity. If you copy panels into your own scenes (or delete and recreate sample scenes), you may need to rebind and resize them to suit your layout.

The visual setup (panel width, font sizes, background opacity, etc.) reflects my own testing preferences and may not suit everyone. If you need larger text, higher contrast, or different opacity, adjust the Inspector settings as needed — nothing is locked.

Accessibility matters. If you have a specific accessibility requirement that isn’t covered by the current options, you can reach out to discuss it. Any adjustments are considered case-by-case and focus on improvements that make sense at the panel base level.

🧩 Available Teaching Areas

RevFramework provides Teaching panels per system. In SKU packages, you’ll only see the systems included in your purchase:

  • Inventory — items, stacks, slots, restrictions, search, sort, snapshots
  • Pickups — definitions, effects, decorators, cooldowns, world pickups
  • Crafting — recipes, validators, modifiers, routing, offline progress
  • Health — damage/heal rules, shields, regen, IFrames, combat state
  • Status Effects — DOT/HOT, cleanses, immunity, auras, potency, snapshots
  • Currency — balances, caps, batch operations, awaiters, inventory-backed
  • Economy — offers, pricing, adapters, transactions, diagnostics

See the left-hand nav under Teaching for the full breakdown.

If you’re new to RevFramework, a solid path is:

  1. Teaching → Inventory — core mental model: containers, slots, items.
  2. Teaching → Currency — balances, caps, transactions, preview vs apply.
  3. Teaching → Crafting — jobs, validators, modifiers, offline progress.
  4. Teaching → Health / Status Effects — combat flows and runtime effects.

Each section is built to stand alone — you don’t need to learn everything up front.

🛡 Safety & Runtime Impact

Teachable Panels are:

  • Editor-only or sample-only where possible
  • Clearly marked as teaching/demo tools
  • Safe to delete from your project once you understand the patterns

They do not add hidden singletons or global state.
If you remove the teaching folder, the core runtime systems remain unaffected.

📦 Copying Patterns into Your Own UI

RevFramework deliberately separates:

  • Runtime services & results (the real API)
  • Teaching panels (examples and overlays)
  • Sample UI (reference implementation)

When you want to build production UI:

  1. Look at the Teaching panel for the behaviour you want
  2. Copy the service calls and result handling into your own UI code
  3. Ignore the IMGUI/layout code — that’s just scaffolding

You should never feel “locked into” the teaching UI.
It’s a playground and reference, not a requirement.