Skip to content

❤️🧪 RevFramework — Health & Status Effects

Teachable Panels

Teachable Panels turn the Health and Status systems into living documentation you interact with directly inside the Unity Editor.

They let you drive the real runtime APIs — HealthSystem and StatusEffectController — without writing UI, wiring events, or building custom debug scenes.

They are: - Not simulations
- Not mockups
- Not demo-only logic

They are the actual runtime systems, running live in your scene.

⚠️ Important — Read This First

Teachable Panels are development and learning tools.

They are not shipping UI.

If a Teachable Panel component is present on a GameObject in a shipped scene,
it will be visible and interactive at runtime.

Shipping with Teachable Panels attached is a developer error, not a framework bug.

Before building your game: - Remove Teaching panels from scenes, or - Ensure REV_TEACHABLES is not enabled

🎯 Why These Panels Exist

Combat systems are traditionally opaque.

Damage rules, stacking, shields, statuses, immunity, and time control are hard to reason about by reading logs or guessing behaviour.

Teachable Panels provide:

  • A safe, visual, real-time debugger
  • A fast way to learn the API by doing
  • Clear result-first reasoning (success, failure, reduction, immunity)
  • A way to validate behaviour before writing gameplay UI
  • A powerful onboarding tool for teams

Open a panel → press buttons → watch the system respond instantly.

🔥 Health Panels Included

Rules — Basics & Tags

Explore the full pre-shield rule flow:

  • Construct hits with tags (Melee / Ranged / Fire / Poison)
  • Test ArmorRule flat & percent reduction
  • Test Affinity providers (resist, weak, immune)
  • Compare hand-calculated breakdowns vs PreviewDamage
  • See exactly where rules apply before shields

Crit • Execute • Attacker Buffs

Deep dive into attacker-side logic:

  • CritRule — chance & multiplier
  • ExecuteThresholdRule — bypass rules under threshold
  • Attacker multipliers via DamageContext.Multiplier
  • Deterministic previews vs applied hits

DOT • HOT • Stack Modes

Understand over-time behaviour clearly:

  • Refresh / Additive / Independent stacking
  • Shared vs per-stack timers
  • Visual tick bars
  • Live events: Started / TickApplied / StacksChanged / Expired

Regen • I-Frames • Combat State

A complete survivability debugger:

  • Regeneration tuning (tick or smooth)
  • Regen ceilings (absolute / %max / %missing)
  • Invincibility frames blocking hits
  • Combat state timers and recovery
  • Visual cooldowns and active regen

Shields Overview

A full shield laboratory:

  • Capacity, Rechargeable, Reduction, Overheal
  • Shield chains
  • True (bypass) damage
  • Absorption preview vs applied
  • ShieldDamaged / ShieldBroken events

Death FX Handlers

Test death behaviour without damaging HP:

  • Preview VFX, slow-time, camera shake
  • Trigger Kill / Revive
  • Validate destroy-on-death behaviour

🧪 Status Panels Included

Status — Basics

Learn the full status lifecycle:

  • Apply by Id, duration, magnitude, stacking
  • Context-driven applies (ability, item, instigator)
  • Preflight reasoning (blocked by immunity, missing sinks)
  • Event counters: Applied / Refreshed / Removed / Expired

Cleanse • Dispel • Immunity

Interactively test gating mechanics:

  • Cleanse by tag mask
  • Dispel by type & tier
  • Immunity toggles (Id or Tag)
  • Resistance-based duration scaling

Potency Auras

Live tuning of receiver-side scaling:

  • Global and per-tag potency multipliers
  • Exact-Id overrides
  • Resistance sliders
  • Live recompute and refresh

Snapshots • Time Control

Demonstrate save/pause style flows:

  • Capture and restore active statuses
  • Optional paired HP snapshots
  • Time modes: Scaled / Unscaled / Paused / Custom
  • Custom ITimeSource integration

🧠 Why These Teachables Matter

They dramatically reduce:

  • Onboarding time
  • Guesswork and trial/error
  • UI-driven debugging
  • Integration mistakes
  • Support questions

And dramatically increase:

  • Developer understanding
  • Debugging clarity
  • Confidence in combat behaviour
  • Safe prototyping
  • Team knowledge sharing

They are a major reason RevFramework is a developer-first asset.

🚀 How to Use

  1. Add a HealthSystem or StatusEffectController to any GameObject
  2. Open a panel from the RevFramework menu
  3. Drive the system live — hits, statuses, rules, immunity
  4. Observe real results and reasoning
  5. Copy the same API calls into your gameplay code

No prefabs.
No hidden magic.
No special setup.

🏁 Summary

The Health & Status Effects Teachable Panels give you:

  • Live debugging
  • Real API behaviour
  • Clear reasoning and breakdowns
  • Full visibility into combat rules and status lifecycles

They are not demos.
They are not toys.

They are the fastest, safest way to master RevFramework’s combat architecture.