Skip to content

Runtime/Core

Framework foundation layer. Not a gameplay integration surface.

Runtime/Core provides cross-system abstractions and low-level runtime services used across multiple RevFramework systems (Health, StatusEffects, Currency/Economy, Pickups, etc.).

It exists to keep systems decoupled, modular, and independently shippable.

Not a Supported Extension Point

This folder is not a public integration surface.

  • ❌ Not intended for gameplay integration
  • ❌ Not intended as a “build your features here” area
  • ❌ Not a stable extension contract (contents may evolve as systems are refined)

If you’re implementing game features, UI, rules, or behaviours:

👉 Start in Runtime/Systems/<System> and follow the Public API, Mental Model, FAQ, Samples, and Teachables for that system.

Teachables live in: RevFramework/Teaching
Samples live in: RevFramework/Samples

What You’ll Find Here

Abstractions (small, cross-system seams)

Minimal interfaces that let systems talk without hard dependencies. Most are consumed by at least one system; the ones marked deprecated never were, and say so on the interface itself.

Examples include:

  • Cooldown / timing
  • ICooldownService — deprecated; nothing calls it. See the note on the interface.

  • ICooldownScaleSink

  • Coroutine execution

  • ICoroutineRunner — deprecated; nothing runs coroutines through it.

  • Actor / gameplay micro-seams

  • IFacingProvider
  • ITeamProvider

  • IMovementSpeedFactor

  • Combat / interaction surfaces

  • IDamageable

  • IDamageTakenModifier

  • Presentation hooks (optional)

  • IWorkbenchFeedback

  • Generic services

  • IResourceLoader — deprecated; framework assets are authored references, not path loads.
  • IObjectFinder — deprecated; each system uses its own scene-scoped resolver.
  • IRandomProvider
  • IInputService

  • IEventBus — deprecated; never wired to anything. See the note on the interface.

  • Time providers

  • ITimeProvider
  • IWallClockProvider

These interfaces are intentionally small and do not own behaviour.

Runtime utilities (foundation helpers)

Low-level helpers shared across systems.

Examples include:

  • Coroutine execution (CoroutineRunner)
  • Authority checks (AuthorityGuard)
  • Diagnostics (DevDiagnostics)
  • Stable identity (StableId)
  • Object lookup caching (FindCache)
  • Compensating transactions (CompTxn)
  • Default time providers (UnityTimeProvider, SystemWallClock)

These are foundation utilities, not gameplay features.

Internal implementations

Internal-only runtime helpers backing abstractions, under Internal/.

  • Example: FindCache — cached first-of-type object lookup, invalidated on scene changes.

These are not part of the public API surface.

Design Intent

Core is a shared substrate:

  • Systems depend on Core
  • Core must not depend on Systems
  • Nothing here should introduce system-to-system coupling

Core exists to:

  • provide minimal shared contracts
  • supply foundational runtime services
  • keep system modules clean and independent

If something feels like gameplay logic, it does not belong here.

TL;DR

Core makes the framework possible — but it’s not where you build your game.
Use Runtime/Systems/<System> and the documented seams.
If a seam is missing, raise it — we add them deliberately.