Architecture Netcode sur Roblox : Bitpacking, Compression Delta par Buffers et Réplication Massive

Dans les jeux compétitifs à plus de 50 joueurs, les RemoteEvents standard saturent la bande passante avec la sérialisation lourde des tables et dictionnaires.

Grâce aux buffers natifs de Luau, les développeurs peuvent quantifier les coordonnées en entiers 16 bits et ne répliquer que les deltas de modifications, économisant 90% de bande passante.

1. La Limite Réseau des RemoteEvents par Défaut

Goulots d'étranglement de la sérialisation standard dans Roblox :

• Poids des tables : L'envoi de clés de chaînes et de nombres 64 bits consomme plus de 50 octets par entité.
• Saturation à 20Hz : Débit supérieur à 250 Ko/s par client menant à des pertes de paquets.
• Bufferbloat et désynchronisation : Retard artificiel créant des décalages d'impacts de tir.
• L'avantage des buffers Luau : Envoi direct d'octets continus sans surcoût de sérialisation.

2. Quantification des Coordonnées & Masques de Bits

Compression de données 64 bits en quelques octets seulement :

• Quantification en virgule fixe : Conversion d'un monde de 2048 studs en entiers 16 bits avec une précision centimétrique.
• Compression d'angles : Encodage d'une rotation complète de 360 degrés sur un seul octet 8 bits.
• Masques d'état : Regroupement de 8 booléens dans un unique octet.
• Codage VarInt : Allocation dynamique d'octets pour les petits identifiants.

--!strict
local NetcodeCompressor = {}
local WORLD_BOUNDS = 2048
local MAX_UINT16 = 65535

function NetcodeCompressor.WritePosition(buf: buffer, offset: number, pos: Vector3): number
    local normX = math.clamp((pos.X + (WORLD_BOUNDS / 2)) / WORLD_BOUNDS, 0, 1)
    local normY = math.clamp((pos.Y + 500) / 2000, 0, 1)
    local normZ = math.clamp((pos.Z + (WORLD_BOUNDS / 2)) / WORLD_BOUNDS, 0, 1)
    buffer.writeu16(buf, offset, math.floor(normX * MAX_UINT16))
    buffer.writeu16(buf, offset + 2, math.floor(normY * MAX_UINT16))
    buffer.writeu16(buf, offset + 4, math.floor(normZ * MAX_UINT16))
    return offset + 6
end

function NetcodeCompressor.ReadPosition(buf: buffer, offset: number): (Vector3, number)
    local qX = buffer.readu16(buf, offset)
    local qY = buffer.readu16(buf, offset + 2)
    local qZ = buffer.readu16(buf, offset + 4)
    local x = (qX / MAX_UINT16) * WORLD_BOUNDS - (WORLD_BOUNDS / 2)
    local y = (qY / MAX_UINT16) * 2000 - 500
    local z = (qZ / MAX_UINT16) * WORLD_BOUNDS - (WORLD_BOUNDS / 2)
    return Vector3.new(x, y, z), offset + 6
end

return NetcodeCompressor

3. Compression Delta & Suivi des Modifications

Réplication ciblée des seuls attributs modifiés :

• Keyframes et Snapshots Delta : Trames de référence toutes les 2 secondes et simples deltas entre-temps.
• Masque de modifications (Dirty Mask) : En-tête indiquant les champs mis à jour.
• Interpolation par spline : Lissage des mouvements sur le client.
• Exclusion des objets immobiles : Consommation nulle pour les entités stationnaires.

4. Gestion de la Portée & Priorisation Réseau

Attribution dynamique de bande passante selon la distance :

• Grille spatiale : Découpage en cellules de 128 studs pour filtrer les paquets lointains.
• Fréquence variable : 30Hz à proximité immédiate, réduite à 3Hz au-delà de 200 studs.
• Tri par champ de vision : Priorité abaissée pour les entités situées derrière la caméra.
• UnreliableRemoteEvents : Élimination du blocage en tête de ligne sur les données de position.

5. Checklist de Production pour Netcode Roblox

Directives clés pour un multijoueur fluide :

• Réutilisation des buffers mémoire pour neutraliser les saccades du Garbage Collector.
• Versionnage du protocole au début de chaque paquet.
• Validation stricte des limites spatiales pour contrer les hacks de téléportation.
• Surveillance de la bande passante sous le seuil de 35 Ko/s par joueur.

Frequently Asked Questions