fe02ca682e
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com). ## [1.2.0] - 2022-11-21 ### Added - Added protected method `NetworkBehaviour.OnSynchronize` which is invoked during the initial `NetworkObject` synchronization process. This provides users the ability to include custom serialization information that will be applied to the `NetworkBehaviour` prior to the `NetworkObject` being spawned. (#2298) - Added support for different versions of the SDK to talk to each other in circumstances where changes permit it. Starting with this version and into future versions, patch versions should be compatible as long as the minor version is the same. (#2290) - Added `NetworkObject` auto-add helper and Multiplayer Tools install reminder settings to Project Settings. (#2285) - Added `public string DisconnectReason` getter to `NetworkManager` and `string Reason` to `ConnectionApprovalResponse`. Allows connection approval to communicate back a reason. Also added `public void DisconnectClient(ulong clientId, string reason)` allowing setting a disconnection reason, when explicitly disconnecting a client. (#2280) ### Changed - Changed 3rd-party `XXHash` (32 & 64) implementation with an in-house reimplementation (#2310) - When `NetworkConfig.EnsureNetworkVariableLengthSafety` is disabled `NetworkVariable` fields do not write the additional `ushort` size value (_which helps to reduce the total synchronization message size_), but when enabled it still writes the additional `ushort` value. (#2298) - Optimized bandwidth usage by encoding most integer fields using variable-length encoding. (#2276) ### Fixed - Fixed issue where `NetworkTransform` components nested under a parent with a `NetworkObject` component (i.e. network prefab) would not have their associated `GameObject`'s transform synchronized. (#2298) - Fixed issue where `NetworkObject`s that failed to instantiate could cause the entire synchronization pipeline to be disrupted/halted for a connecting client. (#2298) - Fixed issue where in-scene placed `NetworkObject`s nested under a `GameObject` would be added to the orphaned children list causing continual console warning log messages. (#2298) - Custom messages are now properly received by the local client when they're sent while running in host mode. (#2296) - Fixed issue where the host would receive more than one event completed notification when loading or unloading a scene only when no clients were connected. (#2292) - Fixed an issue in `UnityTransport` where an error would be logged if the 'Use Encryption' flag was enabled with a Relay configuration that used a secure protocol. (#2289) - Fixed issue where in-scene placed `NetworkObjects` were not honoring the `AutoObjectParentSync` property. (#2281) - Fixed the issue where `NetworkManager.OnClientConnectedCallback` was being invoked before in-scene placed `NetworkObject`s had been spawned when starting `NetworkManager` as a host. (#2277) - Creating a `FastBufferReader` with `Allocator.None` will not result in extra memory being allocated for the buffer (since it's owned externally in that scenario). (#2265) ### Removed - Removed the `NetworkObject` auto-add and Multiplayer Tools install reminder settings from the Menu interface. (#2285)
1051 lines
44 KiB
C#
1051 lines
44 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using System.Reflection;
|
|
using Unity.Collections;
|
|
|
|
namespace Unity.Netcode
|
|
{
|
|
/// <summary>
|
|
/// The base class to override to write network code. Inherits MonoBehaviour
|
|
/// </summary>
|
|
public abstract class NetworkBehaviour : MonoBehaviour
|
|
{
|
|
#pragma warning disable IDE1006 // disable naming rule violation check
|
|
// RuntimeAccessModifiersILPP will make this `protected`
|
|
internal enum __RpcExecStage
|
|
{
|
|
None = 0,
|
|
Server = 1,
|
|
Client = 2
|
|
}
|
|
|
|
|
|
// NetworkBehaviourILPP will override this in derived classes to return the name of the concrete type
|
|
internal virtual string __getTypeName() => nameof(NetworkBehaviour);
|
|
|
|
[NonSerialized]
|
|
// RuntimeAccessModifiersILPP will make this `protected`
|
|
internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.None;
|
|
#pragma warning restore IDE1006 // restore naming rule violation check
|
|
|
|
private const int k_RpcMessageDefaultSize = 1024; // 1k
|
|
private const int k_RpcMessageMaximumSize = 1024 * 64; // 64k
|
|
|
|
#pragma warning disable IDE1006 // disable naming rule violation check
|
|
// RuntimeAccessModifiersILPP will make this `protected`
|
|
internal FastBufferWriter __beginSendServerRpc(uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
|
|
#pragma warning restore IDE1006 // restore naming rule violation check
|
|
{
|
|
return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
|
|
}
|
|
|
|
#pragma warning disable IDE1006 // disable naming rule violation check
|
|
// RuntimeAccessModifiersILPP will make this `protected`
|
|
internal void __endSendServerRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ServerRpcParams serverRpcParams, RpcDelivery rpcDelivery)
|
|
#pragma warning restore IDE1006 // restore naming rule violation check
|
|
{
|
|
var serverRpcMessage = new ServerRpcMessage
|
|
{
|
|
Metadata = new RpcMetadata
|
|
{
|
|
NetworkObjectId = NetworkObjectId,
|
|
NetworkBehaviourId = NetworkBehaviourId,
|
|
NetworkRpcMethodId = rpcMethodId,
|
|
},
|
|
WriteBuffer = bufferWriter
|
|
};
|
|
|
|
NetworkDelivery networkDelivery;
|
|
switch (rpcDelivery)
|
|
{
|
|
default:
|
|
case RpcDelivery.Reliable:
|
|
networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
|
|
break;
|
|
case RpcDelivery.Unreliable:
|
|
if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
|
|
{
|
|
throw new OverflowException("RPC parameters are too large for unreliable delivery.");
|
|
}
|
|
networkDelivery = NetworkDelivery.Unreliable;
|
|
break;
|
|
}
|
|
|
|
var rpcWriteSize = 0;
|
|
|
|
// If we are a server/host then we just no op and send to ourself
|
|
if (IsHost || IsServer)
|
|
{
|
|
using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
|
|
var context = new NetworkContext
|
|
{
|
|
SenderId = NetworkManager.ServerClientId,
|
|
Timestamp = Time.realtimeSinceStartup,
|
|
SystemOwner = NetworkManager,
|
|
// header information isn't valid since it's not a real message.
|
|
// RpcMessage doesn't access this stuff so it's just left empty.
|
|
Header = new MessageHeader(),
|
|
SerializedHeaderSize = 0,
|
|
MessageSize = 0
|
|
};
|
|
serverRpcMessage.ReadBuffer = tempBuffer;
|
|
serverRpcMessage.Handle(ref context);
|
|
rpcWriteSize = tempBuffer.Length;
|
|
}
|
|
else
|
|
{
|
|
rpcWriteSize = NetworkManager.SendMessage(ref serverRpcMessage, networkDelivery, NetworkManager.ServerClientId);
|
|
}
|
|
|
|
bufferWriter.Dispose();
|
|
|
|
#if DEVELOPMENT_BUILD || UNITY_EDITOR
|
|
if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
|
|
{
|
|
NetworkManager.NetworkMetrics.TrackRpcSent(
|
|
NetworkManager.ServerClientId,
|
|
NetworkObject,
|
|
rpcMethodName,
|
|
__getTypeName(),
|
|
rpcWriteSize);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#pragma warning disable IDE1006 // disable naming rule violation check
|
|
// RuntimeAccessModifiersILPP will make this `protected`
|
|
internal FastBufferWriter __beginSendClientRpc(uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery)
|
|
#pragma warning restore IDE1006 // restore naming rule violation check
|
|
{
|
|
return new FastBufferWriter(k_RpcMessageDefaultSize, Allocator.Temp, k_RpcMessageMaximumSize);
|
|
}
|
|
|
|
#pragma warning disable IDE1006 // disable naming rule violation check
|
|
// RuntimeAccessModifiersILPP will make this `protected`
|
|
internal void __endSendClientRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, ClientRpcParams clientRpcParams, RpcDelivery rpcDelivery)
|
|
#pragma warning restore IDE1006 // restore naming rule violation check
|
|
{
|
|
var clientRpcMessage = new ClientRpcMessage
|
|
{
|
|
Metadata = new RpcMetadata
|
|
{
|
|
NetworkObjectId = NetworkObjectId,
|
|
NetworkBehaviourId = NetworkBehaviourId,
|
|
NetworkRpcMethodId = rpcMethodId,
|
|
},
|
|
WriteBuffer = bufferWriter
|
|
};
|
|
|
|
NetworkDelivery networkDelivery;
|
|
switch (rpcDelivery)
|
|
{
|
|
default:
|
|
case RpcDelivery.Reliable:
|
|
networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
|
|
break;
|
|
case RpcDelivery.Unreliable:
|
|
if (bufferWriter.Length > MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE)
|
|
{
|
|
throw new OverflowException("RPC parameters are too large for unreliable delivery.");
|
|
}
|
|
networkDelivery = NetworkDelivery.Unreliable;
|
|
break;
|
|
}
|
|
|
|
var rpcWriteSize = 0;
|
|
|
|
// We check to see if we need to shortcut for the case where we are the host/server and we can send a clientRPC
|
|
// to ourself. Sadly we have to figure that out from the list of clientIds :(
|
|
bool shouldSendToHost = false;
|
|
if (clientRpcParams.Send.TargetClientIds != null)
|
|
{
|
|
foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
|
|
{
|
|
if (targetClientId == NetworkManager.ServerClientId)
|
|
{
|
|
shouldSendToHost = true;
|
|
break;
|
|
}
|
|
|
|
// Check to make sure we are sending to only observers, if not log an error.
|
|
if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
|
|
{
|
|
NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
|
|
}
|
|
}
|
|
|
|
rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, in clientRpcParams.Send.TargetClientIds);
|
|
}
|
|
else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
|
|
{
|
|
foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
|
|
{
|
|
if (targetClientId == NetworkManager.ServerClientId)
|
|
{
|
|
shouldSendToHost = true;
|
|
break;
|
|
}
|
|
|
|
// Check to make sure we are sending to only observers, if not log an error.
|
|
if (NetworkManager.LogLevel >= LogLevel.Error && !NetworkObject.Observers.Contains(targetClientId))
|
|
{
|
|
NetworkLog.LogError(GenerateObserverErrorMessage(clientRpcParams, targetClientId));
|
|
}
|
|
}
|
|
|
|
rpcWriteSize = NetworkManager.SendMessage(ref clientRpcMessage, networkDelivery, clientRpcParams.Send.TargetClientIdsNativeArray.Value);
|
|
}
|
|
else
|
|
{
|
|
var observerEnumerator = NetworkObject.Observers.GetEnumerator();
|
|
while (observerEnumerator.MoveNext())
|
|
{
|
|
// Skip over the host
|
|
if (IsHost && observerEnumerator.Current == NetworkManager.LocalClientId)
|
|
{
|
|
shouldSendToHost = true;
|
|
continue;
|
|
}
|
|
rpcWriteSize = NetworkManager.MessagingSystem.SendMessage(ref clientRpcMessage, networkDelivery, observerEnumerator.Current);
|
|
}
|
|
}
|
|
|
|
// If we are a server/host then we just no op and send to ourself
|
|
if (shouldSendToHost)
|
|
{
|
|
using var tempBuffer = new FastBufferReader(bufferWriter, Allocator.Temp);
|
|
var context = new NetworkContext
|
|
{
|
|
SenderId = NetworkManager.ServerClientId,
|
|
Timestamp = Time.realtimeSinceStartup,
|
|
SystemOwner = NetworkManager,
|
|
// header information isn't valid since it's not a real message.
|
|
// RpcMessage doesn't access this stuff so it's just left empty.
|
|
Header = new MessageHeader(),
|
|
SerializedHeaderSize = 0,
|
|
MessageSize = 0
|
|
};
|
|
clientRpcMessage.ReadBuffer = tempBuffer;
|
|
clientRpcMessage.Handle(ref context);
|
|
}
|
|
|
|
bufferWriter.Dispose();
|
|
|
|
#if DEVELOPMENT_BUILD || UNITY_EDITOR
|
|
if (NetworkManager.__rpc_name_table.TryGetValue(rpcMethodId, out var rpcMethodName))
|
|
{
|
|
if (clientRpcParams.Send.TargetClientIds != null)
|
|
{
|
|
foreach (var targetClientId in clientRpcParams.Send.TargetClientIds)
|
|
{
|
|
NetworkManager.NetworkMetrics.TrackRpcSent(
|
|
targetClientId,
|
|
NetworkObject,
|
|
rpcMethodName,
|
|
__getTypeName(),
|
|
rpcWriteSize);
|
|
}
|
|
}
|
|
else if (clientRpcParams.Send.TargetClientIdsNativeArray != null)
|
|
{
|
|
foreach (var targetClientId in clientRpcParams.Send.TargetClientIdsNativeArray)
|
|
{
|
|
NetworkManager.NetworkMetrics.TrackRpcSent(
|
|
targetClientId,
|
|
NetworkObject,
|
|
rpcMethodName,
|
|
__getTypeName(),
|
|
rpcWriteSize);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var observerEnumerator = NetworkObject.Observers.GetEnumerator();
|
|
while (observerEnumerator.MoveNext())
|
|
{
|
|
NetworkManager.NetworkMetrics.TrackRpcSent(
|
|
observerEnumerator.Current,
|
|
NetworkObject,
|
|
rpcMethodName,
|
|
__getTypeName(),
|
|
rpcWriteSize);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
internal string GenerateObserverErrorMessage(ClientRpcParams clientRpcParams, ulong targetClientId)
|
|
{
|
|
var containerNameHoldingId = clientRpcParams.Send.TargetClientIds != null ? nameof(ClientRpcParams.Send.TargetClientIds) : nameof(ClientRpcParams.Send.TargetClientIdsNativeArray);
|
|
return $"Sending ClientRpc to non-observer! {containerNameHoldingId} contains clientId {targetClientId} that is not an observer!";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the NetworkManager that owns this NetworkBehaviour instance
|
|
/// See note around `NetworkObject` for how there is a chicken / egg problem when we are not initialized
|
|
/// </summary>
|
|
public NetworkManager NetworkManager
|
|
{
|
|
get
|
|
{
|
|
if (NetworkObject?.NetworkManager != null)
|
|
{
|
|
return NetworkObject?.NetworkManager;
|
|
}
|
|
|
|
return NetworkManager.Singleton;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a NetworkObject is assigned, it will return whether or not this NetworkObject
|
|
/// is the local player object. If no NetworkObject is assigned it will always return false.
|
|
/// </summary>
|
|
public bool IsLocalPlayer { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets if the object is owned by the local player or if the object is the local player object
|
|
/// </summary>
|
|
public bool IsOwner { get; internal set; }
|
|
|
|
/// <summary>
|
|
/// Gets if we are executing as server
|
|
/// </summary>
|
|
protected bool IsServer { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets if we are executing as client
|
|
/// </summary>
|
|
protected bool IsClient { get; private set; }
|
|
|
|
|
|
/// <summary>
|
|
/// Gets if we are executing as Host, I.E Server and Client
|
|
/// </summary>
|
|
protected bool IsHost { get; private set; }
|
|
|
|
/// <summary>
|
|
/// Gets Whether or not the object has a owner
|
|
/// </summary>
|
|
public bool IsOwnedByServer { get; internal set; }
|
|
|
|
/// <summary>
|
|
/// Used to determine if it is safe to access NetworkObject and NetworkManager from within a NetworkBehaviour component
|
|
/// Primarily useful when checking NetworkObject/NetworkManager properties within FixedUpate
|
|
/// </summary>
|
|
public bool IsSpawned { get; internal set; }
|
|
|
|
internal bool IsBehaviourEditable()
|
|
{
|
|
// Only server can MODIFY. So allow modification if network is either not running or we are server
|
|
return !m_NetworkObject ||
|
|
m_NetworkObject.NetworkManager == null ||
|
|
m_NetworkObject.NetworkManager.IsListening == false ||
|
|
m_NetworkObject.NetworkManager.IsServer;
|
|
}
|
|
|
|
/// TODO: this needs an overhaul. It's expensive, it's ja little naive in how it looks for networkObject in
|
|
/// its parent and worst, it creates a puzzle if you are a NetworkBehaviour wanting to see if you're live or not
|
|
/// (e.g. editor code). All you want to do is find out if NetworkManager is null, but to do that you
|
|
/// need NetworkObject, but if you try and grab NetworkObject and NetworkManager isn't up you'll get
|
|
/// the warning below. This is why IsBehaviourEditable had to be created. Matt was going to re-do
|
|
/// how NetworkObject works but it was close to the release and too risky to change
|
|
/// <summary>
|
|
/// Gets the NetworkObject that owns this NetworkBehaviour instance
|
|
/// </summary>
|
|
public NetworkObject NetworkObject
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
if (m_NetworkObject == null)
|
|
{
|
|
m_NetworkObject = GetComponentInParent<NetworkObject>();
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// ShutdownInProgress check:
|
|
// This prevents an edge case scenario where the NetworkManager is shutting down but user code
|
|
// in Update and/or in FixedUpdate could still be checking NetworkBehaviour.NetworkObject directly (i.e. does it exist?)
|
|
// or NetworkBehaviour.IsSpawned (i.e. to early exit if not spawned) which, in turn, could generate several Warning messages
|
|
// per spawned NetworkObject. Checking for ShutdownInProgress prevents these unnecessary LogWarning messages.
|
|
// We must check IsSpawned, otherwise a warning will be logged under certain valid conditions (see OnDestroy)
|
|
if (IsSpawned && m_NetworkObject == null && (NetworkManager.Singleton == null || !NetworkManager.Singleton.ShutdownInProgress))
|
|
{
|
|
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
|
{
|
|
NetworkLog.LogWarning($"Could not get {nameof(NetworkObject)} for the {nameof(NetworkBehaviour)}. Are you missing a {nameof(NetworkObject)} component?");
|
|
}
|
|
}
|
|
|
|
return m_NetworkObject;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether or not this NetworkBehaviour instance has a NetworkObject owner.
|
|
/// </summary>
|
|
public bool HasNetworkObject => NetworkObject != null;
|
|
|
|
private NetworkObject m_NetworkObject = null;
|
|
|
|
/// <summary>
|
|
/// Gets the NetworkId of the NetworkObject that owns this NetworkBehaviour
|
|
/// </summary>
|
|
public ulong NetworkObjectId { get; internal set; }
|
|
|
|
/// <summary>
|
|
/// Gets NetworkId for this NetworkBehaviour from the owner NetworkObject
|
|
/// </summary>
|
|
public ushort NetworkBehaviourId { get; internal set; }
|
|
|
|
/// <summary>
|
|
/// Internally caches the Id of this behaviour in a NetworkObject. Makes look-up faster
|
|
/// </summary>
|
|
internal ushort NetworkBehaviourIdCache = 0;
|
|
|
|
/// <summary>
|
|
/// Returns a the NetworkBehaviour with a given BehaviourId for the current NetworkObject
|
|
/// </summary>
|
|
/// <param name="behaviourId">The behaviourId to return</param>
|
|
/// <returns>Returns NetworkBehaviour with given behaviourId</returns>
|
|
protected NetworkBehaviour GetNetworkBehaviour(ushort behaviourId)
|
|
{
|
|
return NetworkObject.GetNetworkBehaviourAtOrderIndex(behaviourId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the ClientId that owns the NetworkObject
|
|
/// </summary>
|
|
public ulong OwnerClientId { get; internal set; }
|
|
|
|
/// <summary>
|
|
/// Updates properties with network session related
|
|
/// dependencies such as a NetworkObject's spawned
|
|
/// state or NetworkManager's session state.
|
|
/// </summary>
|
|
internal void UpdateNetworkProperties()
|
|
{
|
|
// Set NetworkObject dependent properties
|
|
if (NetworkObject != null)
|
|
{
|
|
// Set identification related properties
|
|
NetworkObjectId = NetworkObject.NetworkObjectId;
|
|
IsLocalPlayer = NetworkObject.IsLocalPlayer;
|
|
|
|
// This is "OK" because GetNetworkBehaviourOrderIndex uses the order of
|
|
// NetworkObject.ChildNetworkBehaviours which is set once when first
|
|
// accessed.
|
|
NetworkBehaviourId = NetworkObject.GetNetworkBehaviourOrderIndex(this);
|
|
|
|
// Set ownership related properties
|
|
IsOwnedByServer = NetworkObject.IsOwnedByServer;
|
|
IsOwner = NetworkObject.IsOwner;
|
|
OwnerClientId = NetworkObject.OwnerClientId;
|
|
|
|
// Set NetworkManager dependent properties
|
|
if (NetworkManager != null)
|
|
{
|
|
IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
|
|
IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
|
|
IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
|
|
}
|
|
}
|
|
else // Shouldn't happen, but if so then set the properties to their default value;
|
|
{
|
|
OwnerClientId = NetworkObjectId = default;
|
|
IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = default;
|
|
NetworkBehaviourId = default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
|
|
/// </summary>
|
|
public virtual void OnNetworkSpawn() { }
|
|
|
|
/// <summary>
|
|
/// Gets called when the <see cref="NetworkObject"/> gets despawned. Is called both on the server and clients.
|
|
/// </summary>
|
|
public virtual void OnNetworkDespawn() { }
|
|
|
|
internal void InternalOnNetworkSpawn()
|
|
{
|
|
IsSpawned = true;
|
|
InitializeVariables();
|
|
UpdateNetworkProperties();
|
|
}
|
|
|
|
internal void VisibleOnNetworkSpawn()
|
|
{
|
|
try
|
|
{
|
|
OnNetworkSpawn();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogException(e);
|
|
}
|
|
|
|
InitializeVariables();
|
|
if (IsServer)
|
|
{
|
|
// Since we just spawned the object and since user code might have modified their NetworkVariable, esp.
|
|
// NetworkList, we need to mark the object as free of updates.
|
|
// This should happen for all objects on the machine triggering the spawn.
|
|
PostNetworkVariableWrite(true);
|
|
}
|
|
}
|
|
|
|
internal void InternalOnNetworkDespawn()
|
|
{
|
|
IsSpawned = false;
|
|
UpdateNetworkProperties();
|
|
try
|
|
{
|
|
OnNetworkDespawn();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogException(e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets called when the local client gains ownership of this object
|
|
/// </summary>
|
|
public virtual void OnGainedOwnership() { }
|
|
|
|
internal void InternalOnGainedOwnership()
|
|
{
|
|
UpdateNetworkProperties();
|
|
OnGainedOwnership();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets called when we loose ownership of this object
|
|
/// </summary>
|
|
public virtual void OnLostOwnership() { }
|
|
|
|
internal void InternalOnLostOwnership()
|
|
{
|
|
UpdateNetworkProperties();
|
|
OnLostOwnership();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets called when the parent NetworkObject of this NetworkBehaviour's NetworkObject has changed
|
|
/// </summary>
|
|
/// <param name="parentNetworkObject">the new <see cref="NetworkObject"/> parent</param>
|
|
public virtual void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject) { }
|
|
|
|
private bool m_VarInit = false;
|
|
|
|
private readonly List<HashSet<int>> m_DeliveryMappedNetworkVariableIndices = new List<HashSet<int>>();
|
|
private readonly List<NetworkDelivery> m_DeliveryTypesForNetworkVariableGroups = new List<NetworkDelivery>();
|
|
internal readonly List<NetworkVariableBase> NetworkVariableFields = new List<NetworkVariableBase>();
|
|
|
|
private static Dictionary<Type, FieldInfo[]> s_FieldTypes = new Dictionary<Type, FieldInfo[]>();
|
|
|
|
private static FieldInfo[] GetFieldInfoForType(Type type)
|
|
{
|
|
if (!s_FieldTypes.ContainsKey(type))
|
|
{
|
|
s_FieldTypes.Add(type, GetFieldInfoForTypeRecursive(type));
|
|
}
|
|
|
|
return s_FieldTypes[type];
|
|
}
|
|
|
|
private static FieldInfo[] GetFieldInfoForTypeRecursive(Type type, List<FieldInfo> list = null)
|
|
{
|
|
if (list == null)
|
|
{
|
|
list = new List<FieldInfo>();
|
|
list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance));
|
|
}
|
|
else
|
|
{
|
|
list.AddRange(type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance));
|
|
}
|
|
|
|
if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour))
|
|
{
|
|
return GetFieldInfoForTypeRecursive(type.BaseType, list);
|
|
}
|
|
|
|
return list.OrderBy(x => x.Name, StringComparer.Ordinal).ToArray();
|
|
}
|
|
|
|
internal void InitializeVariables()
|
|
{
|
|
if (m_VarInit)
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_VarInit = true;
|
|
|
|
var sortedFields = GetFieldInfoForType(GetType());
|
|
for (int i = 0; i < sortedFields.Length; i++)
|
|
{
|
|
var fieldType = sortedFields[i].FieldType;
|
|
if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
|
|
{
|
|
var instance = (NetworkVariableBase)sortedFields[i].GetValue(this);
|
|
|
|
if (instance == null)
|
|
{
|
|
throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
|
|
}
|
|
|
|
instance.Initialize(this);
|
|
|
|
var instanceNameProperty = fieldType.GetProperty(nameof(NetworkVariableBase.Name));
|
|
var sanitizedVariableName = sortedFields[i].Name.Replace("<", string.Empty).Replace(">k__BackingField", string.Empty);
|
|
instanceNameProperty?.SetValue(instance, sanitizedVariableName);
|
|
|
|
NetworkVariableFields.Add(instance);
|
|
}
|
|
}
|
|
|
|
{
|
|
// Create index map for delivery types
|
|
var firstLevelIndex = new Dictionary<NetworkDelivery, int>();
|
|
int secondLevelCounter = 0;
|
|
|
|
for (int i = 0; i < NetworkVariableFields.Count; i++)
|
|
{
|
|
var networkDelivery = NetworkVariableBase.Delivery;
|
|
if (!firstLevelIndex.ContainsKey(networkDelivery))
|
|
{
|
|
firstLevelIndex.Add(networkDelivery, secondLevelCounter);
|
|
m_DeliveryTypesForNetworkVariableGroups.Add(networkDelivery);
|
|
secondLevelCounter++;
|
|
}
|
|
|
|
if (firstLevelIndex[networkDelivery] >= m_DeliveryMappedNetworkVariableIndices.Count)
|
|
{
|
|
m_DeliveryMappedNetworkVariableIndices.Add(new HashSet<int>());
|
|
}
|
|
|
|
m_DeliveryMappedNetworkVariableIndices[firstLevelIndex[networkDelivery]].Add(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void PreNetworkVariableWrite()
|
|
{
|
|
// reset our "which variables got written" data
|
|
NetworkVariableIndexesToReset.Clear();
|
|
NetworkVariableIndexesToResetSet.Clear();
|
|
}
|
|
|
|
internal void PostNetworkVariableWrite(bool forced = false)
|
|
{
|
|
if (forced)
|
|
{
|
|
// Mark every variable as no longer dirty. We just spawned the object and whatever the game code did
|
|
// during OnNetworkSpawn has been sent and needs to be cleared
|
|
for (int i = 0; i < NetworkVariableFields.Count; i++)
|
|
{
|
|
NetworkVariableFields[i].ResetDirty();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// mark any variables we wrote as no longer dirty
|
|
for (int i = 0; i < NetworkVariableIndexesToReset.Count; i++)
|
|
{
|
|
NetworkVariableFields[NetworkVariableIndexesToReset[i]].ResetDirty();
|
|
}
|
|
}
|
|
|
|
MarkVariablesDirty(false);
|
|
}
|
|
|
|
internal void PreVariableUpdate()
|
|
{
|
|
if (!m_VarInit)
|
|
{
|
|
InitializeVariables();
|
|
}
|
|
|
|
PreNetworkVariableWrite();
|
|
}
|
|
|
|
internal void VariableUpdate(ulong targetClientId)
|
|
{
|
|
NetworkVariableUpdate(targetClientId, NetworkBehaviourId);
|
|
}
|
|
|
|
internal readonly List<int> NetworkVariableIndexesToReset = new List<int>();
|
|
internal readonly HashSet<int> NetworkVariableIndexesToResetSet = new HashSet<int>();
|
|
|
|
private void NetworkVariableUpdate(ulong targetClientId, int behaviourIndex)
|
|
{
|
|
if (!CouldHaveDirtyNetworkVariables())
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int j = 0; j < m_DeliveryMappedNetworkVariableIndices.Count; j++)
|
|
{
|
|
var shouldSend = false;
|
|
for (int k = 0; k < NetworkVariableFields.Count; k++)
|
|
{
|
|
var networkVariable = NetworkVariableFields[k];
|
|
if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
|
|
{
|
|
shouldSend = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (shouldSend)
|
|
{
|
|
var message = new NetworkVariableDeltaMessage
|
|
{
|
|
NetworkObjectId = NetworkObjectId,
|
|
NetworkBehaviourIndex = NetworkObject.GetNetworkBehaviourOrderIndex(this),
|
|
NetworkBehaviour = this,
|
|
TargetClientId = targetClientId,
|
|
DeliveryMappedNetworkVariableIndex = m_DeliveryMappedNetworkVariableIndices[j]
|
|
};
|
|
// TODO: Serialization is where the IsDirty flag gets changed.
|
|
// Messages don't get sent from the server to itself, so if we're host and sending to ourselves,
|
|
// we still have to actually serialize the message even though we're not sending it, otherwise
|
|
// the dirty flag doesn't change properly. These two pieces should be decoupled at some point
|
|
// so we don't have to do this serialization work if we're not going to use the result.
|
|
if (IsServer && targetClientId == NetworkManager.ServerClientId)
|
|
{
|
|
var tmpWriter = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, MessagingSystem.FRAGMENTED_MESSAGE_MAX_SIZE);
|
|
using (tmpWriter)
|
|
{
|
|
message.Serialize(tmpWriter, message.Version);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NetworkManager.SendMessage(ref message, m_DeliveryTypesForNetworkVariableGroups[j], targetClientId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool CouldHaveDirtyNetworkVariables()
|
|
{
|
|
// TODO: There should be a better way by reading one dirty variable vs. 'n'
|
|
for (int i = 0; i < NetworkVariableFields.Count; i++)
|
|
{
|
|
if (NetworkVariableFields[i].IsDirty())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal void MarkVariablesDirty(bool dirty)
|
|
{
|
|
for (int j = 0; j < NetworkVariableFields.Count; j++)
|
|
{
|
|
NetworkVariableFields[j].SetDirty(dirty);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Synchronizes by setting only the NetworkVariable field values that the client has permission to read.
|
|
/// Note: This is only invoked when first synchronizing a NetworkBehaviour (i.e. late join or spawned NetworkObject)
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// When NetworkConfig.EnsureNetworkVariableLengthSafety is enabled each NetworkVariable field will be preceded
|
|
/// by the number of bytes written for that specific field.
|
|
/// </remarks>
|
|
internal void WriteNetworkVariableData(FastBufferWriter writer, ulong targetClientId)
|
|
{
|
|
if (NetworkVariableFields.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int j = 0; j < NetworkVariableFields.Count; j++)
|
|
{
|
|
|
|
if (NetworkVariableFields[j].CanClientRead(targetClientId))
|
|
{
|
|
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
|
{
|
|
var writePos = writer.Position;
|
|
// Note: This value can't be packed because we don't know how large it will be in advance
|
|
// we reserve space for it, then write the data, then come back and fill in the space
|
|
// to pack here, we'd have to write data to a temporary buffer and copy it in - which
|
|
// isn't worth possibly saving one byte if and only if the data is less than 63 bytes long...
|
|
// The way we do packing, any value > 63 in a ushort will use the full 2 bytes to represent.
|
|
writer.WriteValueSafe((ushort)0);
|
|
var startPos = writer.Position;
|
|
NetworkVariableFields[j].WriteField(writer);
|
|
var size = writer.Position - startPos;
|
|
writer.Seek(writePos);
|
|
writer.WriteValueSafe((ushort)size);
|
|
writer.Seek(startPos + size);
|
|
}
|
|
else
|
|
{
|
|
NetworkVariableFields[j].WriteField(writer);
|
|
}
|
|
}
|
|
else // Only if EnsureNetworkVariableLengthSafety, otherwise just skip
|
|
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
|
{
|
|
writer.WriteValueSafe((ushort)0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Synchronizes by setting only the NetworkVariable field values that the client has permission to read.
|
|
/// Note: This is only invoked when first synchronizing a NetworkBehaviour (i.e. late join or spawned NetworkObject)
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// When NetworkConfig.EnsureNetworkVariableLengthSafety is enabled each NetworkVariable field will be preceded
|
|
/// by the number of bytes written for that specific field.
|
|
/// </remarks>
|
|
internal void SetNetworkVariableData(FastBufferReader reader, ulong clientId)
|
|
{
|
|
if (NetworkVariableFields.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (int j = 0; j < NetworkVariableFields.Count; j++)
|
|
{
|
|
var varSize = (ushort)0;
|
|
var readStartPos = 0;
|
|
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
|
{
|
|
reader.ReadValueSafe(out varSize);
|
|
if (varSize == 0)
|
|
{
|
|
continue;
|
|
}
|
|
readStartPos = reader.Position;
|
|
}
|
|
else // If the client cannot read this field, then skip it
|
|
if (!NetworkVariableFields[j].CanClientRead(clientId))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
NetworkVariableFields[j].ReadField(reader);
|
|
|
|
if (NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
|
|
{
|
|
if (reader.Position > (readStartPos + varSize))
|
|
{
|
|
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
|
{
|
|
NetworkLog.LogWarning($"Var data read too far. {reader.Position - (readStartPos + varSize)} bytes.");
|
|
}
|
|
|
|
reader.Seek(readStartPos + varSize);
|
|
}
|
|
else if (reader.Position < (readStartPos + varSize))
|
|
{
|
|
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
|
|
{
|
|
NetworkLog.LogWarning($"Var data read too little. {(readStartPos + varSize) - reader.Position} bytes.");
|
|
}
|
|
|
|
reader.Seek(readStartPos + varSize);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the local instance of a object with a given NetworkId
|
|
/// </summary>
|
|
/// <param name="networkId"></param>
|
|
/// <returns></returns>
|
|
protected NetworkObject GetNetworkObject(ulong networkId)
|
|
{
|
|
return NetworkManager.SpawnManager.SpawnedObjects.TryGetValue(networkId, out NetworkObject networkObject) ? networkObject : null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Override this method if your derived NetworkBehaviour requires custom synchronization data.
|
|
/// Note: Use of this method is only for the initial client synchronization of NetworkBehaviours
|
|
/// and will increase the payload size for client synchronization and dynamically spawned
|
|
/// <see cref="NetworkObject"/>s.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// When serializing (writing) this will be invoked during the client synchronization period and
|
|
/// when spawning new NetworkObjects.
|
|
/// When deserializing (reading), this will be invoked prior to the NetworkBehaviour's associated
|
|
/// NetworkObject being spawned.
|
|
/// </remarks>
|
|
/// <param name="serializer">The serializer to use to read and write the data.</param>
|
|
/// <typeparam name="T">
|
|
/// Either BufferSerializerReader or BufferSerializerWriter, depending whether the serializer
|
|
/// is in read mode or write mode.
|
|
/// </typeparam>
|
|
protected virtual void OnSynchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
|
|
{
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Internal method that determines if a NetworkBehaviour has additional synchronization data to
|
|
/// be synchronized when first instantiated prior to its associated NetworkObject being spawned.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// This includes try-catch blocks to recover from exceptions that might occur and continue to
|
|
/// synchronize any remaining NetworkBehaviours.
|
|
/// </remarks>
|
|
/// <returns>true if it wrote synchronization data and false if it did not</returns>
|
|
internal bool Synchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
|
|
{
|
|
if (serializer.IsWriter)
|
|
{
|
|
// Get the writer to handle seeking and determining how many bytes were written
|
|
var writer = serializer.GetFastBufferWriter();
|
|
// Save our position before we attempt to write anything so we can seek back to it (i.e. error occurs)
|
|
var positionBeforeWrite = writer.Position;
|
|
writer.WriteValueSafe(NetworkBehaviourId);
|
|
|
|
// Save our position where we will write the final size being written so we can skip over it in the
|
|
// event an exception occurs when deserializing.
|
|
var sizePosition = writer.Position;
|
|
writer.WriteValueSafe((ushort)0);
|
|
|
|
// Save our position before synchronizing to determine how much was written
|
|
var positionBeforeSynchronize = writer.Position;
|
|
var threwException = false;
|
|
try
|
|
{
|
|
OnSynchronize(ref serializer);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
threwException = true;
|
|
if (NetworkManager.LogLevel <= LogLevel.Normal)
|
|
{
|
|
NetworkLog.LogWarning($"{name} threw an exception during synchronization serialization, this {nameof(NetworkBehaviour)} is being skipped and will not be synchronized!");
|
|
if (NetworkManager.LogLevel == LogLevel.Developer)
|
|
{
|
|
NetworkLog.LogError($"{ex.Message}\n {ex.StackTrace}");
|
|
}
|
|
}
|
|
}
|
|
var finalPosition = writer.Position;
|
|
|
|
// If we wrote nothing then skip writing anything for this NetworkBehaviour
|
|
if (finalPosition == positionBeforeSynchronize || threwException)
|
|
{
|
|
writer.Seek(positionBeforeWrite);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// Write the number of bytes serialized to handle exceptions on the deserialization side
|
|
var bytesWritten = finalPosition - positionBeforeSynchronize;
|
|
writer.Seek(sizePosition);
|
|
writer.WriteValueSafe((ushort)bytesWritten);
|
|
writer.Seek(finalPosition);
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
var reader = serializer.GetFastBufferReader();
|
|
// We will always read the expected byte count
|
|
reader.ReadValueSafe(out ushort expectedBytesToRead);
|
|
|
|
// Save our position before we begin synchronization deserialization
|
|
var positionBeforeSynchronize = reader.Position;
|
|
var synchronizationError = false;
|
|
try
|
|
{
|
|
// Invoke synchronization
|
|
OnSynchronize(ref serializer);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (NetworkManager.LogLevel <= LogLevel.Normal)
|
|
{
|
|
NetworkLog.LogWarning($"{name} threw an exception during synchronization deserialization, this {nameof(NetworkBehaviour)} is being skipped and will not be synchronized!");
|
|
if (NetworkManager.LogLevel == LogLevel.Developer)
|
|
{
|
|
NetworkLog.LogError($"{ex.Message}\n {ex.StackTrace}");
|
|
}
|
|
}
|
|
synchronizationError = true;
|
|
}
|
|
|
|
var totalBytesRead = reader.Position - positionBeforeSynchronize;
|
|
if (totalBytesRead != expectedBytesToRead)
|
|
{
|
|
if (NetworkManager.LogLevel <= LogLevel.Normal)
|
|
{
|
|
NetworkLog.LogWarning($"{name} read {totalBytesRead} bytes but was expected to read {expectedBytesToRead} bytes during synchronization deserialization! This {nameof(NetworkBehaviour)} is being skipped and will not be synchronized!");
|
|
}
|
|
synchronizationError = true;
|
|
}
|
|
|
|
// Skip over the entry if deserialization fails
|
|
if (synchronizationError)
|
|
{
|
|
var skipToPosition = positionBeforeSynchronize + expectedBytesToRead;
|
|
reader.Seek(skipToPosition);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Invoked when the <see cref="GameObject"/> the <see cref="NetworkBehaviour"/> is attached to.
|
|
/// NOTE: If you override this, you will want to always invoke this base class version of this
|
|
/// <see cref="OnDestroy"/> method!!
|
|
/// </summary>
|
|
public virtual void OnDestroy()
|
|
{
|
|
if (NetworkObject != null && NetworkObject.IsSpawned && IsSpawned)
|
|
{
|
|
// If the associated NetworkObject is still spawned then this
|
|
// NetworkBehaviour will be removed from the NetworkObject's
|
|
// ChildNetworkBehaviours list.
|
|
NetworkObject.OnNetworkBehaviourDestroyed(this);
|
|
}
|
|
|
|
// this seems odd to do here, but in fact especially in tests we can find ourselves
|
|
// here without having called InitializedVariables, which causes problems if any
|
|
// of those variables use native containers (e.g. NetworkList) as they won't be
|
|
// registered here and therefore won't be cleaned up.
|
|
//
|
|
// we should study to understand the initialization patterns
|
|
if (!m_VarInit)
|
|
{
|
|
InitializeVariables();
|
|
}
|
|
|
|
|
|
for (int i = 0; i < NetworkVariableFields.Count; i++)
|
|
{
|
|
NetworkVariableFields[i].Dispose();
|
|
}
|
|
}
|
|
}
|
|
}
|