InnoLab/com.unity.netcode.gameobjects
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

com.unity.netcode.gameobjects@1.8.0

Browse Source 
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.8.0] - 2023-12-12

### Added

- Added a new RPC attribute, which is simply `Rpc`. (#2762)
  - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs.
  - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately.
  - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option.
- Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762)
- Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762)
- Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735)
- Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735)
- Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710)

### Fixed

- Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789)
- Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789)
- Fixed issue where a host could disconnect its local client but remain running as a server. (#2789)
- Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789)
- Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789)
- Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789)
- Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789)
- Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777)
- Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777)
- Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737)
- Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735)
- Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713)
- Fixed issue where  you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710)

### Changed
- Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789)
- Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789)
- Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777)
- `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762)
- Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735)
- Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713)
- Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710)
- Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710)
- Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710)
- Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710)
- Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
This commit is contained in:
Unity Technologies
2023-12-12 00:00:00 +00:00
parent 514166e159
commit 07f206ff9e
99 changed files with 8667 additions and 1710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

47
CHANGELOG.md
View File

@@ -6,6 +6,49 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
## [1.8.0] - 2023-12-12
### Added
- Added a new RPC attribute, which is simply `Rpc`. (#2762)
- This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs.
- This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately.
- This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option.
- Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762)
- Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762)
- Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735)
- Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735)
- Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710)
### Fixed
- Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789)
- Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789)
- Fixed issue where a host could disconnect its local client but remain running as a server. (#2789)
- Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789)
- Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789)
- Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789)
- Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789)
- Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777)
- Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777)
- Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737)
- Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735)
- Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713)
- Fixed issue where you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710)
### Changed
- Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789)
- Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789)
- Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777)
- `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762)
- Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735)
- Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713)
- Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710)
- Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710)
- Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710)
- Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710)
- Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
## [1.7.1] - 2023-11-15
### Added
@@ -15,8 +58,6 @@ Additional documentation and release notes are available at [Multiplayer Documen
- Fixed a bug where having a class with Rpcs that inherits from a class without Rpcs that inherits from NetworkVariable would cause a compile error. (#2751)
- Fixed issue where `NetworkBehaviour.Synchronize` was not truncating the write buffer if nothing was serialized during `NetworkBehaviour.OnSynchronize` causing an additional 6 bytes to be written per `NetworkBehaviour` component instance. (#2749)
### Changed
## [1.7.0] - 2023-10-11
### Added
@@ -74,7 +115,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
### Added
### Fixed
- Bumped minimum Unity version supported to 2021.3 LTS
- Fixed issue where `NetworkClient.OwnedObjects` was not returning any owned objects due to the `NetworkClient.IsConnected` not being properly set. (#2631)
- Fixed a crash when calling TrySetParent with a null Transform (#2625)
- Fixed issue where a `NetworkTransform` using full precision state updates was losing transform state updates when interpolation was enabled. (#2624)

6
Components/NetworkAnimator.cs
View File

@@ -833,8 +833,7 @@ namespace Unity.Netcode.Components
stateChangeDetected = true;
//Debug.Log($"[Cross-Fade] To-Hash: {nt.fullPathHash} | TI-Duration: ({tt.duration}) | TI-Norm: ({tt.normalizedTime}) | From-Hash: ({m_AnimationHash[layer]}) | SI-FPHash: ({st.fullPathHash}) | SI-Norm: ({st.normalizedTime})");
}
else
if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
else if (!tt.anyState && tt.fullPathHash != m_TransitionHash[layer])
{
// first time in this transition for this layer
m_TransitionHash[layer] = tt.fullPathHash;
@@ -1053,8 +1052,7 @@ namespace Unity.Netcode.Components
BytePacker.WriteValuePacked(writer, valueBool);
}
}
else
if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
else if (cacheValue.Type == AnimationParamEnumWrapper.AnimatorControllerParameterFloat)
{
var valueFloat = m_Animator.GetFloat(hash);
fixed (void* value = cacheValue.Value)

12
Components/NetworkDeltaPosition.cs
View File

@@ -23,12 +23,20 @@ namespace Unity.Netcode.Components
internal Vector3 DeltaPosition;
internal int NetworkTick;
internal bool SynchronizeBase;
internal bool CollapsedDeltaIntoBase;
/// <summary>
/// The serialization implementation of <see cref="INetworkSerializable"/>
/// </summary>
public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
HalfVector3.NetworkSerialize(serializer);
if (SynchronizeBase)
{
serializer.SerializeValue(ref CurrentBasePosition);
}
}
/// <summary>
@@ -122,6 +130,7 @@ namespace Unity.Netcode.Components
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void UpdateFrom(ref Vector3 vector3, int networkTick)
{
CollapsedDeltaIntoBase = false;
NetworkTick = networkTick;
DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
for (int i = 0; i < HalfVector3.Length; i++)
@@ -136,6 +145,7 @@ namespace Unity.Netcode.Components
CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
HalfDeltaConvertedBack[i] = 0.0f;
DeltaPosition[i] = 0.0f;
CollapsedDeltaIntoBase = true;
}
}
}
@@ -164,6 +174,8 @@ namespace Unity.Netcode.Components
DeltaPosition = Vector3.zero;
HalfDeltaConvertedBack = Vector3.zero;
HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
SynchronizeBase = false;
CollapsedDeltaIntoBase = false;
UpdateFrom(ref vector3, networkTick);
}

721
Components/NetworkTransform.cs
View File

File diff suppressed because it is too large Load Diff

2
Documentation~/index.md
View File

@@ -16,7 +16,7 @@ See guides below to install Unity Netcode for GameObjects, set up your project,
## Requirements
Netcode for GameObjects targets the following Unity versions:
- Unity 2020.3, 2021.1, 2021.2 and 2021.3
- Unity 2021.3 (LTS), 2022.3 (LTS) and 2023.2
On the following runtime platforms:
- Windows, MacOS, and Linux

2
Editor/CodeGen/CodeGenHelpers.cs
View File

@@ -26,8 +26,10 @@ namespace Unity.Netcode.Editor.CodeGen
public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName;
public static readonly string ServerRpcAttribute_FullName = typeof(ServerRpcAttribute).FullName;
public static readonly string ClientRpcAttribute_FullName = typeof(ClientRpcAttribute).FullName;
public static readonly string RpcAttribute_FullName = typeof(RpcAttribute).FullName;
public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;
public static readonly string ClientRpcParams_FullName = typeof(ClientRpcParams).FullName;
public static readonly string RpcParams_FullName = typeof(RpcParams).FullName;
public static readonly string ClientRpcSendParams_FullName = typeof(ClientRpcSendParams).FullName;
public static readonly string ClientRpcReceiveParams_FullName = typeof(ClientRpcReceiveParams).FullName;
public static readonly string ServerRpcSendParams_FullName = typeof(ServerRpcSendParams).FullName;

362
Editor/CodeGen/NetworkBehaviourILPP.cs
View File

@@ -363,11 +363,14 @@ namespace Unity.Netcode.Editor.CodeGen
private FieldReference m_NetworkManager_LogLevel_FieldRef;
private MethodReference m_NetworkBehaviour___registerRpc_MethodRef;
private TypeReference m_NetworkBehaviour_TypeRef;
private TypeReference m_AttributeParamsType_TypeRef;
private TypeReference m_NetworkVariableBase_TypeRef;
private MethodReference m_NetworkVariableBase_Initialize_MethodRef;
private MethodReference m_NetworkBehaviour___nameNetworkVariable_MethodRef;
private MethodReference m_NetworkBehaviour_beginSendServerRpc_MethodRef;
private MethodReference m_NetworkBehaviour_endSendServerRpc_MethodRef;
private MethodReference m_NetworkBehaviour_beginSendRpc_MethodRef;
private MethodReference m_NetworkBehaviour_endSendRpc_MethodRef;
private MethodReference m_NetworkBehaviour_beginSendClientRpc_MethodRef;
private MethodReference m_NetworkBehaviour_endSendClientRpc_MethodRef;
private FieldReference m_NetworkBehaviour_rpc_exec_stage_FieldRef;
@@ -378,9 +381,13 @@ namespace Unity.Netcode.Editor.CodeGen
private TypeReference m_RpcParams_TypeRef;
private FieldReference m_RpcParams_Server_FieldRef;
private FieldReference m_RpcParams_Client_FieldRef;
private FieldReference m_RpcParams_Ext_FieldRef;
private TypeReference m_ServerRpcParams_TypeRef;
private FieldReference m_ServerRpcParams_Receive_FieldRef;
private FieldReference m_ServerRpcParams_Receive_SenderClientId_FieldRef;
private FieldReference m_UniversalRpcParams_Receive_FieldRef;
private FieldReference m_UniversalRpcParams_Receive_SenderClientId_FieldRef;
private TypeReference m_UniversalRpcParams_TypeRef;
private TypeReference m_ClientRpcParams_TypeRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef;
private MethodReference m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef;
@@ -495,6 +502,8 @@ namespace Unity.Netcode.Editor.CodeGen
private const string k_NetworkBehaviour_NetworkVariableFields = nameof(NetworkBehaviour.NetworkVariableFields);
private const string k_NetworkBehaviour_beginSendServerRpc = nameof(NetworkBehaviour.__beginSendServerRpc);
private const string k_NetworkBehaviour_endSendServerRpc = nameof(NetworkBehaviour.__endSendServerRpc);
private const string k_NetworkBehaviour_beginSendRpc = nameof(NetworkBehaviour.__beginSendRpc);
private const string k_NetworkBehaviour_endSendRpc = nameof(NetworkBehaviour.__endSendRpc);
private const string k_NetworkBehaviour_beginSendClientRpc = nameof(NetworkBehaviour.__beginSendClientRpc);
private const string k_NetworkBehaviour_endSendClientRpc = nameof(NetworkBehaviour.__endSendClientRpc);
private const string k_NetworkBehaviour___initializeVariables = nameof(NetworkBehaviour.__initializeVariables);
@@ -511,8 +520,11 @@ namespace Unity.Netcode.Editor.CodeGen
private const string k_ServerRpcAttribute_RequireOwnership = nameof(ServerRpcAttribute.RequireOwnership);
private const string k_RpcParams_Server = nameof(__RpcParams.Server);
private const string k_RpcParams_Client = nameof(__RpcParams.Client);
private const string k_RpcParams_Ext = nameof(__RpcParams.Ext);
private const string k_ServerRpcParams_Receive = nameof(ServerRpcParams.Receive);
private const string k_RpcParams_Receive = nameof(RpcParams.Receive);
private const string k_ServerRpcReceiveParams_SenderClientId = nameof(ServerRpcReceiveParams.SenderClientId);
private const string k_RpcReceiveParams_SenderClientId = nameof(RpcReceiveParams.SenderClientId);
// CodeGen cannot reference the collections assembly to do a typeof() on it due to a bug that causes that to crash.
private const string k_INativeListBool_FullName = "Unity.Collections.INativeList`1<System.Byte>";
@@ -545,13 +557,20 @@ namespace Unity.Netcode.Editor.CodeGen
TypeDefinition rpcParamsTypeDef = null;
TypeDefinition serverRpcParamsTypeDef = null;
TypeDefinition clientRpcParamsTypeDef = null;
TypeDefinition universalRpcParamsTypeDef = null;
TypeDefinition fastBufferWriterTypeDef = null;
TypeDefinition fastBufferReaderTypeDef = null;
TypeDefinition networkVariableSerializationTypesTypeDef = null;
TypeDefinition bytePackerTypeDef = null;
TypeDefinition byteUnpackerTypeDef = null;
TypeDefinition attributeParamsType = null;
foreach (var netcodeTypeDef in m_NetcodeModule.GetAllTypes())
{
if (attributeParamsType == null && netcodeTypeDef.Name == nameof(RpcAttribute.RpcAttributeParams))
{
attributeParamsType = netcodeTypeDef;
continue;
}
if (networkManagerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkManager))
{
networkManagerTypeDef = netcodeTypeDef;
@@ -588,6 +607,12 @@ namespace Unity.Netcode.Editor.CodeGen
continue;
}
if (universalRpcParamsTypeDef == null && netcodeTypeDef.Name == nameof(RpcParams))
{
universalRpcParamsTypeDef = netcodeTypeDef;
continue;
}
if (clientRpcParamsTypeDef == null && netcodeTypeDef.Name == nameof(ClientRpcParams))
{
clientRpcParamsTypeDef = netcodeTypeDef;
@@ -662,6 +687,8 @@ namespace Unity.Netcode.Editor.CodeGen
}
}
m_AttributeParamsType_TypeRef = moduleDefinition.ImportReference(attributeParamsType);
foreach (var fieldDef in networkManagerTypeDef.Fields)
{
switch (fieldDef.Name)
@@ -696,6 +723,12 @@ namespace Unity.Netcode.Editor.CodeGen
case k_NetworkBehaviour_endSendServerRpc:
m_NetworkBehaviour_endSendServerRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
break;
case k_NetworkBehaviour_beginSendRpc:
m_NetworkBehaviour_beginSendRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
break;
case k_NetworkBehaviour_endSendRpc:
m_NetworkBehaviour_endSendRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
break;
case k_NetworkBehaviour_beginSendClientRpc:
m_NetworkBehaviour_beginSendClientRpc_MethodRef = moduleDefinition.ImportReference(methodDef);
break;
@@ -763,6 +796,9 @@ namespace Unity.Netcode.Editor.CodeGen
case k_RpcParams_Client:
m_RpcParams_Client_FieldRef = moduleDefinition.ImportReference(fieldDef);
break;
case k_RpcParams_Ext:
m_RpcParams_Ext_FieldRef = moduleDefinition.ImportReference(fieldDef);
break;
}
}
@@ -786,6 +822,26 @@ namespace Unity.Netcode.Editor.CodeGen
break;
}
}
m_UniversalRpcParams_TypeRef = moduleDefinition.ImportReference(rpcParamsTypeDef);
foreach (var fieldDef in rpcParamsTypeDef.Fields)
{
switch (fieldDef.Name)
{
case k_RpcParams_Receive:
foreach (var recvFieldDef in fieldDef.FieldType.Resolve().Fields)
{
switch (recvFieldDef.Name)
{
case k_RpcReceiveParams_SenderClientId:
m_UniversalRpcParams_Receive_SenderClientId_FieldRef = moduleDefinition.ImportReference(recvFieldDef);
break;
}
}
m_UniversalRpcParams_Receive_FieldRef = moduleDefinition.ImportReference(fieldDef);
break;
}
}
m_ClientRpcParams_TypeRef = moduleDefinition.ImportReference(clientRpcParamsTypeDef);
m_FastBufferWriter_TypeRef = moduleDefinition.ImportReference(fastBufferWriterTypeDef);
@@ -1354,7 +1410,8 @@ namespace Unity.Netcode.Editor.CodeGen
var customAttributeType_FullName = customAttribute.AttributeType.FullName;
if (customAttributeType_FullName == CodeGenHelpers.ServerRpcAttribute_FullName ||
customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName)
customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName ||
customAttributeType_FullName == CodeGenHelpers.RpcAttribute_FullName)
{
bool isValid = true;
@@ -1389,6 +1446,13 @@ namespace Unity.Netcode.Editor.CodeGen
isValid = false;
}
if (customAttributeType_FullName == CodeGenHelpers.RpcAttribute_FullName &&
!methodDefinition.Name.EndsWith("Rpc", StringComparison.OrdinalIgnoreCase))
{
m_Diagnostics.AddError(methodDefinition, "Rpc method must end with 'Rpc' suffix!");
isValid = false;
}
if (customAttributeType_FullName == CodeGenHelpers.ClientRpcAttribute_FullName &&
!methodDefinition.Name.EndsWith("ClientRpc", StringComparison.OrdinalIgnoreCase))
{
@@ -1411,11 +1475,15 @@ namespace Unity.Netcode.Editor.CodeGen
{
if (methodDefinition.Name.EndsWith("ServerRpc", StringComparison.OrdinalIgnoreCase))
{
m_Diagnostics.AddError(methodDefinition, "ServerRpc method must be marked with 'ServerRpc' attribute!");
m_Diagnostics.AddError(methodDefinition, $"ServerRpc method {methodDefinition} must be marked with 'ServerRpc' attribute!");
}
else if (methodDefinition.Name.EndsWith("ClientRpc", StringComparison.OrdinalIgnoreCase))
{
m_Diagnostics.AddError(methodDefinition, "ClientRpc method must be marked with 'ClientRpc' attribute!");
m_Diagnostics.AddError(methodDefinition, $"ClientRpc method {methodDefinition} must be marked with 'ClientRpc' attribute!");
}
else if (methodDefinition.Name.EndsWith("ExtRpc", StringComparison.OrdinalIgnoreCase))
{
m_Diagnostics.AddError(methodDefinition, $"Ext Rpc method {methodDefinition} must be marked with 'ExtRpc' attribute!");
}
return null;
@@ -1887,8 +1955,17 @@ namespace Unity.Netcode.Editor.CodeGen
var instructions = new List<Instruction>();
var processor = methodDefinition.Body.GetILProcessor();
var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
var isClientRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ClientRpcAttribute_FullName;
var isGenericRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.RpcAttribute_FullName;
var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
var rpcDelivery = RpcDelivery.Reliable; // default value MUST be == `RpcAttribute.Delivery`
var defaultTarget = SendTo.Everyone;
var allowTargetOverride = false;
if (isGenericRpc)
{
defaultTarget = (SendTo)rpcAttribute.ConstructorArguments[0].Value;
}
foreach (var attrField in rpcAttribute.Fields)
{
switch (attrField.Name)
@@ -1899,6 +1976,9 @@ namespace Unity.Netcode.Editor.CodeGen
case k_ServerRpcAttribute_RequireOwnership:
requireOwnership = attrField.Argument.Type == typeSystem.Boolean && (bool)attrField.Argument.Value;
break;
case nameof(RpcAttribute.AllowTargetOverride):
allowTargetOverride = attrField.Argument.Type == typeSystem.Boolean && (bool)attrField.Argument.Value;
break;
}
}
@@ -1906,7 +1986,33 @@ namespace Unity.Netcode.Editor.CodeGen
var hasRpcParams =
paramCount > 0 &&
((isServerRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ServerRpcParams_FullName) ||
(!isServerRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ClientRpcParams_FullName));
(isClientRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.ClientRpcParams_FullName) ||
(isGenericRpc && methodDefinition.Parameters[paramCount - 1].ParameterType.FullName == CodeGenHelpers.RpcParams_FullName));
if (isGenericRpc && defaultTarget == SendTo.SpecifiedInParams)
{
if (!hasRpcParams)
{
m_Diagnostics.AddError($"{methodDefinition}: {nameof(SendTo)}.{nameof(SendTo.SpecifiedInParams)} cannot be used without a final parameter of type {CodeGenHelpers.RpcParams_FullName}.");
}
foreach (var attrField in rpcAttribute.Fields)
{
switch (attrField.Name)
{
case nameof(RpcAttribute.AllowTargetOverride):
m_Diagnostics.AddWarning($"{methodDefinition}: {nameof(RpcAttribute.AllowTargetOverride)} is ignored with {nameof(SendTo)}.{nameof(SendTo.SpecifiedInParams)}");
break;
}
}
}
if (isGenericRpc && allowTargetOverride)
{
if (!hasRpcParams)
{
m_Diagnostics.AddError($"{methodDefinition}: {nameof(RpcAttribute.AllowTargetOverride)} cannot be used without a final parameter of type {CodeGenHelpers.RpcParams_FullName}.");
}
}
methodDefinition.Body.InitLocals = true;
// NetworkManager networkManager;
@@ -1919,10 +2025,17 @@ namespace Unity.Netcode.Editor.CodeGen
// XXXRpcParams
if (!hasRpcParams)
{
methodDefinition.Body.Variables.Add(new VariableDefinition(isServerRpc ? m_ServerRpcParams_TypeRef : m_ClientRpcParams_TypeRef));
methodDefinition.Body.Variables.Add(new VariableDefinition(isServerRpc ? m_ServerRpcParams_TypeRef : (isClientRpc ? m_ClientRpcParams_TypeRef : m_UniversalRpcParams_TypeRef)));
}
int rpcParamsIdx = !hasRpcParams ? methodDefinition.Body.Variables.Count - 1 : -1;
if (isGenericRpc)
{
methodDefinition.Body.Variables.Add(new VariableDefinition(m_AttributeParamsType_TypeRef));
}
int rpcAttributeParamsIdx = isGenericRpc ? methodDefinition.Body.Variables.Count - 1 : -1;
{
var returnInstr = processor.Create(OpCodes.Ret);
var lastInstr = processor.Create(OpCodes.Nop);
@@ -1952,20 +2065,23 @@ namespace Unity.Netcode.Editor.CodeGen
// if (__rpc_exec_stage != __RpcExecStage.Client) -> ClientRpc
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client)));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
instructions.Add(processor.Create(OpCodes.Ceq));
instructions.Add(processor.Create(OpCodes.Ldc_I4, 0));
instructions.Add(processor.Create(OpCodes.Ceq));
instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
// if (networkManager.IsClient || networkManager.IsHost) { ... } -> ServerRpc
// if (networkManager.IsServer || networkManager.IsHost) { ... } -> ClientRpc
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsClient_MethodRef : m_NetworkManager_getIsServer_MethodRef));
instructions.Add(processor.Create(OpCodes.Brtrue, beginInstr));
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
if (!isGenericRpc)
{
// if (networkManager.IsClient || networkManager.IsHost) { ... } -> ServerRpc
// if (networkManager.IsServer || networkManager.IsHost) { ... } -> ClientRpc
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsClient_MethodRef : m_NetworkManager_getIsServer_MethodRef));
instructions.Add(processor.Create(OpCodes.Brtrue, beginInstr));
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
instructions.Add(processor.Create(OpCodes.Brfalse, lastInstr));
}
instructions.Add(beginInstr);
@@ -2027,7 +2143,7 @@ namespace Unity.Netcode.Editor.CodeGen
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendServerRpc_MethodRef));
instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
}
else
else if (isClientRpc)
{
// ClientRpc
@@ -2047,6 +2163,89 @@ namespace Unity.Netcode.Editor.CodeGen
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendClientRpc_MethodRef));
instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
}
else
{
// Generic RPC
// var bufferWriter = __beginSendRpc(rpcMethodId, rpcParams, rpcAttributeParams, defaultTarget, rpcDelivery);
instructions.Add(processor.Create(OpCodes.Ldarg_0));
// rpcMethodId
instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
// rpcParams
instructions.Add(hasRpcParams ? processor.Create(OpCodes.Ldarg, paramCount) : processor.Create(OpCodes.Ldloc, rpcParamsIdx));
// rpcAttributeParams
instructions.Add(processor.Create(OpCodes.Ldloca, rpcAttributeParamsIdx));
instructions.Add(processor.Create(OpCodes.Initobj, m_AttributeParamsType_TypeRef));
RpcAttribute.RpcAttributeParams dflt = default;
foreach (var field in rpcAttribute.Fields)
{
var found = false;
foreach (var attrField in m_AttributeParamsType_TypeRef.Resolve().Fields)
{
if (attrField.Name == field.Name)
{
found = true;
var value = field.Argument.Value;
var paramField = dflt.GetType().GetField(attrField.Name);
if (value != paramField.GetValue(dflt))
{
instructions.Add(processor.Create(OpCodes.Ldloca, rpcAttributeParamsIdx));
var type = value.GetType();
if (type == typeof(bool))
{
instructions.Add(processor.Create(OpCodes.Ldc_I4, (bool)value ? 1 : 0));
}
else if (type == typeof(short) || type == typeof(int) || type == typeof(ushort)
|| type == typeof(byte) || type == typeof(sbyte) || type == typeof(char))
{
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)value));
}
else if (type == typeof(long) || type == typeof(ulong))
{
instructions.Add(processor.Create(OpCodes.Ldc_I8, (long)value));
}
else if (type == typeof(float))
{
instructions.Add(processor.Create(OpCodes.Ldc_R8, (float)value));
}
else if (type == typeof(double))
{
instructions.Add(processor.Create(OpCodes.Ldc_R8, (double)value));
}
else
{
m_Diagnostics.AddError("Unsupported attribute parameter type.");
}
}
instructions.Add(processor.Create(OpCodes.Stfld, m_MainModule.ImportReference(attrField)));
break;
}
}
if (!found)
{
m_Diagnostics.AddError($"{nameof(RpcAttribute)} contains field {field} which is not present in {nameof(RpcAttribute.RpcAttributeParams)}.");
}
}
instructions.Add(processor.Create(OpCodes.Ldloc, rpcAttributeParamsIdx));
// defaultTarget
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)defaultTarget));
// rpcDelivery
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
// __beginSendRpc
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_beginSendRpc_MethodRef));
instructions.Add(processor.Create(OpCodes.Stloc, bufWriterLocIdx));
}
// write method parameters into stream
for (int paramIndex = 0; paramIndex < paramCount; ++paramIndex)
@@ -2075,7 +2274,7 @@ namespace Unity.Netcode.Editor.CodeGen
}
if (!isServerRpc)
{
m_Diagnostics.AddError($"ClientRpcs may not accept {nameof(ServerRpcParams)} as a parameter.");
m_Diagnostics.AddError($"Only ServerRpcs may accept {nameof(ServerRpcParams)} as a parameter.");
}
continue;
}
@@ -2086,9 +2285,22 @@ namespace Unity.Netcode.Editor.CodeGen
{
m_Diagnostics.AddError(methodDefinition, $"{nameof(ClientRpcParams)} must be the last parameter in a ClientRpc.");
}
if (isServerRpc)
if (!isClientRpc)
{
m_Diagnostics.AddError($"ServerRpcs may not accept {nameof(ClientRpcParams)} as a parameter.");
m_Diagnostics.AddError($"Only clientRpcs may accept {nameof(ClientRpcParams)} as a parameter.");
}
continue;
}
// RpcParams
if (paramType.FullName == CodeGenHelpers.RpcParams_FullName)
{
if (paramIndex != paramCount - 1)
{
m_Diagnostics.AddError(methodDefinition, $"{nameof(RpcParams)} must be the last parameter in a ClientRpc.");
}
if (!isGenericRpc)
{
m_Diagnostics.AddError($"Only Rpcs may accept {nameof(RpcParams)} as a parameter.");
}
continue;
}
@@ -2251,7 +2463,7 @@ namespace Unity.Netcode.Editor.CodeGen
// __endSendServerRpc
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendServerRpc_MethodRef));
}
else
else if (isClientRpc)
{
// ClientRpc
@@ -2279,6 +2491,41 @@ namespace Unity.Netcode.Editor.CodeGen
// __endSendClientRpc
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendClientRpc_MethodRef));
}
else
{
// Generic Rpc
// __endSendRpc(ref bufferWriter, rpcMethodId, rpcParams, rpcAttributeParams, defaultTarget, rpcDelivery);
instructions.Add(processor.Create(OpCodes.Ldarg_0));
// bufferWriter
instructions.Add(processor.Create(OpCodes.Ldloca, bufWriterLocIdx));
// rpcMethodId
instructions.Add(processor.Create(OpCodes.Ldc_I4, unchecked((int)rpcMethodId)));
if (hasRpcParams)
{
// rpcParams
instructions.Add(processor.Create(OpCodes.Ldarg, paramCount));
}
else
{
// default
instructions.Add(processor.Create(OpCodes.Ldloc, rpcParamsIdx));
}
// rpcAttributeParams
instructions.Add(processor.Create(OpCodes.Ldloc, rpcAttributeParamsIdx));
// defaultTarget
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)defaultTarget));
// rpcDelivery
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)rpcDelivery));
// __endSendClientRpc
instructions.Add(processor.Create(OpCodes.Call, m_NetworkBehaviour_endSendRpc_MethodRef));
}
instructions.Add(lastInstr);
}
@@ -2287,25 +2534,53 @@ namespace Unity.Netcode.Editor.CodeGen
var returnInstr = processor.Create(OpCodes.Ret);
var lastInstr = processor.Create(OpCodes.Nop);
// if (__rpc_exec_stage == __RpcExecStage.Server) -> ServerRpc
// if (__rpc_exec_stage == __RpcExecStage.Client) -> ClientRpc
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client)));
instructions.Add(processor.Create(OpCodes.Ceq));
instructions.Add(processor.Create(OpCodes.Brfalse, returnInstr));
if (!isGenericRpc)
{
// if (__rpc_exec_stage == __RpcExecStage.Execute)
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
instructions.Add(processor.Create(OpCodes.Ceq));
instructions.Add(processor.Create(OpCodes.Brfalse, returnInstr));
// if (networkManager.IsServer || networkManager.IsHost) -> ServerRpc
// if (networkManager.IsClient || networkManager.IsHost) -> ClientRpc
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsServer_MethodRef : m_NetworkManager_getIsClient_MethodRef));
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
// if (networkManager.IsServer || networkManager.IsHost) -> ServerRpc
// if (networkManager.IsClient || networkManager.IsHost) -> ClientRpc
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, isServerRpc ? m_NetworkManager_getIsServer_MethodRef : m_NetworkManager_getIsClient_MethodRef));
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
instructions.Add(processor.Create(OpCodes.Ldloc, netManLocIdx));
instructions.Add(processor.Create(OpCodes.Callvirt, m_NetworkManager_getIsHost_MethodRef));
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
instructions.Add(returnInstr);
instructions.Add(lastInstr);
// This needs to be set back before executing the callback or else sending another RPC
// from within an RPC will not work.
// __rpc_exec_stage = __RpcExecStage.Send
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send));
instructions.Add(processor.Create(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
}
else
{
// if (__rpc_exec_stage == __RpcExecStage.Execute)
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Execute));
instructions.Add(processor.Create(OpCodes.Ceq));
instructions.Add(processor.Create(OpCodes.Brtrue, lastInstr));
instructions.Add(returnInstr);
instructions.Add(lastInstr);
// This needs to be set back before executing the callback or else sending another RPC
// from within an RPC will not work.
// __rpc_exec_stage = __RpcExecStage.Send
instructions.Add(processor.Create(OpCodes.Ldarg_0));
instructions.Add(processor.Create(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send));
instructions.Add(processor.Create(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef));
}
instructions.Add(returnInstr);
instructions.Add(lastInstr);
}
instructions.Reverse();
@@ -2458,6 +2733,8 @@ namespace Unity.Netcode.Editor.CodeGen
var processor = rpcHandler.Body.GetILProcessor();
var isServerRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ServerRpcAttribute_FullName;
var isCientRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.ClientRpcAttribute_FullName;
var isGenericRpc = rpcAttribute.AttributeType.FullName == CodeGenHelpers.RpcAttribute_FullName;
var requireOwnership = true; // default value MUST be == `ServerRpcAttribute.RequireOwnership`
foreach (var attrField in rpcAttribute.Fields)
{
@@ -2564,6 +2841,15 @@ namespace Unity.Netcode.Editor.CodeGen
processor.Emit(OpCodes.Stloc, localIndex);
continue;
}
// RpcParams
if (paramType.FullName == CodeGenHelpers.RpcParams_FullName)
{
processor.Emit(OpCodes.Ldarg_2);
processor.Emit(OpCodes.Ldfld, m_RpcParams_Ext_FieldRef);
processor.Emit(OpCodes.Stloc, localIndex);
continue;
}
}
Instruction jumpInstruction = null;
@@ -2690,7 +2976,7 @@ namespace Unity.Netcode.Editor.CodeGen
// NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.Server; -> ServerRpc
// NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.Client; -> ClientRpc
processor.Emit(OpCodes.Ldarg_0);
processor.Emit(OpCodes.Ldc_I4, (int)(isServerRpc ? NetworkBehaviour.__RpcExecStage.Server : NetworkBehaviour.__RpcExecStage.Client));
processor.Emit(OpCodes.Ldc_I4, (int)(NetworkBehaviour.__RpcExecStage.Execute));
processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
// NetworkBehaviour.XXXRpc(...);
@@ -2713,7 +2999,7 @@ namespace Unity.Netcode.Editor.CodeGen
// NetworkBehaviour.__rpc_exec_stage = __RpcExecStage.None;
processor.Emit(OpCodes.Ldarg_0);
processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.None);
processor.Emit(OpCodes.Ldc_I4, (int)NetworkBehaviour.__RpcExecStage.Send);
processor.Emit(OpCodes.Stfld, m_NetworkBehaviour_rpc_exec_stage_FieldRef);
processor.Emit(OpCodes.Ret);

12
Editor/CodeGen/RuntimeAccessModifiersILPP.cs
View File

@@ -2,6 +2,7 @@ using System.Collections.Generic;
using System.IO;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Cecil.Rocks;
using Unity.CompilationPipeline.Common.Diagnostics;
using Unity.CompilationPipeline.Common.ILPostProcessing;
using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
@@ -52,6 +53,15 @@ namespace Unity.Netcode.Editor.CodeGen
case nameof(NetworkBehaviour):
ProcessNetworkBehaviour(typeDefinition);
break;
case nameof(RpcAttribute):
foreach (var methodDefinition in typeDefinition.GetConstructors())
{
if (methodDefinition.Parameters.Count == 0)
{
methodDefinition.IsPublic = true;
}
}
break;
case nameof(__RpcParams):
case nameof(RpcFallbackSerialization):
typeDefinition.IsPublic = true;
@@ -154,6 +164,8 @@ namespace Unity.Netcode.Editor.CodeGen
methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc) ||
methodDefinition.Name == nameof(NetworkBehaviour.__beginSendRpc) ||
methodDefinition.Name == nameof(NetworkBehaviour.__endSendRpc) ||
methodDefinition.Name == nameof(NetworkBehaviour.__initializeVariables) ||
methodDefinition.Name == nameof(NetworkBehaviour.__initializeRpcs) ||
methodDefinition.Name == nameof(NetworkBehaviour.__registerRpc) ||

558
Editor/NetworkManagerEditor.cs
View File

@@ -1,3 +1,6 @@
#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
#define RELAY_INTEGRATION_AVAILABLE
#endif
using System;
using System.Collections.Generic;
using System.IO;
@@ -48,6 +51,27 @@ namespace Unity.Netcode.Editor
private readonly List<Type> m_TransportTypes = new List<Type>();
private string[] m_TransportNames = { "Select transport..." };
/// <inheritdoc/>
public override void OnInspectorGUI()
{
Initialize();
CheckNullProperties();
#if !MULTIPLAYER_TOOLS
DrawInstallMultiplayerToolsTip();
#endif
if (m_NetworkManager.IsServer || m_NetworkManager.IsClient)
{
DrawDisconnectButton();
}
else
{
DrawAllPropertyFields();
ShowStartConnectionButtons();
}
}
private void ReloadTransports()
{
m_TransportTypes.Clear();
@@ -138,209 +162,311 @@ namespace Unity.Netcode.Editor
.FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
}
/// <inheritdoc/>
public override void OnInspectorGUI()
private void DrawAllPropertyFields()
{
Initialize();
CheckNullProperties();
serializedObject.Update();
EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
EditorGUILayout.PropertyField(m_LogLevelProperty);
EditorGUILayout.Space();
#if !MULTIPLAYER_TOOLS
DrawInstallMultiplayerToolsTip();
#endif
EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
EditorGUILayout.Space();
if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
DrawPrefabListField();
EditorGUILayout.Space();
EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
DrawTransportField();
EditorGUILayout.PropertyField(m_TickRateProperty);
EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
{
serializedObject.Update();
EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
EditorGUILayout.PropertyField(m_LogLevelProperty);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
EditorGUILayout.Space();
if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
{
EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
{
// Default directory
var directory = "Assets/";
var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
if (assetPath == "")
{
assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
}
if (assetPath != "")
{
directory = Path.GetDirectoryName(assetPath);
}
else
{
#if UNITY_2021_1_OR_NEWER
var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
#else
var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
#endif
if (prefabStage != null)
{
var prefabPath = prefabStage.assetPath;
if (!string.IsNullOrEmpty(prefabPath))
{
directory = Path.GetDirectoryName(prefabPath);
}
}
if (m_NetworkManager.gameObject.scene != null)
{
var scenePath = m_NetworkManager.gameObject.scene.path;
if (!string.IsNullOrEmpty(scenePath))
{
directory = Path.GetDirectoryName(scenePath);
}
}
}
var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
Debug.Log("Saving migrated Network Prefabs List to " + path);
AssetDatabase.CreateAsset(networkPrefabs, path);
EditorUtility.SetDirty(m_NetworkManager);
}
}
else
{
if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
{
EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
}
EditorGUILayout.PropertyField(m_PrefabsList);
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
EditorGUILayout.PropertyField(m_NetworkTransportProperty);
if (m_NetworkTransportProperty.objectReferenceValue == null)
{
EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
int selection = EditorGUILayout.Popup(0, m_TransportNames);
if (selection > 0)
{
ReloadTransports();
var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
m_NetworkTransportProperty.objectReferenceValue = transportComponent;
Repaint();
}
}
EditorGUILayout.PropertyField(m_TickRateProperty);
EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
{
EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
}
EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
{
EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
}
EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
{
EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
}
serializedObject.ApplyModifiedProperties();
// Start buttons below
{
string buttonDisabledReasonSuffix = "";
if (!EditorApplication.isPlaying)
{
buttonDisabledReasonSuffix = ". This can only be done in play mode";
GUI.enabled = false;
}
if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
{
m_NetworkManager.StartHost();
}
if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
{
m_NetworkManager.StartServer();
}
if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
{
m_NetworkManager.StartClient();
}
if (!EditorApplication.isPlaying)
{
GUI.enabled = true;
}
}
EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
}
else
EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
{
string instanceType = string.Empty;
EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
}
if (m_NetworkManager.IsHost)
{
instanceType = "Host";
}
else if (m_NetworkManager.IsServer)
{
instanceType = "Server";
}
else if (m_NetworkManager.IsClient)
{
instanceType = "Client";
}
EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
{
EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
}
serializedObject.ApplyModifiedProperties();
}
private void DrawTransportField()
{
#if RELAY_INTEGRATION_AVAILABLE
var useRelay = EditorPrefs.GetBool(k_UseEasyRelayIntegrationKey, false);
#else
var useRelay = false;
#endif
if (useRelay)
{
EditorGUILayout.HelpBox("Test connection with relay is enabled, so the default Unity Transport will be used", MessageType.Info);
GUI.enabled = false;
EditorGUILayout.PropertyField(m_NetworkTransportProperty);
GUI.enabled = true;
return;
}
EditorGUILayout.PropertyField(m_NetworkTransportProperty);
if (m_NetworkTransportProperty.objectReferenceValue == null)
{
EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
int selection = EditorGUILayout.Popup(0, m_TransportNames);
if (selection > 0)
{
m_NetworkManager.Shutdown();
ReloadTransports();
var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
m_NetworkTransportProperty.objectReferenceValue = transportComponent;
Repaint();
}
}
}
#if RELAY_INTEGRATION_AVAILABLE
private readonly string k_UseEasyRelayIntegrationKey = "NetworkManagerUI_UseRelay_" + Application.dataPath.GetHashCode();
private string m_JoinCode = "";
private string m_StartConnectionError = null;
private string m_Region = "";
// wait for next frame so that ImGui finishes the current frame
private static void RunNextFrame(Action action) => EditorApplication.delayCall += () => action();
#endif
private void ShowStartConnectionButtons()
{
EditorGUILayout.LabelField("Start Connection", EditorStyles.boldLabel);
#if RELAY_INTEGRATION_AVAILABLE
// use editor prefs to persist the setting when entering / leaving play mode / exiting Unity
var useRelay = EditorPrefs.GetBool(k_UseEasyRelayIntegrationKey, false);
GUILayout.BeginHorizontal();
useRelay = GUILayout.Toggle(useRelay, "Try Relay in the Editor");
var icon = EditorGUIUtility.IconContent("_Help");
icon.tooltip = "This will help you test relay in the Editor. Click here to know how to integrate Relay in your build";
if (GUILayout.Button(icon, GUIStyle.none, GUILayout.Width(20)))
{
Application.OpenURL("https://docs-multiplayer.unity3d.com/netcode/current/relay/");
}
GUILayout.EndHorizontal();
EditorPrefs.SetBool(k_UseEasyRelayIntegrationKey, useRelay);
if (useRelay && !Application.isPlaying && !CloudProjectSettings.projectBound)
{
EditorGUILayout.HelpBox("To use relay, you need to setup your project in the Project Settings in the Services section.", MessageType.Warning);
if (GUILayout.Button("Open Project settings"))
{
SettingsService.OpenProjectSettings("Project/Services");
}
}
#else
var useRelay = false;
#endif
string buttonDisabledReasonSuffix = "";
if (!EditorApplication.isPlaying)
{
buttonDisabledReasonSuffix = ". This can only be done in play mode";
GUI.enabled = false;
}
if (useRelay)
{
ShowStartConnectionButtons_Relay(buttonDisabledReasonSuffix);
}
else
{
ShowStartConnectionButtons_Standard(buttonDisabledReasonSuffix);
}
if (!EditorApplication.isPlaying)
{
GUI.enabled = true;
}
}
private void ShowStartConnectionButtons_Relay(string buttonDisabledReasonSuffix)
{
#if RELAY_INTEGRATION_AVAILABLE
void AddStartServerOrHostButton(bool isServer)
{
var type = isServer ? "Server" : "Host";
if (GUILayout.Button(new GUIContent($"Start {type}", $"Starts a {type} instance with Relay{buttonDisabledReasonSuffix}")))
{
m_StartConnectionError = null;
RunNextFrame(async () =>
{
try
{
var (joinCode, allocation) = isServer ? await m_NetworkManager.StartServerWithRelay() : await m_NetworkManager.StartHostWithRelay();
m_JoinCode = joinCode;
m_Region = allocation.Region;
Repaint();
}
catch (Exception e)
{
m_StartConnectionError = e.Message;
throw;
}
});
}
}
AddStartServerOrHostButton(isServer: true);
AddStartServerOrHostButton(isServer: false);
GUILayout.Space(8f);
m_JoinCode = EditorGUILayout.TextField("Relay Join Code", m_JoinCode);
if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance with Relay" + buttonDisabledReasonSuffix)))
{
m_StartConnectionError = null;
RunNextFrame(async () =>
{
if (string.IsNullOrEmpty(m_JoinCode))
{
m_StartConnectionError = "Please provide a join code!";
return;
}
try
{
var allocation = await m_NetworkManager.StartClientWithRelay(m_JoinCode);
m_Region = allocation.Region;
Repaint();
}
catch (Exception e)
{
m_StartConnectionError = e.Message;
throw;
}
});
}
if (Application.isPlaying && !string.IsNullOrEmpty(m_StartConnectionError))
{
EditorGUILayout.HelpBox(m_StartConnectionError, MessageType.Error);
}
#endif
}
private void ShowStartConnectionButtons_Standard(string buttonDisabledReasonSuffix)
{
if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
{
m_NetworkManager.StartHost();
}
if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
{
m_NetworkManager.StartServer();
}
if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
{
m_NetworkManager.StartClient();
}
}
private void DrawDisconnectButton()
{
string instanceType = string.Empty;
if (m_NetworkManager.IsHost)
{
instanceType = "Host";
}
else if (m_NetworkManager.IsServer)
{
instanceType = "Server";
}
else if (m_NetworkManager.IsClient)
{
instanceType = "Client";
}
EditorGUILayout.HelpBox($"You cannot edit the NetworkConfig when a {instanceType} is running.", MessageType.Info);
#if RELAY_INTEGRATION_AVAILABLE
if (!string.IsNullOrEmpty(m_JoinCode) && !string.IsNullOrEmpty(m_Region))
{
var style = new GUIStyle(EditorStyles.helpBox)
{
fontSize = 10,
alignment = TextAnchor.MiddleCenter,
};
GUILayout.BeginHorizontal(style, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
GUILayout.Space(25f);
GUILayout.BeginVertical();
GUILayout.Space(4f);
GUILayout.Label($"Connected via relay ({m_Region}).\nJoin code: {m_JoinCode}", EditorStyles.miniLabel, GUILayout.ExpandHeight(true));
if (GUILayout.Button("Copy code", GUILayout.ExpandHeight(true)))
{
GUIUtility.systemCopyBuffer = m_JoinCode;
}
GUILayout.Space(4f);
GUILayout.EndVertical();
GUILayout.Space(2f);
GUILayout.EndHorizontal();
}
#endif
if (GUILayout.Button(new GUIContent($"Stop {instanceType}", $"Stops the {instanceType} instance.")))
{
#if RELAY_INTEGRATION_AVAILABLE
m_JoinCode = "";
#endif
m_NetworkManager.Shutdown();
}
}
private const string k_InfoIconName = "console.infoicon";
private static void DrawInstallMultiplayerToolsTip()
{
const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
const string openDocsButtonText = "Open Docs";
const string dismissButtonText = "Dismiss";
const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
const string infoIconName = "console.infoicon";
if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
{
@@ -371,7 +497,7 @@ namespace Unity.Netcode.Editor
GUILayout.FlexibleSpace();
GUILayout.BeginHorizontal(s_HelpBoxStyle, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
{
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(infoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
GUILayout.Space(4);
GUILayout.Label(getToolsText, s_CenteredWordWrappedLabelStyle, GUILayout.ExpandHeight(true));
@@ -404,5 +530,69 @@ namespace Unity.Netcode.Editor
GUILayout.Space(10);
}
private void DrawPrefabListField()
{
if (!m_NetworkManager.NetworkConfig.HasOldPrefabList())
{
if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
{
EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
}
EditorGUILayout.PropertyField(m_PrefabsList);
return;
}
// Old format of prefab list
EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
{
// Default directory
var directory = "Assets/";
var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
if (assetPath == "")
{
assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
}
if (assetPath != "")
{
directory = Path.GetDirectoryName(assetPath);
}
else
{
#if UNITY_2021_1_OR_NEWER
var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
#else
var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
#endif
if (prefabStage != null)
{
var prefabPath = prefabStage.assetPath;
if (!string.IsNullOrEmpty(prefabPath))
{
directory = Path.GetDirectoryName(prefabPath);
}
}
if (m_NetworkManager.gameObject.scene != null)
{
var scenePath = m_NetworkManager.gameObject.scene.path;
if (!string.IsNullOrEmpty(scenePath))
{
directory = Path.GetDirectoryName(scenePath);
}
}
}
var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
Debug.Log("Saving migrated Network Prefabs List to " + path);
AssetDatabase.CreateAsset(networkPrefabs, path);
EditorUtility.SetDirty(m_NetworkManager);
}
}
}
}

120
Editor/NetworkManagerRelayIntegration.cs Normal file
View File

@@ -0,0 +1,120 @@
#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
using System;
using System.Threading.Tasks;
using Unity.Netcode.Transports.UTP;
using Unity.Networking.Transport.Relay;
using Unity.Services.Authentication;
using Unity.Services.Core;
using Unity.Services.Relay;
using Unity.Services.Relay.Models;
namespace Unity.Netcode.Editor
{
/// <summary>
/// Integration with Unity Relay SDK and Unity Transport that support the additional buttons in the NetworkManager inspector.
/// This code could theoretically be used at runtime, but we would like to avoid the additional dependencies in the runtime assembly of netcode for gameobjects.
/// </summary>
public static class NetworkManagerRelayIntegration
{
#if UNITY_WEBGL
private const string k_DefaultConnectionType = "wss";
#else
private const string k_DefaultConnectionType = "dtls";
#endif
/// <summary>
/// Easy relay integration (host): it will initialize the unity services, sign in anonymously and start the host with a new relay allocation.
/// Note that this will force the use of Unity Transport.
/// </summary>
/// <param name="networkManager">The network manager that will start the connection</param>
/// <param name="maxConnections">Maximum number of connections to the created relay.</param>
/// <param name="connectionType">The connection type of the <see cref="RelayServerData"/> (wss, ws, dtls or udp) </param>
/// <returns>The join code that a potential client can use and the allocation</returns>
/// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
/// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
/// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
/// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
/// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
/// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
/// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
internal static async Task<(string, Allocation)> StartHostWithRelay(this NetworkManager networkManager, int maxConnections = 5)
{
var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
return networkManager.StartHost() ? codeAndAllocation : (null, null);
}
/// <summary>
/// Easy relay integration (server): it will initialize the unity services, sign in anonymously and start the server with a new relay allocation.
/// Note that this will force the use of Unity Transport.
/// </summary>
/// <param name="networkManager">The network manager that will start the connection</param>
/// <param name="maxConnections">Maximum number of connections to the created relay.</param>
/// <returns>The join code that a potential client can use and the allocation.</returns>
/// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
/// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
/// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
/// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
/// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
/// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
/// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
internal static async Task<(string, Allocation)> StartServerWithRelay(this NetworkManager networkManager, int maxConnections = 5)
{
var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
return networkManager.StartServer() ? codeAndAllocation : (null, null);
}
/// <summary>
/// Easy relay integration (client): it will initialize the unity services, sign in anonymously, join the relay with the given join code and start the client.
/// Note that this will force the use of Unity Transport.
/// </summary>
/// <param name="networkManager">The network manager that will start the connection</param>
/// <param name="joinCode">The join code of the allocation</param>
/// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
/// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
/// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
/// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
/// <exception cref="RequestFailedException">Thrown when the request does not reach the Relay Allocation Service.</exception>
/// <exception cref="ArgumentException">Thrown if the joinCode has the wrong format.</exception>
/// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
/// <returns>True if starting the client was successful</returns>
internal static async Task<JoinAllocation> StartClientWithRelay(this NetworkManager networkManager, string joinCode)
{
await UnityServices.InitializeAsync();
if (!AuthenticationService.Instance.IsSignedIn)
{
await AuthenticationService.Instance.SignInAnonymouslyAsync();
}
var joinAllocation = await RelayService.Instance.JoinAllocationAsync(joinCode: joinCode);
GetUnityTransport(networkManager, k_DefaultConnectionType).SetRelayServerData(new RelayServerData(joinAllocation, k_DefaultConnectionType));
return networkManager.StartClient() ? joinAllocation : null;
}
private static async Task<(string, Allocation)> InitializeAndCreateAllocAsync(NetworkManager networkManager, int maxConnections, string connectionType)
{
await UnityServices.InitializeAsync();
if (!AuthenticationService.Instance.IsSignedIn)
{
await AuthenticationService.Instance.SignInAnonymouslyAsync();
}
Allocation allocation = await RelayService.Instance.CreateAllocationAsync(maxConnections);
GetUnityTransport(networkManager, connectionType).SetRelayServerData(new RelayServerData(allocation, connectionType));
var joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);
return (joinCode, allocation);
}
private static UnityTransport GetUnityTransport(NetworkManager networkManager, string connectionType)
{
if (!networkManager.TryGetComponent<UnityTransport>(out var transport))
{
transport = networkManager.gameObject.AddComponent<UnityTransport>();
}
#if UTP_TRANSPORT_2_0_ABOVE
transport.UseWebSockets = connectionType.StartsWith("ws"); // Probably should be part of SetRelayServerData, but not possible at this point
#endif
networkManager.NetworkConfig.NetworkTransport = transport; // Force using UnityTransport
return transport;
}
}
}
#endif

3
Editor/NetworkManagerRelayIntegration.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 23b658b1c2e443109a8a131ef3632c9b
timeCreated: 1698673251

6
Editor/NetworkTransformEditor.cs
View File

@@ -10,6 +10,7 @@ namespace Unity.Netcode.Editor
[CustomEditor(typeof(NetworkTransform), true)]
public class NetworkTransformEditor : UnityEditor.Editor
{
private SerializedProperty m_UseUnreliableDeltas;
private SerializedProperty m_SyncPositionXProperty;
private SerializedProperty m_SyncPositionYProperty;
private SerializedProperty m_SyncPositionZProperty;
@@ -39,6 +40,7 @@ namespace Unity.Netcode.Editor
/// <inheritdoc/>
public void OnEnable()
{
m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
m_SyncPositionZProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionZ));
@@ -129,7 +131,9 @@ namespace Unity.Netcode.Editor
EditorGUILayout.PropertyField(m_PositionThresholdProperty);
EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
EditorGUILayout.Space();
EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
EditorGUILayout.PropertyField(m_InLocalSpaceProperty);

25
Editor/com.unity.netcode.editor.asmdef
View File

@@ -3,11 +3,21 @@
"rootNamespace": "Unity.Netcode.Editor",
"references": [
"Unity.Netcode.Runtime",
"Unity.Netcode.Components"
"Unity.Netcode.Components",
"Unity.Services.Relay",
"Unity.Networking.Transport",
"Unity.Services.Core",
"Unity.Services.Authentication"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [
{
"name": "com.unity.multiplayer.tools",
@@ -33,6 +43,17 @@
"name": "com.unity.modules.physics2d",
"expression": "",
"define": "COM_UNITY_MODULES_PHYSICS2D"
},
{
"name": "com.unity.services.relay",
"expression": "1.0",
"define": "RELAY_SDK_INSTALLED"
},
{
"name": "com.unity.transport",
"expression": "2.0",
"define": "UTP_TRANSPORT_2_0_ABOVE"
}
]
],
"noEngineReferences": false
}

2
Runtime/Configuration/NetworkConfig.cs
View File

@@ -132,7 +132,7 @@ namespace Unity.Netcode
/// The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped.
/// </summary>
[Tooltip("The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped")]
public float SpawnTimeout = 1f;
public float SpawnTimeout = 10f;
/// <summary>
/// Whether or not to enable network logs.

31
Runtime/Configuration/NetworkPrefabs.cs
View File

@@ -30,6 +30,12 @@ namespace Unity.Netcode
[NonSerialized]
public Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
/// <summary>
/// This is used for the legacy way of spawning NetworkPrefabs with an override when manually instantiating and spawning.
/// To handle multiple source NetworkPrefab overrides that all point to the same target NetworkPrefab use
/// <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>
/// or <see cref="NetworkObject.InstantiateAndSpawn(NetworkManager, ulong, bool, bool, bool, Vector3, Quaternion)"/>
/// </summary>
[NonSerialized]
public Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
@@ -234,7 +240,8 @@ namespace Unity.Netcode
{
for (int i = 0; i < m_Prefabs.Count; i++)
{
if (m_Prefabs[i].Prefab == prefab)
// Check both values as Prefab and be different than SourcePrefabToOverride
if (m_Prefabs[i].Prefab == prefab || m_Prefabs[i].SourcePrefabToOverride == prefab)
{
return true;
}
@@ -262,7 +269,7 @@ namespace Unity.Netcode
}
/// <summary>
/// Configures <see cref="NetworkPrefabOverrideLinks"/> and <see cref="OverrideToNetworkPrefab"/> for the given <see cref="NetworkPrefab"/>
/// Configures <see cref="NetworkPrefabOverrideLinks"/> for the given <see cref="NetworkPrefab"/>
/// </summary>
private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
{
@@ -296,28 +303,16 @@ namespace Unity.Netcode
return true;
}
// Make sure we don't have several overrides targeting the same prefab. Apparently we don't support that... shame.
if (OverrideToNetworkPrefab.ContainsKey(target))
{
var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
// This can happen if a user tries to make several GlobalObjectIdHash values point to the same target
Debug.LogError($"{nameof(NetworkPrefab)} (\"{networkObject.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} target entry value of: {target}!");
return false;
}
switch (networkPrefab.Override)
{
case NetworkPrefabOverride.Prefab:
{
NetworkPrefabOverrideLinks.Add(source, networkPrefab);
OverrideToNetworkPrefab.Add(target, source);
}
break;
case NetworkPrefabOverride.Hash:
{
NetworkPrefabOverrideLinks.Add(source, networkPrefab);
OverrideToNetworkPrefab.Add(target, source);
if (!OverrideToNetworkPrefab.ContainsKey(target))
{
OverrideToNetworkPrefab.Add(target, source);
}
}
break;
}

217
Runtime/Connection/NetworkConnectionManager.cs
View File

@@ -10,6 +10,38 @@ using Object = UnityEngine.Object;
namespace Unity.Netcode
{
public enum ConnectionEvent
{
ClientConnected,
PeerConnected,
ClientDisconnected,
PeerDisconnected
}
public struct ConnectionEventData
{
public ConnectionEvent EventType;
/// <summary>
/// The client ID for the client that just connected
/// For the <see cref="ConnectionEvent.ClientConnected"/> and <see cref="ConnectionEvent.ClientDisconnected"/>
/// events on the client side, this will be LocalClientId.
/// On the server side, this will be the ID of the client that just connected.
///
/// For the <see cref="ConnectionEvent.PeerConnected"/> and <see cref="ConnectionEvent.PeerDisconnected"/>
/// events on the client side, this will be the client ID assigned by the server to the remote peer.
/// </summary>
public ulong ClientId;
/// <summary>
/// This is only populated in <see cref="ConnectionEvent.ClientConnected"/> on the client side, and
/// contains the list of other peers who were present before you connected. In all other situations,
/// this array will be uninitialized.
/// </summary>
public NativeArray<ulong> PeerClientIds;
}
/// <summary>
/// The NGO connection manager handles:
/// - Client Connections
@@ -42,7 +74,105 @@ namespace Unity.Netcode
/// </summary>
public event Action<ulong> OnClientDisconnectCallback = null;
internal void InvokeOnClientConnectedCallback(ulong clientId) => OnClientConnectedCallback?.Invoke(clientId);
/// <summary>
/// The callback to invoke once a peer connects. This callback is only ran on the server and on the local client that connects.
/// </summary>
public event Action<NetworkManager, ConnectionEventData> OnConnectionEvent = null;
internal void InvokeOnClientConnectedCallback(ulong clientId)
{
try
{
OnClientConnectedCallback?.Invoke(clientId);
}
catch (Exception exception)
{
Debug.LogException(exception);
}
if (!NetworkManager.IsServer)
{
var peerClientIds = new NativeArray<ulong>(Math.Max(NetworkManager.ConnectedClientsIds.Count - 1, 0), Allocator.Temp);
// `using var peerClientIds` or `using(peerClientIds)` renders it immutable...
using var sentinel = peerClientIds;
var idx = 0;
foreach (var peerId in NetworkManager.ConnectedClientsIds)
{
if (peerId == NetworkManager.LocalClientId)
{
continue;
}
peerClientIds[idx] = peerId;
++idx;
}
try
{
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = NetworkManager.LocalClientId, EventType = ConnectionEvent.ClientConnected, PeerClientIds = peerClientIds });
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
else
{
try
{
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.ClientConnected });
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
}
internal void InvokeOnClientDisconnectCallback(ulong clientId)
{
try
{
OnClientDisconnectCallback?.Invoke(clientId);
}
catch (Exception exception)
{
Debug.LogException(exception);
}
try
{
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.ClientDisconnected });
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
internal void InvokeOnPeerConnectedCallback(ulong clientId)
{
try
{
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.PeerConnected });
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
internal void InvokeOnPeerDisconnectedCallback(ulong clientId)
{
try
{
OnConnectionEvent?.Invoke(NetworkManager, new ConnectionEventData { ClientId = clientId, EventType = ConnectionEvent.PeerDisconnected });
}
catch (Exception exception)
{
Debug.LogException(exception);
}
}
/// <summary>
/// The callback to invoke if the <see cref="NetworkTransport"/> fails.
@@ -217,7 +347,7 @@ namespace Unity.Netcode
// When this happens, the client will not have an entry within the m_TransportIdToClientIdMap or m_ClientIdToTransportIdMap lookup tables so we exit early and just return 0 to be used for the disconnect event.
if (!LocalClient.IsServer && !TransportIdToClientIdMap.ContainsKey(transportId))
{
return 0;
return NetworkManager.LocalClientId;
}
var clientId = TransportIdToClientId(transportId);
@@ -346,31 +476,38 @@ namespace Unity.Netcode
s_TransportDisconnect.Begin();
#endif
var clientId = TransportIdCleanUp(transportClientId);
if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
{
NetworkLog.LogInfo($"Disconnect Event From {clientId}");
}
// If we are a client and we have gotten the ServerClientId back, then use our assigned local id as the client that was
// disconnected (either the user disconnected or the server disconnected, but the client that disconnected is the LocalClientId)
if (!NetworkManager.IsServer && clientId == NetworkManager.ServerClientId)
{
clientId = NetworkManager.LocalClientId;
}
// Process the incoming message queue so that we get everything from the server disconnecting us or, if we are the server, so we got everything from that client.
MessageManager.ProcessIncomingMessageQueue();
try
InvokeOnClientDisconnectCallback(clientId);
if (LocalClient.IsHost)
{
OnClientDisconnectCallback?.Invoke(clientId);
}
catch (Exception exception)
{
Debug.LogException(exception);
InvokeOnPeerDisconnectedCallback(clientId);
}
if (LocalClient.IsServer)
{
OnClientDisconnectFromServer(clientId);
}
else
else // As long as we are not in the middle of a shutdown
if (!NetworkManager.ShutdownInProgress)
{
// We must pass true here and not process any sends messages as we are no longer connected and thus there is no one to send any messages to and this will cause an exception within UnityTransport as the client ID is no longer valid.
// We must pass true here and not process any sends messages as we are no longer connected.
// Otherwise, attempting to process messages here can cause an exception within UnityTransport
// as the client ID is no longer valid.
NetworkManager.Shutdown(true);
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
@@ -623,8 +760,17 @@ namespace Unity.Netcode
var message = new ConnectionApprovedMessage
{
OwnerClientId = ownerClientId,
NetworkTick = NetworkManager.LocalTime.Tick
NetworkTick = NetworkManager.LocalTime.Tick,
ConnectedClientIds = new NativeArray<ulong>(ConnectedClientIds.Count, Allocator.Temp)
};
var i = 0;
foreach (var clientId in ConnectedClientIds)
{
message.ConnectedClientIds[i] = clientId;
++i;
}
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
{
// Update the observed spawned NetworkObjects for the newly connected player when scene management is disabled
@@ -651,12 +797,17 @@ namespace Unity.Netcode
SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ownerClientId);
message.MessageVersions.Dispose();
message.ConnectedClientIds.Dispose();
// If scene management is disabled, then we are done and notify the local host-server the client is connected
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
{
NetworkManager.ConnectedClients[ownerClientId].IsConnected = true;
InvokeOnClientConnectedCallback(ownerClientId);
if (LocalClient.IsHost)
{
InvokeOnPeerConnectedCallback(ownerClientId);
}
}
else // Otherwise, let NetworkSceneManager handle the initial scene and NetworkObject synchronization
{
@@ -740,6 +891,8 @@ namespace Unity.Netcode
ConnectedClients.Add(clientId, networkClient);
ConnectedClientsList.Add(networkClient);
var message = new ClientConnectedMessage { ClientId = clientId };
NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
ConnectedClientIds.Add(clientId);
return networkClient;
}
@@ -757,6 +910,7 @@ namespace Unity.Netcode
// If we are shutting down and this is the server or host disconnecting, then ignore
// clean up as everything that needs to be destroyed will be during shutdown.
if (NetworkManager.ShutdownInProgress && clientId == NetworkManager.ServerClientId)
{
return;
@@ -780,7 +934,7 @@ namespace Unity.Netcode
NetworkManager.SpawnManager.DespawnObject(playerObject, true);
}
}
else
else if (!NetworkManager.ShutdownInProgress)
{
playerObject.RemoveOwnership();
}
@@ -816,7 +970,7 @@ namespace Unity.Netcode
Object.Destroy(ownedObject.gameObject);
}
}
else
else if (!NetworkManager.ShutdownInProgress)
{
ownedObject.RemoveOwnership();
}
@@ -837,6 +991,8 @@ namespace Unity.Netcode
}
ConnectedClientIds.Remove(clientId);
var message = new ClientDisconnectedMessage { ClientId = clientId };
MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
}
// If the client ID transport map exists
@@ -845,13 +1001,11 @@ namespace Unity.Netcode
var transportId = ClientIdToTransportId(clientId);
NetworkManager.NetworkConfig.NetworkTransport.DisconnectRemoteClient(transportId);
try
InvokeOnClientDisconnectCallback(clientId);
if (LocalClient.IsHost)
{
OnClientDisconnectCallback?.Invoke(clientId);
}
catch (Exception exception)
{
Debug.LogException(exception);
InvokeOnPeerDisconnectedCallback(clientId);
}
// Clean up the transport to client (and vice versa) mappings
@@ -889,6 +1043,12 @@ namespace Unity.Netcode
throw new NotServerException($"Only server can disconnect remote clients. Please use `{nameof(Shutdown)}()` instead.");
}
if (clientId == NetworkManager.ServerClientId)
{
Debug.LogWarning($"Disconnecting the local server-host client is not allowed. Use NetworkManager.Shutdown instead.");
return;
}
if (!string.IsNullOrEmpty(reason))
{
var disconnectReason = new DisconnectReasonMessage
@@ -933,13 +1093,8 @@ namespace Unity.Netcode
/// </summary>
internal void Shutdown()
{
LocalClient.IsApproved = false;
LocalClient.IsConnected = false;
if (LocalClient.IsServer)
{
// make sure all messages are flushed before transport disconnect clients
MessageManager?.ProcessSendQueues();
// Build a list of all client ids to be disconnected
var disconnectedIds = new HashSet<ulong>();
@@ -975,9 +1130,15 @@ namespace Unity.Netcode
{
DisconnectRemoteClient(clientId);
}
// make sure all messages are flushed before transport disconnects clients
MessageManager?.ProcessSendQueues();
}
else if (NetworkManager != null && NetworkManager.IsListening && LocalClient.IsClient)
{
// make sure all messages are flushed before disconnecting
MessageManager?.ProcessSendQueues();
// Client only, send disconnect and if transport throws and exception, log the exception and continue the shutdown sequence (or forever be shutting down)
try
{
@@ -989,6 +1150,12 @@ namespace Unity.Netcode
}
}
LocalClient.IsApproved = false;
LocalClient.IsConnected = false;
ConnectedClients.Clear();
ConnectedClientIds.Clear();
ConnectedClientsList.Clear();
if (NetworkManager != null && NetworkManager.NetworkConfig?.NetworkTransport != null)
{
NetworkManager.NetworkConfig.NetworkTransport.OnTransportEvent -= HandleNetworkEvent;

137
Runtime/Core/NetworkBehaviour.cs
View File

@@ -6,6 +6,14 @@ using UnityEngine;
namespace Unity.Netcode
{
public class RpcException : Exception
{
public RpcException(string message) : base(message)
{
}
}
/// <summary>
/// The base class to override to write network code. Inherits MonoBehaviour
/// </summary>
@@ -27,16 +35,22 @@ namespace Unity.Netcode
// RuntimeAccessModifiersILPP will make this `protected`
internal enum __RpcExecStage
{
// Technically will overlap with None and Server
// but it doesn't matter since we don't use None and Server
Send = 0,
Execute = 1,
// Backward compatibility, not used...
None = 0,
Server = 1,
Client = 2
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;
internal __RpcExecStage __rpc_exec_stage = __RpcExecStage.Send;
#pragma warning restore IDE1006 // restore naming rule violation check
private const int k_RpcMessageDefaultSize = 1024; // 1k
@@ -284,6 +298,99 @@ namespace Unity.Netcode
#endif
}
#pragma warning disable IDE1006 // disable naming rule violation check
// RuntimeAccessModifiersILPP will make this `protected`
internal FastBufferWriter __beginSendRpc(uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
#pragma warning restore IDE1006 // restore naming rule violation check
{
if (attributeParams.RequireOwnership && !IsOwner)
{
throw new RpcException("This RPC can only be sent by its owner.");
}
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 __endSendRpc(ref FastBufferWriter bufferWriter, uint rpcMethodId, RpcParams rpcParams, RpcAttribute.RpcAttributeParams attributeParams, SendTo defaultTarget, RpcDelivery rpcDelivery)
#pragma warning restore IDE1006 // restore naming rule violation check
{
var rpcMessage = new RpcMessage
{
Metadata = new RpcMetadata
{
NetworkObjectId = NetworkObjectId,
NetworkBehaviourId = NetworkBehaviourId,
NetworkRpcMethodId = rpcMethodId,
},
SenderClientId = NetworkManager.LocalClientId,
WriteBuffer = bufferWriter
};
NetworkDelivery networkDelivery;
switch (rpcDelivery)
{
default:
case RpcDelivery.Reliable:
networkDelivery = NetworkDelivery.ReliableFragmentedSequenced;
break;
case RpcDelivery.Unreliable:
if (bufferWriter.Length > NetworkManager.MessageManager.NonFragmentedMessageMaxSize)
{
throw new OverflowException("RPC parameters are too large for unreliable delivery.");
}
networkDelivery = NetworkDelivery.Unreliable;
break;
}
if (rpcParams.Send.Target == null)
{
switch (defaultTarget)
{
case SendTo.Everyone:
rpcParams.Send.Target = RpcTarget.Everyone;
break;
case SendTo.Owner:
rpcParams.Send.Target = RpcTarget.Owner;
break;
case SendTo.Server:
rpcParams.Send.Target = RpcTarget.Server;
break;
case SendTo.NotServer:
rpcParams.Send.Target = RpcTarget.NotServer;
break;
case SendTo.NotMe:
rpcParams.Send.Target = RpcTarget.NotMe;
break;
case SendTo.NotOwner:
rpcParams.Send.Target = RpcTarget.NotOwner;
break;
case SendTo.Me:
rpcParams.Send.Target = RpcTarget.Me;
break;
case SendTo.ClientsAndHost:
rpcParams.Send.Target = RpcTarget.ClientsAndHost;
break;
case SendTo.SpecifiedInParams:
throw new RpcException("This method requires a runtime-specified send target.");
}
}
else if (defaultTarget != SendTo.SpecifiedInParams && !attributeParams.AllowTargetOverride)
{
throw new RpcException("Target override is not allowed for this method.");
}
if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Default)
{
rpcParams.Send.LocalDeferMode = attributeParams.DeferLocal ? LocalDeferMode.Defer : LocalDeferMode.SendImmediate;
}
rpcParams.Send.Target.Send(this, ref rpcMessage, networkDelivery, rpcParams);
bufferWriter.Dispose();
}
#pragma warning disable IDE1006 // disable naming rule violation check
// RuntimeAccessModifiersILPP will make this `protected`
internal static NativeList<T> __createNativeList<T>() where T : unmanaged
@@ -315,6 +422,24 @@ namespace Unity.Netcode
}
}
// This erroneously tries to simplify these method references but the docs do not pick it up correctly
// because they try to resolve it on the field rather than the class of the same name.
#pragma warning disable IDE0001
/// <summary>
/// Provides access to the various <see cref="SendTo"/> targets at runtime, as well as
/// runtime-bound targets like <see cref="Unity.Netcode.RpcTarget.Single"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeArray{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeList{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group(ulong[])"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group{T}(T)"/>, <see cref="Unity.Netcode.RpcTarget.Not(ulong)"/>,
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
/// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
/// </summary>
#pragma warning restore IDE0001
public RpcTarget RpcTarget => NetworkManager.RpcTarget;
/// <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.
@@ -331,6 +456,11 @@ namespace Unity.Netcode
/// </summary>
public bool IsServer { get; private set; }
/// <summary>
/// Gets if the server (local or remote) is a host - i.e., also a client
/// </summary>
public bool ServerIsHost { get; private set; }
/// <summary>
/// Gets if we are executing as client
/// </summary>
@@ -472,12 +602,13 @@ namespace Unity.Netcode
IsHost = NetworkManager.IsListening && NetworkManager.IsHost;
IsClient = NetworkManager.IsListening && NetworkManager.IsClient;
IsServer = NetworkManager.IsListening && NetworkManager.IsServer;
ServerIsHost = NetworkManager.IsListening && NetworkManager.ServerIsHost;
}
}
else // Shouldn't happen, but if so then set the properties to their default value;
{
OwnerClientId = NetworkObjectId = default;
IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = default;
IsOwnedByServer = IsOwner = IsHost = IsClient = IsServer = ServerIsHost = default;
NetworkBehaviourId = default;
}
}

137
Runtime/Core/NetworkManager.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using Unity.Collections;
using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
@@ -42,6 +43,8 @@ namespace Unity.Netcode
ConnectionManager.ProcessPendingApprovals();
ConnectionManager.PollAndHandleNetworkEvents();
DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0);
MessageManager.ProcessIncomingMessageQueue();
MessageManager.CleanupDisconnectedClients();
}
@@ -70,13 +73,89 @@ namespace Unity.Netcode
if (m_ShuttingDown)
{
ShutdownInternal();
// Host-server will disconnect any connected clients prior to finalizing its shutdown
if (IsServer)
{
ProcessServerShutdown();
}
else
{
// Clients just disconnect immediately
ShutdownInternal();
}
}
}
break;
}
}
/// <summary>
/// Used to provide a graceful shutdown sequence
/// </summary>
internal enum ServerShutdownStates
{
None,
WaitForClientDisconnects,
InternalShutdown,
ShuttingDown,
};
internal ServerShutdownStates ServerShutdownState;
private float m_ShutdownTimeout;
/// <summary>
/// This is a "soft shutdown" where the host or server will disconnect
/// all clients, with a provided reasons, prior to invoking its final
/// internal shutdown.
/// </summary>
internal void ProcessServerShutdown()
{
var minClientCount = IsHost ? 2 : 1;
switch (ServerShutdownState)
{
case ServerShutdownStates.None:
{
if (ConnectedClients.Count >= minClientCount)
{
var hostServer = IsHost ? "host" : "server";
var disconnectReason = $"Disconnected due to {hostServer} shutting down.";
for (int i = ConnectedClientsIds.Count - 1; i >= 0; i--)
{
var clientId = ConnectedClientsIds[i];
if (clientId == ServerClientId)
{
continue;
}
ConnectionManager.DisconnectClient(clientId, disconnectReason);
}
ServerShutdownState = ServerShutdownStates.WaitForClientDisconnects;
m_ShutdownTimeout = Time.realtimeSinceStartup + 5.0f;
}
else
{
ServerShutdownState = ServerShutdownStates.InternalShutdown;
ProcessServerShutdown();
}
break;
}
case ServerShutdownStates.WaitForClientDisconnects:
{
if (ConnectedClients.Count < minClientCount || m_ShutdownTimeout < Time.realtimeSinceStartup)
{
ServerShutdownState = ServerShutdownStates.InternalShutdown;
ProcessServerShutdown();
}
break;
}
case ServerShutdownStates.InternalShutdown:
{
ServerShutdownState = ServerShutdownStates.ShuttingDown;
ShutdownInternal();
break;
}
}
}
/// <summary>
/// The client id used to represent the server
/// </summary>
@@ -104,7 +183,7 @@ namespace Unity.Netcode
/// <summary>
/// Gets a list of just the IDs of all connected clients. This is only accessible on the server.
/// </summary>
public IReadOnlyList<ulong> ConnectedClientsIds => IsServer ? ConnectionManager.ConnectedClientIds : throw new NotServerException($"{nameof(ConnectionManager.ConnectedClientIds)} should only be accessed on server.");
public IReadOnlyList<ulong> ConnectedClientsIds => ConnectionManager.ConnectedClientIds;
/// <summary>
/// Gets the local <see cref="NetworkClient"/> for this client.
@@ -122,6 +201,11 @@ namespace Unity.Netcode
/// </summary>
public bool IsServer => ConnectionManager.LocalClient.IsServer;
/// <summary>
/// Gets whether or not the current server (local or remote) is a host - i.e., also a client
/// </summary>
public bool ServerIsHost => ConnectionManager.ConnectedClientIds.Contains(ServerClientId);
/// <summary>
/// Gets Whether or not a client is running
/// </summary>
@@ -209,6 +293,8 @@ namespace Unity.Netcode
/// <summary>
/// The callback to invoke once a client connects. This callback is only ran on the server and on the local client that connects.
///
/// It is recommended to use OnConnectionEvent instead, as this will eventually be deprecated
/// </summary>
public event Action<ulong> OnClientConnectedCallback
{
@@ -218,6 +304,8 @@ namespace Unity.Netcode
/// <summary>
/// The callback to invoke when a client disconnects. This callback is only ran on the server and on the local client that disconnects.
///
/// It is recommended to use OnConnectionEvent instead, as this will eventually be deprecated
/// </summary>
public event Action<ulong> OnClientDisconnectCallback
{
@@ -225,6 +313,16 @@ namespace Unity.Netcode
remove => ConnectionManager.OnClientDisconnectCallback -= value;
}
/// <summary>
/// The callback to invoke on any connection event. See <see cref="ConnectionEvent"/> and <see cref="ConnectionEventData"/>
/// for more info.
/// </summary>
public event Action<NetworkManager, ConnectionEventData> OnConnectionEvent
{
add => ConnectionManager.OnConnectionEvent += value;
remove => ConnectionManager.OnConnectionEvent -= value;
}
/// <summary>
/// The current host name we are connected to, used to validate certificate
/// </summary>
@@ -379,6 +477,24 @@ namespace Unity.Netcode
internal IDeferredNetworkMessageManager DeferredMessageManager { get; private set; }
// This erroneously tries to simplify these method references but the docs do not pick it up correctly
// because they try to resolve it on the field rather than the class of the same name.
#pragma warning disable IDE0001
/// <summary>
/// Provides access to the various <see cref="SendTo"/> targets at runtime, as well as
/// runtime-bound targets like <see cref="Unity.Netcode.RpcTarget.Single"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeArray{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group(NativeList{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group(ulong[])"/>,
/// <see cref="Unity.Netcode.RpcTarget.Group{T}(T)"/>, <see cref="Unity.Netcode.RpcTarget.Not(ulong)"/>,
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeArray{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Not(NativeList{ulong})"/>,
/// <see cref="Unity.Netcode.RpcTarget.Not(ulong[])"/>, and
/// <see cref="Unity.Netcode.RpcTarget.Not{T}(T)"/>
/// </summary>
#pragma warning restore IDE0001
public RpcTarget RpcTarget;
/// <summary>
/// Gets the CustomMessagingManager for this NetworkManager
/// </summary>
@@ -664,6 +780,12 @@ namespace Unity.Netcode
internal void Initialize(bool server)
{
// Make sure the ServerShutdownState is reset when initializing
if (server)
{
ServerShutdownState = ServerShutdownStates.None;
}
// Don't allow the user to start a network session if the NetworkManager is
// still parented under another GameObject
if (NetworkManagerCheckForParent(true))
@@ -729,6 +851,8 @@ namespace Unity.Netcode
DeferredMessageManager = ComponentFactory.Create<IDeferredNetworkMessageManager>(this);
RpcTarget = new RpcTarget(this);
CustomMessagingManager = new CustomMessagingManager(this);
SceneManager = new NetworkSceneManager(this);
@@ -929,6 +1053,7 @@ namespace Unity.Netcode
{
LocalClientId = ServerClientId;
NetworkMetrics.SetConnectionId(LocalClientId);
MessageManager.SetLocalClientId(LocalClientId);
if (NetworkConfig.ConnectionApproval && ConnectionApprovalCallback != null)
{
@@ -1007,11 +1132,6 @@ namespace Unity.Netcode
MessageManager.StopProcessing = discardMessageQueue;
}
}
if (NetworkConfig != null && NetworkConfig.NetworkTransport != null)
{
NetworkConfig.NetworkTransport.OnTransportEvent -= ConnectionManager.HandleNetworkEvent;
}
}
// Ensures that the NetworkManager is cleaned up before OnDestroy is run on NetworkObjects and NetworkBehaviours when unloading a scene with a NetworkManager
@@ -1036,6 +1156,9 @@ namespace Unity.Netcode
DeferredMessageManager?.CleanupAllTriggers();
CustomMessagingManager = null;
RpcTarget?.Dispose();
RpcTarget = null;
BehaviourUpdater?.Shutdown();
BehaviourUpdater = null;

205
Runtime/Core/NetworkObject.cs
View File

@@ -26,6 +26,22 @@ namespace Unity.Netcode
[SerializeField]
internal uint GlobalObjectIdHash;
/// <summary>
/// Used to track the source GlobalObjectIdHash value of the associated network prefab.
/// When an override exists or it is in-scene placed, GlobalObjectIdHash and PrefabGlobalObjectIdHash
/// will be different. The PrefabGlobalObjectIdHash value is what is used when sending a <see cref="CreateObjectMessage"/>.
/// </summary>
internal uint PrefabGlobalObjectIdHash;
/// <summary>
/// This is the source prefab of an in-scene placed NetworkObject. This is not set for in-scene
/// placd NetworkObjects that are not prefab instances, dynamically spawned prefab instances,
/// or for network prefab assets.
/// </summary>
[HideInInspector]
[SerializeField]
internal uint InScenePlacedSourceGlobalObjectIdHash;
/// <summary>
/// Gets the Prefab Hash Id of this object if the object is registerd as a prefab otherwise it returns 0
/// </summary>
@@ -34,15 +50,7 @@ namespace Unity.Netcode
{
get
{
foreach (var prefab in NetworkManager.NetworkConfig.Prefabs.Prefabs)
{
if (prefab.Prefab == gameObject)
{
return GlobalObjectIdHash;
}
}
return 0;
return GlobalObjectIdHash;
}
}
@@ -149,6 +157,9 @@ namespace Unity.Netcode
EditorUtility.SetDirty(this);
}
}
// Always check for in-scene placed to assure any previous version scene assets with in-scene place NetworkObjects gets updated
CheckForInScenePlaced();
}
private bool IsEditingPrefab()
@@ -164,6 +175,33 @@ namespace Unity.Netcode
return true;
}
/// <summary>
/// This checks to see if this NetworkObject is an in-scene placed prefab instance. If so it will
/// automatically find the source prefab asset's GlobalObjectIdHash value, assign it to
/// InScenePlacedSourceGlobalObjectIdHash and mark this as being in-scene placed.
/// </summary>
/// <remarks>
/// This NetworkObject is considered an in-scene placed prefab asset instance if it is:
/// - Part of a prefab
/// - Not being directly edited
/// - Within a valid scene that is part of the scenes in build list
/// (In-scene defined NetworkObjects that are not part of a prefab instance are excluded.)
/// </remarks>
private void CheckForInScenePlaced()
{
if (PrefabUtility.IsPartOfAnyPrefab(this) && !IsEditingPrefab() && gameObject.scene.IsValid() && gameObject.scene.isLoaded && gameObject.scene.buildIndex >= 0)
{
var prefab = PrefabUtility.GetCorrespondingObjectFromSource(gameObject);
var assetPath = AssetDatabase.GetAssetPath(prefab);
var sourceAsset = AssetDatabase.LoadAssetAtPath<NetworkObject>(assetPath);
if (sourceAsset != null && sourceAsset.GlobalObjectIdHash != 0 && InScenePlacedSourceGlobalObjectIdHash != sourceAsset.GlobalObjectIdHash)
{
InScenePlacedSourceGlobalObjectIdHash = sourceAsset.GlobalObjectIdHash;
}
IsSceneObject = true;
}
}
private GlobalObjectId GetGlobalId()
{
var instanceGlobalId = GlobalObjectId.GetGlobalObjectIdSlow(this);
@@ -703,7 +741,7 @@ namespace Unity.Netcode
// Since we still have a session connection, log locally and on the server to inform user of this issue.
if (NetworkManager.LogLevel <= LogLevel.Error)
{
NetworkLog.LogErrorServer($"Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
NetworkLog.LogErrorServer($"[Invalid Destroy][{gameObject.name}][NetworkObjectId:{NetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call {nameof(Destroy)} or {nameof(Despawn)} on the server/host instead.");
}
return;
}
@@ -720,7 +758,7 @@ namespace Unity.Netcode
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
internal void SpawnInternal(bool destroyWithScene, ulong ownerClientId, bool playerObject)
{
if (!NetworkManager.IsListening)
{
@@ -743,6 +781,78 @@ namespace Unity.Netcode
}
}
/// <summary>
/// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
/// </summary>
/// <param name="networkPrefab">The NetworkPrefab to instantiate and spawn.</param>
/// <param name="networkManager">The local instance of the NetworkManager connected to an session in progress.</param>
/// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
/// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
/// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
/// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
/// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false). </param>
/// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
/// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
/// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
public static NetworkObject InstantiateAndSpawn(GameObject networkPrefab, NetworkManager networkManager, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
{
var networkObject = networkPrefab.GetComponent<NetworkObject>();
if (networkObject == null)
{
Debug.LogError($"The {nameof(NetworkPrefab)} {networkPrefab.name} does not have a {nameof(NetworkObject)} component!");
return null;
}
return networkObject.InstantiateAndSpawn(networkManager, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
}
/// <summary>
/// This invokes <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>.
/// </summary>
/// <param name="networkManager">The local instance of the NetworkManager connected to an session in progress.</param>
/// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
/// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
/// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
/// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
/// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false). </param>
/// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
/// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
/// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
public NetworkObject InstantiateAndSpawn(NetworkManager networkManager, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
{
if (networkManager == null)
{
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NetworkManagerNull]);
return null;
}
if (!networkManager.IsListening)
{
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NoActiveSession]);
return null;
}
if (!networkManager.IsServer)
{
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NotAuthority]);
return null;
}
if (NetworkManager.ShutdownInProgress)
{
Debug.LogWarning(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown]);
return null;
}
// Verify it is actually a valid prefab
if (!NetworkManager.NetworkConfig.Prefabs.Contains(gameObject))
{
Debug.LogError(NetworkSpawnManager.InstantiateAndSpawnErrors[NetworkSpawnManager.InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab]);
return null;
}
return NetworkManager.SpawnManager.InstantiateAndSpawnNoParameterChecks(this, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
}
/// <summary>
/// Spawns this <see cref="NetworkObject"/> across the network. Can only be called from the Server
/// </summary>
@@ -969,20 +1079,21 @@ namespace Unity.Netcode
return false;
}
if (!NetworkManager.IsServer)
if (!NetworkManager.IsServer && !NetworkManager.ShutdownInProgress)
{
return false;
}
if (!IsSpawned)
// If the parent is not null fail only if either of the two is true:
// - This instance is spawned and the parent is not.
// - This instance is not spawned and the parent is.
// Basically, don't allow parenting when either the child or parent is not spawned.
// Caveat: if the parent is null then we can allow parenting whether the instance is or is not spawned.
if (parent != null && (IsSpawned ^ parent.IsSpawned))
{
return false;
}
if (parent != null && !parent.IsSpawned)
{
return false;
}
m_CachedWorldPositionStays = worldPositionStays;
if (parent == null)
@@ -1018,15 +1129,36 @@ namespace Unity.Netcode
if (!NetworkManager.IsServer)
{
transform.parent = m_CachedParent;
Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
// Log exception if we are a client and not shutting down.
if (!NetworkManager.ShutdownInProgress)
{
transform.parent = m_CachedParent;
Debug.LogException(new NotServerException($"Only the server can reparent {nameof(NetworkObject)}s"));
}
else // Otherwise, if we are removing a parent then go ahead and allow parenting to occur
if (transform.parent == null)
{
m_LatestParent = null;
m_CachedParent = null;
InvokeBehaviourOnNetworkObjectParentChanged(null);
}
return;
}
else // Otherwise, on the serer side if this instance is not spawned...
if (!IsSpawned)
{
transform.parent = m_CachedParent;
Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
// ,,,and we are removing the parent, then go ahead and allow parenting to occur
if (transform.parent == null)
{
m_LatestParent = null;
m_CachedParent = null;
InvokeBehaviourOnNetworkObjectParentChanged(null);
}
else
{
transform.parent = m_CachedParent;
Debug.LogException(new SpawnStateException($"{nameof(NetworkObject)} can only be reparented after being spawned"));
}
return;
}
var removeParent = false;
@@ -1869,16 +2001,39 @@ namespace Unity.Netcode
/// <returns></returns>
internal uint HostCheckForGlobalObjectIdHashOverride()
{
if (NetworkManager.IsHost)
if (NetworkManager.IsServer)
{
if (NetworkManager.PrefabHandler.ContainsHandler(this))
{
var globalObjectIdHash = NetworkManager.PrefabHandler.GetSourceGlobalObjectIdHash(GlobalObjectIdHash);
return globalObjectIdHash == 0 ? GlobalObjectIdHash : globalObjectIdHash;
}
if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.TryGetValue(GlobalObjectIdHash, out uint hash))
// If scene management is disabled and this is an in-scene placed NetworkObject then go ahead
// and send the InScenePlacedSourcePrefab's GlobalObjectIdHash value (i.e. what to dynamically spawn)
if (!NetworkManager.NetworkConfig.EnableSceneManagement && IsSceneObject.Value && InScenePlacedSourceGlobalObjectIdHash != 0)
{
return hash;
return InScenePlacedSourceGlobalObjectIdHash;
}
// If the PrefabGlobalObjectIdHash is a non-zero value and the GlobalObjectIdHash value is
// different from the PrefabGlobalObjectIdHash value, then the NetworkObject instance is
// an override for the original network prefab (i.e. PrefabGlobalObjectIdHash)
if (!IsSceneObject.Value && GlobalObjectIdHash != PrefabGlobalObjectIdHash)
{
// If the PrefabGlobalObjectIdHash is already populated (i.e. InstantiateAndSpawn used), then return this
if (PrefabGlobalObjectIdHash != 0)
{
return PrefabGlobalObjectIdHash;
}
else
{
// For legacy manual instantiation and spawning, check the OverrideToNetworkPrefab for a possible match
if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash))
{
return NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab[GlobalObjectIdHash];
}
}
}
}

2
Runtime/Messaging/DeferredMessageManager.cs
View File

@@ -113,6 +113,7 @@ namespace Unity.Netcode
// processed before the object is fully spawned. This must be the last thing done in the spawn process.
if (triggers.TryGetValue(key, out var triggerInfo))
{
triggers.Remove(key);
foreach (var deferredMessage in triggerInfo.TriggerData)
{
// Reader will be disposed within HandleMessage
@@ -120,7 +121,6 @@ namespace Unity.Netcode
}
triggerInfo.TriggerData.Dispose();
triggers.Remove(key);
}
}
}

1
Runtime/Messaging/IDeferredNetworkMessageManager.cs
View File

@@ -6,6 +6,7 @@ namespace Unity.Netcode
{
OnSpawn,
OnAddPrefab,
OnNextFrame,
}
/// <summary>

35
Runtime/Messaging/Messages/ClientConnectedMessage.cs Normal file
View File

@@ -0,0 +1,35 @@
namespace Unity.Netcode
{
internal struct ClientConnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
{
public int Version => 0;
public ulong ClientId;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
BytePacker.WriteValueBitPacked(writer, ClientId);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.IsClient)
{
return false;
}
ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
return true;
}
public void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
networkManager.ConnectionManager.ConnectedClientIds.Add(ClientId);
if (networkManager.IsConnectedClient)
{
networkManager.ConnectionManager.InvokeOnPeerConnectedCallback(ClientId);
}
}
}
}

3
Runtime/Messaging/Messages/ClientConnectedMessage.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 158454105806474cba54a4ea5a0bfb12
timeCreated: 1697836112

35
Runtime/Messaging/Messages/ClientDisconnectedMessage.cs Normal file
View File

@@ -0,0 +1,35 @@
namespace Unity.Netcode
{
internal struct ClientDisconnectedMessage : INetworkMessage, INetworkSerializeByMemcpy
{
public int Version => 0;
public ulong ClientId;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
BytePacker.WriteValueBitPacked(writer, ClientId);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.IsClient)
{
return false;
}
ByteUnpacker.ReadValueBitPacked(reader, out ClientId);
return true;
}
public void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
networkManager.ConnectionManager.ConnectedClientIds.Remove(ClientId);
if (networkManager.IsConnectedClient)
{
networkManager.ConnectionManager.InvokeOnPeerDisconnectedCallback(ClientId);
}
}
}
}

3
Runtime/Messaging/Messages/ClientDisconnectedMessage.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 8f91296c8e5f40b1a2a03d74a31526b6
timeCreated: 1697836161

29
Runtime/Messaging/Messages/ConnectionApprovedMessage.cs
View File

@@ -5,7 +5,8 @@ namespace Unity.Netcode
{
internal struct ConnectionApprovedMessage : INetworkMessage
{
public int Version => 0;
private const int k_VersionAddClientIds = 1;
public int Version => k_VersionAddClientIds;
public ulong OwnerClientId;
public int NetworkTick;
@@ -17,6 +18,8 @@ namespace Unity.Netcode
public NativeArray<MessageVersionData> MessageVersions;
public NativeArray<ulong> ConnectedClientIds;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
// ============================================================
@@ -36,6 +39,11 @@ namespace Unity.Netcode
BytePacker.WriteValueBitPacked(writer, OwnerClientId);
BytePacker.WriteValueBitPacked(writer, NetworkTick);
if (targetVersion >= k_VersionAddClientIds)
{
writer.WriteValueSafe(ConnectedClientIds);
}
uint sceneObjectCount = 0;
// When SpawnedObjectsList is not null then scene management is disabled. Provide a list of
@@ -106,6 +114,16 @@ namespace Unity.Netcode
ByteUnpacker.ReadValueBitPacked(reader, out OwnerClientId);
ByteUnpacker.ReadValueBitPacked(reader, out NetworkTick);
if (receivedMessageVersion >= k_VersionAddClientIds)
{
reader.ReadValueSafe(out ConnectedClientIds, Allocator.TempJob);
}
else
{
ConnectedClientIds = new NativeArray<ulong>(0, Allocator.TempJob);
}
m_ReceivedSceneObjectData = reader;
return true;
}
@@ -114,6 +132,7 @@ namespace Unity.Netcode
{
var networkManager = (NetworkManager)context.SystemOwner;
networkManager.LocalClientId = OwnerClientId;
networkManager.MessageManager.SetLocalClientId(networkManager.LocalClientId);
networkManager.NetworkMetrics.SetConnectionId(networkManager.LocalClientId);
var time = new NetworkTime(networkManager.NetworkTickSystem.TickRate, NetworkTick);
@@ -126,6 +145,12 @@ namespace Unity.Netcode
// Stop the client-side approval timeout coroutine since we are approved.
networkManager.ConnectionManager.StopClientApprovalCoroutine();
networkManager.ConnectionManager.ConnectedClientIds.Clear();
foreach (var clientId in ConnectedClientIds)
{
networkManager.ConnectionManager.ConnectedClientIds.Add(clientId);
}
// Only if scene management is disabled do we handle NetworkObject synchronization at this point
if (!networkManager.NetworkConfig.EnableSceneManagement)
{
@@ -146,6 +171,8 @@ namespace Unity.Netcode
// When scene management is disabled we notify after everything is synchronized
networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
}
ConnectedClientIds.Dispose();
}
}
}

25
Runtime/Messaging/Messages/CreateObjectMessage.cs
View File

@@ -1,3 +1,4 @@
using System.Runtime.CompilerServices;
namespace Unity.Netcode
{
internal struct CreateObjectMessage : INetworkMessage
@@ -34,9 +35,29 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
var networkObject = NetworkObject.AddSceneObject(ObjectInfo, m_ReceivedNetworkVariableData, networkManager);
// If a client receives a create object message and it is still synchronizing, then defer the object creation until it has finished synchronizing
if (networkManager.SceneManager.ShouldDeferCreateObject())
{
networkManager.SceneManager.DeferCreateObject(context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
}
else
{
CreateObject(ref networkManager, context.SenderId, context.MessageSize, ObjectInfo, m_ReceivedNetworkVariableData);
}
}
networkManager.NetworkMetrics.TrackObjectSpawnReceived(context.SenderId, networkObject, context.MessageSize);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static void CreateObject(ref NetworkManager networkManager, ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader networkVariableData)
{
try
{
var networkObject = NetworkObject.AddSceneObject(sceneObject, networkVariableData, networkManager);
networkManager.NetworkMetrics.TrackObjectSpawnReceived(senderId, networkObject, messageSize);
}
catch (System.Exception ex)
{
UnityEngine.Debug.LogException(ex);
}
}
}
}

4
Runtime/Messaging/Messages/NamedMessage.cs
View File

@@ -25,9 +25,9 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.ShutdownInProgress)
if (!networkManager.ShutdownInProgress && networkManager.CustomMessagingManager != null)
{
((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
networkManager.CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
}
}
}

70
Runtime/Messaging/Messages/ProxyMessage.cs Normal file
View File

@@ -0,0 +1,70 @@
using System;
using Unity.Collections;
namespace Unity.Netcode
{
internal struct ProxyMessage : INetworkMessage
{
public NativeArray<ulong> TargetClientIds;
public NetworkDelivery Delivery;
public RpcMessage WrappedMessage;
// Version of ProxyMessage and RpcMessage must always match.
// If ProxyMessage needs to change, increment RpcMessage's version
public int Version => new RpcMessage().Version;
public void Serialize(FastBufferWriter writer, int targetVersion)
{
writer.WriteValueSafe(TargetClientIds);
BytePacker.WriteValuePacked(writer, Delivery);
WrappedMessage.Serialize(writer, targetVersion);
}
public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
reader.ReadValueSafe(out TargetClientIds, Allocator.Temp);
ByteUnpacker.ReadValuePacked(reader, out Delivery);
WrappedMessage = new RpcMessage();
WrappedMessage.Deserialize(reader, ref context, receivedMessageVersion);
return true;
}
public unsafe void Handle(ref NetworkContext context)
{
var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.SpawnManager.SpawnedObjects.TryGetValue(WrappedMessage.Metadata.NetworkObjectId, out var networkObject))
{
throw new InvalidOperationException($"An RPC called on a {nameof(NetworkObject)} that is not in the spawned objects list. Please make sure the {nameof(NetworkObject)} is spawned before calling RPCs.");
}
var observers = networkObject.Observers;
var nonServerIds = new NativeList<ulong>(Allocator.Temp);
for (var i = 0; i < TargetClientIds.Length; ++i)
{
if (!observers.Contains(TargetClientIds[i]))
{
continue;
}
if (TargetClientIds[i] == NetworkManager.ServerClientId)
{
WrappedMessage.Handle(ref context);
}
else
{
nonServerIds.Add(TargetClientIds[i]);
}
}
WrappedMessage.WriteBuffer = new FastBufferWriter(WrappedMessage.ReadBuffer.Length, Allocator.Temp);
using (WrappedMessage.WriteBuffer)
{
WrappedMessage.WriteBuffer.WriteBytesSafe(WrappedMessage.ReadBuffer.GetUnsafePtr(), WrappedMessage.ReadBuffer.Length);
networkManager.MessageManager.SendMessage(ref WrappedMessage, Delivery, nonServerIds);
}
}
}
}

3
Runtime/Messaging/Messages/ProxyMessage.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e9ee0457d5b740b38dfe6542658fb522
timeCreated: 1697825043

38
Runtime/Messaging/Messages/RpcMessages.cs
View File

@@ -159,4 +159,42 @@ namespace Unity.Netcode
RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
}
}
internal struct RpcMessage : INetworkMessage
{
public int Version => 0;
public RpcMetadata Metadata;
public ulong SenderClientId;
public FastBufferWriter WriteBuffer;
public FastBufferReader ReadBuffer;
public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
{
BytePacker.WriteValuePacked(writer, SenderClientId);
RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
}
public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
{
ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer);
}
public void Handle(ref NetworkContext context)
{
var rpcParams = new __RpcParams
{
Ext = new RpcParams
{
Receive = new RpcReceiveParams
{
SenderClientId = SenderClientId
}
}
};
RpcMessageHelpers.Handle(ref context, ref Metadata, ref ReadBuffer, ref rpcParams);
}
}
}

37
Runtime/Messaging/NetworkManagerHooks.cs
View File

@@ -1,4 +1,5 @@
using System;
using Unity.Netcode.Transports.UTP;
namespace Unity.Netcode
{
@@ -56,7 +57,8 @@ namespace Unity.Netcode
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. {transportErrorMsg}");
}
return false;
@@ -66,7 +68,7 @@ namespace Unity.Netcode
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted.");
}
return false;
@@ -76,7 +78,8 @@ namespace Unity.Netcode
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. {transportErrorMsg}");
}
return false;
@@ -88,7 +91,8 @@ namespace Unity.Netcode
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. {transportErrorMsg}");
}
return false;
@@ -98,7 +102,8 @@ namespace Unity.Netcode
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
{
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
var transportErrorMsg = GetTransportErrorMessage(messageContent, m_NetworkManager);
NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. {transportErrorMsg}");
}
return false;
@@ -108,6 +113,28 @@ namespace Unity.Netcode
return !m_NetworkManager.MessageManager.StopProcessing;
}
private static string GetTransportErrorMessage(FastBufferReader messageContent, NetworkManager networkManager)
{
if (networkManager.NetworkConfig.NetworkTransport is not UnityTransport)
{
return $"NetworkTransport: {networkManager.NetworkConfig.NetworkTransport.GetType()}. Please report this to the maintainer of transport layer.";
}
var transportVersion = GetTransportVersion(networkManager);
return $"{transportVersion}. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {NetworkMessageManager.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}";
}
private static string GetTransportVersion(NetworkManager networkManager)
{
var transportVersion = "NetworkTransport: " + networkManager.NetworkConfig.NetworkTransport.GetType();
if (networkManager.NetworkConfig.NetworkTransport is UnityTransport unityTransport)
{
transportVersion += " UnityTransportProtocol: " + unityTransport.Protocol;
}
return transportVersion;
}
public void OnBeforeHandleMessage<T>(ref T message, ref NetworkContext context) where T : INetworkMessage
{
}

20
Runtime/Messaging/NetworkMessageManager.cs
View File

@@ -85,6 +85,8 @@ namespace Unity.Netcode
private INetworkMessageSender m_Sender;
private bool m_Disposed;
private ulong m_LocalClientId;
internal Type[] MessageTypes => m_ReverseTypeMap;
internal MessageHandler[] MessageHandlers => m_MessageHandlers;
@@ -95,6 +97,16 @@ namespace Unity.Netcode
return m_MessageTypes[t];
}
internal object GetOwner()
{
return m_Owner;
}
internal void SetLocalClientId(ulong id)
{
m_LocalClientId = id;
}
public const int DefaultNonFragmentedMessageMaxSize = 1300 & ~7; // Round down to nearest word aligned size (1296)
public int NonFragmentedMessageMaxSize = DefaultNonFragmentedMessageMaxSize;
public int FragmentedMessageMaxSize = int.MaxValue;
@@ -551,7 +563,7 @@ namespace Unity.Netcode
// Special cases because these are the messages that carry the version info - thus the version info isn't
// populated yet when we get these. The first part of these messages always has to be the version data
// and can't change.
if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage))
if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage) && context.SenderId != manager.m_LocalClientId)
{
messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
if (messageVersion < 0)
@@ -808,6 +820,12 @@ namespace Unity.Netcode
return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
}
internal unsafe int SendMessage<T>(ref T message, NetworkDelivery delivery, in NativeList<ulong> clientIds)
where T : INetworkMessage
{
return SendMessage(ref message, delivery, new PointerListWrapper<ulong>((ulong*)clientIds.GetUnsafePtr(), clientIds.Length));
}
internal unsafe void ProcessSendQueues()
{
if (StopProcessing)

44
Runtime/Messaging/RpcAttributes.cs
View File

@@ -21,12 +21,36 @@ namespace Unity.Netcode
/// <summary>
/// <para>Represents the common base class for Rpc attributes.</para>
/// </summary>
public abstract class RpcAttribute : Attribute
[AttributeUsage(AttributeTargets.Method)]
public class RpcAttribute : Attribute
{
// Must match the set of parameters below
public struct RpcAttributeParams
{
public RpcDelivery Delivery;
public bool RequireOwnership;
public bool DeferLocal;
public bool AllowTargetOverride;
}
// Must match the fields in RemoteAttributeParams
/// <summary>
/// Type of RPC delivery method
/// </summary>
public RpcDelivery Delivery = RpcDelivery.Reliable;
public bool RequireOwnership;
public bool DeferLocal;
public bool AllowTargetOverride;
public RpcAttribute(SendTo target)
{
}
// To get around an issue with the release validator, RuntimeAccessModifiersILPP will make this 'public'
private RpcAttribute()
{
}
}
/// <summary>
@@ -36,10 +60,12 @@ namespace Unity.Netcode
[AttributeUsage(AttributeTargets.Method)]
public class ServerRpcAttribute : RpcAttribute
{
/// <summary>
/// Whether or not the ServerRpc should only be run if executed by the owner of the object
/// </summary>
public bool RequireOwnership = true;
public new bool RequireOwnership;
public ServerRpcAttribute() : base(SendTo.Server)
{
}
}
/// <summary>
@@ -47,5 +73,11 @@ namespace Unity.Netcode
/// <para>A ClientRpc marked method will be fired by the server but executed on clients.</para>
/// </summary>
[AttributeUsage(AttributeTargets.Method)]
public class ClientRpcAttribute : RpcAttribute { }
public class ClientRpcAttribute : RpcAttribute
{
public ClientRpcAttribute() : base(SendTo.NotServer)
{
}
}
}

55
Runtime/Messaging/RpcParams.cs
View File

@@ -3,6 +3,60 @@ using Unity.Collections;
namespace Unity.Netcode
{
public enum LocalDeferMode
{
Default,
Defer,
SendImmediate
}
/// <summary>
/// Generic RPC
/// </summary>
public struct RpcSendParams
{
public BaseRpcTarget Target;
public LocalDeferMode LocalDeferMode;
public static implicit operator RpcSendParams(BaseRpcTarget target) => new RpcSendParams { Target = target };
public static implicit operator RpcSendParams(LocalDeferMode deferMode) => new RpcSendParams { LocalDeferMode = deferMode };
}
/// <summary>
/// The receive parameters for server-side remote procedure calls
/// </summary>
public struct RpcReceiveParams
{
/// <summary>
/// Server-Side RPC
/// The client identifier of the sender
/// </summary>
public ulong SenderClientId;
}
/// <summary>
/// Server-Side RPC
/// Can be used with any sever-side remote procedure call
/// Note: typically this is use primarily for the <see cref="ServerRpcReceiveParams"/>
/// </summary>
public struct RpcParams
{
/// <summary>
/// The server RPC send parameters (currently a place holder)
/// </summary>
public RpcSendParams Send;
/// <summary>
/// The client RPC receive parameters provides you with the sender's identifier
/// </summary>
public RpcReceiveParams Receive;
public static implicit operator RpcParams(RpcSendParams send) => new RpcParams { Send = send };
public static implicit operator RpcParams(BaseRpcTarget target) => new RpcParams { Send = new RpcSendParams { Target = target } };
public static implicit operator RpcParams(LocalDeferMode deferMode) => new RpcParams { Send = new RpcSendParams { LocalDeferMode = deferMode } };
public static implicit operator RpcParams(RpcReceiveParams receive) => new RpcParams { Receive = receive };
}
/// <summary>
/// Server-Side RPC
/// Place holder. <see cref="ServerRpcParams"/>
@@ -99,6 +153,7 @@ namespace Unity.Netcode
internal struct __RpcParams
#pragma warning restore IDE1006 // restore naming rule violation check
{
public RpcParams Ext;
public ServerRpcParams Server;
public ClientRpcParams Client;
}

3
Runtime/Messaging/RpcTargets.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: b02186acd1144e20acbd0dcb69b14938
timeCreated: 1697824888

57
Runtime/Messaging/RpcTargets/BaseRpcTarget.cs Normal file
View File

@@ -0,0 +1,57 @@
using System;
namespace Unity.Netcode
{
public abstract class BaseRpcTarget : IDisposable
{
protected NetworkManager m_NetworkManager;
private bool m_Locked;
internal void Lock()
{
m_Locked = true;
}
internal void Unlock()
{
m_Locked = false;
}
internal BaseRpcTarget(NetworkManager manager)
{
m_NetworkManager = manager;
}
protected void CheckLockBeforeDispose()
{
if (m_Locked)
{
throw new Exception($"RPC targets obtained through {nameof(RpcTargetUse)}.{RpcTargetUse.Temp} may not be disposed.");
}
}
public abstract void Dispose();
internal abstract void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams);
private protected void SendMessageToClient(NetworkBehaviour behaviour, ulong clientId, ref RpcMessage message, NetworkDelivery delivery)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
var size =
#endif
behaviour.NetworkManager.MessageManager.SendMessage(ref message, delivery, clientId);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{
behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
clientId,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
size);
}
#endif
}
}
}

11
Runtime/Messaging/RpcTargets/BaseRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 07c2620262e24eb5a426b521c09b3091
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

37
Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs Normal file
View File

@@ -0,0 +1,37 @@
namespace Unity.Netcode
{
internal class ClientsAndHostRpcTarget : BaseRpcTarget
{
private BaseRpcTarget m_UnderlyingTarget;
public override void Dispose()
{
m_UnderlyingTarget = null;
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_UnderlyingTarget == null)
{
// NotServer treats a host as being a server and will not send to it
// ClientsAndHost sends to everyone who runs any client logic
// So if the server is a host, this target includes it (as hosts run client logic)
// If the server is not a host, this target leaves it out, ergo the selection of NotServer.
if (behaviour.NetworkManager.ServerIsHost)
{
m_UnderlyingTarget = behaviour.RpcTarget.Everyone;
}
else
{
m_UnderlyingTarget = behaviour.RpcTarget.NotServer;
}
}
m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
}
internal ClientsAndHostRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

3
Runtime/Messaging/RpcTargets/ClientsAndHostRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c9f883d678ec4715b160dd9497d5f42d
timeCreated: 1699481382

34
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs Normal file
View File

@@ -0,0 +1,34 @@
namespace Unity.Netcode
{
internal class DirectSendRpcTarget : BaseRpcTarget, IIndividualRpcTarget
{
public BaseRpcTarget Target => this;
internal ulong ClientId;
public override void Dispose()
{
CheckLockBeforeDispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
SendMessageToClient(behaviour, ClientId, ref message, delivery);
}
public void SetClientId(ulong clientId)
{
ClientId = clientId;
}
internal DirectSendRpcTarget(NetworkManager manager) : base(manager)
{
}
internal DirectSendRpcTarget(ulong clientId, NetworkManager manager) : base(manager)
{
ClientId = clientId;
}
}
}

3
Runtime/Messaging/RpcTargets/DirectSendRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 077544cfd0b94cfc8a2a55d3828b74bb
timeCreated: 1697824873

26
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs Normal file
View File

@@ -0,0 +1,26 @@
namespace Unity.Netcode
{
internal class EveryoneRpcTarget : BaseRpcTarget
{
private NotServerRpcTarget m_NotServerRpcTarget;
private ServerRpcTarget m_ServerRpcTarget;
public override void Dispose()
{
m_NotServerRpcTarget.Dispose();
m_ServerRpcTarget.Dispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
m_NotServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
internal EveryoneRpcTarget(NetworkManager manager) : base(manager)
{
m_NotServerRpcTarget = new NotServerRpcTarget(manager);
m_ServerRpcTarget = new ServerRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 675d4a5c79fc47078092ac15d255745d
timeCreated: 1697824941

9
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs Normal file
View File

@@ -0,0 +1,9 @@
namespace Unity.Netcode
{
internal interface IGroupRpcTarget
{
void Add(ulong clientId);
void Clear();
BaseRpcTarget Target { get; }
}
}

3
Runtime/Messaging/RpcTargets/IGroupRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: beb19a6bb1334252a89b21c8490f7cbe
timeCreated: 1697825109

8
Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Unity.Netcode
{
internal interface IIndividualRpcTarget
{
void SetClientId(ulong clientId);
BaseRpcTarget Target { get; }
}
}

3
Runtime/Messaging/RpcTargets/IIndividualRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c658d9641f564d9890bef4f558f1cea6
timeCreated: 1697825115

67
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs Normal file
View File

@@ -0,0 +1,67 @@
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
namespace Unity.Netcode
{
internal class LocalSendRpcTarget : BaseRpcTarget
{
public override void Dispose()
{
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
var networkManager = behaviour.NetworkManager;
var context = new NetworkContext
{
SenderId = m_NetworkManager.LocalClientId,
Timestamp = networkManager.RealTimeProvider.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 NetworkMessageHeader(),
SerializedHeaderSize = 0,
MessageSize = 0
};
int length;
if (rpcParams.Send.LocalDeferMode == LocalDeferMode.Defer)
{
using var serializedWriter = new FastBufferWriter(message.WriteBuffer.Length + UnsafeUtility.SizeOf<RpcMetadata>(), Allocator.Temp, int.MaxValue);
message.Serialize(serializedWriter, message.Version);
using var reader = new FastBufferReader(serializedWriter, Allocator.None);
context.Header = new NetworkMessageHeader
{
MessageSize = (uint)reader.Length,
MessageType = m_NetworkManager.MessageManager.GetMessageType(typeof(RpcMessage))
};
behaviour.NetworkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0, reader, ref context);
length = reader.Length;
}
else
{
using var tempBuffer = new FastBufferReader(message.WriteBuffer, Allocator.None);
message.ReadBuffer = tempBuffer;
message.Handle(ref context);
length = tempBuffer.Length;
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{
behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
behaviour.NetworkManager.LocalClientId,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
length);
}
#endif
}
internal LocalSendRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

3
Runtime/Messaging/RpcTargets/LocalSendRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c3b290cdc20d4d2293652ec79652962a
timeCreated: 1697824985

67
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs Normal file
View File

@@ -0,0 +1,67 @@
namespace Unity.Netcode
{
internal class NotMeRpcTarget : BaseRpcTarget
{
private IGroupRpcTarget m_GroupSendTarget;
private ServerRpcTarget m_ServerRpcTarget;
public override void Dispose()
{
m_ServerRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
m_GroupSendTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.IsServer)
{
foreach (var clientId in behaviour.NetworkObject.Observers)
{
if (clientId == behaviour.NetworkManager.LocalClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == behaviour.NetworkManager.LocalClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
if (!behaviour.IsServer)
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal NotMeRpcTarget(NetworkManager manager) : base(manager)
{
m_ServerRpcTarget = new ServerRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/NotMeRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 99cd5e8be7bd454bab700ee08b8dad7b
timeCreated: 1697824966

83
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs Normal file
View File

@@ -0,0 +1,83 @@
namespace Unity.Netcode
{
internal class NotOwnerRpcTarget : BaseRpcTarget
{
private IGroupRpcTarget m_GroupSendTarget;
private ServerRpcTarget m_ServerRpcTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
public override void Dispose()
{
m_ServerRpcTarget.Dispose();
m_LocalSendRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
m_GroupSendTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.IsServer)
{
foreach (var clientId in behaviour.NetworkObject.Observers)
{
if (clientId == behaviour.OwnerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == behaviour.OwnerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
if (behaviour.OwnerClientId != NetworkManager.ServerClientId)
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal NotOwnerRpcTarget(NetworkManager manager) : base(manager)
{
m_ServerRpcTarget = new ServerRpcTarget(manager);
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/NotOwnerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: d7bc66c5253b44d09ad978ea9e51c96f
timeCreated: 1698789420

72
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs Normal file
View File

@@ -0,0 +1,72 @@
namespace Unity.Netcode
{
internal class NotServerRpcTarget : BaseRpcTarget
{
private IGroupRpcTarget m_GroupSendTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
public override void Dispose()
{
m_LocalSendRpcTarget.Dispose();
if (m_GroupSendTarget != null)
{
m_GroupSendTarget.Target.Dispose();
m_GroupSendTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_GroupSendTarget == null)
{
if (behaviour.IsServer)
{
m_GroupSendTarget = new RpcTargetGroup(m_NetworkManager);
}
else
{
m_GroupSendTarget = new ProxyRpcTargetGroup(m_NetworkManager);
}
}
m_GroupSendTarget.Clear();
if (behaviour.IsServer)
{
foreach (var clientId in behaviour.NetworkObject.Observers)
{
if (clientId == NetworkManager.ServerClientId)
{
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
else
{
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId == NetworkManager.ServerClientId)
{
continue;
}
if (clientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
continue;
}
m_GroupSendTarget.Add(clientId);
}
}
m_GroupSendTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
}
internal NotServerRpcTarget(NetworkManager manager) : base(manager)
{
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/NotServerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c63787afe52f45ffbd5d801f78e7c0d6
timeCreated: 1697824954

54
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs Normal file
View File

@@ -0,0 +1,54 @@
namespace Unity.Netcode
{
internal class OwnerRpcTarget : BaseRpcTarget
{
private IIndividualRpcTarget m_UnderlyingTarget;
private LocalSendRpcTarget m_LocalRpcTarget;
private ServerRpcTarget m_ServerRpcTarget;
public override void Dispose()
{
m_LocalRpcTarget.Dispose();
if (m_UnderlyingTarget != null)
{
m_UnderlyingTarget.Target.Dispose();
m_UnderlyingTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (behaviour.OwnerClientId == behaviour.NetworkManager.LocalClientId)
{
m_LocalRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
return;
}
if (behaviour.OwnerClientId == NetworkManager.ServerClientId)
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
return;
}
if (m_UnderlyingTarget == null)
{
if (behaviour.NetworkManager.IsServer)
{
m_UnderlyingTarget = new DirectSendRpcTarget(m_NetworkManager);
}
else
{
m_UnderlyingTarget = new ProxyRpcTarget(behaviour.OwnerClientId, m_NetworkManager);
}
}
m_UnderlyingTarget.SetClientId(behaviour.OwnerClientId);
m_UnderlyingTarget.Target.Send(behaviour, ref message, delivery, rpcParams);
}
internal OwnerRpcTarget(NetworkManager manager) : base(manager)
{
m_LocalRpcTarget = new LocalSendRpcTarget(manager);
m_ServerRpcTarget = new ServerRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/OwnerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 23c4d52455fc419aaf03094617894257
timeCreated: 1697824972

16
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs Normal file
View File

@@ -0,0 +1,16 @@
namespace Unity.Netcode
{
internal class ProxyRpcTarget : ProxyRpcTargetGroup, IIndividualRpcTarget
{
internal ProxyRpcTarget(ulong clientId, NetworkManager manager) : base(manager)
{
Add(clientId);
}
public void SetClientId(ulong clientId)
{
Clear();
Add(clientId);
}
}
}

3
Runtime/Messaging/RpcTargets/ProxyRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 86002805bb9e422e8b71581d1325357f
timeCreated: 1697825007

100
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs Normal file
View File

@@ -0,0 +1,100 @@
using System;
using System.Collections.Generic;
using Unity.Collections;
namespace Unity.Netcode
{
internal class ProxyRpcTargetGroup : BaseRpcTarget, IDisposable, IGroupRpcTarget
{
public BaseRpcTarget Target => this;
private ServerRpcTarget m_ServerRpcTarget;
private LocalSendRpcTarget m_LocalSendRpcTarget;
private bool m_Disposed;
public NativeList<ulong> TargetClientIds;
internal HashSet<ulong> Ids = new HashSet<ulong>();
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
var proxyMessage = new ProxyMessage { Delivery = delivery, TargetClientIds = TargetClientIds.AsArray(), WrappedMessage = message };
#if DEVELOPMENT_BUILD || UNITY_EDITOR
var size =
#endif
behaviour.NetworkManager.MessageManager.SendMessage(ref proxyMessage, delivery, NetworkManager.ServerClientId);
#if DEVELOPMENT_BUILD || UNITY_EDITOR
if (NetworkBehaviour.__rpc_name_table[behaviour.GetType()].TryGetValue(message.Metadata.NetworkRpcMethodId, out var rpcMethodName))
{
foreach (var clientId in TargetClientIds)
{
behaviour.NetworkManager.NetworkMetrics.TrackRpcSent(
clientId,
behaviour.NetworkObject,
rpcMethodName,
behaviour.__getTypeName(),
size);
}
}
#endif
if (Ids.Contains(NetworkManager.ServerClientId))
{
m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
if (Ids.Contains(m_NetworkManager.LocalClientId))
{
m_LocalSendRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
}
}
internal ProxyRpcTargetGroup(NetworkManager manager) : base(manager)
{
TargetClientIds = new NativeList<ulong>(Allocator.Persistent);
m_ServerRpcTarget = new ServerRpcTarget(manager);
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
public override void Dispose()
{
CheckLockBeforeDispose();
if (!m_Disposed)
{
TargetClientIds.Dispose();
m_Disposed = true;
m_ServerRpcTarget.Dispose();
m_LocalSendRpcTarget.Dispose();
}
}
public void Add(ulong clientId)
{
if (!Ids.Contains(clientId))
{
Ids.Add(clientId);
if (clientId != NetworkManager.ServerClientId && clientId != m_NetworkManager.LocalClientId)
{
TargetClientIds.Add(clientId);
}
}
}
public void Remove(ulong clientId)
{
Ids.Remove(clientId);
for (var i = 0; i < TargetClientIds.Length; ++i)
{
if (TargetClientIds[i] == clientId)
{
TargetClientIds.RemoveAt(i);
break;
}
}
}
public void Clear()
{
Ids.Clear();
TargetClientIds.Clear();
}
}
}

3
Runtime/Messaging/RpcTargets/ProxyRpcTargetGroup.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 5728dbab532e46a88127510b4ec75af9
timeCreated: 1697825000

564
Runtime/Messaging/RpcTargets/RpcTarget.cs Normal file
View File

@@ -0,0 +1,564 @@
using System.Collections.Generic;
using Unity.Collections;
namespace Unity.Netcode
{
/// <summary>
/// Configuration for the default method by which an RPC is communicated across the network
/// </summary>
public enum SendTo
{
/// <summary>
/// Send to the NetworkObject's current owner.
/// Will execute locally if the local process is the owner.
/// </summary>
Owner,
/// <summary>
/// Send to everyone but the current owner, filtered to the current observer list.
/// Will execute locally if the local process is not the owner.
/// </summary>
NotOwner,
/// <summary>
/// Send to the server, regardless of ownership.
/// Will execute locally if invoked on the server.
/// </summary>
Server,
/// <summary>
/// Send to everyone but the server, filtered to the current observer list.
/// Will NOT send to a server running in host mode - it is still treated as a server.
/// If you want to send to servers when they are host, but not when they are dedicated server, use
/// <see cref="ClientsAndHost"/>.
/// <br />
/// <br />
/// Will execute locally if invoked on a client.
/// Will NOT execute locally if invoked on a server running in host mode.
/// </summary>
NotServer,
/// <summary>
/// Execute this RPC locally.
/// <br />
/// <br />
/// Normally this is no different from a standard function call.
/// <br />
/// <br />
/// Using the DeferLocal parameter of the attribute or the LocalDeferMode override in RpcSendParams,
/// this can allow an RPC to be processed on localhost with a one-frame delay as if it were sent over
/// the network.
/// </summary>
Me,
/// <summary>
/// Send this RPC to everyone but the local machine, filtered to the current observer list.
/// </summary>
NotMe,
/// <summary>
/// Send this RPC to everone, filtered to the current observer list.
/// Will execute locally.
/// </summary>
Everyone,
/// <summary>
/// Send this RPC to all clients, including the host, if a host exists.
/// If the server is running in host mode, this is the same as <see cref="Everyone" />.
/// If the server is running in dedicated server mode, this is the same as <see cref="NotServer" />.
/// </summary>
ClientsAndHost,
/// <summary>
/// This RPC cannot be sent without passing in a target in RpcSendParams.
/// </summary>
SpecifiedInParams
}
public enum RpcTargetUse
{
Temp,
Persistent
}
/// <summary>
/// Implementations of the various <see cref="SendTo"/> options, as well as additional runtime-only options
/// <see cref="Single"/>,
/// <see cref="Group(NativeArray{ulong})"/>,
/// <see cref="Group(NativeList{ulong})"/>,
/// <see cref="Group(ulong[])"/>,
/// <see cref="Group{T}(T)"/>, <see cref="Not(ulong)"/>,
/// <see cref="Not(NativeArray{ulong})"/>,
/// <see cref="Not(NativeList{ulong})"/>,
/// <see cref="Not(ulong[])"/>, and
/// <see cref="Not{T}(T)"/>
/// </summary>
public class RpcTarget
{
private NetworkManager m_NetworkManager;
internal RpcTarget(NetworkManager manager)
{
m_NetworkManager = manager;
Everyone = new EveryoneRpcTarget(manager);
Owner = new OwnerRpcTarget(manager);
NotOwner = new NotOwnerRpcTarget(manager);
Server = new ServerRpcTarget(manager);
NotServer = new NotServerRpcTarget(manager);
NotMe = new NotMeRpcTarget(manager);
Me = new LocalSendRpcTarget(manager);
ClientsAndHost = new ClientsAndHostRpcTarget(manager);
m_CachedProxyRpcTargetGroup = new ProxyRpcTargetGroup(manager);
m_CachedTargetGroup = new RpcTargetGroup(manager);
m_CachedDirectSendTarget = new DirectSendRpcTarget(manager);
m_CachedProxyRpcTarget = new ProxyRpcTarget(0, manager);
m_CachedProxyRpcTargetGroup.Lock();
m_CachedTargetGroup.Lock();
m_CachedDirectSendTarget.Lock();
m_CachedProxyRpcTarget.Lock();
}
public void Dispose()
{
Everyone.Dispose();
Owner.Dispose();
NotOwner.Dispose();
Server.Dispose();
NotServer.Dispose();
NotMe.Dispose();
Me.Dispose();
ClientsAndHost.Dispose();
m_CachedProxyRpcTargetGroup.Unlock();
m_CachedTargetGroup.Unlock();
m_CachedDirectSendTarget.Unlock();
m_CachedProxyRpcTarget.Unlock();
m_CachedProxyRpcTargetGroup.Dispose();
m_CachedTargetGroup.Dispose();
m_CachedDirectSendTarget.Dispose();
m_CachedProxyRpcTarget.Dispose();
}
/// <summary>
/// Send to the NetworkObject's current owner.
/// Will execute locally if the local process is the owner.
/// </summary>
public BaseRpcTarget Owner;
/// <summary>
/// Send to everyone but the current owner, filtered to the current observer list.
/// Will execute locally if the local process is not the owner.
/// </summary>
public BaseRpcTarget NotOwner;
/// <summary>
/// Send to the server, regardless of ownership.
/// Will execute locally if invoked on the server.
/// </summary>
public BaseRpcTarget Server;
/// <summary>
/// Send to everyone but the server, filtered to the current observer list.
/// Will NOT send to a server running in host mode - it is still treated as a server.
/// If you want to send to servers when they are host, but not when they are dedicated server, use
/// <see cref="SendTo.ClientsAndHost"/>.
/// <br />
/// <br />
/// Will execute locally if invoked on a client.
/// Will NOT execute locally if invoked on a server running in host mode.
/// </summary>
public BaseRpcTarget NotServer;
/// <summary>
/// Execute this RPC locally.
/// <br />
/// <br />
/// Normally this is no different from a standard function call.
/// <br />
/// <br />
/// Using the DeferLocal parameter of the attribute or the LocalDeferMode override in RpcSendParams,
/// this can allow an RPC to be processed on localhost with a one-frame delay as if it were sent over
/// the network.
/// </summary>
public BaseRpcTarget Me;
/// <summary>
/// Send this RPC to everyone but the local machine, filtered to the current observer list.
/// </summary>
public BaseRpcTarget NotMe;
/// <summary>
/// Send this RPC to everone, filtered to the current observer list.
/// Will execute locally.
/// </summary>
public BaseRpcTarget Everyone;
/// <summary>
/// Send this RPC to all clients, including the host, if a host exists.
/// If the server is running in host mode, this is the same as <see cref="Everyone" />.
/// If the server is running in dedicated server mode, this is the same as <see cref="NotServer" />.
/// </summary>
public BaseRpcTarget ClientsAndHost;
/// <summary>
/// Send to a specific single client ID.
/// </summary>
/// <param name="clientId"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Single(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Single(ulong clientId, RpcTargetUse use)
{
if (clientId == m_NetworkManager.LocalClientId)
{
return Me;
}
if (m_NetworkManager.IsServer || clientId == NetworkManager.ServerClientId)
{
if (use == RpcTargetUse.Persistent)
{
return new DirectSendRpcTarget(clientId, m_NetworkManager);
}
m_CachedDirectSendTarget.SetClientId(clientId);
return m_CachedDirectSendTarget;
}
if (use == RpcTargetUse.Persistent)
{
return new ProxyRpcTarget(clientId, m_NetworkManager);
}
m_CachedProxyRpcTarget.SetClientId(clientId);
return m_CachedProxyRpcTarget;
}
/// <summary>
/// Send to everyone EXCEPT a specific single client ID.
/// </summary>
/// <param name="excludedClientId"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(ulong excludedClientId, RpcTargetUse use)
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (clientId != excludedClientId)
{
target.Add(clientId);
}
}
// If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
if (!m_NetworkManager.ServerIsHost && excludedClientId != NetworkManager.ServerClientId)
{
target.Add(NetworkManager.ServerClientId);
}
return target.Target;
}
/// <summary>
/// Sends to a group of client IDs.
/// NativeArrays can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group(NativeArray<ulong> clientIds, RpcTargetUse use)
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
foreach (var clientId in clientIds)
{
target.Add(clientId);
}
return target.Target;
}
/// <summary>
/// Sends to a group of client IDs.
/// NativeList can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group(NativeList<ulong> clientIds, RpcTargetUse use)
{
var asArray = clientIds.AsArray();
return Group(asArray, use);
}
/// <summary>
/// Sends to a group of client IDs.
/// Constructing arrays requires garbage collected allocations. This override is only recommended
/// if you either have no strict performance requirements, or have the group of client IDs cached so
/// it is not created each time.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group(ulong[] clientIds, RpcTargetUse use)
{
return Group(new NativeArray<ulong>(clientIds, Allocator.Temp), use);
}
/// <summary>
/// Sends to a group of client IDs.
/// This accepts any IEnumerable type, such as List&lt;ulong&gt;, but cannot be called without
/// a garbage collected allocation (even if the type itself is a struct type, due to boxing).
/// This override is only recommended if you either have no strict performance requirements,
/// or have the group of client IDs cached so it is not created each time.
/// </summary>
/// <param name="clientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Group<T>(T clientIds, RpcTargetUse use) where T : IEnumerable<ulong>
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
foreach (var clientId in clientIds)
{
target.Add(clientId);
}
return target.Target;
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// NativeArrays can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(NativeArray<ulong> excludedClientIds, RpcTargetUse use)
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
using var asASet = new NativeHashSet<ulong>(excludedClientIds.Length, Allocator.Temp);
foreach (var clientId in excludedClientIds)
{
asASet.Add(clientId);
}
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (!asASet.Contains(clientId))
{
target.Add(clientId);
}
}
// If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
if (!m_NetworkManager.ServerIsHost && !asASet.Contains(NetworkManager.ServerClientId))
{
target.Add(NetworkManager.ServerClientId);
}
return target.Target;
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// NativeList can be trivially constructed using Allocator.Temp, making this an efficient
/// Group method if the group list is dynamically constructed.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(NativeList<ulong> excludedClientIds, RpcTargetUse use)
{
var asArray = excludedClientIds.AsArray();
return Not(asArray, use);
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// Constructing arrays requires garbage collected allocations. This override is only recommended
/// if you either have no strict performance requirements, or have the group of client IDs cached so
/// it is not created each time.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not(ulong[] excludedClientIds, RpcTargetUse use)
{
return Not(new NativeArray<ulong>(excludedClientIds, Allocator.Temp), use);
}
/// <summary>
/// Sends to everyone EXCEPT a group of client IDs.
/// This accepts any IEnumerable type, such as List&lt;ulong&gt;, but cannot be called without
/// a garbage collected allocation (even if the type itself is a struct type, due to boxing).
/// This override is only recommended if you either have no strict performance requirements,
/// or have the group of client IDs cached so it is not created each time.
/// </summary>
/// <param name="excludedClientIds"></param>
/// <param name="use"><see cref="RpcTargetUse.Temp"/> will return a cached target, which should not be stored as it will
/// be overwritten in future calls to Not() or Group(). Do not call Dispose() on Temp targets.<br /><br /><see cref="RpcTargetUse.Persistent"/> will
/// return a new target, which can be stored, but should not be done frequently because it results in a GC allocation. You must call Dispose() on Persistent targets when you are done with them.</param>
/// <returns></returns>
public BaseRpcTarget Not<T>(T excludedClientIds, RpcTargetUse use) where T : IEnumerable<ulong>
{
IGroupRpcTarget target;
if (m_NetworkManager.IsServer)
{
if (use == RpcTargetUse.Persistent)
{
target = new RpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedTargetGroup;
}
}
else
{
if (use == RpcTargetUse.Persistent)
{
target = new ProxyRpcTargetGroup(m_NetworkManager);
}
else
{
target = m_CachedProxyRpcTargetGroup;
}
}
target.Clear();
using var asASet = new NativeHashSet<ulong>(m_NetworkManager.ConnectedClientsIds.Count, Allocator.Temp);
foreach (var clientId in excludedClientIds)
{
asASet.Add(clientId);
}
foreach (var clientId in m_NetworkManager.ConnectedClientsIds)
{
if (!asASet.Contains(clientId))
{
target.Add(clientId);
}
}
// If ServerIsHost, ConnectedClientIds already contains ServerClientId and this would duplicate it.
if (!m_NetworkManager.ServerIsHost && !asASet.Contains(NetworkManager.ServerClientId))
{
target.Add(NetworkManager.ServerClientId);
}
return target.Target;
}
private ProxyRpcTargetGroup m_CachedProxyRpcTargetGroup;
private RpcTargetGroup m_CachedTargetGroup;
private DirectSendRpcTarget m_CachedDirectSendTarget;
private ProxyRpcTarget m_CachedProxyRpcTarget;
}
}

3
Runtime/Messaging/RpcTargets/RpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 1b26d0227e71408b918ae25ca2a0179b
timeCreated: 1699555535

80
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs Normal file
View File

@@ -0,0 +1,80 @@
using System.Collections.Generic;
namespace Unity.Netcode
{
internal class RpcTargetGroup : BaseRpcTarget, IGroupRpcTarget
{
public BaseRpcTarget Target => this;
internal List<BaseRpcTarget> Targets = new List<BaseRpcTarget>();
private LocalSendRpcTarget m_LocalSendRpcTarget;
private HashSet<ulong> m_Ids = new HashSet<ulong>();
private Stack<DirectSendRpcTarget> m_TargetCache = new Stack<DirectSendRpcTarget>();
public override void Dispose()
{
CheckLockBeforeDispose();
foreach (var target in Targets)
{
target.Dispose();
}
foreach (var target in m_TargetCache)
{
target.Dispose();
}
m_LocalSendRpcTarget.Dispose();
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
foreach (var target in Targets)
{
target.Send(behaviour, ref message, delivery, rpcParams);
}
}
public void Add(ulong clientId)
{
if (!m_Ids.Contains(clientId))
{
m_Ids.Add(clientId);
if (clientId == m_NetworkManager.LocalClientId)
{
Targets.Add(m_LocalSendRpcTarget);
}
else
{
if (m_TargetCache.Count == 0)
{
Targets.Add(new DirectSendRpcTarget(m_NetworkManager) { ClientId = clientId });
}
else
{
var target = m_TargetCache.Pop();
target.ClientId = clientId;
Targets.Add(target);
}
}
}
}
public void Clear()
{
m_Ids.Clear();
foreach (var target in Targets)
{
if (target is DirectSendRpcTarget directSendRpcTarget)
{
m_TargetCache.Push(directSendRpcTarget);
}
}
Targets.Clear();
}
internal RpcTargetGroup(NetworkManager manager) : base(manager)
{
m_LocalSendRpcTarget = new LocalSendRpcTarget(manager);
}
}
}

3
Runtime/Messaging/RpcTargets/RpcTargetGroup.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 7f8c0fc053b64a588c99dd7d706d9f0a
timeCreated: 1697824991

36
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs Normal file
View File

@@ -0,0 +1,36 @@
namespace Unity.Netcode
{
internal class ServerRpcTarget : BaseRpcTarget
{
private BaseRpcTarget m_UnderlyingTarget;
public override void Dispose()
{
if (m_UnderlyingTarget != null)
{
m_UnderlyingTarget.Dispose();
m_UnderlyingTarget = null;
}
}
internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
{
if (m_UnderlyingTarget == null)
{
if (behaviour.NetworkManager.IsServer)
{
m_UnderlyingTarget = new LocalSendRpcTarget(m_NetworkManager);
}
else
{
m_UnderlyingTarget = new DirectSendRpcTarget(m_NetworkManager) { ClientId = NetworkManager.ServerClientId };
}
}
m_UnderlyingTarget.Send(behaviour, ref message, delivery, rpcParams);
}
internal ServerRpcTarget(NetworkManager manager) : base(manager)
{
}
}
}

3
Runtime/Messaging/RpcTargets/ServerRpcTarget.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: c911725afb6d44f3bb1a1d567d9dee0f
timeCreated: 1697824979

10
Runtime/NetworkVariable/NetworkVariableBase.cs
View File

@@ -100,7 +100,15 @@ namespace Unity.Netcode
"Are you modifying a NetworkVariable before the NetworkObject is spawned?");
return;
}
if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress)
{
if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
{
Debug.LogWarning($"NetworkVariable is written to during the NetworkManager shutdown! " +
"Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
}
return;
}
m_NetworkBehaviour.NetworkManager.BehaviourUpdater.AddForUpdate(m_NetworkBehaviour.NetworkObject);
}

147
Runtime/SceneManagement/NetworkSceneManager.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Unity.Collections;
using UnityEngine;
using UnityEngine.SceneManagement;
@@ -597,6 +598,47 @@ namespace Unity.Netcode
}
}
/// <summary>
/// Used for integration tests, normal runtime mode this will always be LoadSceneMode.Single
/// </summary>
internal LoadSceneMode DeferLoadingFilter = LoadSceneMode.Single;
/// <summary>
/// Determines if a remote client should defer object creation initiated by CreateObjectMessage
/// until a scene event is completed.
/// </summary>
/// <remarks>
/// Deferring object creation should only occur when there is a possibility the objects could be
/// instantiated in a currently active scene that will be unloaded during single mode scene loading
/// to prevent the newly created objects from being destroyed when the scene is unloaded.
/// </remarks>
internal bool ShouldDeferCreateObject()
{
// This applies only to remote clients and when scene management is enabled
if (!NetworkManager.NetworkConfig.EnableSceneManagement || NetworkManager.IsServer)
{
return false;
}
var synchronizeEventDetected = false;
var loadingEventDetected = false;
foreach (var entry in SceneEventDataStore)
{
if (entry.Value.SceneEventType == SceneEventType.Synchronize)
{
synchronizeEventDetected = true;
}
// When loading a scene and the load scene mode is single we should defer object creation
if (entry.Value.SceneEventType == SceneEventType.Load && entry.Value.LoadSceneMode == DeferLoadingFilter)
{
loadingEventDetected = true;
}
}
// Synchronizing while in client synchronization mode single --> Defer
// When not synchronizing but loading a scene in single mode --> Defer
return (synchronizeEventDetected && ClientSynchronizationMode == LoadSceneMode.Single) || (!synchronizeEventDetected && loadingEventDetected);
}
/// <summary>
/// Gets the scene name from full path to the scene
/// </summary>
@@ -740,12 +782,17 @@ namespace Unity.Netcode
// Since NetworkManager is now always migrated to the DDOL we will use this to get the DDOL scene
DontDestroyOnLoadScene = networkManager.gameObject.scene;
// Since the server tracks loaded scenes, we need to add the currently active scene
// to the list of scenes that can be unloaded.
if (networkManager.IsServer)
// Since the server tracks loaded scenes, we need to add any currently loaded scenes on the
// server side when the NetworkManager is started and NetworkSceneManager instantiated when
// scene management is enabled.
if (networkManager.IsServer && networkManager.NetworkConfig.EnableSceneManagement)
{
var activeScene = SceneManager.GetActiveScene();
ScenesLoaded.Add(activeScene.handle, activeScene);
for (int i = 0; i < SceneManager.sceneCount; i++)
{
var loadedScene = SceneManager.GetSceneAt(i);
ScenesLoaded.Add(loadedScene.handle, loadedScene);
}
SceneManagerHandler.PopulateLoadedScenes(ref ScenesLoaded, NetworkManager);
}
// Add to the server to client scene handle table
@@ -969,17 +1016,16 @@ namespace Unity.Netcode
/// <returns></returns>
private SceneEventProgress ValidateSceneEventUnloading(Scene scene)
{
if (!NetworkManager.IsServer)
{
throw new NotServerException("Only server can start a scene event!");
}
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
{
//Log message about enabling SceneManagement
throw new Exception(
$"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
$"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
Debug.LogWarning($"{nameof(LoadScene)} was called, but {nameof(NetworkConfig.EnableSceneManagement)} was not enabled! Enable {nameof(NetworkConfig.EnableSceneManagement)} prior to starting a client, host, or server prior to using {nameof(NetworkSceneManager)}!");
return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
}
if (!NetworkManager.IsServer)
{
Debug.LogWarning($"[{nameof(SceneEventProgressStatus.ServerOnlyAction)}][Unload] Clients cannot invoke the {nameof(UnloadScene)} method!");
return new SceneEventProgress(null, SceneEventProgressStatus.ServerOnlyAction);
}
if (!scene.isLoaded)
@@ -998,16 +1044,16 @@ namespace Unity.Netcode
/// <returns></returns>
private SceneEventProgress ValidateSceneEventLoading(string sceneName)
{
if (!NetworkManager.IsServer)
{
throw new NotServerException("Only server can start a scene event!");
}
if (!NetworkManager.NetworkConfig.EnableSceneManagement)
{
//Log message about enabling SceneManagement
throw new Exception(
$"{nameof(NetworkConfig.EnableSceneManagement)} flag is not enabled in the {nameof(Netcode.NetworkManager)}'s {nameof(NetworkConfig)}. " +
$"Please set {nameof(NetworkConfig.EnableSceneManagement)} flag to true before calling {nameof(LoadScene)} or {nameof(UnloadScene)}.");
Debug.LogWarning($"{nameof(LoadScene)} was called, but {nameof(NetworkConfig.EnableSceneManagement)} was not enabled! Enable {nameof(NetworkConfig.EnableSceneManagement)} prior to starting a client, host, or server prior to using {nameof(NetworkSceneManager)}!");
return new SceneEventProgress(null, SceneEventProgressStatus.SceneManagementNotEnabled);
}
if (!NetworkManager.IsServer)
{
Debug.LogWarning($"[{nameof(SceneEventProgressStatus.ServerOnlyAction)}][Load] Clients cannot invoke the {nameof(LoadScene)} method!");
return new SceneEventProgress(null, SceneEventProgressStatus.ServerOnlyAction);
}
return ValidateSceneEvent(sceneName);
@@ -1112,6 +1158,7 @@ namespace Unity.Netcode
{
var sceneName = scene.name;
var sceneHandle = scene.handle;
if (!scene.isLoaded)
{
Debug.LogWarning($"{nameof(UnloadScene)} was called, but the scene {scene.name} is not currently loaded!");
@@ -1697,6 +1744,9 @@ namespace Unity.Netcode
SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
m_IsSceneEventActive = false;
// Process any pending create object messages that the client received while loading a scene
ProcessDeferredCreateObjectMessages();
// Notify local client that the scene was loaded
OnSceneEvent?.Invoke(new SceneEvent()
{
@@ -2058,6 +2108,9 @@ namespace Unity.Netcode
// If needed, migrate dynamically spawned NetworkObjects to the same scene as they are on the server
SynchronizeNetworkObjectScene();
// Process any pending create object messages that the client received during synchronization
ProcessDeferredCreateObjectMessages();
sceneEventData.SceneEventType = SceneEventType.SynchronizeComplete;
SendSceneEventData(sceneEventId, new ulong[] { NetworkManager.ServerClientId });
@@ -2213,6 +2266,11 @@ namespace Unity.Netcode
// of the client was persisted since MLAPI)
NetworkManager.ConnectionManager.InvokeOnClientConnectedCallback(clientId);
if (NetworkManager.IsHost)
{
NetworkManager.ConnectionManager.InvokeOnPeerConnectedCallback(clientId);
}
// Check to see if the client needs to resynchronize and before sending the message make sure the client is still connected to avoid
// a potential crash within the MessageSystem (i.e. sending to a client that no longer exists)
if (sceneEventData.ClientNeedsReSynchronization() && !DisableReSynchronization && NetworkManager.ConnectedClients.ContainsKey(clientId))
@@ -2549,5 +2607,50 @@ namespace Unity.Netcode
internal Dictionary<int, List<ulong>> ObjectsMigratedTable;
}
internal List<DeferredObjectsMovedEvent> DeferredObjectsMovedEvents = new List<DeferredObjectsMovedEvent>();
internal struct DeferredObjectCreation
{
internal ulong SenderId;
internal uint MessageSize;
internal NetworkObject.SceneObject SceneObject;
internal FastBufferReader FastBufferReader;
}
internal List<DeferredObjectCreation> DeferredObjectCreationList = new List<DeferredObjectCreation>();
internal int DeferredObjectCreationCount;
internal void DeferCreateObject(ulong senderId, uint messageSize, NetworkObject.SceneObject sceneObject, FastBufferReader fastBufferReader)
{
var deferredObjectCreationEntry = new DeferredObjectCreation()
{
SenderId = senderId,
MessageSize = messageSize,
SceneObject = sceneObject,
};
unsafe
{
deferredObjectCreationEntry.FastBufferReader = new FastBufferReader(fastBufferReader.GetUnsafePtrAtCurrentPosition(), Allocator.Persistent, fastBufferReader.Length - fastBufferReader.Position);
}
DeferredObjectCreationList.Add(deferredObjectCreationEntry);
}
private void ProcessDeferredCreateObjectMessages()
{
// If no pending create object messages exit early
if (DeferredObjectCreationList.Count == 0)
{
return;
}
var networkManager = NetworkManager;
// Process all deferred create object messages.
foreach (var deferredObjectCreation in DeferredObjectCreationList)
{
CreateObjectMessage.CreateObject(ref networkManager, deferredObjectCreation.SenderId, deferredObjectCreation.MessageSize, deferredObjectCreation.SceneObject, deferredObjectCreation.FastBufferReader);
}
DeferredObjectCreationCount = DeferredObjectCreationList.Count;
DeferredObjectCreationList.Clear();
}
}
}

8
Runtime/SceneManagement/SceneEventProgress.cs
View File

@@ -47,6 +47,14 @@ namespace Unity.Netcode
/// If you receive this event then it is most likely due to a bug (<em>please open a GitHub issue with steps to replicate</em>).<br/>
/// </summary>
InternalNetcodeError,
/// <summary>
/// This is returned when an unload or load action is attempted and scene management is disabled
/// </summary>
SceneManagementNotEnabled,
/// <summary>
/// This is returned when a client attempts to perform a server only action
/// </summary>
ServerOnlyAction,
}
/// <summary>

258
Runtime/Spawning/NetworkSpawnManager.cs
View File

@@ -322,6 +322,167 @@ namespace Unity.Netcode
return networkObject != null;
}
internal enum InstantiateAndSpawnErrorTypes
{
NetworkPrefabNull,
NotAuthority,
InvokedWhenShuttingDown,
NotRegisteredNetworkPrefab,
NetworkManagerNull,
NoActiveSession,
}
internal static readonly Dictionary<InstantiateAndSpawnErrorTypes, string> InstantiateAndSpawnErrors = new Dictionary<InstantiateAndSpawnErrorTypes, string>(
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>[]{
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NetworkPrefabNull, $"The {nameof(NetworkObject)} prefab parameter was null!"),
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NotAuthority, $"Only the server has authority to {nameof(InstantiateAndSpawn)}!"),
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown, $"Invoking {nameof(InstantiateAndSpawn)} while shutting down! Calls to {nameof(InstantiateAndSpawn)} will be ignored."),
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab, $"The {nameof(NetworkObject)} parameter is not a registered network prefab. Did you forget to register it or are you trying to instantiate and spawn an instance of a network prefab?"),
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NetworkManagerNull, $"The {nameof(NetworkManager)} parameter was null!"),
new KeyValuePair<InstantiateAndSpawnErrorTypes, string>(InstantiateAndSpawnErrorTypes.NoActiveSession, "You can only invoke this method when you are connected to an existing/in-progress network session!")
});
/// <summary>
/// Use this method to easily instantiate and spawn an instance of a network prefab.
/// InstantiateAndSpawn will:
/// - Find any override associated with the <see cref="NetworkObject"/> prefab
/// - If there is no override, then the current <see cref="NetworkObject"/> prefab type is used.
/// - Create an instance of the <see cref="NetworkObject"/> prefab (or its override).
/// - Spawn the <see cref="NetworkObject"/> prefab instance
/// </summary>
/// <param name="networkPrefab">The <see cref="NetworkObject"/> of the pefab asset.</param>
/// <param name="ownerClientId">The owner of the <see cref="NetworkObject"/> instance (defaults to server).</param>
/// <param name="destroyWithScene">Whether the <see cref="NetworkObject"/> instance will be destroyed when the scene it is located within is unloaded (default is false).</param>
/// <param name="isPlayerObject">Whether the <see cref="NetworkObject"/> instance is a player object or not (default is false).</param>
/// <param name="forceOverride">Whether you want to force spawning the override when running as a host or server or if you want it to spawn the override for host mode and
/// the source prefab for server. If there is an override, clients always spawn that as opposed to the source prefab (defaults to false). </param>
/// <param name="position">The starting poisiton of the <see cref="NetworkObject"/> instance.</param>
/// <param name="rotation">The starting rotation of the <see cref="NetworkObject"/> instance.</param>
/// <returns>The newly instantiated and spawned <see cref="NetworkObject"/> prefab instance.</returns>
public NetworkObject InstantiateAndSpawn(NetworkObject networkPrefab, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
{
if (networkPrefab == null)
{
Debug.LogError(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.NetworkPrefabNull]);
return null;
}
if (!NetworkManager.IsServer)
{
Debug.LogError(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.NotAuthority]);
return null;
}
if (NetworkManager.ShutdownInProgress)
{
Debug.LogWarning(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.InvokedWhenShuttingDown]);
return null;
}
// Verify it is actually a valid prefab
if (!NetworkManager.NetworkConfig.Prefabs.Contains(networkPrefab.gameObject))
{
Debug.LogError(InstantiateAndSpawnErrors[InstantiateAndSpawnErrorTypes.NotRegisteredNetworkPrefab]);
return null;
}
return InstantiateAndSpawnNoParameterChecks(networkPrefab, ownerClientId, destroyWithScene, isPlayerObject, forceOverride, position, rotation);
}
/// <summary>
/// !!! Does not perform any parameter checks prior to attempting to instantiate and spawn the NetworkObject !!!
/// </summary>
internal NetworkObject InstantiateAndSpawnNoParameterChecks(NetworkObject networkPrefab, ulong ownerClientId = NetworkManager.ServerClientId, bool destroyWithScene = false, bool isPlayerObject = false, bool forceOverride = false, Vector3 position = default, Quaternion rotation = default)
{
var networkObject = networkPrefab;
// Host spawns the ovveride and server spawns the original prefab unless forceOverride is set to true where both server or host will spawn the override.
if (forceOverride || NetworkManager.IsHost)
{
networkObject = GetNetworkObjectToSpawn(networkPrefab.GlobalObjectIdHash, ownerClientId, position, rotation);
}
if (networkObject == null)
{
Debug.LogError($"Failed to instantiate and spawn {networkPrefab.name}!");
return null;
}
networkObject.IsPlayerObject = isPlayerObject;
networkObject.transform.position = position;
networkObject.transform.rotation = rotation;
networkObject.SpawnWithOwnership(ownerClientId, destroyWithScene);
return networkObject;
}
/// <summary>
/// Gets the right NetworkObject prefab instance to spawn. If a handler is registered or there is an override assigned to the
/// passed in globalObjectIdHash value, then that is what will be instantiated, spawned, and returned.
/// </summary>
internal NetworkObject GetNetworkObjectToSpawn(uint globalObjectIdHash, ulong ownerId, Vector3 position = default, Quaternion rotation = default, bool isScenePlaced = false)
{
NetworkObject networkObject = null;
// If the prefab hash has a registered INetworkPrefabInstanceHandler derived class
if (NetworkManager.PrefabHandler.ContainsHandler(globalObjectIdHash))
{
// Let the handler spawn the NetworkObject
networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, ownerId, position, rotation);
networkObject.NetworkManagerOwner = NetworkManager;
}
else
{
// See if there is a valid registered NetworkPrefabOverrideLink associated with the provided prefabHash
var networkPrefabReference = (GameObject)null;
var inScenePlacedWithNoSceneManagement = !NetworkManager.NetworkConfig.EnableSceneManagement && isScenePlaced;
if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
{
var networkPrefab = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash];
switch (networkPrefab.Override)
{
default:
case NetworkPrefabOverride.None:
networkPrefabReference = networkPrefab.Prefab;
break;
case NetworkPrefabOverride.Hash:
case NetworkPrefabOverride.Prefab:
{
// When scene management is disabled and this is an in-scene placed NetworkObject, we want to always use the
// SourcePrefabToOverride and not any possible prefab override as a user might want to spawn overrides dynamically
// but might want to use the same source network prefab as an in-scene placed NetworkObject.
// (When scene management is enabled, clients don't delete their in-scene placed NetworkObjects prior to dynamically
// spawning them so the original prefab placed is preserved and this is not needed)
if (inScenePlacedWithNoSceneManagement)
{
networkPrefabReference = networkPrefab.SourcePrefabToOverride ? networkPrefab.SourcePrefabToOverride : networkPrefab.Prefab;
}
else
{
networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
}
break;
}
}
}
// If not, then there is an issue (user possibly didn't register the prefab properly?)
if (networkPrefabReference == null)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogError($"Failed to create object locally. [{nameof(globalObjectIdHash)}={globalObjectIdHash}]. {nameof(NetworkPrefab)} could not be found. Is the prefab registered with {nameof(NetworkManager)}?");
}
}
else
{
// Create prefab instance
networkObject = UnityEngine.Object.Instantiate(networkPrefabReference).GetComponent<NetworkObject>();
networkObject.NetworkManagerOwner = NetworkManager;
networkObject.PrefabGlobalObjectIdHash = globalObjectIdHash;
}
}
return networkObject;
}
/// <summary>
/// Creates a local NetowrkObject to be spawned.
/// </summary>
@@ -343,48 +504,7 @@ namespace Unity.Netcode
// If scene management is disabled or the NetworkObject was dynamically spawned
if (!NetworkManager.NetworkConfig.EnableSceneManagement || !sceneObject.IsSceneObject)
{
// If the prefab hash has a registered INetworkPrefabInstanceHandler derived class
if (NetworkManager.PrefabHandler.ContainsHandler(globalObjectIdHash))
{
// Let the handler spawn the NetworkObject
networkObject = NetworkManager.PrefabHandler.HandleNetworkPrefabSpawn(globalObjectIdHash, sceneObject.OwnerClientId, position, rotation);
networkObject.NetworkManagerOwner = NetworkManager;
isSpawnedByPrefabHandler = true;
}
else
{
// See if there is a valid registered NetworkPrefabOverrideLink associated with the provided prefabHash
GameObject networkPrefabReference = null;
if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
{
switch (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Override)
{
default:
case NetworkPrefabOverride.None:
networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Prefab;
break;
case NetworkPrefabOverride.Hash:
case NetworkPrefabOverride.Prefab:
networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
break;
}
}
// If not, then there is an issue (user possibly didn't register the prefab properly?)
if (networkPrefabReference == null)
{
if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
{
NetworkLog.LogError($"Failed to create object locally. [{nameof(globalObjectIdHash)}={globalObjectIdHash}]. {nameof(NetworkPrefab)} could not be found. Is the prefab registered with {nameof(NetworkManager)}?");
}
}
else
{
// Create prefab instance
networkObject = UnityEngine.Object.Instantiate(networkPrefabReference).GetComponent<NetworkObject>();
networkObject.NetworkManagerOwner = NetworkManager;
}
}
networkObject = GetNetworkObjectToSpawn(sceneObject.Hash, sceneObject.OwnerClientId, position, rotation, sceneObject.IsSceneObject);
}
else // Get the in-scene placed NetworkObject
{
@@ -624,6 +744,13 @@ namespace Unity.Netcode
{
networkObject.SubscribeToActiveSceneForSynch();
}
// If we are an in-scene placed NetworkObject and our InScenePlacedSourceGlobalObjectIdHash is set
// then assign this to the PrefabGlobalObjectIdHash
if (networkObject.IsSceneObject.Value && networkObject.InScenePlacedSourceGlobalObjectIdHash != 0)
{
networkObject.PrefabGlobalObjectIdHash = networkObject.InScenePlacedSourceGlobalObjectIdHash;
}
}
internal void SendSpawnCallForObject(ulong clientId, NetworkObject networkObject)
@@ -728,17 +855,43 @@ namespace Unity.Netcode
// Leave destruction up to the handler
NetworkManager.PrefabHandler.HandleNetworkPrefabDestroy(networkObjects[i]);
}
else if (networkObjects[i].IsSpawned)
else
{
// If it is an in-scene placed NetworkObject then just despawn
// and let it be destroyed when the scene is unloaded. Otherwise, despawn and destroy it.
// If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
// is unloaded. Otherwise, despawn and destroy it.
var shouldDestroy = !(networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value);
OnDespawnObject(networkObjects[i], shouldDestroy);
}
else if (networkObjects[i].IsSceneObject != null && !networkObjects[i].IsSceneObject.Value)
{
UnityEngine.Object.Destroy(networkObjects[i].gameObject);
// If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
if (shouldDestroy)
{
// Check to see if there are any in-scene placed children that are marked to be destroyed with the scene
var childrenObjects = networkObjects[i].GetComponentsInChildren<NetworkObject>();
foreach (var childObject in childrenObjects)
{
if (childObject == networkObjects[i])
{
continue;
}
// If the child is an in-scene placed NetworkObject then remove the child from the parent (which was dynamically spawned)
// and set its parent to root
if (childObject.IsSceneObject != null && childObject.IsSceneObject.Value)
{
childObject.TryRemoveParent(childObject.WorldPositionStays());
}
}
}
// If spawned, then despawn and potentially destroy.
if (networkObjects[i].IsSpawned)
{
OnDespawnObject(networkObjects[i], shouldDestroy);
}
else // Otherwise, if we are not spawned and we should destroy...then destroy.
if (shouldDestroy)
{
UnityEngine.Object.Destroy(networkObjects[i].gameObject);
}
}
}
}
@@ -788,7 +941,7 @@ namespace Unity.Netcode
{
if (networkObjects[i].NetworkManager == NetworkManager)
{
if (networkObjects[i].IsSceneObject == null)
if (networkObjects[i].IsSceneObject == null || (networkObjects[i].IsSceneObject.HasValue && networkObjects[i].IsSceneObject.Value))
{
networkObjectsToSpawn.Add(networkObjects[i]);
}
@@ -937,7 +1090,7 @@ namespace Unity.Netcode
if (sobj.CheckObjectVisibility == null)
{
// If the client is not part of the observers and spawn with observers is enabled on this instance or the clientId is the server
if (!sobj.Observers.Contains(clientId) && (sobj.SpawnWithObservers || clientId == NetworkManager.ServerClientId))
if (sobj.SpawnWithObservers || clientId == NetworkManager.ServerClientId)
{
sobj.Observers.Add(clientId);
}
@@ -950,7 +1103,6 @@ namespace Unity.Netcode
sobj.Observers.Add(clientId);
}
else // Otherwise, if the observers contains the clientId (shouldn't happen) then remove it since CheckObjectVisibility returned false
if (sobj.Observers.Contains(clientId))
{
sobj.Observers.Remove(clientId);
}

68
Runtime/Transports/UTP/BatchedSendQueue.cs
View File

@@ -198,43 +198,69 @@ namespace Unity.Netcode.Transports.UTP
/// could lead to a corrupted queue.
/// </remarks>
/// <param name="writer">The <see cref="DataStreamWriter"/> to write to.</param>
/// <param name="softMaxBytes">
/// Maximum number of bytes to copy (0 means writer capacity). This is a soft limit only.
/// If a message is larger than that but fits in the writer, it will be written. In effect,
/// this parameter is the maximum size that small messages can be coalesced together.
/// </param>
/// <returns>How many bytes were written to the writer.</returns>
public int FillWriterWithMessages(ref DataStreamWriter writer)
public int FillWriterWithMessages(ref DataStreamWriter writer, int softMaxBytes = 0)
{
if (!IsCreated || Length == 0)
{
return 0;
}
softMaxBytes = softMaxBytes == 0 ? writer.Capacity : Math.Min(softMaxBytes, writer.Capacity);
unsafe
{
var reader = new DataStreamReader(m_Data.AsArray());
var writerAvailable = writer.Capacity;
var readerOffset = HeadIndex;
while (readerOffset < TailIndex)
reader.SeekSet(readerOffset);
var messageLength = reader.ReadInt();
var bytesToWrite = messageLength + sizeof(int);
// Our behavior here depends on the size of the first message in the queue. If it's
// larger than the soft limit, then add only that message to the writer (we want
// large payloads to be fragmented on their own). Otherwise coalesce all small
// messages until we hit the soft limit (which presumably means they won't be
// fragmented, which is the desired behavior for smaller messages).
if (bytesToWrite > softMaxBytes && bytesToWrite <= writer.Capacity)
{
reader.SeekSet(readerOffset);
var messageLength = reader.ReadInt();
writer.WriteInt(messageLength);
WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
if (writerAvailable < sizeof(int) + messageLength)
{
break;
}
else
{
writer.WriteInt(messageLength);
var messageOffset = reader.GetBytesRead();
WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + messageOffset, messageLength);
writerAvailable -= sizeof(int) + messageLength;
readerOffset += sizeof(int) + messageLength;
}
return bytesToWrite;
}
else
{
var bytesWritten = 0;
return writer.Capacity - writerAvailable;
while (readerOffset < TailIndex)
{
reader.SeekSet(readerOffset);
messageLength = reader.ReadInt();
bytesToWrite = messageLength + sizeof(int);
if (bytesWritten + bytesToWrite <= softMaxBytes)
{
writer.WriteInt(messageLength);
WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + reader.GetBytesRead(), messageLength);
readerOffset += bytesToWrite;
bytesWritten += bytesToWrite;
}
else
{
break;
}
}
return bytesWritten;
}
}
}

20
Runtime/Transports/UTP/UnityTransport.cs
View File

@@ -753,7 +753,7 @@ namespace Unity.Netcode.Transports.UTP
// in the stream (the send queue does that automatically) we are sure they'll be
// reassembled properly at the other end. This allows us to lift the limit of ~44KB
// on reliable payloads (because of the reliable window size).
var written = pipeline == ReliablePipeline ? Queue.FillWriterWithBytes(ref writer, MTU) : Queue.FillWriterWithMessages(ref writer);
var written = pipeline == ReliablePipeline ? Queue.FillWriterWithBytes(ref writer, MTU) : Queue.FillWriterWithMessages(ref writer, MTU);
result = Driver.EndSend(writer);
if (result == written)
@@ -995,6 +995,11 @@ namespace Unity.Netcode.Transports.UTP
private void ExtractNetworkMetricsFromPipeline(NetworkPipeline pipeline, NetworkConnection networkConnection)
{
if (m_Driver.GetConnectionState(networkConnection) != NetworkConnection.State.Connected)
{
return;
}
//Don't need to dispose of the buffers, they are filled with data pointers.
m_Driver.GetPipelineBuffers(pipeline,
#if UTP_TRANSPORT_2_0_ABOVE
@@ -1229,7 +1234,18 @@ namespace Unity.Netcode.Transports.UTP
// Bump the reliable window size to its maximum size of 64. Since NGO makes heavy use of
// reliable delivery, we're better off with the increased window size compared to the
// extra 4 bytes of header that this costs us.
m_NetworkSettings.WithReliableStageParameters(windowSize: 64);
//
// We also increase the maximum resend timeout since the default one in UTP is very
// aggressive (optimized for latency and low bandwidth). With NGO, it's too low and
// we sometimes notice a lot of useless resends, especially if using Relay. (We can
// only do this with UTP 2.0 because 1.X doesn't support that parameter.)
m_NetworkSettings.WithReliableStageParameters(
windowSize: 64
#if UTP_TRANSPORT_2_0_ABOVE
,
maximumResendTime: m_ProtocolType == ProtocolType.RelayUnityTransport ? 750 : 500
#endif
);
#if !UTP_TRANSPORT_2_0_ABOVE && !UNITY_WEBGL
m_NetworkSettings.WithBaselibNetworkInterfaceParameters(

57
TestHelpers/Runtime/NetcodeIntegrationTest.cs
View File

@@ -305,8 +305,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
public IEnumerator SetUp()
{
VerboseDebug($"Entering {nameof(SetUp)}");
NetcodeLogAssert = new NetcodeLogAssert();
if (m_EnableTimeTravel)
{
// Setup the frames per tick for time travel advance to next tick
ConfigureFramesPerTick();
}
if (m_SetupIsACoroutine)
{
yield return OnSetup();
@@ -732,6 +736,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
Assert.Fail("Failed to start instances");
}
// When scene management is enabled, we need to re-apply the scenes populated list since we have overriden the ISceneManagerHandler
// imeplementation at this point. This assures any pre-loaded scenes will be automatically assigned to the server and force clients
// to load their own scenes.
if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement)
{
var scenesLoaded = m_ServerNetworkManager.SceneManager.ScenesLoaded;
m_ServerNetworkManager.SceneManager.SceneManagerHandler.PopulateLoadedScenes(ref scenesLoaded, m_ServerNetworkManager);
}
if (LogAllMessages)
{
EnableMessageLogging();
@@ -799,6 +813,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
Assert.Fail("Failed to start instances");
}
// Time travel does not play nice with scene loading, clear out server side pre-loaded scenes.
if (m_ServerNetworkManager.NetworkConfig.EnableSceneManagement)
{
m_ServerNetworkManager.SceneManager.ScenesLoaded.Clear();
}
if (LogAllMessages)
{
EnableMessageLogging();
@@ -1544,8 +1564,42 @@ namespace Unity.Netcode.TestHelpers.Runtime
}
}
protected virtual uint GetTickRate()
{
return k_DefaultTickRate;
}
protected virtual int GetFrameRate()
{
return Application.targetFrameRate == 0 ? 60 : Application.targetFrameRate;
}
private int m_FramesPerTick = 0;
private float m_TickFrequency = 0;
/// <summary>
/// Recalculates the <see cref="m_TickFrequency"/> and <see cref="m_FramesPerTick"/> that is
/// used in <see cref="TimeTravelAdvanceTick"/>.
/// </summary>
protected void ConfigureFramesPerTick()
{
m_TickFrequency = 1.0f / GetTickRate();
m_FramesPerTick = Math.Max((int)(m_TickFrequency / GetFrameRate()), 1);
}
/// <summary>
/// Helper function to time travel exactly one tick's worth of time at the current frame and tick rates.
/// This is NetcodeIntegrationTest instance relative and will automatically adjust based on <see cref="GetFrameRate"/>
/// and <see cref="GetTickRate"/>.
/// </summary>
protected void TimeTravelAdvanceTick()
{
TimeTravel(m_TickFrequency, m_FramesPerTick);
}
/// <summary>
/// Helper function to time travel exactly one tick's worth of time at the current frame and tick rates.
/// ** Is based on the global k_DefaultTickRate and is not local to each NetcodeIntegrationTest instance **
/// </summary>
public static void TimeTravelToNextTick()
{
@@ -1555,7 +1609,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
{
frameRate = 60;
}
var frames = Math.Max((int)(timePassed / frameRate), 1);
TimeTravel(timePassed, frames);
}

3
TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs
View File

@@ -813,7 +813,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
if (minFrames > 0)
{
yield return new WaitUntil(() => Time.frameCount >= minFrames);
var waitForFrameCount = Time.frameCount + minFrames;
yield return new WaitUntil(() => Time.frameCount >= waitForFrameCount);
}
while (Time.realtimeSinceStartup - startTime < timeout && !predicate())

29
Tests/Editor/Transports/BatchedSendQueueTests.cs
View File

@@ -237,6 +237,35 @@ namespace Unity.Netcode.EditorTests
AssertIsTestMessage(data);
}
[Test]
public void BatchedSendQueue_FillWriterWithMessages_StopOnSoftMaxBytes()
{
var smallMessage = new ArraySegment<byte>(new byte[10]);
var largeMessage = new ArraySegment<byte>(new byte[3000]);
var smallMessageSize = smallMessage.Count + BatchedSendQueue.PerMessageOverhead;
var largeMessageSize = largeMessage.Count + BatchedSendQueue.PerMessageOverhead;
using var q = new BatchedSendQueue(k_TestQueueCapacity);
using var data = new NativeArray<byte>(largeMessageSize, Allocator.Temp);
q.PushMessage(smallMessage);
q.PushMessage(largeMessage);
q.PushMessage(smallMessage);
var writer = new DataStreamWriter(data);
Assert.AreEqual(smallMessageSize, q.FillWriterWithMessages(ref writer, 1000));
q.Consume(smallMessageSize);
writer = new DataStreamWriter(data);
Assert.AreEqual(largeMessageSize, q.FillWriterWithMessages(ref writer, 1000));
q.Consume(largeMessageSize);
writer = new DataStreamWriter(data);
Assert.AreEqual(smallMessageSize, q.FillWriterWithMessages(ref writer, 1000));
q.Consume(smallMessageSize);
}
[Test]
public void BatchedSendQueue_FillWriterWithBytes_NoopIfNoData()
{

4
Tests/Runtime/DeferredMessagingTests.cs
View File

@@ -94,6 +94,10 @@ namespace Unity.Netcode.RuntimeTests
public override void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
{
if (trigger == IDeferredNetworkMessageManager.TriggerType.OnNextFrame)
{
return;
}
ProcessTriggersCalled = true;
base.ProcessTriggers(trigger, key);
}

18
Tests/Runtime/InvalidConnectionEventsTest.cs
View File

@@ -79,7 +79,10 @@ namespace Unity.Netcode.RuntimeTests
[UnityTest]
public IEnumerator WhenSendingConnectionApprovedToAlreadyConnectedClient_ConnectionApprovedMessageIsRejected()
{
var message = new ConnectionApprovedMessage();
var message = new ConnectionApprovedMessage
{
ConnectedClientIds = new NativeArray<ulong>(0, Allocator.Temp)
};
m_ServerNetworkManager.ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ClientNetworkManagers[0].LocalClientId);
// Unnamed message is something to wait for. When this one is received,
@@ -93,7 +96,7 @@ namespace Unity.Netcode.RuntimeTests
m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new Hooks<ConnectionApprovedMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established\\. This should not happen\\."));
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(m_ClientNetworkManagers.ToList());
}
@@ -115,7 +118,7 @@ namespace Unity.Netcode.RuntimeTests
m_ClientNetworkManagers[0].ConnectionManager.MessageManager.Hook(new Hooks<ConnectionRequestMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side\\. This should not happen\\."));
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(m_ClientNetworkManagers.ToList());
}
@@ -137,7 +140,7 @@ namespace Unity.Netcode.RuntimeTests
m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new Hooks<ConnectionRequestMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established\\. This should not happen\\."));
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(new List<NetworkManager> { m_ServerNetworkManager });
}
@@ -145,7 +148,10 @@ namespace Unity.Netcode.RuntimeTests
[UnityTest]
public IEnumerator WhenSendingConnectionApprovedFromAnyClient_ConnectionApprovedMessageIsRejected()
{
var message = new ConnectionApprovedMessage();
var message = new ConnectionApprovedMessage
{
ConnectedClientIds = new NativeArray<ulong>(0, Allocator.Temp)
};
m_ClientNetworkManagers[0].ConnectionManager.SendMessage(ref message, NetworkDelivery.Reliable, m_ServerNetworkManager.LocalClientId);
// Unnamed message is something to wait for. When this one is received,
@@ -159,7 +165,7 @@ namespace Unity.Netcode.RuntimeTests
m_ServerNetworkManager.ConnectionManager.MessageManager.Hook(new Hooks<ConnectionApprovedMessage>());
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side\\. This should not happen\\."));
LogAssert.Expect(LogType.Error, new Regex($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side\\. NetworkTransport: Unity.Netcode.Transports.UTP.UnityTransport UnityTransportProtocol: UnityTransport. This should not happen\\."));
yield return WaitForMessageReceived<UnnamedMessage>(new List<NetworkManager> { m_ServerNetworkManager });
}

10
Tests/Runtime/NetworkObject/NetworkObjectDestroyTests.cs
View File

@@ -58,6 +58,9 @@ namespace Unity.Netcode.RuntimeTests
ShuttingDown,
ActiveSession
}
private string m_ClientPlayerName;
private ulong m_ClientNetworkObjectId;
/// <summary>
/// Validates the expected behavior when the client-side destroys a <see cref="NetworkObject"/>
/// </summary>
@@ -78,7 +81,8 @@ namespace Unity.Netcode.RuntimeTests
LogAssert.ignoreFailingMessages = true;
NetworkLog.NetworkManagerOverride = m_ClientNetworkManagers[0];
}
m_ClientPlayerName = clientPlayer.gameObject.name;
m_ClientNetworkObjectId = clientPlayer.NetworkObjectId;
Object.DestroyImmediate(clientPlayer.gameObject);
// destroying a NetworkObject while a session is active is not allowed
@@ -91,12 +95,12 @@ namespace Unity.Netcode.RuntimeTests
private bool HaveLogsBeenReceived()
{
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, "[Netcode] Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
{
return false;
}
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] Destroy a spawned NetworkObject on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
if (!NetcodeLogAssert.HasLogBeenReceived(LogType.Error, $"[Netcode-Server Sender={m_ClientNetworkManagers[0].LocalClientId}] [Invalid Destroy][{m_ClientPlayerName}][NetworkObjectId:{m_ClientNetworkObjectId}] Destroy a spawned {nameof(NetworkObject)} on a non-host client is not valid. Call Destroy or Despawn on the server/host instead."))
{
return false;
}

137
Tests/Runtime/NetworkObject/NetworkObjectOnNetworkDespawnTests.cs
View File

@@ -10,111 +10,104 @@ namespace Unity.Netcode.RuntimeTests
/// <summary>
/// Tests that check OnNetworkDespawn being invoked
/// </summary>
public class NetworkObjectOnNetworkDespawnTests
[TestFixture(HostOrServer.Host)]
[TestFixture(HostOrServer.Server)]
public class NetworkObjectOnNetworkDespawnTests : NetcodeIntegrationTest
{
private NetworkManager m_ServerHost;
private NetworkManager[] m_Clients;
private const string k_ObjectName = "TestDespawn";
public enum InstanceType
{
Server,
Client
}
protected override int NumberOfClients => 1;
private GameObject m_ObjectToSpawn;
private NetworkObject m_NetworkObject;
private HostOrServer m_HostOrServer;
public NetworkObjectOnNetworkDespawnTests(HostOrServer hostOrServer) : base(hostOrServer)
{
m_HostOrServer = hostOrServer;
}
internal class OnNetworkDespawnTestComponent : NetworkBehaviour
{
public bool OnNetworkDespawnCalled { get; internal set; }
public static bool OnServerNetworkDespawnCalled { get; internal set; }
public static bool OnClientNetworkDespawnCalled { get; internal set; }
public override void OnNetworkSpawn()
{
OnNetworkDespawnCalled = false;
if (IsServer)
{
OnServerNetworkDespawnCalled = false;
}
else
{
OnClientNetworkDespawnCalled = false;
}
base.OnNetworkSpawn();
}
public override void OnNetworkDespawn()
{
OnNetworkDespawnCalled = true;
if (IsServer)
{
OnServerNetworkDespawnCalled = true;
}
else
{
OnClientNetworkDespawnCalled = true;
}
base.OnNetworkDespawn();
}
}
[UnitySetUp]
public IEnumerator Setup()
protected override void OnServerAndClientsCreated()
{
Assert.IsTrue(NetcodeIntegrationTestHelpers.Create(1, out m_ServerHost, out m_Clients));
m_ObjectToSpawn = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(nameof(NetworkObjectOnNetworkDespawnTests), m_ServerHost, m_Clients);
m_ObjectToSpawn = CreateNetworkObjectPrefab(k_ObjectName);
m_ObjectToSpawn.AddComponent<OnNetworkDespawnTestComponent>();
m_NetworkObject = m_ObjectToSpawn.GetComponent<NetworkObject>();
yield return null;
}
[UnityTearDown]
public IEnumerator Teardown()
{
// Shutdown and clean up both of our NetworkManager instances
if (m_ObjectToSpawn)
{
Object.Destroy(m_ObjectToSpawn);
m_ObjectToSpawn = null;
}
NetcodeIntegrationTestHelpers.Destroy();
yield return null;
}
public enum InstanceType
{
Server,
Host,
Client
base.OnServerAndClientsCreated();
}
/// <summary>
/// Tests that a spawned NetworkObject's associated NetworkBehaviours will have
/// their OnNetworkDespawn invoked during NetworkManager shutdown.
/// This test validates that <see cref="NetworkBehaviour.OnNetworkDespawn"/> is invoked when the
/// <see cref="NetworkManager"/> is shutdown.
/// </summary>
[UnityTest]
public IEnumerator TestNetworkObjectDespawnOnShutdown([Values(InstanceType.Server, InstanceType.Host, InstanceType.Client)] InstanceType despawnCheck)
public IEnumerator TestNetworkObjectDespawnOnShutdown()
{
var useHost = despawnCheck != InstanceType.Server;
var networkManager = despawnCheck == InstanceType.Host || despawnCheck == InstanceType.Server ? m_ServerHost : m_Clients[0];
// Start the instances
if (!NetcodeIntegrationTestHelpers.Start(useHost, m_ServerHost, m_Clients))
{
Debug.LogError("Failed to start instances");
Assert.Fail("Failed to start instances");
}
// [Client-Side] Wait for a connection to the server
yield return NetcodeIntegrationTestHelpers.WaitForClientsConnected(m_Clients, null, 512);
// [Host-Server-Side] Check to make sure all clients are connected
var clientCount = useHost ? m_Clients.Length + 1 : m_Clients.Length;
yield return NetcodeIntegrationTestHelpers.WaitForClientsConnectedToServer(m_ServerHost, clientCount, null, 512);
// Spawn the test object
var spawnedObject = Object.Instantiate(m_NetworkObject);
var spawnedObject = SpawnObject(m_ObjectToSpawn, m_ServerNetworkManager);
var spawnedNetworkObject = spawnedObject.GetComponent<NetworkObject>();
spawnedNetworkObject.NetworkManagerOwner = m_ServerHost;
spawnedNetworkObject.Spawn(true);
// Get the spawned object relative to which NetworkManager instance we are testing.
var relativeSpawnedObject = new NetcodeIntegrationTestHelpers.ResultWrapper<NetworkObject>();
yield return NetcodeIntegrationTestHelpers.GetNetworkObjectByRepresentation((x => x.GetComponent<OnNetworkDespawnTestComponent>() != null), networkManager, relativeSpawnedObject);
var onNetworkDespawnTestComponent = relativeSpawnedObject.Result.GetComponent<OnNetworkDespawnTestComponent>();
// Wait for the client to spawn the object
yield return WaitForConditionOrTimeOut(() =>
{
if (!s_GlobalNetworkObjects.ContainsKey(m_ClientNetworkManagers[0].LocalClientId))
{
return false;
}
if (!s_GlobalNetworkObjects[m_ClientNetworkManagers[0].LocalClientId].ContainsKey(spawnedNetworkObject.NetworkObjectId))
{
return false;
}
return true;
});
AssertOnTimeout($"Timed out waiting for client to spawn {k_ObjectName}!");
// Confirm it is not set before shutting down the NetworkManager
Assert.IsFalse(onNetworkDespawnTestComponent.OnNetworkDespawnCalled);
Assert.IsFalse(OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled, "[Client-side] despawn state is already set (should not be set at this point)!");
Assert.IsFalse(OnNetworkDespawnTestComponent.OnServerNetworkDespawnCalled, $"[{m_HostOrServer}-side] despawn state is already set (should not be set at this point)!");
// Shutdown the NetworkManager instance we are testing.
networkManager.Shutdown();
// Shutdown the client-side first to validate the client-side instance invokes OnNetworkDespawn
m_ClientNetworkManagers[0].Shutdown();
yield return WaitForConditionOrTimeOut(() => OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled);
AssertOnTimeout($"[Client-side] Timed out waiting for {k_ObjectName}'s {nameof(NetworkBehaviour.OnNetworkDespawn)} to be invoked!");
// Since shutdown is now delayed until the post frame update
// just wait 2 frames before checking to see if OnNetworkDespawnCalled is true
var currentFrame = Time.frameCount + 2;
yield return new WaitUntil(() => Time.frameCount <= currentFrame);
// Confirm that OnNetworkDespawn is invoked after shutdown
Assert.IsTrue(onNetworkDespawnTestComponent.OnNetworkDespawnCalled);
// Shutdown the servr-host-side second to validate servr-host-side instance invokes OnNetworkDespawn
m_ServerNetworkManager.Shutdown();
yield return WaitForConditionOrTimeOut(() => OnNetworkDespawnTestComponent.OnClientNetworkDespawnCalled);
AssertOnTimeout($"[{m_HostOrServer}-side]Timed out waiting for {k_ObjectName}'s {nameof(NetworkBehaviour.OnNetworkDespawn)} to be invoked!");
}
}
}

6
Tests/Runtime/NetworkObject/NetworkObjectSpawnManyObjectsTests.cs
View File

@@ -57,9 +57,9 @@ namespace Unity.Netcode.RuntimeTests
serverObject.NetworkManagerOwner = m_ServerNetworkManager;
serverObject.Spawn();
}
// ensure all objects are replicated before spawning more
yield return WaitForConditionOrTimeOut(() => SpawnObjecTrackingComponent.SpawnedObjects < k_SpawnedObjects);
Assert.False(s_GlobalTimeoutHelper.TimedOut, $"Timed out waiting for the client to spawn {k_SpawnedObjects} objects!");
// ensure all objects are replicated
yield return WaitForConditionOrTimeOut(() => SpawnObjecTrackingComponent.SpawnedObjects == k_SpawnedObjects);
AssertOnTimeout($"Timed out waiting for the client to spawn {k_SpawnedObjects} objects!");
}
}
}

1004
Tests/Runtime/NetworkTransform/NetworkTransformBase.cs Normal file
View File

File diff suppressed because it is too large Load Diff

11
Tests/Runtime/NetworkTransform/NetworkTransformBase.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: ccdf46d0c73f8ac47921ec1be2772fac
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

314
Tests/Runtime/NetworkTransform/NetworkTransformGeneral.cs Normal file
View File

@@ -0,0 +1,314 @@
using NUnit.Framework;
using Unity.Netcode.Components;
using UnityEngine;
namespace Unity.Netcode.RuntimeTests
{
[TestFixture(HostOrServer.Host, Authority.OwnerAuthority)]
[TestFixture(HostOrServer.Host, Authority.ServerAuthority)]
public class NetworkTransformGeneral : NetworkTransformBase
{
public NetworkTransformGeneral(HostOrServer testWithHost, Authority authority) :
base(testWithHost, authority, RotationCompression.None, Rotation.Euler, Precision.Full)
{ }
protected override bool m_EnableTimeTravel => true;
protected override bool m_SetupIsACoroutine => false;
protected override bool m_TearDownIsACoroutine => false;
/// <summary>
/// Test to verify nonAuthority cannot change the transform directly
/// </summary>
[Test]
public void VerifyNonAuthorityCantChangeTransform([Values] Interpolation interpolation)
{
m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "other side pos should be zero at first"); // sanity check
m_NonAuthoritativeTransform.transform.position = new Vector3(4, 5, 6);
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "[Position] NonAuthority was able to change the position!");
var nonAuthorityRotation = m_NonAuthoritativeTransform.transform.rotation;
var originalNonAuthorityEulerRotation = nonAuthorityRotation.eulerAngles;
var nonAuthorityEulerRotation = originalNonAuthorityEulerRotation;
// Verify rotation is not marked dirty when rotated by half of the threshold
nonAuthorityEulerRotation.y += 20.0f;
nonAuthorityRotation.eulerAngles = nonAuthorityEulerRotation;
m_NonAuthoritativeTransform.transform.rotation = nonAuthorityRotation;
TimeTravelAdvanceTick();
var nonAuthorityCurrentEuler = m_NonAuthoritativeTransform.transform.rotation.eulerAngles;
Assert.True(originalNonAuthorityEulerRotation.Equals(nonAuthorityCurrentEuler), "[Rotation] NonAuthority was able to change the rotation!");
var nonAuthorityScale = m_NonAuthoritativeTransform.transform.localScale;
m_NonAuthoritativeTransform.transform.localScale = nonAuthorityScale * 100;
TimeTravelAdvanceTick();
Assert.True(nonAuthorityScale.Equals(m_NonAuthoritativeTransform.transform.localScale), "[Scale] NonAuthority was able to change the scale!");
}
/// <summary>
/// Validates that rotation checks don't produce false positive
/// results when rolling over between 0 and 360 degrees
/// </summary>
[Test]
public void TestRotationThresholdDeltaCheck([Values] Interpolation interpolation)
{
m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 5.0f;
var halfThreshold = m_AuthoritativeTransform.RotAngleThreshold * 0.5001f;
// Apply the current state prior to getting reference rotations which assures we have
// applied the most current rotation deltas and that all bitset flags are updated
var results = m_AuthoritativeTransform.ApplyState();
TimeTravelAdvanceTick();
// Get the current rotation values;
var authorityRotation = m_AuthoritativeTransform.transform.rotation;
var authorityEulerRotation = authorityRotation.eulerAngles;
// Verify rotation is not marked dirty when rotated by half of the threshold
authorityEulerRotation.y += halfThreshold;
authorityRotation.eulerAngles = authorityEulerRotation;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
results = m_AuthoritativeTransform.ApplyState();
Assert.IsFalse(results.isRotationDirty, $"Rotation is dirty when rotation threshold is {m_AuthoritativeTransform.RotAngleThreshold} degrees and only adjusted by {halfThreshold} degrees!");
// Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
// Verify rotation is marked dirty when rotated by another half threshold value
authorityEulerRotation.y += halfThreshold;
authorityRotation.eulerAngles = authorityEulerRotation;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
results = m_AuthoritativeTransform.ApplyState();
Assert.IsTrue(results.isRotationDirty, $"Rotation was not dirty when rotated by the threshold value: {m_AuthoritativeTransform.RotAngleThreshold} degrees!");
// Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
//Reset rotation back to zero on all axis
authorityRotation.eulerAngles = authorityEulerRotation = Vector3.zero;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
// Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
// Rotate by 360 minus halfThreshold (which is really just negative halfThreshold) and verify rotation is not marked dirty
authorityEulerRotation.y = 360 - halfThreshold;
authorityRotation.eulerAngles = authorityEulerRotation;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
results = m_AuthoritativeTransform.ApplyState();
Assert.IsFalse(results.isRotationDirty, $"Rotation is dirty when rotation threshold is {m_AuthoritativeTransform.RotAngleThreshold} degrees and only adjusted by " +
$"{Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
// Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
// Now apply one more minor decrement that should trigger a dirty flag
authorityEulerRotation.y -= halfThreshold;
authorityRotation.eulerAngles = authorityEulerRotation;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
results = m_AuthoritativeTransform.ApplyState();
Assert.IsTrue(results.isRotationDirty, $"Rotation was not dirty when rotated by {Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
//Reset rotation back to zero on all axis
authorityRotation.eulerAngles = authorityEulerRotation = Vector3.zero;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
// Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
// Minor decrement again under the threshold value
authorityEulerRotation.y -= halfThreshold;
authorityRotation.eulerAngles = authorityEulerRotation;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
results = m_AuthoritativeTransform.ApplyState();
Assert.IsFalse(results.isRotationDirty, $"Rotation is dirty when rotation threshold is {m_AuthoritativeTransform.RotAngleThreshold} degrees and only adjusted by " +
$"{Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
// Now allow the delta state to be processed and sent (just allow for two ticks to cover edge cases with time travel and the testing environment)
TimeTravelAdvanceTick();
TimeTravelAdvanceTick();
// Now decrement another half threshold which should trigger the dirty flag
authorityEulerRotation.y -= halfThreshold;
authorityRotation.eulerAngles = authorityEulerRotation;
m_AuthoritativeTransform.transform.rotation = authorityRotation;
results = m_AuthoritativeTransform.ApplyState();
Assert.IsTrue(results.isRotationDirty, $"Rotation was not dirty when rotated by {Mathf.DeltaAngle(0, authorityEulerRotation.y)} degrees!");
}
private bool ValidateBitSetValues()
{
var serverState = m_AuthoritativeTransform.AuthorityLastSentState;
var clientState = m_NonAuthoritativeTransform.LocalAuthoritativeNetworkState;
if (serverState.HasPositionX == clientState.HasPositionX && serverState.HasPositionY == clientState.HasPositionY && serverState.HasPositionZ == clientState.HasPositionZ &&
serverState.HasRotAngleX == clientState.HasRotAngleX && serverState.HasRotAngleY == clientState.HasRotAngleY && serverState.HasRotAngleZ == clientState.HasRotAngleZ &&
serverState.HasScaleX == clientState.HasScaleX && serverState.HasScaleY == clientState.HasScaleY && serverState.HasScaleZ == clientState.HasScaleZ)
{
return true;
}
return false;
}
/// <summary>
/// Test to make sure that the bitset value is updated properly
/// </summary>
[Test]
public void TestBitsetValue([Values] Interpolation interpolation)
{
m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 0.1f;
m_AuthoritativeTransform.transform.rotation = Quaternion.Euler(1, 2, 3);
TimeTravelAdvanceTick();
var success = WaitForConditionOrTimeOutWithTimeTravel(ValidateBitSetValues);
Assert.True(success, $"Timed out waiting for Authoritative Bitset state to equal NonAuthoritative replicated Bitset state!");
success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationsMatch());
Assert.True(success, $"[Timed-Out] Authoritative rotation {m_AuthoritativeTransform.transform.rotation.eulerAngles} != Non-Authoritative rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles}");
}
/// <summary>
/// This validates that you can perform multiple explicit <see cref="NetworkTransform.SetState(Vector3?, Quaternion?, Vector3?, bool)"/> calls
/// within the same fractional tick period without the loss of the states applied.
/// </summary>
[Test]
public void TestMultipleExplicitSetStates([Values] Interpolation interpolation)
{
var interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthoritativeTransform.Interpolate = interpolate;
var updatedPosition = GetRandomVector3(-5.0f, 5.0f);
m_AuthoritativeTransform.SetState(updatedPosition, null, null, !interpolate);
// Advance to next frame
TimeTravel(0.001f, 1);
updatedPosition += GetRandomVector3(-5.0f, 5.0f);
m_AuthoritativeTransform.SetState(updatedPosition, null, null, !interpolate);
TimeTravelAdvanceTick();
var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatch());
Assert.True(success, $"[Timed-Out] Authoritative position {m_AuthoritativeTransform.transform.position} != Non-Authoritative position {m_NonAuthoritativeTransform.transform.position}");
Assert.True(Approximately(updatedPosition, m_NonAuthoritativeTransform.transform.position), $"NonAuthority position {m_NonAuthoritativeTransform.transform.position} does not equal the calculated position {updatedPosition}!");
var updatedRotation = m_AuthoritativeTransform.transform.rotation;
updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
m_AuthoritativeTransform.SetState(null, updatedRotation, null, !interpolate);
// Advance to next frame
TimeTravel(0.001f, 1);
updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
m_AuthoritativeTransform.SetState(null, updatedRotation, null, !interpolate);
TimeTravelAdvanceTick();
success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationsMatch());
Assert.True(success, $"[Timed-Out] Authoritative rotation {m_AuthoritativeTransform.transform.rotation.eulerAngles} != Non-Authoritative rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles}");
Assert.True(Approximately(updatedRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), $"NonAuthority rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles} does not equal the calculated rotation {updatedRotation.eulerAngles}!");
var updatedScale = m_AuthoritativeTransform.transform.localScale;
updatedScale += GetRandomVector3(-2.0f, 2.0f);
m_AuthoritativeTransform.SetState(null, null, updatedScale, !interpolate);
// Advance to next frame
TimeTravel(0.001f, 1);
updatedScale += GetRandomVector3(-2.0f, 2.0f);
m_AuthoritativeTransform.SetState(null, null, updatedScale, !interpolate);
TimeTravelAdvanceTick();
success = WaitForConditionOrTimeOutWithTimeTravel(() => ScaleValuesMatch());
Assert.True(success, $"[Timed-Out] Authoritative rotation {m_AuthoritativeTransform.transform.localScale} != Non-Authoritative rotation {m_NonAuthoritativeTransform.transform.localScale}");
Assert.True(Approximately(updatedScale, m_NonAuthoritativeTransform.transform.localScale), $"NonAuthority scale {m_NonAuthoritativeTransform.transform.localScale} does not equal the calculated scale {updatedScale}!");
// Now test explicitly setting all axis of transform multiple times during a fractional tick period
updatedPosition += GetRandomVector3(-5.0f, 5.0f);
updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
updatedScale += GetRandomVector3(-2.0f, 2.0f);
m_AuthoritativeTransform.SetState(updatedPosition, updatedRotation, updatedScale, !interpolate);
// Advance to next frame
TimeTravel(0.001f, 1);
updatedPosition += GetRandomVector3(-5.0f, 5.0f);
updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
updatedScale += GetRandomVector3(-2.0f, 2.0f);
m_AuthoritativeTransform.SetState(updatedPosition, updatedRotation, updatedScale, !interpolate);
// Advance to next frame
TimeTravel(0.001f, 1);
updatedPosition += GetRandomVector3(-5.0f, 5.0f);
updatedRotation.eulerAngles += GetRandomVector3(-30.0f, 30.0f);
updatedScale += GetRandomVector3(-2.0f, 2.0f);
m_AuthoritativeTransform.SetState(updatedPosition, updatedRotation, updatedScale, !interpolate);
// Advance to next frame
TimeTravel(0.001f, 1);
TimeTravelAdvanceTick();
success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatch() && RotationsMatch() && ScaleValuesMatch());
Assert.True(success, $"[Timed-Out] Authoritative transform != Non-Authoritative transform!");
Assert.True(Approximately(updatedPosition, m_NonAuthoritativeTransform.transform.position), $"NonAuthority position {m_NonAuthoritativeTransform.transform.position} does not equal the calculated position {updatedPosition}!");
Assert.True(Approximately(updatedRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), $"NonAuthority rotation {m_NonAuthoritativeTransform.transform.rotation.eulerAngles} does not equal the calculated rotation {updatedRotation.eulerAngles}!");
Assert.True(Approximately(updatedScale, m_NonAuthoritativeTransform.transform.localScale), $"NonAuthority scale {m_NonAuthoritativeTransform.transform.localScale} does not equal the calculated scale {updatedScale}!");
}
/// <summary>
/// This test validates the <see cref="NetworkTransform.SetState(Vector3?, Quaternion?, Vector3?, bool)"/> method
/// usage for the non-authoritative side. It will either be the owner or the server making/requesting state changes.
/// This validates that:
/// - The owner authoritative mode can still be controlled by the server (i.e. owner authoritative with server authority override capabilities)
/// - The server authoritative mode can still be directed by the client owner.
/// </summary>
/// <remarks>
/// This also tests that the original server authoritative model with client-owner driven NetworkTransforms is preserved.
/// </remarks>
[Test]
public void NonAuthorityOwnerSettingStateTest([Values] Interpolation interpolation)
{
var interpolate = interpolation != Interpolation.EnableInterpolate;
m_AuthoritativeTransform.Interpolate = interpolate;
m_NonAuthoritativeTransform.Interpolate = interpolate;
m_NonAuthoritativeTransform.RotAngleThreshold = m_AuthoritativeTransform.RotAngleThreshold = 0.1f;
// Test one parameter at a time first
var newPosition = new Vector3(125f, 35f, 65f);
var newRotation = Quaternion.Euler(1, 2, 3);
var newScale = new Vector3(2.0f, 2.0f, 2.0f);
m_NonAuthoritativeTransform.SetState(newPosition, null, null, interpolate);
var success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionsMatchesValue(newPosition));
Assert.True(success, $"Timed out waiting for non-authoritative position state request to be applied!");
Assert.True(Approximately(newPosition, m_AuthoritativeTransform.transform.position), "Authoritative position does not match!");
Assert.True(Approximately(newPosition, m_NonAuthoritativeTransform.transform.position), "Non-Authoritative position does not match!");
m_NonAuthoritativeTransform.SetState(null, newRotation, null, interpolate);
success = WaitForConditionOrTimeOutWithTimeTravel(() => RotationMatchesValue(newRotation.eulerAngles));
Assert.True(success, $"Timed out waiting for non-authoritative rotation state request to be applied!");
Assert.True(Approximately(newRotation.eulerAngles, m_AuthoritativeTransform.transform.rotation.eulerAngles), "Authoritative rotation does not match!");
Assert.True(Approximately(newRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), "Non-Authoritative rotation does not match!");
m_NonAuthoritativeTransform.SetState(null, null, newScale, interpolate);
success = WaitForConditionOrTimeOutWithTimeTravel(() => ScaleMatchesValue(newScale));
Assert.True(success, $"Timed out waiting for non-authoritative scale state request to be applied!");
Assert.True(Approximately(newScale, m_AuthoritativeTransform.transform.localScale), "Authoritative scale does not match!");
Assert.True(Approximately(newScale, m_NonAuthoritativeTransform.transform.localScale), "Non-Authoritative scale does not match!");
// Test all parameters at once
newPosition = new Vector3(55f, 95f, -25f);
newRotation = Quaternion.Euler(20, 5, 322);
newScale = new Vector3(0.5f, 0.5f, 0.5f);
m_NonAuthoritativeTransform.SetState(newPosition, newRotation, newScale, interpolate);
success = WaitForConditionOrTimeOutWithTimeTravel(() => PositionRotationScaleMatches(newPosition, newRotation.eulerAngles, newScale));
Assert.True(success, $"Timed out waiting for non-authoritative position, rotation, and scale state request to be applied!");
Assert.True(Approximately(newPosition, m_AuthoritativeTransform.transform.position), "Authoritative position does not match!");
Assert.True(Approximately(newPosition, m_NonAuthoritativeTransform.transform.position), "Non-Authoritative position does not match!");
Assert.True(Approximately(newRotation.eulerAngles, m_AuthoritativeTransform.transform.rotation.eulerAngles), "Authoritative rotation does not match!");
Assert.True(Approximately(newRotation.eulerAngles, m_NonAuthoritativeTransform.transform.rotation.eulerAngles), "Non-Authoritative rotation does not match!");
Assert.True(Approximately(newScale, m_AuthoritativeTransform.transform.localScale), "Authoritative scale does not match!");
Assert.True(Approximately(newScale, m_NonAuthoritativeTransform.transform.localScale), "Non-Authoritative scale does not match!");
}
}
}

11
Tests/Runtime/NetworkTransform/NetworkTransformGeneral.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 7a69eaaf3c4b8464a93520a3514bf5e8
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

485
Tests/Runtime/NetworkTransform/NetworkTransformPacketLossTests.cs Normal file
View File

@@ -0,0 +1,485 @@
// TODO: Rewrite test to use the tools package. Debug simulator not available in UTP 2.X.
#if !UTP_TRANSPORT_2_0_ABOVE
using System.Collections;
using NUnit.Framework;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
/// <summary>
/// Integration tests for NetworkTransform that will test both
/// server and host operating modes and will test both authoritative
/// models for each operating mode when packet loss and latency is
/// present.
/// </summary>
[TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Euler, Precision.Full)]
[TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Euler, Precision.Half)]
[TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Quaternion, Precision.Full)]
[TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.None, Rotation.Quaternion, Precision.Half)]
[TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.QuaternionCompress, Rotation.Quaternion, Precision.Full)]
[TestFixture(HostOrServer.Host, Authority.ServerAuthority, RotationCompression.QuaternionCompress, Rotation.Quaternion, Precision.Half)]
public class NetworkTransformPacketLossTests : NetworkTransformBase
{
private const int k_Latency = 50;
private const int k_PacketLoss = 2;
private Vector3 m_RandomPosition;
private Vector3 m_TeleportOffset = new Vector3(-1024f, 0f, 0f);
private bool m_Teleported;
/// <summary>
/// Constructor
/// </summary>
/// <param name="testWithHost">Determines if we are running as a server or host</param>
/// <param name="authority">Determines if we are using server or owner authority</param>
public NetworkTransformPacketLossTests(HostOrServer testWithHost, Authority authority, RotationCompression rotationCompression, Rotation rotation, Precision precision) :
base(testWithHost, authority, rotationCompression, rotation, precision)
{ }
protected override void OnServerAndClientsCreated()
{
base.OnServerAndClientsCreated();
var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
unityTransport.SetDebugSimulatorParameters(k_Latency, 0, k_PacketLoss);
}
/// <summary>
/// Handles validating all children of the test objects have matching local and global space vaues.
/// </summary>
private IEnumerator AllChildrenLocalTransformValuesMatch(bool useSubChild, ChildrenTransformCheckType checkType)
{
// We don't assert on timeout here because we want to log this information during PostAllChildrenLocalTransformValuesMatch
yield return WaitForConditionOrTimeOut(() => AllInstancesKeptLocalTransformValues(useSubChild));
var success = true;
m_InfoMessage.AppendLine($"[{checkType}][{useSubChild}] Timed out waiting for all children to have the correct local space values:\n");
if (s_GlobalTimeoutHelper.TimedOut)
{
var waitForMs = new WaitForSeconds(0.001f);
// If we timed out, then wait for a full range of ticks to assure all data has been synchronized before declaring this a failed test.
for (int j = 0; j < m_ServerNetworkManager.NetworkConfig.TickRate; j++)
{
var instances = useSubChild ? ChildObjectComponent.SubInstances : ChildObjectComponent.Instances;
success = PostAllChildrenLocalTransformValuesMatch(useSubChild);
yield return waitForMs;
}
}
if (!success)
{
Assert.True(success, m_InfoMessage.ToString());
}
}
/// <summary>
/// Validates that transform values remain the same when a NetworkTransform is
/// parented under another NetworkTransform under all of the possible axial conditions
/// as well as when the parent has a varying scale.
/// </summary>
[UnityTest]
public IEnumerator ParentedNetworkTransformTest([Values] Interpolation interpolation, [Values] bool worldPositionStays, [Values(0.5f, 1.0f, 5.0f)] float scale)
{
ChildObjectComponent.EnableChildLog = m_EnableVerboseDebug;
if (m_EnableVerboseDebug)
{
ChildObjectComponent.TestCount++;
}
// Get the NetworkManager that will have authority in order to spawn with the correct authority
var isServerAuthority = m_Authority == Authority.ServerAuthority;
var authorityNetworkManager = m_ServerNetworkManager;
if (!isServerAuthority)
{
authorityNetworkManager = m_ClientNetworkManagers[0];
}
// Spawn a parent and children
ChildObjectComponent.HasSubChild = true;
var serverSideParent = SpawnObject(m_ParentObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
var serverSideChild = SpawnObject(m_ChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
var serverSideSubChild = SpawnObject(m_SubChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
// Assure all of the child object instances are spawned before proceeding to parenting
yield return WaitForConditionOrTimeOut(AllChildObjectInstancesAreSpawned);
AssertOnTimeout("Timed out waiting for all child instances to be spawned!");
// Get the authority parent and child instances
m_AuthorityParentObject = NetworkTransformTestComponent.AuthorityInstance.NetworkObject;
m_AuthorityChildObject = ChildObjectComponent.AuthorityInstance.NetworkObject;
m_AuthoritySubChildObject = ChildObjectComponent.AuthoritySubInstance.NetworkObject;
// The child NetworkTransform will use world space when world position stays and
// local space when world position does not stay when parenting.
ChildObjectComponent.AuthorityInstance.InLocalSpace = !worldPositionStays;
ChildObjectComponent.AuthorityInstance.UseHalfFloatPrecision = m_Precision == Precision.Half;
ChildObjectComponent.AuthorityInstance.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
ChildObjectComponent.AuthorityInstance.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
ChildObjectComponent.AuthoritySubInstance.InLocalSpace = !worldPositionStays;
ChildObjectComponent.AuthoritySubInstance.UseHalfFloatPrecision = m_Precision == Precision.Half;
ChildObjectComponent.AuthoritySubInstance.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
ChildObjectComponent.AuthoritySubInstance.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
// Set whether we are interpolating or not
m_AuthorityParentNetworkTransform = m_AuthorityParentObject.GetComponent<NetworkTransformTestComponent>();
m_AuthorityParentNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthorityChildNetworkTransform = m_AuthorityChildObject.GetComponent<ChildObjectComponent>();
m_AuthorityChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthoritySubChildNetworkTransform = m_AuthoritySubChildObject.GetComponent<ChildObjectComponent>();
m_AuthoritySubChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
// Apply a scale to the parent object to make sure the scale on the child is properly updated on
// non-authority instances.
var halfScale = scale * 0.5f;
m_AuthorityParentObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
m_AuthorityChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
m_AuthoritySubChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
// Allow one tick for authority to update these changes
yield return WaitForConditionOrTimeOut(PositionRotationScaleMatches);
AssertOnTimeout("All transform values did not match prior to parenting!");
// Parent the child under the parent with the current world position stays setting
Assert.True(serverSideChild.TrySetParent(serverSideParent.transform, worldPositionStays), "[Server-Side Child] Failed to set child's parent!");
// Parent the sub-child under the child with the current world position stays setting
Assert.True(serverSideSubChild.TrySetParent(serverSideChild.transform, worldPositionStays), "[Server-Side SubChild] Failed to set sub-child's parent!");
// This waits for all child instances to be parented
yield return WaitForConditionOrTimeOut(AllChildObjectInstancesHaveChild);
AssertOnTimeout("Timed out waiting for all instances to have parented a child!");
var latencyWait = new WaitForSeconds(k_Latency * 0.003f);
// Wait for at least 3x designated latency period
yield return latencyWait;
// This validates each child instance has preserved their local space values
yield return AllChildrenLocalTransformValuesMatch(false, ChildrenTransformCheckType.Connected_Clients);
// This validates each sub-child instance has preserved their local space values
yield return AllChildrenLocalTransformValuesMatch(true, ChildrenTransformCheckType.Connected_Clients);
// Verify that a late joining client will synchronize to the parented NetworkObjects properly
yield return CreateAndStartNewClient();
// Assure all of the child object instances are spawned (basically for the newly connected client)
yield return WaitForConditionOrTimeOut(AllChildObjectInstancesAreSpawned);
AssertOnTimeout("Timed out waiting for all child instances to be spawned!");
// This waits for all child instances to be parented
yield return WaitForConditionOrTimeOut(AllChildObjectInstancesHaveChild);
AssertOnTimeout("Timed out waiting for all instances to have parented a child!");
// Wait for at least 3x designated latency period
yield return latencyWait;
// This validates each child instance has preserved their local space values
yield return AllChildrenLocalTransformValuesMatch(false, ChildrenTransformCheckType.Late_Join_Client);
// This validates each sub-child instance has preserved their local space values
yield return AllChildrenLocalTransformValuesMatch(true, ChildrenTransformCheckType.Late_Join_Client);
}
/// <summary>
/// This validates that multiple changes can occur within the same tick or over
/// several ticks while still keeping non-authoritative instances synchronized.
/// </summary>
/// <remarks>
/// When testing < 3 axis: Interpolation is disabled and only 3 delta updates are applied per unique test
/// When testing 3 axis: Interpolation is enabled, sometimes an axis is intentionally excluded during a
/// delta update, and it runs through 8 delta updates per unique test.
/// </remarks>
[UnityTest]
public IEnumerator NetworkTransformMultipleChangesOverTime([Values] TransformSpace testLocalTransform, [Values] Axis axis)
{
yield return s_DefaultWaitForTick;
// Just test for OverrideState.Update (they are already being tested for functionality in normal NetworkTransformTests)
var overideState = OverrideState.Update;
var tickRelativeTime = new WaitForSeconds(1.0f / m_ServerNetworkManager.NetworkConfig.TickRate);
m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
bool axisX = axis == Axis.X || axis == Axis.XY || axis == Axis.XZ || axis == Axis.XYZ;
bool axisY = axis == Axis.Y || axis == Axis.XY || axis == Axis.YZ || axis == Axis.XYZ;
bool axisZ = axis == Axis.Z || axis == Axis.XZ || axis == Axis.YZ || axis == Axis.XYZ;
var axisCount = axisX ? 1 : 0;
axisCount += axisY ? 1 : 0;
axisCount += axisZ ? 1 : 0;
m_AuthoritativeTransform.StatePushed = false;
// Enable interpolation when all 3 axis are selected to make sure we are synchronizing properly
// when interpolation is enabled.
m_AuthoritativeTransform.Interpolate = axisCount == 3 ? true : false;
m_CurrentAxis = axis;
// Authority dictates what is synchronized and what the precision is going to be
// so we only need to set this on the authoritative side.
m_AuthoritativeTransform.UseHalfFloatPrecision = m_Precision == Precision.Half;
m_AuthoritativeTransform.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
m_AuthoritativeTransform.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
m_AuthoritativeTransform.SyncPositionX = axisX;
m_AuthoritativeTransform.SyncPositionY = axisY;
m_AuthoritativeTransform.SyncPositionZ = axisZ;
if (!m_AuthoritativeTransform.UseQuaternionSynchronization)
{
m_AuthoritativeTransform.SyncRotAngleX = axisX;
m_AuthoritativeTransform.SyncRotAngleY = axisY;
m_AuthoritativeTransform.SyncRotAngleZ = axisZ;
}
else
{
// This is not required for usage (setting the value should not matter when quaternion synchronization is enabled)
// but is required for this test so we don't get a failure on an axis that is marked to not be synchronized when
// validating the authority's values on non-authority instances.
m_AuthoritativeTransform.SyncRotAngleX = true;
m_AuthoritativeTransform.SyncRotAngleY = true;
m_AuthoritativeTransform.SyncRotAngleZ = true;
}
m_AuthoritativeTransform.SyncScaleX = axisX;
m_AuthoritativeTransform.SyncScaleY = axisY;
m_AuthoritativeTransform.SyncScaleZ = axisZ;
var positionStart = GetRandomVector3(0.25f, 1.75f);
var rotationStart = GetRandomVector3(1f, 15f);
var scaleStart = GetRandomVector3(0.25f, 2.0f);
var position = positionStart;
var rotation = rotationStart;
var scale = scaleStart;
var success = false;
// Wait for the deltas to be pushed
yield return WaitForConditionOrTimeOut(() => m_AuthoritativeTransform.StatePushed);
// Just in case we drop the first few state updates
if (s_GlobalTimeoutHelper.TimedOut)
{
// Set the local state to not reflect the authority state's local space settings
// to trigger the state update (it would eventually get there, but this is an integration test)
var state = m_AuthoritativeTransform.LocalAuthoritativeNetworkState;
state.InLocalSpace = !m_AuthoritativeTransform.InLocalSpace;
m_AuthoritativeTransform.LocalAuthoritativeNetworkState = state;
// Wait for the deltas to be pushed
yield return WaitForConditionOrTimeOut(() => m_AuthoritativeTransform.StatePushed);
}
AssertOnTimeout("State was never pushed!");
// Allow the precision settings to propagate first as changing precision
// causes a teleport event to occur
yield return s_DefaultWaitForTick;
yield return s_DefaultWaitForTick;
yield return s_DefaultWaitForTick;
yield return s_DefaultWaitForTick;
yield return s_DefaultWaitForTick;
var iterations = axisCount == 3 ? k_PositionRotationScaleIterations3Axis : k_PositionRotationScaleIterations;
// Move and rotate within the same tick, validate the non-authoritative instance updates
// to each set of changes. Repeat several times.
for (int i = 0; i < iterations; i++)
{
// Always reset this per delta update pass
m_AxisExcluded = false;
var deltaPositionDelta = GetRandomVector3(-1.5f, 1.5f);
var deltaRotationDelta = GetRandomVector3(-3.5f, 3.5f);
var deltaScaleDelta = GetRandomVector3(-0.5f, 0.5f);
m_NonAuthoritativeTransform.StateUpdated = false;
m_AuthoritativeTransform.StatePushed = false;
// With two or more axis, excluding one of them while chaging another will validate that
// full precision updates are maintaining their target state value(s) to interpolate towards
if (axisCount == 3)
{
position += RandomlyExcludeAxis(deltaPositionDelta);
rotation += RandomlyExcludeAxis(deltaRotationDelta);
scale += RandomlyExcludeAxis(deltaScaleDelta);
}
else
{
position += deltaPositionDelta;
rotation += deltaRotationDelta;
scale += deltaScaleDelta;
}
// Apply delta between ticks
MoveRotateAndScaleAuthority(position, rotation, scale, overideState);
// Wait for the deltas to be pushed (unlike the original test, we don't wait for state to be updated as that could be dropped here)
yield return WaitForConditionOrTimeOut(() => m_AuthoritativeTransform.StatePushed);
AssertOnTimeout($"[Non-Interpolate {i}] Timed out waiting for state to be pushed ({m_AuthoritativeTransform.StatePushed})!");
// For 3 axis, we will skip validating that the non-authority interpolates to its target point at least once.
// This will validate that non-authoritative updates are maintaining their target state axis values if only 2
// of the axis are being updated to assure interpolation maintains the targeted axial value per axis.
// For 2 and 1 axis tests we always validate per delta update
if (m_AxisExcluded || axisCount < 3)
{
// Wait for deltas to synchronize on non-authoritative side
yield return WaitForConditionOrTimeOut(PositionRotationScaleMatches);
// Provide additional debug info about what failed (if it fails)
if (s_GlobalTimeoutHelper.TimedOut)
{
Debug.Log("[Synch Issue Start - 1]");
// If we timed out, then wait for a full range of ticks (plus 1) to assure it sent synchronization data.
for (int j = 0; j < m_ServerNetworkManager.NetworkConfig.TickRate * 2; j++)
{
success = PositionRotationScaleMatches();
if (success)
{
// If we matched, then something was dropped and recovered when synchronized
break;
}
yield return s_DefaultWaitForTick;
}
// Only if we still didn't match
if (!success)
{
m_EnableVerboseDebug = true;
success = PositionRotationScaleMatches();
m_EnableVerboseDebug = false;
Debug.Log("[Synch Issue END - 1]");
AssertOnTimeout($"[Non-Interpolate {i}] Timed out waiting for non-authority to match authority's position or rotation");
}
}
}
}
if (axisCount == 3)
{
// As a final test, wait for deltas to synchronize on non-authoritative side to assure it interpolates to the correct values
yield return WaitForConditionOrTimeOut(PositionRotationScaleMatches);
// Provide additional debug info about what failed (if it fails)
if (s_GlobalTimeoutHelper.TimedOut)
{
Debug.Log("[Synch Issue Start - 2]");
// If we timed out, then wait for a full range of ticks (plus 1) to assure it sent synchronization data.
for (int j = 0; j < m_ServerNetworkManager.NetworkConfig.TickRate * 2; j++)
{
success = PositionRotationScaleMatches();
if (success)
{
// If we matched, then something was dropped and recovered when synchronized
break;
}
yield return s_DefaultWaitForTick;
}
// Only if we still didn't match
if (!success)
{
m_EnableVerboseDebug = true;
PositionRotationScaleMatches();
m_EnableVerboseDebug = false;
Debug.Log("[Synch Issue END - 2]");
AssertOnTimeout("Timed out waiting for non-authority to match authority's position or rotation");
}
}
}
}
/// <summary>
/// Tests changing all axial values one at a time with packet loss
/// These tests are performed:
/// - While in local space and world space
/// - While interpolation is enabled and disabled
/// </summary>
[UnityTest]
public IEnumerator TestAuthoritativeTransformChangeOneAtATime([Values] TransformSpace testLocalTransform, [Values] Interpolation interpolation)
{
// Just test for OverrideState.Update (they are already being tested for functionality in normal NetworkTransformTests)
m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
m_AuthoritativeTransform.UseQuaternionCompression = m_RotationCompression == RotationCompression.QuaternionCompress;
m_AuthoritativeTransform.UseHalfFloatPrecision = m_Precision == Precision.Half;
m_AuthoritativeTransform.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
// test position
var authPlayerTransform = m_AuthoritativeTransform.transform;
Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "server side pos should be zero at first"); // sanity check
m_AuthoritativeTransform.transform.position = GetRandomVector3(2f, 30f);
yield return WaitForConditionOrTimeOut(() => PositionsMatch());
AssertOnTimeout($"Timed out waiting for positions to match {m_AuthoritativeTransform.transform.position} | {m_NonAuthoritativeTransform.transform.position}");
// test rotation
Assert.AreEqual(Quaternion.identity, m_NonAuthoritativeTransform.transform.rotation, "wrong initial value for rotation"); // sanity check
m_AuthoritativeTransform.transform.rotation = Quaternion.Euler(GetRandomVector3(5, 60)); // using euler angles instead of quaternions directly to really see issues users might encounter
// Make sure the values match
yield return WaitForConditionOrTimeOut(() => RotationsMatch());
AssertOnTimeout($"Timed out waiting for rotations to match");
m_AuthoritativeTransform.StatePushed = false;
m_AuthoritativeTransform.transform.localScale = GetRandomVector3(1, 6);
// Make sure the scale values match
yield return WaitForConditionOrTimeOut(() => ScaleValuesMatch());
AssertOnTimeout($"Timed out waiting for scale values to match");
}
[UnityTest]
public IEnumerator TestSameFrameDeltaStateAndTeleport([Values] TransformSpace testLocalTransform, [Values] Interpolation interpolation)
{
m_AuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_NonAuthoritativeTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthoritativeTransform.InLocalSpace = testLocalTransform == TransformSpace.Local;
// test position
var authPlayerTransform = m_AuthoritativeTransform.transform;
Assert.AreEqual(Vector3.zero, m_NonAuthoritativeTransform.transform.position, "server side pos should be zero at first"); // sanity check
m_AuthoritativeTransform.AuthorityPushedTransformState += OnAuthorityPushedTransformState;
m_RandomPosition = GetRandomVector3(2f, 30f);
m_AuthoritativeTransform.transform.position = m_RandomPosition;
m_Teleported = false;
yield return WaitForConditionOrTimeOut(() => m_Teleported);
AssertOnTimeout($"Timed out waiting for random position to be pushed!");
yield return WaitForConditionOrTimeOut(() => PositionsMatch());
AssertOnTimeout($"Timed out waiting for positions to match {m_AuthoritativeTransform.transform.position} | {m_NonAuthoritativeTransform.transform.position}");
var authPosition = m_AuthoritativeTransform.GetSpaceRelativePosition();
var nonAuthPosition = m_NonAuthoritativeTransform.GetSpaceRelativePosition();
var finalPosition = m_TeleportOffset + m_RandomPosition;
Assert.True(Approximately(authPosition, finalPosition), $"Authority did not set its position ({authPosition}) to the teleport position ({finalPosition})!");
Assert.True(Approximately(nonAuthPosition, finalPosition), $"NonAuthority did not set its position ({nonAuthPosition}) to the teleport position ({finalPosition})!");
}
/// <summary>
/// For the TestSameFrameDeltaStateAndTeleport test, we want to teleport on the same frame that we had a delta state update when
/// using unreliable delta state updates (i.e. we want the unreliable packet to be sent first and then the teleport to be sent on
/// the next tick. Store off both states when invoked
/// </summary>
/// <param name="networkTransformState"></param>
private void OnAuthorityPushedTransformState(ref NetworkTransform.NetworkTransformState networkTransformState)
{
// Match the first position update
if (Approximately(m_RandomPosition, networkTransformState.GetPosition()))
{
// Teleport to the m_RandomPosition plus the
m_AuthoritativeTransform.SetState(m_TeleportOffset + m_RandomPosition, null, null, false);
m_AuthoritativeTransform.AuthorityPushedTransformState -= OnAuthorityPushedTransformState;
m_Teleported = true;
}
}
}
}
#endif

3
Tests/Runtime/NetworkTransform/NetworkTransformPacketLossTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e0f584e8eb891d5459373e96e54fe821
timeCreated: 1620872927

7
Tests/Runtime/NetworkTransform/NetworkTransformStateTests.cs
View File

@@ -230,6 +230,11 @@ namespace Unity.Netcode.RuntimeTests
var gameObject = new GameObject($"Test-{nameof(NetworkTransformStateTests)}.{nameof(TestSyncAxes)}");
var networkObject = gameObject.AddComponent<NetworkObject>();
var networkTransform = gameObject.AddComponent<NetworkTransform>();
var manager = new GameObject($"Test-{nameof(NetworkManager)}.{nameof(TestSyncAxes)}");
var networkManager = manager.AddComponent<NetworkManager>();
networkObject.NetworkManagerOwner = networkManager;
networkTransform.enabled = false; // do not tick `FixedUpdate()` or `Update()`
var initialPosition = Vector3.zero;
@@ -269,6 +274,7 @@ namespace Unity.Netcode.RuntimeTests
if (syncPosX || syncPosY || syncPosZ || syncRotX || syncRotY || syncRotZ || syncScaX || syncScaY || syncScaZ)
{
Assert.NotNull(networkTransform.NetworkManager, "NetworkManager is NULL!");
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
}
}
@@ -714,6 +720,7 @@ namespace Unity.Netcode.RuntimeTests
}
Object.DestroyImmediate(gameObject);
Object.DestroyImmediate(manager);
}

1148
Tests/Runtime/NetworkTransform/NetworkTransformTests.cs
View File

File diff suppressed because it is too large Load Diff

67
Tests/Runtime/NetworkVariableTests.cs
View File

@@ -2769,4 +2769,71 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsFalse(s_GlobalTimeoutHelper.TimedOut, nameof(CheckTestObjectComponentValuesOnAll));
}
}
public class NetvarDespawnShutdown : NetworkBehaviour
{
private NetworkVariable<int> m_IntNetworkVariable = new NetworkVariable<int>();
private NetworkList<int> m_IntList;
private void Awake()
{
m_IntList = new NetworkList<int>();
}
public override void OnNetworkDespawn()
{
if (IsServer)
{
m_IntNetworkVariable.Value = 5;
for (int i = 0; i < 10; i++)
{
m_IntList.Add(i);
}
}
base.OnNetworkDespawn();
}
}
/// <summary>
/// Validates that setting values for NetworkVariable or NetworkList during the
/// OnNetworkDespawn method will not cause an exception to occur.
/// </summary>
public class NetworkVariableModifyOnNetworkDespawn : NetcodeIntegrationTest
{
protected override int NumberOfClients => 1;
private GameObject m_TestPrefab;
protected override void OnServerAndClientsCreated()
{
m_TestPrefab = CreateNetworkObjectPrefab("NetVarDespawn");
m_TestPrefab.AddComponent<NetvarDespawnShutdown>();
base.OnServerAndClientsCreated();
}
private bool OnClientSpawnedTestPrefab(ulong networkObjectId)
{
var clientId = m_ClientNetworkManagers[0].LocalClientId;
if (!s_GlobalNetworkObjects.ContainsKey(clientId))
{
return false;
}
if (!s_GlobalNetworkObjects[clientId].ContainsKey(networkObjectId))
{
return false;
}
return true;
}
[UnityTest]
public IEnumerator ModifyNetworkVariableOrListOnNetworkDespawn()
{
var instance = SpawnObject(m_TestPrefab, m_ServerNetworkManager);
yield return WaitForConditionOrTimeOut(() => OnClientSpawnedTestPrefab(instance.GetComponent<NetworkObject>().NetworkObjectId));
m_ServerNetworkManager.Shutdown();
// As long as no excetptions occur, the test passes.
}
}
}

185
Tests/Runtime/PeerDisconnectCallbackTests.cs Normal file
View File

@@ -0,0 +1,185 @@
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
{
/// <summary>
/// Validates the client disconnection process.
/// This assures that:
/// - When a client disconnects from the server that the server:
/// -- Detects the client disconnected.
/// -- Cleans up the transport to NGO client (and vice versa) mappings.
/// - When a server disconnects a client that:
/// -- The client detects this disconnection.
/// -- The server cleans up the transport to NGO client (and vice versa) mappings.
/// - When <see cref="DisconnectTests.OwnerPersistence.DestroyWithOwner"/> the server-side player object is destroyed
/// - When <see cref="DisconnectTests.OwnerPersistence.DontDestroyWithOwner"/> the server-side player object ownership is transferred back to the server
/// </summary>
[TestFixture(HostOrServer.Server)]
[TestFixture(HostOrServer.Host)]
public class PeerDisconnectCallbackTests : NetcodeIntegrationTest
{
public enum ClientDisconnectType
{
ServerDisconnectsClient,
ClientDisconnectsFromServer
}
protected override int NumberOfClients => 3;
private int m_ClientDisconnectCount;
private int m_PeerDisconnectCount;
public PeerDisconnectCallbackTests(HostOrServer hostOrServer)
: base(hostOrServer)
{
}
protected override void OnServerAndClientsCreated()
{
// Adjusting client and server timeout periods to reduce test time
// Get the tick frequency in milliseconds and triple it for the heartbeat timeout
var heartBeatTimeout = (int)(300 * (1.0f / m_ServerNetworkManager.NetworkConfig.TickRate));
var unityTransport = m_ServerNetworkManager.NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
if (unityTransport != null)
{
unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
}
unityTransport = m_ClientNetworkManagers[0].NetworkConfig.NetworkTransport as Transports.UTP.UnityTransport;
if (unityTransport != null)
{
unityTransport.HeartbeatTimeoutMS = heartBeatTimeout;
}
base.OnServerAndClientsCreated();
}
protected override IEnumerator OnSetup()
{
m_ClientDisconnectCount = 0;
m_PeerDisconnectCount = 0;
return base.OnSetup();
}
private void OnConnectionEventCallback(NetworkManager networkManager, ConnectionEventData data)
{
switch (data.EventType)
{
case ConnectionEvent.ClientDisconnected:
Assert.IsFalse(data.PeerClientIds.IsCreated);
++m_ClientDisconnectCount;
break;
case ConnectionEvent.PeerDisconnected:
Assert.IsFalse(data.PeerClientIds.IsCreated);
++m_PeerDisconnectCount;
break;
}
}
[UnityTest]
public IEnumerator TestPeerDisconnectCallback([Values] ClientDisconnectType clientDisconnectType, [Values(1ul, 2ul, 3ul)] ulong disconnectedClient)
{
foreach (var client in m_ClientNetworkManagers)
{
client.OnConnectionEvent += OnConnectionEventCallback;
if (m_UseHost)
{
Assert.IsTrue(client.ConnectedClientsIds.Contains(0ul));
}
Assert.IsTrue(client.ConnectedClientsIds.Contains(1ul));
Assert.IsTrue(client.ConnectedClientsIds.Contains(2ul));
Assert.IsTrue(client.ConnectedClientsIds.Contains(3ul));
Assert.AreEqual(client.ServerIsHost, m_UseHost);
}
m_ServerNetworkManager.OnConnectionEvent += OnConnectionEventCallback;
if (m_UseHost)
{
Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(0ul));
}
Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(1ul));
Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(2ul));
Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(3ul));
Assert.AreEqual(m_ServerNetworkManager.ServerIsHost, m_UseHost);
// Set up a WaitForMessageReceived hook.
// In some cases the message will be received during StopOneClient, but it is not guaranteed
// So we start the listener before we call Stop so it will be noticed regardless of whether it happens
// during StopOneClient or whether we have to wait for it
var messageHookEntriesForSpawn = new List<MessageHookEntry>();
foreach (var clientNetworkManager in m_ClientNetworkManagers.Where(c => c.LocalClientId != disconnectedClient))
{
var messageHook = new MessageHookEntry(clientNetworkManager);
messageHook.AssignMessageType<ClientDisconnectedMessage>();
messageHookEntriesForSpawn.Add(messageHook);
}
// Used to determine if all clients received the CreateObjectMessage
var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
if (clientDisconnectType == ClientDisconnectType.ServerDisconnectsClient)
{
m_ServerNetworkManager.DisconnectClient(disconnectedClient);
}
else
{
yield return StopOneClient(m_ClientNetworkManagers[disconnectedClient - 1]);
}
yield return WaitForConditionOrTimeOut(hooks);
Assert.False(s_GlobalTimeoutHelper.TimedOut);
foreach (var client in m_ClientNetworkManagers)
{
if (!client.IsConnectedClient)
{
Assert.IsEmpty(client.ConnectedClientsIds);
continue;
}
if (m_UseHost)
{
Assert.IsTrue(client.ConnectedClientsIds.Contains(0ul));
}
for (var i = 1ul; i < 3ul; ++i)
{
if (i == disconnectedClient)
{
Assert.IsFalse(client.ConnectedClientsIds.Contains(i));
}
else
{
Assert.IsTrue(client.ConnectedClientsIds.Contains(i));
}
}
}
if (m_UseHost)
{
Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(0ul));
}
for (var i = 1ul; i < 3ul; ++i)
{
if (i == disconnectedClient)
{
Assert.IsFalse(m_ServerNetworkManager.ConnectedClientsIds.Contains(i));
}
else
{
Assert.IsTrue(m_ServerNetworkManager.ConnectedClientsIds.Contains(i));
}
}
// If disconnected, the server and the client that disconnected will be notified
Assert.AreEqual(2, m_ClientDisconnectCount);
// Host receives peer disconnect, dedicated server does not
Assert.AreEqual(m_UseHost ? 3 : 2, m_PeerDisconnectCount);
}
}
}

3
Tests/Runtime/PeerDisconnectCallbackTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 283ae7cc9a0641c8b49dacad79242287
timeCreated: 1699978638

1
Tests/Runtime/RpcTests.cs
View File

@@ -62,7 +62,6 @@ namespace Unity.Netcode.RuntimeTests
}
#endif
[ClientRpc]
public void MyClientRpc()
{

25
Tests/Runtime/StopStartRuntimeTests.cs
View File

@@ -1,7 +1,6 @@
using System.Collections;
using NUnit.Framework;
using Unity.Netcode.TestHelpers.Runtime;
using UnityEngine;
using UnityEngine.TestTools;
namespace Unity.Netcode.RuntimeTests
@@ -16,15 +15,19 @@ namespace Unity.Netcode.RuntimeTests
base.OnOneTimeSetup();
}
private bool m_ServerStopped;
[UnityTest]
public IEnumerator WhenShuttingDownAndRestarting_SDKRestartsSuccessfullyAndStaysRunning()
{
// shutdown the server
m_ServerNetworkManager.OnServerStopped += OnServerStopped;
m_ServerNetworkManager.Shutdown();
// wait 1 frame because shutdowns are delayed
var nextFrameNumber = Time.frameCount + 1;
yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
// wait until the OnServerStopped is invoked
m_ServerStopped = false;
yield return WaitForConditionOrTimeOut(() => m_ServerStopped);
AssertOnTimeout("Timed out waiting for the server to stop!");
// Verify the shutdown occurred
Assert.IsFalse(m_ServerNetworkManager.IsServer);
@@ -45,15 +48,23 @@ namespace Unity.Netcode.RuntimeTests
Assert.IsTrue(m_ServerNetworkManager.IsListening);
}
private void OnServerStopped(bool obj)
{
m_ServerNetworkManager.OnServerStopped -= OnServerStopped;
m_ServerStopped = true;
}
[UnityTest]
public IEnumerator WhenShuttingDownTwiceAndRestarting_SDKRestartsSuccessfullyAndStaysRunning()
{
// shutdown the server
m_ServerNetworkManager.OnServerStopped += OnServerStopped;
m_ServerNetworkManager.Shutdown();
// wait 1 frame because shutdowns are delayed
var nextFrameNumber = Time.frameCount + 1;
yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
// wait until the OnServerStopped is invoked
m_ServerStopped = false;
yield return WaitForConditionOrTimeOut(() => m_ServerStopped);
AssertOnTimeout("Timed out waiting for the server to stop!");
// Verify the shutdown occurred
Assert.IsFalse(m_ServerNetworkManager.IsServer);

24
Tests/Runtime/Transports/UnityTransportTests.cs
View File

@@ -192,19 +192,31 @@ namespace Unity.Netcode.RuntimeTests
yield return WaitForNetworkEvent(NetworkEvent.Connect, m_Client1Events);
var data1 = new ArraySegment<byte>(new byte[] { 11 });
m_Client1.Send(m_Client1.ServerClientId, data1, delivery);
var data1 = new byte[10];
data1[0] = 11;
m_Client1.Send(m_Client1.ServerClientId, new ArraySegment<byte>(data1), delivery);
var data2 = new ArraySegment<byte>(new byte[] { 22 });
m_Client1.Send(m_Client1.ServerClientId, data2, delivery);
var data2 = new byte[3000];
data2[0] = 22;
m_Client1.Send(m_Client1.ServerClientId, new ArraySegment<byte>(data2), delivery);
var data3 = new byte[10];
data3[0] = 33;
m_Client1.Send(m_Client1.ServerClientId, new ArraySegment<byte>(data3), delivery);
yield return WaitForNetworkEvent(NetworkEvent.Data, m_ServerEvents);
Assert.AreEqual(3, m_ServerEvents.Count);
Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[2].Type);
Assert.AreEqual(4, m_ServerEvents.Count);
Assert.AreEqual(NetworkEvent.Data, m_ServerEvents[3].Type);
Assert.AreEqual(11, m_ServerEvents[1].Data.First());
Assert.AreEqual(10, m_ServerEvents[1].Data.Count);
Assert.AreEqual(22, m_ServerEvents[2].Data.First());
Assert.AreEqual(3000, m_ServerEvents[2].Data.Count);
Assert.AreEqual(33, m_ServerEvents[3].Data.First());
Assert.AreEqual(10, m_ServerEvents[3].Data.Count);
yield return null;
}

1917
Tests/Runtime/UniversalRpcTests.cs Normal file
View File

File diff suppressed because it is too large Load Diff

3
Tests/Runtime/UniversalRpcTests.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: af2b96a4f4d34fa798385b487fc5c97d
timeCreated: 1698158457

12
package.json
View File

File diff suppressed because one or more lines are too long