multiplayer refactor
This commit is contained in:
515
Runtime/Engine/Code/Network/NetworkSystem.cs
Normal file
515
Runtime/Engine/Code/Network/NetworkSystem.cs
Normal file
@@ -0,0 +1,515 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Runtime.CompilerServices;
|
||||
using System.Threading;
|
||||
using Cysharp.Threading.Tasks;
|
||||
using RebootKit.Engine.Extensions;
|
||||
using RebootKit.Engine.Foundation;
|
||||
using RebootKit.Engine.Main;
|
||||
using RebootKit.Engine.Simulation;
|
||||
using Unity.Collections;
|
||||
using Unity.Netcode;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Assertions;
|
||||
using Logger = RebootKit.Engine.Foundation.Logger;
|
||||
|
||||
namespace RebootKit.Engine.Network {
|
||||
enum NetworkClientSyncState {
|
||||
NotReady,
|
||||
LoadingWorld,
|
||||
PreparingForActorsSync,
|
||||
SyncingActors,
|
||||
Ready
|
||||
}
|
||||
|
||||
struct NetworkClientState : INetworkSerializable {
|
||||
public ulong ClientID;
|
||||
public NetworkClientSyncState SyncState;
|
||||
public int ActorsSyncPacketsLeft;
|
||||
|
||||
public NetworkPacketQueue ReliableQueue;
|
||||
public NetworkPacketQueue UnreliableQueue;
|
||||
|
||||
public bool IsReady {
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
get {
|
||||
return SyncState == NetworkClientSyncState.Ready;
|
||||
}
|
||||
}
|
||||
|
||||
public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter {
|
||||
serializer.SerializeValue(ref ClientID);
|
||||
serializer.SerializeValue(ref SyncState);
|
||||
serializer.SerializeValue(ref ActorsSyncPacketsLeft);
|
||||
}
|
||||
}
|
||||
|
||||
struct NetworkPacketTarget {
|
||||
public enum Type {
|
||||
AllClients,
|
||||
Single
|
||||
}
|
||||
|
||||
public Type TargetType;
|
||||
public ulong ClientID;
|
||||
|
||||
public static NetworkPacketTarget AllClients() {
|
||||
return new NetworkPacketTarget {
|
||||
TargetType = Type.AllClients,
|
||||
ClientID = 0
|
||||
};
|
||||
}
|
||||
|
||||
public static NetworkPacketTarget Single(ulong clientID) {
|
||||
return new NetworkPacketTarget {
|
||||
TargetType = Type.Single,
|
||||
ClientID = clientID
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
public class NetworkSystem : NetworkBehaviour {
|
||||
[ConfigVar("sv.tick_rate", 32, "Server tick rate in Hz", CVarFlags.Server)]
|
||||
public static ConfigVar TickRate;
|
||||
|
||||
static readonly Logger s_Logger = new Logger(nameof(NetworkSystem));
|
||||
|
||||
[field: SerializeField] public ActorsManager Actors { get; private set; }
|
||||
|
||||
internal readonly Dictionary<ulong, NetworkClientState> Clients = new Dictionary<ulong, NetworkClientState>();
|
||||
|
||||
public FixedString512Bytes WorldID { get; private set; } = new FixedString512Bytes("");
|
||||
bool m_IsChangingWorld = false;
|
||||
|
||||
float m_TickTimer;
|
||||
|
||||
public ulong TickCount { get; private set; }
|
||||
public event Action<ulong> ServerTick = delegate { };
|
||||
|
||||
public ulong LocalClientID {
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
get {
|
||||
return NetworkManager.Singleton.LocalClientId;
|
||||
}
|
||||
}
|
||||
|
||||
NetworkPacketQueue m_ReliablePacketQueue;
|
||||
NetworkPacketQueue m_UnreliablePacketQueue;
|
||||
|
||||
//
|
||||
// @MARK: Unity callbacks
|
||||
//
|
||||
void Awake() {
|
||||
RR.NetworkSystemInstance = this;
|
||||
|
||||
m_ReliablePacketQueue = new NetworkPacketQueue(1024 * 4);
|
||||
m_UnreliablePacketQueue = new NetworkPacketQueue(1024);
|
||||
}
|
||||
|
||||
void Update() {
|
||||
float deltaTime = Time.deltaTime;
|
||||
|
||||
float serverDeltaTime = 1.0f / TickRate.IndexValue;
|
||||
m_TickTimer += deltaTime;
|
||||
|
||||
while (m_TickTimer >= serverDeltaTime) {
|
||||
m_TickTimer -= serverDeltaTime;
|
||||
|
||||
if (RR.IsServer()) {
|
||||
Actors.ServerTick(serverDeltaTime);
|
||||
|
||||
ServerTick?.Invoke(TickCount);
|
||||
TickCount++;
|
||||
|
||||
FlushNetworkPackets();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// @MARK: NetworkBehaviour callbacks
|
||||
//
|
||||
public override void OnNetworkSpawn() {
|
||||
base.OnNetworkSpawn();
|
||||
|
||||
NetworkManager.Singleton.OnClientConnectedCallback += OnClientConnected;
|
||||
NetworkManager.Singleton.OnClientDisconnectCallback += OnClientDisconnect;
|
||||
}
|
||||
|
||||
public override void OnNetworkDespawn() {
|
||||
base.OnNetworkDespawn();
|
||||
|
||||
NetworkManager.Singleton.OnClientConnectedCallback -= OnClientConnected;
|
||||
NetworkManager.Singleton.OnClientDisconnectCallback -= OnClientDisconnect;
|
||||
}
|
||||
|
||||
void OnClientConnected(ulong clientID) {
|
||||
if (!IsServer) {
|
||||
return;
|
||||
}
|
||||
|
||||
s_Logger.Info($"OnClientConnected: {clientID}");
|
||||
|
||||
NetworkClientState newClientState = new NetworkClientState {
|
||||
ClientID = clientID,
|
||||
SyncState = NetworkClientSyncState.NotReady,
|
||||
ReliableQueue = new NetworkPacketQueue(1024 * 4),
|
||||
UnreliableQueue = new NetworkPacketQueue(512)
|
||||
};
|
||||
Clients.Add(clientID, newClientState);
|
||||
|
||||
if (clientID != NetworkManager.Singleton.LocalClientId) {
|
||||
foreach (NetworkClientState state in Clients.Values) {
|
||||
UpdateClientStateRpc(state, RpcTarget.Single(clientID, RpcTargetUse.Temp));
|
||||
}
|
||||
}
|
||||
|
||||
if (!WorldID.IsEmpty) {
|
||||
s_Logger.Info($"Synchronizing world load for client {clientID} with world ID '{WorldID}'");
|
||||
ClientLoadWorldRpc(WorldID.ToString(), RpcTarget.Single(clientID, RpcTargetUse.Temp));
|
||||
}
|
||||
}
|
||||
|
||||
void OnClientDisconnect(ulong clientID) {
|
||||
s_Logger.Info($"OnClientDisconnect: {clientID}");
|
||||
Clients.Remove(clientID);
|
||||
}
|
||||
|
||||
//
|
||||
// @MARK: Server API
|
||||
//
|
||||
public void KickClient(ulong clientID, string reason = "Kicked by server") {
|
||||
if (!IsServer) {
|
||||
s_Logger.Error("Only server can kick clients.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (NetworkManager.Singleton.ConnectedClients.TryGetValue(clientID, out NetworkClient client)) {
|
||||
NetworkManager.Singleton.DisconnectClient(clientID, reason);
|
||||
s_Logger.Info($"Kicked client {clientID}: {reason}");
|
||||
} else {
|
||||
s_Logger.Error($"Client {clientID} not found.");
|
||||
}
|
||||
}
|
||||
|
||||
public void SetCurrentWorld(string worldID) {
|
||||
if (!IsServer) {
|
||||
s_Logger.Error("Only server can set the current world.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (m_IsChangingWorld) {
|
||||
s_Logger.Error($"Already changing world to '{WorldID}'. Please wait until the current world change is complete.");
|
||||
return;
|
||||
}
|
||||
|
||||
WorldConfigAsset worldConfigAsset = RR.GetWorldConfigAsset(worldID);
|
||||
if (worldConfigAsset is null) {
|
||||
s_Logger.Error($"Failed to set current world: World config asset for '{worldID}' not found.");
|
||||
return;
|
||||
}
|
||||
|
||||
WorldID = worldID;
|
||||
|
||||
foreach ((ulong _, NetworkClientState clientState) in Clients.ToList()) {
|
||||
NetworkClientState state = clientState;
|
||||
state.SyncState = NetworkClientSyncState.LoadingWorld;
|
||||
UpdateClientState(state);
|
||||
}
|
||||
|
||||
ServerLoadWorldAsync(worldConfigAsset, destroyCancellationToken).Forget();
|
||||
}
|
||||
|
||||
async UniTask ServerLoadWorldAsync(WorldConfigAsset asset, CancellationToken cancellationToken) {
|
||||
s_Logger.Info($"ServerLoadWorldAsync: {asset.Config.name}");
|
||||
|
||||
m_IsChangingWorld = true;
|
||||
|
||||
RR.World.Unload();
|
||||
RR.CloseMainMenu();
|
||||
|
||||
await RR.World.LoadAsync(asset.Config, cancellationToken);
|
||||
|
||||
m_IsChangingWorld = false;
|
||||
|
||||
if (!TryGetClientState(NetworkManager.Singleton.LocalClientId, out NetworkClientState localClientState)) {
|
||||
s_Logger.Error($"Local client state not found for client ID {NetworkManager.Singleton.LocalClientId}.");
|
||||
RR.Disconnect();
|
||||
return;
|
||||
}
|
||||
|
||||
localClientState.SyncState = NetworkClientSyncState.Ready;
|
||||
UpdateClientState(localClientState);
|
||||
|
||||
RR.GameInstance.PlayerBecameReady(localClientState.ClientID);
|
||||
|
||||
ClientLoadWorldRpc(asset.name, RpcTarget.NotMe);
|
||||
}
|
||||
|
||||
[Rpc(SendTo.SpecifiedInParams, Delivery = RpcDelivery.Reliable)]
|
||||
void ClientLoadWorldRpc(string worldID, RpcParams rpcParams) {
|
||||
WorldConfigAsset worldConfigAsset = RR.GetWorldConfigAsset(worldID);
|
||||
if (worldConfigAsset is null) {
|
||||
s_Logger.Error($"World config asset for '{worldID}' not found.");
|
||||
RR.Disconnect();
|
||||
return;
|
||||
}
|
||||
|
||||
ClientLoadWorldAsync(worldID, destroyCancellationToken).Forget();
|
||||
}
|
||||
|
||||
async UniTask ClientLoadWorldAsync(string worldID, CancellationToken cancellationToken) {
|
||||
s_Logger.Info($"ClientLoadWorldAsync: {worldID}");
|
||||
|
||||
WorldConfigAsset worldConfigAsset = RR.GetWorldConfigAsset(worldID);
|
||||
if (worldConfigAsset is null) {
|
||||
s_Logger.Error($"World config asset for '{worldID}' not found.");
|
||||
return;
|
||||
}
|
||||
|
||||
RR.World.Unload();
|
||||
RR.CloseMainMenu();
|
||||
|
||||
await RR.World.LoadAsync(worldConfigAsset.Config, cancellationToken);
|
||||
|
||||
WorldID = worldID;
|
||||
ClientLoadedWorldRpc(worldID);
|
||||
}
|
||||
|
||||
[Rpc(SendTo.Server, Delivery = RpcDelivery.Reliable)]
|
||||
void ClientLoadedWorldRpc(string worldID, RpcParams rpcParams = default) {
|
||||
ulong clientID = rpcParams.Receive.SenderClientId;
|
||||
|
||||
if (!WorldID.Equals(worldID)) {
|
||||
s_Logger.Error($"Client {clientID} tried to load world '{worldID}', but server is in world '{WorldID}'.");
|
||||
NetworkManager.Singleton.DisconnectClient(clientID, "World mismatch!");
|
||||
return;
|
||||
}
|
||||
|
||||
if (Clients.TryGetValue(clientID, out NetworkClientState clientState)) {
|
||||
Actors.InitializeActorsForClient(clientID);
|
||||
} else {
|
||||
NetworkManager.Singleton.DisconnectClient(clientID, "Client is not registered!");
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// @MARK: Internal
|
||||
//
|
||||
internal bool TryGetClientState(ulong clientID, out NetworkClientState clientState) {
|
||||
return Clients.TryGetValue(clientID, out clientState);
|
||||
}
|
||||
|
||||
internal void UpdateClientState(NetworkClientState clientState) {
|
||||
if (!IsServer) {
|
||||
s_Logger.Error("UpdateClientState can only be called on the server.");
|
||||
return;
|
||||
}
|
||||
|
||||
Clients[clientState.ClientID] = clientState;
|
||||
UpdateClientStateRpc(clientState, RpcTarget.NotServer);
|
||||
}
|
||||
|
||||
[Rpc(SendTo.SpecifiedInParams, Delivery = RpcDelivery.Reliable)]
|
||||
void UpdateClientStateRpc(NetworkClientState newState, RpcParams rpcParams) {
|
||||
Clients[newState.ClientID] = newState;
|
||||
}
|
||||
|
||||
internal void ClientSynchronizedActors(ulong clientID) {
|
||||
if (TryGetClientState(clientID, out NetworkClientState state)) {
|
||||
state.SyncState = NetworkClientSyncState.Ready;
|
||||
UpdateClientState(state);
|
||||
|
||||
RR.GameInstance.PlayerBecameReady(clientID);
|
||||
} else {
|
||||
s_Logger.Error($"Client state for {clientID} not found.");
|
||||
}
|
||||
}
|
||||
|
||||
internal int GetReadyClientsCount() {
|
||||
int count = 0;
|
||||
foreach (NetworkClientState clientState in Clients.Values) {
|
||||
if (clientState.IsReady) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
//
|
||||
// @MARK: Network packets
|
||||
//
|
||||
NetworkPacketQueue GetPacketQueue(NetworkPacketTarget target, bool reliable) {
|
||||
if (target.TargetType == NetworkPacketTarget.Type.AllClients) {
|
||||
return reliable ? m_ReliablePacketQueue : m_UnreliablePacketQueue;
|
||||
}
|
||||
|
||||
if (target.TargetType == NetworkPacketTarget.Type.Single) {
|
||||
if (TryGetClientState(target.ClientID, out NetworkClientState clientState)) {
|
||||
return reliable ? clientState.ReliableQueue : clientState.UnreliableQueue;
|
||||
}
|
||||
|
||||
s_Logger.Error($"Client state for {target.ClientID} not found.");
|
||||
return null;
|
||||
}
|
||||
|
||||
s_Logger.Error($"Invalid network packet target type: {target.TargetType}");
|
||||
return null;
|
||||
}
|
||||
|
||||
internal void WriteActorState(NetworkPacketTarget target, ulong actorID, IActorData actorData) {
|
||||
NetworkPacketQueue queue = GetPacketQueue(target, true);
|
||||
queue.WriteActorState(actorID, actorData);
|
||||
}
|
||||
|
||||
internal void WriteActorTransformState(NetworkPacketTarget target,
|
||||
ulong actorID,
|
||||
ActorTransformSyncData transformData) {
|
||||
NetworkPacketQueue queue = GetPacketQueue(target, false);
|
||||
queue.WriteActorTransformState(actorID, transformData);
|
||||
}
|
||||
|
||||
internal void WriteActorCoreState(NetworkPacketTarget target,
|
||||
ulong actorID,
|
||||
ActorCoreStateSnapshot coreData) {
|
||||
NetworkPacketQueue queue = GetPacketQueue(target, true);
|
||||
queue.WriteActorCoreState(actorID, coreData);
|
||||
}
|
||||
|
||||
internal void WriteSpawnActor(NetworkPacketTarget target,
|
||||
string assetGUID,
|
||||
ulong actorID,
|
||||
ActorCoreStateSnapshot coreState,
|
||||
IActorData actorData) {
|
||||
NetworkPacketQueue queue = GetPacketQueue(target, true);
|
||||
queue.WriteSpawnActor(assetGUID, actorID, coreState, actorData);
|
||||
}
|
||||
|
||||
internal void WriteActorSynchronize(NetworkPacketTarget target,
|
||||
ulong actorID,
|
||||
ActorCoreStateSnapshot coreState,
|
||||
IActorData actorData) {
|
||||
NetworkPacketQueue queue = GetPacketQueue(target, true);
|
||||
queue.WriteActorSynchronize(actorID, coreState, actorData);
|
||||
}
|
||||
|
||||
void FlushNetworkPackets() {
|
||||
if (!RR.IsServer()) {
|
||||
return;
|
||||
}
|
||||
|
||||
foreach (NetworkPacket networkPacket in m_ReliablePacketQueue.NetworkPackets) {
|
||||
foreach ((ulong clientID, NetworkClientState state) in RR.NetworkSystemInstance.Clients) {
|
||||
if (clientID == NetworkManager.Singleton.LocalClientId) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (networkPacket.EntityCount == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state.IsReady) {
|
||||
ReliableReceiveNetworkPacketRpc(networkPacket.Data,
|
||||
RpcTarget.Single(clientID, RpcTargetUse.Temp));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
foreach (NetworkPacket networkPacket in m_UnreliablePacketQueue.NetworkPackets) {
|
||||
foreach ((ulong clientID, NetworkClientState state) in RR.NetworkSystemInstance.Clients) {
|
||||
if (clientID == NetworkManager.Singleton.LocalClientId) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (networkPacket.EntityCount == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (state.IsReady) {
|
||||
UnreliableReceiveNetworkPacketRpc(networkPacket.Data,
|
||||
RpcTarget.Single(clientID, RpcTargetUse.Temp));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
m_ReliablePacketQueue.Clear();
|
||||
m_UnreliablePacketQueue.Clear();
|
||||
|
||||
foreach (NetworkClientState clientState in Clients.Values) {
|
||||
if (clientState.ClientID == NetworkManager.Singleton.LocalClientId) {
|
||||
continue;
|
||||
}
|
||||
|
||||
foreach (NetworkPacket networkPacket in clientState.ReliableQueue.NetworkPackets) {
|
||||
if (networkPacket.EntityCount == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
ReliableReceiveNetworkPacketRpc(networkPacket.Data,
|
||||
RpcTarget.Single(clientState.ClientID, RpcTargetUse.Temp));
|
||||
}
|
||||
|
||||
foreach (NetworkPacket networkPacket in clientState.UnreliableQueue.NetworkPackets) {
|
||||
if (networkPacket.EntityCount == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
UnreliableReceiveNetworkPacketRpc(networkPacket.Data,
|
||||
RpcTarget.Single(clientState.ClientID, RpcTargetUse.Temp));
|
||||
}
|
||||
|
||||
clientState.ReliableQueue.Clear();
|
||||
clientState.UnreliableQueue.Clear();
|
||||
}
|
||||
}
|
||||
|
||||
[Rpc(SendTo.SpecifiedInParams, Delivery = RpcDelivery.Reliable)]
|
||||
void ReliableReceiveNetworkPacketRpc(NativeArray<byte> data, RpcParams rpcParams) {
|
||||
OnReceivedNetworkPacket(data);
|
||||
}
|
||||
|
||||
[Rpc(SendTo.SpecifiedInParams, Delivery = RpcDelivery.Unreliable)]
|
||||
void UnreliableReceiveNetworkPacketRpc(NativeArray<byte> data, RpcParams rpcParams) {
|
||||
OnReceivedNetworkPacket(data);
|
||||
}
|
||||
|
||||
void OnReceivedNetworkPacket(NativeArray<byte> data) {
|
||||
using NetworkBufferReader reader = new NetworkBufferReader(data);
|
||||
|
||||
NetworkPacketHeader packetHeader = new NetworkPacketHeader();
|
||||
packetHeader.Deserialize(reader);
|
||||
|
||||
// s_Logger.Info($"Received packet: MagicNumber={packetHeader.MagicNumber}, Version={packetHeader.Version}, EntityCount={packetHeader.EntityCount}");
|
||||
|
||||
Assert.IsTrue(packetHeader.MagicNumber == RConsts.k_NetworkPacketMagicNumber,
|
||||
"Received packet with invalid magic number.");
|
||||
|
||||
if (packetHeader.EntityCount == 0) {
|
||||
s_Logger.Info("Received packet with no entities.\n" + data.ToHexString());
|
||||
}
|
||||
|
||||
for (int i = 0; i < packetHeader.EntityCount; i++) {
|
||||
NetworkDataHeader dataHeader = new NetworkDataHeader();
|
||||
dataHeader.Deserialize(reader);
|
||||
|
||||
// s_Logger.Info($"Received entity: Type={dataHeader.Type}, ActorID={dataHeader.ActorID}, DataSize={dataHeader.DataSize}");
|
||||
|
||||
if (dataHeader.Type == NetworkDataType.None) {
|
||||
s_Logger.Info("Data of packet with entry with type None:\n" + data.ToHexString());
|
||||
}
|
||||
|
||||
Assert.IsTrue(dataHeader.Type != NetworkDataType.None, "Received packet with invalid data type.");
|
||||
|
||||
reader.Read(out NativeArray<byte> entityData, dataHeader.DataSize, Allocator.Temp);
|
||||
OnReceivedEntity(dataHeader, entityData);
|
||||
|
||||
entityData.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
void OnReceivedEntity(NetworkDataHeader header, NativeArray<byte> data) {
|
||||
Actors.OnReceivedEntity(header, data);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user