RevFramework: Inventory, Pickups & Crafting

🚀 RevFramework — Inventory, Pickups & Crafting

If something fails, it tells you why.

That's the rule every RevFramework system is built around.

Explicit APIs. Deterministic behaviour. Real failure codes. No hidden state. No guesswork.

RevFramework gives you production-ready Inventory, Pickups, and Crafting systems — with the documentation, testing, and debugging infrastructure to match.

⚠️ Requires C# scripting knowledge. This is not a no-code tool or drag-and-drop template.

--------------------------------------------------------

🧩 What You Actually Get

Three runtime systems built for developers who want to understand what their code is doing:

✅ Inventory — slots, stacks, equipment, snapshots, authority-aware mutations

✅ Pickups — 2D & 3D, multiple interaction modes, effect-driven architecture

✅ Crafting — preflight validation, job-based crafting, deterministic RNG, offline progress

Plus the infrastructure most assets skip:

• 20 YouTube tutorials
• Public MkDocs documentation site
• Interactive teachable panels that call real APIs and show live results
• Folder-level READMEs across the entire codebase

The full documentation site is publicly accessible — no purchase required. Read it before you decide.

📚 Documentation

RevFramework Documentation

--------------------------------------------------------

🔥 Why It's Different

Most Unity assets give you prefabs and hope.

RevFramework gives you systems and explanations.

Every operation returns a result object with a success flag, a reason code, and an optional message. When something doesn't work, the system tells you exactly what happened and why.

There are no black boxes here.

--------------------------------------------------------

🧰 Core Features

📦 Inventory

A service-driven container system with explicit mutation boundaries and deterministic results.

• Slot-based containers with configurable capacity
• Hotbars, equipment slots, and equipment filters
• Stack splitting, merging, swapping, and moving
• Sorting and searching with replaceable strategies
• JSON snapshot save and restore
• Authority-aware mutations with clear rejection codes
• Every operation returns an InvOpResult — success, code, message

🎁 Pickups

A context-aware pickup system that doesn't assume how your game works.

• 2D and 3D trigger pickups
• Auto, Press, Hold, and Facing interaction modes
• Effect-driven architecture — you define what pickup means
• Decorator pipelines for conditional behaviour
• Clean integration bridges to Inventory and other systems

🔨 Crafting

A job-based crafting pipeline with preflight validation and deterministic output.

• Preflight validation before any craft attempt
• Job-based crafting with progress tracking
• Batch crafting support
• Validators and modifiers for custom rules
• Output routing
• Deterministic RNG
• Optional offline progress

--------------------------------------------------------

🎮 Built for Both 2D and 3D

All runtime systems are dimension-agnostic.

• 2D and 3D pickups with TriggerRelay2D and TriggerRelay3D
• Inventory and crafting systems with no dimension assumptions
• No physics assumptions, controller requirements, or camera dependencies
• Teachable demo scenes for both 2D and 3D workflows

Works great for survival games, RPGs, action RPGs, crafting games, top-down games, and Metroidvania-style projects.

--------------------------------------------------------

🌐 Multiplayer & Networking

RevFramework is netcode-agnostic by design.

Authority binders let you gate mutations through your own ownership and permission rules — whether that's NGO, Mirror, Photon, Fusion, or a custom solution.

Replication, prediction, and rollback are yours to implement.

— We give you the rules. Your netcode drives the simulation.

--------------------------------------------------------

🎓 Learning Infrastructure

This is where RevFramework is genuinely different from other assets.

Teachable Panels

20 interactive panels built directly into the framework. Each one:

• Calls real public APIs — no shortcuts, no internals
• Shows live results and reason codes in the scene
• Demonstrates actual workflows you can copy directly
• Proves the public API works by being a hostile consumer of it

If the teachable panels compile and run correctly, the public API works. Not just documented — actually usable.

Documentation

• Public MkDocs site — freely accessible before you buy
• Every system has: Overview, Mental Model, Integration Surfaces, Public API, System Guarantees Matrix, Testing Philosophy, System Boundaries, and FAQ
•  Folder-level READMEs explaining intent and reasoning, not just "this does this"
• Eight dedicated onboarding documents per system

Videos

• 20 YouTube tutorials covering every teachable panel
• 4 core onboarding videos covering scope, teachables, documentation, and modularity
• Each video shows real behaviour in a real scene

--------------------------------------------------------

🧪 Testing & Reliability

RevFramework test with 1600+ tests across the full framework.

The goal was never coverage percentages.

The goal was predictable architectural behaviour.

Hostile Consumer Tests

Validate the public API the way a real project would — through supported surfaces only, with no access to internals. If these pass, the contract holds.

Internal Truth Tests

Lock down framework assumptions so future refactors don't silently change behaviour. Event ordering, rollback paths, authority rejection, restore semantics.

PlayMode Smoke Tests

Catch Unity lifecycle failures that EditMode tests can't reach.

Test assemblies are not shipped with the framework. You get clean runtime, editor, sample, and teaching assemblies — no NUnit dependencies, no compile overhead.

--------------------------------------------------------

🧱 What's Included

Runtime Systems

• Inventory
• Pickups
• Crafting

Learning & Debugging

• 20 teachable panels
• Demo scenes
• Reference UI examples
• Example integrations

Documentation

• Full MkDocs site
• Folder-level READMEs
• 20 YouTube tutorials

--------------------------------------------------------

🚫 What This Is Not

• Not a character controller
• Not a quest system
• Not a dialogue system
• Not an AI framework
• Not a visual scripting tool
• Not a networking implementation
• Not a locked UI workflow
• Not a drag-and-drop game template

RevFramework is a runtime framework for developers who write code.

--------------------------------------------------------

🎨 UI

Reference UI is included for Inventory, Crafting, and Pickups.

It shows you how to talk to the systems correctly.

It is not your game UI.

Build your own using Unity Canvas, UI Toolkit, or whatever fits your project. RevFramework puts no constraints on how you present its systems to players.

--------------------------------------------------------

🔗 Other RevFramework Modules

• Health & Status Effects
• Currency & Economy
• RevFramework Complete — all systems together

All modules share the same architecture, documentation standard, and testing philosophy. Each one works independently or integrates cleanly with the others.

--------------------------------------------------------

🧑‍💻 Who This Is For

RevFramework is for developers who:

• Are comfortable writing C#
• Want modular systems they can understand and extend
• Prefer explicit APIs over magic behaviour
• Need to know why something failed, not just that it did
• Value documentation and debugging infrastructure as much as features

If you want a no-code solution or a beginner template, this is not the right package. That's not a criticism — it's just a different tool for a different job.

--------------------------------------------------------

🙋 Core Philosophy

Every system. Every operation. Every failure.

If something fails, it tells you why.

That's not a feature. That's the foundation everything else is built on.