Public API

Enemy Masses Public API Reference

This document provides a comprehensive reference for the public methods available in the Enemy Masses system. The primary entry point for most operations is the EnemyMassesCrowdController MonoBehaviour, which exposes a static Instance for convenience.

---

Core Controller Access

Most operations are performed through the EnemyMassesCrowdController instance. The class sets a static Instance in Awake, but this is not a hard-enforced singleton—adding multiple controllers will cause the last one to overwrite the static reference.

Recommended: Keep exactly one controller in the scene and use the static accessor for convenience.

// Access the singleton instance
EnemyMassesCrowdController controller = EnemyMassesCrowdController.Instance;

---

Spawning Agents

Methods for spawning agents into the world.

Spawn by Faction Index

/// <summary>
/// Spawns agents from a specific enemy crowd faction by index.
/// </summary>
/// <param name="enemyCrowdIndex">Index of the faction in the EnemyCrowds list.</param>
/// <param name="spawnPosition">World position to spawn at.</param>
/// <param name="spawnRotation">Rotation of the spawn group.</param>
/// <param name="count">Number of agents to spawn.</param>
/// <param name="formation">Formation type (Circle, Square, Random, etc.).</param>
/// <param name="formationSpacingOverride">Optional: Override the default formation spacing.</param>
/// <returns>List of spawned agent indices.</returns>
public List<int> SpawnEnemyCrowd(
    int enemyCrowdIndex, 
    Vector3 spawnPosition, 
    Quaternion spawnRotation, 
    int count, 
    FormationType formation = FormationType.Random,
    float? formationSpacingOverride = null
)

Spawn by Faction Index (Transform)

/// <summary>
/// Spawns agents from a specific enemy crowd faction at a transform's position/rotation.
/// </summary>
public List<int> SpawnEnemyCrowd(
    int enemyCrowdIndex, 
    Transform spawnTransform, 
    int count, 
    FormationType formation = FormationType.Random,
    float? formationSpacingOverride = null
)

Spawn by Faction Name

/// <summary>
/// Spawns agents from a specific faction by name.
/// </summary>
/// <param name="factionName">Name of the faction (must match EnemyCrowd.factionName).</param>
/// <param name="spawnPosition">World position to spawn at.</param>
/// <param name="count">Number of agents to spawn.</param>
/// <param name="formation">Formation type.</param>
/// <param name="formationSpacingOverride">Optional: Override the default formation spacing.</param>
/// <returns>List of spawned agent indices.</returns>
public List<int> SpawnEnemyCrowdByName(
    string factionName, 
    Vector3 spawnPosition, 
    int count, 
    FormationType formation = FormationType.Random,
    float? formationSpacingOverride = null
)

Spawn by Faction Name (Transform)

/// <summary>
/// Spawns agents from a specific faction by name at a transform's position.
/// </summary>
public List<int> SpawnEnemyCrowdByName(
    string factionName, 
    Transform spawnTransform, 
    int count, 
    FormationType formation = FormationType.Random,
    float? formationSpacingOverride = null
)

---

Despawning & Killing Agents

Methods for removing agents from the world.

Kill/Despawn Single Agent

/// <summary>
/// Immediately kills an agent by index.
/// Applies massive damage to trigger death (ragdoll, events, etc.).
/// </summary>
/// <param name="agentIndex">Index of the agent to kill.</param>
/// <param name="useRagdoll">If true, plays death animation/ragdoll. If false, still applies damage.</param>
/// <returns>True if agent was found and killed.</returns>
public bool KillAgent(int agentIndex, bool useRagdoll = true)

Kill by GPUICrowdInstance

/// <summary>
/// Immediately kills an agent by GPUICrowdInstance reference.
/// </summary>
public bool KillAgent(GPUICrowdInstance instance, bool useRagdoll = true)

Clear All Agents

/// <summary>
/// Clears all spawned agents and resets the system state.
/// Removes agents from GPUI before destroying to prevent buffer corruption.
/// </summary>
public void ClearAllAgents()

Respawn Agent

/// <summary>
/// Respawns a dead/disabled agent at a new position.
/// Resets all death-related state including sinking, ragdoll, and combat state.
/// Use this to re-enable pooled agents instead of spawning new ones.
/// </summary>
/// <param name="agentIndex">Index of the agent to respawn.</param>
/// <param name="spawnPosition">World position to respawn at.</param>
/// <param name="spawnRotation">Rotation for the respawned agent.</param>
/// <returns>True if respawn succeeded.</returns>
public bool RespawnAgent(int agentIndex, Vector3 spawnPosition, Quaternion spawnRotation)

---

Navigation & Movement

Methods for controlling agent movement.

Set Global Destination

/// <summary>
/// Sets a new destination for all agents.
/// </summary>
/// <param name="targetPosition">World position to move to.</param>
public void SetDestination(Vector3 targetPosition)

Set Faction Destination (by Index)

/// <summary>
/// Sets a destination for agents from a specific faction by index.
/// All agents of this faction will form their own formation independent of other factions.
/// </summary>
/// <param name="factionIndex">Index of the faction in the enemyCrowds list.</param>
/// <param name="targetPosition">World position to move to.</param>
/// <param name="useFormation">If true, arrange agents in formation. If false, all go to same point.</param>
public void SetDestinationForFaction(int factionIndex, Vector3 targetPosition, bool useFormation = true)

Set Faction Destination (by Name)

/// <summary>
/// Sets a destination for agents from a specific faction by name.
/// </summary>
/// <param name="factionName">Name of the faction.</param>
/// <param name="targetPosition">World position to move to.</param>
/// <param name="useFormation">If true, arrange agents in formation.</param>
public void SetDestinationForFaction(string factionName, Vector3 targetPosition, bool useFormation = true)

Set Destination for Spawn Group

/// <summary>
/// Sets a destination for all agents in a specific spawn group.
/// Spawn groups are assigned when agents are spawned together.
/// </summary>
/// <param name="spawnGroupId">ID of the spawn group.</param>
/// <param name="targetPosition">World position to move to.</param>
/// <param name="useFormation">If true, arrange in formation.</param>
/// <param name="useManualCommand">If true, treats as manual command (affects navigation state).</param>
public void SetDestinationForSpawnGroup(int spawnGroupId, Vector3 targetPosition, bool useFormation = true, bool useManualCommand = false)

Set Destination for Single Agent

/// <summary>
/// Sets a destination for a specific agent.
/// </summary>
/// <param name="agentIndex">Index of the agent.</param>
/// <param name="targetPosition">World position to move to.</param>
/// <returns>True if destination was set successfully.</returns>
public bool SetDestinationForAgent(int agentIndex, Vector3 targetPosition)

---

Healing & Health

Methods for managing agent health.

Heal Single Agent

/// <summary>
/// Heals a specific agent (instant heal).
/// </summary>
/// <param name="agentIndex">Index of the agent to heal.</param>
/// <param name="healAmount">Amount of health to restore.</param>
/// <returns>True if agent was healed (was alive and not at full health).</returns>
public bool HealAgent(int agentIndex, float healAmount)

Heal by GPUICrowdInstance

/// <summary>
/// Heals an agent by GPUICrowdInstance reference.
/// </summary>
public bool HealAgent(GPUICrowdInstance instance, float healAmount)

Heal Agents in Radius (AOE)

/// <summary>
/// Heals all agents within a radius (instant heal).
/// </summary>
/// <param name="center">World position center of the heal area.</param>
/// <param name="radius">Radius of the heal area.</param>
/// <param name="healAmount">Amount of health to restore per agent.</param>
/// <param name="targetFactionIndex">Optional: Only heal agents of this faction.</param>
/// <returns>Number of agents healed.</returns>
public int HealAgentsInRadius(
    Vector3 center, 
    float radius, 
    float healAmount, 
    int? targetFactionIndex = null
)

Get Agent Health

/// <summary>
/// Get an agent's current health.
/// </summary>
public float GetAgentHealth(int agentIndex)

---

Status Effects

The Status Effect System allows applying buffs, debuffs, and crowd control effects directly through the controller.

Apply Status Effect (Runtime)

/// <summary>
/// Apply a status effect to an agent by values.
/// </summary>
/// <param name="agentIndex">Index of the target agent.</param>
/// <param name="type">Type of effect (e.g., Stun, Slow, Burn, Regeneration).</param>
/// <param name="duration">Duration in seconds.</param>
/// <param name="value">Effect value (damage/heal per tick, speed modifier, etc.).</param>
/// <param name="tickInterval">Seconds between ticks (default: 1).</param>
/// <param name="sourceAgentIndex">Source agent index (-1 for player/environment).</param>
/// <returns>Slot index where effect was placed, or -1 if failed.</returns>
public int ApplyStatusEffect(
    int agentIndex, 
    StatusEffectType type, 
    float duration, 
    float value,
    float tickInterval = 1f,
    int sourceAgentIndex = -1
)

Apply Status Effect (Config Asset)

/// <summary>
/// Apply a status effect to an agent using a StatusEffectConfig ScriptableObject.
/// </summary>
public int ApplyStatusEffect(int agentIndex, StatusEffectConfig config, int sourceAgentIndex = -1)

Apply Status Effect in Radius (AOE)

/// <summary>
/// Apply a status effect to all agents within a radius.
/// Perfect for creating healing zones, AOE debuffs, buff auras, etc.
/// </summary>
/// <example>
/// // Create a healing zone that heals 5 HP/sec for 10 seconds
/// controller.ApplyStatusEffectInRadius(transform.position, 5f, StatusEffectType.Regeneration, 10f, 5f);
/// 
/// // Create a poison cloud that deals 3 damage/sec for 8 seconds to faction 1
/// controller.ApplyStatusEffectInRadius(transform.position, 8f, StatusEffectType.Poison, 8f, 3f, 1f, -1, 1);
/// </example>
/// <param name="center">World position center of the effect.</param>
/// <param name="radius">Radius of the effect area.</param>
/// <param name="type">Type of status effect to apply.</param>
/// <param name="duration">Duration in seconds.</param>
/// <param name="value">Effect value (damage/healing per tick).</param>
/// <param name="tickInterval">Seconds between ticks (default: 1).</param>
/// <param name="sourceAgentIndex">Source agent index (-1 for environment).</param>
/// <param name="targetFactionIndex">Optional: only affect agents of this faction.</param>
/// <returns>Number of agents affected.</returns>
public int ApplyStatusEffectInRadius(
    Vector3 center, 
    float radius, 
    StatusEffectType type, 
    float duration, 
    float value, 
    float tickInterval = 1f, 
    int sourceAgentIndex = -1,
    int? targetFactionIndex = null
)

Remove/Dispel Effects

/// <summary>
/// Remove a specific status effect type from an agent.
/// </summary>
public void RemoveStatusEffect(int agentIndex, StatusEffectType type, bool wasDispelled = false)

/// <summary>
/// Dispel all negative effects (debuffs, DOTs, CC) from an agent.
/// Use this for cleanse/purify abilities.
/// </summary>
/// <returns>Number of effects dispelled.</returns>
public int DispelNegativeEffects(int agentIndex)

/// <summary>
/// Dispel all positive effects (buffs) from an agent.
/// Use this for purge/strip abilities.
/// </summary>
/// <returns>Number of effects dispelled.</returns>
public int DispelPositiveEffects(int agentIndex)

/// <summary>
/// Clear all status effects from an agent (for respawn, transformation, etc.).
/// </summary>
public void ClearAllStatusEffects(int agentIndex)

Query Status Effects

/// <summary>
/// Check if an agent has a specific status effect active.
/// </summary>
public bool HasStatusEffect(int agentIndex, StatusEffectType type)

---

Civil AI

Methods for toggling agents between Combat and Civil modes.

Enable Civil Mode

/// <summary>
/// Enables civil mode for a specific agent, removing them from combat/formation behavior.
/// The agent will start following civil navigation waypoints if available.
/// Note: The agent's faction (EnemyCrowd) must have enableCivilMode set to true for full civil behavior.
/// </summary>
/// <param name="agentIndex">Index of the agent to convert to civil mode.</param>
/// <param name="startWaypoint">Optional: The waypoint to start civil navigation from. If null, agent stays at current position.</param>
/// <returns>True if successful, false if agent not found or already in civil mode.</returns>
public bool EnableAgentCivilMode(int agentIndex, CivilWaypointNode startWaypoint = null)

Disable Civil Mode

/// <summary>
/// Disables civil mode for a specific agent, making them participate in combat/formation behavior.
/// The agent will immediately start using the combat and navigation systems.
/// </summary>
/// <param name="agentIndex">Index of the agent to convert from civil to combat mode.</param>
/// <returns>True if successful, false if agent not found or not in civil mode.</returns>
public bool DisableAgentCivilMode(int agentIndex)

Spawn Civil Agent

/// <summary>
/// Spawns a civil agent at a specific spawn waypoint.
/// Converts an existing agent to civil mode and positions them at the waypoint.
/// </summary>
/// <param name="agentIndex">Index of an existing agent to convert to civil mode.</param>
/// <param name="spawnWaypoint">The spawn waypoint to start at.</param>
public void SpawnCivilAgent(int agentIndex, CivilWaypointNode spawnWaypoint)

Despawn Civil Agent

/// <summary>
/// Forces a civil agent to despawn with fade effect.
/// </summary>
/// <param name="agentIndex">Index of the agent to despawn.</param>
public void DespawnCivilAgent(int agentIndex)

Civil Navigation Commands

/// <summary>
/// Forces a civil agent to navigate to a specific waypoint.
/// </summary>
public void NavigateCivilAgentToWaypoint(int agentIndex, CivilWaypointNode targetWaypoint)

/// <summary>
/// Forces a civil agent to start a specific activity.
/// </summary>
public void StartCivilActivity(int agentIndex, CivilActivityDefinition activity)

/// <summary>
/// Gets civil navigation statistics.
/// </summary>
public CivilAgentStats GetCivilStats()

---

Query Methods

Methods for retrieving agent information.

Get Active Agents

/// <summary>
/// Returns the list of all currently managed agents.
/// Note: This returns the internal list - do not modify directly.
/// </summary>
public List<CrowdAgent> GetAgents()

Get Agents in Radius

/// <summary>
/// Gets all agent indices within a radius from a center point.
/// </summary>
public List<int> GetAgentsInRadius(Vector3 center, float radius)

/// <summary>
/// Gets all CrowdAgent objects within a radius from a center point.
/// </summary>
public List<CrowdAgent> GetCrowdAgentsInRadius(Vector3 center, float radius)

Get Agents by Owner (Networking)

/// <summary>
/// Gets all agent indices owned by a specific player.
/// Used for network authority checks.
/// </summary>
/// <param name="playerId">The owner's player ID.</param>
/// <param name="results">List to populate with agent indices.</param>
/// <returns>Number of agents found.</returns>
public int GetAgentsByOwner(int playerId, List<int> results)

Get Alive Agents

/// <summary>
/// Gets all alive agent indices.
/// </summary>
public List<int> GetAliveAgentIndices()

Get Agent by GameObject

/// <summary>
/// Gets a CrowdAgent by its associated GameObject (NavMeshAgent or GPUICrowdInstance).
/// Used for RTS selection to determine faction membership.
/// </summary>
/// <param name="gameObject">The GameObject to find the agent for.</param>
/// <returns>The CrowdAgent if found, null otherwise.</returns>
public CrowdAgent GetAgentByGameObject(GameObject gameObject)

---

Global Damage Multipliers

Properties for adjusting global damage values at runtime.

/// <summary>
/// Global multiplier applied to all incoming damage to agents.
/// Values > 1 increase damage (agents take more damage), values < 1 reduce damage.
/// Modify at runtime for difficulty settings, damage buffs/debuffs.
/// </summary>
public float IncomingDamageMultiplier { get; set; }

/// <summary>
/// Multiplier applied to damage coming from the Player Target (non-agent attacker).
/// Use this to buff/nerf player damage against crowds without touching weapons.
/// </summary>
public float PlayerDamageMultiplier { get; set; }

Example Usage

// Agents take 50% more damage (harder difficulty)
controller.IncomingDamageMultiplier = 1.5f;

// Player deals 50% less damage (boss fight nerf)
controller.PlayerDamageMultiplier = 0.5f;

---

Events

Events fired by the controller for integration with other systems.

Core Events

/// <summary>
/// Fired when an agent is killed.
/// </summary>
public event Action<GPUICrowdInstance> EventAgentKilled;

/// <summary>
/// Fired when an agent's health changes.
/// Parameters: (agentIndex, currentHealth, maxHealth)
/// </summary>
public event Action<int, float, float> EventAgentHealthChanged;

/// <summary>
/// Fired when an EnemyCrowd agent hits the Player Target (via melee or ranged attack).
/// Use this event to apply damage to the player via GC2's health system or custom logic.
/// Parameters: (attackerAgent, attackerPosition, targetTransform, damage, hitPoint, isMeleeAttack)
/// </summary>
public event Action<CrowdAgent, Vector3, Transform, float, Vector3, bool> EventPlayerTargetHit;

Network Events

/// <summary>
/// Fired when agents are spawned. Use for network synchronization.
/// The SpawnEventData contains all information needed to replicate spawn on clients.
/// </summary>
public event Action<SpawnEventData> NetworkEventAgentSpawned;

/// <summary>
/// Fired when an agent takes damage. Use for network damage validation/sync.
/// The DamageEventData contains attacker, target, damage amount, and result.
/// </summary>
public event Action<DamageEventData> NetworkEventDamageApplied;

/// <summary>
/// Fired when an agent dies. Use for network death synchronization.
/// The DeathEventData contains killer info, death position, and ragdoll state.
/// </summary>
public event Action<DeathEventData> NetworkEventAgentDied;

/// <summary>
/// Fired when an agent's health changes (damage or healing).
/// More detailed than EventAgentHealthChanged - includes source info.
/// </summary>
public event Action<HealthChangeEventData> NetworkEventHealthChanged;

/// <summary>
/// Fired when an agent's state changes (navigation state, combat state, etc.).
/// </summary>
public event Action<StateChangeEventData> NetworkEventStateChanged;

/// <summary>
/// Fired when agents are despawned.
/// Parameters: (networkIds[], despawnReason)
/// </summary>
public event Action<uint[], DespawnReason> NetworkEventAgentsDespawned;

Event Usage Example

void Start()
{
    var controller = EnemyMassesCrowdController.Instance;
    
    // Subscribe to agent death
    controller.EventAgentKilled += OnAgentKilled;
    
    // Subscribe to player being hit
    controller.EventPlayerTargetHit += OnPlayerHit;
    
    // Subscribe to network events for multiplayer
    controller.NetworkEventAgentSpawned += OnNetworkSpawn;
}

void OnAgentKilled(GPUICrowdInstance instance)
{
    // Award XP, play effects, etc.
    Debug.Log($"Agent killed: {instance.name}");
}

void OnPlayerHit(CrowdAgent attacker, Vector3 attackerPos, Transform target, float damage, Vector3 hitPoint, bool isMelee)
{
    // Apply damage to player
    PlayerHealth.TakeDamage(damage);
    
    // Spawn hit effect
    Instantiate(hitEffectPrefab, hitPoint, Quaternion.identity);
}

void OnNetworkSpawn(SpawnEventData data)
{
    // Replicate spawn to clients
    SpawnRpc(data.factionIndex, data.position, data.count, data.networkIds);
}

---

Subsystem Access

Methods to access underlying subsystems for advanced operations.

/// <summary>
/// Gets the navigation controller for advanced navigation operations.
/// </summary>
public EnemyMassesNavigationController GetNavigationController()

/// <summary>
/// Gets the list of configured enemy crowd factions.
/// </summary>
public List<EnemyCrowd> EnemyCrowds { get; }

/// <summary>
/// Gets the primary player target transform.
/// </summary>
public Transform PlayerTarget { get; }

/// <summary>
/// Gets all player targets for multi-player targeting.
/// </summary>
public IReadOnlyList<Transform> PlayerTargets { get; }

---

Faction Battle Mode

Properties for controlling faction vs faction battles.

/// <summary>
/// Gets or sets whether faction battle mode is enabled.
/// When enabled, agents attack other factions instead of the player.
/// </summary>
public bool FactionBattleMode { get; set; }

/// <summary>
/// Gets or sets the faction battle type.
/// AllVsAll = every agent for themselves
/// FactionVsFaction = faction-based teams
/// </summary>
public FactionBattleType FactionBattleType { get; set; }

Example

// Enable faction battles
controller.FactionBattleMode = true;
controller.FactionBattleType = FactionBattleType.FactionVsFaction;

// Spawn two opposing factions
controller.SpawnEnemyCrowdByName("Orcs", spawnPoint1.position, 50);
controller.SpawnEnemyCrowdByName("Elves", spawnPoint2.position, 50);
// They will automatically fight each other!

---

Quick Reference

Category	Method	Description
Spawning	SpawnEnemyCrowd()	Spawn by faction index
	SpawnEnemyCrowdByName()	Spawn by faction name
Killing	KillAgent()	Kill single agent
	ClearAllAgents()	Remove all agents
	RespawnAgent()	Respawn dead agent
Navigation	SetDestination()	Move all agents
	SetDestinationForFaction()	Move specific faction
	SetDestinationForAgent()	Move single agent
Health	HealAgent()	Heal single agent
	HealAgentsInRadius()	AOE heal
	GetAgentHealth()	Query health
Status Effects	ApplyStatusEffect()	Apply buff/debuff
	ApplyStatusEffectInRadius()	AOE status effect
	DispelNegativeEffects()	Cleanse debuffs
	DispelPositiveEffects()	Purge buffs
Civil AI	EnableAgentCivilMode()	Switch to civil
	DisableAgentCivilMode()	Switch to combat
Queries	GetAgents()	Get all agents
	GetAgentsInRadius()	Spatial query
	GetAgentByGameObject()	Find by GameObject

---

Networking API Reference

This section covers the networking interfaces and classes for multiplayer integration.

Note: Enemy Masses provides networking groundwork (~70% complete). You implement the RPC layer using your preferred networking solution (NGO, Mirror, Photon, etc.).

---

NetworkAuthorityProvider

Static class for registering and accessing network authority implementations.

using Arawn.EnemyMasses.Runtime.Networking;

// Register your authority implementation
NetworkAuthorityProvider.SetAuthority(myNetworkAuthority);

// Access the registered authority
INetworkAuthorityExtended authority = NetworkAuthorityProvider.Authority;

// Check if authority is registered
bool hasAuthority = NetworkAuthorityProvider.HasAuthority;

// Clear all authorities (on disconnect)
NetworkAuthorityProvider.ClearAuthorities();

---

INetworkAuthorityProvider

Base interface for network authority. Implement this to integrate with your networking solution.

public interface INetworkAuthorityProvider
{
    /// <summary>True if this instance is the server/host.</summary>
    bool IsServer { get; }
    
    /// <summary>True if this instance is a client.</summary>
    bool IsClient { get; }
    
    /// <summary>True if this instance is the host (server + client).</summary>
    bool IsHost { get; }
    
    /// <summary>Local player's ID.</summary>
    int LocalPlayerId { get; }
}

---

INetworkSpawnAuthority

Interface for server-authoritative spawning and despawning.

public interface INetworkSpawnAuthority : INetworkAuthorityProvider
{
    /// <summary>
    /// Check if local spawning is allowed.
    /// Server always returns true. Clients may return false to request from server.
    /// </summary>
    bool CanSpawnLocally(int factionIndex, Vector3 position, Quaternion rotation, 
        int count, int requestingPlayerId);
    
    /// <summary>
    /// Called when agents are spawned locally. Returns assigned network IDs.
    /// Server generates IDs; clients receive IDs from server.
    /// </summary>
    uint[] OnAgentsSpawned(int[] agentIndices, int factionIndex, Vector3[] positions, 
        Quaternion[] rotations, int ownerPlayerId);
    
    /// <summary>
    /// Called when receiving spawn data from the network (client-side).
    /// </summary>
    void OnNetworkSpawnRequest(uint[] networkIds, int factionIndex, Vector3[] positions, 
        Quaternion[] rotations, int ownerPlayerId);
    
    /// <summary>
    /// Called when an agent is about to despawn.
    /// </summary>
    void OnAgentDespawning(int agentIndex, uint networkId, DespawnReason reason);
    
    /// <summary>
    /// Called when receiving despawn request from network.
    /// </summary>
    void OnNetworkDespawnRequest(uint networkId, DespawnReason reason);
    
    /// <summary>
    /// Generate a unique network ID (server only).
    /// </summary>
    uint GenerateNetworkId();
}

---

INetworkDamageAuthority

Interface for server-authoritative damage validation.

public interface INetworkDamageAuthority
{
    /// <summary>
    /// Whether clients should predict damage locally before server confirmation.
    /// </summary>
    bool EnableClientPrediction { get; }
    
    /// <summary>
    /// Called when damage is attempted. Returns true if damage should be applied.
    /// Server validates; clients may predict or wait for confirmation.
    /// </summary>
    /// <param name="sequence">Output: sequence number for tracking this damage event.</param>
    bool OnDamageAttempt(uint targetNetworkId, float damage, uint attackerNetworkId,
        Vector3 hitPoint, DamageType damageType, out int sequence);
    
    /// <summary>
    /// Called when damage is confirmed by server.
    /// </summary>
    void OnDamageConfirmed(uint targetNetworkId, float actualDamage, float newHealth,
        bool isDead, int sequence);
    
    /// <summary>
    /// Called when predicted damage needs to be rolled back.
    /// </summary>
    void OnDamageRollback(uint targetNetworkId, float correctHealth, int sequence,
        DamageRollbackReason reason);
    
    /// <summary>
    /// Called when an agent dies.
    /// </summary>
    void OnAgentDeath(uint networkId, uint killerNetworkId, int killerPlayerId,
        Vector3 deathPosition);
}

---

INetworkCommandAuthority

Interface for server-authoritative command validation.

public interface INetworkCommandAuthority
{
    /// <summary>
    /// Called when a move command is issued. Returns true if command is valid.
    /// </summary>
    bool OnMoveCommand(MoveCommandData command);
    
    /// <summary>
    /// Called when an attack command is issued. Returns true if command is valid.
    /// </summary>
    bool OnAttackCommand(AttackCommandData command);
    
    /// <summary>
    /// Called when a stop command is issued. Returns true if command is valid.
    /// </summary>
    bool OnStopCommand(StopCommandData command);
    
    /// <summary>
    /// Called when server confirms a command.
    /// </summary>
    void OnCommandConfirmed(int commandSequence, bool success, CommandResult result);
    
    /// <summary>
    /// Called when a command is rejected/rolled back.
    /// </summary>
    void OnCommandRollback(int commandSequence, CommandRejectReason reason);
    
    /// <summary>
    /// Called when receiving a command from another client (via server).
    /// </summary>
    void OnRemoteCommandReceived(RemoteCommandData command);
    
    /// <summary>
    /// Get next command sequence number.
    /// </summary>
    int GetNextCommandSequence();
}

---

INetworkAuthorityExtended

Extended interface that combines all sub-authorities.

public interface INetworkAuthorityExtended : 
    INetworkSpawnAuthority, 
    INetworkDamageAuthority, 
    INetworkCommandAuthority
{
    /// <summary>True if network is active.</summary>
    bool IsNetworkActive { get; }
    
    /// <summary>True if running as dedicated server (no local player).</summary>
    bool IsDedicatedServer { get; }
    
    /// <summary>Synchronized network time.</summary>
    float NetworkTime { get; }
    
    /// <summary>Current round-trip time to server.</summary>
    float RoundTripTime { get; }
    
    /// <summary>Called when network connects.</summary>
    void OnNetworkConnected();
    
    /// <summary>Called when network disconnects.</summary>
    void OnNetworkDisconnected();
    
    /// <summary>Transform synchronization authority.</summary>
    INetworkTransformAuthority TransformAuthority { get; }
    
    /// <summary>State synchronization authority.</summary>
    INetworkStateAuthority StateAuthority { get; }
    
    /// <summary>Fog of war authority.</summary>
    INetworkFogAuthority FogAuthority { get; }
    
    /// <summary>Projectile authority.</summary>
    INetworkProjectileAuthority ProjectileAuthority { get; }
}

---

AntiCheatComponent

Server-side anti-cheat system. See Anti-Cheat System for full documentation.

using Arawn.EnemyMasses.Runtime.Networking;

// Singleton access
AntiCheatComponent antiCheat = AntiCheatComponent.Instance;

// Properties
bool isInitialized = antiCheat.IsInitialized;
float threshold = antiCheat.SuspicionThreshold;

// Subsystem access
NetworkDamageValidator damageValidator = antiCheat.DamageValidator;
NetworkCommandValidator commandValidator = antiCheat.CommandValidator;
SpeedHackDetector speedDetector = antiCheat.SpeedDetector;

// Methods
AntiCheatStatistics stats = antiCheat.GetStatistics();
Dictionary<int, float> suspicion = antiCheat.GetAllSuspicionLevels();
antiCheat.ResetPlayerSuspicion(playerId);
antiCheat.FlagPlayer(playerId);
antiCheat.ResetStatistics();
antiCheat.ResetAll();

// Events (via runtime manager)
var manager = antiCheat.GetRuntimeManager();
manager.OnCheatDetected += (playerId, type, details, severity) => { };
manager.OnSuspicionLevelChanged += (playerId, newLevel) => { };
manager.OnPlayerFlaggedAsCheater += (playerId) => { };

---

Command Data Structures

MoveCommandData

public struct MoveCommandData
{
    public int playerId;              // Commanding player
    public uint[] agentNetworkIds;    // Agents to move
    public Vector3 destination;       // Target position
    public FormationType formation;   // Formation type
    public float formationSpacing;    // Spacing between agents
    public Vector3 facingDirection;   // Direction to face on arrival
    public int commandSequence;       // Sequence number for tracking
}

AttackCommandData

public struct AttackCommandData
{
    public int playerId;              // Commanding player
    public uint[] attackerNetworkIds; // Attacking agents
    public uint targetNetworkId;      // Target agent
    public int targetIndex;           // Target's local index
    public int commandSequence;       // Sequence number
}

StopCommandData

public struct StopCommandData
{
    public int playerId;              // Commanding player
    public uint[] agentNetworkIds;    // Agents to stop
    public bool holdPosition;         // If true, agents won't auto-engage
    public int commandSequence;       // Sequence number
}

---

Event Data Structures

SpawnEventData

public struct SpawnEventData
{
    public uint[] networkIds;         // Assigned network IDs
    public int[] agentIndices;        // Local agent indices
    public int factionIndex;          // Faction spawned from
    public Vector3[] positions;       // Spawn positions
    public Quaternion[] rotations;    // Spawn rotations
    public int ownerPlayerId;         // Owning player
    public int spawnGroupId;          // Spawn group identifier
}

DamageEventData

public struct DamageEventData
{
    public uint attackerNetworkId;    // Attacker's network ID (0 if environment)
    public uint targetNetworkId;      // Target's network ID
    public float damage;              // Damage amount
    public DamageType damageType;     // Type of damage
    public Vector3 attackerPosition;  // Attacker position at time of attack
    public Vector3 targetPosition;    // Target position at time of hit
    public Vector3 hitPoint;          // Exact hit location
    public int sequence;              // Damage sequence number
}

DeathEventData

public struct DeathEventData
{
    public uint victimNetworkId;      // Killed agent's network ID
    public uint killerNetworkId;      // Killer's network ID (0 if environment)
    public int killerPlayerId;        // Killer's player ID (-1 if NPC)
    public Vector3 deathPosition;     // Position of death
    public bool useRagdoll;           // Whether to ragdoll
}

HealthChangeEventData

public struct HealthChangeEventData
{
    public uint networkId;            // Agent's network ID
    public float previousHealth;      // Health before change
    public float currentHealth;       // Health after change
    public float maxHealth;           // Maximum health
    public float delta;               // Change amount (negative = damage)
    public uint sourceNetworkId;      // Source of change (0 if environment)
    public HealthChangeReason reason; // Why health changed
}

---

Networking Enums

DespawnReason

public enum DespawnReason
{
    Unknown,
    Killed,           // Died in combat
    Despawned,        // Manually despawned
    OutOfBounds,      // Left valid area
    Disconnected,     // Owner disconnected
    PoolReturn,       // Returned to object pool
    SceneUnload       // Scene being unloaded
}

DamageType

public enum DamageType
{
    Physical,
    Magical,
    Fire,
    Ice,
    Lightning,
    Poison,
    Holy,
    Dark,
    True,             // Ignores resistances
    Environmental
}

DamageRollbackReason

public enum DamageRollbackReason
{
    None,
    InvalidTarget,    // Target doesn't exist
    OutOfRange,       // Attacker too far
    AlreadyDead,      // Target was already dead
    ServerOverride,   // Server had different state
    CheatDetected,    // Anti-cheat rejected
    Timeout           // Confirmation took too long
}

CommandRejectReason

public enum CommandRejectReason
{
    None,             // Command accepted
    InvalidAgent,     // Agent doesn't exist
    NotOwned,         // Player doesn't own agent
    InvalidTarget,    // Target doesn't exist
    OutOfRange,       // Target out of command range
    RateLimited,      // Too many commands
    CheatDetected,    // Anti-cheat rejected
    ServerBusy        // Server couldn't process
}

CheatType

public enum CheatType
{
    SpeedHack,
    Teleport,
    DamageHack,
    GodMode,
    CommandFlooding,
    OwnershipViolation,
    RangeHack,
    AttackSpeedHack,
    Suspicious,
    Unknown
}

HealthChangeReason

public enum HealthChangeReason
{
    Unknown,
    Damage,
    Healing,
    Regeneration,
    StatusEffect,
    Environmental,
    Respawn,
    AdminCommand
}

---

Networking Quick Reference

Interface	Purpose
INetworkAuthorityProvider	Base interface - IsServer, IsClient, LocalPlayerId
INetworkSpawnAuthority	Spawn/despawn with network IDs
INetworkDamageAuthority	Damage validation and confirmation
INetworkCommandAuthority	Command validation and sync
INetworkAuthorityExtended	All-in-one extended interface

Class	Purpose
NetworkAuthorityProvider	Static accessor for registered authority
LocalNetworkAuthority	Single-player/testing stub
AntiCheatComponent	Server-side cheat detection

Data Structure	Purpose
MoveCommandData	Move command parameters
AttackCommandData	Attack command parameters
StopCommandData	Stop command parameters
SpawnEventData	Spawn event details
DamageEventData	Damage event details
DeathEventData	Death event details
HealthChangeEventData	Health change details
AntiCheatStatistics	Anti-cheat metrics

---

See Also

• Networking Overview - Architecture and concepts

• NGO Integration Guide - Netcode for GameObjects 2.7.0

• Anti-Cheat System - Server-side protection

• Local Network Authority - Testing without networking

---

RTS Controller API Reference

The EnemyMassesRTSController provides selection, commands, and formation controls for RTS gameplay.

---

Controller Access

// Find the controller in scene
EnemyMassesRTSController rtsController = FindFirstObjectByType<EnemyMassesRTSController>();

---

Properties

/// <summary>Currently selected agent indices (read-only).</summary>
public IReadOnlyList<int> SelectedAgents { get; }

/// <summary>Currently selected external units (not backed by EnemyCrowd agents).</summary>
public IReadOnlyList<IRTSExternalSelectable> SelectedExternalAgents { get; }

/// <summary>All registered external selectables.</summary>
public IReadOnlyList<IRTSExternalSelectable> ExternalSelectables { get; }

/// <summary>Number of currently selected controllables (crowd + external).</summary>
public int SelectedCount { get; }

/// <summary>Whether a drag selection is in progress.</summary>
public bool IsDragging { get; }

/// <summary>Returns true if no faction filter is set (all factions selectable).</summary>
public bool AllFactionsSelectable { get; }

---

Selection Methods

Clear Selection

/// <summary>Clear all selected agents.</summary>
public void ClearSelection()

Select Agents

/// <summary>Select agents by their indices.</summary>
/// <param name="agentIndices">Indices of agents to select.</param>
/// <param name="additive">If true, adds to existing selection. If false, replaces.</param>
public void SelectAgents(IEnumerable<int> agentIndices, bool additive = false)

Select Faction

/// <summary>Select all agents of a specific faction.</summary>
/// <param name="enemyCrowdIndex">Index of the faction in the EnemyCrowds list.</param>
/// <param name="additive">If true, adds to existing selection.</param>
public void SelectFaction(int enemyCrowdIndex, bool additive = false)

External Selectables

/// <summary>Registers an external NavMesh-driven unit so it can be selected and commanded.</summary>
public void RegisterExternalSelectable(IRTSExternalSelectable selectable)

/// <summary>Unregisters an external selectable and removes it from the active selection.</summary>
public void UnregisterExternalSelectable(IRTSExternalSelectable selectable)

---

Command Methods

Request Move Command (Networked)

/// <summary>
/// Requests a move command through the network authority system.
/// </summary>
/// <param name="agentIndices">Local indices of agents to move.</param>
/// <param name="destination">Target position.</param>
/// <param name="formation">Formation type.</param>
/// <param name="spacing">Formation spacing (-1 for default).</param>
/// <param name="facingDirection">Direction to face on arrival (zero for none).</param>
/// <returns>True if command was accepted (or predicted).</returns>
public bool RequestMoveCommand(IReadOnlyList<int> agentIndices, Vector3 destination, 
    FormationType formation = FormationType.Rectangle, float spacing = -1f, 
    Vector3 facingDirection = default)

Request Attack Command (Networked)

/// <summary>
/// Requests an attack command through the network authority system.
/// </summary>
/// <param name="agentIndices">Local indices of attacking agents.</param>
/// <param name="targetIndex">Local index of target agent.</param>
/// <returns>True if command was accepted (or predicted).</returns>
public bool RequestAttackCommand(IReadOnlyList<int> agentIndices, int targetIndex)

Request Stop Command (Networked)

/// <summary>
/// Requests a stop command through the network authority system.
/// </summary>
/// <param name="agentIndices">Local indices of agents to stop.</param>
/// <param name="holdPosition">Whether to hold position.</param>
/// <returns>True if command was accepted.</returns>
public bool RequestStopCommand(IReadOnlyList<int> agentIndices, bool holdPosition = false)

Execute Server Commands

/// <summary>
/// Executes a move command received from the server.
/// Use for remote player commands and server confirmations.
/// </summary>
public void ExecuteServerMoveCommand(uint[] agentNetworkIds, Vector3 destination, 
    FormationType formation, float spacing, Vector3 facingDirection)

/// <summary>Executes an attack command received from the server.</summary>
public void ExecuteServerAttackCommand(uint[] attackerNetworkIds, uint targetNetworkId)

/// <summary>Executes a stop command received from the server.</summary>
public void ExecuteServerStopCommand(uint[] agentNetworkIds, bool holdPosition)

---

Combat Stance Methods

/// <summary>
/// Sets the combat stance for all currently selected agents.
/// </summary>
/// <param name="stance">The combat stance to apply (Offensive, Defensive, or HoldPosition).</param>
public void SetSelectedAgentsCombatStance(CombatStance stance)

/// <summary>Sets selected agents to Offensive stance. Agents actively seek and attack enemies.</summary>
public void SetSelectedAgentsOffensive()

/// <summary>Sets selected agents to Defensive stance. Agents only attack if attacked first.</summary>
public void SetSelectedAgentsDefensive()

/// <summary>Sets selected agents to Hold Position stance. Agents stay in place and attack enemies in range.</summary>
public void SetSelectedAgentsHoldPosition()

/// <summary>
/// Sets selected agents to Offensive stance AND optionally ignores Ally Defense System alerts.
/// </summary>
public void SetSelectedAgentsOffensiveStrict(bool ignoreAllyDefense = true)

---

Events

Selection Events

/// <summary>Fired when selection changes. Provides detailed information about what changed.</summary>
public event Action<SelectionChangedEventData> SelectionChanged;

/// <summary>Fired when a single agent is added to selection.</summary>
public event Action<int, CrowdAgent> AgentSelected;

/// <summary>Fired when a single agent is removed from selection.</summary>
public event Action<int, CrowdAgent> AgentDeselected;

/// <summary>Fired when selection is completely cleared.</summary>
public event Action SelectionCleared;

Command Events

/// <summary>Fired when a move command is issued to selected agents.</summary>
public event Action<Vector3, IReadOnlyList<int>> MoveCommandIssued;

/// <summary>Fired when an attack command is issued. Parameters: target index, attacker indices.</summary>
public event Action<int, IReadOnlyList<int>> AttackCommandIssued;

Network Command Events

/// <summary>
/// Fired when a move command is issued. Subscribe to route commands through network.
/// The CommandEventData includes all info needed to replicate the command on server/clients.
/// </summary>
public event Action<CommandEventData> NetworkMoveCommandIssued;

/// <summary>Fired when an attack command is issued. Subscribe to route through network.</summary>
public event Action<CommandEventData> NetworkAttackCommandIssued;

/// <summary>Fired when a stop command is issued (agents ordered to halt).</summary>
public event Action<CommandEventData> NetworkStopCommandIssued;

---

SelectionChangedEventData

public class SelectionChangedEventData
{
    public List<int> selectedIndices;    // All currently selected
    public List<int> newlySelected;      // Added this frame
    public List<int> newlyDeselected;    // Removed this frame
    public int totalSelected;            // Total count
}

---

RTS Controller Quick Reference

Category	Method/Property	Description
Properties	SelectedAgents	Currently selected agent indices
	SelectedCount	Number of selected agents
	IsDragging	True during drag selection
Selection	ClearSelection()	Deselect all
	SelectAgents()	Select by indices
	SelectFaction()	Select all in faction
Commands	RequestMoveCommand()	Move with network support
	RequestAttackCommand()	Attack with network support
	RequestStopCommand()	Stop with network support
Server	ExecuteServerMoveCommand()	Apply server command
	ExecuteServerAttackCommand()	Apply server attack
	ExecuteServerStopCommand()	Apply server stop
Stance	SetSelectedAgentsCombatStance()	Set combat behavior
	SetSelectedAgentsOffensive()	Aggressive mode
	SetSelectedAgentsDefensive()	Reactive mode
	SetSelectedAgentsHoldPosition()	Static defense

---

RTS Camera Controller API Reference

The RTSCameraController provides camera movement, zoom, rotation, and bookmarks for RTS gameplay.

---

Controller Access

// Find the controller in scene
RTSCameraController cameraController = FindFirstObjectByType<RTSCameraController>();

---

Properties

/// <summary>Index of the active camera preset.</summary>
public int ActivePresetIndex { get; }

/// <summary>The currently active camera preset.</summary>
public RTSCameraPreset ActivePreset { get; }

/// <summary>Number of available presets.</summary>
public int PresetCount { get; }

/// <summary>Whether camera control is currently active.</summary>
public bool IsControlActive { get; }

/// <summary>Whether follow mode is enabled.</summary>
public bool IsFollowModeEnabled { get; }

/// <summary>Current camera target position.</summary>
public Vector3 CurrentPosition { get; }

/// <summary>Current zoom level.</summary>
public float CurrentZoom { get; }

---

Preset Methods

Apply Preset

/// <summary>Immediately applies a camera preset without transition.</summary>
public void ApplyPreset(RTSCameraPreset preset)

Transition to Preset

/// <summary>Smoothly transitions to a preset by index.</summary>
/// <param name="presetIndex">Index of the target preset.</param>
/// <param name="followOverride">Optional transform to follow after transition.</param>
/// <param name="useCachedState">If true, restores previously cached camera state for this preset.</param>
public void TransitionToPreset(int presetIndex, Transform followOverride = null, bool useCachedState = true)

/// <summary>Smoothly transitions to a preset by name.</summary>
public void TransitionToPreset(string presetName, Transform followOverride = null, bool useCachedState = true)

/// <summary>Smoothly transitions to a specific preset.</summary>
public void TransitionToPreset(RTSCameraPreset preset, Transform followOverride = null, bool useCachedState = true)

Preset Management

/// <summary>Gets a preset at the specified index.</summary>
public RTSCameraPreset GetPresetAt(int index)

/// <summary>Gets the index of a preset by name.</summary>
public int GetPresetIndex(string presetName)

/// <summary>Adds a preset to the list.</summary>
public void AddPreset(RTSCameraPreset preset)

/// <summary>Removes a preset from the list.</summary>
public bool RemovePreset(RTSCameraPreset preset)

---

Focus & Follow Methods

/// <summary>
/// Moves camera to focus on a world position.
/// </summary>
/// <param name="position">World position to focus on.</param>
/// <param name="instant">If true, snaps immediately. If false, smoothly moves.</param>
public void FocusOnPosition(Vector3 position, bool instant = false)

/// <summary>
/// Moves camera to focus on a transform.
/// </summary>
public void FocusOnTarget(Transform target, bool instant = false)

/// <summary>Starts following a transform.</summary>
public void StartFollowing(Transform target)

/// <summary>Stops following the current target.</summary>
public void StopFollowing()

/// <summary>Sets the follow target without starting follow mode.</summary>
public void SetFollowTarget(Transform target)

/// <summary>Enables or disables follow mode.</summary>
public void SetFollowMode(bool enabled)

---

Bookmark Methods

/// <summary>
/// Saves the current camera state to a bookmark slot.
/// </summary>
/// <param name="slot">Slot index (0-8).</param>
public void SaveBookmark(int slot)

/// <summary>
/// Loads a camera bookmark.
/// </summary>
/// <param name="slot">Slot index (0-8).</param>
public void LoadBookmark(int slot)

---

Camera Control Methods

/// <summary>Enables or disables camera control.</summary>
public void SetControlActive(bool active)

/// <summary>Syncs internal state from the camera's current transform.</summary>
public void SyncFromCameraTransform()

/// <summary>Suppresses zoom input temporarily (e.g., when UI is being scrolled).</summary>
/// <param name="duration">Duration in seconds.</param>
public void SuppressZoom(float duration = 0.2f)

/// <summary>Shakes the camera.</summary>
/// <param name="intensity">Shake strength.</param>
/// <param name="duration">Duration in seconds.</param>
public void Shake(float intensity, float duration)

---

Direct Camera Manipulation

/// <summary>Gets the current target position.</summary>
public Vector3 GetPosition()

/// <summary>Sets the camera target position directly.</summary>
public void SetPosition(Vector3 position)

/// <summary>Gets the current zoom level.</summary>
public float GetZoom()

/// <summary>Sets the zoom level directly.</summary>
public void SetZoom(float zoom)

/// <summary>Sets the camera rotation (yaw and pitch).</summary>
public void SetRotation(float yaw, float pitch)

/// <summary>Sets the camera movement bounds.</summary>
public void SetBounds(float minX, float maxX, float minZ, float maxZ)

/// <summary>Gets the current camera bounds.</summary>
public void GetBounds(out float minX, out float maxX, out float minZ, out float maxZ)

/// <summary>Enables or disables all camera controls.</summary>
public void SetControlsEnabled(bool enabled)

---

Events

/// <summary>Fired when camera control is enabled.</summary>
public event Action<RTSCameraController> OnControlEnabled;

/// <summary>Fired when camera control is disabled.</summary>
public event Action<RTSCameraController> OnControlDisabled;

---

Camera Controller Quick Reference

Category	Method/Property	Description
Properties	ActivePreset	Current camera preset
	IsControlActive	Whether controls are active
	CurrentPosition	Camera target position
	CurrentZoom	Current zoom level
Presets	TransitionToPreset()	Smooth preset change
	ApplyPreset()	Instant preset change
	GetPresetAt()	Get preset by index
Focus	FocusOnPosition()	Move to position
	FocusOnTarget()	Move to transform
	StartFollowing()	Begin follow mode
	StopFollowing()	End follow mode
Bookmarks	SaveBookmark()	Save camera state
	LoadBookmark()	Restore camera state
Control	SetControlActive()	Enable/disable control
	SetPosition()	Direct position set
	SetZoom()	Direct zoom set
	SetRotation()	Direct rotation set
	Shake()	Camera shake effect