515 lines
19 KiB
C#
515 lines
19 KiB
C#
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);
|
|
}
|
|
}
|
|
} |