Skip to content

Health Teaching Demos

This folder contains interactive teaching and sandbox panels for the Health system.

Unlike the panels in HostileConsumers, these demos are designed to demonstrate runtime behaviour, component composition, and debugging tools in a controlled environment.

Some panels here may temporarily modify scene components or health state to illustrate specific features of the Health system.

Why These Panels Are Not Hostile Consumers

Panels in this folder may:

  • Dynamically add or remove rule components
  • Rebuild shield stacks or rule chains
  • Configure runtime handlers for demonstration
  • Attach temporary gameplay components
  • Modify test targets during Play Mode
  • Provide interactive debug controls for health state

Because of this, they are not used as verification of the public API surface.

These panels exist purely for teaching, experimentation, and demonstration.

Hostile Consumer Note

Panels in this folder are not classified as hostile-consumer panels.

Some demos intentionally manipulate runtime state to make scenarios easier to test or visualize.

Examples include:

  • forcing a target into a dead state
  • reviving targets for repeated testing
  • dynamically rebuilding rule configurations
  • attaching demonstration handlers at runtime

These behaviours are used to make demo scenes self-contained and interactive.

They do not represent required runtime architecture for projects using RevFramework.

Public API Discipline

Even though these panels are not classified as hostile consumers, they still follow the same core design discipline:

  • Damage flows through HealthSystem.ApplyDamage
  • Previews use HealthSystem.PreviewDamage
  • Damage contexts are created via DamageContext
  • Lifecycle behaviour uses public lifecycle seams such as IHealthLifecycle
  • Rule composition uses public rule configuration APIs

These demos do not:

  • reference .Internal namespaces
  • use reflection
  • access private fields
  • bypass framework encapsulation

Some debug actions may intentionally use public lifecycle utilities or direct state setters (for example forcing a dead state) to support sandbox testing.

Examples of Demo Behaviour

Panels in this folder demonstrate real-world Health system scenarios such as:

  • Shield composition and chaining
  • Capacity vs rechargeable shields
  • Overheal and temporary HP mechanics
  • Team-based friendly fire behaviour
  • Combat state debugging
  • Interactive damage and healing tests
  • Temporary runtime tools such as the Health Debug Panel

Some debug utilities in this folder intentionally use direct state mutation (for example setting health to 0) instead of full lifecycle operations like Kill().

This is done to provide deterministic, predictable behaviour for testing, and to avoid gameplay-side systems (such as death interception or revive handlers) interfering with debug workflows.

These demos allow developers to experiment with the health system interactively.

Relationship to Hostile Consumer Panels

RevFramework includes two categories of teaching panels.

HostileConsumers

Panels that:

  • use only public APIs
  • rely strictly on documented runtime seams
  • do not modify runtime wiring
  • act as verification tools for the framework API

These panels prove that the framework surface is usable by external code.

Demos

Panels in this folder:

  • demonstrate interactive gameplay scenarios
  • show runtime rule composition
  • provide sandbox debugging tools
  • allow experimentation with live health behaviour

They are not part of the hostile-consumer API guarantee.

When to Use These Panels

Use demo panels when you want to:

  • experiment with rule behaviour
  • debug shield or effect interactions
  • visualise damage flows in real time
  • explore gameplay configurations
  • test death/revive flows quickly
  • understand how different rule combinations affect outcomes

Production projects should implement their own runtime composition and gameplay logic, using these demos as reference examples.

Summary

The panels in this folder are interactive sandbox tools.

They demonstrate how the Health system behaves in real gameplay scenarios and provide convenient debugging helpers.

They are not used to verify the public API surface.

For API verification panels, see the HostileConsumers folder.