RevFramework — Inventory, Pickups & Crafting¶

Teachable Panels¶

Teachable Panels turn the Inventory, Pickups and Crafting systems into living documentation you interact with directly inside the Unity Editor.

They let you drive the real runtime APIs — SceneInventoryService, the pickup effect apply path, and CraftingService — without writing UI, wiring events, or building custom debug scenes.

Important — Read This First¶

Teachable Panels are development and learning tools.

Why These Panels Exist¶

Item systems fail in quiet ways.

A craft that is valid as a recipe still fails because a container has no space. An equip silently does nothing because a slot filter rejected the item. A pickup applies twice. None of that is obvious from reading logs.

Teachable Panels provide:

• A safe, visual, real-time debugger
• A fast way to learn the API by doing
• Clear result-first reasoning (why an operation was refused, not just that it was)
• A way to validate behaviour before writing gameplay UI
• A powerful onboarding tool for teams

Open the scene → press Play → press buttons → watch the system respond instantly.

Inventory Panels Included¶

Quickstart — Minimal Inventory¶

Samples/Systems/Inventory/Scenes/00_Quickstart_Minimal

The first-time path through the service seam:

• Real flow: UI input → SceneInventoryService → result-first feedback
• Honest read/write operations through the public service seam
• Copy-pasteable Give, Peek, Remove and Clear patterns
• Adapter-based and dependency-safe throughout

Items & Stacks¶

Samples/Systems/Inventory/Scenes/01_Items_And_Stacks

Practical stack interactions, the ones drag-and-drop UI actually needs:

• Select a slot, then click another to merge-then-swap
• Split with an explicit amount and target
• Quick-split into auto-placement via right-click
• Mutation always routed through the service, never direct container edits

Slots & Restrictions¶

Samples/Systems/Inventory/Scenes/02_Slots_And_Restrictions

The backpack-to-equipment flow, made explicit:

• Strict per-slot filter checks
• Quantity of exactly 1 on equipment slots
• Acceptance tested with pure read checks first, so nothing changes while you probe
• Equip / unequip semantics you can copy directly

Search & Sort¶

Samples/Systems/Inventory/Scenes/03_Search_And_Sort

Discovery tools driven through the service rather than reimplemented client-side:

• Stable, empty-last sorting via InventorySortSpec
• Text search through the service seam
• Seed / Sort / Search sections that stand alone and lift out cleanly

Snapshots — Save & Load¶

Samples/Systems/Inventory/Scenes/04_Snapshots

A real persistence loop for inventory and optional equipment:

• Input → JSON capture → file write/read → apply
• Missing-item policy made explicit, with no silent magic
• Separate Seed, Options, Save/Load and File Tools sections

Pickups Panels Included¶

Quickstart — Pickups¶

Samples/Systems/Pickups/Scenes/00_Quickstart_Pickups

The apply path end to end:

• Inspect live bindings and run preflight before applying
• Compare the standard dispatch path against the context dispatch path
• See how a null target is handled, and when apply is blocked outright

Decorators & Apply Path¶

Samples/Systems/Pickups/Scenes/01_Decorators_+_Cooldowns

• Shows the live decorator chain for an effect
• Applies that effect through the supported runtime path, not a shortcut
• Makes cooldown behaviour visible as part of the chain

World Pickups & Interactables¶

Integrations/Pickups/InventoryIntegration/Scenes/02_World_Pickups_+_Interactables
Cross-system scene — requires Inventory.

• Real world pickups through TriggerPickup
• Runtime selectors and scene trigger consumption
• Selector UI works in builds: no UnityEditor API anywhere in the panel

Crafting Panels Included¶

Quickstart — Crafting¶

Samples/Systems/Crafting/Scenes/00_Crafting_Quickstart

Organised around the first-time learning path:

1. Overview — what is wired, resolved and discovered
2. Seed — create valid input state through supported adapters
3. Preflight — why a craft can or cannot run before a job exists
4. Jobs — live jobs, progress, pause / resume / cancel

This panel deliberately behaves as a hostile consumer: it only touches the public API surface.

Workbench Basics (2D or 3D)¶

Samples/Systems/Crafting/Scenes/01_Workbench_Basics_2D_or_3D

Bench-driven crafting as three separate decision layers:

1. Bench gate — can this bench attempt this recipe here?
2. Service gate — can CraftingService actually run it now?
3. Runtime state — did a job get created, progress, complete, or fail?

That separation is the point: being near a bench does not mean the craft is valid. Works with either CraftingWorkbench2D or CraftingWorkbench3D.

Routing, Space & Currency¶

Samples/Systems/Crafting/Scenes/02_Routing_Space_Currency

Three reasons a craft can be a valid recipe and still fail in practice:

1. Routing — where do outputs try to go?
2. Space — can those containers actually accept the outputs?
3. Currency — can the owner afford the cost right now?

Note: this panel uses TeachingOutputRouter, a teachables-only helper, to make the routing seam visible. The router preview is educational, not a production recommendation.

Validators & Modifiers¶

Samples/Systems/Crafting/Scenes/03_Validators_And_Modifiers

The validator/modifier seams as a loop:

1. Discover — validators and modifiers found on the owner or parent chain
2. Toggle — enable/disable MonoBehaviour seams without touching internals
3. Diagnose — re-run preflight and Probe for the live context
4. Act — enqueue and surface the real rejection or failure reason

Offline Progress & Persistence¶

Samples/Systems/Crafting/Scenes/04_Offline_Progress_Persistence

Offline progress as four separate steps:

1. Inspect live jobs queued or running for this owner
2. Save snapshots through CraftingService public APIs
3. Age the snapshot by shifting acceptedAtUtc backward to simulate time away
4. Restore through the API and let the service decide resume, completion or failure

The mental model matters here: offline progress is not a magic save system.

Real Adapters with Inventory & Currency¶

Integrations/Crafting/InventoryIntegration/Scenes/05_Adapters_InventoryCurrency
Cross-system scene — requires Inventory and Currency.

The final integration loop, with no fake adapters:

1. Bind real adapters — inventory and currency adapters assigned on CraftingService
2. Mutate real state — add/remove items and credit currency through those adapters
3. Diagnose — CanCraftDetailed and Probe against live adapter state
4. Enqueue real jobs — the service consumes, credits and refunds through real integrations
5. Observe — progress, cancellation and failure straight from the service

Why These Teachables Matter¶

They dramatically reduce:

• Onboarding time
• Guesswork and trial/error
• UI-driven debugging
• Integration mistakes
• Support questions

And dramatically increase:

• Developer understanding
• Debugging clarity
• Confidence in item, pickup and crafting behaviour
• Safe prototyping
• Team knowledge sharing

They are a major reason RevFramework is a developer-first asset.

How to Use¶

1. Open the scene listed under the panel you want, from Samples/Systems/<System>/Scenes/
2. Press Play — the panel is already in the scene and its overlay draws itself
3. Drive the system live: give items, equip, trigger pickups, enqueue crafts
4. Observe real results and the reasoning behind each refusal
5. Copy the same API calls into your gameplay code

Summary¶

The Inventory, Pickups & Crafting Teachable Panels give you:

• Live debugging
• Real API behaviour
• Clear reasoning for every refusal
• Full visibility into stacking, slot rules, apply paths and craft preflight