RevFramework: Health & Status Effects

❤️ RevFramework — Health & Status Effects

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 Health and Status Effects 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 combat kit.

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

🧩 What You Actually Get

Two runtime systems built for developers who want to understand what their combat logic is doing:

❤️ Health — damage pipelines, healing, shields, regeneration, death lifecycle, snapshots, authority-aware mutations

🧪 Status Effects — buffs, debuffs, DOT/HOT, stack and refresh policies, dispel, immunity, aura and zone support

Both systems work independently. Neither requires the other.

Plus the infrastructure most assets skip:

• 14 YouTube tutorials
• Public MkDocs documentation site — freely accessible before you buy. Read it before you decide.
• 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

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

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

🔥 Why It's Different

Most Unity combat assets give you behaviours 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.

If damage fails, you know why. If a status doesn't apply, you see why. If something behaves oddly, you can trace it.

There are no black boxes here.

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

⚔️ Health System

A deterministic damage and healing pipeline with explicit results at every step.

• Damage and healing pipelines with result-based operations
• Damage and heal previews — non-mutating, safe to call from UI
• Regeneration systems
• Invincibility and i-frames
• Shields — rechargeable, damage reduction, temporary HP, overheal, and shield chains
• Death and revive lifecycle with before-death handlers and death event hooks
• DOT and HOT support
• JSON snapshot save and restore
• Authority-aware mutations with clear rejection codes
• UI integration helpers

All shield systems participate in both real damage resolution and non-mutating preview systems.

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

🧪 Status Effects System

A rule-driven status pipeline that handles the complexity of buff and debuff interactions cleanly.

• Buffs and debuffs
• DOT and HOT effects
• Stack and refresh rules with Replace, Refresh, and Stack policies
• Dispel and cleanse systems
• Potency and duration scaling
• Immunity and resistance seams
• Aura and zone support
• Runtime status UI helpers
• Multiple time source support
• Authority-aware ticking and mutation

Common RPG-style effects included as reference implementations:

Poison, Burn, Regen, Slow, Haste, Stun, Vulnerability, Shields, Thorns

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

🎮 Built for Both 2D and 3D

All runtime systems are dimension-agnostic.

• No physics assumptions
• No controller requirements
• No camera dependencies

Damage pipelines, status effects, and combat state work the same regardless of genre or dimension.

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

🌐 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

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

• 14 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 tests 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

• Health System
• Status Effects System

Learning & Debugging

• Teachable panels
• Demo scenes
• Reference UI examples
• Example integrations

Documentation

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

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

🚫 What This Is Not

• Not a character controller
• Not a full RPG template
• Not a networking implementation
• Not a visual scripting framework
• Not a drag-and-drop combat kit
• Not a locked UI workflow

RevFramework is a runtime framework for developers who write code.

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

🎨 UI

Reference UI is included for Health and Status Effects.

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

Inventory, Pickups & Crafting

• 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.

If you value clarity, structure, and real engineering — this framework will feel like home.