RevFramework¶

RevFramework is built for developers who want control, clarity, and predictable behaviour, rather than drag-and-drop magic.

Start Here — Is This For You?¶

Three minutes on what RevFramework is, what it deliberately is not, and how to approach it. Worth watching before you buy or before you wire anything up.

The full onboarding series continues with the Teachable Panels, a tour of this documentation, and a live demonstration of removing and restoring systems in a real project: Watch the onboarding series

Important Notice — Please Read First¶

RevFramework is designed for developers comfortable with C# scripting in Unity.

RevFramework is:

• 100% C#
• Fully modular and opt-in
• Prefab-free by design
• Explicit rather than automatic

Every system shows its state, requirements, and results clearly — nothing happens “behind your back”.

Teachable Panels & Build Safety¶

RevFramework includes Teachable Panels for learning and debugging.

These panels are runtime-capable in the Editor (Play Mode), but are not intended to ship in player builds.

Teachable panels are development-only tools and are not part of the supported runtime surface.

Which SKUs Did I Import?¶

Depending on what you purchased, this package may include one or more of the following systems:

• Currency
• Economy
• Inventory
• Health
• Status Effects
• Pickups
• Crafting
• Loot
• Attributes — Complete Bundle only
• Complete Bundle (all systems)

Each system is fully independent.
Owning one system does not require owning any others.

Choose Your Documentation¶

Documentation¶

Each system includes its own focused documentation inside the project:

Documentation/
 └─ {SystemName}/
    └─ README.md

These same documents power the online MkDocs documentation and mirror the in-editor Teachable Panels exactly — same labels, same flow, same behaviour.

There is no single giant manual by design.
You only read the system you are actually using — nothing more.

Cookbook¶

The documentation above teaches one system at a time. The Cookbook is the other half: small, complete compositions built from the public seams of two or three systems at once — a shop that charges in health, loot odds that read the player's condition, a craft that cannot half-happen, death drops built from what the corpse was actually carrying.

Each recipe is one class you copy into a project that already exists. Every page states the systems it needs, the traps found while writing it, and the trade-offs it makes rather than hiding them.

Like the tests, the Cookbook is not in this package — for a different reason. Recipes are reference implementations meant to be copied, adapted, and owned by you. They are deliberately not part of RevFramework's supported gameplay surface: once you change one it is your code, and support covers the framework's behaviour rather than your copy of a recipe.

They live on the site instead, where nothing needs downloading and no framework update can break a recipe you have already taken:

👉 Browse the Cookbook

Tests¶

RevFramework is built test-first — there is more test code in the project than there is code under Runtime/, and every system is covered by adversarial and behaviour-pinning tests.

Those tests are not in this package, deliberately: a game project shouldn't carry a framework's test suite unless its author wants it. They are available instead as a free download for owners — useful if you are extending the framework, subclassing its components, or want a regression net around changes you make.

See Testing for what the suite covers and how to get it, or use the Test Suite (free download) button in the welcome window.

That window opens by itself on your first import and not again — it is a once-ever introduction rather than a per-project one. To reach it at any time, including in a project where it never appeared:

Tools ▸ RevGaming ▸ RevFramework ▸ Help ▸ Show … Welcome

Where Do I Start?¶

For any system you want to use:

1. Open the matching Sample Scene under Samples/Systems/<System>/Scenes/
2. Press Play — that scene's Teachable Panel overlay is already in it (Editor-only)
3. Read the system’s README.md
4. Wire the system into your own code, prefabs, and UI

You do not need to understand the entire framework to use one system.

Architecture at a Glance¶

• Fully modular — systems are opt-in
• No required singletons — every service is an instance you create, own, and can substitute
• A few static accessors (SceneInventoryService.Instance, InputServiceRegistry.Current) exist as fallbacks for the convenience resolvers — hold your own service reference and nothing consults them
• No “MonoBehaviour soup”
• Clear runtime vs editor separation
• Result-based operations — every mutation returns a code you can branch on, never a bare bool
• Authority-gated mutation on six of the ten systems, so a server can refuse a change and say why
• Adapter-driven integrations (shops, UI, gameplay layers)

If a dependency is missing, the framework tells you what and why — not just that something failed.

Why It Works This Way¶

A few of the choices above are visible in your project long before their reasoning is, and without the reasoning they look like mistakes. Why the framework installs into Assets/ rather than as a package. Why the scene services are large single files. Why authority stops short of doing your networking for you.

Each has a page giving the reason and what the choice costs you, so you can judge whether the trade suits your project instead of reverse-engineering it from the code:

👉 Why It Works This Way

Editor-Only Tooling¶

RevFramework includes extensive Editor-only tooling:

• Teachable Panels
• Debug & diagnostics helpers
• Sample scenes and inspectors

These are for learning, testing, and integration — not runtime performance flags.

What Can I Delete Before Building?¶

RevFramework is safe to trim for player builds.

The following folders are editor-only or reference-only and may be deleted before building your game if you are not using their contents:

• Documentation/ – Markdown docs (also available online)
• Samples/ – Example scenes and prefabs
• Teaching/ – Editor-only Teachable Panels

⚠️ If you keep Teaching content, remove the Teaching/ folder before building — Pre-Build Clean does it for you. The REV_TEACHABLES define follows the folder and cannot be turned off on its own.

Before Contacting Support¶

Before reaching out, please check:

• You are using a supported Unity version
• Required systems are present (as listed in the panel or README)
• You are not running a sample scene with a removed system
• Console warnings have been read — they usually explain exactly what’s missing
• You have not enabled REV_TEACHABLES in a player build

If something still doesn’t work: 👉 Reach out before leaving a review.
If it’s broken, it gets fixed.

The RevGaming Philosophy¶

What that looks like in practice¶

Hide nothing. Every system shows its state. Every failure has a reason. Every demo is runnable and editable. Every document matches what you see in Unity.

We won't lie to you. Every system ships a guarantees matrix, and it lists what the system does not promise as plainly as what it does. Where a page has been wrong, the correction says so instead of quietly replacing it — and where an API exists but was never wired up, it says that too rather than letting you build on it.

We meet you where you are. There is no single intended depth. Drop a component in an Inspector and never read a line of the source; or read the folder README beside that source; or download the test suite and run the behaviour for yourself. All of those are supported entry points, and none of them is the "real" one.

No guessing. No magic. No surprises.

© RevGaming