Networking Overview

Enemy Masses includes a networking-agnostic multiplayer contract: interfaces, server-side validation, and editor tooling that make it straightforward to connect your preferred networking solution (NGO, Mirror, Photon, FishNet, custom). You implement the transport/RPC layer and game-specific systems (auth, lobby, matchmaking), while Enemy Masses provides the scalable RTS simulation and authority/validation hooks.

---

What's Included

✅ Ready to Use

Feature	Description
Network Interfaces	INetworkAuthorityProvider, INetworkDamageAuthority, INetworkCommandAuthority, INetworkSpawnAuthority
Anti-Cheat System	Server-side validation for damage, commands, spawns, and movement
Command Validation	Rate limiting, ownership checks, range validation
Network Events	Hooks for damage, death, spawn, and command events
Local Testing Stub	LocalNetworkAuthority for single-player and prototyping
Editor Tools	Setup Wizard, Anti-Cheat Monitor window

🔧 You Implement

Task	Why
RPC Layer	We can't know which networking solution you'll use (NGO, Mirror, Photon, etc.)
Player Authentication	Your game's login/session system
Lobby & Matchmaking	Game-specific requirements vary widely
Network Transport	Handled by your chosen networking package

---

Architecture

┌─────────────────────────────────────────────────────────────┐
│                      Your Game Code                         │
│         (Input handling, UI, game logic)                    │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Enemy Masses Runtime                     │
│  ┌─────────────────┐  ┌─────────────────┐                  │
│  │ CrowdController │  │  RTSController  │                  │
│  │  (Agent AI)     │  │ (Selection/Cmd) │                  │
│  └────────┬────────┘  └────────┬────────┘                  │
│           │                    │                            │
│           ▼                    ▼                            │
│  ┌─────────────────────────────────────────────────────┐   │
│  │            Network Authority Provider                │   │
│  │  - INetworkDamageAuthority (validate/apply damage)  │   │
│  │  - INetworkCommandAuthority (validate commands)     │   │
│  │  - INetworkSpawnAuthority (spawn/despawn agents)    │   │
│  │  - AntiCheatComponent (server-side validation)      │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│              Your Networking Implementation                 │
│                                                             │
│   ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐      │
│   │   NGO   │  │ Mirror  │  │ Photon  │  │ FishNet │      │
│   └─────────┘  └─────────┘  └─────────┘  └─────────┘      │
│                                                             │
│   You implement RPCs that call our interfaces               │
└─────────────────────────────────────────────────────────────┘

---

Quick Start

1. Choose Your Path

Scenario	Recommended Approach
Single-player only	Use LocalNetworkAuthority (default) — no extra work needed
Prototyping multiplayer	Start with LocalNetworkAuthority, add networking later
Production multiplayer	Implement INetworkAuthorityProvider with your networking solution

2. Single-Player Setup (Default)

Enemy Masses works out of the box for single-player. The LocalNetworkAuthority stub handles all network calls locally:

// This is already set up by default
var authority = new LocalNetworkAuthority();
authority.Initialize();

// All operations work locally
crowdController.SetNetworkAuthority(authority);

3. Multiplayer Setup

For multiplayer, implement the network interfaces with your chosen solution:

// Example: Your custom implementation
public class MyNetworkAuthority : NetworkBehaviour, INetworkAuthorityProvider
{
    public bool IsServer => NetworkManager.Singleton?.IsServer ?? false;
    public bool IsClient => NetworkManager.Singleton?.IsClient ?? false;
    
    public INetworkDamageAuthority DamageAuthority { get; private set; }
    public INetworkCommandAuthority CommandAuthority { get; private set; }
    public INetworkSpawnAuthority SpawnAuthority { get; private set; }
    
    // Implement RPCs that call these interfaces...
}

---

Implementation Checklist

Minimum Viable Multiplayer

• Implement INetworkAuthorityProvider — Main entry point

• Add Damage RPCs — Server validates, broadcasts results

• Add Command RPCs — Move, attack, stop commands

• Add Spawn RPCs — Server-authoritative spawning

• Assign Network IDs — Server generates, clients receive

Recommended Additions

• Enable Anti-Cheat — Add AntiCheatComponent to your authority GameObject

• State Synchronization — Periodic position/health sync from server

• Client Prediction — Local feedback while waiting for server response

• Reconciliation — Correct client state when it diverges from server

Production Ready

• Bandwidth Optimization — Delta compression, batching, LOD sync

• Lag Compensation — Interpolation, extrapolation

• Admin Tools — In-game anti-cheat monitoring, player kick/ban

• Persistence — Save/load networked state

---

Networking Solutions

We provide integration guides for popular networking packages:

Solution	Guide	Status
Netcode for GameObjects	NGO Integration	✅ Available
Mirror	Mirror Integration	🚧 Coming Soon
Photon Fusion	Photon Fusion Integration	🚧 Coming Soon
FishNet	FishNet Integration	🚧 Coming Soon

---

Key Concepts

Server Authority

All gameplay-affecting actions are validated by the server:

// Client sends request
RequestDamageRpc(attackerId, targetId, damage);

// Server validates
if (antiCheat.ValidateDamage(attackerId, targetId, damage))
{
    // Apply and broadcast to all clients
    ApplyDamageRpc(targetId, validatedDamage);
}

Network IDs

Every networked agent needs a unique ID assigned by the server:

// Server generates IDs
uint networkId = authority.GenerateNetworkId();

// Clients use IDs to reference agents
agent.networkId = networkId;

Ownership

Agents can be owned by players for command validation:

// Set ownership when spawning
agent.ownerPlayerId = requestingPlayerId;

// Commands are validated against ownership
if (agent.ownerPlayerId != sendingPlayerId)
{
    // Reject command — player doesn't own this agent
}

---

Anti-Cheat System

The optional anti-cheat system provides server-side validation:

Validation	What It Checks
Damage	Range, rate, valid targets, damage amounts
Commands	Ownership, rate limits, valid destinations
Spawns	Authority, spawn limits, valid positions
Movement	Speed limits, teleport detection

Enable in Inspector on your Network Authority GameObject, or via code:

var antiCheat = gameObject.AddComponent<AntiCheatComponent>();
antiCheat.enableDamageValidation = true;
antiCheat.enableCommandValidation = true;
antiCheat.enableSpawnValidation = true;

See Anti-Cheat System for configuration details.

---

Common Questions

Do I need multiplayer for Enemy Masses to work?

No. Enemy Masses works fully in single-player mode using LocalNetworkAuthority. Networking support is optional.

Can I add multiplayer later?

Yes. The architecture is designed so you can start single-player and add networking later. Your game logic stays the same — you just swap the authority provider.

Which networking solution should I use?

Solution	Best For
NGO	Unity-native, good for new projects
Mirror	Open source, mature, large community
Photon Fusion	Managed hosting, global infrastructure
FishNet	Performance-focused, modern API

Why isn't the networking layer fully implemented?

Every game has different requirements:

• Different networking solutions (NGO, Mirror, Photon, etc.)

• Different authority models (dedicated server, host-client, relay)

• Different persistence needs

• Different matchmaking requirements

We provide the architecture and validation — you provide the transport and RPCs for your specific needs.

---

Next Steps

1. Single-player? → You're done! LocalNetworkAuthority works by default

2. Planning multiplayer? → Read NGO Integration Guide

3. Need anti-cheat? → See Anti-Cheat System

4. Testing locally? → See Local Network Authority

---

Related Documentation

• Netcode for GameObjects Integration

• Local Network Authority

• Anti-Cheat System

• Public API Reference