Skip to content

🧲 Pickups — What This System Does (and Doesn’t Do)

This page explains what the Pickups system is responsible for and what is intentionally left to you.

No code. No implementation details. Just boundaries.

✅ What Pickups does

Pickups is responsible for:

  • Representing pickup behaviour as effects
  • Applying effects to an actor or context object
  • Supporting trigger-driven world pickups
  • Supporting 2D and 3D trigger relay flows
  • Handling basic pickup filters such as layers and optional tags
  • Supporting optional authority checks through interfaces
  • Supporting effect cooldowns
  • Supporting effect decorators such as VFX, sound, debug logging, persistent VFX, and conditional gates
  • Supporting success and failure feedback hooks
  • Providing simple helper components for common pickup behaviour
  • Allowing effects that do not require a damageable target when explicitly marked as safe

👉 In short:

Pickups owns the moment an actor attempts to consume a pickup and what effect runs from that attempt

❌ What Pickups does not do

Pickups intentionally does not provide:

Persistence

  • No save files
  • No pickup collection history
  • No automatic restore of consumed pickups
  • No cloud sync

You must decide:

  • which pickups stay gone
  • which pickups respawn
  • when pickup state is saved
  • where pickup state is stored
  • how pickup state is restored

Networking

  • No replication
  • No prediction
  • No rollback
  • No multiplayer reconciliation

Pickups can ask an authority provider whether an actor is allowed to consume something, but:

👉 You own the multiplayer rules and state sync

Inventory Ownership

  • No inventory containers
  • No item stacks
  • No equipment slots
  • No item database ownership

Pickups can receive item/source context and can be used by inventory-facing flows, but:

👉 Inventory remains the inventory system’s responsibility

Health Ownership

  • No health lifecycle
  • No alive/dead rules
  • No automatic damage pipeline
  • No automatic shield interception

Some effects can work with damageable targets or add helper components, but:

👉 Your health/damage system owns health rules

UI / UX

  • No inventory UI
  • No pickup list UI
  • No tooltip system
  • No prompt styling system

Pickups provides simple hooks such as prompts, success feedback, and failure feedback.

You decide:

  • how prompts look
  • how pickup messages appear
  • how feedback is styled
  • how UI communicates failure or success

Game Design Rules

  • No rarity system
  • No loot tables
  • No economy balancing
  • No progression rules
  • No “who should get what” logic

Pickups gives you the execution point.

You define the game rules around it.

🧠 Responsibility Split

Responsibility Owner
Trigger pickup attempt Pickups
Effect application Pickups
Decorator wrapping Pickups
Cooldown gating Pickups
Success/failure feedback hooks Pickups
Basic layer/tag filtering Pickups
Optional authority query Pickups + your authority implementation
Pickup save/load state You
Multiplayer replication You
Inventory storage Inventory / You
Health lifecycle Health / You
UI presentation You
Loot/progression rules You

🧩 The Mental Shortcut

If you’re ever unsure:

  • “What happens when this pickup is touched or used?” → Pickups
  • “What effect should run?” → Pickups
  • “Should this actor be allowed?” → Your authority rules
  • “Does this item go into inventory?” → Inventory / You
  • “Is this character alive, dead, shielded, or immune?” → Health / You
  • “Should this pickup stay gone after reload?” → You
  • “How is this shown to the player?” → You

🧪 Why Pickups Is Designed This Way

Pickups is deliberately small at the ownership level.

It should be able to sit between systems without trying to become all of them:

  • It can trigger health-facing effects.
  • It can be used beside inventory flows.
  • It can play feedback.
  • It can ask an authority service.
  • It can run decorated effects.

But it does not pretend to own your whole game loop.

That is the fucking point.

🎯 The Point

Pickups is designed to be:

  • Modular
  • Explicit
  • Easy to wire into different game types
  • Safe to extend through documented seams
  • Useful without forcing a full gameplay architecture

It gives you:

👉 a reliable effect-and-trigger layer

It does not try to be:

👉 your inventory system, health system, networking layer, save system, loot table, and UI framework all wearing one trench coat

TL;DR

Pickups handles the pickup attempt and effect execution.
You own the game rules around it.