Client–Server Netcode
Authoritative servers run game logic while clients predict locally. Snapshots, delta compression and jitter buffering keep gameplay smooth across variable networks
SUNA
SUNA is a competitive first-person shooter game, set on a dystopian planet devastated by the ongoing war between the native population and the Corporation entity. The gameplay is highly inspired by Counter-Strike and VALORANT as they are both leaders in the genre
This project was started with the team presented later on this page as part of our 3rd year at Creajeux. It is a student project aimed at improving our skills in game development and teamwork, as well as exploring new technologies and methodologies
Considering the scope of the project, we all endorsed multiple roles and responsibilities to ensure its success.
My roles were Gameplay programmer, Online Programmer and Project Manager
This project was started with the team presented later on this page as part of our 3rd year at Creajeux. It is a student project aimed at improving our skills in game development and teamwork, as well as exploring new technologies and methodologies
Considering the scope of the project, we all endorsed multiple roles and responsibilities to ensure its success.
My roles were Gameplay programmer, Online Programmer and Project Manager
Gameplay & Online Programmer
6 Programmers | 4 Artists
9 Weeks
May 2025
.svg)
.svg)
Dedicated Server
Built a fully headless authoritative Unity 6 ECS server from ground up to run Entity-based simulation and network replication for multiplayer sessions Implementation includes custom configuration (port, max players, tickrate), deterministic server-side simulation using the ECS + Jobs + Burst toolchain, snapshot-based state replication with explicit server reconciliation (lastProcessedInputSeq + tick IDs), telemetry & remote debug channels, and an automated session lifecycle with failover/restart logic all validated for deployment on a tuned virtual machine with secure remote management
Server-authoritative ECS architecture
Authoritative simulation implemented in Unity 6 Entities (ECS) + Jobs + Burst: entity-only state on server, deterministic systems, fixed tick scheduler, and isolated world instances for session sharding
Snapshot replication & client prediction
Custom NetCode pipeline using snapshot delta compression, reliable/unreliable channel separation (UDP), and client-side prediction to mask latency while preserving server authority
Server reconciliation (rollback + replay)
Snapshots include authoritative tick IDs andlastProcessedInputSeq. Clients compare incoming snapshots and, if the divergence exceeds a threshold, restore the authoritative state and deterministically replay unacknowledged inputs (seq > lastProcessedInputSeq) via the Ghost Component System in Unity ECS to apply snapshots, perform rollback and replay. Corrections are then smoothly interpolated. Ring-buffered predicted states and inputs are used so rollback is cheap and limited to the local player
Config-driven server runtime
Runtime config layer supports CLI / JSON configs and env-vars for port, maxPlayers, tickrate, simulation scale, logging levels and snapshot frequency
Session lifecycle & auto-restart
Robust session manager with graceful shutdown, snapshot persistence, automatic restart on crash or health-check failure, and configurable session rotation for continuous availability
Remote ops & VM tooling
Deployed to a tuned VM with SSH key-based access + optional RDP/VNC for visual tasks: automated build/deploy scripts, systemd service wrapper, Docker image option, and CI integration
Telemetry, remote debug & diagnostics
Client telemetry channel for debug payloads, server-side ring-buffered logs, structured metrics export (Prometheus-compatible), and on-demand remote console for live troubleshooting and replay trace dumps
Security & performance hardening
Network hardening (UDP rate-limits, port whitelisting), VM tuning (CPU pinning, cgroups, sysctl net/core tuning), swap disabled, NIC offload config and resource limits to maintain low jitter and deterministic ticks for reliable reconciliation
Server build optimization
Editor-only pre/post-build processor that strips cameras, lights and renderers for dedicated server builds, and strips unnecessary shaders/compute kernels to reduce size and avoid graphical overhead on headless servers
Client System
Client-side replication & instantiation for Unity ECS: deterministic client interpolation, snapshot application with local prediction, playerID dispatch to local entities, and authoritative reconciliation handling. Implemented with Entities + Jobs + Burst for performance; includes client-side ghost application, spawn ownership mapping, and lightweight client-side state buffering for smooth gameplay under jitter
Client-side entity instantiation
Deterministic client spawn prediction + authoritative confirm path: local ghost creation, temporary local IDs, remapped to server-assigned authoritative IDs on snapshot
Client replication & prediction
Snapshot apply pipeline with delta decompression, jitter buffer, and local prediction for player-controlled entities; non-player entities interpolated with configurable smoothing windows
PlayerID dispatch & ownership
PlayerID routed to spawned entities with ownership components; input dispatch ensures local player authoritative input is reconciled with server confirmations
Client lifecycle & reconnect
Session resume, entity snapshot diff on reconnect, and reapply of unacknowledged local inputs to avoid desync after transient disconnects
Matchmaking : LoadingScreen with async confirmation
Asynchronous matchmaking and loading workflow: confirm and fill sessions automatically, wait for client loading (async/await), create a client world on load completion, and auto-fill concurrent matchmaking sessions. Includes optional private-session mode for testing. Designed to spawn and map local ghosts, dispatch player IDs, and reconcile with authoritative server snapshots when available
Async loading & client-world creation
Client waits for asset and scene load with async confirmation hooks; upon completion we create the client ECS World and apply initial snapshot + local prediction buffers
Automatic matchmaking & session filling
Matchmaking fills sessions concurrently: join queue → allocate session → wait for load confirmations from players → start when fill threshold or timeout is reached. Sessions are rotatable to multiple shards.
Private-session support (testing)
Private sessions with invite/PIN: testers can create private rooms that bypass public queue, still benefiting from async load confirmation and automatic world instantiation.
PlayerID dispatch & reconciliation
On join/confirm we map playerID → local entity owner and keep deterministic replay buffers so server confirmations can be applied with minimal jitter.
Programmers :
.svg){kind=icon}
Artists :
Supporting Contributors :
Special Thanks :