Glossary
========

This glossary explains common terms and concepts used in the networking
library. Each entry is short, student-friendly, and tied to how the term
is implemented here.

.. glossary::

   Area
      A logical grouping of clients and objects used for **interest
      management**. Clients only receive updates for areas they belong to.
      Examples: a dungeon floor, a chat channel, or a scene.

   Authority
      The right to control the state of a networked object. In this library,
      authority is represented by **ownership**.

   Client
      A Unity project that connects to the server. Clients send player input
      and requests, and render authoritative updates from the server.

   ClientNetwork
      The component responsible for managing a client’s connection,
      instantiation of objects, RPCs, and sync messages.

   Delivery Method
      How a message is sent over the network. Can be reliable
      (guaranteed delivery, ordered) or unreliable (may drop older
      packets but ensures the newest one is processed). Controlled by
      ``UCNetwork.DeliveryMethod``.

   Destroy
      The removal of a networked object across the network. Only the owner
      (or the server) can request destruction.

   ID Pool
      A block of unique IDs given by the server to each client. Ensures
      instant local instantiation while keeping IDs globally unique.

   Instantiate
      The process of creating a new object on all clients at once. Done
      using ``ClientNetwork.Instantiate`` or ``ServerNetwork.Instantiate``.

   LiteSync
      A lightweight synchronization message containing only custom byte
      data (no transform). Useful for stats, animation states, or other
      small updates.

   MessageReceiver
      An enum that determines which machines should receive a message.
      Options include ServerOnly, AllClients, OtherClients, AllClientsInArea,
      OtherClientsInArea, and SingleClient.

   MessageType
      An integer code that specifies the type of message being sent (e.g.,
      RPC, SyncUpdate, Instantiate, Destroy). Defined in ``UCNetwork``.

   Networked Object
      A GameObject with a ``NetworkSync`` component. Has a unique network ID
      and participates in synchronization and RPC targeting.

   Network ID
      A globally unique integer assigned to every networked object. Used to
      map messages to objects.

   NetworkSync
      A Unity component that manages the networking behavior of a specific
      object (ID assignment, sync data, RPC routing, ownership callbacks).

   Ownership
      Which machine (server or client) currently controls a networked
      object. Owners send authoritative updates; replicas display them.
      Ownership can transfer when needed.

   ReliableOrdered
      A delivery method where messages are guaranteed to arrive and in
      the order sent. Used for critical actions like instantiating or
      destroying objects.

   RPC (Remote Procedure Call)
      A message that tells another machine to execute a specific method
      on a specific object. Best for discrete events like “OpenDoor” or
      “PlayAnimation.”

   Server
      The authoritative instance of the game. Runs ``ServerNetwork`` and
      manages all connected clients, object IDs, and areas.

   ServerNetwork
      The component responsible for handling client connections, ID
      allocation, synchronization forwarding, and validation.

   Sequence Channel
      A separate stream of ordered messages. Keeps different message
      categories from interfering. Example: channel 10 for Sync updates.

   SyncUpdate
      A synchronization message that includes position, rotation, and
      custom byte data. Used for continuous state (like movement).

   UCNetwork
      The abstract base class for both client and server networking
      components. Provides message loop, RPC serialization, ID tracking,
      and connection utilities.

   VoiceData
      A message type reserved for sending compressed voice samples.
      Stubbed out in this library; optional to implement later.