RevFramework Complete — Modular Gameplay Systems for Unity

Asset description

🚀 REVFRAMEWORK COMPLETE If something fails, it tells you why. That is the rule every RevFramework system is built around. Explicit APIs. Deterministic RNG and rounding. Real failure codes. No guesswork. -------------------------------------------------------- ⚠️ READ THIS BEFORE YOU BUY RevFramework is for developers comfortable writing C# in Unity. It is not a no-code tool. There are no drop-in prefabs that "just work" and there is no inspector-only configuration path. If that is what you are looking for, this is the wrong asset — and I would rather you knew now than after buying. That is not a criticism of what you need; it is a different job. The full documentation site is public and needs no purchase. Read it and decide for yourself before you spend anything: -------------------------------------------------------- 🧩 WHAT YOU GET Nine gameplay systems, each usable on its own: 🧺 Inventory — slot-based containers, hotbars, equipment slots and filters, stack split/merge/swap/move, replaceable sort and search strategies, JSON snapshot save and restore 🎁 Pickups — 2D and 3D pipelines, multiple interaction modes, effect-driven architecture so you define what "pickup" means, decorators, cooldowns 🔨 Crafting — job-based with preflight validation and progress tracking, batch crafting, validators, modifiers, output routing, workbenches, deterministic RNG, optional offline progress 💎 Loot — drop tables, weighted and independent-chance rolls, nested tables with cycle detection, and delivery that accounts for every award: given to the owner, dropped into the world, or named in an Undelivered event. Never silently discarded, which is the failure a loot system is likeliest to hide ❤️ Health — damage and heal pipelines returning structured results, non-mutating previews safe to call from UI, shields (rechargeable, damage reduction, temporary HP, overheal, chains), regeneration, i-frames, death and revive lifecycle with before-death handlers ✨ Status Effects — buffs and debuffs with stack and refresh policies, DOT and HOT, dispel and cleanse, potency and duration scaling, immunity and resistance seams, auras and zones, multiple time sources 💰 Currency — ledger-based credit, debit and transfer, overflow-safe execution, escrow and holds with commit/release/TTL expiry, rollback-safe transaction staging, request-ID replay protection, exchange with rates, fees, limits and deterministic rounding, batched blocks with audit logs 🏪 Economy — shop services with all-or-nothing delivery and charge refund on failure, crafting cost integration with refund and restore, reward flows 📊 Attributes — Complete only. Somewhere to keep the numbers a character is made of, with no fixed stat list. How contributions stack is a function you supply: no two games agree, so nothing ships Plus a save layer: a coordinator, a file store, participant ordering and carry-over — so a save written by a build that had a system you have since removed does not lose that data. You are not buying a prefab kit. You are buying gameplay architecture. -------------------------------------------------------- 🔥 WHY IT IS DIFFERENT Most Unity assets give you templates and hope the pieces fit together. RevFramework gives you systems and explanations. Every Currency, Economy and Inventory operation returns a result object: a success flag, a machine-readable reason code, and an optional message. When a transaction does not go through, the system tells you exactly what happened. If a rollback occurs, you can trace it. If authority validation rejects a mutation, it is explicit. By design, not by luck. -------------------------------------------------------- 🎓 IT TEACHES ITSELF INSIDE THE EDITOR This is the hardest part to show in a screenshot. TEACHABLE PANELS 49 interactive panels, already placed across 49 sample scenes. Press Play, read what the panel is teaching, toggle the edge cases, press the buttons, and watch live results — balances, stacks, failure reasons, state changes. When it makes sense, copy the service calls into your own UI and delete the panel. Most are written as hostile consumers: restricted to the public API and nothing else. No internal namespaces, no reflection, no undocumented helpers, no sample-only utilities. That constraint is the point. If they compile and run, the public API is genuinely sufficient to build on. THE COOKBOOK 46 worked recipes on the public site, each complete C# you copy into a project that already exists. Nine categories, and the last is the point: Systems You Own — a quest objective, a faction standing, an ability, a spawn director. Recognisable gameplay this framework deliberately does not ship, built from mechanisms already here. Attributes is what made that category possible. DOCUMENTATION Public MkDocs site, freely readable before you buy Every system has an Overview, Mental Model, Integration Surfaces, Public API, System Guarantees Matrix, Testing Philosophy, System Boundaries and FAQ 500+ folder-level READMEs beside the source, explaining intent and reasoning rather than restating what the code says A guarantees matrix per system that lists what it does NOT promise as plainly as what it does Where a page has been wrong, the correction says so instead of quietly replacing the text. Where a design costs you something, the documentation lists the cost. An In Development page marks itself as intent, not promise. VIDEO 49 tutorials covering the teachable panels 4 core onboarding videos: scope, teachables, documentation, and a live demonstration of removing and restoring systems in a real project -------------------------------------------------------- 🧪 TESTING AND RELIABILITY EditMode 3240 tests 49 assemblies PlayMode 613 tests 26 assemblies Both green, run on every push against a clean Unity project in CI. The counts are stated rather than summarised because a number you can check is worth more than an adjective. The goal was never a coverage percentage. It was predictable architectural behaviour. Hostile Consumer tests — exercise the public API the way a real project would, with no access to internals. If these pass, the contract holds. Internal Truth tests — pin assumptions a refactor could silently change: event ordering, rollback paths, authority rejection, restore semantics. PlayMode tests — Unity lifecycle failures EditMode cannot reach. Convention tests — structural guards that stop a fixed bug class returning. Test assemblies are not shipped — clean runtime, editor, sample and teaching assemblies, no NUnit dependency. The suite is a free download for owners. -------------------------------------------------------- 🧬 MODULARITY Modularity is enforced at the assembly level, not just by folders. Each system compiles independently — delete Inventory and Crafting still builds. Integration lives in optional, define-gated layers, and scripting symbols update automatically as systems are added or removed. One deliberate exception: Economy is the integration layer over Currency and Inventory, so it builds on both by design. No prefabs. No required singletons — every service is an instance you create, own and can substitute. No MonoBehaviour soup. -------------------------------------------------------- 🌐 MULTIPLAYER AND NETWORKING Stated plainly because it is the likeliest mistaken assumption. RevFramework is netcode-agnostic: it does not implement networking, replication, prediction or rollback. Authority binders let you gate mutations through your own ownership and permission rules across every gameplay system that mutates state — NGO, Mirror, Photon, Fusion, or something you wrote. We give you the rules; your netcode drives the simulation. -------------------------------------------------------- 🎨 UI Reference UI is included across all systems. It shows you how to talk to the systems correctly — it is not your game UI. Build your own with Canvas, UI Toolkit, or whatever fits. -------------------------------------------------------- 🚫 WHAT THIS IS NOT Not a character controller. Not a quest or dialogue system. Not an AI framework. Not a visual node editor. Not a drag-and-drop template. Not a locked UI workflow. Quests and reputation are absences on purpose: both are thin once the primitives under them are right, and the Cookbook shows you building them. RevFramework gives you the foundations. You build the game. -------------------------------------------------------- ⚙️ REQUIREMENTS Unity 6.0 or later Built-in, URP and HDRP — runtime systems are render-pipeline agnostic Dimension-agnostic — no physics, controller or camera assumptions No third-party dependencies Full C# source included Some sample scenes reference the Input System and Universal RP — dependencies of those scenes, not of the framework. Opening one without them names the objects and packages responsible rather than silently doing nothing. Only the Runtime folder is required for a build. Documentation, Samples and Teaching are optional, and Pre-Build Clean archives them rather than deleting them. -------------------------------------------------------- 🔗 PREFER TO START WITH ONE SYSTEM? Inventory, Pickups & Crafting Health & Status Effects Currency & Economy All share the same architecture, documentation standard and testing philosophy. -------------------------------------------------------- 🛟 SUPPORT Reach out before leaving a review. If it is broken, it gets fixed. Documentation: -------------------------------------------------------- Every system. Every failure. If something fails, it tells you why. That is not a feature. It is the foundation everything else is built on. 🛠 UNITY & RENDERING Unity 6.0 or later Built-in Render Pipeline, URP and HDRP all supported Runtime systems are render-pipeline agnostic — no RP-specific code, shaders or dependencies -------------------------------------------------------- 📦 ARCHITECTURE 100% C#, no native plugins Modular and opt-in — each system compiles independently Prefab-free: no enforced workflows, no required scene setup No REQUIRED singletons. Every service is an instance you create, own and can substitute. A few static accessors exist as fallbacks for the convenience resolvers — hold your own reference and nothing consults them No hidden dependencies. Where one exists, it is documented Result-first operations across all systems: explicit success flags,machine-readable reason codes, optional messages -------------------------------------------------------- 🧩 SYSTEMS INCLUDED • Inventory • Health • Currency • Pickups • Status Effects • Economy • Crafting • Loot • Attributes Plus a save layer: coordinator, file store, participant ordering and carry-over. Each system works independently or together through adapters. One deliberate exception: Economy is the integration layer over Currency and Inventory. -------------------------------------------------------- 🧠 RUNTIME DESIGN Deterministic pipelines, with deterministic RNG where applicable Retry-safe operations — request-ID replay protection on currency Rollback-safe transaction staging Built for server-authoritative multiplayer and predictable simulation -------------------------------------------------------- 🌐 MULTIPLAYER Netcode-agnostic — no networking, replication, prediction or rollback Authority-aware by design, with authority interfaces across every system You handle networking. RevFramework handles logic and validation. -------------------------------------------------------- 🔌 INTEGRATION Adapter-driven: systems integrate through clean interfaces with no hard coupling between modules. Any integration point can be replaced or extended. -------------------------------------------------------- 🧪 PERFORMANCE Struct-based data with batch operations Deterministic RNG where applicable Low-GC hot paths — no per-frame allocations on normal use paths -------------------------------------------------------- 🎓 TEACHABLE PANELS Live Editor panels across every system that call real runtime APIs, show success and failure results with reason codes, and visualise behaviour as it happens. Interactive documentation built into the Editor. -------------------------------------------------------- 📚 DOCUMENTATION & SAMPLES Full MkDocs site, public and readable before purchase Folder-level READMEs beside the source 42 sample scenes, quickstart through full demos XML-documented public APIs Teachable Panels aligned with the docs — docs, panels and code match -------------------------------------------------------- 🧵 PLATFORM SUPPORT Pure C# with no platform-specific code, so the framework imposes no platform restrictions of its own. Developed and tested on Windows. Nothing in the runtime is desktop-specific and the same code is expected to run anywhere Unity 6 does — WebGL, iOS, Android, macOS, Linux and console targets included. -------------------------------------------------------- 🔑 REQUIREMENTS Unity 6.0 or later C# scripting experience required Familiarity with interfaces and composition recommended For multiplayer: a basic understanding of authority and RPCs