### NetworkManager Scene Setup Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Demonstrates how to instantiate and configure a NetworkManager node within a Godot scene, including setting up child nodes and network properties before starting a network mode.

```csharp
// Create a NetworkManager node with child nodes
var networkManager = new NetworkManager();
networkManager.Server = GetNode<NetworkServer>("Server");
networkManager.ServerObjectManager = GetNode<ServerObjectManager>("ServerObjectManager");
networkManager.Client = GetNode<NetworkClient>("Client");
networkManager.ClientObjectManager = GetNode<ClientObjectManager>("ClientObjectManager");
networkManager.SocketFactory = new UdpSocketFactory();
networkManager.MaxConnections = 100;

// Start the appropriate mode
networkManager.StartServer(); // or StartClient() or StartHost()
```

--------------------------------

### GameServer Node Setup and Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-server.md

Demonstrates how to set up and use the NetworkServer within a Godot Node. It covers initializing the server, setting up event listeners for player authentication and disconnection, starting the server, and manually updating message processing in the _Process loop.

```csharp
public class GameServer : Node
{
    private NetworkServer _server;
    private ServerObjectManager _objectManager;

    public override void _Ready()
    {
        _server = GetNode<NetworkServer>("NetworkServer");
        _objectManager = GetNode<ServerObjectManager>("ObjectManager");

        // Setup events
        _server.Started.AddListener(OnServerStarted);
        _server.Authenticated += OnPlayerAuthenticated;
        _server.Disconnected += OnPlayerDisconnected;
        
        // Start listening
        _server.Listen(7777);
    }

    private void OnServerStarted()
    {
        Debug.Log("Server started and listening!");
    }

    private void OnPlayerAuthenticated(NetworkPlayer player)
    {
        Debug.Log($"Player {player} authenticated");
        
        // Spawn player character
        var prefab = GD.Load<PackedScene>("res://Player.tscn");
        var character = prefab.Instantiate();
        AddChild(character);
        
        _objectManager.Spawn(character, player);
    }

    private void OnPlayerDisconnected(NetworkPlayer player)
    {
        Debug.Log($"Player {player} disconnected");
    }

    public override void _Process(double delta)
    {
        if (_server.Active)
        {
            _server.UpdateReceive();
            _server.UpdateSent();
        }
    }
}
```

--------------------------------

### StartHost

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Starts both the server and a local client, enabling host mode for single-player or cooperative gameplay.

```APIDOC
## StartHost

### Description
Starts both server and a local client (host mode). Useful for single-player or cooperative games where the host also participates.

### Method
`virtual void StartHost()`

### Parameters
None

### Returns
void

### Throws
None

### Example
```csharp
networkManager.StartHost();
```
```

--------------------------------

### NetworkClient Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-client.md

This C# example demonstrates how to set up and manage a NetworkClient instance within a Godot Node. It covers connecting to a server, handling various connection events, and updating the client's network state each frame. Ensure the NetworkClient node and its dependencies are correctly set up in the scene.

```csharp
public class GameClient : Node
{
    private NetworkClient _client;
    private ClientObjectManager _objectManager;
    private Label _statusLabel;

    public override void _Ready()
    {
        _client = GetNode<NetworkClient>("NetworkClient");
        _objectManager = GetNode<ClientObjectManager>("ObjectManager");
        _statusLabel = GetNode<Label>("StatusLabel");

        // Setup events
        _client.Started.AddListener(OnClientStarted);
        _client.Connected.AddListener(OnConnected);
        _client.Authenticated.AddListener(OnAuthenticated);
        _client.Disconnected.AddListener(OnDisconnected);
    }

    public void ConnectToServer(string address, ushort port)
    {
        Debug.Log($"Connecting to {address}:{port}");
        _client.Connect(address, port);
    }

    private void OnClientStarted()
    {
        _statusLabel.Text = "Connecting...";
    }

    private void OnConnected(NetworkPlayer player)
    {
        _statusLabel.Text = "Connected, authenticating...";
    }

    private void OnAuthenticated(NetworkPlayer player)
    {
        _statusLabel.Text = "Authenticated, ready to play!";
        Debug.Log("Authentication successful");
    }

    private void OnDisconnected(ClientStoppedReason reason)
    {
        _statusLabel.Text = $"Disconnected: {reason}";
        Debug.Log($"Disconnected: {reason}");
    }

    public override void _Process(double delta)
    {
        if (_client.Active)
        {
            _client.UpdateReceive();
            _client.UpdateSent();
        }
    }

    public override void _ExitTree()
    {
        if (_client.Active)
            _client.Disconnect();
    }
}
```

--------------------------------

### Start Host Mode

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Use this method to start the NetworkManager in host mode, simultaneously running as both a server and a local client. This is ideal for single-player or cooperative experiences.

```csharp
public virtual void StartHost()
{
    // ... implementation details ...
}
```

```csharp
networkManager.StartHost();
```

--------------------------------

### Player Spawner Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Example of spawning a player object and attaching an OnStartClient listener in a game manager or spawner script. This demonstrates dynamic object creation and event subscription.

```csharp
// In a game manager or spawner
public class PlayerSpawner
{
    public void SpawnPlayer(NetworkPlayer player)
    {
        var prefab = GD.Load<PackedScene>("res://Player.tscn");
        var instance = prefab.Instantiate<Node>();
        
        var identity = instance.GetNode<NetworkIdentity>(".");
        identity.OnStartClient.AddListener(() => {
            Debug.Log("Player spawned on client!");
        });
        
        GetTree().Root.AddChild(instance);
    }
}
```

--------------------------------

### Start Client Mode

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Use this method to configure the NetworkManager to act as a client, connecting to an existing server.

```csharp
public virtual void StartClient()
{
    // ... implementation details ...
}
```

```csharp
networkManager.StartClient();
```

--------------------------------

### Start Listening on a Port

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-server.md

Starts the NetworkServer to listen for incoming client connections on a specified port.

```csharp
server.Listen(7777);
```

--------------------------------

### NetworkBehaviour Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Example of setting up event listeners for NetworkIdentity events within a NetworkBehaviour script. Demonstrates server, client, and local player initialization.

```csharp
// In a NetworkBehaviour script
public class PlayerCharacter : NetworkBehaviour
{
    public override void _Ready()
    {
        // Access the NetworkIdentity
        var identity = Identity;
        
        // Setup event listeners
        identity.OnStartServer.AddListener(ServerStarted);
        identity.OnStartClient.AddListener(ClientStarted);
        identity.OnStartLocalPlayer.AddListener(LocalPlayerStarted);
    }

    private void ServerStarted()
    {
        Debug.Log($
```

--------------------------------

### Setup Commands for Mirage.Godot

Source: https://github.com/james-frowen/mirage.godot/blob/main/README.md

Execute these commands in your terminal to set up Mirage.Godot in your project. Adjust paths as necessary.

```sh
git clone git@github.com:James-Frowen/Mirage.Godot.git
cd Mirage.Godot
cp src/Mirage.Godot/Scripts "path/to/project/Mirage.Godot"
dotnet build src/Mirage.Core/Mirage.CodeGen/Mirage.CodeGen.csproj -o ./CodeGen
```

--------------------------------

### ClientObjectManager Setup

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/configuration.md

Configure the parent node for spawned objects and pre-load packed scenes for auto-registration on client startup.

```csharp
// In editor or code:
var clientManager = GetNode<ClientObjectManager>("ObjectManager");
clientManager.SpawnParent = GetNode("SpawnedObjects");
clientManager.PackedScenes = new[] 
{
    GD.Load<PackedScene>("res://prefabs/Player.tscn"),
    GD.Load<PackedScene>("res://prefabs/Enemy.tscn"),
    GD.Load<PackedScene>("res://prefabs/Pickup.tscn"),
};
```

--------------------------------

### Start Server in Host Mode

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-server.md

Starts the NetworkServer in host mode, integrating a local client and optionally specifying a port.

```csharp
server.StartHost(client, 7777);
```

--------------------------------

### StartServer

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Starts the server in server-only mode, allowing it to listen for incoming client connections.

```APIDOC
## StartServer

### Description
Starts the server in server-only mode. The server listens for client connections.

### Method
`virtual void StartServer()`

### Parameters
None

### Returns
void

### Throws
None

### Example
```csharp
networkManager.StartServer();
```
```

--------------------------------

### Listen

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-server.md

Starts listening for incoming client connections on a specified port.

```APIDOC
## Listen

### Description
Starts listening for incoming client connections.

### Method
`public void Listen(ushort port = 0)`

### Parameters
- **port** (ushort, optional): Port number. 0 = use any available port

### Returns
void

### Throws
InvalidOperationException if already listening

### Example
```csharp
server.Listen(7777);
```
```

--------------------------------

### PlayerBehaviour Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-behaviour.md

An example demonstrating how to access the NetworkIdentity within a custom NetworkBehaviour script to log the object's NetId.

```csharp
public class PlayerBehaviour : NetworkBehaviour
{
    public void PrintObjectId()
    {
        Debug.Log($
```

--------------------------------

### Basic Server Setup in Godot

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/README.md

Sets up a basic network server in Godot. Listen for incoming connections on a specified port and handle player authentication events.

```csharp
public class GameServer : Node
{
    public override void _Ready()
    {
        var server = GetNode<NetworkServer>("NetworkServer");
        server.Authenticated += (player) => Debug.Log($"Player {player} connected");
        server.Listen(7777);
    }

    public override void _Process(double delta)
    {
        var server = GetNode<NetworkServer>("NetworkServer");
        if (server.Active)
        {
            server.UpdateReceive();
            server.UpdateSent();
        }
    }
}
```

--------------------------------

### Player Spawner Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/object-managers.md

Demonstrates how to spawn a player character with ownership using ServerObjectManager. Requires a 'ServerObjectManager' node and a 'Player.tscn' prefab.

```csharp
public class PlayerSpawner : Node
{
    private ServerObjectManager _objectManager;

    public override void _Ready()
    {
        _objectManager = GetNode<ServerObjectManager>("ServerObjectManager");
    }

    public void SpawnPlayerCharacter(NetworkPlayer player)
    {
        var prefab = GD.Load<PackedScene>("res://Player.tscn");
        var character = prefab.Instantiate();
        AddChild(character);
        
        // Spawn with ownership
        _objectManager.Spawn(character as Node, player);
    }

    public void SpawnPickup(Vector3 position)
    {
        var prefab = GD.Load<PackedScene>("res://Pickup.tscn");
        var pickup = prefab.Instantiate<Node3D>();
        pickup.Position = position;
        AddChild(pickup);
        
        _objectManager.Spawn(pickup);
    }
}
```

--------------------------------

### Basic Client Setup in Godot

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/README.md

Establishes a basic network client connection in Godot. Connect to a server at a given address and port, and log connection events.

```csharp
public class GameClient : Node
{
    public override void _Ready()
    {
        var client = GetNode<NetworkClient>("NetworkClient");
        client.Authenticated.AddListener((player) => Debug.Log("Connected!"));
        client.Connect("localhost", 7777);
    }

    public override void _Process(double delta)
    {
        var client = GetNode<NetworkClient>("NetworkClient");
        if (client.Active)
        {
            client.UpdateReceive();
            client.UpdateSent();
        }
    }
}
```

--------------------------------

### Server Started Event Listener

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-server.md

Adds a listener to the Started event to execute code when the server begins.

```csharp
server.Started.AddListener(() => {
    Debug.Log("Server started!");
});
```

--------------------------------

### Start Server Mode

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Use this method to initiate the NetworkManager in server-only mode, enabling it to listen for incoming client connections.

```csharp
public virtual void StartServer()
{
    // ... implementation details ...
}
```

```csharp
networkManager.StartServer();
```

--------------------------------

### SyncVar Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/attributes.md

Demonstrates how to use the SyncVar attribute with various properties like hooks, initialOnly, and invokeHookOnOwner.

```csharp
public class PlayerBehaviour : NetworkBehaviour
{
    [SyncVar(hook = nameof(OnHealthChanged))]
    public int Health = 100;

    private void OnHealthChanged(int oldHealth, int newHealth)
    {
        Debug.Log($
```

```csharp
[SyncVar(initialOnly = true)]
    public string PlayerName;

    [SyncVar(invokeHookOnOwner = true)]
    public bool IsAlive = true;
}
```

--------------------------------

### Game Manager Example with Object Spawning

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/object-managers.md

Demonstrates spawning player characters and environmental pickups upon player authentication using ServerObjectManager. Requires NetworkServer and ServerObjectManager nodes.

```csharp
public class GameManager : Node
{
    private NetworkServer _server;
    private ServerObjectManager _objectManager;

    public override void _Ready()
    {
        _server = GetNode<NetworkServer>("NetworkServer");
        _objectManager = GetNode<ServerObjectManager>("ObjectManager");
        
        _server.Authenticated += OnPlayerAuthenticated;
    }

    private void OnPlayerAuthenticated(NetworkPlayer player)
    {
        // Spawn character for player
        var prefab = GD.Load<PackedScene>("res://Player.tscn");
        var character = prefab.Instantiate<Node>();
        GetTree().Root.AddChild(character);
        
        _objectManager.Spawn(character, player);
        
        // Spawn environmental objects
        SpawnPickups();
    }

    private void SpawnPickups()
    {
        var pickupPrefab = GD.Load<PackedScene>("res://Pickup.tscn");
        
        Vector3[] pickupPositions = new Vector3[]
        {
            Vector3.Zero,
            new Vector3(5, 0, 0),
            new Vector3(-5, 0, 0)
        };

        foreach (var pos in pickupPositions)
        {
            var pickup = pickupPrefab.Instantiate<Node3D>();
            pickup.Position = pos;
            GetTree().Root.AddChild(pickup);
            
            _objectManager.Spawn(pickup);
        }
    }
}
```

--------------------------------

### ServerRpc Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/attributes.md

Shows how to use the ServerRpc attribute to invoke methods on the server from clients, with options for channel and authority.

```csharp
public class PlayerBehaviour : NetworkBehaviour
{
    [ServerRpc(channel = Channel.Reliable, requireAuthority = true)]
    public void CmdAttack(Vector3 targetPos)
    {
        Debug.Log($"Player attacking at {targetPos}");
    }

    [ServerRpc(requireAuthority = false)]
    public void CmdRequestData()
    {
    }
}
```

--------------------------------

### Start Server in Server-Only Mode

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-server.md

Initiates the NetworkServer to run in a server-only mode, without a local client.

```csharp
server.StartServer();
```

--------------------------------

### Player Network Behaviour Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-behaviour.md

Demonstrates how to use SyncVars for health and player name, ServerRPC for taking damage, and ClientRPC for death animation. Includes accessing NetworkIdentity and handling SyncVar hooks.

```csharp
public class PlayerBehaviour : NetworkBehaviour
{
    [SyncVar(hook = nameof(OnHealthChanged))]
    public int Health = 100;

    [SyncVar]
    public string PlayerName;

    [SyncVar(initialOnly = true)]
    public uint PlayerId;

    private void OnHealthChanged(int oldHealth, int newHealth)
    {
        Debug.Log($
```

--------------------------------

### SyncSet Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/sync-collections.md

Demonstrates how to use SyncSet to manage a collection of unique network IDs for group members. Only the server should modify the SyncSet directly.

```csharp
public class PlayerGroup : NetworkBehaviour
{
    private SyncSet<uint> memberNetIds = new SyncSet<uint>();

    [ServerRpc]
    public void CmdJoinGroup(uint playerNetId)
    {
        if (IsServer)
        {
            memberNetIds.Add(playerNetId);
        }
    }

    [ServerRpc]
    public void CmdLeaveGroup(uint playerNetId)
    {
        if (IsServer)
        {
            memberNetIds.Remove(playerNetId);
        }
    }

    public bool IsMember(uint playerNetId)
    {
        return memberNetIds.Contains(playerNetId);
    }
}
```

--------------------------------

### Scene Loading Preparation

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/errors.md

Ensure scene loading issues are resolved by calling PrepareToSpawnSceneObjects() before loading. Verify client readiness and scene ID setup.

```csharp
public class SceneManager : Node
{
    private ClientObjectManager _objectManager;

    public void LoadScene(string scenePath)
    {
        _objectManager.PrepareToSpawnSceneObjects();
    }
}
```

--------------------------------

### SyncList<T> Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/sync-collections.md

Demonstrates how to use SyncList<T> in an InventoryManager, including setting up event handlers for item additions and removals, and using ServerRpc for modifying the list.

```csharp
public class InventoryManager : NetworkBehaviour
{
    private SyncList<string> items = new SyncList<string>();

    public override void _Ready()
    {
        base._Ready();
        
        // Setup events
        items.OnInsert += OnItemAdded;
        items.OnRemove += OnItemRemoved;
    }

    private void OnItemAdded(int index, string item)
    {
        Debug.Log($
```

--------------------------------

### ClientRpc Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/attributes.md

Illustrates using the ClientRpc attribute to send method calls from the server to clients, with options for target and exclusion.

```csharp
public class PlayerBehaviour : NetworkBehaviour
{
    [ClientRpc(target = RpcTarget.Observers)]
    public void RpcPlayAttackAnimation(string animName)
    {
        GetNode<AnimationPlayer>("AnimationPlayer").Play(animName);
    }

    [ClientRpc(target = RpcTarget.Owner)]
    public void RpcShowGameOver(bool won)
    {
        if (won) Debug.Log("You won!");
    }

    [ClientRpc(target = RpcTarget.Player, excludeOwner = true)]
    public void RpcDamagePlayer(NetworkPlayer player, int damage)
    {
    }
}
```

--------------------------------

### SyncDictionary<TKey, TValue> Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/sync-collections.md

Illustrates the use of SyncDictionary<TKey, TValue> in a PlayerStatsManager, showing how to handle stat changes and updates via ServerRpc.

```csharp
public class PlayerStatsManager : NetworkBehaviour
{
    private SyncDictionary<string, int> playerStats = new SyncDictionary<string, int>();

    public override void _Ready()
    {
        base._Ready();
        playerStats.OnSet += OnStatChanged;
        playerStats.OnInsert += OnStatAdded;
    }

    private void OnStatAdded(string statName, int value)
    {
        Debug.Log($        }          
```

--------------------------------

### Clone Mirage.Godot Repository with Symlinks

Source: https://github.com/james-frowen/mirage.godot/blob/main/README.md

Use this command to clone the repository while preserving symlinks, which is necessary for the development setup.

```sh
git clone -c core.symlinks=true git@github.com:James-Frowen/Mirage.Godot.git
```

--------------------------------

### NetworkReader Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Demonstrates deserializing various data types including int, string, Vector3, and Color using NetworkReader.

```csharp
public class MessageDeserialization
{
    public void DeserializePlayerMessage(byte[] data)
    {
        using (var reader = NetworkReaderPool.GetReader(data))
        {
            int playerId = reader.Read<int>();
            string name = reader.Read<string>();
            Vector3 position = reader.Read<Vector3>();
            Color color = reader.Read<Color>();
        }
    }
}
```

--------------------------------

### Synchronized Health System Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/INDEX.md

Implement a health system using a SyncVar with a hook method. A ServerRpc is used to handle incoming damage requests from clients.

```csharp
[SyncVar(hook=nameof(OnHealthChanged))] public int Health;

public void OnHealthChanged(int oldHealth, int newHealth) {
    // Update health bar or other UI elements
}

[ServerRpc]
public void CmdTakeDamage(int amount) {
    Health -= amount;
}
```

--------------------------------

### NetworkWriter Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Demonstrates serializing various data types including primitives, Godot types, and arrays using NetworkWriter.

```csharp
public class MessageSerialization
{
    public void SerializePlayerMessage()
    {
        using (var writer = NetworkWriterPool.GetWriter())
        {
            // Write primitive types
            writer.Write(123); // int
            writer.Write("Player Name"); // string
            
            // Write Godot types
            writer.Write(Vector3.One);
            writer.Write(Color.White);
            
            // Write arrays
            var positions = new Vector3[] { Vector3.Zero, Vector3.One };
            writer.Write(positions);
            
            // Get the serialized bytes
            byte[] data = writer.ToArray();
        }
    }
}
```

--------------------------------

### Enable Detailed Logging in Mirage.Godot

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/errors.md

To get more insights into the network's behavior, enable debug-level logging. This snippet shows how to access and configure the `MirageLogSettings` node.

```csharp
var mirageLogSettings = GetNode<MirageLogSettings>("LogSettings");
mirageLogSettings.Level = LogLevel.Debug;
```

--------------------------------

### Rebuild Mirage.CodeGen Project During Development

Source: https://github.com/james-frowen/mirage.godot/blob/main/README.md

Add this command to the start of your PostBuild targets when developing locally to ensure the Mirage.CodeGen project is rebuilt before execution.

```xml
<Exec Command="dotnet build $(ProjectDir)/../Mirage.Core/Mirage.CodeGen/Mirage.CodeGen.csproj -c Release" />
```

--------------------------------

### Synchronized Position Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/INDEX.md

Use a SyncVar to synchronize a Vector3 position across the network. This is useful for updating player or object positions.

```csharp
[SyncVar] public Vector3 Position;
```

--------------------------------

### Network Message and RPC Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Defines a custom network message struct and demonstrates sending state updates via ServerRpc and broadcasting state via ClientRpc using NetworkWriter. Ensure to use NetworkWriterPool for efficient allocation.

```csharp
[NetworkMessage]
public struct CharacterStateMessage
{
    public uint NetId;
    public Vector3 Position;
    public Vector3 Velocity;
    public float Health;
    public int Score;
}

public class NetworkCharacter : NetworkBehaviour
{
    [SyncVar]
    public Vector3 Position;
    
    [SyncVar]
    public float Health;

    [ServerRpc]
    public void CmdUpdateState(Vector3 pos, Vector3 vel, float health)
    {
        Position = pos;
        Health = health;
    }

    [ClientRpc]
    public void RpcBroadcastState()
    {
        using (var writer = NetworkWriterPool.GetWriter())
        {
            writer.Write(Identity.NetId);
            writer.Write(Position);
            writer.Write(Vector3.Zero); // velocity
            writer.Write(Health);
            writer.Write(0); // score
            
            byte[] data = writer.ToArray();
            // Send to other clients
        }
    }
}
```

--------------------------------

### SyncStack Usage Example

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/sync-collections.md

Illustrates the use of SyncStack for managing a Last-In, First-Out collection, such as a dialogue history. Ensure the server checks for empty stacks before popping.

```csharp
public class DialogueManager : NetworkBehaviour
{
    private SyncStack<string> dialogueStack = new SyncStack<string>();

    [ServerRpc]
    public void CmdPushDialogue(string text)
    {
        if (IsServer)
        {
            dialogueStack.Push(text);
        }
    }

    [ServerRpc]
    public void CmdPopDialogue()
    {
        if (IsServer && dialogueStack.Count > 0)
        {
            dialogueStack.Pop();
        }
    }
}
```

--------------------------------

### Complex Synced State Management

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/sync-collections.md

An example demonstrating the management of multiple synchronized collections (SyncList, SyncDictionary, SyncSet) to represent complex game state. Event handlers are set up for observing changes.

```csharp
public class GameState : NetworkBehaviour
{
    // Synchronized collections
    private SyncList<uint> activePlayers = new SyncList<uint>();
    private SyncDictionary<uint, int> playerScores = new SyncDictionary<uint, int>();
    private SyncSet<string> enabledPowerups = new SyncSet<string>();

    public override void _Ready()
    {
        base._Ready();
        
        // Setup event handlers
        activePlayers.OnInsert += (idx, netId) => Debug.Log($"Player {netId} joined");
        activePlayers.OnRemove += (idx, netId) => Debug.Log($"Player {netId} left");
        
        playerScores.OnSet += (netId, oldScore, newScore) => 
            Debug.Log($"Player {netId} score: {oldScore} -> {newScore}");
        
        enabledPowerups.OnInsert += (_, powerup) => Debug.Log($"Powerup active: {powerup}");
    }

    [ServerRpc]
    public void CmdAddPlayer(uint netId)
    {
        if (IsServer && !activePlayers.Contains(netId))
        {
            activePlayers.Add(netId);
            playerScores[netId] = 0;
        }
    }

    [ServerRpc]
    public void CmdRemovePlayer(uint netId)
    {
        if (IsServer)
        {
            activePlayers.Remove(netId);
            playerScores.Remove(netId);
        }
    }

    [ServerRpc]
    public void CmdAddScore(uint netId, int amount)
    {
        if (IsServer && playerScores.TryGetValue(netId, out var current))
        {
            playerScores[netId] = current + amount;
        }
    }
}
```

--------------------------------

### OnStartClient Event

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Event fired when this NetworkIdentity object becomes active on a client. SyncVar values are guaranteed to be initialized with server state at this point, making it suitable for client-side setup.

```APIDOC
## OnStartClient

### Description
Event fired when this object becomes active on a client. SyncVar values are guaranteed to be initialized with server state at this point.

### Event Signature
`public IAddLateEvent OnStartClient { get; }`
```

--------------------------------

### Custom ServerObjectManager ID Generator

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/configuration.md

Implement a custom INetIdGenerator for the ServerObjectManager to provide unique network IDs. This example uses an auto-incrementing counter starting from a large number.

```csharp
public class CustomNetIdGenerator : Node, INetIdGenerator
{
    private uint _nextId = 1000000;

    public uint GenerateNetId()
    {
        return _nextId++;
    }
}

// Setup
var objectManager = GetNode<ServerObjectManager>("ObjectManager");
objectManager.NetIdGenerator = GetNode<CustomNetIdGenerator>("IdGenerator");
```

--------------------------------

### StartClient

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-manager.md

Initiates the client to connect to a running server.

```APIDOC
## StartClient

### Description
Starts the client and connects to the server.

### Method
`virtual void StartClient()`

### Parameters
None

### Returns
void

### Throws
None

### Example
```csharp
networkManager.StartClient();
```
```

--------------------------------

### NetworkPlayer Identity Property

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-player.md

Gets the primary NetworkIdentity of the character owned by this player, if one exists.

```csharp
public NetworkIdentity Identity { get; }
```

--------------------------------

### Configure NetworkClient in Godot Editor

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/configuration.md

Sets up NetworkClient properties and initiates a connection to a server, including custom network configurations.

```csharp
public class ClientSetup : Node
{
    public override void _Ready()
    {
        var client = GetNode<NetworkClient>("NetworkClient");
        var config = new Config 
        {
            DisconnectTimeout = 30,
            SendRate = 0.05f 
        };
        client.PeerConfig = config;
        client.Connect("localhost", 7777);
    }
}
```

--------------------------------

### NetworkIdentity Property

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-behaviour.md

Gets the NetworkIdentity associated with this NetworkBehaviour. This is crucial for identifying the networked object the behaviour is attached to.

```APIDOC
## NetworkIdentity Property

### Description
Gets the NetworkIdentity for the object this behaviour is attached to. Automatically searches up the node hierarchy if not cached.

### Type
NetworkIdentity

### Example
```csharp
public class PlayerBehaviour : NetworkBehaviour
{
    public void PrintObjectId()
    {
        Debug.Log($"My NetId is {Identity.NetId}");
    }
}
```
```

--------------------------------

### Instantiate Network Configuration

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/configuration.md

Creates an instance of the Config class and assigns values to its properties for server-side network settings.

```csharp
var config = new Config 
{
    MaxConnections = 100,
    SendRate = 0.1f,
    SerializationTickRate = 0.1f,
    DisconnectTimeout = 60f
};
server.PeerConfig = config;
```

--------------------------------

### Check if Client is Local Host

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-client.md

Use IsLocalClient to identify if this NetworkClient instance is running as the host in a local multiplayer setup.

```csharp
public bool IsLocalClient { get; }
```

--------------------------------

### Client Connect Method

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-client.md

Initiates a connection to a NetworkServer. Optionally specify the address and port; otherwise, defaults are used. Throws InvalidOperationException if already connecting or connected.

```csharp
public void Connect(string address = null, ushort? port = null)
```

```csharp
client.Connect("192.168.1.100", 7777);
```

--------------------------------

### Configuration

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Allows configuration of spawn settings and the root node for the networked object.

```APIDOC
## Configuration

### SpawnSettings

```csharp
public NetworkSpawnSettings SpawnSettings { get; set; }
```

Settings controlling how this object spawns on clients.

**Type:** NetworkSpawnSettings

---

### Root

```csharp
public Node Root { get; }
```

The root node of this object's hierarchy (defaults to self).

**Type:** Node
```

--------------------------------

### NetworkReaderPool Class and Usage

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Manages a pool of NetworkReader instances. Provides methods to get a reader with specified data and offset/size, and to recycle readers.

```csharp
public static class NetworkReaderPool
{
    public static NetworkReader GetReader(byte[] data)
    public static NetworkReader GetReader(byte[] data, int offset, int size)
    public static void Recycle(NetworkReader reader)
}

using (var reader = NetworkReaderPool.GetReader(data))
{
    int value = reader.Read<int>();
    string text = reader.Read<string>();
} // Automatically recycled
```

--------------------------------

### Configure NetworkServer in Godot Editor

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/configuration.md

Sets up NetworkServer properties directly within the Godot editor or via script, including metrics, exceptions, and listening behavior.

```csharp
public class ServerSetup : Node
{
    public override void _Ready()
    {
        var server = GetNode<NetworkServer>("NetworkServer");
        var config = new Config { MaxConnections = 256 };
        server.PeerConfig = config;
        server.EnablePeerMetrics = true;
        server.MetricsSize = 12; // ~68 seconds at 60hz
        server.Listening = true;
        server.Listen(7777);
    }
}
```

--------------------------------

### NetworkReaderPool

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Manages a pool of NetworkReader instances to reduce garbage allocation. Provides methods to get a reader with specified data and offset/size, and to recycle readers.

```APIDOC
## NetworkReaderPool

Manages a pool of NetworkReader instances.

```csharp
public static class NetworkReaderPool
{
    public static NetworkReader GetReader(byte[] data)
    public static NetworkReader GetReader(byte[] data, int offset, int size)
    public static void Recycle(NetworkReader reader)
}
```

**Usage:**
```csharp
using (var reader = NetworkReaderPool.GetReader(data))
{
    int value = reader.Read<int>();
    string text = reader.Read<string>();
} // Automatically recycled
```
```

--------------------------------

### NetworkIdentity OnStartServer Event

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Event fired when this object becomes active on the server. Used to perform server-specific initialization.

```csharp
public IAddLateEvent OnStartServer { get; }
```

```csharp
var identity = GetNode<NetworkIdentity>(".");
identity.OnStartServer.AddListener(() => {
    Debug.Log("Object spawned on server!");
});
```

--------------------------------

### NetworkWriterPool

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Manages a pool of NetworkWriter instances to reduce garbage allocation. Provides methods to get a writer, recycle it, and configure the maximum packet size.

```APIDOC
## NetworkWriterPool

Manages a pool of NetworkWriter instances to reduce garbage allocation.

```csharp
public static class NetworkWriterPool
{
    public static NetworkWriter GetWriter()
    public static void Recycle(NetworkWriter writer)
    public static void Configure(int maxPacketSize)
}
```

**Usage:**
```csharp
// Get a writer from the pool
using (var writer = NetworkWriterPool.GetWriter())
{
    writer.Write(42);
    writer.Write("hello");
    
    byte[] data = writer.ToArray();
} // Automatically recycled
```
```

--------------------------------

### Add Listener for Client Authentication

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/errors.md

Use this to ensure client-side operations, like loading initial scenes, are performed only after the client has been authenticated and is ready. This prevents race conditions where objects might be processed before the client is fully prepared.

```csharp
client.Authenticated.AddListener((player) =>
{
    // Player is authenticated and ready
    // Now safe to load initial scenes
    LoadStartScene();
});
```

--------------------------------

### Mirage.Godot API Reference Overview

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/COMPLETION_SUMMARY.txt

This section provides an overview of the API reference documents generated for Mirage.Godot. It details the scope and content coverage of the documentation, including exported functions, classes, attributes, configuration, synchronization, RPCs, object management, serialization, error handling, and message systems.

```APIDOC
## Mirage.Godot API Reference

### Description
This documentation covers the public API surface of the Mirage.Godot C# networking library. It includes details on exported functions, methods, classes, types, attributes, configuration options, synchronization mechanisms, Remote Procedure Calls (RPCs), object management, serialization, error handling, and the message system.

### API Reference Documents

- **attributes.md**: Documentation for SyncVar, ServerRpc, and ClientRpc attributes.
- **network-manager.md**: Details on the main orchestration component.
- **network-behaviour.md**: Information on the base class for networked objects.
- **network-identity.md**: Covers object identity and lifecycle management.
- **network-server.md**: API reference for server-side networking.
- **network-client.md**: API reference for client-side networking.
- **network-player.md**: Documentation for the connection representation.
- **serialization.md**: Details on NetworkWriter and Reader APIs.
- **sync-collections.md**: Information on synchronized containers (List, Dict, Set, Stack).
- **object-managers.md**: Covers object spawning and management.

### Content Coverage

- **Exported Functions & Methods**: Full signatures, parameter types, return types, usage examples, and source file references.
- **Classes & Types**: Public classes, enums, structs, and interfaces with detailed descriptions.
- **Attributes & Decorators**: Documentation for decorator attributes, parameter options, hook types, and usage patterns.
- **Configuration Options**: NetworkServer and NetworkClient configurations, socket factory options, performance tuning, and config class parameters.
- **Synchronization System**: SyncVar attribute, sync collections, dirty tracking, serialization flow, and hook mechanisms.
- **RPC System**: ServerRpc and ClientRpc attributes, RpcTarget enum, and authority-based invocation.
- **Object Management**: NetworkIdentity lifecycle, NetworkBehaviour component system, spawn/despawn workflow, and ownership model.
- **Serialization**: NetworkWriter and NetworkReader APIs, object pooling, and supported types.
- **Error Handling**: Custom exception types, common error scenarios, debugging strategies, and recovery patterns.
- **Message System**: Built-in message types, NetworkMessage attribute, custom message creation, and handler patterns.

### Documentation Quality

- **Clear Structure**: Consistent formatting, logical organization, and easy navigation.
- **Complete Signatures**: Full method signatures, parameter tables, return types, and exception specifications.
- **Practical Examples**: Real-world code samples and common patterns.
- **Source References**: File paths and line numbers for traceability.
- **Cross-linking**: References between related documentation sections.
```

--------------------------------

### Godot Project .csproj Configuration

Source: https://github.com/james-frowen/mirage.godot/blob/main/README.md

Include these changes in your Godot project's main .csproj file to integrate Mirage.Godot. This includes build targets for code generation.

```xml
<PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <EnableDynamicLoading>true</EnableDynamicLoading>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
  </PropertyGroup>
  <ItemGroup>
    <ProjectReference Include="..\Mirage.Godot\src\Mirage.Core\Mirage.Logging\Mirage.Logging.csproj" />
    <ProjectReference Include="..\Mirage.Godot\src\Mirage.Core\Mirage.SocketLayer\Mirage.SocketLayer.csproj" />
  </ItemGroup>
  <Target Name="PostBuild" AfterTargets="PostBuildEvent">
    <Exec Command="dotnet build ..\Mirage.Godot\src\Mirage.Core\Mirage.CodeGen\Mirage.CodeGen.csproj -c Release" />
    <Exec Condition=" '$(OS)' == 'Windows_NT' " Command="..\Mirage.Godot\src\Mirage.Core\Mirage.CodeGen\bin\Release\net8.0\Mirage.CodeGen.exe $(TargetPath) -force" />
    <Exec Condition=" '$(OS)' == 'Unix' " Command="..\Mirage.Godot\src\Mirage.Core\Mirage.CodeGen\bin\Release\net8.0\Mirage.CodeGen $(TargetPath) -force" />
    <Error Condition="$(ExitCode) == 1" />
  </Target>
  <Target Name="PrePublish" BeforeTargets="Publish">
    <Exec Command="dotnet build ..\Mirage.Godot\src\Mirage.Core\Mirage.CodeGen\Mirage.CodeGen.csproj -c Release" />
    <Exec Condition=" '$(OS)' == 'Windows_NT' " Command="..\Mirage.Godot\src\Mirage.Core\Mirage.CodeGen\bin\Release\net8.0\Mirage.CodeGen.exe $(PublishDir)$(TargetFileName) $(TargetDir) -force" />
    <Exec Condition=" '$(OS)' == 'Unix' " Command="..\Mirage.Godot\src\Mirage.Core\Mirage.CodeGen\bin\Release\net8.0\Mirage.CodeGen $(PublishDir)$(TargetFileName) $(TargetDir) -force" />
    <Error Condition="$(ExitCode) == 1" />
  </Target>
```

--------------------------------

### Register Prefabs for Network Spawning

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/object-managers.md

Register prefabs with the ClientObjectManager to make them available for network spawning. This is typically done in the _Ready function of a Node.

```csharp
public class PrefabRegistry : Node
{
    private ClientObjectManager _objectManager;

    public override void _Ready()
    {
        _objectManager = GetNode<ClientObjectManager>("ObjectManager");
        
        // Register prefabs manually
        var playerPrefab = GD.Load<PackedScene>("res://Player.tscn");
        var enemyPrefab = GD.Load<PackedScene>("res://Enemy.tscn");
        
        _objectManager.RegisterPrefab(playerPrefab);
        _objectManager.RegisterPrefab(enemyPrefab);
    }
}
```

--------------------------------

### Connect

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-client.md

Connects to a server at the specified address and port. Uses SocketFactory defaults if not specified.

```APIDOC
## Connect (Overloads)

### Description
Connects to a server at the specified address and port. Uses SocketFactory defaults if not specified.

### Method
public void Connect(string address = null, ushort? port = null)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```csharp
client.Connect("192.168.1.100", 7777);
```

### Response
#### Success Response
void

#### Response Example
None

### Throws
InvalidOperationException if already connecting/connected
```

--------------------------------

### NetworkWriterPool Class and Usage

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/serialization.md

Manages a pool of NetworkWriter instances to reduce garbage allocation. Provides methods to get a writer, recycle it, and configure max packet size.

```csharp
public static class NetworkWriterPool
{
    public static NetworkWriter GetWriter()
    public static void Recycle(NetworkWriter writer)
    public static void Configure(int maxPacketSize)
}

// Get a writer from the pool
using (var writer = NetworkWriterPool.GetWriter())
{
    writer.Write(42);
    writer.Write("hello");
    
    byte[] data = writer.ToArray();
} // Automatically recycled
```

--------------------------------

### MirageLogSettings Configuration

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/configuration.md

Configure logging settings for Mirage, including the log level, whether to log to a file, and the log file path.

```csharp
public class MirageLogSettings
{
    public LogLevel Level { get; set; }
    public bool LogToFile { get; set; }
    public string LogFilePath { get; set; }
}

// Enable in code:
var logSettings = GetNode<MirageLogSettings>("LogSettings");
logSettings.Level = LogLevel.Debug;
logSettings.LogToFile = true;
logSettings.LogFilePath = "user://mirage.log";
```

--------------------------------

### Enemy Spawner Script

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/README.md

This C# script demonstrates how to spawn enemies in a Godot game using Mirage. It handles object instantiation, positioning, and registration with the server's object manager.

```csharp
public class EnemySpawner : Node
{
    private ServerObjectManager _objectManager;

    public override void _Ready()
    {
        _objectManager = GetNode<ServerObjectManager>("ObjectManager");
    }

    public void SpawnEnemy(Vector3 position)
    {
        var prefab = GD.Load<PackedScene>("res://Enemy.tscn");
        var enemy = prefab.Instantiate<Node>();
        enemy.Position = position;
        AddChild(enemy);

        _objectManager.Spawn(enemy);
    }
}
```

--------------------------------

### SocketFactory Abstract Class

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/types.md

Abstract factory for creating network sockets, providing methods to create client and server sockets, get connection endpoints, and determine maximum packet size.

```APIDOC
## SocketFactory Abstract Class

### Description
Abstract factory for creating network sockets, providing methods to create client and server sockets, get connection endpoints, and determine maximum packet size.

### Abstract Methods
- **CreateClientSocket()** (ISocket)
- **CreateServerSocket()** (ISocket)
- **GetConnectEndPoint(string address = null, ushort? port = null)** (EndPoint)

### Abstract Properties
- **MaxPacketSize** (int)
```

--------------------------------

### OnStartServer Event

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Event fired when this NetworkIdentity object becomes active on the server. This is useful for initializing server-specific logic when an object is spawned.

```APIDOC
## OnStartServer

### Description
Event fired when this object becomes active on the server.

### Event Signature
`public IAddLateEvent OnStartServer { get; }`

### Usage Example
```csharp
var identity = GetNode<NetworkIdentity>(".");
identity.OnStartServer.AddListener(() => {
    Debug.Log("Object spawned on server!");
});
```
```

--------------------------------

### Registering Prefabs Programmatically

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/errors.md

Register prefabs programmatically if not done in the editor. Ensure the ClientObjectManager is accessible.

```csharp
public override void _Ready()
{
    var clientManager = GetNode<ClientObjectManager>("ObjectManager");
    
    // Register in editor (preferred)
    clientManager.PackedScenes = new[] 
    {
        GD.Load<PackedScene>("res://Player.tscn"),
        GD.Load<PackedScene>("res://Enemy.tscn")
    };
    
    // OR register programmatically
    clientManager.RegisterPrefab(GD.Load<PackedScene>("res://Projectile.tscn"));
}
```

--------------------------------

### Prepare Scene Objects for Spawning

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/object-managers.md

Registers all NetworkIdentities present in the current scene as spawnable. This should be called after a new scene has been loaded on a connected client.

```csharp
public class SceneManager : Node
{
    private ClientObjectManager _objectManager;

    public async void LoadScene(string scenePath)
    {
        // Load the scene
        var scene = await GD.Load<PackedScene>(scenePath).Instantiate<Node>();
        AddChild(scene);
        
        // Register scene objects for network spawning
        _objectManager.PrepareToSpawnSceneObjects();
    }
}
```

--------------------------------

### DynamicSpawnHandlerDelegate Delegate

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/types.md

Dynamic handler for custom spawn logic. It takes a prefab hash and returns a GameObject.

```csharp
public delegate GameObject DynamicSpawnHandlerDelegate(int prefabHash);
```

--------------------------------

### Add Mirage.Godot Code Generation to CSPROJ

Source: https://github.com/james-frowen/mirage.godot/blob/main/README.md

Integrates Mirage.Godot's code generation into the build process by adding PostBuild and PrePublish targets to your csproj file. Ensure the path to Mirage.CodeGen.exe is correctly set.

```xml
<Target Name="PostBuild" AfterTargets="PostBuildEvent">
  <Exec Condition=" '$(OS)' == 'Windows_NT' " Command="path/to/Mirage.CodeGen.exe $(TargetPath) -force" />
  <Exec Condition=" '$(OS)' == 'Unix' " Command="path/to/Mirage.CodeGen $(TargetPath) -force" />
  <Error Condition="$(ExitCode) == 1" />
</Target>
<Target Name="PrePublish" BeforeTargets="Publish">
  <Exec Condition=" '$(OS)' == 'Windows_NT' " Command="path/to/Mirage.CodeGen.exe $(PublishDir)$(TargetFileName) $(TargetDir) -force" />
  <Exec Condition=" '$(OS)' == 'Unix' " Command="path/to/Mirage.CodeGen $(PublishDir)$(TargetFileName) $(TargetDir) -force" />
  <Error Condition="$(ExitCode) == 1" />
</Target>
```

--------------------------------

### ClientObjectManager.PrepareToSpawnSceneObjects

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/object-managers.md

Registers all NetworkIdentities in the current scene as spawnable. This should be called after loading a scene on a connected client.

```APIDOC
## PrepareToSpawnSceneObjects

### Description
Registers all NetworkIdentities present in the current scene as spawnable network objects. This method should be invoked after a new scene has been loaded on a connected client to ensure all scene objects are recognized for network spawning.

### Method
- `PrepareToSpawnSceneObjects()`

### Parameters
None

### Response
#### Success Response (200)
None

### Response Example
```json
{}
```
```

--------------------------------

### Mirage.Godot File Organization

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/README.md

This tree structure outlines the organization of the Mirage.Godot project, detailing the core networking library and Godot-specific scripts.

```tree
mirage.godot/
    ├── src/
│   │   ├── Mirage.Core/              # Core networking library
│   │   │   ├── Mirage.SocketLayer/   # Transport abstraction
│   │   │   ├── Mirage.Logging/       # Logging system
│   │   │   └── Mirage.CodeGen/       # IL weaver for code generation
│   │   │
│   │   └── Mirage.Godot/
│   │       └── Scripts/
│   │           ├── Attributes/       # [SyncVar], [ServerRpc], etc.
│   │           ├── Objects/          # NetworkIdentity, NetworkBehaviour
│   │           ├── Components/       # NetworkServer, NetworkClient, etc.
│   │           ├── Messages/         # Network message types
│   │           ├── Serialization/    # NetworkWriter/Reader
│   │           ├── Syncing/          # SyncVar system, collections
│   │           ├── RemoteCalls/      # RPC system
│   │           ├── Authentication/   # Auth system
│   │           ├── Events/           # Event system
│   │           ├── Logging/          # Logging components
│   │           └── Utils/            # Utility classes
│
    └── README.md
```

--------------------------------

### NetworkIdentity OnStartLocalPlayer Event

Source: https://github.com/james-frowen/mirage.godot/blob/main/_autodocs/api-reference/network-identity.md

Event fired when this object becomes the local player. Called after OnStartClient. Appropriate place to enable local-only features like cameras and input handling.

```csharp
public IAddLateEvent OnStartLocalPlayer { get; }
```