Game Systems Guide

Getting Started

Game Systems You Can Add

Add Inventory

How It Works

Add Inventory creates a scene GameObject with a U3DInventory component on it. The inventory finds the local player automatically at runtime and lives on their side only — each player in a multiplayer session has their own inventory state, and items spawned from inventory go through normal multiplayer spawning, so they appear to other players too.

Inventory holds up to 10 stacks. When you collect an item type for the first time, it lands in the next empty slot. Collecting the same item again increments that slot's count. Pressing the slot's hotkey spawns one instance of that item at your hand and reduces the count by one. Slots clear when their count hits zero.

How Items Activate

When a hotkey press summons an item, Inventory calls into the prefab's interactable components to activate it. What "activate" means depends on the prefab:

• Grabbable + Throwable: the item is grabbed to your hand. Press the throw key (R by default) to release it forward in the camera direction. If you have more in the stack, pressing the slot hotkey again throws the current one and grabs the next — so you can press 1 five times to throw five gems in a row.
• Grabbable only: the item is grabbed to your hand. When you press the hotkey again, it releases — falling or floating depending on the prefab's Rigidbody settings.
• Kickable: the item is kicked immediately in the camera direction. No "held" state.
• Interact Trigger only: the prefab's OnInteractTriggered event fires. Wire it to whatever effect you want — a particle burst, a sound, a heal, a stat change. The prefab can also self-destruct if the effect is one-shot.

Inspector Fields

• Slot Hotkeys: An array of 10 KeyCodes, one per slot. Defaults to 1, 2, 3, 4, 5, 6, 7, 8, 9, 0. Remap any of them per scene.
• Hand Bone Name: Name of the hand bone on the player avatar where items spawn. Defaults to RightHand. The inventory walks the local player's child transforms at runtime to find a bone matching this name.
• Max Live Spawned Instances: Maximum number of inventory-spawned objects that can exist in the world at once, across all slots combined. When this limit is reached, pressing a slot hotkey leaves the banked stack untouched and fires OnSpawnLimitReached instead of spawning. Set to 0 (the default) for unlimited. Useful for scenes where players can bank large stacks of throwable items — caps the world-mesh load that spam-throwing can produce.

Events

• OnItemAdded: Fires when a Collectable adds something to inventory. Args: the prefab added and its new stack count. Wire to UI updates or pickup sounds.
• OnItemRemoved: Fires when an item is removed (via use or via custom scripting).
• OnSlotChanged: Fires whenever any slot's contents change (add, remove, or use). Args: slot index, prefab, count.
• OnSlotUsed: Fires when a slot's hotkey successfully spawns an item.
• OnInventoryFull: Fires when a Collectable tries to add a new item type but all 10 slots are already holding different prefabs.
• OnSpawnLimitReached: Fires when a slot hotkey press is blocked because the live spawn limit is reached. The banked stack is not consumed. Arg: the prefab that would have spawned. Wire to UI feedback like a "too many out — pick some up before spawning more" message.

Check Your Work

• Only one Inventory per scene. If you accidentally add two, only the first one found at runtime is used. Make Collectable's auto-add helps avoid this — it only adds an Inventory if none exists.
• Inventory is scene-local and per-session. When a player leaves and rejoins, their inventory starts empty. There's no persistence in this version.
• Inventory finds the local player at runtime. If you can press a hotkey but nothing happens, check the Console for a warning about not finding the local player — that usually means the scene doesn't have a U3D Core prefab, or the player hasn't spawned yet.
• The spawn limit only counts inventory-spawned objects. Objects that exist in your scene from authoring (Collectables sitting in the world, prop spawners, etc.) don't count against it — only items that came out of an inventory slot. The count drops when those objects are destroyed. If your spawned items never get destroyed (e.g., thrown coins that persist forever), the live count climbs to the cap and stays there until something cleans them up. That's the safety behavior working as intended, but if you want unlimited spawning you'll want a despawn mechanism on the spawned prefabs themselves.

Make Collectable

How It Works

Make Collectable adds a U3DCollectable component to the selected object. When triggered, the Collectable adds one or more copies of a configured prefab to the local player's Inventory. The Collectable itself doesn't disappear by default — wire its OnCollected event to a SetActive or Destroy if you want one-shot pickups. Leaving it active lets the same object dispense repeatedly, like a vending machine or a resource node.

If your scene doesn't have an Inventory yet, applying Make Collectable adds one automatically — Collectable has nothing useful to do without one.

Two Collection Methods

• OnEnter (default): The Collectable acts as a trigger volume. Walking into it picks it up automatically. Use this for items lying on the ground.
• OnInteract: The player must press the Interact key (R by default) while near the Collectable. Use this for nodes, dispensers, and anywhere you want pickup to feel deliberate.

Inspector Fields

• Prefab To Collect: Which prefab gets added to inventory. Defaults to the Collectable's own GameObject — fine when the visual you walk into IS the item being collected (a gem floating in the air). For node-style setups where the visual stays in place and dispenses a different item, drag your prefab asset here. This must be a prefab asset from your Project window, not a scene GameObject.
• Quantity: How many copies are added per successful collection.
• Collection Method: OnEnter or OnInteract, as described above.
• Interact Distance: Maximum distance for OnInteract pickup. Ignored for OnEnter.
• Trigger Once: When enabled, the Collectable becomes inert after one successful pickup. Good for one-time quest rewards.
• Cooldown Time: Seconds before the Collectable can dispense again. Use this for renewable resource nodes (e.g., set it to 5 seconds for a gem that regrows).
• Require Tag / Required Tag: When enabled, only objects with the specified tag count as the collecting player.
• Optional Label: Assign a U3DWorldspaceUI to display a label near the Collectable, matching the Grabbable and Pushable label pattern.

Events

• OnCollected: Fires when a player successfully picks up. Args: the GameObject of the collecting player. Wire to visual feedback (particle burst, sound, mesh swap to "harvested" state) or to the Collectable's own SetActive/Destroy if you want it to disappear.
• OnCollectFailed: Fires when a pickup attempt is blocked by cooldown, trigger-once, tag mismatch, or full inventory.
• OnPlayerEnterRangeEvent / OnPlayerExitRangeEvent: Fires when the local player enters or leaves interact range. OnInteract mode only.

Check Your Work

• Two GameObjects to think about. The Collectable in your scene is the dispenser. The Prefab To Collect is what ends up in inventory. They can be the same thing (gem-in-the-air pattern) or different (node-dispenses-gem pattern). When using a node, drag the prefab from your Project window, not the Hierarchy.
• OnEnter needs a trigger collider. Make Collectable sets the Collider's "Is Trigger" automatically when applied. If you change this later, OnEnter will stop working.
• OnInteract pickups require the player to be in range AND press R. If you're standing right on top of a Collectable in OnInteract mode and nothing happens, you still need to press R — being in range alone doesn't trigger pickup. Set the collection method to OnEnter if you want pickup-on-contact.
• If pickups feel broken in multiplayer: Collectables fire on the local player's machine. If you walk into a Collectable and your friend doesn't see anything happen on their screen, that's normal — inventory is per-player. They'll see your spawned items appear when you use them.

Add Scorable

How It Works

Add Scorable creates a new scene GameObject with two parts: a U3DScorable component that holds and updates the score value, and a worldspace UI label that displays it. The label updates automatically whenever the score changes, so you don't need to wire it up yourself. Position the GameObject wherever you want the scoreboard to appear in the world — above a goal, on a wall, hovering over the playfield.

Each Scorable is independent. You can have several in one scene tracking different things — one for the player's total, one per zone, one per team, one per round.

Inspector Fields

• Score: The current score value. Edit at design time to set a starting score; modified at runtime as points come in.
• Score Label Prefix: Optional text shown before the number on the worldspace label. Defaults to "Score: " — change to "Coins: ", "Points: ", "Round 1 — ", or whatever fits your scene.
• Label Reference: The worldspace UI child created automatically. You can replace it with your own if you want a custom display.

Events

• OnScoreChanged: Fires whenever the score changes. Args: the new score value. Wire to sound effects, particle bursts, achievement triggers, or external UI.
• OnScoreReset: Fires when ResetScore is called from script or wired to an event.

Scripting

Public methods on U3DScorable:

• AddScore(int amount): Adds the given amount to the current score. Use with negative numbers to subtract.
• SetScore(int newScore): Sets the score to an exact value.
• ResetScore(): Sets the score back to 0 and fires OnScoreReset.

Check Your Work

• The label is a child of the Scorable GameObject. Move the parent, and the label moves with it. Rotate the parent to face the label toward where players will be.
• You can rename the GameObject freely. The Scorable doesn't look itself up by name — Make Scorable on a Collectable references the target directly via Inspector.
• Score is scene-local. Each Scorable tracks its own value, and that value doesn't persist between sessions. If you need persistence, capture the value at end-of-experience and store it via your own logic.

Make Scorable

How It Works

Make Scorable adds a U3DScorable component to the currently selected GameObject. Unlike Add Scorable, it doesn't create a worldspace label — use this when the selected object already has a display you've built yourself, or when you want a hidden score tracker that drives game logic without showing a number in the world.

Everything else works the same as Add Scorable: same Inspector fields (minus the label reference), same events, same scripting API.

When to Use This Instead of Add Scorable

• You've built a custom scoreboard UI and want the score data to drive it
• You want to track score without displaying it (hidden win-condition counter)
• You're attaching scoring to an object that already exists in your scene (a goal post, a target, a treasure chest)
• You want multiple Scorables consolidated onto a single display you'll wire up via OnScoreChanged events

Check Your Work

• No automatic label. If you used Make Scorable and expected a worldspace number to appear, you wanted Add Scorable instead. You can either swap or add a U3DWorldspaceUI child yourself and wire OnScoreChanged to update its text.
• Pairing with Collectables for "collect → score" flows. Wire the Collectable's OnCollected event to call AddScore(amount) on your Scorable. This is the standard pattern for arcade-style scoring (collect coins, score goes up).

Trash Handler

How It Works

Two tools in Creator Dashboard → Project Tools → Game Systems set this up. Add Trash Handler creates a new GameObject with a BoxCollider set to Is Trigger and a U3DTrashHandler component — use this when you're starting from scratch. Make Trash Handler adds U3DTrashHandler to an object you've already placed and sized in your scene — use this when you want to repurpose an existing collider volume. Either way, any physics object that enters the zone is destroyed or sent back to where it started, depending on the mode you configure.

Trash Handler works on two levels. The zone itself (U3DTrashHandler) handles what happens to things that enter it. A separate optional component (U3DDestroyable) is added to individual objects that need clean networked destruction, creator event hooks, or the ability to be destroyed by world bounds violations on physics interactables.

Two Modes

• Destroy: Objects that enter the zone are removed. If the entering object has a U3DDestroyable component, that component handles despawn correctly in multiplayer, with the OnDestroyed event firing before removal. Without U3DDestroyable, the zone falls back to direct destroy/despawn. Use this for score collectors, consumption zones, and floors that eat anything that falls off the map.
• Respawn: Objects that enter the zone are returned to their authored starting positions. U3D interactables (Throwable, Kickable, Pushable, Grabbable) are sent back via their own reset logic. An object the player is holding stays in hand instead of being sent back. To reset a held object, the player drops or throws it, and it's sent home when it enters the zone on its own. The player is teleported to the scene's U3DPlayerSpawnPoint — no additional setup required if the scene already has one (included in the U3D CORE - DO NOT DELETE prefab). Plain Rigidbody objects (no U3D interactable component) are teleported back to the position and rotation they had when the scene started, not wherever they may have settled under gravity after. Use this for out-of-bounds recovery zones and puzzle reset areas.

Target Object List

The Target Objects list controls what the zone acts on:

• Empty (default): The zone acts on any Rigidbody that enters it. This is the right default for a world-floor catcher — it catches everything.
• Populated: The zone acts only on the listed objects. Everything else passes through untouched. Use this when you want the zone to be selective — for example, a scoring collector that destroys only the specific gem prefabs that are worth points, and ignores the player or other objects that might cross it.

U3DDestroyable

Add a U3DDestroyable component to any object that should be destroyable — either by a Trash Handler zone or by falling out of world bounds on a physics interactable. Apply it via Creator Dashboard → Project Tools → Game Systems → Make Destroyable. It exposes one public method (RequestDestroy()) and one event (OnDestroyed), which fires before the object is removed. Wire OnDestroyed to spawn a particle effect, play a sound, update a score, or do anything else that should happen at the moment of destruction. The component handles multiplayer correctly — it requests state authority if needed before despawning, so destruction is clean in networked sessions.

destroyOnOutOfBounds (Kickable, Throwable, Pushable)

Kickable, Throwable, and Pushable each have a Destroy On Out Of Bounds toggle in their Inspector (Starting State section). When enabled, an object that violates its world bounds — falling below the floor threshold or traveling past the radius limit — calls RequestDestroy() on its U3DDestroyable component instead of respawning. U3DDestroyable is required for this to work; without it, the toggle logs a warning and the object respawns as normal.

Inspector Fields — U3DTrashHandler

• Mode: Destroy or Respawn, as described above.
• Target Objects: Optional list of specific objects this zone is intended to act on. Leave empty to act on all Rigidbodies.

Events

• OnDestroyed (on U3DDestroyable): Fires before the object is removed. Safe for spawning effects, updating score, or playing sounds — the object is still present when this fires.
• OnObjectDestroyed (on U3DTrashHandler): Fires when the zone destroys an object. Args: the destroyed GameObject.
• OnObjectRespawned (on U3DTrashHandler): Fires when the zone respawns an object. Args: the respawned GameObject.

Check Your Work

• The collider must be set to Is Trigger. Both Add and Make Trash Handler set this automatically. If you toggle it off, the zone stops working.
• Plain Rigidbody objects respawn to their scene-start transform, not their resting position. If an object dropped under gravity after the scene loaded and then entered the zone in Respawn mode, it goes back to where it was in the editor, not where it landed. This is intentional — it's the authored position, not a random settled spot.
• Destroy On Out Of Bounds requires U3DDestroyable. The toggle on Kickable, Throwable, and Pushable does nothing without it. A warning in the Console tells you if it's missing.
• Player respawn uses the existing U3DPlayerSpawnPoint. No new setup is required if the scene already has one. If your scene doesn't have a U3D Core prefab yet, add it first — see U3D CORE — DO NOT DELETE.
• The Target Objects list is an allowlist, not a blocklist. Populating it means only those specific objects are affected. If you want the zone to catch everything except certain objects, leave the list empty and add logic to those objects instead.
• A held object stays in the player's hand. Walking into a Respawn zone while carrying something respawns the player but leaves the held object in hand rather than sending it home. That's the intended behavior, since a held object isn't lost. To reset the object too, the player drops or throws it so it enters the zone on its own.

Planned Game Systems

Quest System

A structured way to define multi-step objectives with progress tracking and rewards. Quests will read from existing UnityEvents in the scene — Collectables, Scorables, triggers, and any custom event source can advance a quest step. A single-player version exists; the multiplayer-synced version is in progress.

Dialogue, Quiz, and NPC Tools

Branching dialogue trees, quiz sequences, and NPC conversation logic are planned. Designed to compose cleanly with quests and scoring — finishing a dialogue can complete a quest step, answering a quiz question correctly can add to a score.

Progress and Persistence

Checkpoint System for save-and-restore player progress, Achievement System for unlock-style milestones, and Progress Bar for visual indicators driven by any value source.

Pacing and Time

Timer System for countdown and stopwatch use cases — race modes, time-limited challenges, rhythm gameplay. Fires UnityEvents on start, tick, and completion.

Game Systems Examples

Working with Other U3D Systems

Pairing with Interactivity Tools

Game Systems are designed to compose with Interactivity Tools. The most common patterns:

• Collectable + Grabbable + Throwable: A gem you collect into inventory and throw at a target
• Trigger Zone + Scorable: A scoring zone that increments when objects enter
• Interact Trigger + Scorable: A button that adds to a score when pressed
• Collectable + Interact Trigger spell-style items: Inventory items that fire effects when used
• Trash Handler + Throwable/Kickable/Pushable: A floor or boundary zone that resets or destroys physics objects that leave the playfield

UnityEvent Integration

Every Game System exposes UnityEvents you can connect to your own scripts, sounds, particles, animations, or UI. The pattern is consistent: pickup/score/use/destroy → event fires → you decide what happens next. No custom scripting required for typical setups.

Multiplayer Considerations

Inventory is per-player; Scorables are scene-shared by default. U3DDestroyable handles networked object removal correctly from any client. If you need per-player scoring in multiplayer, you'll currently need to place multiple Scorables and assign them to players via your own logic. Per-player scoring built directly into Scorable is a planned feature.

🎮 Your game systems are operational! Combine Inventory, Collectables, Scoring, and Trash Handler with Interactivity Tools to build complete play experiences.

U3D CORE — DO NOT DELETE

What It Is

The U3D CORE prefab is required in every scene. It contains the networking manager, player spawning system, platform services, and the U3DPlayerSpawnPoint that Trash Handler uses for player respawn. Without it, multiplayer, player spawning, and several Game Systems features won't work.

Adding It to Your Scene

Go to Creator Dashboard → Project Tools → Game Systems → Add U3D Core Prefab. The tool checks for an existing instance before adding — running it twice won't create a duplicate.

The "DO NOT DELETE" Part

Deleting this prefab from a scene breaks networking and player spawning for everyone in that session. If you've accidentally removed it, use the dashboard tool to add it back.