Skip to content

🎁 Using the Pickups System

The Pickups system is a modular, decorator-driven, netcode-agnostic pipeline for collectible items and interactables.

It scales from simple world pickups (VFX, teleport, animation triggers) to more structured interactables with decorators, authority binders, and feedback — without hard dependencies on other systems.

🎯 Purpose

Pickups provide a data-driven execution pipeline for triggering gameplay effects from world interactions.

They are designed to:

  • support standalone usage or integration with other systems
  • separate authoring (definitions) from execution (effects)
  • allow behaviour composition via decorators
  • optionally gate execution via authority rules

📦 Folder Overview

Pickups are composed from these layers:

  1. Effects → what actually happens
  2. Decorators → wrappers that add behaviour
  3. Definitions → authoring assets
  4. UnityIntegration → scene components (triggers, interactables)
  5. Authority → optional mutation gating
  6. Feedback → optional UX responses

🧩 What Lives Here

Core components involved in the pipeline:

  • PickupEffect → base effect contract
  • PickupEffectDecorator → behaviour wrappers
  • IPickupDecoratorCreator → decorator construction
  • PickupEffectRunner → execution entry point
  • IPickupAuthority → optional gating
  • IPickupFeedback → optional UX handling

🧠 Usage Guidance

Create a Definition

Assets → Create → RevFramework → Pickups → Definitions → ...

Definitions are data-only assets describing:

  • effect configuration
  • decorator entries and priority
  • optional VFX/SFX or conditions

Add Decorators

Decorators wrap effects in a defined order:

  • lower priority → inner
  • higher priority → outer

Decorators may:

  • cancel execution
  • add VFX/SFX
  • gate execution (tags, RNG, conditions)
  • provide debug or logging hooks

Create a World Pickup

Common entry components:

  • TriggerPickup → automatic trigger-based pickup
  • InteractablePickupBase → input-driven interaction

Requires:

  • TriggerRelay2D or TriggerRelay3D

Apply an Effect (code)

PickupEffectRunner.Apply(effect, damageable, actor);

This handles:

  • decorator routing
  • cooldown enforcement
  • null-damageable rules

🧪 Diagnostics

Execution flow:

Trigger / Interaction
        ↓
Authority (optional)
        ↓
PickupEffectRunner
        ↓
PickupEffect.ApplyTo (standard path)
        ↓
Decorators (inner → outer)
        ↓
OnApply (effect logic)
        ↓
Feedback (optional)

Notes:

  • Authority is checked before execution
  • Decorators may cancel execution
  • Effects run only after pipeline checks pass

⚠️ Important Notes

  • Null-damageable requires IEffectAllowsNullDamageable
  • Context-aware effects bypass base gating
  • Cooldowns bind to owner (damageable → context fallback)
  • Decorators may cancel execution early
  • Definitions do not enforce behaviour
  • Feedback does not affect execution logic

🚫 Not for Production Use

This module does not provide:

  • networking or replication
  • inventory integration
  • UI systems
  • prefab-driven gameplay setups

Networking (sync, RPCs, rollback) must be implemented externally.

  • Core
  • Definitions
  • Decorators
  • Effects
  • UnityIntegration
  • Authority
  • Feedback