1

Been and Gone

A multiplayer shared 3D scene-building experience. Players take turns placing childhood memory objects into a scene, nudging it toward one of six endings through a hidden attribute system — helping a waiting soul recognize the world that's been, and gone. Built in Unity, playable in browser.

Website

Overview

Been and Gone is a shared 3D scene-building experience completed collectively by all online players in relay, built in Unity and playable in browser. Each player enters the scene left by the previous player, selects up to 5 items from a randomly refreshed inventory, and submits — with changes uploaded to a server in real time. Every item carries hidden attributes; the sum of all attributes in the scene determines which of six endings it trends toward, reflected through real-time visual changes (transparency, color, post-processing). The long-term goal is for all players collectively to liberate the souls waiting in each of the six scenes. I contributed to game mechanic design and was responsible for programming the room/scene system, transparency and visual change system, playback system, and the majority of player systems including inventory, item spawning, item identification, and the player item bar. Narrative writing and art were handled by other team members.

Problems Addressed

  • Async multiplayer state sync: Players are not in real-time sessions — each submission must accurately upload scene state to the server and restore it correctly for the next player, including conflict resolution when two players submit changes to the same scene concurrently.
  • Visual mapping of hidden attribute system: The sum of item attributes needed to be communicated to players perceptibly but non-explicitly — through post-processing visual effects rather than numerical UI.
  • Item identification and ending detection: The system needed to accurately identify all items' types and attributes at any point, compute scene similarity to each of the six endings, and drive visual changes and soul dialogue accordingly.
  • Playback system timeline reconstruction: The world view allows players to replay historical scene screenshots for each ending, requiring time-ordered screenshot sequence management and frame-by-frame rewind on hover.
  • Inventory random refresh and item bar management: The player inventory refreshes after each selection, requiring random draws of 5 items from the item pool while maintaining current selection state and placement logic.

Solution & Implementation

  • Room/scene system: Implemented scene item loading, saving, and submission logic with JSON serialization to the server. On game entry, the latest scene state is fetched and all item positions and attributes are restored. Conflict resolution appends the latest player's changes and removes the oldest items to maintain the 50-item cap.
  • Transparency and visual change system: Implemented real-time visual changes driven by the scene's cumulative attribute sum, including dynamic item transparency adjustment and volumetric fog and custom shader post-processing effects. Scene atmosphere shifts progressively as players collectively push toward an ending.
  • Playback system: Implemented historical screenshot playback for the six ending windows in the world view. Hovering replays screenshots in reverse chronological order, clicking freezes a frame, and leaving restores the latest state, with a light music fade-in effect.
  • Player inventory and item bar: Implemented random pool draw logic (5 items per refresh), with number key 1-5 selection and automatic refresh on pick. Managed current held item spawning, cursor-following float, distance adjustment via scroll wheel, and placement on toggle.
  • Item identification and attribute computation: Implemented type identification and hidden attribute accumulation for all scene items, computing real-time similarity scores against six endings as the data input driving the visual and soul dialogue systems.

Tech Stack

  • Engine: Unity
  • Language: C#
  • Backend: Custom server (Server advisor: Cetian)
  • Post-processing: Unity Post Processing Stack (volumetric fog, transparent materials, custom shaders)
  • Audio: FMOD (dynamic music, ending-driven)
  • Platform: HTML5 (browser-playable)
  • Version Control: GitHub

Key Features

  • Async multiplayer relay scene-building with all players editing the same scene
  • Hidden item attribute system driving six-ending similarity scores
  • Real-time visual changes (transparency, volumetric fog, post-processing shaders)
  • Random inventory refresh with number key item selection and placement
  • Item spawning, floating physics collision, and cursor-following placement
  • Six ending scenes, each with distinct childhood memory themes and soul characters
  • World view: six-window historical playback (hover rewind, click freeze)
  • Forgetting phase: relay-clicking items to dissolve them after an ending is reached
  • FMOD dynamic music shifting with ending progress and forgetting phase

Challenges & Tradeoffs

  • Simplified async conflict resolution: Concurrent submissions are handled by appending new changes and removing the oldest items rather than implementing OT (Operational Transformation), which is feasible within the development timeline but risks item loss under high concurrency — retained as a known tradeoff.
  • Perceptibility vs. opacity of the attribute system: Item attributes are fully hidden, with scene direction communicated only through visual changes — requiring careful shader parameter calibration between “change is noticeable enough to feel meaningful” and “doesn't expose the underlying numerical logic.”
  • Playback system's network dependency: Playback relies on server-side historical screenshot sequences and degrades under unstable network conditions. Submission/download stability was prioritized, with playback treated as a secondary feature in development priority.
  • Item limit implementation lag: The design specifies a 5-item-per-turn limit and 50-item scene cap, but the current build does not fully enforce these limits — disclosed on the itch page and reframed as open-ended play while the implementation catches up.

Results & Impact

The game is currently in active development and has been released on itch.io as a playable build, with any online player able to participate in scene-building in real time. All six ending scenes and their item systems have been designed, with the core async multiplayer submission, item attribute computation, and visual change systems functional. A Spring Showcase presentation is planned for May 2026.

Next Steps

  • Complete the item placement limit (5 per turn) and scene cap (50 items) logic, and refine concurrent submission conflict resolution.
  • Complete the dialogue system so souls provide progressive narrative cues based on the scene's current ending similarity score.
  • Complete full end-to-end playtesting across all six endings' relay and forgetting phases before Spring Showcase.