Example - Unity NGO

Netcode for GameObjects Integration

This guide walks you through integrating Enemy Masses with Unity's Netcode for GameObjects (NGO) for multiplayer gameplay, including RTS, co-op, and horde-style games.

---

Prerequisites

• Unity 6 LTS or newer

• Netcode for GameObjects package (com.unity.netcode.gameobjects)

• Enemy Masses 1.4.0+

// Package Manager
com.unity.netcode.gameobjects: 2.7.0+

---

Game Mode Considerations

Enemy Masses supports different multiplayer game types with varying synchronization strategies:

RTS / Strategy Games

• Players control specific factions — ownership validation required

• Commands synced — move, attack, stop commands sent to server

• Moderate position sync — periodic corrections (0.2-0.5s intervals)

• Strict validation — verify ownership and reasonable distances

Co-op / Horde / Survivor Games (e.g., Vampire Survivors-style)

• All enemies are AI-controlled — server owns all enemies

• Player positions synced — enemies target nearest synced player

• High position sync rate — frequent updates (0.1s) for smooth enemy movement

• Relaxed validation — generous distance tolerances for hit detection

Key Architecture Difference

Approach	Best For	Server Role	Client Role
Command-Based	RTS	Validates & executes commands	Sends commands, receives corrections
Position-Sync	Co-op/Horde	Runs all AI, broadcasts positions	Visual-only for enemies, sends player pos

Important: Unity's NavMeshAgent is not deterministic across machines. For games needing accurate hit validation (distance checks, facing, etc.), the server should run the simulation and broadcast positions. Clients should not run independent enemy AI simulations and expect them to match.

---

Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                    Your Game Server                         │
│  ┌─────────────────────────────────────────────────────┐   │
│  │           NGONetworkAuthority (Server)               │   │
│  │  - Validates all damage/commands                     │   │
│  │  - Owns spawn authority                              │   │
│  │  - Runs anti-cheat systems                           │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                              │
                    [RPCs / NetworkVariables]
                              │
┌─────────────────────────────────────────────────────────────┐
│                    Client Instances                         │
│  ┌─────────────────────────────────────────────────────┐   │
│  │           NGONetworkAuthority (Client)               │   │
│  │  - Sends requests to server                          │   │
│  │  - Applies local prediction                          │   │
│  │  - Receives authoritative state                      │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

---

Step 1: Create the Network Authority Implementation

Create a new script that implements INetworkAuthorityProvider using NGO:

using System.Collections;
using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;
using Arawn.EnemyMasses.Runtime;
using Arawn.EnemyMasses.Runtime.Networking;

namespace YourGame.Networking
{
    /// <summary>
    /// Netcode for GameObjects implementation of Enemy Masses network authority.
    /// Attach this to a NetworkObject that exists in every scene.
    /// </summary>
    public class NGONetworkAuthority : NetworkBehaviour, INetworkAuthorityProvider
    {
        public static NGONetworkAuthority Instance { get; private set; }

        // Interface implementations
        public bool IsServer => NetworkManager.Singleton?.IsServer ?? false;
        public bool IsClient => NetworkManager.Singleton?.IsClient ?? false;
        public bool IsHost => NetworkManager.Singleton?.IsHost ?? false;
        public int LocalPlayerId => (int)(NetworkManager.Singleton?.LocalClientId ?? 0);

        // Sub-authorities
        public INetworkDamageAuthority DamageAuthority { get; private set; }
        public INetworkCommandAuthority CommandAuthority { get; private set; }
        public INetworkSpawnAuthority SpawnAuthority { get; private set; }
        public INetworkStateSync StateSync { get; private set; }
        public INetworkOwnership Ownership { get; private set; }

        // Network ID counter (server only)
        private uint _nextNetworkId = 1;

        private void Awake()
        {
            if (Instance != null && Instance != this)
            {
                Destroy(gameObject);
                return;
            }
            Instance = this;
        }

        public override void OnNetworkSpawn()
        {
            base.OnNetworkSpawn();

            // Initialize sub-authorities
            DamageAuthority = new NGODamageAuthority(this);
            CommandAuthority = new NGOCommandAuthority(this);
            SpawnAuthority = new NGOSpawnAuthority(this);
            StateSync = new NGOStateSync(this);
            Ownership = new NGOOwnership(this);

            // Register as the global authority provider
            NetworkAuthorityProvider.Instance = this;

            // Subscribe to client connections for late-joiner sync
            if (IsServer)
            {
                NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnected;
            }
        }

        public override void OnNetworkDespawn()
        {
            if (NetworkAuthorityProvider.Instance == this)
            {
                NetworkAuthorityProvider.Instance = null;
            }
            
            if (NetworkManager.Singleton != null)
            {
                NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnected;
            }
            
            base.OnNetworkDespawn();
        }

        /// <summary>
        /// Called when a new client connects. Sends full game state to late-joiners.
        /// </summary>
        private void OnClientConnected(ulong clientId)
        {
            if (!IsServer) return;
            
            // Skip the host's own connection
            if (clientId == NetworkManager.Singleton.LocalClientId) return;
            
            // Send full state after a short delay to ensure client is ready
            StartCoroutine(SendLateJoinerState(clientId));
        }

        private System.Collections.IEnumerator SendLateJoinerState(ulong clientId)
        {
            yield return new WaitForSeconds(0.5f);
            SendFullStateToClient(clientId);
            Debug.Log($"[NGONetworkAuthority] Sent full state to late-joiner {clientId}");
        }

        /// <summary>
        /// Sends full game state to a newly connected client.
        /// </summary>
        public void SendFullStateToClient(ulong clientId)
        {
            if (!IsServer) return;

            var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
            if (controller == null) return;

            var agents = controller.GetAgents();
            var fullState = new List<AgentFullState>();

            for (int i = 0; i < agents.Count; i++)
            {
                var agent = agents[i];
                if (agent == null || agent.networkId == 0) continue;

                var transform = agent.navMeshAgent?.transform;
                
                fullState.Add(new AgentFullState
                {
                    networkId = agent.networkId,
                    factionIndex = agent.factionIndex,
                    position = transform?.position ?? Vector3.zero,
                    rotation = transform?.rotation ?? Quaternion.identity,
                    health = agent.health,
                    isDead = agent.isDead,
                    ownerPlayerId = agent.ownerPlayerId
                });

                // Send in batches
                if (fullState.Count >= 50)
                {
                    SendFullStateBatchRpc(fullState.ToArray(), RpcTarget.Single(clientId, RpcTargetUse.Temp));
                    fullState.Clear();
                }
            }

            if (fullState.Count > 0)
            {
                SendFullStateBatchRpc(fullState.ToArray(), RpcTarget.Single(clientId, RpcTargetUse.Temp));
            }
        }

        [Rpc(SendTo.SpecifiedInParams)]
        private void SendFullStateBatchRpc(AgentFullState[] states, RpcParams rpcParams = default)
        {
            ApplyFullStateBatch(states);
        }

        private void ApplyFullStateBatch(AgentFullState[] states)
        {
            var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
            if (controller == null) return;

            foreach (var state in states)
            {
                // Try to find existing agent
                var agents = controller.GetAgents();
                int existingIndex = -1;
                
                for (int i = 0; i < agents.Count; i++)
                {
                    if (agents[i]?.networkId == state.networkId)
                    {
                        existingIndex = i;
                        break;
                    }
                }
                
                if (existingIndex >= 0)
                {
                    // Update existing agent
                    var agent = agents[existingIndex];
                    if (agent?.navMeshAgent != null)
                    {
                        agent.navMeshAgent.Warp(state.position);
                        agent.navMeshAgent.transform.rotation = state.rotation;
                    }
                    agent.health = state.health;
                    agent.isDead = state.isDead;
                    agent.ownerPlayerId = state.ownerPlayerId;
                    
                    if (state.isDead)
                    {
                        controller.TriggerDeathVisuals(existingIndex);
                    }
                }
                else
                {
                    // Spawn new agent
                    var spawnedIndices = controller.SpawnAgents(
                        state.factionIndex, 1, state.position, FormationType.None, 1f
                    );
                    
                    if (spawnedIndices.Count > 0)
                    {
                        int newIndex = spawnedIndices[0];
                        var agent = controller.GetAgents()[newIndex];
                        
                        agent.networkId = state.networkId;
                        if (agent.navMeshAgent != null)
                        {
                            agent.navMeshAgent.Warp(state.position);
                            agent.navMeshAgent.transform.rotation = state.rotation;
                        }
                        agent.health = state.health;
                        agent.isDead = state.isDead;
                        agent.ownerPlayerId = state.ownerPlayerId;
                        
                        if (state.isDead)
                        {
                            controller.TriggerDeathVisuals(newIndex);
                        }
                    }
                }
            }
            
            Debug.Log($"[NGONetworkAuthority] Applied full state batch ({states.Length} agents)");
        }

        /// <summary>
        /// Checks if this client has authority over an agent.
        /// Server always has authority; clients only for agents they own.
        /// </summary>
        public bool IsNetworkAuthoritative(CrowdAgent agent)
        {
            if (agent == null) return false;
            
            // Server is authoritative over everything
            if (IsServer) return true;
            
            // Clients are authoritative over their own agents (for prediction)
            return agent.ownerPlayerId == LocalPlayerId;
        }

        /// <summary>
        /// Generates a unique network ID (server only).
        /// </summary>
        public uint GenerateNetworkId()
        {
            if (!IsServer)
            {
                Debug.LogError("[NGONetworkAuthority] Only server can generate network IDs!");
                return 0;
            }
            return _nextNetworkId++;
        }
    }

    /// <summary>
    /// Full agent state for late-joiner synchronization and position sync.
    /// </summary>
    [System.Serializable]
    public struct AgentFullState : INetworkSerializable
    {
        public uint networkId;
        public int factionIndex;
        public Vector3 position;
        public Quaternion rotation;
        public float health;
        public bool isDead;
        public int ownerPlayerId;

        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
        {
            serializer.SerializeValue(ref networkId);
            serializer.SerializeValue(ref factionIndex);
            serializer.SerializeValue(ref position);
            serializer.SerializeValue(ref rotation);
            serializer.SerializeValue(ref health);
            serializer.SerializeValue(ref isDead);
            serializer.SerializeValue(ref ownerPlayerId);
        }
    }
}

---

Step 2: Implement Damage Authority

Handle damage validation and synchronization:

using Unity.Netcode;
using UnityEngine;
using Arawn.EnemyMasses.Runtime.Networking;

namespace YourGame.Networking
{
    public class NGODamageAuthority : INetworkDamageAuthority
    {
        private readonly NGONetworkAuthority _authority;
        private readonly NetworkDamageValidator _validator;
        private uint _damageSequence;

        public event System.Action<DamageEventData> OnDamageApplied;
        public event System.Action<DamageEventData, DamageRejectReason> OnDamageRejected;

        public NGODamageAuthority(NGONetworkAuthority authority)
        {
            _authority = authority;
            
            // Initialize validator with game-appropriate settings
            // 
            // FOR RTS GAMES (strict validation):
            // _validator = new NetworkDamageValidator(
            //     maxDamagePerHit: 500f,
            //     maxDPS: 300f,
            //     maxAttackRange: 5f,        // Tight range
            //     attackCooldown: 0.3f,
            //     distanceTolerance: 1f      // Small tolerance
            // );
            //
            // FOR CO-OP/HORDE GAMES (relaxed validation):
            _validator = new NetworkDamageValidator(
                maxDamagePerHit: 500f,
                maxDPS: 300f,
                maxAttackRange: 25f,         // Generous range
                attackCooldown: 0.3f,
                distanceTolerance: 5f        // Large tolerance for network delay
            );
            
            // The distanceTolerance accounts for position sync delay.
            // In co-op games where server broadcasts positions at 0.1s intervals,
            // clients may be slightly behind - the tolerance prevents false rejections.
        }

        public int LocalPlayerId => _authority.LocalPlayerId;
        
        public uint GetNextDamageSequence() => ++_damageSequence;

        public bool ValidateDamage(DamageEventData data)
        {
            // Only server validates
            if (!_authority.IsServer)
                return true; // Client assumes valid for prediction

            var request = new DamageRequest
            {
                attackerNetworkId = data.attackerNetworkId,
                targetNetworkId = data.targetNetworkId,
                damage = data.damage,
                damageType = data.damageType,
                attackerPosition = data.attackerPosition,
                targetPosition = data.targetPosition,
                requestingPlayerId = data.sourcePlayerId,
                timestamp = Time.time
            };

            var result = _validator.ValidateDamageRequest(request);
            
            if (!result.isValid)
            {
                OnDamageRejected?.Invoke(data, result.reason);
                return false;
            }

            return true;
        }

        public bool OnDamageRequest(DamageEventData data)
        {
            if (_authority.IsServer)
            {
                // Server: validate and broadcast
                if (ValidateDamage(data))
                {
                    BroadcastDamageToClients(data);
                    OnDamageApplied?.Invoke(data);
                    return true;
                }
                return false;
            }
            else
            {
                // Client: send to server
                SendDamageRequestToServer(data);
                return true; // Predict locally
            }
        }

        private void SendDamageRequestToServer(DamageEventData data)
        {
            // Use NGO RPC to send to server
            _authority.RequestDamageRpc(
                data.attackerNetworkId,
                data.targetNetworkId,
                data.damage,
                (int)data.damageType,
                data.attackerPosition,
                data.targetPosition
            );
        }

        private void BroadcastDamageToClients(DamageEventData data)
        {
            _authority.ApplyDamageRpc(
                data.attackerNetworkId,
                data.targetNetworkId,
                data.damage,
                data.targetPosition
            );
        }
    }
}

---

Step 3: Add RPCs to Network Authority

Add the RPC methods to NGONetworkAuthority:

// Add to NGONetworkAuthority class:

#region Damage RPCs

[Rpc(SendTo.Server)]
public void RequestDamageRpc(uint attackerId, uint targetId, float damage, 
    int damageType, Vector3 attackerPos, Vector3 targetPos, RpcParams rpcParams = default)
{
    int senderId = (int)rpcParams.Receive.SenderClientId;
    
    var data = new DamageEventData
    {
        attackerNetworkId = attackerId,
        targetNetworkId = targetId,
        damage = damage,
        damageType = (DamageType)damageType,
        attackerPosition = attackerPos,
        targetPosition = targetPos,
        sourcePlayerId = senderId
    };

    // Validate and apply through damage authority
    if (DamageAuthority.ValidateDamage(data))
    {
        // Apply damage on server
        ApplyDamageLocally(data);
        
        // Broadcast to all clients
        ApplyDamageRpc(attackerId, targetId, damage, targetPos);
    }
    else
    {
        // Send rejection to requesting client
        RejectDamageRpc(RpcTarget.Single(rpcParams.Receive.SenderClientId, RpcTargetUse.Temp), attackerId, targetId);
    }
}

[Rpc(SendTo.NotServer)]
public void ApplyDamageRpc(uint attackerId, uint targetId, float damage, Vector3 hitPoint)
{
    // Find target agent and apply authoritative damage
    var combatSystem = FindFirstObjectByType<EnemyMassesCombatSystem>();
    combatSystem?.ApplyServerDamage(targetId, damage, attackerId, hitPoint);
}

[Rpc(SendTo.SpecifiedInParams)]
public void RejectDamageRpc(RpcParams rpcParams, uint attackerId, uint targetId)
{
    // Rollback predicted damage
    var combatSystem = FindFirstObjectByType<EnemyMassesCombatSystem>();
    combatSystem?.RollbackDamage(targetId);
}

private void ApplyDamageLocally(DamageEventData data)
{
    var combatSystem = FindFirstObjectByType<EnemyMassesCombatSystem>();
    combatSystem?.ApplyServerDamage(data.targetNetworkId, data.damage, 
        data.attackerNetworkId, data.targetPosition);
}

#endregion

---

Step 4: Implement Command Authority

Handle RTS commands (move, attack, stop):

using Unity.Netcode;
using UnityEngine;
using System.Collections.Generic;
using Arawn.EnemyMasses.Runtime.Networking;

namespace YourGame.Networking
{
    public class NGOCommandAuthority : INetworkCommandAuthority
    {
        private readonly NGONetworkAuthority _authority;
        private readonly NetworkCommandValidator _validator;
        private uint _commandSequence;

        public event System.Action<MoveCommandData> OnMoveCommandValidated;
        public event System.Action<AttackCommandData> OnAttackCommandValidated;
        public event System.Action<StopCommandData> OnStopCommandValidated;

        public NGOCommandAuthority(NGONetworkAuthority authority)
        {
            _authority = authority;
            _validator = new NetworkCommandValidator(
                maxCommandsPerSecond: 30,
                maxAgentsPerCommand: 200,
                maxCommandRange: 500f
            );
        }

        public int LocalPlayerId => _authority.LocalPlayerId;
        public uint GetNextCommandSequence() => ++_commandSequence;

        public bool OnMoveCommand(MoveCommandData command)
        {
            if (_authority.IsServer)
            {
                // Server: validate and execute
                var result = _validator.ValidateMoveCommand(
                    command.playerId,
                    command.agentNetworkIds,
                    command.destination,
                    ValidateAgentOwnership
                );

                if (result == CommandRejectReason.None)
                {
                    OnMoveCommandValidated?.Invoke(command);
                    _authority.BroadcastMoveCommandRpc(
                        command.agentNetworkIds,
                        command.destination,
                        (int)command.formation,
                        command.formationSpacing,
                        command.facingDirection
                    );
                    return true;
                }
                return false;
            }
            else
            {
                // Client: send to server, predict locally
                _authority.RequestMoveCommandRpc(
                    command.agentNetworkIds,
                    command.destination,
                    (int)command.formation,
                    command.formationSpacing,
                    command.facingDirection
                );
                return true; // Predict
            }
        }

        public bool OnAttackCommand(AttackCommandData command)
        {
            if (_authority.IsServer)
            {
                var result = _validator.ValidateAttackCommand(
                    command.playerId,
                    command.agentNetworkIds,
                    command.targetNetworkId,
                    ValidateAgentOwnership
                );

                if (result == CommandRejectReason.None)
                {
                    OnAttackCommandValidated?.Invoke(command);
                    _authority.BroadcastAttackCommandRpc(
                        command.agentNetworkIds,
                        command.targetNetworkId,
                        command.targetIndex
                    );
                    return true;
                }
                return false;
            }
            else
            {
                _authority.RequestAttackCommandRpc(
                    command.agentNetworkIds,
                    command.targetNetworkId,
                    command.targetIndex
                );
                return true;
            }
        }

        public bool OnStopCommand(StopCommandData command)
        {
            if (_authority.IsServer)
            {
                var result = _validator.ValidateStopCommand(
                    command.playerId,
                    command.agentNetworkIds,
                    ValidateAgentOwnership
                );

                if (result == CommandRejectReason.None)
                {
                    OnStopCommandValidated?.Invoke(command);
                    _authority.BroadcastStopCommandRpc(
                        command.agentNetworkIds,
                        command.holdPosition
                    );
                    return true;
                }
                return false;
            }
            else
            {
                _authority.RequestStopCommandRpc(
                    command.agentNetworkIds,
                    command.holdPosition
                );
                return true;
            }
        }

        private bool ValidateAgentOwnership(uint networkId, int playerId)
        {
            // Look up agent and check ownership
            var agent = FindAgentByNetworkId(networkId);
            return agent != null && agent.ownerPlayerId == playerId;
        }

        private CrowdAgent FindAgentByNetworkId(uint networkId)
        {
            var controller = Object.FindFirstObjectByType<EnemyMassesCrowdController>();
            return controller?.GetAgentByNetworkId(networkId);
        }
    }
}

---

Step 5: Add Command RPCs

Add these RPCs to NGONetworkAuthority:

// Add to NGONetworkAuthority class:

#region Command RPCs

[Rpc(SendTo.Server)]
public void RequestMoveCommandRpc(uint[] agentIds, Vector3 destination, 
    int formation, float spacing, Vector3 facing, RpcParams rpcParams = default)
{
    int senderId = (int)rpcParams.Receive.SenderClientId;
    
    var command = new MoveCommandData
    {
        agentNetworkIds = agentIds,
        destination = destination,
        formation = (FormationType)formation,
        formationSpacing = spacing,
        facingDirection = facing,
        playerId = senderId
    };

    CommandAuthority.OnMoveCommand(command);
}

[Rpc(SendTo.NotServer)]
public void BroadcastMoveCommandRpc(uint[] agentIds, Vector3 destination, 
    int formation, float spacing, Vector3 facing)
{
    // Find RTS controller and execute
    var rtsController = FindFirstObjectByType<EnemyMassesRTSController>();
    var agentIndices = ConvertNetworkIdsToIndices(agentIds);
    rtsController?.ExecuteServerMoveCommand(agentIndices, destination, 
        (FormationType)formation, spacing, facing);
}

[Rpc(SendTo.Server)]
public void RequestAttackCommandRpc(uint[] agentIds, uint targetId, 
    int targetIndex, RpcParams rpcParams = default)
{
    int senderId = (int)rpcParams.Receive.SenderClientId;
    
    var command = new AttackCommandData
    {
        agentNetworkIds = agentIds,
        targetNetworkId = targetId,
        targetIndex = targetIndex,
        playerId = senderId
    };

    CommandAuthority.OnAttackCommand(command);
}

[Rpc(SendTo.NotServer)]
public void BroadcastAttackCommandRpc(uint[] agentIds, uint targetId, int targetIndex)
{
    var rtsController = FindFirstObjectByType<EnemyMassesRTSController>();
    var agentIndices = ConvertNetworkIdsToIndices(agentIds);
    rtsController?.ExecuteServerAttackCommand(agentIndices, targetIndex);
}

[Rpc(SendTo.Server)]
public void RequestStopCommandRpc(uint[] agentIds, bool holdPosition, 
    RpcParams rpcParams = default)
{
    int senderId = (int)rpcParams.Receive.SenderClientId;
    
    var command = new StopCommandData
    {
        agentNetworkIds = agentIds,
        holdPosition = holdPosition,
        playerId = senderId
    };

    CommandAuthority.OnStopCommand(command);
}

[Rpc(SendTo.NotServer)]
public void BroadcastStopCommandRpc(uint[] agentIds, bool holdPosition)
{
    var rtsController = FindFirstObjectByType<EnemyMassesRTSController>();
    var agentIndices = ConvertNetworkIdsToIndices(agentIds);
    rtsController?.ExecuteServerStopCommand(agentIndices, holdPosition);
}

private List<int> ConvertNetworkIdsToIndices(uint[] networkIds)
{
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    var indices = new List<int>();
    
    foreach (uint id in networkIds)
    {
        int index = controller?.GetAgentIndexByNetworkId(id) ?? -1;
        if (index >= 0)
            indices.Add(index);
    }
    
    return indices;
}

#endregion

---

Step 6: Implement Spawn Authority

Handle synchronized agent spawning:

using Unity.Netcode;
using UnityEngine;
using Arawn.EnemyMasses.Runtime.Networking;

namespace YourGame.Networking
{
    public class NGOSpawnAuthority : INetworkSpawnAuthority
    {
        private readonly NGONetworkAuthority _authority;

        public event System.Action<SpawnEventData> OnAgentSpawned;
        public event System.Action<uint, DespawnReason> OnAgentDespawned;

        public NGOSpawnAuthority(NGONetworkAuthority authority)
        {
            _authority = authority;
            
            // Subscribe to Enemy Masses spawn events
            var controller = Object.FindFirstObjectByType<EnemyMassesCrowdController>();
            if (controller != null)
            {
                controller.NetworkEventAgentSpawned += HandleLocalSpawn;
                controller.NetworkEventAgentDied += HandleLocalDeath;
            }
        }

        public bool RequestSpawn(SpawnRequestData request, out uint assignedNetworkId)
        {
            assignedNetworkId = 0;

            if (!_authority.IsServer)
            {
                // Clients must request spawns from server
                _authority.RequestSpawnRpc(
                    request.crowdIndex,
                    request.position,
                    request.rotation,
                    request.requestingPlayerId
                );
                return false; // Don't spawn locally yet
            }

            // Server: generate ID and spawn
            assignedNetworkId = _authority.GenerateNetworkId();
            return true;
        }

        public bool RequestDespawn(uint networkId, DespawnReason reason)
        {
            if (!_authority.IsServer)
            {
                _authority.RequestDespawnRpc(networkId, (int)reason);
                return false;
            }

            // Server: despawn and broadcast
            _authority.BroadcastDespawnRpc(networkId, (int)reason);
            OnAgentDespawned?.Invoke(networkId, reason);
            return true;
        }

        private void HandleLocalSpawn(SpawnEventData data)
        {
            if (_authority.IsServer)
            {
                // Broadcast to clients
                _authority.BroadcastSpawnRpc(
                    data.networkId,
                    data.crowdIndex,
                    data.position,
                    data.rotation,
                    data.ownerPlayerId
                );
                OnAgentSpawned?.Invoke(data);
            }
        }

        private void HandleLocalDeath(DeathEventData data)
        {
            if (_authority.IsServer)
            {
                _authority.BroadcastDeathRpc(
                    data.victimNetworkId,
                    data.killerNetworkId,
                    data.deathPosition,
                    data.useRagdoll
                );
            }
        }
    }
}

---

Step 7: Add Spawn RPCs

// Add to NGONetworkAuthority class:

#region Spawn RPCs

[Rpc(SendTo.Server)]
public void RequestSpawnRpc(int crowdIndex, Vector3 position, 
    Quaternion rotation, int ownerPlayerId, RpcParams rpcParams = default)
{
    // Validate spawn request
    // (Add your validation logic here)
    
    uint networkId = GenerateNetworkId();
    
    // Spawn on server
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    controller?.SpawnAgent(crowdIndex, position, rotation, networkId, ownerPlayerId);
}

[Rpc(SendTo.NotServer)]
public void BroadcastSpawnRpc(uint networkId, int crowdIndex, 
    Vector3 position, Quaternion rotation, int ownerPlayerId)
{
    // Spawn on client with server-assigned ID
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    controller?.SpawnAgent(crowdIndex, position, rotation, networkId, ownerPlayerId);
}

[Rpc(SendTo.Server)]
public void RequestDespawnRpc(uint networkId, int reason, 
    RpcParams rpcParams = default)
{
    int senderId = (int)rpcParams.Receive.SenderClientId;
    
    // Validate ownership
    var agent = FindAgentByNetworkId(networkId);
    if (agent == null || agent.ownerPlayerId != senderId)
        return;
    
    SpawnAuthority.RequestDespawn(networkId, (DespawnReason)reason);
}

[Rpc(SendTo.NotServer)]
public void BroadcastDespawnRpc(uint networkId, int reason)
{
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    controller?.DespawnAgentByNetworkId(networkId);
}

[Rpc(SendTo.NotServer)]
public void BroadcastDeathRpc(uint victimId, uint killerId, 
    Vector3 deathPos, bool useRagdoll)
{
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    var agent = controller?.GetAgentByNetworkId(victimId);
    if (agent != null)
    {
        agent.SetDeadAuthoritative(true);
        // Trigger death visuals
    }
}

private CrowdAgent FindAgentByNetworkId(uint networkId)
{
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    return controller?.GetAgentByNetworkId(networkId);
}

#endregion

---

Step 8: State Synchronization

Implement periodic state sync for large-scale battles:

using Unity.Netcode;
using UnityEngine;
using System.Collections.Generic;
using Arawn.EnemyMasses.Runtime.Networking;

namespace YourGame.Networking
{
    public class NGOStateSync : INetworkStateSync
    {
        private readonly NGONetworkAuthority _authority;
        private readonly StateReconciliationSystem _reconciliation;
        private float _lastSyncTime;
        private const float SyncInterval = 0.1f; // 10 Hz

        public NGOStateSync(NGONetworkAuthority authority)
        {
            _authority = authority;
            _reconciliation = new StateReconciliationSystem(
                reconciliationInterval: 1f,
                urgentReconcileThreshold: 0.2f,
                enableDeltaCompression: true
            );
        }

        public void Update()
        {
            if (!_authority.IsServer) return;
            
            if (Time.time - _lastSyncTime >= SyncInterval)
            {
                _lastSyncTime = Time.time;
                SyncAllAgents();
            }
        }

        private void SyncAllAgents()
        {
            var controller = Object.FindFirstObjectByType<EnemyMassesCrowdController>();
            var agents = controller?.GetAgents();
            if (agents == null) return;

            // Batch agents for efficient sync
            var batch = new List<AgentSyncData>();
            
            foreach (var agent in agents)
            {
                if (agent == null || agent.networkId == 0) continue;
                
                batch.Add(new AgentSyncData
                {
                    networkId = agent.networkId,
                    position = agent.navMeshAgent?.transform.position ?? Vector3.zero,
                    rotation = agent.navMeshAgent?.transform.rotation ?? Quaternion.identity,
                    health = agent.health,
                    isDead = agent.isDead
                });

                // Send in batches of 50 to avoid packet size limits
                if (batch.Count >= 50)
                {
                    SendSyncBatch(batch);
                    batch.Clear();
                }
            }

            if (batch.Count > 0)
            {
                SendSyncBatch(batch);
            }
        }

        private void SendSyncBatch(List<AgentSyncData> batch)
        {
            // Convert to arrays for RPC
            var ids = new uint[batch.Count];
            var positions = new Vector3[batch.Count];
            var rotations = new Quaternion[batch.Count];
            var healths = new float[batch.Count];
            var deadFlags = new bool[batch.Count];

            for (int i = 0; i < batch.Count; i++)
            {
                ids[i] = batch[i].networkId;
                positions[i] = batch[i].position;
                rotations[i] = batch[i].rotation;
                healths[i] = batch[i].health;
                deadFlags[i] = batch[i].isDead;
            }

            _authority.SyncAgentStateRpc(ids, positions, rotations, healths, deadFlags);
        }

        public void SyncAgentState(uint networkId, AgentSyncData data)
        {
            // Individual sync (for important updates)
            _authority.SyncSingleAgentRpc(
                networkId,
                data.position,
                data.rotation,
                data.health,
                data.isDead
            );
        }

        private struct AgentSyncData
        {
            public uint networkId;
            public Vector3 position;
            public Quaternion rotation;
            public float health;
            public bool isDead;
        }
    }
}

Add the sync RPCs:

// Add to NGONetworkAuthority class:

#region State Sync RPCs

[Rpc(SendTo.NotServer)]
public void SyncAgentStateRpc(uint[] ids, Vector3[] positions, 
    Quaternion[] rotations, float[] healths, bool[] deadFlags)
{
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    
    for (int i = 0; i < ids.Length; i++)
    {
        var agent = controller?.GetAgentByNetworkId(ids[i]);
        if (agent == null) continue;
        
        // Apply authoritative state
        if (agent.navMeshAgent != null)
        {
            agent.navMeshAgent.Warp(positions[i]);
            agent.navMeshAgent.transform.rotation = rotations[i];
        }
        
        agent.SetHealthAuthoritative(healths[i]);
        if (deadFlags[i] && !agent.isDead)
        {
            agent.SetDeadAuthoritative(true);
        }
    }
}

[Rpc(SendTo.NotServer)]
public void SyncSingleAgentRpc(uint networkId, Vector3 position, 
    Quaternion rotation, float health, bool isDead)
{
    var controller = FindFirstObjectByType<EnemyMassesCrowdController>();
    var agent = controller?.GetAgentByNetworkId(networkId);
    if (agent == null) return;
    
    if (agent.navMeshAgent != null)
    {
        agent.navMeshAgent.Warp(position);
        agent.navMeshAgent.transform.rotation = rotation;
    }
    
    agent.SetHealthAuthoritative(health);
    if (isDead && !agent.isDead)
    {
        agent.SetDeadAuthoritative(true);
    }
}

#endregion

---

Step 9: Setup Anti-Cheat (Server Only)

Add anti-cheat to your server:

// In your server initialization code:

public class GameServer : NetworkBehaviour
{
    private AntiCheatManager _antiCheat;

    public override void OnNetworkSpawn()
    {
        if (!IsServer) return;

        // Initialize anti-cheat with strict settings for competitive play
        _antiCheat = new AntiCheatManager(AntiCheatConfig.Strict);

        // Handle cheat detections
        _antiCheat.OnCheatDetected += (playerId, type, details, severity) =>
        {
            Debug.LogWarning($"[AntiCheat] Player {playerId}: {type} - {details}");
            
            // Optional: Log to analytics
            // Analytics.LogCheatDetection(playerId, type, severity);
        };

        _antiCheat.OnPlayerFlaggedAsCheater += (playerId) =>
        {
            Debug.LogError($"[AntiCheat] Player {playerId} flagged as cheater!");
            
            // Take action: kick, ban, or flag for review
            KickPlayer((ulong)playerId, "Suspicious activity detected");
        };
    }

    private void Update()
    {
        if (!IsServer) return;
        
        // Update suspicion decay
        _antiCheat?.UpdateSuspicionDecay();
    }

    private void KickPlayer(ulong clientId, string reason)
    {
        NetworkManager.Singleton.ConnectionManager.DisconnectClient(clientId, reason);
    }
}

---

Step 10: Scene Setup

1. Create a NetworkManager prefab with NGO's NetworkManager component

2. Create a NetworkAuthority prefab:

   • Add NetworkObject component

   • Add NGONetworkAuthority component

   • Mark as Spawn With Player or instantiate on server start

3. Ensure your Enemy Masses prefabs are in the scene:

   • EnemyMassesCrowdController

   • EnemyMassesRTSController

   • Your crowd prefabs

---

Network Topology Options

Dedicated Server (Recommended for Competitive)

[Dedicated Server]
    ├── Full authority over all agents
    ├── Runs all validation
    ├── Runs anti-cheat
    └── Broadcasts state to clients

[Client 1] ←──→ [Server] ←──→ [Client 2]
    └── Predicts locally          └── Predicts locally
    └── Receives corrections      └── Receives corrections

Host Mode (Good for Casual/Co-op)

[Host = Server + Client]
    ├── Runs server logic
    ├── Also plays as a client
    └── Has natural advantage (no latency)

[Host] ←──→ [Client 1] ←──→ [Client 2]

---

Performance Tips

1. Batch Network Calls

// Bad: Individual RPCs per agent
foreach (var agent in agents)
{
    SyncAgentRpc(agent.networkId, agent.position);
}

// Good: Batched RPC
var ids = agents.Select(a => a.networkId).ToArray();
var positions = agents.Select(a => a.position).ToArray();
SyncAgentBatchRpc(ids, positions);

2. Use Delta Compression

// Only sync what changed
if (Vector3.Distance(lastSyncedPosition, currentPosition) > 0.1f)
{
    SyncPosition(currentPosition);
    lastSyncedPosition = currentPosition;
}

3. Prioritize Important Agents

// Sync agents near players more frequently
float distanceToPlayer = Vector3.Distance(agent.position, localPlayer.position);
float syncPriority = 1f / (distanceToPlayer + 1f);

4. Use Unreliable for Position Updates

// Positions can use unreliable delivery (some loss is OK)
[Rpc(SendTo.NotServer, Delivery = RpcDelivery.Unreliable)]
public void SyncPositionsRpc(Vector3[] positions) { }

// Critical state must be reliable
[Rpc(SendTo.NotServer, Delivery = RpcDelivery.Reliable)]
public void SyncDeathRpc(uint networkId) { }

---

Late-Joiner Synchronization

When a player joins mid-game, they need the full current state of all agents. The NGONetworkAuthority handles this automatically via OnClientConnected.

How It Works

1. Player Connects → OnClientConnected fires on the server

2. Server Waits → Short delay (0.5s) ensures client is ready

3. Full State Sent → Server sends AgentFullState for every agent (batched in groups of 50)

4. Client Applies → Client spawns missing agents and updates existing ones

What Gets Synced

Property	Description
networkId	Unique identifier for the agent
factionIndex	Which faction the agent belongs to
position	World position (Vector3)
rotation	World rotation (Quaternion)
health	Current health value
isDead	Whether agent is dead
ownerPlayerId	Which player owns this agent

Custom Late-Joiner Logic

Extend the late-joiner sync to include your custom game state:

// Override in your custom network authority
protected override void OnClientConnected(ulong clientId)
{
    base.OnClientConnected(clientId); // Sends agent state
    
    // Send additional game state
    StartCoroutine(SendCustomState(clientId));
}

private IEnumerator SendCustomState(ulong clientId)
{
    yield return new WaitForSeconds(0.6f); // After base sync
    
    SendGameScoreRpc(currentScore, RpcTarget.Single(clientId, RpcTargetUse.Temp));
    SendObjectivesRpc(activeObjectives.ToArray(), RpcTarget.Single(clientId, RpcTargetUse.Temp));
}

---

NavMeshAgent Position Synchronization

Unity's NavMeshAgent is not deterministic across different machines. Even with identical inputs, agents will drift apart over time due to:

• Floating-point differences between CPUs

• Frame rate variations

• Path recalculation timing

• Local avoidance interactions

The Solution: Server Authority

This guide uses server-authoritative positions:

1. Server runs all NavMeshAgents and owns the "truth"

2. Clients receive position updates periodically via NGOStateSync.SyncAllAgents()

3. Correction threshold prevents jitter from small differences

// In NGOStateSync.ApplySync():
float distance = Vector3.Distance(agent.transform.position, serverPos);

// Only correct if significantly different (avoids jitter)
if (distance > 1f)
{
    agent.navMeshAgent.Warp(serverPos);
    agent.navMeshAgent.transform.rotation = serverRotation;
}

Tuning Position Sync

Scenario	Sync Interval	Correction Threshold
RTS (low precision)	0.2s	2.0f
Action game	0.1s	0.5f
High precision	0.05s	0.25f

Bandwidth Note: Lower intervals = more network traffic but more accurate positions.

Client-Side Interpolation

For smoother visuals, implement interpolation instead of instant warping:

private void ApplyPositionCorrection(NavMeshAgent agent, Vector3 serverPos)
{
    float distance = Vector3.Distance(agent.transform.position, serverPos);
    
    if (distance > 3f)
    {
        // Large error: instant warp
        agent.Warp(serverPos);
    }
    else if (distance > 0.5f)
    {
        // Small error: smooth interpolation
        StartCoroutine(SmoothCorrection(agent, serverPos, 0.2f));
    }
    // Under threshold: ignore (client is close enough)
}

private IEnumerator SmoothCorrection(NavMeshAgent agent, Vector3 target, float duration)
{
    Vector3 start = agent.transform.position;
    float elapsed = 0f;
    
    while (elapsed < duration)
    {
        elapsed += Time.deltaTime;
        float t = elapsed / duration;
        agent.transform.position = Vector3.Lerp(start, target, t);
        yield return null;
    }
    
    agent.Warp(target);
}

---

Troubleshooting

Agents Teleporting

• Increase sync frequency

• Add interpolation on client

• Check network latency

Commands Not Executing

• Verify ownership validation

• Check command rate limits

• Ensure network IDs match

Desync Issues

• Enable state reconciliation logging

• Compare server/client states

• Check for missing RPCs

High Bandwidth Usage

• Reduce sync frequency

• Enable delta compression

• Batch smaller packets

---

Debug Tip: Use Tools > Enemy Masses > Network > Anti-Cheat Monitor during development to monitor cheat detections in real-time. This is an Editor-only tool; for in-game admin panels, query AntiCheatComponent.GetStatistics() directly.