RevFramework: Health & Status Effects

🚀 HEALTH & STATUS EFFECTS

If something fails, it tells you why.

That is the rule every RevFramework system is built around. Explicit APIs. Rule-driven pipelines. 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 tool for a different job.

The full documentation site is public and needs no purchase. Read it and decide for yourself before you spend anything:

https://revandrab.github.io/RevFramework/SKUs/HealthStatusEffects/

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

🧩 WHAT YOU GET

Two gameplay systems, usable together or on their own:

❤️ 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, invincibility and i-frames, combat state, death and revive lifecycle with before-death handlers, and a PRE/POST rule pipeline you extend with your own rules

✨ 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, snapshots, and multiple time sources so an effect can run on scaled, unscaled or your own clock

Plus a save layer: a coordinator, a file store, participant ordering, and carry-over. Health restores state without re-firing the events that state would normally raise — no Died, no Revived, no HealthChanged — because spawning death VFX every time a save loads would be wrong. LoadCompleted is where you reconcile presentation.

Not included: Inventory, Pickups, Crafting, Loot, Currency and Economy. Those ship in their own packages, or all eight systems together in RevFramework Complete.

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.

Damage returns a structured report rather than a number: what was requested, what each rule did to it, and what was finally applied. Previews are non-mutating and safe to call from UI every frame — a crit rule does not roll during a preview, so a damage estimate does not flicker between values.

A rule you untick in the Inspector really is disabled. If a status effect is refused, the reason is available rather than inferred.

If something fails, you know why. By design, not by luck.

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

🎓 IT TEACHES ITSELF INSIDE THE EDITOR

This is where RevFramework is genuinely different, and it is the hardest part to show in a screenshot.

TEACHABLE PANELS

Interactive panels built into the framework, already placed in the sample scenes. Press Play, read what the panel is teaching, toggle the edge cases, press the buttons, and watch live results — damage reports, shield layers, stacking policies, cleanse behaviour, failure reasons. 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.

They teach the framework and verify its API surface at the same time.

DOCUMENTATION

• Public MkDocs site, freely readable before you buy
• Each system has an Overview, Mental Model, Integration Surfaces, Public API, System Guarantees Matrix, Testing Philosophy, System Boundaries and FAQ
• A damage pipeline diagram showing the order rules actually run in
• 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.

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

🧪 TESTING AND RELIABILITY

RevFramework is built test-first. Across the whole framework, including these systems:

EditMode 2519 tests 36 assemblies

PlayMode 402 tests 19 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.

Four kinds: Hostile Consumer tests that exercise the public API through supported surfaces only; Internal Truth tests that pin documented behaviour so a refactor cannot silently change it; PlayMode tests for Unity lifecycle; and Convention tests that stop a fixed bug class from quietly returning.

Test assemblies are not shipped — you get clean runtime, editor, sample and teaching assemblies with no NUnit dependency and no compile overhead. The suite is a free download for owners instead.

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

🧬 MODULARITY

Modularity is enforced at the assembly level, not just by folders. Each system compiles independently — Health runs with Status Effects absent, and Status Effects does not require Health. Integration lives in optional, define-gated layers rather than hard references, and scripting symbols update automatically as systems are added or removed.

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, using NGO, Mirror, Photon, Fusion, or something you wrote. We give you the rules; your netcode drives the simulation.

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

🎨 UI

Reference UI is included — health bars, buff bars. 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 combat or ability system.

Not an AI framework.

Not a visual node editor.

Not a drag-and-drop template.

Not a locked UI workflow.

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. Neither is a dependency of the framework, only of those scenes — and 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.

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

🔗 THE OTHER PACKAGES

• Inventory, Pickups & Crafting
• Currency & Economy
• RevFramework Complete — all eight systems

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: https://revandrab.github.io/RevFramework/SKUs/HealthStatusEffects/

Email: [email protected]

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

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.