🖥️ Computers

A system for creating in-game virtual computers that can run independently with their own operating systems and applications.

The Computers system is designed to support both:

  • Standalone in-world computers — interactive, self-contained devices that simulate real hardware + OS.
  • Game UI desktops — slick and flexible UI shells (DesktopEnvironment, UIWindowSystem, AppSystem, etc.) that provide a modern in-game interface for menus, HUDs, and apps.

✨ Features

  • Modular architecture where each Computer can have its own configuration, display, input, and operating system.

  • Support for multiple computers in one scene, each isolated but following the same base rules.

  • Extensible OperatingSystem layer with pluggable subsystems:

    • UIWindowSystem for windows, panels, and docking logic.
    • AppSystem for apps, processes, and task management.
    • ConsoleSystem for debugging or diegetic terminals.

  • Works both as diegetic devices (in-world monitors) and non-diegetic UI environments (main menus, HUD desktops).

📂 Module + Folder Structure

The system is split into modular namespaces under CosterGraphics.Computers. Each namespace corresponds to a subfolder, keeping runtime and editor code cleanly separated.

Computers/
 ├── Runtime/
 │    ├── Computer.cs                 # Core computer class (bootstrap + OS host)
 │    ├── ComputerDisplay.cs          # Display / screen binding
 │    ├── ComputerSpeaker.cs          # Audio output binding
 │    ├── OperatingSystem/
 │    │    ├── OperatingSystem.cs     # Base OS class
 │    │    ├── DesktopEnvironment.cs  # Handles UIWindowSystem
 │    │    ├── AppSystemHost.cs       # AppSystem integration
 │    │    ├── ConsoleSystemHost.cs   # ConsoleSystem integration
 │    │    └── ...
 │    └── Input/
 │         ├── KeyboardInput.cs
 │         ├── VirtualMouseInput.cs
 │         └── ...
 │
 └── Editor/
      ├── ComputerEditor.cs           # Inspector tooling
      └── Gizmos/                     # Debug visualization tools

This modular split ensures:

  • Each Computer instance is just a shell → you “plug in” display, input, and OS.
  • OperatingSystem can evolve independently (desktop-like, console-only, or experimental).
  • Easy to add new subsystems (e.g., networking, file systems, or narrative layers).

⚡ Boot Process Walkthrough

When a Computer is powered on in-game, it goes through a deterministic boot cycle similar to real-world hardware/OS startup:

  1. Initialization (Hardware Layer)

    • The Computer component initializes its connected devices:

      • ComputerDisplay (video output)
      • ComputerSpeaker (audio output)
      • Input bindings (KeyboardInput, VirtualMouseInput, XR input, etc.)

    • Debug messages or a “POST-like” (Power-On Self Test) log may be shown.

  2. Operating System Load

    • The OperatingSystem component is instantiated and attached.
    • Core subsystems are initialized (ConsoleSystemHost, AppSystemHost, etc.).
    • The system can show a boot sequence (text logs, loading visuals).

  3. Desktop Environment / Console Start

    • Depending on configuration:

      • DesktopEnvironment starts, spawning the UIWindowSystem and AppSystem.
      • ConsoleSystem is launched instead for text-only computers.

    • Subsystems register themselves with the OS for process and resource management.

  4. App Startup

    • Startup apps or services are launched (e.g., Task Manager, Start Menu, Network App).
    • System transitions to a ready state where the player can interact.

This lifecycle allows each Computer to behave like a self-contained machine, and makes it possible to support different “flavors” of computers (lightweight console-only, full desktop OS, kiosk mode, etc.).

🔄 Boot Process Diagram

flowchart TD
    A[💻 Computer Power On] --> B[🔧 Hardware Init]
    B --> C[🖥️ Display + 🎧 Speaker + ⌨️ Input Ready]
    C --> D[🪟 Operating System Load]
    D --> E[⚙️ Subsystems Init<br/>(ConsoleSystemHost, AppSystemHost...)]
    E --> F{Desktop or Console?}
    F -->|Desktop| G[🖼️ DesktopEnvironment<br/>UIWindowSystem + AppSystem]
    F -->|Console| H[🖥️ ConsoleSystem]
    G --> I[🚀 Startup Apps Launched]
    H --> I
    I --> J[✅ Ready for Player Interaction]

🧩 Namespace

CosterGraphics.Computers

🔗 Related Articles